github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-08-14 10:46:57 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

refact: refactored module parameters api

Browse source
This commit is contained in:
evilsocket 2018-01-11 00:27:53 +01:00
commit e543582257
12 changed files with 111 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

70
modules/api_rest.go
View file

@ -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) {
// refresh the address after session has been created
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 {
func (api *RestAPI) Configure() error {
var err 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, v := api.Param("api.rest.certificate").Get(api.Session); err != nil {
if err, api.keyFile = api.StringParam("api.rest.key"); err != nil {
return err
} 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 {
api.keyFile = v.(string)
if api.keyFile, err = core.ExpandPath(api.keyFile); err != nil {
return err
}
} else if api.username == "" {
return fmt.Errorf("api.rest.username is empty.")
}
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 {
api.username = v.(string)
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.")
}
} else 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
}

26
modules/arp_spoof.go
View file

@ -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()

13
modules/events_stream.go
View file

@ -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()
}
}

42
modules/http_proxy.go
View file

@ -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 {
scriptPath := v.(string)
if scriptPath != "" {
if err, p.script = LoadProxyScript(scriptPath, p.Session); err != nil {
return err
} else {
log.Debug("Proxy script %s loaded.", scriptPath)
}
} else if scriptPath != "" {
if err, p.script = LoadProxyScript(scriptPath, p.Session); err != nil {
return err
} else {
log.Debug("Proxy script %s loaded.", scriptPath)
}
}

35
modules/http_server.go
View file

@ -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) {
// refresh the address after session has been created
s.Env.Set("http.server.address", s.Interface.IpAddress)
}
func (httpd *HttpServer) OnSessionEnded(s *session.Session) {
if httpd.Running() {
httpd.Stop()
}
}
func (httpd *HttpServer) configure() error {
func (httpd *HttpServer) Configure() error {
var err error
var path string
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
}

13
modules/net_probe.go
View file

@ -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)
if err, v := p.Param("net.probe.throttle").Get(p.Session); err != nil {
var err error
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)
}

6
modules/net_recon.go
View file

@ -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 {

6
modules/net_sniff.go
View file

@ -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

46
modules/net_sniff_context.go
View file

@ -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 {
if ctx.Filter = v.(string); ctx.Filter != "" {
err = ctx.Handle.SetBPFFilter(ctx.Filter)
if err != nil {
return err, ctx
}
} else if ctx.Filter != "" {
err = ctx.Handle.SetBPFFilter(ctx.Filter)
if err != nil {
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 {
if ctx.Expression = v.(string); ctx.Expression != "" {
if ctx.Compiled, err = regexp.Compile(ctx.Expression); err != nil {
return err, ctx
}
} else if ctx.Expression != "" {
if ctx.Compiled, err = regexp.Compile(ctx.Expression); err != nil {
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 {
if ctx.Output = v.(string); ctx.Output != "" {
if ctx.OutputFile, err = os.Create(ctx.Output); err != nil {
return err, ctx
}
ctx.OutputWriter = pcapgo.NewWriter(ctx.OutputFile)
ctx.OutputWriter.WriteFileHeader(65536, layers.LinkTypeEthernet)
} else if ctx.Output != "" {
if ctx.OutputFile, err = os.Create(ctx.Output); err != nil {
return err, ctx
}
ctx.OutputWriter = pcapgo.NewWriter(ctx.OutputFile)
ctx.OutputWriter.WriteFileHeader(65536, layers.LinkTypeEthernet)
}
return nil, ctx