github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-08-19 13:09:49 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

revert !

Browse source
This commit is contained in:
Edznux 2018-10-28 17:42:25 +01:00
commit 2fe8999b2d
54 changed files with 473 additions and 542 deletions
Download patch file Download diff file Expand all files Collapse all files

115
core/core_test.go
View file

@ -2,13 +2,53 @@ package core
import ( import (
"bytes" "bytes"
"github.com/evilsocket/islazy/fs"
"github.com/evilsocket/islazy/str"
"io" "io"
"os" "os"
"os/user"
"path/filepath"
"testing" "testing"
) )
func TestCoreTrim(t *testing.T) {
var units = []struct {
from string
to string
}{
{"\t ", ""},
{" ", ""},
{" hello world", "hello world"},
{"hello world ", "hello world"},
{" hello world\t", "hello world"},
}
for _, u := range units {
got := Trim(u.from)
if got != u.to {
t.Fatalf("expected '%s', got '%s'", u.to, got)
}
}
}
func TestCoreTrimRight(t *testing.T) {
var units = []struct {
from string
to string
}{
{"\t ", ""},
{" ", ""},
{" hello world", " hello world"},
{"hello world ", "hello world"},
{" hello world\t", " hello world"},
}
for _, u := range units {
got := TrimRight(u.from)
if got != u.to {
t.Fatalf("expected '%s', got '%s'", u.to, got)
}
}
}
func hasInt(a []int, v int) bool { func hasInt(a []int, v int) bool {
for _, n := range a { for _, n := range a {
if n == v { if n == v {
@ -92,6 +132,30 @@ func sameStrings(a []string, b []string) bool {
return true return true
} }
func TestCoreSepSplitAndCommaSplit(t *testing.T) {
var units = []struct {
from string
to []string
}{
{"foo", []string{"foo"}},
{"foo#bar", []string{"foo#bar"}},
{"foo,bar", []string{"foo", "bar"}},
{"foo,bar,", []string{"foo", "bar"}},
{"foo,bar,", []string{"foo", "bar"}},
{"foo,,bar,", []string{"foo", "bar"}},
{"foo,,bar,,,,", []string{"foo", "bar"}},
{"foo,bar@wut,.ok", []string{"foo", "bar@wut", ".ok"}},
}
for _, u := range units {
if got := SepSplit(u.from, ","); !sameStrings(got, u.to) {
t.Fatalf("expected '%v', got '%v'", u.to, got)
} else if got = CommaSplit(u.from); !sameStrings(got, u.to) {
t.Fatalf("expected '%v', got '%v'", u.to, got)
}
}
}
func TestCoreExec(t *testing.T) { func TestCoreExec(t *testing.T) {
var units = []struct { var units = []struct {
exec string exec string
@ -118,20 +182,16 @@ func TestCoreExec(t *testing.T) {
io.Copy(&buf, r) io.Copy(&buf, r)
os.Stdout = oldStdout os.Stdout = oldStdout
gotStdout := str.Trim(buf.String()) gotStdout := Trim(buf.String())
if gotOut != u.out { if gotOut != u.out {
t.Fatalf("expected output '%s', got '%s'", u.out, gotOut) t.Fatalf("expected output '%s', got '%s'", u.out, gotOut)
} } else if u.err == "" && gotErr != nil {
if u.err == "" && gotErr != nil {
t.Fatalf("expected no error, got '%s'", gotErr) t.Fatalf("expected no error, got '%s'", gotErr)
} } else if u.err != "" && gotErr == nil {
if u.err != "" && gotErr == nil {
t.Fatalf("expected error '%s', got none", u.err) t.Fatalf("expected error '%s', got none", u.err)
} } else if u.err != "" && gotErr != nil && gotErr.Error() != u.err {
if u.err != "" && gotErr != nil && gotErr.Error() != u.err {
t.Fatalf("expected error '%s', got '%s'", u.err, gotErr) t.Fatalf("expected error '%s', got '%s'", u.err, gotErr)
} } else if gotStdout != "" {
if gotStdout != "" {
t.Fatalf("expected empty stdout, got '%s'", gotStdout) t.Fatalf("expected empty stdout, got '%s'", gotStdout)
} }
} }
@ -148,7 +208,7 @@ func TestCoreExec(t *testing.T) {
io.Copy(&buf, r) io.Copy(&buf, r)
os.Stdout = oldStdout os.Stdout = oldStdout
gotStdout := str.Trim(buf.String()) gotStdout := Trim(buf.String())
if gotOut != u.out { if gotOut != u.out {
t.Fatalf("expected output '%s', got '%s'", u.out, gotOut) t.Fatalf("expected output '%s', got '%s'", u.out, gotOut)
} else if u.err == "" && gotErr != nil { } else if u.err == "" && gotErr != nil {
@ -176,9 +236,38 @@ func TestCoreExists(t *testing.T) {
} }
for _, u := range units { for _, u := range units {
got := fs.Exists(u.what) got := Exists(u.what)
if got != u.exists { if got != u.exists {
t.Fatalf("expected '%v', got '%v'", u.exists, got) t.Fatalf("expected '%v', got '%v'", u.exists, got)
} }
} }
} }
func TestCoreExpandPath(t *testing.T) {
base, _ := filepath.Abs(".")
usr, _ := user.Current()
var units = []struct {
from string
to string
err string
}{
{"", "", ""},
{"/lulz", "/lulz", ""},
{".", base, ""},
{"~", usr.HomeDir, ""},
}
for _, u := range units {
gotPath, gotErr := ExpandPath(u.from)
if gotPath != u.to {
t.Fatalf("expected path '%s', got '%s'", u.to, gotPath)
} else if u.err == "" && gotErr != nil {
t.Fatalf("expected no error, got '%v'", gotErr)
} else if u.err != "" && gotErr == nil {
t.Fatalf("expected error '%s', got none", u.err)
} else if u.err != "" && gotErr != nil && gotErr.Error() != u.err {
t.Fatalf("expected error '%s', got '%s'", u.err, gotErr.Error())
}
}
}

15
firewall/firewall_darwin.go
View file

@ -43,12 +43,12 @@ func Make(iface *network.Endpoint) FirewallManager {
func (f PfFirewall) sysCtlRead(param string) (string, error) { func (f PfFirewall) sysCtlRead(param string) (string, error) {
if out, err := core.ExecSilent("sysctl", []string{param}); err != nil { if out, err := core.ExecSilent("sysctl", []string{param}); err != nil {
return "", err return "", err
} } else if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param {
if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param {
return m[2], nil return m[2], nil
} } else {
return "", fmt.Errorf("Unexpected sysctl output: %s", out) return "", fmt.Errorf("Unexpected sysctl output: %s", out)
} }
}
func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) { func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) {
args := []string{"-w", fmt.Sprintf("%s=%s", param, value)} args := []string{"-w", fmt.Sprintf("%s=%s", param, value)}
@ -60,12 +60,12 @@ func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) {
// make sure we actually wrote the value // make sure we actually wrote the value
if out, err := f.sysCtlRead(param); err != nil { if out, err := f.sysCtlRead(param); err != nil {
return "", err return "", err
} } else if out != value {
if out != value {
return "", fmt.Errorf("Expected value for '%s' is %s, found %s", param, value, out) return "", fmt.Errorf("Expected value for '%s' is %s, found %s", param, value, out)
} } else {
return out, nil return out, nil
} }
}
func (f PfFirewall) IsForwardingEnabled() bool { func (f PfFirewall) IsForwardingEnabled() bool {
out, err := f.sysCtlRead("net.inet.ip.forwarding") out, err := f.sysCtlRead("net.inet.ip.forwarding")
@ -87,9 +87,10 @@ func (f PfFirewall) enableParam(param string, enabled bool) error {
if _, err := f.sysCtlWrite(param, value); err != nil { if _, err := f.sysCtlWrite(param, value); err != nil {
return err return err
} } else {
return nil return nil
} }
}
func (f PfFirewall) EnableForwarding(enabled bool) error { func (f PfFirewall) EnableForwarding(enabled bool) error {
return f.enableParam("net.inet.ip.forwarding", enabled) return f.enableParam("net.inet.ip.forwarding", enabled)

9
firewall/firewall_linux.go
View file

@ -53,12 +53,12 @@ func (f LinuxFirewall) enableFeature(filename string, enable bool) error {
func (f LinuxFirewall) IsForwardingEnabled() bool { func (f LinuxFirewall) IsForwardingEnabled() bool {
out, err := ioutil.ReadFile(IPV4ForwardingFile) if out, err := ioutil.ReadFile(IPV4ForwardingFile); err != nil {
if err != nil {
return false return false
} } else {
return str.Trim(string(out)) == "1" return str.Trim(string(out)) == "1"
} }
}
func (f LinuxFirewall) EnableForwarding(enabled bool) error { func (f LinuxFirewall) EnableForwarding(enabled bool) error {
return f.enableFeature(IPV4ForwardingFile, enabled) return f.enableFeature(IPV4ForwardingFile, enabled)
@ -111,8 +111,7 @@ func (f *LinuxFirewall) EnableRedirection(r *Redirection, enabled bool) error {
// accept all // accept all
if _, err := core.Exec("iptables", []string{"-P", "FORWARD", "ACCEPT"}); err != nil { if _, err := core.Exec("iptables", []string{"-P", "FORWARD", "ACCEPT"}); err != nil {
return err return err
} } else if _, err := core.Exec("iptables", cmdLine); err != nil {
if _, err := core.Exec("iptables", cmdLine); err != nil {
return err return err
} }
} else { } else {

6
firewall/firewall_windows.go
View file

@ -30,9 +30,10 @@ func (f WindowsFirewall) IsForwardingEnabled() bool {
if out, err := core.Exec("netsh", []string{"interface", "ipv4", "dump"}); err != nil { if out, err := core.Exec("netsh", []string{"interface", "ipv4", "dump"}); err != nil {
fmt.Printf("%s\n", err) fmt.Printf("%s\n", err)
return false return false
} } else {
return strings.Contains(out, "forwarding=enabled") return strings.Contains(out, "forwarding=enabled")
} }
}
func (f WindowsFirewall) EnableForwarding(enabled bool) error { func (f WindowsFirewall) EnableForwarding(enabled bool) error {
v := "enabled" v := "enabled"
@ -87,8 +88,7 @@ func (f *WindowsFirewall) AllowPort(port int, address string, proto string, allo
func (f *WindowsFirewall) EnableRedirection(r *Redirection, enabled bool) error { func (f *WindowsFirewall) EnableRedirection(r *Redirection, enabled bool) error {
if err := f.AllowPort(r.SrcPort, r.DstAddress, r.Protocol, enabled); err != nil { if err := f.AllowPort(r.SrcPort, r.DstAddress, r.Protocol, enabled); err != nil {
return err return err
} } else if err := f.AllowPort(r.DstPort, r.DstAddress, r.Protocol, enabled); err != nil {
if err := f.AllowPort(r.DstPort, r.DstAddress, r.Protocol, enabled); err != nil {
return err return err
} }

18
modules/any_proxy.go
View file

@ -82,23 +82,17 @@ func (p *AnyProxy) Configure() error {
if p.Running() { if p.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, iface = p.StringParam("any.proxy.iface"); err != nil {
if err, iface = p.StringParam("any.proxy.iface"); err != nil {
return err return err
} } else if err, protocol = p.StringParam("any.proxy.protocol"); err != nil {
if err, protocol = p.StringParam("any.proxy.protocol"); err != nil {
return err return err
} } else if err, srcPort = p.IntParam("any.proxy.src_port"); err != nil {
if err, srcPort = p.IntParam("any.proxy.src_port"); err != nil {
return err return err
} } else if err, dstPort = p.IntParam("any.proxy.dst_port"); err != nil {
if err, dstPort = p.IntParam("any.proxy.dst_port"); err != nil {
return err return err
} } else if err, srcAddress = p.StringParam("any.proxy.src_address"); err != nil {
if err, srcAddress = p.StringParam("any.proxy.src_address"); err != nil {
return err return err
} } else if err, dstAddress = p.StringParam("any.proxy.dst_address"); err != nil {
if err, dstAddress = p.StringParam("any.proxy.dst_address"); err != nil {
return err return err
} }

30
modules/api_rest.go
View file

@ -128,35 +128,25 @@ func (api *RestAPI) Configure() error {
if api.Running() { if api.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, ip = api.StringParam("api.rest.address"); err != nil {
if err, ip = api.StringParam("api.rest.address"); err != nil {
return err return err
} } else if err, port = api.IntParam("api.rest.port"); err != nil {
if err, port = api.IntParam("api.rest.port"); err != nil {
return err return err
} } else if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil {
if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil {
return err return err
} } else if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
return err return err
} } else if api.certFile, err = fs.Expand(api.certFile); err != nil {
if api.certFile, err = fs.Expand(api.certFile); err != nil {
return err return err
} } else if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
return err return err
} } else if api.keyFile, err = fs.Expand(api.keyFile); err != nil {
if api.keyFile, err = fs.Expand(api.keyFile); err != nil {
return err return err
} } else if err, api.username = api.StringParam("api.rest.username"); err != nil {
if err, api.username = api.StringParam("api.rest.username"); err != nil {
return err return err
} } else if err, api.password = api.StringParam("api.rest.password"); err != nil {
if err, api.password = api.StringParam("api.rest.password"); err != nil {
return err return err
} } else if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil {
if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil {
return err return err
} }

9
modules/api_rest_controller.go
View file

@ -51,8 +51,7 @@ func (api *RestAPI) checkAuth(r *http.Request) bool {
// timing attack my ass // timing attack my ass
if subtle.ConstantTimeCompare([]byte(user), []byte(api.username)) != 1 { if subtle.ConstantTimeCompare([]byte(user), []byte(api.username)) != 1 {
return false return false
} } else if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 {
if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 {
return false return false
} }
} }
@ -185,12 +184,10 @@ func (api *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) {
if !api.checkAuth(r) { if !api.checkAuth(r) {
setAuthFailed(w, r) setAuthFailed(w, r)
return return
} } else if r.Method == "POST" {
if r.Method == "POST" {
api.runSessionCommand(w, r) api.runSessionCommand(w, r)
return return
} } else if r.Method != "GET" {
if r.Method != "GET" {
http.Error(w, "Bad Request", 400) http.Error(w, "Bad Request", 400)
return return
} }

18
modules/arp_spoof.go
View file

@ -92,17 +92,13 @@ func (p *ArpSpoofer) Configure() error {
if err, p.internal = p.BoolParam("arp.spoof.internal"); err != nil { if err, p.internal = p.BoolParam("arp.spoof.internal"); err != nil {
return err return err
} } else if err, targets = p.StringParam("arp.spoof.targets"); err != nil {
if err, targets = p.StringParam("arp.spoof.targets"); err != nil {
return err return err
} } else if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil {
if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil {
return err return err
} } else if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil {
if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil {
return err return err
} } else if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil {
if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil {
return err return err
} }
@ -240,12 +236,10 @@ func (p *ArpSpoofer) sendArp(saddr net.IP, smac net.HardwareAddr, check_running
for ip, mac := range targets { for ip, mac := range targets {
if check_running && !p.Running() { if check_running && !p.Running() {
return return
} } else if p.isWhitelisted(ip, mac) {
if p.isWhitelisted(ip, mac) {
log.Debug("%s (%s) is whitelisted, skipping from spoofing loop.", ip, mac) log.Debug("%s (%s) is whitelisted, skipping from spoofing loop.", ip, mac)
continue continue
} } else if saddr.String() == ip {
if saddr.String() == ip {
continue continue
} }

3
modules/ble_recon.go
View file

@ -184,8 +184,7 @@ func (d *BLERecon) enumAllTheThings(mac string) error {
dev, found := d.Session.BLE.Get(mac) dev, found := d.Session.BLE.Get(mac)
if !found || dev == nil { if !found || dev == nil {
return fmt.Errorf("BLE device with address %s not found.", mac) return fmt.Errorf("BLE device with address %s not found.", mac)
} } else if d.Running() {
if d.Running() {
d.gattDevice.StopScanning() d.gattDevice.StopScanning()
} }

3
modules/ble_recon_events.go
View file

@ -43,8 +43,7 @@ func (d *BLERecon) onPeriphConnected(p gatt.Peripheral, err error) {
if err != nil { if err != nil {
log.Warning("Connected to %s but with error: %s", p.ID(), err) log.Warning("Connected to %s but with error: %s", p.ID(), err)
return return
} } else if d.currDevice == nil {
if d.currDevice == nil {
// timed out // timed out
log.Warning("Connected to %s but after the timeout :(", p.ID()) log.Warning("Connected to %s but after the timeout :(", p.ID())
return return

3
modules/ble_recon_view.go
View file

@ -117,9 +117,10 @@ func parseRawData(raw []byte) string {
return fmt.Sprintf("%x", raw) return fmt.Sprintf("%x", raw)
} else if b == 0 { } else if b == 0 {
break break
} } else {
s += fmt.Sprintf("%c", b) s += fmt.Sprintf("%c", b)
} }
}
return tui.Yellow(s) return tui.Yellow(s)
} }

18
modules/dns_spoof.go
View file

@ -89,23 +89,17 @@ func (s *DNSSpoofer) Configure() error {
if s.Running() { if s.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil {
if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil {
return err return err
} } else if err = s.Handle.SetBPFFilter("udp"); err != nil {
if err = s.Handle.SetBPFFilter("udp"); err != nil {
return err return err
} } else if err, s.All = s.BoolParam("dns.spoof.all"); err != nil {
if err, s.All = s.BoolParam("dns.spoof.all"); err != nil {
return err return err
} } else if err, address = s.IPParam("dns.spoof.address"); err != nil {
if err, address = s.IPParam("dns.spoof.address"); err != nil {
return err return err
} } else if err, domains = s.ListParam("dns.spoof.domains"); err != nil {
if err, domains = s.ListParam("dns.spoof.domains"); err != nil {
return err return err
} } else if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil {
if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil {
return err return err
} }

12
modules/events_view_http.go
View file

@ -40,14 +40,11 @@ func (s *EventsStream) shouldDumpHttpRequest(req HTTPRequest) bool {
func (s *EventsStream) shouldDumpHttpResponse(res HTTPResponse) bool { func (s *EventsStream) shouldDumpHttpResponse(res HTTPResponse) bool {
if s.dumpHttpResp { if s.dumpHttpResp {
return true return true
} } else if strings.Contains(res.ContentType, "text/plain") {
if strings.Contains(res.ContentType, "text/plain") {
return true return true
} } else if strings.Contains(res.ContentType, "application/json") {
if strings.Contains(res.ContentType, "application/json") {
return true return true
} } else if strings.Contains(res.ContentType, "text/xml") {
if strings.Contains(res.ContentType, "text/xml") {
return true return true
} }
// search for interesting headers // search for interesting headers
@ -93,8 +90,7 @@ func (s *EventsStream) dumpGZIP(body []byte) string {
reader, err := gzip.NewReader(buffer) reader, err := gzip.NewReader(buffer)
if err != nil { if err != nil {
return s.dumpRaw(body) return s.dumpRaw(body)
} } else if _, err = uncompressed.ReadFrom(reader); err != nil {
if _, err = uncompressed.ReadFrom(reader); err != nil {
return s.dumpRaw(body) return s.dumpRaw(body)
} }
return s.dumpRaw(uncompressed.Bytes()) return s.dumpRaw(uncompressed.Bytes())

6
modules/gps.go
View file

@ -74,11 +74,9 @@ func (gps *GPS) Author() string {
func (gps *GPS) Configure() (err error) { func (gps *GPS) Configure() (err error) {
if gps.Running() { if gps.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, gps.serialPort = gps.StringParam("gps.device"); err != nil {
if err, gps.serialPort = gps.StringParam("gps.device"); err != nil {
return err return err
} } else if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil {
if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil {
return err return err
} }

18
modules/http_proxy.go
View file

@ -80,23 +80,17 @@ func (p *HttpProxy) Configure() error {
if p.Running() { if p.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, address = p.StringParam("http.proxy.address"); err != nil {
if err, address = p.StringParam("http.proxy.address"); err != nil {
return err return err
} } else if err, proxyPort = p.IntParam("http.proxy.port"); err != nil {
if err, proxyPort = p.IntParam("http.proxy.port"); err != nil {
return err return err
} } else if err, httpPort = p.IntParam("http.port"); err != nil {
if err, httpPort = p.IntParam("http.port"); err != nil {
return err return err
} } else if err, scriptPath = p.StringParam("http.proxy.script"); err != nil {
if err, scriptPath = p.StringParam("http.proxy.script"); err != nil {
return err return err
} } else if err, stripSSL = p.BoolParam("http.proxy.sslstrip"); err != nil {
if err, stripSSL = p.BoolParam("http.proxy.sslstrip"); err != nil {
return err return err
} } else if err, jsToInject = p.StringParam("http.proxy.injectjs"); err != nil {
if err, jsToInject = p.StringParam("http.proxy.injectjs"); err != nil {
return err return err
} }

12
modules/http_proxy_base.go
View file

@ -119,12 +119,12 @@ func (p *HTTPProxy) Configure(address string, proxyPort int, httpPort int, scrip
if strings.HasPrefix(jsToInject, "http://") || strings.HasPrefix(jsToInject, "https://") { if strings.HasPrefix(jsToInject, "http://") || strings.HasPrefix(jsToInject, "https://") {
p.jsHook = fmt.Sprintf("<script src=\"%s\" type=\"text/javascript\"></script></head>", jsToInject) p.jsHook = fmt.Sprintf("<script src=\"%s\" type=\"text/javascript\"></script></head>", jsToInject)
} else if fs.Exists(jsToInject) { } else if fs.Exists(jsToInject) {
data, err := ioutil.ReadFile(jsToInject) if data, err := ioutil.ReadFile(jsToInject); err != nil {
if err != nil {
return err return err
} } else {
jsToInject = string(data) jsToInject = string(data)
} }
}
if p.jsHook == "" && jsToInject != "" { if p.jsHook == "" && jsToInject != "" {
if !strings.HasPrefix(jsToInject, "<script ") { if !strings.HasPrefix(jsToInject, "<script ") {
@ -134,12 +134,12 @@ func (p *HTTPProxy) Configure(address string, proxyPort int, httpPort int, scrip
} }
if scriptPath != "" { if scriptPath != "" {
err, p.Script = LoadHttpProxyScript(scriptPath, p.sess) if err, p.Script = LoadHttpProxyScript(scriptPath, p.sess); err != nil {
if err != nil {
return err return err
} } else {
log.Debug("Proxy script %s loaded.", scriptPath) log.Debug("Proxy script %s loaded.", scriptPath)
} }
}
p.Server = &http.Server{ p.Server = &http.Server{
Addr: fmt.Sprintf("%s:%d", p.Address, proxyPort), Addr: fmt.Sprintf("%s:%d", p.Address, proxyPort),

6
modules/http_proxy_base_cookietracker.go
View file

@ -24,13 +24,13 @@ func NewCookieTracker() *CookieTracker {
} }
func (t *CookieTracker) domainOf(req *http.Request) string { func (t *CookieTracker) domainOf(req *http.Request) string {
parsed, err := tld.Parse(req.Host) if parsed, err := tld.Parse(req.Host); err != nil {
if err != nil {
log.Warning("Could not parse host %s: %s", req.Host, err) log.Warning("Could not parse host %s: %s", req.Host, err)
return req.Host return req.Host
} } else {
return fmt.Sprintf("%s.%s", parsed.Domain, parsed.TLD) return fmt.Sprintf("%s.%s", parsed.Domain, parsed.TLD)
} }
}
func (t *CookieTracker) keyOf(req *http.Request) string { func (t *CookieTracker) keyOf(req *http.Request) string {
client := strings.Split(req.RemoteAddr, ":")[0] client := strings.Split(req.RemoteAddr, ":")[0]

6
modules/http_proxy_base_filters.go
View file

@ -43,8 +43,7 @@ func (p *HTTPProxy) onRequestFilter(req *http.Request, ctx *goproxy.ProxyCtx) (*
// the request has been changed by the script // the request has been changed by the script
p.logRequestAction(req, jsreq) p.logRequestAction(req, jsreq)
return jsreq.ToRequest(), nil return jsreq.ToRequest(), nil
} } else if jsres != nil {
if jsres != nil {
// a fake response has been returned by the script // a fake response has been returned by the script
p.logResponseAction(req, jsres) p.logResponseAction(req, jsres)
return req, jsres.ToResponse(req) return req, jsres.ToResponse(req)
@ -99,8 +98,7 @@ func (p *HTTPProxy) doScriptInjection(res *http.Response, cType string) (error,
raw, err := ioutil.ReadAll(res.Body) raw, err := ioutil.ReadAll(res.Body)
if err != nil { if err != nil {
return err, nil return err, nil
} } else if html := string(raw); strings.Contains(html, "</head>") {
if html := string(raw); strings.Contains(html, "</head>") {
log.Info("(%s) > injecting javascript (%d bytes) into %s (%d bytes) for %s", log.Info("(%s) > injecting javascript (%d bytes) into %s (%d bytes) for %s",
tui.Green(p.Name), tui.Green(p.Name),
len(p.jsHook), len(p.jsHook),

3
modules/http_proxy_base_sslstriper.go
View file

@ -272,9 +272,10 @@ func (s *SSLStripper) isMaxRedirs(hostname string) bool {
// reset // reset
delete(s.redirs, hostname) delete(s.redirs, hostname)
return true return true
} } else {
// increment // increment
s.redirs[hostname]++ s.redirs[hostname]++
}
} else { } else {
// start tracking redirections // start tracking redirections
s.redirs[hostname] = 1 s.redirs[hostname] = 1

6
modules/http_proxy_js_response.go
View file

@ -65,12 +65,10 @@ func (j *JSResponse) WasModified() bool {
if j.bodyRead { if j.bodyRead {
// body was read // body was read
return true return true
} } else if j.bodyClear {
if j.bodyClear {
// body was cleared manually // body was cleared manually
return true return true
} } else if j.Body != "" {
if j.Body != "" {
// body was not read but just set // body was not read but just set
return true return true
} }

13
modules/http_proxy_script.go
View file

@ -58,12 +58,10 @@ func (s *HttpProxyScript) OnRequest(original *http.Request) (jsreq *JSRequest, j
if _, err := s.Call("onRequest", jsreq, jsres); err != nil { if _, err := s.Call("onRequest", jsreq, jsres); err != nil {
log.Error("%s", err) log.Error("%s", err)
return nil, nil return nil, nil
} } else if jsreq.WasModified() {
if jsreq.WasModified() {
jsreq.UpdateHash() jsreq.UpdateHash()
return jsreq, nil return jsreq, nil
} } else if jsres.WasModified() {
if jsres.WasModified() {
jsres.UpdateHash() jsres.UpdateHash()
return nil, jsres return nil, jsres
} }
@ -91,13 +89,10 @@ func (s *HttpProxyScript) OnResponse(res *http.Response) (jsreq *JSRequest, jsre
func (s *HttpProxyScript) OnCommand(cmd string) bool { func (s *HttpProxyScript) OnCommand(cmd string) bool {
if s.doOnCommand { if s.doOnCommand {
ret, err := s.Call("onCommand", cmd) if ret, err := s.Call("onCommand", cmd); err != nil {
if err != nil {
log.Error("Error while executing onCommand callback: %+v", err) log.Error("Error while executing onCommand callback: %+v", err)
return false return false
} } else if v, ok := ret.(bool); ok {
v, ok := ret.(bool)
if ok {
return v return v
} }
} }

30
modules/https_proxy.go
View file

@ -98,35 +98,25 @@ func (p *HttpsProxy) Configure() error {
if p.Running() { if p.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, address = p.StringParam("https.proxy.address"); err != nil {
if err, address = p.StringParam("https.proxy.address"); err != nil {
return err return err
} } else if err, proxyPort = p.IntParam("https.proxy.port"); err != nil {
if err, proxyPort = p.IntParam("https.proxy.port"); err != nil {
return err return err
} } else if err, httpPort = p.IntParam("https.port"); err != nil {
if err, httpPort = p.IntParam("https.port"); err != nil {
return err return err
} } else if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil {
if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil {
return err return err
} } else if err, certFile = p.StringParam("https.proxy.certificate"); err != nil {
if err, certFile = p.StringParam("https.proxy.certificate"); err != nil {
return err return err
} } else if certFile, err = fs.Expand(certFile); err != nil {
if certFile, err = fs.Expand(certFile); err != nil {
return err return err
} } else if err, keyFile = p.StringParam("https.proxy.key"); err != nil {
if err, keyFile = p.StringParam("https.proxy.key"); err != nil {
return err return err
} } else if keyFile, err = fs.Expand(keyFile); err != nil {
if keyFile, err = fs.Expand(keyFile); err != nil {
return err return err
} } else if err, scriptPath = p.StringParam("https.proxy.script"); err != nil {
if err, scriptPath = p.StringParam("https.proxy.script"); err != nil {
return err return err
} } else if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil {
if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil {
return err return err
} }

9
modules/mac_changer.go
View file

@ -68,8 +68,7 @@ func (mc *MacChanger) Configure() (err error) {
if err, mc.iface = mc.StringParam("mac.changer.iface"); err != nil { if err, mc.iface = mc.StringParam("mac.changer.iface"); err != nil {
return err return err
} } else if err, changeTo = mc.StringParam("mac.changer.address"); err != nil {
if err, changeTo = mc.StringParam("mac.changer.address"); err != nil {
return err return err
} }
@ -106,11 +105,9 @@ func (mc *MacChanger) setMac(mac net.HardwareAddr) error {
func (mc *MacChanger) Start() error { func (mc *MacChanger) Start() error {
if mc.Running() { if mc.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err := mc.Configure(); err != nil {
if err := mc.Configure(); err != nil {
return err return err
} } else if err := mc.setMac(mc.fakeMac); err != nil {
if err := mc.setMac(mc.fakeMac); err != nil {
return err return err
} }

27
modules/mysql_server.go
View file

@ -82,23 +82,17 @@ func (mysql *MySQLServer) Configure() error {
if mysql.Running() { if mysql.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, mysql.infile = mysql.StringParam("mysql.server.infile"); err != nil {
if err, mysql.infile = mysql.StringParam("mysql.server.infile"); err != nil {
return err return err
} } else if err, mysql.outfile = mysql.StringParam("mysql.server.outfile"); err != nil {
if err, mysql.outfile = mysql.StringParam("mysql.server.outfile"); err != nil {
return err return err
} } else if err, address = mysql.StringParam("mysql.server.address"); err != nil {
if err, address = mysql.StringParam("mysql.server.address"); err != nil {
return err return err
} } else if err, port = mysql.IntParam("mysql.server.port"); err != nil {
if err, port = mysql.IntParam("mysql.server.port"); err != nil {
return err return err
} } else if mysql.address, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil {
if mysql.address, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil {
return err return err
} } else if mysql.listener, err = net.ListenTCP("tcp", mysql.address); err != nil {
if mysql.listener, err = net.ListenTCP("tcp", mysql.address); err != nil {
return err return err
} }
return nil return nil
@ -147,16 +141,13 @@ func (mysql *MySQLServer) Start() error {
if _, err := conn.Write(packets.MySQLFirstResponseOK); err != nil { if _, err := conn.Write(packets.MySQLFirstResponseOK); err != nil {
log.Warning("[%s] error while writing server first response ok: %s", tui.Green("mysql.server"), err) log.Warning("[%s] error while writing server first response ok: %s", tui.Green("mysql.server"), err)
continue continue
} } else if _, err := reader.Read(readBuffer); err != nil {
if _, err := reader.Read(readBuffer); err != nil {
log.Warning("[%s] error while reading client message: %s", tui.Green("mysql.server"), err) log.Warning("[%s] error while reading client message: %s", tui.Green("mysql.server"), err)
continue continue
} } else if _, err := conn.Write(packets.MySQLGetFile(mysql.infile)); err != nil {
if _, err := conn.Write(packets.MySQLGetFile(mysql.infile)); err != nil {
log.Warning("[%s] error while writing server get file request: %s", tui.Green("mysql.server"), err) log.Warning("[%s] error while writing server get file request: %s", tui.Green("mysql.server"), err)
continue continue
} } else if read, err = reader.Read(readBuffer); err != nil {
if read, err = reader.Read(readBuffer); err != nil {
log.Warning("[%s] error while readind buffer: %s", tui.Green("mysql.server"), err) log.Warning("[%s] error while readind buffer: %s", tui.Green("mysql.server"), err)
continue continue
} }

21
modules/net_probe.go
View file

@ -82,20 +82,17 @@ func (p *Prober) Configure() error {
var err error var err error
if err, p.throttle = p.IntParam("net.probe.throttle"); err != nil { if err, p.throttle = p.IntParam("net.probe.throttle"); err != nil {
return err return err
} } else if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil {
if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil {
return err return err
} } else if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil {
if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil {
return err return err
} } else if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil {
if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil {
return err return err
} } else if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil {
if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil {
return err return err
} } else {
log.Debug("Throttling packets of %d ms.", p.throttle) log.Debug("Throttling packets of %d ms.", p.throttle)
}
return nil return nil
} }
@ -139,12 +136,10 @@ func (p *Prober) Start() error {
for _, ip := range addresses { for _, ip := range addresses {
if !p.Running() { if !p.Running() {
return return
} } else if p.Session.Skip(ip) {
if p.Session.Skip(ip) {
log.Debug("skipping address %s from probing.", ip) log.Debug("skipping address %s from probing.", ip)
continue continue
} } else if p.probes.NBNS {
if p.probes.NBNS {
p.sendProbeNBNS(from, from_hw, ip) p.sendProbeNBNS(from, from_hw, ip)
} }
time.Sleep(throttle) time.Sleep(throttle)

3
modules/net_probe_mdns.go
View file

@ -12,8 +12,7 @@ func (p *Prober) sendProbeMDNS(from net.IP, from_hw net.HardwareAddr) {
if err != nil { if err != nil {
log.Error("error while sending mdns probe: %v", err) log.Error("error while sending mdns probe: %v", err)
return return
} } else if err := p.Session.Queue.Send(raw); err != nil {
if err := p.Session.Queue.Send(raw); err != nil {
log.Error("error sending mdns packet: %s", err) log.Error("error sending mdns packet: %s", err)
} else { } else {
log.Debug("sent %d bytes of MDNS probe", len(raw)) log.Debug("sent %d bytes of MDNS probe", len(raw))

18
modules/net_recon_show.go
View file

@ -88,8 +88,7 @@ func (d *Discovery) getRow(e *network.Endpoint, withMeta bool) [][]string {
if !withMeta { if !withMeta {
return [][]string{row} return [][]string{row}
} } else if e.Meta.Empty() {
if e.Meta.Empty() {
return [][]string{append(row, tui.Dim("-"))} return [][]string{append(row, tui.Dim("-"))}
} }
@ -121,14 +120,13 @@ func (d *Discovery) Show(by string, expr string) (err error) {
targets = d.Session.Lan.List() targets = d.Session.Lan.List()
} }
switch by { if by == "seen" {
case "seen":
sort.Sort(BySeenSorter(targets)) sort.Sort(BySeenSorter(targets))
case "sent": } else if by == "sent" {
sort.Sort(BySentSorter(targets)) sort.Sort(BySentSorter(targets))
case "rcvd": } else if by == "rcvd" {
sort.Sort(ByRcvdSorter(targets)) sort.Sort(ByRcvdSorter(targets))
default: } else {
sort.Sort(ByAddressSorter(targets)) sort.Sort(ByAddressSorter(targets))
} }
@ -141,11 +139,9 @@ func (d *Discovery) Show(by string, expr string) (err error) {
} }
hasMeta := false hasMeta := false
err, showMeta := d.BoolParam("net.show.meta") if err, showMeta := d.BoolParam("net.show.meta"); err != nil {
if err != nil {
return err return err
} } else if showMeta {
if showMeta {
for _, t := range targets { for _, t := range targets {
if !t.Meta.Empty() { if !t.Meta.Empty() {
hasMeta = true hasMeta = true

3
modules/net_sniff.go
View file

@ -112,8 +112,7 @@ func (s *Sniffer) Configure() error {
if s.Running() { if s.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, s.Ctx = s.GetContext(); err != nil {
if err, s.Ctx = s.GetContext(); err != nil {
if s.Ctx != nil { if s.Ctx != nil {
s.Ctx.Close() s.Ctx.Close()
s.Ctx = nil s.Ctx = nil

24
modules/net_sniff_parsers.go
View file

@ -17,14 +17,11 @@ func tcpParser(ip *layers.IPv4, pkt gopacket.Packet, verbose bool) {
if sniParser(ip, pkt, tcp) { if sniParser(ip, pkt, tcp) {
return return
} } else if ntlmParser(ip, pkt, tcp) {
if ntlmParser(ip, pkt, tcp) {
return return
} } else if httpParser(ip, pkt, tcp) {
if httpParser(ip, pkt, tcp) {
return return
} } else if verbose {
if verbose {
NewSnifferEvent( NewSnifferEvent(
pkt.Metadata().Timestamp, pkt.Metadata().Timestamp,
"tcp", "tcp",
@ -49,17 +46,13 @@ func udpParser(ip *layers.IPv4, pkt gopacket.Packet, verbose bool) {
if dnsParser(ip, pkt, udp) { if dnsParser(ip, pkt, udp) {
return return
} } else if mdnsParser(ip, pkt, udp) {
if mdnsParser(ip, pkt, udp) {
return return
} } else if krb5Parser(ip, pkt, udp) {
if krb5Parser(ip, pkt, udp) {
return return
} } else if upnpParser(ip, pkt, udp) {
if upnpParser(ip, pkt, udp) {
return return
} } else if verbose {
if verbose {
NewSnifferEvent( NewSnifferEvent(
pkt.Metadata().Timestamp, pkt.Metadata().Timestamp,
"udp", "udp",
@ -125,8 +118,7 @@ func mainParser(pkt gopacket.Packet, verbose bool) bool {
unkParser(ip, pkt, verbose) unkParser(ip, pkt, verbose)
} }
return true return true
} } else if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok {
if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok {
// are we sniffing in monitor mode? // are we sniffing in monitor mode?
dot11Parser(radiotap, dot11, pkt, verbose) dot11Parser(radiotap, dot11, pkt, verbose)
return true return true

3
modules/net_sniff_views.go
View file

@ -13,8 +13,7 @@ import (
func vIP(ip net.IP) string { func vIP(ip net.IP) string {
if session.I.Interface.IP.Equal(ip) { if session.I.Interface.IP.Equal(ip) {
return tui.Dim("local") return tui.Dim("local")
} } else if session.I.Gateway.IP.Equal(ip) {
if session.I.Gateway.IP.Equal(ip) {
return "gateway" return "gateway"
} }

36
modules/packet_proxy_linux_amd64.go
View file

@ -135,21 +135,17 @@ func (pp *PacketProxy) Configure() (err error) {
if err, pp.queueNum = pp.IntParam("packet.proxy.queue.num"); err != nil { if err, pp.queueNum = pp.IntParam("packet.proxy.queue.num"); err != nil {
return return
} } else if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil {
if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil {
return return
} } else if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil {
if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil {
return return
} } else if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil {
if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil {
return return
} }
if pp.pluginPath == "" { if pp.pluginPath == "" {
return fmt.Errorf("The parameter %s can not be empty.", tui.Bold("packet.proxy.plugin")) return fmt.Errorf("The parameter %s can not be empty.", tui.Bold("packet.proxy.plugin"))
} } else if !fs.Exists(pp.pluginPath) {
if !fs.Exists(pp.pluginPath) {
return fmt.Errorf("%s does not exist.", pp.pluginPath) return fmt.Errorf("%s does not exist.", pp.pluginPath)
} }
@ -160,34 +156,26 @@ func (pp *PacketProxy) Configure() (err error) {
if pp.plugin, err = plugin.Open(pp.pluginPath); err != nil { if pp.plugin, err = plugin.Open(pp.pluginPath); err != nil {
return return
} } else if sym, err = pp.plugin.Lookup("OnPacket"); err != nil {
if sym, err = pp.plugin.Lookup("OnPacket"); err != nil {
return return
} } else if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok {
if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok {
return fmt.Errorf("Symbol OnPacket is not a valid callback function.") return fmt.Errorf("Symbol OnPacket is not a valid callback function.")
} }
pp.queue = new(nfqueue.Queue) pp.queue = new(nfqueue.Queue)
if err = pp.queue.SetCallback(dummyCallback); err != nil { if err = pp.queue.SetCallback(dummyCallback); err != nil {
return return
} } else if err = pp.queue.Init(); err != nil {
if err = pp.queue.Init(); err != nil {
return return
} } else if err = pp.queue.Unbind(syscall.AF_INET); err != nil {
if err = pp.queue.Unbind(syscall.AF_INET); err != nil {
return return
} } else if err = pp.queue.Bind(syscall.AF_INET); err != nil {
if err = pp.queue.Bind(syscall.AF_INET); err != nil {
return return
} } else if err = pp.queue.CreateQueue(pp.queueNum); err != nil {
if err = pp.queue.CreateQueue(pp.queueNum); err != nil {
return return
} } else if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil {
if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil {
return return
} } else if err = pp.runRule(true); err != nil {
if err = pp.runRule(true); err != nil {
return return
} }

33
modules/tcp_proxy.go
View file

@ -97,38 +97,27 @@ func (p *TcpProxy) Configure() error {
if p.Running() { if p.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, address = p.StringParam("tcp.address"); err != nil {
if err, address = p.StringParam("tcp.address"); err != nil {
return err return err
} } else if err, proxyAddress = p.StringParam("tcp.proxy.address"); err != nil {
if err, proxyAddress = p.StringParam("tcp.proxy.address"); err != nil {
return err return err
} } else if err, proxyPort = p.IntParam("tcp.proxy.port"); err != nil {
if err, proxyPort = p.IntParam("tcp.proxy.port"); err != nil {
return err return err
} } else if err, port = p.IntParam("tcp.port"); err != nil {
if err, port = p.IntParam("tcp.port"); err != nil {
return err return err
} } else if err, tunnelAddress = p.StringParam("tcp.tunnel.address"); err != nil {
if err, tunnelAddress = p.StringParam("tcp.tunnel.address"); err != nil {
return err return err
} } else if err, tunnelPort = p.IntParam("tcp.tunnel.port"); err != nil {
if err, tunnelPort = p.IntParam("tcp.tunnel.port"); err != nil {
return err return err
} } else if err, scriptPath = p.StringParam("tcp.proxy.script"); err != nil {
if err, scriptPath = p.StringParam("tcp.proxy.script"); err != nil {
return err return err
} } else if p.localAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", proxyAddress, proxyPort)); err != nil {
if p.localAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", proxyAddress, proxyPort)); err != nil {
return err return err
} } else if p.remoteAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil {
if p.remoteAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", address, port)); err != nil {
return err return err
} } else if p.tunnelAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", tunnelAddress, tunnelPort)); err != nil {
if p.tunnelAddr, err = net.ResolveTCPAddr("tcp", fmt.Sprintf("%s:%d", tunnelAddress, tunnelPort)); err != nil {
return err return err
} } else if p.listener, err = net.ListenTCP("tcp", p.localAddr); err != nil {
if p.listener, err = net.ListenTCP("tcp", p.localAddr); err != nil {
return err return err
} }

6
modules/ticker.go
View file

@ -61,11 +61,9 @@ func (t *Ticker) Configure() error {
if t.Running() { if t.Running() {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} } else if err, commands = t.StringParam("ticker.commands"); err != nil {
if err, commands = t.StringParam("ticker.commands"); err != nil {
return err return err
} } else if err, period = t.IntParam("ticker.period"); err != nil {
if err, period = t.IntParam("ticker.period"); err != nil {
return err return err
} }

28
modules/wifi.go
View file

@ -72,9 +72,7 @@ func NewWiFiModule(s *session.Session) *WiFiModule {
bssid, err := net.ParseMAC(args[0]) bssid, err := net.ParseMAC(args[0])
if err != nil { if err != nil {
return err return err
} } else if ap, found := w.Session.WiFi.Get(bssid.String()); found {
ap, found := w.Session.WiFi.Get(bssid.String())
if found {
w.ap = ap w.ap = ap
w.stickChan = ap.Channel() w.stickChan = ap.Channel()
return nil return nil
@ -106,8 +104,9 @@ func NewWiFiModule(s *session.Session) *WiFiModule {
func(args []string) error { func(args []string) error {
if err := w.parseApConfig(); err != nil { if err := w.parseApConfig(); err != nil {
return err return err
} } else {
return w.startAp() return w.startAp()
}
})) }))
w.AddParam(session.NewStringParameter("wifi.ap.ssid", w.AddParam(session.NewStringParameter("wifi.ap.ssid",
@ -151,12 +150,12 @@ func NewWiFiModule(s *session.Session) *WiFiModule {
} }
} else { } else {
// No channels setted, retrieve frequencies supported by the card // No channels setted, retrieve frequencies supported by the card
frequencies, err := network.GetSupportedFrequencies(w.Session.Interface.Name()) if frequencies, err := network.GetSupportedFrequencies(w.Session.Interface.Name()); err != nil {
if err != nil {
return err return err
} } else {
newfrequencies = frequencies newfrequencies = frequencies
} }
}
w.frequencies = newfrequencies w.frequencies = newfrequencies
@ -212,22 +211,18 @@ func (w *WiFiModule) Configure() error {
if err = ihandle.SetRFMon(true); err != nil { if err = ihandle.SetRFMon(true); err != nil {
return fmt.Errorf("Error while setting interface %s in monitor mode: %s", tui.Bold(w.Session.Interface.Name()), err) return fmt.Errorf("Error while setting interface %s in monitor mode: %s", tui.Bold(w.Session.Interface.Name()), err)
} } else if err = ihandle.SetSnapLen(65536); err != nil {
if err = ihandle.SetSnapLen(65536); err != nil {
return err return err
} } else if err = ihandle.SetTimeout(pcap.BlockForever); err != nil {
if err = ihandle.SetTimeout(pcap.BlockForever); err != nil {
return err return err
} } else if w.handle, err = ihandle.Activate(); err != nil {
if w.handle, err = ihandle.Activate(); err != nil {
return err return err
} }
} }
if err, w.skipBroken = w.BoolParam("wifi.skip-broken"); err != nil { if err, w.skipBroken = w.BoolParam("wifi.skip-broken"); err != nil {
return err return err
} } else if err, hopPeriod = w.IntParam("wifi.hop.period"); err != nil {
if err, hopPeriod = w.IntParam("wifi.hop.period"); err != nil {
return err return err
} }
@ -300,8 +295,7 @@ func (w *WiFiModule) Start() error {
for packet := range w.pktSourceChan { for packet := range w.pktSourceChan {
if !w.Running() { if !w.Running() {
break break
} } else if packet == nil {
if packet == nil {
continue continue
} }

15
modules/wifi_ap.go
View file

@ -19,17 +19,13 @@ func (w *WiFiModule) parseApConfig() (err error) {
var bssid string var bssid string
if err, w.apConfig.SSID = w.StringParam("wifi.ap.ssid"); err != nil { if err, w.apConfig.SSID = w.StringParam("wifi.ap.ssid"); err != nil {
return return
} } else if err, bssid = w.StringParam("wifi.ap.bssid"); err != nil {
if err, bssid = w.StringParam("wifi.ap.bssid"); err != nil {
return return
} } else if w.apConfig.BSSID, err = net.ParseMAC(network.NormalizeMac(bssid)); err != nil {
if w.apConfig.BSSID, err = net.ParseMAC(network.NormalizeMac(bssid)); err != nil {
return return
} } else if err, w.apConfig.Channel = w.IntParam("wifi.ap.channel"); err != nil {
if err, w.apConfig.Channel = w.IntParam("wifi.ap.channel"); err != nil {
return return
} } else if err, w.apConfig.Encryption = w.BoolParam("wifi.ap.encryption"); err != nil {
if err, w.apConfig.Encryption = w.BoolParam("wifi.ap.encryption"); err != nil {
return return
} }
return return
@ -39,8 +35,7 @@ func (w *WiFiModule) startAp() error {
// we need channel hopping and packet injection for this // we need channel hopping and packet injection for this
if !w.Running() { if !w.Running() {
return errNoRecon return errNoRecon
} } else if w.apRunning {
if w.apRunning {
return session.ErrAlreadyStarted return session.ErrAlreadyStarted
} }

13
modules/wifi_show.go
View file

@ -84,7 +84,7 @@ func (w *WiFiModule) getRow(station *network.Station) ([]string, bool) {
recvd, recvd,
seen, seen,
}, include }, include
} } else {
// this is ugly, but necessary in order to have this // this is ugly, but necessary in order to have this
// method handle both access point and clients // method handle both access point and clients
// transparently // transparently
@ -108,6 +108,7 @@ func (w *WiFiModule) getRow(station *network.Station) ([]string, bool) {
seen, seen,
}, include }, include
} }
}
func (w *WiFiModule) Show(by string) error { func (w *WiFiModule) Show(by string) error {
var stations []*network.Station var stations []*network.Station
@ -122,14 +123,14 @@ func (w *WiFiModule) Show(by string) error {
} else { } else {
stations = w.Session.WiFi.Stations() stations = w.Session.WiFi.Stations()
} }
switch by {
case "seen": if by == "seen" {
sort.Sort(ByWiFiSeenSorter(stations)) sort.Sort(ByWiFiSeenSorter(stations))
case "essid": } else if by == "essid" {
sort.Sort(ByEssidSorter(stations)) sort.Sort(ByEssidSorter(stations))
case "channel": } else if by == "channel" {
sort.Sort(ByChannelSorter(stations)) sort.Sort(ByChannelSorter(stations))
default: } else {
sort.Sort(ByRSSISorter(stations)) sort.Sort(ByRSSISorter(stations))
} }

15
modules/wol.go
View file

@ -31,21 +31,21 @@ func NewWOL(s *session.Session) *WOL {
w.AddHandler(session.NewModuleHandler("wol.eth MAC", "wol.eth(\\s.+)?", w.AddHandler(session.NewModuleHandler("wol.eth MAC", "wol.eth(\\s.+)?",
"Send a WOL as a raw ethernet packet of type 0x0847 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).", "Send a WOL as a raw ethernet packet of type 0x0847 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).",
func(args []string) error { func(args []string) error {
mac, err := parseMAC(args) if mac, err := parseMAC(args); err != nil {
if err != nil {
return err return err
} } else {
return w.wolETH(mac) return w.wolETH(mac)
}
})) }))
w.AddHandler(session.NewModuleHandler("wol.udp MAC", "wol.udp(\\s.+)?", w.AddHandler(session.NewModuleHandler("wol.udp MAC", "wol.udp(\\s.+)?",
"Send a WOL as an IPv4 broadcast packet to UDP port 9 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).", "Send a WOL as an IPv4 broadcast packet to UDP port 9 (if no MAC is specified, ff:ff:ff:ff:ff:ff will be used).",
func(args []string) error { func(args []string) error {
mac, err := parseMAC(args) if mac, err := parseMAC(args); err != nil {
if err != nil {
return err return err
} } else {
return w.wolUDP(mac) return w.wolUDP(mac)
}
})) }))
return w return w
@ -58,10 +58,11 @@ func parseMAC(args []string) (string, error) {
if tmp != "" { if tmp != "" {
if !reMAC.MatchString(tmp) { if !reMAC.MatchString(tmp) {
return "", fmt.Errorf("%s is not a valid MAC address.", tmp) return "", fmt.Errorf("%s is not a valid MAC address.", tmp)
} } else {
mac = tmp mac = tmp
} }
} }
}
return mac, nil return mac, nil
} }

13
network/lan_endpoint.go
View file

@ -147,11 +147,9 @@ func (t *Endpoint) String() string {
if t.HwAddress == "" { if t.HwAddress == "" {
return t.IpAddress return t.IpAddress
} } else if t.Vendor == "" {
if t.Vendor == "" {
return fmt.Sprintf("%s%s", ipPart, t.HwAddress) return fmt.Sprintf("%s%s", ipPart, t.HwAddress)
} } else if t.Hostname == "" {
if t.Hostname == "" {
return fmt.Sprintf("%s%s ( %s )", ipPart, t.HwAddress, t.Vendor) return fmt.Sprintf("%s%s ( %s )", ipPart, t.HwAddress, t.Vendor)
} }
return fmt.Sprintf("%s%s ( %s ) - %s", ipPart, t.HwAddress, t.Vendor, tui.Bold(t.Hostname)) return fmt.Sprintf("%s%s ( %s ) - %s", ipPart, t.HwAddress, t.Vendor, tui.Bold(t.Hostname))
@ -161,14 +159,11 @@ func (t *Endpoint) OnMeta(meta map[string]string) {
host := "" host := ""
for k, v := range meta { for k, v := range meta {
// simple heuristics to get the longest candidate name // simple heuristics to get the longest candidate name
if len(v) > len(host) { if strings.HasSuffix(k, ":hostname") && len(v) > len(host) {
if strings.HasSuffix(k, ":hostname") {
host = v host = v
} } else if k == "mdns:md" && len(v) > len(host) {
if k == "mdns:md" {
host = v host = v
} }
}
t.Meta.Set(k, v) t.Meta.Set(k, v)
} }

3
network/net_gateway.go
View file

@ -31,7 +31,7 @@ func FindGateway(iface *Endpoint) (*Endpoint, error) {
if gateway == iface.IpAddress { if gateway == iface.IpAddress {
Debug("gateway is the interface") Debug("gateway is the interface")
return iface, nil return iface, nil
} } else {
// we have the address, now we need its mac // we have the address, now we need its mac
mac, err := ArpLookup(ifName, gateway, false) mac, err := ArpLookup(ifName, gateway, false)
if err != nil { if err != nil {
@ -39,6 +39,7 @@ func FindGateway(iface *Endpoint) (*Endpoint, error) {
} }
Debug("gateway is %s[%s]", gateway, mac) Debug("gateway is %s[%s]", gateway, mac)
return NewEndpoint(gateway, mac), nil return NewEndpoint(gateway, mac), nil
}
}) })
} }
} }

6
network/net_linux.go
View file

@ -50,8 +50,7 @@ func SetInterfaceChannel(iface string, channel int) error {
out, err := core.Exec("iwconfig", []string{iface, "channel", fmt.Sprintf("%d", channel)}) out, err := core.Exec("iwconfig", []string{iface, "channel", fmt.Sprintf("%d", channel)})
if err != nil { if err != nil {
return err return err
} } else if out != "" {
if out != "" {
return fmt.Errorf("Unexpected output while setting interface %s to channel %d: %s", iface, channel, out) return fmt.Errorf("Unexpected output while setting interface %s to channel %d: %s", iface, channel, out)
} }
@ -64,8 +63,7 @@ func processSupportedFrequencies(output string, err error) ([]int, error) {
freqs := make([]int, 0) freqs := make([]int, 0)
if err != nil { if err != nil {
return freqs, err return freqs, err
} } else if output != "" {
if output != "" {
scanner := bufio.NewScanner(strings.NewReader(output)) scanner := bufio.NewScanner(strings.NewReader(output))
for scanner.Scan() { for scanner.Scan() {
line := scanner.Text() line := scanner.Text()

12
network/wifi.go
View file

@ -10,11 +10,9 @@ import (
func Dot11Freq2Chan(freq int) int { func Dot11Freq2Chan(freq int) int {
if freq <= 2472 { if freq <= 2472 {
return ((freq - 2412) / 5) + 1 return ((freq - 2412) / 5) + 1
} } else if freq == 2484 {
if freq == 2484 {
return 14 return 14
} } else if freq >= 5035 && freq <= 5865 {
if freq >= 5035 && freq <= 5865 {
return ((freq - 5035) / 5) + 7 return ((freq - 5035) / 5) + 7
} }
return 0 return 0
@ -23,11 +21,9 @@ func Dot11Freq2Chan(freq int) int {
func Dot11Chan2Freq(channel int) int { func Dot11Chan2Freq(channel int) int {
if channel <= 13 { if channel <= 13 {
return ((channel - 1) * 5) + 2412 return ((channel - 1) * 5) + 2412
} } else if channel == 14 {
if channel == 14 {
return 2484 return 2484
} } else if channel <= 173 {
if channel <= 173 {
return ((channel - 7) * 5) + 5035 return ((channel - 7) * 5) + 5035
} }

5
network/wifi_station.go
View file

@ -19,10 +19,11 @@ func cleanESSID(essid string) string {
res := "" res := ""
for _, c := range essid { for _, c := range essid {
if !strconv.IsPrint(c) { if strconv.IsPrint(c) {
res += string(c)
} else {
break break
} }
res += string(c)
} }
return res return res
} }

6
packets/dhcp6.go
View file

@ -38,11 +38,11 @@ func DHCP6For(what dhcp6.MessageType, to dhcp6.Packet, duid []byte) (err error,
} }
var rawCID []byte var rawCID []byte
raw, found := to.Options[dhcp6.OptionClientID] if raw, found := to.Options[dhcp6.OptionClientID]; !found || len(raw) < 1 {
if !found || len(raw) < 1 {
return ErrNoCID, p return ErrNoCID, p
} } else {
rawCID = raw[0] rawCID = raw[0]
}
p.Options.AddRaw(dhcp6.OptionClientID, rawCID) p.Options.AddRaw(dhcp6.OptionClientID, rawCID)
p.Options.AddRaw(dhcp6.OptionServerID, duid) p.Options.AddRaw(dhcp6.OptionServerID, duid)

3
packets/queue.go
View file

@ -233,8 +233,9 @@ func (q *Queue) Send(raw []byte) error {
if err := q.handle.WritePacketData(raw); err != nil { if err := q.handle.WritePacketData(raw); err != nil {
q.TrackError() q.TrackError()
return err return err
} } else {
q.TrackSent(uint64(len(raw))) q.TrackSent(uint64(len(raw)))
}
return nil return nil
} }

3
session/command_handler.go
View file

@ -27,6 +27,7 @@ func (h *CommandHandler) Parse(line string) (bool, []string) {
result := h.Parser.FindStringSubmatch(line) result := h.Parser.FindStringSubmatch(line)
if len(result) == h.Parser.NumSubexp()+1 { if len(result) == h.Parser.NumSubexp()+1 {
return true, result[1:] return true, result[1:]
} } else {
return false, nil return false, nil
} }
}

10
session/command_handler_test.go
View file

@ -46,15 +46,11 @@ func TestSessionCommandHandler(t *testing.T) {
shouldNotParse := "simple123" shouldNotParse := "simple123"
shouldParse := "simple 123" shouldParse := "simple 123"
parsed, _ := c.Parse(shouldNotParse) if parsed, _ := c.Parse(shouldNotParse); parsed {
if parsed {
t.Fatalf("should not parse '%s'", shouldNotParse) t.Fatalf("should not parse '%s'", shouldNotParse)
} } else if parsed, parts := c.Parse(shouldParse); !parsed {
parsed, parts := c.Parse(shouldParse)
if !parsed {
t.Fatalf("should parse '%s'", shouldParse) t.Fatalf("should parse '%s'", shouldParse)
} } else if !sameStrings(parts, u.parsed) {
if !sameStrings(parts, u.parsed) {
t.Fatalf("expected '%v', got '%v'", u.parsed, parts) t.Fatalf("expected '%v', got '%v'", u.parsed, parts)
} }
} }

6
session/environment.go
View file

@ -112,11 +112,11 @@ func (env *Environment) Get(name string) (bool, string) {
func (env *Environment) GetInt(name string) (error, int) { func (env *Environment) GetInt(name string) (error, int) {
if found, value := env.Get(name); found { if found, value := env.Get(name); found {
i, err := strconv.Atoi(value) if i, err := strconv.Atoi(value); err == nil {
if err != nil { return nil, i
} else {
return err, 0 return err, 0
} }
return nil, i
} }
return fmt.Errorf("Not found."), 0 return fmt.Errorf("Not found."), 0

153
session/environment_test.go
View file

@ -22,20 +22,17 @@ func setup(t testing.TB, envFile bool, envFileData bool) {
teardown(t) teardown(t)
if envFile { if envFile {
fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666) if fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666); err == nil {
if err != nil { fp.Close()
} else {
panic(err) panic(err)
} }
fp.Close()
} }
if envFileData { if envFileData {
raw, err := json.Marshal(testEnvData) if raw, err := json.Marshal(testEnvData); err != nil {
if err != nil {
panic(err) panic(err)
} } else if err = ioutil.WriteFile(testEnvFile, raw, 0755); err != nil {
err = ioutil.WriteFile(testEnvFile, raw, 0755)
if err != nil {
panic(err) panic(err)
} }
} }
@ -48,71 +45,64 @@ func teardown(t testing.TB) {
} }
func TestSessionEnvironmentWithoutFile(t *testing.T) { func TestSessionEnvironmentWithoutFile(t *testing.T) {
env, err := NewEnvironment("") if env, err := NewEnvironment(""); env == nil {
if err != nil { t.Fatal("expected valid environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != 0 {
if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data)) t.Fatalf("expected empty environment, found %d elements", len(env.Data))
} }
t.Log("expected valid environment")
} }
func TestSessionEnvironmentWithInvalidFile(t *testing.T) { func TestSessionEnvironmentWithInvalidFile(t *testing.T) {
env, err := NewEnvironment("/idontexist") if env, err := NewEnvironment("/idontexist"); env == nil {
if err != nil { t.Fatal("expected valid environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != 0 {
if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data)) t.Fatalf("expected empty environment, found %d elements", len(env.Data))
} }
t.Log("expected valid environment")
} }
func TestSessionEnvironmentWithEmptyFile(t *testing.T) { func TestSessionEnvironmentWithEmptyFile(t *testing.T) {
setup(t, true, false) setup(t, true, false)
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) if env, err := NewEnvironment(testEnvFile); env == nil {
if err != nil { t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != 0 {
if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data)) t.Fatalf("expected empty environment, found %d elements", len(env.Data))
} }
t.Log("expected environment")
} }
func TestSessionEnvironmentWithDataFile(t *testing.T) { func TestSessionEnvironmentWithDataFile(t *testing.T) {
setup(t, true, true) setup(t, true, true)
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) if env, err := NewEnvironment(testEnvFile); env == nil {
if err != nil { t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != len(testEnvData) {
if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
} } else if !reflect.DeepEqual(env.Data, testEnvData) {
if !reflect.DeepEqual(env.Data, testEnvData) {
t.Fatalf("unexpected contents: %v", env.Data) t.Fatalf("unexpected contents: %v", env.Data)
} }
t.Log("expected environment")
} }
func TestSessionEnvironmentSaveWithError(t *testing.T) { func TestSessionEnvironmentSaveWithError(t *testing.T) {
setup(t, false, false) setup(t, false, false)
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) if env, err := NewEnvironment(testEnvFile); env == nil {
if err != nil { t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if err = env.Save("/lulz/nope"); err == nil {
if err = env.Save("/lulz/nope"); err == nil {
t.Fatal("expected error") t.Fatal("expected error")
} }
t.Log("expected environment")
} }
func TestSessionEnvironmentSave(t *testing.T) { func TestSessionEnvironmentSave(t *testing.T) {
@ -120,24 +110,24 @@ func TestSessionEnvironmentSave(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
t.Log("expected environment")
env.Data["new"] = "value" env.Data["new"] = "value"
if err = env.Save(testEnvFile); err != nil { if err = env.Save(testEnvFile); err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
env, err = NewEnvironment(testEnvFile) if env, err := NewEnvironment(testEnvFile); env == nil {
if err != nil { t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
t.Fatalf("unexpected contents: %v", env.Data) t.Fatalf("unexpected contents: %v", env.Data)
} }
t.Log("expected environment")
} }
func TestSessionEnvironmentHas(t *testing.T) { func TestSessionEnvironmentHas(t *testing.T) {
@ -145,13 +135,13 @@ func TestSessionEnvironmentHas(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != len(testEnvData) {
if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
} }
t.Log("expected environment")
for k := range testEnvData { for k := range testEnvData {
if !env.Has(k) { if !env.Has(k) {
@ -171,24 +161,19 @@ func TestSessionEnvironmentSet(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if old := env.Set("people", "ok"); old != "shit" {
old := env.Set("people", "ok")
if old != "shit" {
t.Fatalf("unexpected old value: %s", old) t.Fatalf("unexpected old value: %s", old)
} } else if env.Data["people"] != "ok" {
if env.Data["people"] != "ok" {
t.Fatalf("unexpected new value: %s", env.Data["people"]) t.Fatalf("unexpected new value: %s", env.Data["people"])
} } else if old := env.Set("newkey", "nk"); old != "" {
old = env.Set("newkey", "nk")
if old != "" {
t.Fatalf("unexpected old value: %s", old) t.Fatalf("unexpected old value: %s", old)
} } else if env.Data["newkey"] != "nk" {
if env.Data["newkey"] != "nk" {
t.Fatalf("unexpected new value: %s", env.Data["newkey"]) t.Fatalf("unexpected new value: %s", env.Data["newkey"])
} }
t.Log("expected environment")
} }
func TestSessionEnvironmentSetWithCallback(t *testing.T) { func TestSessionEnvironmentSetWithCallback(t *testing.T) {
@ -196,10 +181,11 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} }
t.Log("expected environment")
cbCalled := false cbCalled := false
old := env.WithCallback("people", "ok", func(newValue string) { old := env.WithCallback("people", "ok", func(newValue string) {
@ -213,8 +199,7 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
old = env.Set("people", "shitagain") old = env.Set("people", "shitagain")
if old != "ok" { if old != "ok" {
t.Fatalf("unexpected old value: %s", old) t.Fatalf("unexpected old value: %s", old)
} } else if !cbCalled {
if !cbCalled {
t.Fatal("callback has not been called") t.Fatal("callback has not been called")
} }
@ -230,27 +215,24 @@ func TestSessionEnvironmentGet(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != len(testEnvData) {
if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
} }
t.Log("expected environment")
for k, v := range testEnvData { for k, v := range testEnvData {
found, vv := env.Get(k) if found, vv := env.Get(k); !found {
if !found {
t.Fatalf("should have found %s", k) t.Fatalf("should have found %s", k)
} } else if v != vv {
if v != vv {
t.Fatalf("unexpected value found: %s", vv) t.Fatalf("unexpected value found: %s", vv)
} }
} }
for _, k := range []string{"these", "keys", "should", "not", "be", "found"} { for _, k := range []string{"these", "keys", "should", "not", "be", "found"} {
found, _ := env.Get(k) if found, _ := env.Get(k); found {
if found {
t.Fatalf("should not have found %s", k) t.Fatalf("should not have found %s", k)
} }
} }
@ -261,13 +243,13 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != len(testEnvData) {
if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
} }
t.Log("expected environment")
for k := range testEnvData { for k := range testEnvData {
if err, _ := env.GetInt(k); err == nil { if err, _ := env.GetInt(k); err == nil {
@ -276,11 +258,9 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
} }
env.Data["num"] = "1234" env.Data["num"] = "1234"
err, i := env.GetInt("num") if err, i := env.GetInt("num"); err != nil {
if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if i != 1234 {
if i != 1234 {
t.Fatalf("unexpected integer: %d", i) t.Fatalf("unexpected integer: %d", i)
} }
} }
@ -290,14 +270,13 @@ func TestSessionEnvironmentSorted(t *testing.T) {
defer teardown(t) defer teardown(t)
env, err := NewEnvironment(testEnvFile) env, err := NewEnvironment(testEnvFile)
if err != nil { if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err) t.Fatalf("unexpected error: %v", err)
} } else if len(env.Data) != len(testEnvData) {
if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data)) t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
} } else if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
t.Fatalf("unexpected sorted keys: %v", sorted) t.Fatalf("unexpected sorted keys: %v", sorted)
} }
t.Log("expected environment")
} }

3
session/events.go
View file

@ -118,8 +118,7 @@ func (p *EventPool) Add(tag string, data interface{}) {
func (p *EventPool) Log(level log.Verbosity, format string, args ...interface{}) { func (p *EventPool) Log(level log.Verbosity, format string, args ...interface{}) {
if level == log.DEBUG && !p.debug { if level == log.DEBUG && !p.debug {
return return
} } else if level < log.ERROR && p.silent {
if level < log.ERROR && p.silent {
return return
} }

44
session/module.go
View file

@ -61,11 +61,10 @@ func (m *SessionModule) Param(name string) *ModuleParam {
func (m SessionModule) ListParam(name string) (err error, values []string) { func (m SessionModule) ListParam(name string) (err error, values []string) {
values = make([]string, 0) values = make([]string, 0)
err, list := m.StringParam(name) list := ""
if err != nil { if err, list = m.StringParam(name); err != nil {
return return
} } else {
parts := strings.Split(list, ",") parts := strings.Split(list, ",")
for _, part := range parts { for _, part := range parts {
part = str.Trim(part) part = str.Trim(part)
@ -73,48 +72,50 @@ func (m SessionModule) ListParam(name string) (err error, values []string) {
values = append(values, part) values = append(values, part)
} }
} }
}
return return
} }
func (m SessionModule) StringParam(name string) (error, string) { func (m SessionModule) StringParam(name string) (error, string) {
p, found := m.params[name] if p, found := m.params[name]; found {
if found { if err, v := p.Get(m.Session); err != nil {
err, v := p.Get(m.Session)
if err != nil {
return err, "" return err, ""
} } else {
return nil, v.(string) return nil, v.(string)
} }
} else {
return fmt.Errorf("Parameter %s does not exist.", name), "" return fmt.Errorf("Parameter %s does not exist.", name), ""
} }
}
func (m SessionModule) IPParam(name string) (error, net.IP) { func (m SessionModule) IPParam(name string) (error, net.IP) {
err, v := m.StringParam(name) if err, v := m.StringParam(name); err != nil {
if err != nil {
return err, nil return err, nil
} } else {
return nil, net.ParseIP(v) return nil, net.ParseIP(v)
} }
}
func (m SessionModule) IntParam(name string) (error, int) { func (m SessionModule) IntParam(name string) (error, int) {
p, found := m.params[name] if p, found := m.params[name]; found {
if found { if err, v := p.Get(m.Session); err != nil {
err, v := p.Get(m.Session)
if err != nil {
return err, 0 return err, 0
} } else {
return nil, v.(int) return nil, v.(int)
} }
} else {
return fmt.Errorf("Parameter %s does not exist.", name), 0 return fmt.Errorf("Parameter %s does not exist.", name), 0
} }
}
func (m SessionModule) BoolParam(name string) (error, bool) { func (m SessionModule) BoolParam(name string) (error, bool) {
err, v := m.params[name].Get(m.Session) if err, v := m.params[name].Get(m.Session); err != nil {
if err != nil {
return err, false return err, false
} } else {
return nil, v.(bool) return nil, v.(bool)
} }
}
func (m *SessionModule) AddHandler(h ModuleHandler) { func (m *SessionModule) AddHandler(h ModuleHandler) {
m.handlers = append(m.handlers, h) m.handlers = append(m.handlers, h)
@ -136,9 +137,10 @@ func (m *SessionModule) SetRunning(running bool, cb func()) error {
if running == m.Running() { if running == m.Running() {
if m.Started { if m.Started {
return ErrAlreadyStarted return ErrAlreadyStarted
} } else {
return ErrAlreadyStopped return ErrAlreadyStopped
} }
}
m.StatusLock.Lock() m.StatusLock.Lock()
m.Started = running m.Started = running

22
session/module_param.go
View file

@ -64,19 +64,18 @@ func (p ModuleParam) Validate(value string) (error, interface{}) {
} }
} }
switch p.Type { if p.Type == STRING {
case STRING:
return nil, value return nil, value
case BOOL: } else if p.Type == BOOL {
lvalue := strings.ToLower(value) lvalue := strings.ToLower(value)
if lvalue == "true" { if lvalue == "true" {
return nil, true return nil, true
} } else if lvalue == "false" {
if lvalue == "false" {
return nil, false return nil, false
} } else {
return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil return fmt.Errorf("Can't typecast '%s' to boolean.", value), nil
case INT: }
} else if p.Type == INT {
i, err := strconv.Atoi(value) i, err := strconv.Atoi(value)
return err, i return err, i
} }
@ -91,14 +90,13 @@ const ParamRandomMAC = "<random mac>"
func (p ModuleParam) Get(s *Session) (error, interface{}) { func (p ModuleParam) Get(s *Session) (error, interface{}) {
_, v := s.Env.Get(p.Name) _, v := s.Env.Get(p.Name)
switch v { if v == ParamIfaceName {
case ParamIfaceName:
v = s.Interface.Name() v = s.Interface.Name()
case ParamIfaceAddress: } else if v == ParamIfaceAddress {
v = s.Interface.IpAddress v = s.Interface.IpAddress
case ParamSubnet: } else if v == ParamSubnet {
v = s.Interface.CIDR() v = s.Interface.CIDR()
case ParamRandomMAC: } else if v == ParamRandomMAC {
hw := make([]byte, 6) hw := make([]byte, 6)
rand.Read(hw) rand.Read(hw)
v = net.HardwareAddr(hw).String() v = net.HardwareAddr(hw).String()

14
session/session.go
View file

@ -119,11 +119,9 @@ func New() (*Session, error) {
} }
if *s.Options.CpuProfile != "" { if *s.Options.CpuProfile != "" {
f, err := os.Create(*s.Options.CpuProfile) if f, err := os.Create(*s.Options.CpuProfile); err != nil {
if err != nil {
return nil, err return nil, err
} } else if err := pprof.StartCPUProfile(f); err != nil {
if err := pprof.StartCPUProfile(f); err != nil {
return nil, err return nil, err
} }
} }
@ -279,11 +277,9 @@ func (s *Session) Start() error {
func (s *Session) Skip(ip net.IP) bool { func (s *Session) Skip(ip net.IP) bool {
if ip.IsLoopback() { if ip.IsLoopback() {
return true return true
} } else if ip.Equal(s.Interface.IP) {
if ip.Equal(s.Interface.IP) {
return true return true
} } else if ip.Equal(s.Gateway.IP) {
if ip.Equal(s.Gateway.IP) {
return true return true
} }
return false return false
@ -328,8 +324,10 @@ func parseCapletCommand(line string) (is bool, caplet *caplets.Caplet, argv []st
// check for any arguments // check for any arguments
if argc > 1 { if argc > 1 {
file = str.Trim(parts[0]) file = str.Trim(parts[0])
if argc >= 2 {
argv = parts[1:] argv = parts[1:]
} }
}
if err, cap := caplets.Load(file); err == nil { if err, cap := caplets.Load(file); err == nil {
return true, cap, argv return true, cap, argv

19
session/session_core_handlers.go
View file

@ -46,9 +46,11 @@ func (s *Session) generalHelp() {
pad = "%" + strconv.Itoa(maxLen) + "s" pad = "%" + strconv.Itoa(maxLen) + "s"
for _, m := range s.Modules { for _, m := range s.Modules {
status := tui.Red("not running") status := ""
if m.Running() { if m.Running() {
status = tui.Green("running") status = tui.Green("running")
} else {
status = tui.Red("not running")
} }
fmt.Printf(" "+tui.Yellow(pad)+" > %s\n", m.Name(), status) fmt.Printf(" "+tui.Yellow(pad)+" > %s\n", m.Name(), status)
} }
@ -63,11 +65,12 @@ func (s *Session) moduleHelp(filter string) error {
} }
fmt.Println() fmt.Println()
status := tui.Red("not running") status := ""
if m.Running() { if m.Running() {
status = tui.Green("running") status = tui.Green("running")
} else {
status = tui.Red("not running")
} }
fmt.Printf("%s (%s): %s\n\n", tui.Yellow(m.Name()), status, tui.Dim(m.Description())) fmt.Printf("%s (%s): %s\n\n", tui.Yellow(m.Name()), status, tui.Dim(m.Description()))
maxLen := 0 maxLen := 0
@ -162,12 +165,13 @@ func (s *Session) exitHandler(args []string, sess *Session) error {
} }
func (s *Session) sleepHandler(args []string, sess *Session) error { func (s *Session) sleepHandler(args []string, sess *Session) error {
secs, err := strconv.Atoi(args[0]) if secs, err := strconv.Atoi(args[0]); err == nil {
if err == nil {
time.Sleep(time.Duration(secs) * time.Second) time.Sleep(time.Duration(secs) * time.Second)
} return nil
} else {
return err return err
} }
}
func (s *Session) getHandler(args []string, sess *Session) error { func (s *Session) getHandler(args []string, sess *Session) error {
key := args[0] key := args[0]
@ -273,9 +277,10 @@ func (s *Session) aliasHandler(args []string, sess *Session) error {
if s.Lan.SetAliasFor(mac, alias) { if s.Lan.SetAliasFor(mac, alias) {
return nil return nil
} } else {
return fmt.Errorf("Could not find endpoint %s", mac) return fmt.Errorf("Could not find endpoint %s", mac)
} }
}
func (s *Session) addHandler(h CommandHandler, c *readline.PrefixCompleter) { func (s *Session) addHandler(h CommandHandler, c *readline.PrefixCompleter) {
h.Completer = c h.Completer = c

6
session/session_parse.go
View file

@ -74,11 +74,11 @@ func ParseCommands(line string) []string {
func (s *Session) parseEnvTokens(str string) (string, error) { func (s *Session) parseEnvTokens(str string) (string, error) {
for _, m := range reEnvVarCapture.FindAllString(str, -1) { for _, m := range reEnvVarCapture.FindAllString(str, -1) {
varName := strings.Trim(strings.Replace(m, "env.", "", -1), "{}") varName := strings.Trim(strings.Replace(m, "env.", "", -1), "{}")
found, value := s.Env.Get(varName) if found, value := s.Env.Get(varName); found {
if !found { str = strings.Replace(str, m, value, -1)
} else {
return "", fmt.Errorf("variable '%s' is not defined", varName) return "", fmt.Errorf("variable '%s' is not defined", varName)
} }
str = strings.Replace(str, m, value, -1)
} }
return str, nil return str, nil
} }