github/bettercap
1
0
Fork 0
mirror of https://github.com/bettercap/bettercap synced 2025-08-20 21:43:18 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

new: centralized logging and implemented DELETE /api/events route, closes #5

Browse source
This commit is contained in:
evilsocket 2018-01-08 06:39:44 +01:00
commit f1f146d3d7
21 changed files with 144 additions and 184 deletions
Download patch file Download diff file Expand all files Collapse all files

44
session/events.go
View file

@ -2,12 +2,22 @@ package session
import (
"fmt"
"os"
"sync"
"time"
"github.com/evilsocket/bettercap-ng/core"
)
const (
DEBUG = iota
INFO
IMPORTANT
WARNING
ERROR
FATAL
)
type Event struct {
Tag string `json:"tag"`
Time time.Time `json:"time"`
@ -23,16 +33,20 @@ func NewEvent(tag string, data interface{}) Event {
}
func (e Event) Print() {
fmt.Printf("[%s] [%s] [%s] %+v\n", e.Time, core.Bold("event"), core.Green(e.Tag), e.Data)
fmt.Printf("[%s] [%s] %v\n", e.Time, core.Green(e.Tag), e.Data)
}
type EventPool struct {
debug bool
silent bool
events []Event
lock *sync.Mutex
}
func NewEventPool() *EventPool {
func NewEventPool(debug bool, silent bool) *EventPool {
return &EventPool{
debug: debug,
silent: silent,
events: make([]Event, 0),
lock: &sync.Mutex{},
}
@ -46,6 +60,32 @@ func (p *EventPool) Add(tag string, data interface{}) {
e.Print()
}
func (p *EventPool) Log(level int, format string, args ...interface{}) {
if level == DEBUG && p.debug == false {
return
} else if level < ERROR && p.silent == true {
return
}
p.Add("sys.log", struct {
Level int
Message string
}{
level,
fmt.Sprintf(format, args...),
})
if level == FATAL {
os.Exit(1)
}
}
func (p *EventPool) Clear() {
p.lock.Lock()
defer p.lock.Unlock()
p.events = make([]Event, 0)
}
func (p *EventPool) Events() []Event {
p.lock.Lock()
defer p.lock.Unlock()

19
session/modules/api_rest.go
View file

@ -8,7 +8,6 @@ import (
"strconv"
"strings"
"github.com/evilsocket/bettercap-ng/core"
"github.com/evilsocket/bettercap-ng/session"
)
@ -80,7 +79,7 @@ func (api *RestAPI) sessRoute(w http.ResponseWriter, r *http.Request) {
if r.Method == "GET" {
js, err := json.Marshal(api.Session)
if err != nil {
log.Errorf("Error while returning session: %s", err)
api.Session.Events.Log(session.ERROR, "Error while returning session: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@ -103,7 +102,7 @@ func (api *RestAPI) sessRoute(w http.ResponseWriter, r *http.Request) {
}
js, err := json.Marshal(res)
if err != nil {
log.Errorf("Error while returning response: %s", err)
api.Session.Events.Log(session.ERROR, "Error while returning response: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
@ -142,13 +141,18 @@ func (api *RestAPI) eventsRoute(w http.ResponseWriter, r *http.Request) {
js, err := json.Marshal(events[0:n])
if err != nil {
log.Errorf("Error while returning events: %s", err)
api.Session.Events.Log(session.ERROR, "Error while returning events: %s", err)
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(js)
} else if r.Method == "DELETE" {
api.Session.Events.Clear()
api.Session.Events.Add("sys.log.cleared", nil)
// w.Header().Set("Content-Type", "application/json")
// w.Write([]byte("{}"))
} else {
http.Error(w, "Not Found", 404)
}
@ -156,7 +160,7 @@ func (api *RestAPI) eventsRoute(w http.ResponseWriter, r *http.Request) {
func (api RestAPI) checkAuth(w http.ResponseWriter, r *http.Request) bool {
if api.Authenticated(w, r) == false {
log.Warningf("Unauthenticated access!")
api.Session.Events.Log(session.WARNING, "Unauthenticated access!")
http.Error(w, "Not authorized", 401)
return false
}
@ -250,10 +254,11 @@ func (api *RestAPI) Start() error {
api.server.Addr = fmt.Sprintf("%s:%d", address, port)
go func() {
fmt.Printf("[%s] starting on http://%s/ ...\n", core.Green("api"), api.server.Addr)
api.Session.Events.Log(session.INFO, "API server starting on http://%s", api.server.Addr)
err := api.server.ListenAndServe()
if err != nil {
fmt.Printf("[%s] %s\n", core.Green("api"), err)
api.Session.Events.Log(session.ERROR, "%s", err)
}
}()

17
session/modules/arp_spoof.go
View file

@ -85,7 +85,7 @@ func (p *ArpSpoofer) getMAC(ip net.IP, probe bool) (net.HardwareAddr, error) {
from_hw := p.Session.Interface.HW
if err, probe := packets.NewUDPProbe(from, from_hw, ip, 139); err != nil {
log.Errorf("Error while creating UDP probe packet for %s: %s\n", ip.String(), err)
p.Session.Events.Log(session.ERROR, "Error while creating UDP probe packet for %s: %s\n", ip.String(), err)
} else {
p.Session.Queue.Send(probe)
}
@ -110,21 +110,21 @@ func (p *ArpSpoofer) getMAC(ip net.IP, probe bool) (net.HardwareAddr, error) {
func (p *ArpSpoofer) sendArp(addresses []net.IP, saddr net.IP, smac net.HardwareAddr, check_running bool, probe bool) {
for _, ip := range addresses {
if p.shouldSpoof(ip) == false {
log.Debugf("Skipping address %s from ARP spoofing.\n", ip)
p.Session.Events.Log(session.DEBUG, "Skipping address %s from ARP spoofing.\n", ip)
continue
}
// do we have this ip mac address?
hw, err := p.getMAC(ip, probe)
if err != nil {
log.Debugf("Error while looking up hardware address for %s: %s\n", ip.String(), err)
p.Session.Events.Log(session.DEBUG, "Error while looking up hardware address for %s: %s\n", ip.String(), err)
continue
}
if err, pkt := packets.NewARPReply(saddr, smac, ip, hw); err != nil {
log.Errorf("Error while creating ARP spoof packet for %s: %s\n", ip.String(), err)
p.Session.Events.Log(session.ERROR, "Error while creating ARP spoof packet for %s: %s\n", ip.String(), err)
} else {
log.Debugf("Sending %d bytes of ARP packet to %s:%s.\n", len(pkt), ip.String(), hw.String())
p.Session.Events.Log(session.DEBUG, "Sending %d bytes of ARP packet to %s:%s.\n", len(pkt), ip.String(), hw.String())
p.Session.Queue.Send(pkt)
}
@ -152,7 +152,7 @@ func (p *ArpSpoofer) unSpoof() error {
from := p.Session.Gateway.IP
from_hw := p.Session.Gateway.HW
log.Infof("Restoring ARP cache of %d targets (%s).\n", len(addresses), targets)
p.Session.Events.Log(session.INFO, "Restoring ARP cache of %d targets (%s).\n", len(addresses), targets)
p.sendArp(addresses, from, from_hw, false, false)
@ -182,7 +182,7 @@ func (p *ArpSpoofer) Start() error {
from := p.Session.Gateway.IP
from_hw := p.Session.Interface.HW
log.Infof("ARP spoofer started, probing %d targets (%s).\n", len(addresses), targets)
p.Session.Events.Log(session.INFO, "ARP spoofer started, probing %d targets (%s).\n", len(addresses), targets)
for p.Running() {
p.sendArp(addresses, from, from_hw, true, false)
@ -190,7 +190,6 @@ func (p *ArpSpoofer) Start() error {
}
p.Done <- true
log.Info("ARP spoofer stopped.\n")
}()
return nil
@ -203,7 +202,7 @@ func (p *ArpSpoofer) Stop() error {
if p.Running() == true {
p.SetRunning(false)
log.Info("Waiting for ARP spoofer to stop ...\n")
p.Session.Events.Log(session.INFO, "Waiting for ARP spoofer to stop ...")
<-p.Done

34
session/modules/http_proxy.go
View file

@ -5,17 +5,12 @@ import (
"net/http"
"strings"
"github.com/op/go-logging"
"github.com/elazarl/goproxy"
"github.com/evilsocket/bettercap-ng/core"
"github.com/evilsocket/bettercap-ng/firewall"
"github.com/evilsocket/bettercap-ng/session"
)
var log = logging.MustGetLogger("mitm")
type HttpProxy struct {
session.SessionModule
@ -27,13 +22,19 @@ type HttpProxy struct {
}
func (p HttpProxy) logAction(req *http.Request, jsres *JSResponse) {
fmt.Printf("[%s] %s > '%s %s%s' | Sending %d bytes of spoofed response.\n",
core.Green("http.proxy"),
core.Bold(strings.Split(req.RemoteAddr, ":")[0]),
p.Session.Events.Add("http.proxy.spoofed-response", struct {
To string
Method string
Host string
Path string
Size int
}{
strings.Split(req.RemoteAddr, ":")[0],
req.Method,
req.Host,
req.URL.Path,
len(jsres.Body))
len(jsres.Body),
})
}
func NewHttpProxy(s *session.Session) *HttpProxy {
@ -169,12 +170,13 @@ func (p *HttpProxy) Start() error {
if err, p.script = LoadProxyScript(scriptPath, p.Session); err != nil {
return err
} else {
log.Debugf("Proxy script %s loaded.", scriptPath)
p.Session.Events.Log(session.DEBUG, "Proxy script %s loaded.", scriptPath)
}
}
}
if p.Session.Firewall.IsForwardingEnabled() == false {
p.Session.Events.Log(session.INFO, "Enabling forwarding.")
p.Session.Firewall.EnableForwarding(true)
}
@ -188,15 +190,15 @@ func (p *HttpProxy) Start() error {
return err
}
address := fmt.Sprintf("%s:%d", p.address, proxy_port)
log.Infof("Starting proxy on %s.\n", address)
p.Session.Events.Log(session.DEBUG, "Applied redirection %s", p.redirection.String())
address := fmt.Sprintf("%s:%d", p.address, proxy_port)
p.server = http.Server{Addr: address, Handler: p.proxy}
go func() {
p.SetRunning(true)
if err := p.server.ListenAndServe(); err != nil {
p.SetRunning(false)
log.Warning(err)
p.Session.Events.Log(session.WARNING, "%s", err)
}
}()
@ -207,8 +209,8 @@ func (p *HttpProxy) Stop() error {
if p.Running() == true {
p.SetRunning(false)
p.server.Shutdown(nil)
log.Info("HTTP proxy stopped.\n")
if p.redirection != nil {
p.Session.Events.Log(session.DEBUG, "Disabling redirection %s", p.redirection.String())
if err := p.Session.Firewall.EnableRedirection(p.redirection, false); err != nil {
return err
}
@ -228,13 +230,13 @@ func (p HttpProxy) doProxy(req *http.Request) bool {
}
if req.Host == "" {
log.Errorf("Got request with empty host: %v\n", req)
p.Session.Events.Log(session.ERROR, "Got request with empty host: %v", req)
return false
}
for _, blacklisted := range blacklist {
if strings.HasPrefix(req.Host, blacklisted) {
log.Errorf("Got request with blacklisted host: %s\n", req.Host)
p.Session.Events.Log(session.ERROR, "Got request with blacklisted host: %s", req.Host)
return false
}
}

1
session/modules/http_proxy_js_request.go
View file

@ -42,7 +42,6 @@ func NewJSRequest(req *http.Request) JSRequest {
func (j *JSRequest) ReadBody() string {
raw, err := ioutil.ReadAll(j.req.Body)
if err != nil {
log.Errorf("Could not read request body: %s", err)
return ""
}

3
session/modules/http_proxy_js_response.go
View file

@ -54,8 +54,6 @@ func (j *JSResponse) ToResponse(req *http.Request) (resp *http.Response) {
parts := strings.SplitN(header, ":", 2)
if len(parts) == 2 {
resp.Header.Add(parts[0], parts[1])
} else {
log.Warningf("Unexpected header '%s'", header)
}
}
}
@ -67,7 +65,6 @@ func (j *JSResponse) ReadBody() string {
raw, err := ioutil.ReadAll(j.resp.Body)
if err != nil {
log.Errorf("Could not read response body: %s", err)
return ""
}

28
session/modules/http_proxy_script.go
View file

@ -15,6 +15,7 @@ type ProxyScript struct {
Source string
VM *otto.Otto
sess *session.Session
gil *sync.Mutex
onRequestScript *otto.Script
onResponseScript *otto.Script
@ -23,7 +24,7 @@ type ProxyScript struct {
}
func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScript) {
log.Infof("Loading proxy script %s ...", path)
sess.Events.Log(session.INFO, "Loading proxy script %s ...", path)
raw, err := ioutil.ReadFile(path)
if err != nil {
@ -35,6 +36,7 @@ func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScr
Source: string(raw),
VM: otto.New(),
sess: sess,
gil: &sync.Mutex{},
onRequestScript: nil,
onResponseScript: nil,
@ -51,7 +53,7 @@ func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScr
// define session pointer
err = s.VM.Set("env", sess.Env.Storage)
if err != nil {
log.Errorf("Error while defining environment: %s", err)
sess.Events.Log(session.ERROR, "Error while defining environment: %s", err)
return
}
@ -59,7 +61,7 @@ func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScr
if s.hasCallback("onLoad") {
_, err = s.VM.Run("onLoad()")
if err != nil {
log.Errorf("Error while executing onLoad callback: %s", err)
sess.Events.Log(session.ERROR, "Error while executing onLoad callback: %s", err)
return
}
}
@ -68,7 +70,7 @@ func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScr
if s.hasCallback("onRequest") {
s.onRequestScript, err = s.VM.Compile("", "onRequest(req, res)")
if err != nil {
log.Errorf("Error while compiling onRequest callback: %s", err)
sess.Events.Log(session.ERROR, "Error while compiling onRequest callback: %s", err)
return
}
}
@ -77,7 +79,7 @@ func LoadProxyScript(path string, sess *session.Session) (err error, s *ProxyScr
if s.hasCallback("onResponse") {
s.onResponseScript, err = s.VM.Compile("", "onResponse(req, res)")
if err != nil {
log.Errorf("Error while compiling onResponse callback: %s", err)
sess.Events.Log(session.ERROR, "Error while compiling onResponse callback: %s", err)
return
}
}
@ -109,13 +111,13 @@ func (s *ProxyScript) doRequestDefines(req *http.Request) (err error, jsres *JSR
// convert request and define empty response to be optionally filled
jsreq := NewJSRequest(req)
if err = s.VM.Set("req", &jsreq); err != nil {
log.Errorf("Error while defining request: %s", err)
s.sess.Events.Log(session.ERROR, "Error while defining request: %s", err)
return
}
jsres = &JSResponse{}
if err = s.VM.Set("res", jsres); err != nil {
log.Errorf("Error while defining response: %s", err)
s.sess.Events.Log(session.ERROR, "Error while defining response: %s", err)
return
}
@ -126,13 +128,13 @@ func (s *ProxyScript) doResponseDefines(res *http.Response) (err error, jsres *J
// convert both request and response
jsreq := NewJSRequest(res.Request)
if err = s.VM.Set("req", jsreq); err != nil {
log.Errorf("Error while defining request: %s", err)
s.sess.Events.Log(session.ERROR, "Error while defining request: %s", err)
return
}
jsres = NewJSResponse(res)
if err = s.VM.Set("res", jsres); err != nil {
log.Errorf("Error while defining response: %s", err)
s.sess.Events.Log(session.ERROR, "Error while defining response: %s", err)
return
}
@ -146,13 +148,13 @@ func (s *ProxyScript) OnRequest(req *http.Request) *JSResponse {
err, jsres := s.doRequestDefines(req)
if err != nil {
log.Errorf("Error while running bootstrap definitions: %s", err)
s.sess.Events.Log(session.ERROR, "Error while running bootstrap definitions: %s", err)
return nil
}
_, err = s.VM.Run(s.onRequestScript)
if err != nil {
log.Errorf("Error while executing onRequest callback: %s", err)
s.sess.Events.Log(session.ERROR, "Error while executing onRequest callback: %s", err)
return nil
}
@ -171,13 +173,13 @@ func (s *ProxyScript) OnResponse(res *http.Response) *JSResponse {
err, jsres := s.doResponseDefines(res)
if err != nil {
log.Errorf("Error while running bootstrap definitions: %s", err)
s.sess.Events.Log(session.ERROR, "Error while running bootstrap definitions: %s", err)
return nil
}
_, err = s.VM.Run(s.onResponseScript)
if err != nil {
log.Errorf("Error while executing onRequest callback: %s", err)
s.sess.Events.Log(session.ERROR, "Error while executing onRequest callback: %s", err)
return nil
}

23
session/modules/net_probe.go
View file

@ -2,11 +2,12 @@ package session_modules
import (
"fmt"
// "github.com/evilsocket/bettercap-ng/packets"
"github.com/evilsocket/bettercap-ng/session"
"github.com/malfunkt/iprange"
"net"
"time"
"github.com/evilsocket/bettercap-ng/session"
"github.com/malfunkt/iprange"
)
type Prober struct {
@ -72,11 +73,11 @@ func (p Prober) OnSessionEnded(s *session.Session) {
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 {
log.Errorf("Could not resolve %s.", name)
p.Session.Events.Log(session.ERROR, "Could not resolve %s.", name)
} else if con, err := net.DialUDP("udp", nil, addr); err != nil {
log.Errorf("Could not dial %s.", name)
p.Session.Events.Log(session.ERROR, "Could not dial %s.", name)
} else {
// log.Debugf("UDP connection to %s enstablished.\n", name)
// p.Session.Events.Log(session.DEBUG,"UDP connection to %s enstablished.\n", name)
defer con.Close()
con.Write([]byte{0xde, 0xad, 0xbe, 0xef})
}
@ -89,7 +90,7 @@ func (p *Prober) Start() error {
return err
} else {
throttle = v.(int)
log.Debugf("Throttling packets of %d ms.\n", throttle)
p.Session.Events.Log(session.DEBUG, "Throttling packets of %d ms.", throttle)
}
p.SetRunning(true)
@ -97,19 +98,17 @@ func (p *Prober) Start() error {
go func() {
list, err := iprange.Parse(p.Session.Interface.CIDR())
if err != nil {
log.Fatal(err)
p.Session.Events.Log(session.FATAL, "%s", err)
}
from := p.Session.Interface.IP
from_hw := p.Session.Interface.HW
addresses := list.Expand()
log.Infof("Network prober started, probing %d possible addresses.\n", len(addresses))
for p.Running() {
for _, ip := range addresses {
if p.shouldProbe(ip) == false {
log.Debugf("Skipping address %s from UDP probing.\n", ip)
p.Session.Events.Log(session.DEBUG, "Skipping address %s from UDP probing.", ip)
continue
}
@ -122,8 +121,6 @@ func (p *Prober) Start() error {
time.Sleep(5 * time.Second)
}
log.Info("Network prober stopped.\n")
}()
return nil

8
session/modules/net_recon.go
View file

@ -70,7 +70,7 @@ func (d *Discovery) Start() error {
d.SetRunning(true)
go func() {
log.Info("Network discovery started.\n")
d.Session.Events.Log(session.INFO, "Network discovery started.")
for {
select {
@ -78,7 +78,7 @@ func (d *Discovery) Start() error {
var err error
if d.current, err = net.ArpUpdate(d.Session.Interface.Name()); err != nil {
log.Error(err)
d.Session.Events.Log(session.ERROR, "%s", err)
continue
}
@ -111,7 +111,7 @@ func (d *Discovery) Start() error {
b = ""
}
log.Warningf("WARNING: Found %d endpoint%s which share%s the same MAC of the gateway (%s), there're might be some IP isolation going on, skipping.\n", n_gw_shared, a, b, d.Session.Gateway.HwAddress)
d.Session.Events.Log(session.WARNING, "WARNING: Found %d endpoint%s which share%s the same MAC of the gateway (%s), there're might be some IP isolation going on, skipping.", n_gw_shared, a, b, d.Session.Gateway.HwAddress)
}
// refresh target pool
@ -127,7 +127,7 @@ func (d *Discovery) Start() error {
d.before = d.current
case <-d.quit:
log.Info("Network discovery stopped.\n")
d.Session.Events.Log(session.INFO, "Network discovery stopped.")
return
}
}

40
session/modules/net_sniff.go
View file

@ -45,34 +45,30 @@ var (
yes = core.Green("yes")
)
func (c *SnifferContext) Log() {
log.Info("\n")
func (c *SnifferContext) Log(sess *session.Session) {
if c.DumpLocal {
log.Info(" Skip local packets : " + no)
sess.Events.Log(session.INFO, "Skip local packets : "+no)
} else {
log.Info(" Skip local packets : " + yes)
sess.Events.Log(session.INFO, "Skip local packets : "+yes)
}
if c.Verbose {
log.Info(" Verbose : " + yes)
sess.Events.Log(session.INFO, "Verbose : "+yes)
} else {
log.Info(" Verbose : " + no)
sess.Events.Log(session.INFO, "Verbose : "+no)
}
if c.Filter != "" {
log.Info(" BPF Filter : '" + core.Yellow(c.Filter) + "'")
sess.Events.Log(session.INFO, "BPF Filter : '"+core.Yellow(c.Filter)+"'")
}
if c.Expression != "" {
log.Info(" Regular expression : '" + core.Yellow(c.Expression) + "'")
sess.Events.Log(session.INFO, "Regular expression : '"+core.Yellow(c.Expression)+"'")
}
if c.Output != "" {
log.Info(" File output : '" + core.Yellow(c.Output) + "'")
sess.Events.Log(session.INFO, "File output : '"+core.Yellow(c.Output)+"'")
}
log.Info("\n")
}
func (c *SnifferContext) Close() {
@ -272,7 +268,7 @@ func (s *Sniffer) PrintStats() error {
return fmt.Errorf("No stats yet.")
}
s.Ctx.Log()
s.Ctx.Log(s.Session)
first := "never"
last := "never"
@ -285,13 +281,13 @@ func (s *Sniffer) PrintStats() error {
last = s.Stats.LastPacket.String()
}
log.Infof(" Sniffer Started : %s\n", s.Stats.Started)
log.Infof(" First Packet Seen : %s\n", first)
log.Infof(" Last Packet Seen : %s\n", last)
log.Infof(" Local Packets : %d\n", s.Stats.NumLocal)
log.Infof(" Matched Packets : %d\n", s.Stats.NumMatched)
log.Infof(" Dumped Packets : %d\n", s.Stats.NumDumped)
log.Infof(" Wrote Packets : %d\n", s.Stats.NumWrote)
s.Session.Events.Log(session.INFO, "Sniffer Started : %s", s.Stats.Started)
s.Session.Events.Log(session.INFO, "First Packet Seen : %s", first)
s.Session.Events.Log(session.INFO, "Last Packet Seen : %s", last)
s.Session.Events.Log(session.INFO, "Local Packets : %d", s.Stats.NumLocal)
s.Session.Events.Log(session.INFO, "Matched Packets : %d", s.Stats.NumMatched)
s.Session.Events.Log(session.INFO, "Dumped Packets : %d", s.Stats.NumDumped)
s.Session.Events.Log(session.INFO, "Wrote Packets : %d", s.Stats.NumWrote)
return nil
}
@ -314,8 +310,6 @@ func (s *Sniffer) Start() error {
go func() {
defer s.Ctx.Close()
log.Info("Network sniffer started.\n")
src := gopacket.NewPacketSource(s.Ctx.Handle, s.Ctx.Handle.LinkType())
for packet := range src.Packets() {
if s.Running() == false {
@ -351,8 +345,6 @@ func (s *Sniffer) Start() error {
}
}
}
log.Info("Network sniffer stopped.\n")
}()
return nil

44
session/session.go
View file

@ -13,7 +13,6 @@ import (
"time"
"github.com/chzyer/readline"
"github.com/op/go-logging"
"github.com/evilsocket/bettercap-ng/core"
"github.com/evilsocket/bettercap-ng/firewall"
@ -51,30 +50,22 @@ func New() (*Session, error) {
Modules: make([]Module, 0),
HelpPadding: 0,
Events: NewEventPool(),
Events: nil,
}
s.Env = NewEnvironment(s)
if s.Options, err = core.ParseOptions(); err != nil {
return nil, err
}
s.Env = NewEnvironment(s)
s.Events = NewEventPool(*s.Options.Debug, *s.Options.Silent)
if u, err := user.Current(); err != nil {
return nil, err
} else if u.Uid != "0" {
return nil, fmt.Errorf("This software must run as root.")
}
// setup logging
if *s.Options.Debug == true {
logging.SetLevel(logging.DEBUG, "")
} else if *s.Options.Silent == true {
logging.SetLevel(logging.ERROR, "")
} else {
logging.SetLevel(logging.INFO, "")
}
s.registerCoreHandlers()
return s, nil
@ -206,7 +197,6 @@ func (s *Session) registerCoreHandlers() {
}
s.Env.Set(key, value)
fmt.Printf(" %s => '%s'\n", core.Green(key), core.Yellow(value))
return nil
}))
}
@ -251,21 +241,6 @@ func (s *Session) setupInput() error {
return err
}
// now that we have the readline instance, we can set logging to its
// console writer so the whole thing gets correctly updated when something
// is logged to screen (it won't overlap with the prompt).
log_be := logging.NewLogBackend(s.Input.Stderr(), "", 0)
log_level := logging.AddModuleLevel(log_be)
if *s.Options.Debug == true {
log_level.SetLevel(logging.DEBUG, "")
} else if *s.Options.Silent == true {
log_level.SetLevel(logging.ERROR, "")
} else {
log_level.SetLevel(logging.INFO, "")
}
logging.SetBackend(log_level)
return nil
}
@ -302,11 +277,8 @@ func (s *Session) Start() error {
return err
}
log.Debugf("[%s%s%s] %s\n", core.GREEN, s.Interface.Name(), core.RESET, s.Interface)
log.Debugf("[%ssubnet%s] %s\n", core.GREEN, core.RESET, s.Interface.CIDR())
if s.Gateway, err = net.FindGateway(s.Interface); err != nil {
log.Warningf("%s\n", err)
s.Events.Log(WARNING, "%s", err)
}
if s.Gateway == nil || s.Gateway.IpAddress == s.Interface.IpAddress {
@ -316,8 +288,6 @@ func (s *Session) Start() error {
s.Env.Set("gateway.address", s.Gateway.IpAddress)
s.Env.Set("gateway.mac", s.Gateway.HwAddress)
log.Debugf("[%sgateway%s] %s\n", core.GREEN, core.RESET, s.Gateway)
s.Targets = NewTargets(s, s.Interface, s.Gateway)
s.Firewall = firewall.Make()
@ -350,7 +320,7 @@ func (s *Session) Start() error {
go func() {
<-c
fmt.Println()
log.Warning("Got SIGTERM ...")
s.Events.Log(WARNING, "Got SIGTERM")
s.Close()
os.Exit(0)
}()
@ -373,7 +343,7 @@ func (s *Session) ReadLine() (string, error) {
}
func (s *Session) RunCaplet(filename string) error {
log.Infof("Reading from caplet %s ...\n", filename)
s.Events.Log(INFO, "Reading from caplet %s ...\n", filename)
input, err := os.Open(filename)
if err != nil {

4
session/targets.go
View file

@ -5,14 +5,10 @@ import (
"sort"
"sync"
"github.com/op/go-logging"
"github.com/evilsocket/bettercap-ng/core"
"github.com/evilsocket/bettercap-ng/net"
)
var log = logging.MustGetLogger("mitm")
type Targets struct {
Session *Session `json:"-"`
Interface *net.Endpoint