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

misc: small fix or general refactoring i did not bother commenting

Browse source
This commit is contained in:
evilsocket 2019-02-13 10:12:34 +01:00
commit 4eead7eafa
No known key found for this signature in database
GPG key ID: 1564D7F30393A456
58 changed files with 2052 additions and 2052 deletions
Download patch file Download diff file Expand all files Collapse all files

144
modules/net_sniff/net_sniff.go
View file

@ -24,133 +24,133 @@ type Sniffer struct {
}
func NewSniffer(s *session.Session) *Sniffer {
sniff := &Sniffer{
mod := &Sniffer{
SessionModule: session.NewSessionModule("net.sniff", s),
Stats: nil,
}
sniff.AddParam(session.NewBoolParameter("net.sniff.verbose",
mod.AddParam(session.NewBoolParameter("net.sniff.verbose",
"false",
"If true, every captured and parsed packet will be sent to the events.stream for displaying, otherwise only the ones parsed at the application layer (sni, http, etc)."))
sniff.AddParam(session.NewBoolParameter("net.sniff.local",
mod.AddParam(session.NewBoolParameter("net.sniff.local",
"false",
"If true it will consider packets from/to this computer, otherwise it will skip them."))
sniff.AddParam(session.NewStringParameter("net.sniff.filter",
mod.AddParam(session.NewStringParameter("net.sniff.filter",
"not arp",
"",
"BPF filter for the sniffer."))
sniff.AddParam(session.NewStringParameter("net.sniff.regexp",
mod.AddParam(session.NewStringParameter("net.sniff.regexp",
"",
"",
"If set, only packets matching this regular expression will be considered."))
sniff.AddParam(session.NewStringParameter("net.sniff.output",
mod.AddParam(session.NewStringParameter("net.sniff.output",
"",
"",
"If set, the sniffer will write captured packets to this file."))
sniff.AddParam(session.NewStringParameter("net.sniff.source",
mod.AddParam(session.NewStringParameter("net.sniff.source",
"",
"",
"If set, the sniffer will read from this pcap file instead of the current interface."))
sniff.AddHandler(session.NewModuleHandler("net.sniff stats", "",
mod.AddHandler(session.NewModuleHandler("net.sniff stats", "",
"Print sniffer session configuration and statistics.",
func(args []string) error {
if sniff.Stats == nil {
if mod.Stats == nil {
return fmt.Errorf("No stats yet.")
}
sniff.Ctx.Log(sniff.Session)
mod.Ctx.Log(mod.Session)
return sniff.Stats.Print()
return mod.Stats.Print()
}))
sniff.AddHandler(session.NewModuleHandler("net.sniff on", "",
mod.AddHandler(session.NewModuleHandler("net.sniff on", "",
"Start network sniffer in background.",
func(args []string) error {
return sniff.Start()
return mod.Start()
}))
sniff.AddHandler(session.NewModuleHandler("net.sniff off", "",
mod.AddHandler(session.NewModuleHandler("net.sniff off", "",
"Stop network sniffer in background.",
func(args []string) error {
return sniff.Stop()
return mod.Stop()
}))
sniff.AddHandler(session.NewModuleHandler("net.fuzz on", "",
mod.AddHandler(session.NewModuleHandler("net.fuzz on", "",
"Enable fuzzing for every sniffed packet containing the sapecified layers.",
func(args []string) error {
return sniff.StartFuzzing()
return mod.StartFuzzing()
}))
sniff.AddHandler(session.NewModuleHandler("net.fuzz off", "",
mod.AddHandler(session.NewModuleHandler("net.fuzz off", "",
"Disable fuzzing",
func(args []string) error {
return sniff.StopFuzzing()
return mod.StopFuzzing()
}))
sniff.AddParam(session.NewStringParameter("net.fuzz.layers",
mod.AddParam(session.NewStringParameter("net.fuzz.layers",
"Payload",
"",
"Types of layer to fuzz."))
sniff.AddParam(session.NewDecimalParameter("net.fuzz.rate",
mod.AddParam(session.NewDecimalParameter("net.fuzz.rate",
"1.0",
"Rate in the [0.0,1.0] interval of packets to fuzz."))
sniff.AddParam(session.NewDecimalParameter("net.fuzz.ratio",
mod.AddParam(session.NewDecimalParameter("net.fuzz.ratio",
"0.4",
"Rate in the [0.0,1.0] interval of bytes to fuzz for each packet."))
sniff.AddParam(session.NewBoolParameter("net.fuzz.silent",
mod.AddParam(session.NewBoolParameter("net.fuzz.silent",
"false",
"If true it will not report fuzzed packets."))
return sniff
return mod
}
func (s Sniffer) Name() string {
func (mod Sniffer) Name() string {
return "net.sniff"
}
func (s Sniffer) Description() string {
func (mod Sniffer) Description() string {
return "Sniff packets from the network."
}
func (s Sniffer) Author() string {
func (mod Sniffer) Author() string {
return "Simone Margaritelli <evilsocket@gmail.com>"
}
func (s Sniffer) isLocalPacket(packet gopacket.Packet) bool {
func (mod Sniffer) isLocalPacket(packet gopacket.Packet) bool {
ipl := packet.Layer(layers.LayerTypeIPv4)
if ipl != nil {
ip, _ := ipl.(*layers.IPv4)
if ip.SrcIP.Equal(s.Session.Interface.IP) || ip.DstIP.Equal(s.Session.Interface.IP) {
if ip.SrcIP.Equal(mod.Session.Interface.IP) || ip.DstIP.Equal(mod.Session.Interface.IP) {
return true
}
}
return false
}
func (s *Sniffer) onPacketMatched(pkt gopacket.Packet) {
if mainParser(pkt, s.Ctx.Verbose) {
s.Stats.NumDumped++
func (mod *Sniffer) onPacketMatched(pkt gopacket.Packet) {
if mainParser(pkt, mod.Ctx.Verbose) {
mod.Stats.NumDumped++
}
}
func (s *Sniffer) Configure() error {
func (mod *Sniffer) Configure() error {
var err error
if s.Running() {
if mod.Running() {
return session.ErrAlreadyStarted
} else if err, s.Ctx = s.GetContext(); err != nil {
if s.Ctx != nil {
s.Ctx.Close()
s.Ctx = nil
} else if err, mod.Ctx = mod.GetContext(); err != nil {
if mod.Ctx != nil {
mod.Ctx.Close()
mod.Ctx = nil
}
return err
}
@ -158,66 +158,66 @@ func (s *Sniffer) Configure() error {
return nil
}
func (s *Sniffer) Start() error {
if err := s.Configure(); err != nil {
func (mod *Sniffer) Start() error {
if err := mod.Configure(); err != nil {
return err
}
return s.SetRunning(true, func() {
s.Stats = NewSnifferStats()
return mod.SetRunning(true, func() {
mod.Stats = NewSnifferStats()
src := gopacket.NewPacketSource(s.Ctx.Handle, s.Ctx.Handle.LinkType())
s.pktSourceChan = src.Packets()
for packet := range s.pktSourceChan {
if !s.Running() {
s.Debug("end pkt loop (pkt=%v filter='%s')", packet, s.Ctx.Filter)
src := gopacket.NewPacketSource(mod.Ctx.Handle, mod.Ctx.Handle.LinkType())
mod.pktSourceChan = src.Packets()
for packet := range mod.pktSourceChan {
if !mod.Running() {
mod.Debug("end pkt loop (pkt=%v filter='%s')", packet, mod.Ctx.Filter)
break
}
now := time.Now()
if s.Stats.FirstPacket.IsZero() {
s.Stats.FirstPacket = now
if mod.Stats.FirstPacket.IsZero() {
mod.Stats.FirstPacket = now
}
s.Stats.LastPacket = now
mod.Stats.LastPacket = now
isLocal := s.isLocalPacket(packet)
isLocal := mod.isLocalPacket(packet)
if isLocal {
s.Stats.NumLocal++
mod.Stats.NumLocal++
}
if s.fuzzActive {
s.doFuzzing(packet)
if mod.fuzzActive {
mod.doFuzzing(packet)
}
if s.Ctx.DumpLocal || !isLocal {
if mod.Ctx.DumpLocal || !isLocal {
data := packet.Data()
if s.Ctx.Compiled == nil || s.Ctx.Compiled.Match(data) {
s.Stats.NumMatched++
if mod.Ctx.Compiled == nil || mod.Ctx.Compiled.Match(data) {
mod.Stats.NumMatched++
s.onPacketMatched(packet)
mod.onPacketMatched(packet)
if s.Ctx.OutputWriter != nil {
s.Ctx.OutputWriter.WritePacket(packet.Metadata().CaptureInfo, data)
s.Stats.NumWrote++
if mod.Ctx.OutputWriter != nil {
mod.Ctx.OutputWriter.WritePacket(packet.Metadata().CaptureInfo, data)
mod.Stats.NumWrote++
}
}
}
}
s.pktSourceChan = nil
mod.pktSourceChan = nil
})
}
func (s *Sniffer) Stop() error {
return s.SetRunning(false, func() {
s.Debug("stopping sniffer")
if s.pktSourceChan != nil {
s.Debug("sending nil")
s.pktSourceChan <- nil
s.Debug("nil sent")
func (mod *Sniffer) Stop() error {
return mod.SetRunning(false, func() {
mod.Debug("stopping sniffer")
if mod.pktSourceChan != nil {
mod.Debug("sending nil")
mod.pktSourceChan <- nil
mod.Debug("nil sent")
}
s.Debug("closing ctx")
s.Ctx.Close()
s.Debug("ctx closed")
mod.Debug("closing ctx")
mod.Ctx.Close()
mod.Debug("ctx closed")
})
}

16
modules/net_sniff/net_sniff_context.go
View file

@ -27,12 +27,12 @@ type SnifferContext struct {
OutputWriter *pcapgo.Writer
}
func (s *Sniffer) GetContext() (error, *SnifferContext) {
func (mod *Sniffer) GetContext() (error, *SnifferContext) {
var err error
ctx := NewSnifferContext()
if err, ctx.Source = s.StringParam("net.sniff.source"); err != nil {
if err, ctx.Source = mod.StringParam("net.sniff.source"); err != nil {
return err, ctx
}
@ -42,7 +42,7 @@ func (s *Sniffer) GetContext() (error, *SnifferContext) {
* could hang waiting for a timeout to expire ...
*/
readTimeout := 500 * time.Millisecond
if ctx.Handle, err = pcap.OpenLive(s.Session.Interface.Name(), 65536, true, readTimeout); err != nil {
if ctx.Handle, err = pcap.OpenLive(mod.Session.Interface.Name(), 65536, true, readTimeout); err != nil {
return err, ctx
}
} else {
@ -51,15 +51,15 @@ func (s *Sniffer) GetContext() (error, *SnifferContext) {
}
}
if err, ctx.Verbose = s.BoolParam("net.sniff.verbose"); err != nil {
if err, ctx.Verbose = mod.BoolParam("net.sniff.verbose"); err != nil {
return err, ctx
}
if err, ctx.DumpLocal = s.BoolParam("net.sniff.local"); err != nil {
if err, ctx.DumpLocal = mod.BoolParam("net.sniff.local"); err != nil {
return err, ctx
}
if err, ctx.Filter = s.StringParam("net.sniff.filter"); err != nil {
if err, ctx.Filter = mod.StringParam("net.sniff.filter"); err != nil {
return err, ctx
} else if ctx.Filter != "" {
err = ctx.Handle.SetBPFFilter(ctx.Filter)
@ -68,7 +68,7 @@ func (s *Sniffer) GetContext() (error, *SnifferContext) {
}
}
if err, ctx.Expression = s.StringParam("net.sniff.regexp"); err != nil {
if err, ctx.Expression = mod.StringParam("net.sniff.regexp"); err != nil {
return err, ctx
} else if ctx.Expression != "" {
if ctx.Compiled, err = regexp.Compile(ctx.Expression); err != nil {
@ -76,7 +76,7 @@ func (s *Sniffer) GetContext() (error, *SnifferContext) {
}
}
if err, ctx.Output = s.StringParam("net.sniff.output"); err != nil {
if err, ctx.Output = mod.StringParam("net.sniff.output"); err != nil {
return err, ctx
} else if ctx.Output != "" {
if ctx.OutputFile, err = os.Create(ctx.Output); err != nil {

52
modules/net_sniff/net_sniff_fuzz.go
View file

@ -21,10 +21,10 @@ var mutators = []func(byte) byte{
},
}
func (s *Sniffer) fuzz(data []byte) int {
func (mod *Sniffer) fuzz(data []byte) int {
changes := 0
for off, b := range data {
if rand.Float64() > s.fuzzRatio {
if rand.Float64() > mod.fuzzRatio {
continue
}
@ -34,19 +34,19 @@ func (s *Sniffer) fuzz(data []byte) int {
return changes
}
func (s *Sniffer) doFuzzing(pkt gopacket.Packet) {
if rand.Float64() > s.fuzzRate {
func (mod *Sniffer) doFuzzing(pkt gopacket.Packet) {
if rand.Float64() > mod.fuzzRate {
return
}
layersChanged := 0
bytesChanged := 0
for _, fuzzLayerType := range s.fuzzLayers {
for _, fuzzLayerType := range mod.fuzzLayers {
for _, layer := range pkt.Layers() {
if layer.LayerType().String() == fuzzLayerType {
fuzzData := layer.LayerContents()
changes := s.fuzz(fuzzData)
changes := mod.fuzz(fuzzData)
if changes > 0 {
layersChanged++
bytesChanged += changes
@ -57,62 +57,62 @@ func (s *Sniffer) doFuzzing(pkt gopacket.Packet) {
}
if bytesChanged > 0 {
logFn := s.Info
if s.fuzzSilent {
logFn = s.Debug
logFn := mod.Info
if mod.fuzzSilent {
logFn = mod.Debug
}
logFn("changed %d bytes in %d layers.", bytesChanged, layersChanged)
if err := s.Session.Queue.Send(pkt.Data()); err != nil {
s.Error("error sending fuzzed packet: %s", err)
if err := mod.Session.Queue.Send(pkt.Data()); err != nil {
mod.Error("error sending fuzzed packet: %s", err)
}
}
}
func (s *Sniffer) configureFuzzing() (err error) {
func (mod *Sniffer) configureFuzzing() (err error) {
layers := ""
if err, layers = s.StringParam("net.fuzz.layers"); err != nil {
if err, layers = mod.StringParam("net.fuzz.layers"); err != nil {
return
} else {
s.fuzzLayers = str.Comma(layers)
mod.fuzzLayers = str.Comma(layers)
}
if err, s.fuzzRate = s.DecParam("net.fuzz.rate"); err != nil {
if err, mod.fuzzRate = mod.DecParam("net.fuzz.rate"); err != nil {
return
}
if err, s.fuzzRatio = s.DecParam("net.fuzz.ratio"); err != nil {
if err, mod.fuzzRatio = mod.DecParam("net.fuzz.ratio"); err != nil {
return
}
if err, s.fuzzSilent = s.BoolParam("net.fuzz.silent"); err != nil {
if err, mod.fuzzSilent = mod.BoolParam("net.fuzz.silent"); err != nil {
return
}
return
}
func (s *Sniffer) StartFuzzing() error {
if s.fuzzActive {
func (mod *Sniffer) StartFuzzing() error {
if mod.fuzzActive {
return nil
}
if err := s.configureFuzzing(); err != nil {
if err := mod.configureFuzzing(); err != nil {
return err
} else if !s.Running() {
if err := s.Start(); err != nil {
} else if !mod.Running() {
if err := mod.Start(); err != nil {
return err
}
}
s.fuzzActive = true
mod.fuzzActive = true
s.Info("active on layer types %s (rate:%f ratio:%f)", strings.Join(s.fuzzLayers, ","), s.fuzzRate, s.fuzzRatio)
mod.Info("active on layer types %s (rate:%f ratio:%f)", strings.Join(mod.fuzzLayers, ","), mod.fuzzRate, mod.fuzzRatio)
return nil
}
func (s *Sniffer) StopFuzzing() error {
s.fuzzActive = false
func (mod *Sniffer) StopFuzzing() error {
mod.fuzzActive = false
return nil
}