github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-08-19 21:13:18 -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 (
"bytes"
"github.com/evilsocket/islazy/fs"
"github.com/evilsocket/islazy/str"
"io"
"os"
"os/user"
"path/filepath"
"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 {
for _, n := range a {
if n == v {
@ -92,6 +132,30 @@ func sameStrings(a []string, b []string) bool {
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) {
var units = []struct {
exec string
@ -118,20 +182,16 @@ func TestCoreExec(t *testing.T) {
io.Copy(&buf, r)
os.Stdout = oldStdout
gotStdout := str.Trim(buf.String())
gotStdout := Trim(buf.String())
if gotOut != u.out {
t.Fatalf("expected output '%s', got '%s'", u.out, gotOut)
}
if u.err == "" && gotErr != nil {
} else if u.err == "" && gotErr != nil {
t.Fatalf("expected no error, got '%s'", gotErr)
}
if u.err != "" && gotErr == nil {
} else if u.err != "" && gotErr == nil {
t.Fatalf("expected error '%s', got none", u.err)
}
if u.err != "" && gotErr != nil && gotErr.Error() != u.err {
} else if u.err != "" && gotErr != nil && gotErr.Error() != u.err {
t.Fatalf("expected error '%s', got '%s'", u.err, gotErr)
}
if gotStdout != "" {
} else if gotStdout != "" {
t.Fatalf("expected empty stdout, got '%s'", gotStdout)
}
}
@ -148,7 +208,7 @@ func TestCoreExec(t *testing.T) {
io.Copy(&buf, r)
os.Stdout = oldStdout
gotStdout := str.Trim(buf.String())
gotStdout := Trim(buf.String())
if gotOut != u.out {
t.Fatalf("expected output '%s', got '%s'", u.out, gotOut)
} else if u.err == "" && gotErr != nil {
@ -176,9 +236,38 @@ func TestCoreExists(t *testing.T) {
}
for _, u := range units {
got := fs.Exists(u.what)
got := Exists(u.what)
if got != u.exists {
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,11 +43,11 @@ func Make(iface *network.Endpoint) FirewallManager {
func (f PfFirewall) sysCtlRead(param string) (string, error) {
if out, err := core.ExecSilent("sysctl", []string{param}); err != nil {
return "", err
}
if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param {
} else if m := sysCtlParser.FindStringSubmatch(out); len(m) == 3 && m[1] == param {
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) {
@ -60,11 +60,11 @@ func (f PfFirewall) sysCtlWrite(param string, value string) (string, error) {
// make sure we actually wrote the value
if out, err := f.sysCtlRead(param); err != nil {
return "", err
}
if out != value {
} else if out != value {
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 {
@ -87,8 +87,9 @@ func (f PfFirewall) enableParam(param string, enabled bool) error {
if _, err := f.sysCtlWrite(param, value); err != nil {
return err
} else {
return nil
}
return nil
}
func (f PfFirewall) EnableForwarding(enabled bool) error {

9
firewall/firewall_linux.go
View file

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

6
firewall/firewall_windows.go
View file

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

18
modules/any_proxy.go
View file

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

30
modules/api_rest.go
View file

@ -128,35 +128,25 @@ func (api *RestAPI) Configure() error {
if api.Running() {
return session.ErrAlreadyStarted
}
if err, ip = api.StringParam("api.rest.address"); err != nil {
} else if err, ip = api.StringParam("api.rest.address"); err != nil {
return err
}
if err, port = api.IntParam("api.rest.port"); err != nil {
} else if err, port = api.IntParam("api.rest.port"); err != nil {
return err
}
if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil {
} else if err, api.allowOrigin = api.StringParam("api.rest.alloworigin"); err != nil {
return err
}
if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
} else if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
return err
}
if api.certFile, err = fs.Expand(api.certFile); err != nil {
} else if api.certFile, err = fs.Expand(api.certFile); err != nil {
return err
}
if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
} else if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
return err
}
if api.keyFile, err = fs.Expand(api.keyFile); err != nil {
} else if api.keyFile, err = fs.Expand(api.keyFile); err != nil {
return err
}
if err, api.username = api.StringParam("api.rest.username"); err != nil {
} else if err, api.username = api.StringParam("api.rest.username"); err != nil {
return err
}
if err, api.password = api.StringParam("api.rest.password"); err != nil {
} else if err, api.password = api.StringParam("api.rest.password"); err != nil {
return err
}
if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil {
} else if err, api.useWebsocket = api.BoolParam("api.rest.websocket"); err != nil {
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
if subtle.ConstantTimeCompare([]byte(user), []byte(api.username)) != 1 {
return false
}
if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 {
} else if subtle.ConstantTimeCompare([]byte(pass), []byte(api.password)) != 1 {
return false
}
}
@ -185,12 +184,10 @@ func (api *RestAPI) sessionRoute(w http.ResponseWriter, r *http.Request) {
if !api.checkAuth(r) {
setAuthFailed(w, r)
return
}
if r.Method == "POST" {
} else if r.Method == "POST" {
api.runSessionCommand(w, r)
return
}
if r.Method != "GET" {
} else if r.Method != "GET" {
http.Error(w, "Bad Request", 400)
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 {
return err
}
if err, targets = p.StringParam("arp.spoof.targets"); err != nil {
} else if err, targets = p.StringParam("arp.spoof.targets"); err != nil {
return err
}
if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil {
} else if err, whitelist = p.StringParam("arp.spoof.whitelist"); err != nil {
return err
}
if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil {
} else if p.addresses, p.macs, err = network.ParseTargets(targets, p.Session.Lan.Aliases()); err != nil {
return err
}
if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil {
} else if p.wAddresses, p.wMacs, err = network.ParseTargets(whitelist, p.Session.Lan.Aliases()); err != nil {
return err
}
@ -240,12 +236,10 @@ func (p *ArpSpoofer) sendArp(saddr net.IP, smac net.HardwareAddr, check_running
for ip, mac := range targets {
if check_running && !p.Running() {
return
}
if p.isWhitelisted(ip, mac) {
} else if p.isWhitelisted(ip, mac) {
log.Debug("%s (%s) is whitelisted, skipping from spoofing loop.", ip, mac)
continue
}
if saddr.String() == ip {
} else if saddr.String() == ip {
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)
if !found || dev == nil {
return fmt.Errorf("BLE device with address %s not found.", mac)
}
if d.Running() {
} else if d.Running() {
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 {
log.Warning("Connected to %s but with error: %s", p.ID(), err)
return
}
if d.currDevice == nil {
} else if d.currDevice == nil {
// timed out
log.Warning("Connected to %s but after the timeout :(", p.ID())
return

3
modules/ble_recon_view.go
View file

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

18
modules/dns_spoof.go
View file

@ -89,23 +89,17 @@ func (s *DNSSpoofer) Configure() error {
if s.Running() {
return session.ErrAlreadyStarted
}
if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil {
} else if s.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, pcap.BlockForever); err != nil {
return err
}
if err = s.Handle.SetBPFFilter("udp"); err != nil {
} else if err = s.Handle.SetBPFFilter("udp"); err != nil {
return err
}
if err, s.All = s.BoolParam("dns.spoof.all"); err != nil {
} else if err, s.All = s.BoolParam("dns.spoof.all"); err != nil {
return err
}
if err, address = s.IPParam("dns.spoof.address"); err != nil {
} else if err, address = s.IPParam("dns.spoof.address"); err != nil {
return err
}
if err, domains = s.ListParam("dns.spoof.domains"); err != nil {
} else if err, domains = s.ListParam("dns.spoof.domains"); err != nil {
return err
}
if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil {
} else if err, hostsFile = s.StringParam("dns.spoof.hosts"); err != nil {
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 {
if s.dumpHttpResp {
return true
}
if strings.Contains(res.ContentType, "text/plain") {
} else if strings.Contains(res.ContentType, "text/plain") {
return true
}
if strings.Contains(res.ContentType, "application/json") {
} else if strings.Contains(res.ContentType, "application/json") {
return true
}
if strings.Contains(res.ContentType, "text/xml") {
} else if strings.Contains(res.ContentType, "text/xml") {
return true
}
// search for interesting headers
@ -93,8 +90,7 @@ func (s *EventsStream) dumpGZIP(body []byte) string {
reader, err := gzip.NewReader(buffer)
if err != nil {
return s.dumpRaw(body)
}
if _, err = uncompressed.ReadFrom(reader); err != nil {
} else if _, err = uncompressed.ReadFrom(reader); err != nil {
return s.dumpRaw(body)
}
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) {
if gps.Running() {
return session.ErrAlreadyStarted
}
if err, gps.serialPort = gps.StringParam("gps.device"); err != nil {
} else if err, gps.serialPort = gps.StringParam("gps.device"); err != nil {
return err
}
if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil {
} else if err, gps.baudRate = gps.IntParam("gps.baudrate"); err != nil {
return err
}

18
modules/http_proxy.go
View file

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

12
modules/http_proxy_base.go
View file

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

6
modules/http_proxy_base_cookietracker.go
View file

@ -24,12 +24,12 @@ func NewCookieTracker() *CookieTracker {
}
func (t *CookieTracker) domainOf(req *http.Request) string {
parsed, err := tld.Parse(req.Host)
if err != nil {
if parsed, err := tld.Parse(req.Host); err != nil {
log.Warning("Could not parse host %s: %s", req.Host, err)
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 {

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
p.logRequestAction(req, jsreq)
return jsreq.ToRequest(), nil
}
if jsres != nil {
} else if jsres != nil {
// a fake response has been returned by the script
p.logResponseAction(req, jsres)
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)
if err != nil {
return err, nil
}
if html := string(raw); strings.Contains(html, "</head>") {
} else if html := string(raw); strings.Contains(html, "</head>") {
log.Info("(%s) > injecting javascript (%d bytes) into %s (%d bytes) for %s",
tui.Green(p.Name),
len(p.jsHook),

5
modules/http_proxy_base_sslstriper.go
View file

@ -272,9 +272,10 @@ func (s *SSLStripper) isMaxRedirs(hostname string) bool {
// reset
delete(s.redirs, hostname)
return true
} else {
// increment
s.redirs[hostname]++
}
// increment
s.redirs[hostname]++
} else {
// start tracking redirections
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 {
// body was read
return true
}
if j.bodyClear {
} else if j.bodyClear {
// body was cleared manually
return true
}
if j.Body != "" {
} else if j.Body != "" {
// body was not read but just set
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 {
log.Error("%s", err)
return nil, nil
}
if jsreq.WasModified() {
} else if jsreq.WasModified() {
jsreq.UpdateHash()
return jsreq, nil
}
if jsres.WasModified() {
} else if jsres.WasModified() {
jsres.UpdateHash()
return nil, jsres
}
@ -91,13 +89,10 @@ func (s *HttpProxyScript) OnResponse(res *http.Response) (jsreq *JSRequest, jsre
func (s *HttpProxyScript) OnCommand(cmd string) bool {
if s.doOnCommand {
ret, err := s.Call("onCommand", cmd)
if err != nil {
if ret, err := s.Call("onCommand", cmd); err != nil {
log.Error("Error while executing onCommand callback: %+v", err)
return false
}
v, ok := ret.(bool)
if ok {
} else if v, ok := ret.(bool); ok {
return v
}
}

30
modules/https_proxy.go
View file

@ -98,35 +98,25 @@ func (p *HttpsProxy) Configure() error {
if p.Running() {
return session.ErrAlreadyStarted
}
if err, address = p.StringParam("https.proxy.address"); err != nil {
} else if err, address = p.StringParam("https.proxy.address"); err != nil {
return err
}
if err, proxyPort = p.IntParam("https.proxy.port"); err != nil {
} else if err, proxyPort = p.IntParam("https.proxy.port"); err != nil {
return err
}
if err, httpPort = p.IntParam("https.port"); err != nil {
} else if err, httpPort = p.IntParam("https.port"); err != nil {
return err
}
if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil {
} else if err, stripSSL = p.BoolParam("https.proxy.sslstrip"); err != nil {
return err
}
if err, certFile = p.StringParam("https.proxy.certificate"); err != nil {
} else if err, certFile = p.StringParam("https.proxy.certificate"); err != nil {
return err
}
if certFile, err = fs.Expand(certFile); err != nil {
} else if certFile, err = fs.Expand(certFile); err != nil {
return err
}
if err, keyFile = p.StringParam("https.proxy.key"); err != nil {
} else if err, keyFile = p.StringParam("https.proxy.key"); err != nil {
return err
}
if keyFile, err = fs.Expand(keyFile); err != nil {
} else if keyFile, err = fs.Expand(keyFile); err != nil {
return err
}
if err, scriptPath = p.StringParam("https.proxy.script"); err != nil {
} else if err, scriptPath = p.StringParam("https.proxy.script"); err != nil {
return err
}
if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil {
} else if err, jsToInject = p.StringParam("https.proxy.injectjs"); err != nil {
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 {
return err
}
if err, changeTo = mc.StringParam("mac.changer.address"); err != nil {
} else if err, changeTo = mc.StringParam("mac.changer.address"); err != nil {
return err
}
@ -106,11 +105,9 @@ func (mc *MacChanger) setMac(mac net.HardwareAddr) error {
func (mc *MacChanger) Start() error {
if mc.Running() {
return session.ErrAlreadyStarted
}
if err := mc.Configure(); err != nil {
} else if err := mc.Configure(); err != nil {
return err
}
if err := mc.setMac(mc.fakeMac); err != nil {
} else if err := mc.setMac(mc.fakeMac); err != nil {
return err
}

27
modules/mysql_server.go
View file

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

21
modules/net_probe.go
View file

@ -82,20 +82,17 @@ func (p *Prober) Configure() error {
var err error
if err, p.throttle = p.IntParam("net.probe.throttle"); err != nil {
return err
}
if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil {
} else if err, p.probes.NBNS = p.BoolParam("net.probe.nbns"); err != nil {
return err
}
if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil {
} else if err, p.probes.MDNS = p.BoolParam("net.probe.mdns"); err != nil {
return err
}
if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil {
} else if err, p.probes.UPNP = p.BoolParam("net.probe.upnp"); err != nil {
return err
}
if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil {
} else if err, p.probes.WSD = p.BoolParam("net.probe.wsd"); err != nil {
return err
} else {
log.Debug("Throttling packets of %d ms.", p.throttle)
}
log.Debug("Throttling packets of %d ms.", p.throttle)
return nil
}
@ -139,12 +136,10 @@ func (p *Prober) Start() error {
for _, ip := range addresses {
if !p.Running() {
return
}
if p.Session.Skip(ip) {
} else if p.Session.Skip(ip) {
log.Debug("skipping address %s from probing.", ip)
continue
}
if p.probes.NBNS {
} else if p.probes.NBNS {
p.sendProbeNBNS(from, from_hw, ip)
}
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 {
log.Error("error while sending mdns probe: %v", err)
return
}
if err := p.Session.Queue.Send(raw); err != nil {
} else if err := p.Session.Queue.Send(raw); err != nil {
log.Error("error sending mdns packet: %s", err)
} else {
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 {
return [][]string{row}
}
if e.Meta.Empty() {
} else if e.Meta.Empty() {
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()
}
switch by {
case "seen":
if by == "seen" {
sort.Sort(BySeenSorter(targets))
case "sent":
} else if by == "sent" {
sort.Sort(BySentSorter(targets))
case "rcvd":
} else if by == "rcvd" {
sort.Sort(ByRcvdSorter(targets))
default:
} else {
sort.Sort(ByAddressSorter(targets))
}
@ -141,11 +139,9 @@ func (d *Discovery) Show(by string, expr string) (err error) {
}
hasMeta := false
err, showMeta := d.BoolParam("net.show.meta")
if err != nil {
if err, showMeta := d.BoolParam("net.show.meta"); err != nil {
return err
}
if showMeta {
} else if showMeta {
for _, t := range targets {
if !t.Meta.Empty() {
hasMeta = true

3
modules/net_sniff.go
View file

@ -112,8 +112,7 @@ func (s *Sniffer) Configure() error {
if s.Running() {
return session.ErrAlreadyStarted
}
if err, s.Ctx = s.GetContext(); err != nil {
} else if err, s.Ctx = s.GetContext(); err != nil {
if s.Ctx != nil {
s.Ctx.Close()
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) {
return
}
if ntlmParser(ip, pkt, tcp) {
} else if ntlmParser(ip, pkt, tcp) {
return
}
if httpParser(ip, pkt, tcp) {
} else if httpParser(ip, pkt, tcp) {
return
}
if verbose {
} else if verbose {
NewSnifferEvent(
pkt.Metadata().Timestamp,
"tcp",
@ -49,17 +46,13 @@ func udpParser(ip *layers.IPv4, pkt gopacket.Packet, verbose bool) {
if dnsParser(ip, pkt, udp) {
return
}
if mdnsParser(ip, pkt, udp) {
} else if mdnsParser(ip, pkt, udp) {
return
}
if krb5Parser(ip, pkt, udp) {
} else if krb5Parser(ip, pkt, udp) {
return
}
if upnpParser(ip, pkt, udp) {
} else if upnpParser(ip, pkt, udp) {
return
}
if verbose {
} else if verbose {
NewSnifferEvent(
pkt.Metadata().Timestamp,
"udp",
@ -125,8 +118,7 @@ func mainParser(pkt gopacket.Packet, verbose bool) bool {
unkParser(ip, pkt, verbose)
}
return true
}
if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok {
} else if ok, radiotap, dot11 := packets.Dot11Parse(pkt); ok {
// are we sniffing in monitor mode?
dot11Parser(radiotap, dot11, pkt, verbose)
return true

3
modules/net_sniff_views.go
View file

@ -13,8 +13,7 @@ import (
func vIP(ip net.IP) string {
if session.I.Interface.IP.Equal(ip) {
return tui.Dim("local")
}
if session.I.Gateway.IP.Equal(ip) {
} else if session.I.Gateway.IP.Equal(ip) {
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 {
return
}
if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil {
} else if err, pp.chainName = pp.StringParam("packet.proxy.chain"); err != nil {
return
}
if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil {
} else if err, pp.rule = pp.StringParam("packet.proxy.rule"); err != nil {
return
}
if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil {
} else if err, pp.pluginPath = pp.StringParam("packet.proxy.plugin"); err != nil {
return
}
if pp.pluginPath == "" {
return fmt.Errorf("The parameter %s can not be empty.", tui.Bold("packet.proxy.plugin"))
}
if !fs.Exists(pp.pluginPath) {
} else if !fs.Exists(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 {
return
}
if sym, err = pp.plugin.Lookup("OnPacket"); err != nil {
} else if sym, err = pp.plugin.Lookup("OnPacket"); err != nil {
return
}
if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok {
} else if pp.queueCb, ok = sym.(func(*nfqueue.Payload) int); !ok {
return fmt.Errorf("Symbol OnPacket is not a valid callback function.")
}
pp.queue = new(nfqueue.Queue)
if err = pp.queue.SetCallback(dummyCallback); err != nil {
return
}
if err = pp.queue.Init(); err != nil {
} else if err = pp.queue.Init(); err != nil {
return
}
if err = pp.queue.Unbind(syscall.AF_INET); err != nil {
} else if err = pp.queue.Unbind(syscall.AF_INET); err != nil {
return
}
if err = pp.queue.Bind(syscall.AF_INET); err != nil {
} else if err = pp.queue.Bind(syscall.AF_INET); err != nil {
return
}
if err = pp.queue.CreateQueue(pp.queueNum); err != nil {
} else if err = pp.queue.CreateQueue(pp.queueNum); err != nil {
return
}
if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil {
} else if err = pp.queue.SetMode(nfqueue.NFQNL_COPY_PACKET); err != nil {
return
}
if err = pp.runRule(true); err != nil {
} else if err = pp.runRule(true); err != nil {
return
}

33
modules/tcp_proxy.go
View file

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

6
modules/ticker.go
View file

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

28
modules/wifi.go
View file

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

15
modules/wifi_ap.go
View file

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

53
modules/wifi_show.go
View file

@ -84,29 +84,30 @@ func (w *WiFiModule) getRow(station *network.Station) ([]string, bool) {
recvd,
seen,
}, include
}
// this is ugly, but necessary in order to have this
// method handle both access point and clients
// transparently
clients := ""
if ap, found := w.Session.WiFi.Get(station.HwAddress); found {
if ap.NumClients() > 0 {
clients = strconv.Itoa(ap.NumClients())
} else {
// this is ugly, but necessary in order to have this
// method handle both access point and clients
// transparently
clients := ""
if ap, found := w.Session.WiFi.Get(station.HwAddress); found {
if ap.NumClients() > 0 {
clients = strconv.Itoa(ap.NumClients())
}
}
}
return []string{
fmt.Sprintf("%d dBm", station.RSSI),
bssid,
ssid,
/* station.Vendor, */
encryption,
strconv.Itoa(station.Channel()),
clients,
sent,
recvd,
seen,
}, include
return []string{
fmt.Sprintf("%d dBm", station.RSSI),
bssid,
ssid,
/* station.Vendor, */
encryption,
strconv.Itoa(station.Channel()),
clients,
sent,
recvd,
seen,
}, include
}
}
func (w *WiFiModule) Show(by string) error {
@ -122,14 +123,14 @@ func (w *WiFiModule) Show(by string) error {
} else {
stations = w.Session.WiFi.Stations()
}
switch by {
case "seen":
if by == "seen" {
sort.Sort(ByWiFiSeenSorter(stations))
case "essid":
} else if by == "essid" {
sort.Sort(ByEssidSorter(stations))
case "channel":
} else if by == "channel" {
sort.Sort(ByChannelSorter(stations))
default:
} else {
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.+)?",
"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 {
mac, err := parseMAC(args)
if err != nil {
if mac, err := parseMAC(args); err != nil {
return err
} else {
return w.wolETH(mac)
}
return w.wolETH(mac)
}))
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).",
func(args []string) error {
mac, err := parseMAC(args)
if err != nil {
if mac, err := parseMAC(args); err != nil {
return err
} else {
return w.wolUDP(mac)
}
return w.wolUDP(mac)
}))
return w
@ -58,8 +58,9 @@ func parseMAC(args []string) (string, error) {
if tmp != "" {
if !reMAC.MatchString(tmp) {
return "", fmt.Errorf("%s is not a valid MAC address.", tmp)
} else {
mac = tmp
}
mac = tmp
}
}

17
network/lan_endpoint.go
View file

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

15
network/net_gateway.go
View file

@ -31,14 +31,15 @@ func FindGateway(iface *Endpoint) (*Endpoint, error) {
if gateway == iface.IpAddress {
Debug("gateway is the interface")
return iface, nil
} else {
// we have the address, now we need its mac
mac, err := ArpLookup(ifName, gateway, false)
if err != nil {
return nil, err
}
Debug("gateway is %s[%s]", gateway, mac)
return NewEndpoint(gateway, mac), nil
}
// we have the address, now we need its mac
mac, err := ArpLookup(ifName, gateway, false)
if err != nil {
return nil, err
}
Debug("gateway is %s[%s]", gateway, mac)
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)})
if err != nil {
return err
}
if out != "" {
} else if 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)
if err != nil {
return freqs, err
}
if output != "" {
} else if output != "" {
scanner := bufio.NewScanner(strings.NewReader(output))
for scanner.Scan() {
line := scanner.Text()

12
network/wifi.go
View file

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

5
network/wifi_station.go
View file

@ -19,10 +19,11 @@ func cleanESSID(essid string) string {
res := ""
for _, c := range essid {
if !strconv.IsPrint(c) {
if strconv.IsPrint(c) {
res += string(c)
} else {
break
}
res += string(c)
}
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
raw, found := to.Options[dhcp6.OptionClientID]
if !found || len(raw) < 1 {
if raw, found := to.Options[dhcp6.OptionClientID]; !found || len(raw) < 1 {
return ErrNoCID, p
} else {
rawCID = raw[0]
}
rawCID = raw[0]
p.Options.AddRaw(dhcp6.OptionClientID, rawCID)
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 {
q.TrackError()
return err
} else {
q.TrackSent(uint64(len(raw)))
}
q.TrackSent(uint64(len(raw)))
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)
if len(result) == h.Parser.NumSubexp()+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"
shouldParse := "simple 123"
parsed, _ := c.Parse(shouldNotParse)
if parsed {
if parsed, _ := c.Parse(shouldNotParse); parsed {
t.Fatalf("should not parse '%s'", shouldNotParse)
}
parsed, parts := c.Parse(shouldParse)
if !parsed {
} else if parsed, parts := c.Parse(shouldParse); !parsed {
t.Fatalf("should parse '%s'", shouldParse)
}
if !sameStrings(parts, u.parsed) {
} else if !sameStrings(parts, u.parsed) {
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) {
if found, value := env.Get(name); found {
i, err := strconv.Atoi(value)
if err != nil {
if i, err := strconv.Atoi(value); err == nil {
return nil, i
} else {
return err, 0
}
return nil, i
}
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)
if envFile {
fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666)
if err != nil {
if fp, err := os.OpenFile(testEnvFile, os.O_RDONLY|os.O_CREATE, 0666); err == nil {
fp.Close()
} else {
panic(err)
}
fp.Close()
}
if envFileData {
raw, err := json.Marshal(testEnvData)
if err != nil {
if raw, err := json.Marshal(testEnvData); err != nil {
panic(err)
}
err = ioutil.WriteFile(testEnvFile, raw, 0755)
if err != nil {
} else if err = ioutil.WriteFile(testEnvFile, raw, 0755); err != nil {
panic(err)
}
}
@ -48,71 +45,64 @@ func teardown(t testing.TB) {
}
func TestSessionEnvironmentWithoutFile(t *testing.T) {
env, err := NewEnvironment("")
if err != nil {
if env, err := NewEnvironment(""); env == nil {
t.Fatal("expected valid environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != 0 {
} else if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data))
}
t.Log("expected valid environment")
}
func TestSessionEnvironmentWithInvalidFile(t *testing.T) {
env, err := NewEnvironment("/idontexist")
if err != nil {
if env, err := NewEnvironment("/idontexist"); env == nil {
t.Fatal("expected valid environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != 0 {
} else if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data))
}
t.Log("expected valid environment")
}
func TestSessionEnvironmentWithEmptyFile(t *testing.T) {
setup(t, true, false)
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env, err := NewEnvironment(testEnvFile); env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != 0 {
} else if len(env.Data) != 0 {
t.Fatalf("expected empty environment, found %d elements", len(env.Data))
}
t.Log("expected environment")
}
func TestSessionEnvironmentWithDataFile(t *testing.T) {
setup(t, true, true)
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env, err := NewEnvironment(testEnvFile); env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != len(testEnvData) {
} else if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
}
if !reflect.DeepEqual(env.Data, testEnvData) {
} else if !reflect.DeepEqual(env.Data, testEnvData) {
t.Fatalf("unexpected contents: %v", env.Data)
}
t.Log("expected environment")
}
func TestSessionEnvironmentSaveWithError(t *testing.T) {
setup(t, false, false)
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env, err := NewEnvironment(testEnvFile); env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if err = env.Save("/lulz/nope"); err == nil {
} else if err = env.Save("/lulz/nope"); err == nil {
t.Fatal("expected error")
}
t.Log("expected environment")
}
func TestSessionEnvironmentSave(t *testing.T) {
@ -120,24 +110,24 @@ func TestSessionEnvironmentSave(t *testing.T) {
defer teardown(t)
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.Log("expected environment")
env.Data["new"] = "value"
if err = env.Save(testEnvFile); err != nil {
t.Fatalf("unexpected error: %v", err)
}
env, err = NewEnvironment(testEnvFile)
if err != nil {
if env, err := NewEnvironment(testEnvFile); env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
} else if !reflect.DeepEqual(env.Data, map[string]string{"new": "value"}) {
t.Fatalf("unexpected contents: %v", env.Data)
}
t.Log("expected environment")
}
func TestSessionEnvironmentHas(t *testing.T) {
@ -145,13 +135,13 @@ func TestSessionEnvironmentHas(t *testing.T) {
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != len(testEnvData) {
} else if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
}
t.Log("expected environment")
for k := range testEnvData {
if !env.Has(k) {
@ -171,24 +161,19 @@ func TestSessionEnvironmentSet(t *testing.T) {
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
old := env.Set("people", "ok")
if old != "shit" {
} else if old := env.Set("people", "ok"); old != "shit" {
t.Fatalf("unexpected old value: %s", old)
}
if env.Data["people"] != "ok" {
} else if env.Data["people"] != "ok" {
t.Fatalf("unexpected new value: %s", env.Data["people"])
}
old = env.Set("newkey", "nk")
if old != "" {
} else if old := env.Set("newkey", "nk"); old != "" {
t.Fatalf("unexpected old value: %s", old)
}
if env.Data["newkey"] != "nk" {
} else if env.Data["newkey"] != "nk" {
t.Fatalf("unexpected new value: %s", env.Data["newkey"])
}
t.Log("expected environment")
}
func TestSessionEnvironmentSetWithCallback(t *testing.T) {
@ -196,10 +181,11 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
defer teardown(t)
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.Log("expected environment")
cbCalled := false
old := env.WithCallback("people", "ok", func(newValue string) {
@ -213,8 +199,7 @@ func TestSessionEnvironmentSetWithCallback(t *testing.T) {
old = env.Set("people", "shitagain")
if old != "ok" {
t.Fatalf("unexpected old value: %s", old)
}
if !cbCalled {
} else if !cbCalled {
t.Fatal("callback has not been called")
}
@ -230,27 +215,24 @@ func TestSessionEnvironmentGet(t *testing.T) {
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != len(testEnvData) {
} else if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
}
t.Log("expected environment")
for k, v := range testEnvData {
found, vv := env.Get(k)
if !found {
if found, vv := env.Get(k); !found {
t.Fatalf("should have found %s", k)
}
if v != vv {
} else if v != vv {
t.Fatalf("unexpected value found: %s", vv)
}
}
for _, k := range []string{"these", "keys", "should", "not", "be", "found"} {
found, _ := env.Get(k)
if found {
if found, _ := env.Get(k); found {
t.Fatalf("should not have found %s", k)
}
}
@ -261,13 +243,13 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != len(testEnvData) {
} else if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
}
t.Log("expected environment")
for k := range testEnvData {
if err, _ := env.GetInt(k); err == nil {
@ -276,11 +258,9 @@ func TestSessionEnvironmentGetInt(t *testing.T) {
}
env.Data["num"] = "1234"
err, i := env.GetInt("num")
if err != nil {
if err, i := env.GetInt("num"); err != nil {
t.Fatalf("unexpected error: %v", err)
}
if i != 1234 {
} else if i != 1234 {
t.Fatalf("unexpected integer: %d", i)
}
}
@ -290,14 +270,13 @@ func TestSessionEnvironmentSorted(t *testing.T) {
defer teardown(t)
env, err := NewEnvironment(testEnvFile)
if err != nil {
if env == nil {
t.Fatal("expected environment")
} else if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(env.Data) != len(testEnvData) {
} else if len(env.Data) != len(testEnvData) {
t.Fatalf("expected %d, found %d", len(testEnvData), len(env.Data))
}
if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
} else if sorted := env.Sorted(); !reflect.DeepEqual(sorted, testEnvSorted) {
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{}) {
if level == log.DEBUG && !p.debug {
return
}
if level < log.ERROR && p.silent {
} else if level < log.ERROR && p.silent {
return
}

58
session/module.go
View file

@ -61,59 +61,60 @@ func (m *SessionModule) Param(name string) *ModuleParam {
func (m SessionModule) ListParam(name string) (err error, values []string) {
values = make([]string, 0)
err, list := m.StringParam(name)
if err != nil {
list := ""
if err, list = m.StringParam(name); err != nil {
return
}
parts := strings.Split(list, ",")
for _, part := range parts {
part = str.Trim(part)
if part != "" {
values = append(values, part)
} else {
parts := strings.Split(list, ",")
for _, part := range parts {
part = str.Trim(part)
if part != "" {
values = append(values, part)
}
}
}
return
}
func (m SessionModule) StringParam(name string) (error, string) {
p, found := m.params[name]
if found {
err, v := p.Get(m.Session)
if err != nil {
if p, found := m.params[name]; found {
if err, v := p.Get(m.Session); err != nil {
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) {
err, v := m.StringParam(name)
if err != nil {
if err, v := m.StringParam(name); err != nil {
return err, nil
} else {
return nil, net.ParseIP(v)
}
return nil, net.ParseIP(v)
}
func (m SessionModule) IntParam(name string) (error, int) {
p, found := m.params[name]
if found {
err, v := p.Get(m.Session)
if err != nil {
if p, found := m.params[name]; found {
if err, v := p.Get(m.Session); err != nil {
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) {
err, v := m.params[name].Get(m.Session)
if err != nil {
if err, v := m.params[name].Get(m.Session); err != nil {
return err, false
} else {
return nil, v.(bool)
}
return nil, v.(bool)
}
func (m *SessionModule) AddHandler(h ModuleHandler) {
@ -136,8 +137,9 @@ func (m *SessionModule) SetRunning(running bool, cb func()) error {
if running == m.Running() {
if m.Started {
return ErrAlreadyStarted
} else {
return ErrAlreadyStopped
}
return ErrAlreadyStopped
}
m.StatusLock.Lock()

22
session/module_param.go
View file

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

16
session/session.go
View file

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

19
session/session_core_handlers.go
View file

@ -46,9 +46,11 @@ func (s *Session) generalHelp() {
pad = "%" + strconv.Itoa(maxLen) + "s"
for _, m := range s.Modules {
status := tui.Red("not running")
status := ""
if m.Running() {
status = tui.Green("running")
} else {
status = tui.Red("not running")
}
fmt.Printf(" "+tui.Yellow(pad)+" > %s\n", m.Name(), status)
}
@ -63,11 +65,12 @@ func (s *Session) moduleHelp(filter string) error {
}
fmt.Println()
status := tui.Red("not running")
status := ""
if m.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()))
maxLen := 0
@ -162,11 +165,12 @@ func (s *Session) exitHandler(args []string, sess *Session) error {
}
func (s *Session) sleepHandler(args []string, sess *Session) error {
secs, err := strconv.Atoi(args[0])
if err == nil {
if secs, err := strconv.Atoi(args[0]); err == nil {
time.Sleep(time.Duration(secs) * time.Second)
return nil
} else {
return err
}
return err
}
func (s *Session) getHandler(args []string, sess *Session) error {
@ -273,8 +277,9 @@ func (s *Session) aliasHandler(args []string, sess *Session) error {
if s.Lan.SetAliasFor(mac, alias) {
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) {

6
session/session_parse.go
View file

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