refact: refactored module parameters api

modules/api_rest.go

@@ -25,12 +25,10 @@ func NewRestAPI(s *session.Session) *RestAPI {
 	api := &RestAPI{
 		SessionModule: session.NewSessionModule("api.rest", s),
 		server:        &http.Server{},
-		username:      "",
-		password:      "",
 	}
 
 	api.AddParam(session.NewStringParameter("api.rest.address",
-		"<interface address>",
+		session.ParamIfaceAddress,
 		`^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$`,
 		"Address to bind the API REST server to."))
 
@@ -95,69 +93,41 @@ func (api *RestAPI) Author() string {
 	return "Simone Margaritelli <evilsocket@protonmail.com>"
 }
 
-func (api *RestAPI) OnSessionStarted(s *session.Session) {
+func (api *RestAPI) Configure() error {
-	// refresh the address after session has been created
+	var err error
-	s.Env.Set("api.rest.address", s.Interface.IpAddress)
-}
-
-func (api *RestAPI) OnSessionEnded(s *session.Session) {
-	if api.Running() {
-		api.Stop()
-	}
-}
-
-func (api *RestAPI) configure() error {
 	var address string
 	var port int
 
-	if err, v := api.Param("api.rest.address").Get(api.Session); err != nil {
+	if err, address = api.StringParam("api.rest.addr"); err != nil {
+		return err
+	} else if err, port = api.IntParam("api.rest.port"); err != nil {
 		return err
 	} else {
-		address = v.(string)
+		api.server.Addr = fmt.Sprintf("%s:%d", address, port)
 	}
 
-	if err, v := api.Param("api.rest.port").Get(api.Session); err != nil {
+	if err, api.certFile = api.StringParam("api.rest.certificate"); err != nil {
+		return err
+	} else if api.certFile, err = core.ExpandPath(api.certFile); err != nil {
 		return err
-	} else {
-		port = v.(int)
 	}
 
-	api.server.Addr = fmt.Sprintf("%s:%d", address, port)
+	if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
-
+		return err
-	if err, v := api.Param("api.rest.certificate").Get(api.Session); err != nil {
+	} else if api.keyFile, err = core.ExpandPath(api.keyFile); err != nil {
 		return err
-	} else {
-		api.certFile = v.(string)
-		if api.certFile, err = core.ExpandPath(api.certFile); err != nil {
-			return err
-		}
 	}
 
-	if err, v := api.Param("api.rest.key").Get(api.Session); err != nil {
+	if err, api.username = api.StringParam("api.rest.username"); err != nil {
 		return err
-	} else {
+	} else if api.username == "" {
-		api.keyFile = v.(string)
+		return fmt.Errorf("api.rest.username is empty.")
-		if api.keyFile, err = core.ExpandPath(api.keyFile); err != nil {
-			return err
-		}
 	}
 
-	if err, v := api.Param("api.rest.username").Get(api.Session); err != nil {
+	if err, api.password = api.StringParam("api.rest.password"); err != nil {
 		return err
-	} else {
+	} else if api.password == "" {
-		api.username = v.(string)
+		return fmt.Errorf("api.rest.password is empty.")
-		if api.username == "" {
-			return fmt.Errorf("api.rest.username is empty.")
-		}
-	}
-
-	if err, v := api.Param("api.rest.password").Get(api.Session); err != nil {
-		return err
-	} else {
-		api.password = v.(string)
-		if api.password == "" {
-			return fmt.Errorf("api.rest.password is empty.")
-		}
 	}
 
 	if core.Exists(api.certFile) == false || core.Exists(api.keyFile) == false {
@@ -175,7 +145,7 @@ func (api *RestAPI) configure() error {
 }
 
 func (api *RestAPI) Start() error {
-	if err := api.configure(); err != nil {
+	if err := api.Configure(); err != nil {
 		return err
 	}
 

modules/arp_spoof.go

@@ -15,16 +15,16 @@ import (
 
 type ArpSpoofer struct {
 	session.SessionModule
-	Done chan bool
+	done chan bool
 }
 
 func NewArpSpoofer(s *session.Session) *ArpSpoofer {
 	p := &ArpSpoofer{
 		SessionModule: session.NewSessionModule("arp.spoof", s),
-		Done:          make(chan bool),
+		done:          make(chan bool),
 	}
 
-	p.AddParam(session.NewStringParameter("arp.spoof.targets", "<entire subnet>", "", "IP addresses to spoof."))
+	p.AddParam(session.NewStringParameter("arp.spoof.targets", session.ParamSubnet, "", "IP addresses to spoof."))
 
 	p.AddHandler(session.NewModuleHandler("arp.spoof on", "",
 		"Start ARP spoofer.",
@@ -41,17 +41,6 @@ func NewArpSpoofer(s *session.Session) *ArpSpoofer {
 	return p
 }
 
-func (p *ArpSpoofer) OnSessionStarted(s *session.Session) {
-	// refresh the subnet after session has been created
-	s.Env.Set("arp.spoof.targets", s.Interface.CIDR())
-}
-
-func (p *ArpSpoofer) OnSessionEnded(s *session.Session) {
-	if p.Running() {
-		p.Stop()
-	}
-}
-
 func (p ArpSpoofer) Name() string {
 	return "arp.spoof"
 }
@@ -164,12 +153,11 @@ func (p *ArpSpoofer) unSpoof() error {
 
 func (p *ArpSpoofer) Start() error {
 	if p.Running() == false {
+		var err error
 		var targets string
 
-		if err, v := p.Param("arp.spoof.targets").Get(p.Session); err != nil {
+		if err, targets = p.StringParam("arp.spoof.targets"); err != nil {
 			return err
-		} else {
-			targets = v.(string)
 		}
 
 		list, err := iprange.Parse(targets)
@@ -192,7 +180,7 @@ func (p *ArpSpoofer) Start() error {
 				time.Sleep(1 * time.Second)
 			}
 
-			p.Done <- true
+			p.done <- true
 		}()
 
 		return nil
@@ -207,7 +195,7 @@ func (p *ArpSpoofer) Stop() error {
 
 		log.Info("Waiting for ARP spoofer to stop ...")
 
-		<-p.Done
+		<-p.done
 
 		p.unSpoof()
 

modules/events_stream.go

@@ -60,12 +60,11 @@ func (s EventsStream) Author() string {
 
 func (s *EventsStream) Start() error {
 	if s.Running() == false {
-		filter := ""
+		var err error
+		var filter string
 
-		if err, v := s.Param("events.stream.filter").Get(s.Session); err != nil {
+		if err, filter = s.StringParam("events.stream.filter"); err != nil {
 			return err
-		} else {
-			filter = v.(string)
 		}
 
 		s.SetRunning(true)
@@ -108,9 +107,3 @@ func (s *EventsStream) Stop() error {
 	}
 	return fmt.Errorf("Events stream already stopped.")
 }
-
-func (s *EventsStream) OnSessionEnded(sess *session.Session) {
-	if s.Running() {
-		s.Stop()
-	}
-}

modules/http_proxy.go

@@ -52,7 +52,7 @@ func NewHttpProxy(s *session.Session) *HttpProxy {
 		"HTTP port to redirect when the proxy is activated."))
 
 	p.AddParam(session.NewStringParameter("http.proxy.address",
-		"<interface address>",
+		session.ParamIfaceAddress,
 		`^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$`,
 		"Address to bind the HTTP proxy to."))
 
@@ -126,53 +126,35 @@ func (p *HttpProxy) Author() string {
 	return "Simone Margaritelli <evilsocket@protonmail.com>"
 }
 
-func (p *HttpProxy) OnSessionStarted(s *session.Session) {
-	// refresh the address after session has been created
-	s.Env.Set("http.proxy.address", s.Interface.IpAddress)
-}
-
-func (p *HttpProxy) OnSessionEnded(s *session.Session) {
-	if p.Running() {
-		p.Stop()
-	}
-}
-
 func (p *HttpProxy) Start() error {
+	var err error
 	var http_port int
 	var proxy_port int
+	var scriptPath string
 
 	if p.Running() == true {
 		return fmt.Errorf("HTTP proxy already started.")
 	}
 
-	if err, v := p.Param("http.proxy.address").Get(p.Session); err != nil {
+	if err, p.address = p.StringParam("http.proxy.address"); err != nil {
 		return err
-	} else {
-		p.address = v.(string)
 	}
 
-	if err, v := p.Param("http.proxy.port").Get(p.Session); err != nil {
+	if err, proxy_port = p.IntParam("http.proxy.port"); err != nil {
 		return err
-	} else {
-		proxy_port = v.(int)
 	}
 
-	if err, v := p.Param("http.port").Get(p.Session); err != nil {
+	if err, http_port = p.IntParam("http.port"); err != nil {
 		return err
-	} else {
-		http_port = v.(int)
 	}
 
-	if err, v := p.Param("http.proxy.script").Get(p.Session); err != nil {
+	if err, scriptPath = p.StringParam("http.proxy.script"); err != nil {
 		return err
-	} else {
+	} else if scriptPath != "" {
-		scriptPath := v.(string)
+		if err, p.script = LoadProxyScript(scriptPath, p.Session); err != nil {
-		if scriptPath != "" {
+			return err
-			if err, p.script = LoadProxyScript(scriptPath, p.Session); err != nil {
+		} else {
-				return err
+			log.Debug("Proxy script %s loaded.", scriptPath)
-			} else {
-				log.Debug("Proxy script %s loaded.", scriptPath)
-			}
 		}
 	}
 

modules/http_server.go

@@ -13,14 +13,12 @@ import (
 type HttpServer struct {
 	session.SessionModule
 	server *http.Server
-	path   string
 }
 
 func NewHttpServer(s *session.Session) *HttpServer {
 	httpd := &HttpServer{
 		SessionModule: session.NewSessionModule("http.server", s),
 		server:        &http.Server{},
-		path:          ".",
 	}
 
 	httpd.AddParam(session.NewStringParameter("http.server.path",
@@ -29,7 +27,7 @@ func NewHttpServer(s *session.Session) *HttpServer {
 		"Server folder."))
 
 	httpd.AddParam(session.NewStringParameter("http.server.address",
-		"<interface address>",
+		session.ParamIfaceAddress,
 		`^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$`,
 		"Address to bind the http server to."))
 
@@ -64,39 +62,24 @@ func (httpd *HttpServer) Author() string {
 	return "Simone Margaritelli <evilsocket@protonmail.com>"
 }
 
-func (httpd *HttpServer) OnSessionStarted(s *session.Session) {
+func (httpd *HttpServer) Configure() error {
-	// refresh the address after session has been created
+	var err error
-	s.Env.Set("http.server.address", s.Interface.IpAddress)
+	var path string
-}
-
-func (httpd *HttpServer) OnSessionEnded(s *session.Session) {
-	if httpd.Running() {
-		httpd.Stop()
-	}
-}
-
-func (httpd *HttpServer) configure() error {
 	var address string
 	var port int
 
-	if err, v := httpd.Param("http.server.path").Get(httpd.Session); err != nil {
+	if err, path = httpd.StringParam("http.server.path"); err != nil {
 		return err
-	} else {
-		httpd.path = v.(string)
 	}
 
-	http.Handle("/", http.FileServer(http.Dir(httpd.path)))
+	http.Handle("/", http.FileServer(http.Dir(path)))
 
-	if err, v := httpd.Param("http.server.address").Get(httpd.Session); err != nil {
+	if err, address = httpd.StringParam("http.server.addr"); err != nil {
 		return err
-	} else {
-		address = v.(string)
 	}
 
-	if err, v := httpd.Param("http.server.port").Get(httpd.Session); err != nil {
+	if err, port = httpd.IntParam("http.server.port"); err != nil {
 		return err
-	} else {
-		port = v.(int)
 	}
 
 	httpd.server.Addr = fmt.Sprintf("%s:%d", address, port)
@@ -105,7 +88,7 @@ func (httpd *HttpServer) configure() error {
 }
 
 func (httpd *HttpServer) Start() error {
-	if err := httpd.configure(); err != nil {
+	if err := httpd.Configure(); err != nil {
 		return err
 	}
 

modules/net_probe.go

@@ -65,12 +65,6 @@ func (p *Prober) shouldProbe(ip net.IP) bool {
 	return true
 }
 
-func (p Prober) OnSessionEnded(s *session.Session) {
-	if p.Running() {
-		p.Stop()
-	}
-}
-
 func (p *Prober) sendProbe(from net.IP, from_hw net.HardwareAddr, ip net.IP) {
 	name := fmt.Sprintf("%s:137", ip)
 	if addr, err := net.ResolveUDPAddr("udp", name); err != nil {
@@ -86,11 +80,12 @@ func (p *Prober) sendProbe(from net.IP, from_hw net.HardwareAddr, ip net.IP) {
 
 func (p *Prober) Start() error {
 	if p.Running() == false {
-		throttle := int(0)
+		var err error
-		if err, v := p.Param("net.probe.throttle").Get(p.Session); err != nil {
+		var throttle int
+
+		if err, throttle = p.IntParam("net.probe.throttle"); err != nil {
 			return err
 		} else {
-			throttle = v.(int)
 			log.Debug("Throttling packets of %d ms.", throttle)
 		}
 

modules/net_recon.go

@@ -60,12 +60,6 @@ func (d Discovery) Author() string {
 	return "Simone Margaritelli <evilsocket@protonmail.com>"
 }
 
-func (d Discovery) OnSessionEnded(s *session.Session) {
-	if d.Running() {
-		d.Stop()
-	}
-}
-
 func (d *Discovery) checkShared(new net.ArpTable) {
 	n_gw_shared := 0
 	for ip, mac := range new {

modules/net_sniff.go

@@ -85,12 +85,6 @@ func (s Sniffer) Author() string {
 	return "Simone Margaritelli <evilsocket@protonmail.com>"
 }
 
-func (sn Sniffer) OnSessionEnded(s *session.Session) {
-	if sn.Running() {
-		sn.Stop()
-	}
-}
-
 func same(a, b net.HardwareAddr) bool {
 	if len(a) != len(b) {
 		return false

modules/net_sniff_context.go

@@ -34,50 +34,40 @@ func (s *Sniffer) GetContext() (error, *SnifferContext) {
 		return err, ctx
 	}
 
-	if err, v := s.Param("net.sniff.verbose").Get(s.Session); err != nil {
+	if err, ctx.Verbose = s.BoolParam("net.sniff.verbose"); err != nil {
 		return err, ctx
-	} else {
-		ctx.Verbose = v.(bool)
 	}
 
-	if err, v := s.Param("net.sniff.local").Get(s.Session); err != nil {
+	if err, ctx.DumpLocal = s.BoolParam("net.sniff.local"); err != nil {
 		return err, ctx
-	} else {
-		ctx.DumpLocal = v.(bool)
 	}
 
-	if err, v := s.Param("net.sniff.filter").Get(s.Session); err != nil {
+	if err, ctx.Filter = s.StringParam("net.sniff.filter"); err != nil {
 		return err, ctx
-	} else {
+	} else if ctx.Filter != "" {
-		if ctx.Filter = v.(string); ctx.Filter != "" {
+		err = ctx.Handle.SetBPFFilter(ctx.Filter)
-			err = ctx.Handle.SetBPFFilter(ctx.Filter)
+		if err != nil {
-			if err != nil {
+			return err, ctx
-				return err, ctx
-			}
 		}
 	}
 
-	if err, v := s.Param("net.sniff.regexp").Get(s.Session); err != nil {
+	if err, ctx.Expression = s.StringParam("net.sniff.regexp"); err != nil {
 		return err, ctx
-	} else {
+	} else if ctx.Expression != "" {
-		if ctx.Expression = v.(string); ctx.Expression != "" {
+		if ctx.Compiled, err = regexp.Compile(ctx.Expression); err != nil {
-			if ctx.Compiled, err = regexp.Compile(ctx.Expression); err != nil {
+			return err, ctx
-				return err, ctx
-			}
 		}
 	}
 
-	if err, v := s.Param("net.sniff.output").Get(s.Session); err != nil {
+	if err, ctx.Output = s.StringParam("net.sniff.output"); err != nil {
 		return err, ctx
-	} else {
+	} else if ctx.Output != "" {
-		if ctx.Output = v.(string); ctx.Output != "" {
+		if ctx.OutputFile, err = os.Create(ctx.Output); err != nil {
-			if ctx.OutputFile, err = os.Create(ctx.Output); err != nil {
+			return err, ctx
-				return err, ctx
-			}
-
-			ctx.OutputWriter = pcapgo.NewWriter(ctx.OutputFile)
-			ctx.OutputWriter.WriteFileHeader(65536, layers.LinkTypeEthernet)
 		}
+
+		ctx.OutputWriter = pcapgo.NewWriter(ctx.OutputFile)
+		ctx.OutputWriter.WriteFileHeader(65536, layers.LinkTypeEthernet)
 	}
 
 	return nil, ctx

session/module.go

@@ -12,9 +12,6 @@ type Module interface {
 	Running() bool
 	Start() error
 	Stop() error
-
-	OnSessionStarted(s *Session)
-	OnSessionEnded(s *Session)
 }
 
 type SessionModule struct {
@@ -53,13 +50,38 @@ func (m *SessionModule) Param(name string) *ModuleParam {
 	return m.params[name]
 }
 
+func (m SessionModule) StringParam(name string) (error, string) {
+	if err, v := m.params[name].Get(m.Session); err != nil {
+		return err, ""
+	} else {
+		return nil, v.(string)
+	}
+}
+
+func (m SessionModule) IntParam(name string) (error, int) {
+	if err, v := m.params[name].Get(m.Session); err != nil {
+		return err, 0
+	} else {
+		return nil, v.(int)
+	}
+}
+
+func (m SessionModule) BoolParam(name string) (error, bool) {
+	if err, v := m.params[name].Get(m.Session); err != nil {
+		return err, false
+	} else {
+		return nil, v.(bool)
+	}
+}
+
 func (m *SessionModule) AddHandler(h ModuleHandler) {
 	m.handlers = append(m.handlers, h)
 }
 
-func (m *SessionModule) AddParam(p *ModuleParam) {
+func (m *SessionModule) AddParam(p *ModuleParam) *ModuleParam {
 	m.params[p.Name] = p
 	p.Register(m.Session)
+	return p
 }
 
 func (m *SessionModule) Running() bool {
@@ -79,7 +101,3 @@ func (m *SessionModule) SetRunning(running bool) {
 		m.Session.Events.Add("mod.stopped", m.Name)
 	}
 }
-
-func (m *SessionModule) OnSessionStarted(s *Session) {
-
-}

session/module_param.go

@@ -79,6 +79,9 @@ func (p ModuleParam) Validate(value string) (error, interface{}) {
 	return fmt.Errorf("Unhandled module parameter type %d.", p.Type), nil
 }
 
+const ParamIfaceAddress = "<interface address>"
+const ParamSubnet = "<entire subnet>"
+
 func (p ModuleParam) Get(s *Session) (error, interface{}) {
 	var v string
 	var found bool
@@ -89,6 +92,12 @@ func (p ModuleParam) Get(s *Session) (error, interface{}) {
 		v = ""
 	}
 
+	if v == ParamIfaceAddress {
+		v = s.Interface.IpAddress
+	} else if v == ParamSubnet {
+		v = s.Interface.CIDR()
+	}
+
 	err, obj = p.Validate(v)
 	return err, obj
 

session/session.go

@@ -133,7 +133,9 @@ func (s *Session) Close() {
 	s.Events.Add("session.closing", nil)
 
 	for _, m := range s.Modules {
-		m.OnSessionEnded(s)
+		if m.Running() {
+			m.Stop()
+		}
 	}
 
 	s.Firewall.Restore()
@@ -216,11 +218,6 @@ func (s *Session) Start() error {
 	}()
 
 	s.Active = true
-
-	for _, m := range s.Modules {
-		m.OnSessionStarted(s)
-	}
-
 	s.Events.Add("session.started", nil)
 
 	return nil