overflow_backup_2018_0455/overflow_probe
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fixed test

Browse Source
This commit is contained in:
snoop 2017-08-09 12:21:34 +09:00
parent ac55bd8435
commit e2c14584b6
12 changed files with 562 additions and 547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
matcher/activedirectory/activedirectory_test.go
View File

@ -4,10 +4,12 @@ import (
"crypto/tls" "crypto/tls"
"net" "net"
"testing" "testing"
"fmt"
"git.loafle.net/overflow/overflow_probe/matcher/packet"
) )
func TestADNor(t *testing.T) { func TestADNor(t *testing.T) {
client, err := net.Dial("tcp", "192.168.1.1:389") client, err := net.Dial("tcp", "192.168.1.15:389")
if err != nil { if err != nil {
t.Log(err) t.Log(err)
@ -40,8 +42,8 @@ func TestADTLS(t *testing.T) {
func dDRun(client net.Conn, t *testing.T) { func dDRun(client net.Conn, t *testing.T) {
//lm := NewActiveDirectoryMatcher() lm := NewActiveDirectoryMatcher()
//
//port := types.NewPort("389", types.NewHost("192.168.1.1"), types.TYPE_TCP) //port := types.NewPort("389", types.NewHost("192.168.1.1"), types.TYPE_TCP)
// //
//var ipport string //var ipport string
@ -50,28 +52,28 @@ func dDRun(client net.Conn, t *testing.T) {
//fmt.Println(ipport) //fmt.Println(ipport)
// //
//fmt.Println(lm.PacketCount()) //fmt.Println(lm.PacketCount())
//
//for ii := 0; ii < lm.PacketCount(); ii++ { for ii := 0; ii < lm.PacketCount(); ii++ {
//
// pack := lm.Packet(ii) pack := lm.Packet(ii)
//
// fmt.Println(pack) fmt.Println(pack)
//
// client.Write(pack.Buffer) client.Write(pack.Buffer)
//
// bytes := make([]byte, 1024) bytes := make([]byte, 1024)
//
// read, _ := client.Read(bytes) read, _ := client.Read(bytes)
//
// fmt.Println(bytes) fmt.Println(bytes)
//
// b := lm.Match(ii, packet.NewPacket(bytes, read), scanInfo) b := lm.Match(ii, packet.NewPacket(bytes, read), nil)
//
// if b { if b {
// fmt.Println("Good") fmt.Println("Good")
// } }
//
//} }
//
//t.Log(scanInfo)
} }

374
matcher/dhcp/dhcp.go
View File

@ -1,188 +1,190 @@
package dhcp package dhcp
//
//import ( import (
// "bytes" "bytes"
// "encoding/binary" "encoding/binary"
// "fmt" "fmt"
// log "github.com/cihub/seelog" log "github.com/cihub/seelog"
// "git.loafle.net/overflow/overflow_probe/matcher" //"git.loafle.net/overflow/overflow_probe/matcher"
// "net" "net"
// "time" "time"
//)
// "git.loafle.net/overflow/overflow_probe/discovery/discovery/types"
//const ( )
// MAGIC_COOKIE uint32 = 0x63825363
// OPT_CODE_SERVER_IDENTIFIER uint8 = 54 const (
// OPT_CODE_SUBNET_MASK uint8 = 1 MAGIC_COOKIE uint32 = 0x63825363
// OPT_CODE_ROUTER uint8 = 3 OPT_CODE_SERVER_IDENTIFIER uint8 = 54
// OPT_CODE_DNS uint8 = 6 OPT_CODE_SUBNET_MASK uint8 = 1
//) OPT_CODE_ROUTER uint8 = 3
// OPT_CODE_DNS uint8 = 6
//type dhcpDiscover struct { )
// MsgType byte
// HwType byte type dhcpDiscover struct {
// HwAddrLen byte MsgType byte
// Hops byte HwType byte
// Xid uint32 HwAddrLen byte
// Secs uint16 Hops byte
// BootpFlags uint16 Xid uint32
// ClientIp uint32 Secs uint16
// YourIp uint32 BootpFlags uint16
// NextServerIp uint32 ClientIp uint32
// RelayAgentIp uint32 YourIp uint32
// ClientMacAddr [6]byte NextServerIp uint32
// ClientHwAddrPadding [10]byte RelayAgentIp uint32
// ServerHostName [64]byte ClientMacAddr [6]byte
// BootFileName [128]byte ClientHwAddrPadding [10]byte
// MagicCookie uint32 ServerHostName [64]byte
// Mtype byte BootFileName [128]byte
// MtypeLen byte MagicCookie uint32
// MtypeVal byte Mtype byte
// Opts [200]byte MtypeLen byte
// End byte MtypeVal byte
// Padding [16]byte Opts [200]byte
//} End byte
// Padding [16]byte
//func DiscoverDHCP(zone *types.DiscoveryZone) { }
// err := sendDHCPDiscovery()
// if err != nil { func DiscoverDHCP(zone *types.DiscoveryZone) {
// log.Error(err) err := sendDHCPDiscovery()
// return if err != nil {
// } log.Error(err)
// recvDHCPOffer(zone) return
//} }
// recvDHCPOffer(zone)
//func sendDHCPDiscovery() error { }
// dhcp := dhcpDiscover{
// MsgType: 0x01, func sendDHCPDiscovery() error {
// HwType: 0x01, dhcp := dhcpDiscover{
// HwAddrLen: 0x06, MsgType: 0x01,
// Hops: 0x00, HwType: 0x01,
// Xid: 0x00000000, HwAddrLen: 0x06,
// Secs: 0x0000, Hops: 0x00,
// ClientIp: 0x00000000, Xid: 0x00000000,
// YourIp: 0x00000000, Secs: 0x0000,
// NextServerIp: 0x00000000, ClientIp: 0x00000000,
// RelayAgentIp: 0x00000000, YourIp: 0x00000000,
// MagicCookie: MAGIC_COOKIE, NextServerIp: 0x00000000,
// Mtype: 0x35, RelayAgentIp: 0x00000000,
// MtypeLen: 0x01, MagicCookie: MAGIC_COOKIE,
// MtypeVal: 0x01, Mtype: 0x35,
// End: 0xff, MtypeLen: 0x01,
// } MtypeVal: 0x01,
// End: 0xff,
// var flag uint16 = 0 }
// dhcp.BootpFlags = ^flag // flag = unicast , ^flag = broadcast
// var flag uint16 = 0
// //TODO : getting mac addr from zone dhcp.BootpFlags = ^flag // flag = unicast , ^flag = broadcast
// dhcp.ClientMacAddr[0] = 0x50
// dhcp.ClientMacAddr[1] = 0xe5 //TODO : getting mac addr from zone
// dhcp.ClientMacAddr[2] = 0x49 dhcp.ClientMacAddr[0] = 0x50
// dhcp.ClientMacAddr[3] = 0x46 dhcp.ClientMacAddr[1] = 0xe5
// dhcp.ClientMacAddr[4] = 0x93 dhcp.ClientMacAddr[2] = 0x49
// dhcp.ClientMacAddr[5] = 0x28 dhcp.ClientMacAddr[3] = 0x46
// dhcp.ClientMacAddr[4] = 0x93
// writer := new(bytes.Buffer) dhcp.ClientMacAddr[5] = 0x28
// binary.Write(writer, binary.BigEndian, dhcp)
// conn, err := net.Dial("udp", "255.255.255.255:67") writer := new(bytes.Buffer)
// if err != nil { binary.Write(writer, binary.BigEndian, dhcp)
// return err conn, err := net.Dial("udp", "255.255.255.255:67")
// } if err != nil {
// conn.Write(writer.Bytes()) return err
// defer conn.Close() }
// conn.Write(writer.Bytes())
// return nil defer conn.Close()
//}
// return nil
//func recvDHCPOffer(zone *types.DiscoveryZone) { }
//
// socket, err := net.ListenUDP("udp4", &net.UDPAddr{ func recvDHCPOffer(zone *types.DiscoveryZone) {
// IP: net.IPv4(255, 255, 255, 255),
// Port: 68, socket, err := net.ListenUDP("udp4", &net.UDPAddr{
// }) IP: net.IPv4(255, 255, 255, 255),
// if err != nil { Port: 68,
// log.Error(err) })
// return if err != nil {
// } log.Error(err)
// err = socket.SetDeadline(time.Now().Add(3 * time.Second)) return
// if err != nil { }
// log.Error(err) err = socket.SetDeadline(time.Now().Add(3 * time.Second))
// return if err != nil {
// } log.Error(err)
// return
// buf := make([]byte, 4096) }
// n, _, err := socket.ReadFromUDP(buf)
// if err != nil { buf := make([]byte, 4096)
// log.Error(err) n, _, err := socket.ReadFromUDP(buf)
// return if err != nil {
// } log.Error(err)
// if n <= 0 { return
// log.Error("No DHCP offer.") }
// return if n <= 0 {
// } log.Error("No DHCP offer.")
// return
// offer := dhcpDiscover{} }
//
// reader := new(bytes.Buffer) offer := dhcpDiscover{}
// reader.Write(buf)
// if err := binary.Read(reader, binary.BigEndian, &offer); err != nil { reader := new(bytes.Buffer)
// log.Error(err) reader.Write(buf)
// return if err := binary.Read(reader, binary.BigEndian, &offer); err != nil {
// } log.Error(err)
// if offer.MagicCookie != MAGIC_COOKIE { return
// log.Error("Not a DHCP packet.") }
// return if offer.MagicCookie != MAGIC_COOKIE {
// } log.Error("Not a DHCP packet.")
// return
// //option searching }
// r := new(bytes.Buffer)
// r.Write(offer.Opts[:]) //option searching
// r := new(bytes.Buffer)
// for i := 0; i < r.Len(); i++ { r.Write(offer.Opts[:])
// v := r.Next(1)[0]
// for i := 0; i < r.Len(); i++ {
// if v == OPT_CODE_SUBNET_MASK && r.Next(1)[0] == 4 { v := r.Next(1)[0]
// ipStr := byteToIpString(r.Next(4))
// log.Infof("SUBNET MASK: %s", ipStr) if v == OPT_CODE_SUBNET_MASK && r.Next(1)[0] == 4 {
// } ipStr := byteToIpString(r.Next(4))
// log.Infof("SUBNET MASK: %s", ipStr)
// if v == OPT_CODE_ROUTER && r.Next(1)[0] == 4 { }
// ipStr := byteToIpString(r.Next(4))
// log.Infof("ROUTER: %s", ipStr) if v == OPT_CODE_ROUTER && r.Next(1)[0] == 4 {
// } ipStr := byteToIpString(r.Next(4))
// log.Infof("ROUTER: %s", ipStr)
// if v == OPT_CODE_DNS { }
// len := r.Next(1)[0]
// var dns []string = make([]string, 0) if v == OPT_CODE_DNS {
// var ipStr string len := r.Next(1)[0]
// ipStr = byteToIpString(r.Next(4)) var dns []string = make([]string, 0)
// dns = append(dns, ipStr) var ipStr string
// if len == 8 { ipStr = byteToIpString(r.Next(4))
// ipStr = byteToIpString(r.Next(4)) dns = append(dns, ipStr)
// dns = append(dns, ipStr) if len == 8 {
// } ipStr = byteToIpString(r.Next(4))
// log.Infof("DNS", dns) dns = append(dns, ipStr)
// } }
// log.Infof("DNS", dns)
// if v == OPT_CODE_SERVER_IDENTIFIER && r.Next(1)[0] == 4 { }
// ipStr := byteToIpString(r.Next(4))
// log.Infof("DHCP SERVER: %s", ipStr) if v == OPT_CODE_SERVER_IDENTIFIER && r.Next(1)[0] == 4 {
// } ipStr := byteToIpString(r.Next(4))
// } log.Infof("DHCP SERVER: %s", ipStr)
// }
//} }
//
//func byteToIpString(b []byte) string { }
// var ipStr string
// len := len(b) func byteToIpString(b []byte) string {
// for i := 0; i < len; i++ { var ipStr string
// v := b[i] len := len(b)
// ipStr += fmt.Sprintf("%d", v) for i := 0; i < len; i++ {
// if i < len-1 { v := b[i]
// ipStr += "." ipStr += fmt.Sprintf("%d", v)
// } if i < len-1 {
// } ipStr += "."
// }
// return ipStr }
//}
return ipStr
}

20
matcher/dhcp/dhcp_test.go
View File

@ -1,12 +1,12 @@
package dhcp package dhcp
//
//import ( import (
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/zone" "git.loafle.net/overflow/overflow_probe/discovery/core/scan/zone"
// "testing" "testing"
//) )
//
//func TestDHCP(t *testing.T) { func TestDHCP(t *testing.T) {
// zone := zone.NewZone() zone := zone.NewZone()
// DiscoverDHCP(zone) DiscoverDHCP(zone)
//} }

62
matcher/dns/dns_test.go
View File

@ -1,33 +1,33 @@
package dns package dns
//import ( import (
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "net" "net"
// "testing" "testing"
//) )
//
//func TestDns(t *testing.T) { func TestDns(t *testing.T) {
// m := NewDnsMatcher() m := NewDnsMatcher()
//
// conn, _ := net.Dial("udp", "192.168.1.215:53") conn, _ := net.Dial("udp", "168.126.63.1:53")
//
// defer conn.Close() defer conn.Close()
//
// for i := 0; i < m.PacketCount(); i++ { for i := 0; i < m.PacketCount(); i++ {
// if m.IsSend(53) != true { if m.IsSend(53) != true {
// t.Error("not port") t.Error("not port")
// } }
// pack := m.Packet(i) pack := m.Packet(i)
// conn.Write(pack.Buffer) conn.Write(pack.Buffer)
// bytes := make([]byte, 1024) bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes) n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n) p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) { if m.Match(i, p, nil) {
// t.Log("dns found") t.Log("dns found")
// return return
// } }
//
// t.Error("dns not found") t.Error("dns not found")
// } }
//} }

94
matcher/http/http_test.go
View File

@ -1,49 +1,49 @@
package http package http
//import ( import (
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/types" //"git.loafle.net/overflow/overflow_probe/discovery/discovery/types"
// "net" "net"
// "testing" "testing"
//) )
//
//func TestHTTPMatcher_Packet(t *testing.T) { func TestHTTPMatcher_Packet(t *testing.T) {
// hm := NewHTTPMatcher() hm := NewHTTPMatcher()
// fmt.Println(hm) fmt.Println(hm)
// fmt.Println(hm.sendPackets[0]) fmt.Println(hm.sendPackets[0])
//
//} }
//
//func TestHTTPMatcher_Match(t *testing.T) { func TestHTTPMatcher_Match(t *testing.T) {
// fmt.Println("Match") fmt.Println("Match")
//
// hm := NewHTTPMatcher() hm := NewHTTPMatcher()
//
// port := types.NewPort("80", types.NewHost("192.168.1.103"), types.TYPE_TCP) //port := types.NewPort("80", types.NewHost("192.168.1.103"), types.TYPE_TCP)
// //
// var ipport string //var ipport string
// ipport = port.Host.Ip + ":" + string(port.Port) //ipport = port.Host.Ip + ":" + string(port.Port)
//
// //fmt.Println(ipport) //fmt.Println(ipport)
//
// client, _ := net.Dial("tcp", ipport) client, _ := net.Dial("tcp", "192.168.1.15:38980")
//
// defer client.Close() defer client.Close()
//
// pack := hm.Packet(0) pack := hm.Packet(0)
//
// //fmt.Println(pack) //fmt.Println(pack)
//
// //writer.WriteString(pack) //writer.WriteString(pack)
// client.Write(pack.Buffer) client.Write(pack.Buffer)
//
// bytes := make([]byte, 512) bytes := make([]byte, 512)
//
// l, _ := client.Read(bytes) l, _ := client.Read(bytes)
//
// //fmt.Println(bytes) //fmt.Println(bytes)
//
// hm.Match(0, packet.NewPacket(bytes, l), nil) hm.Match(0, packet.NewPacket(bytes, l), nil)
//
//} }

106
matcher/http/https_test.go
View File

@ -1,55 +1,55 @@
package http package http
//import ( import (
// "crypto/tls" "crypto/tls"
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/scan/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "log" "log"
// "net" "net"
// "testing" "testing"
// "time" "time"
//) )
//
//func TestHTTPSMatcher_Match(t *testing.T) { func TestHTTPSMatcher_Match(t *testing.T) {
// netinfo := "192.168.1.1:443" netinfo := "192.168.1.10:10443"
// dialer := &net.Dialer{ dialer := &net.Dialer{
// Timeout: 5 * time.Second, Timeout: 5 * time.Second,
// } }
//
// conn, err := tls.DialWithDialer( conn, err := tls.DialWithDialer(
// dialer, dialer,
// "tcp", "tcp",
// netinfo, netinfo,
// &tls.Config{ &tls.Config{
// InsecureSkipVerify: true, InsecureSkipVerify: true,
// ServerName: "192.168.1.103", ServerName: "192.168.1.103",
// }, },
// ) )
//
// if err != nil { if err != nil {
// log.Println(err) log.Println(err)
// return return
// } }
// defer conn.Close() defer conn.Close()
//
// //fmt.Println(conn) //fmt.Println(conn)
// h := NewHTTPMatcher() h := NewHTTPMatcher()
//
// pac := h.Packet(0) pac := h.Packet(0)
//
// //fmt.Println(pac) //fmt.Println(pac)
// //fmt.Println(pac.Buffer) //fmt.Println(pac.Buffer)
//
// //bytes := make([]byte, 1024) //bytes := make([]byte, 1024)
//
// l, _ := conn.Write(pac.Buffer) l, _ := conn.Write(pac.Buffer)
//
// buf := make([]byte, 1024) buf := make([]byte, 1024)
// l, _ = conn.Read(buf) l, _ = conn.Read(buf)
//
// fmt.Println(string(buf)) fmt.Println(string(buf))
// fmt.Println(l) fmt.Println(l)
// is := h.Match(0, packet.NewPacket(buf, l), nil) is := h.Match(0, packet.NewPacket(buf, l), nil)
// fmt.Println(is) fmt.Println(is)
//
//} }

2
matcher/mysql/mysql_test.go
View File

@ -17,7 +17,7 @@ func TestMySql(t *testing.T) {
192.168.1.105:8306 - ssl 192.168.1.105:8306 - ssl
192.168.1.203:3306 - mysql with error code 192.168.1.203:3306 - mysql with error code
*/ */
conn, _ := net.Dial("tcp", "192.168.1.15:3306") conn, _ := net.Dial("tcp", "192.168.1.15:33068")
defer conn.Close() defer conn.Close()

96
matcher/rmi/rmi_test.go
View File

@ -1,48 +1,52 @@
package rmi package rmi
//import ( import (
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/types" //"git.loafle.net/overflow/overflow_probe/discovery/discovery/types"
// "net" "net"
// "testing" "testing"
//) )
//
//func TestNew(t *testing.T) { func TestNew(t *testing.T) {
// r := NewRMIMatcher() r := NewRMIMatcher()
// fmt.Println("TestNew: ", r) fmt.Println("TestNew: ", r)
//} }
//func TestRMIMatcher_Match(t *testing.T) { func TestRMIMatcher_Match(t *testing.T) {
//
// fmt.Println("Match") fmt.Println("Match")
//
// hm := NewRMIMatcher() hm := NewRMIMatcher()
//
// port := types.NewPort("9840", types.NewHost("192.168.1.101"), types.TYPE_TCP) //port := types.NewPort("9840", types.NewHost("192.168.1.101"), types.TYPE_TCP)
// //
// var ipport string //var ipport string
// ipport = port.Host.Ip + ":" + string(port.Port) //ipport = port.Host.Ip + ":" + string(port.Port)
//
// //fmt.Println(ipport) //fmt.Println(ipport)
//
// client, _ := net.Dial("tcp", ipport) client, err := net.Dial("tcp", "192.168.1.101:9840")
//
// defer client.Close() if err != nil {
// t.Fatal(err)
// pack := hm.Packet(0) }
//
// fmt.Println(pack.Buffer) defer client.Close()
//
// //writer.WriteString(pack) pack := hm.Packet(0)
// client.Write(pack.Buffer)
// fmt.Println(pack.Buffer)
// bytes := make([]byte, 512)
// //writer.WriteString(pack)
// l, _ := client.Read(bytes) client.Write(pack.Buffer)
//
// //fmt.Println(bytes) bytes := make([]byte, 512)
//
// t1 := hm.Match(0, packet.NewPacket(bytes, l), nil) l, _ := client.Read(bytes)
//
// fmt.Println(t1) //fmt.Println(bytes)
//}
t1 := hm.Match(0, packet.NewPacket(bytes, l), nil)
fmt.Println(t1)
}

75
matcher/smb/smb_test.go
View File

@ -1,37 +1,42 @@
package smb package smb
//import ( import (
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "net" "net"
// "testing" "testing"
//) )
//
//const ( const (
// ADDR string = "192.168.1.104:139" ADDR string = "192.168.1.106:139"
//) )
//
//func TestSMBMatcher(t *testing.T) { func TestSMBMatcher(t *testing.T) {
//
// m := NewSMBMatcher() m := NewSMBMatcher()
//
// conn, _ := net.Dial("tcp", ADDR) conn, err := net.Dial("tcp", ADDR)
// defer conn.Close()
// if err != nil {
// for i := 0; i < m.PacketCount(); i++ { t.Fatal(err)
// }
// pack := m.Packet(i)
// conn.Write(pack.Buffer) defer conn.Close()
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes) for i := 0; i < m.PacketCount(); i++ {
//
// p := packet.NewPacket(bytes, n) pack := m.Packet(i)
// conn.Write(pack.Buffer)
// if m.Match(i, p, nil) { bytes := make([]byte, 1024)
// t.Log("SMB found.") n, _ := conn.Read(bytes)
// return
// } p := packet.NewPacket(bytes, n)
//
// t.Error("SMB not found") if m.Match(i, p, nil) {
// } t.Log("SMB found.")
// return
//} }
t.Error("SMB not found")
}
}

64
matcher/ssh/ssh_test.go
View File

@ -1,33 +1,35 @@
package ssh package ssh
//import ( import (
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" //"git.loafle.net/overflow/overflow_probe/matcher/ssh"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/types" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "net" //"git.loafle.net/overflow/overflow_probe/collector/discovery/types"
// "testing" "net"
//) "testing"
//
//func TestSSHMatcher_Match(t *testing.T) { )
//
// port := types.NewPort("22", types.NewHost("192.168.1.103"), types.TYPE_TCP) func TestSSHMatcher_Match(t *testing.T) {
// ssh := NewSSHMatcher()
// //port := types.NewPort("22", types.NewHost("192.168.1.103"), types.TYPE_TCP)
// var ipport string //ssh := NewSSHMatcher()
// ipport = port.Host.Ip + ":" + string(port.Port) //
// //var ipport string
// client, _ := net.Dial("tcp", ipport) //ipport = port.Host.Ip + ":" + string(port.Port)
//
// defer client.Close() client, _ := net.Dial("tcp", "192.168.1.10:22")
//
// bytes := make([]byte, 512) defer client.Close()
//
// l, _ := client.Read(bytes) bytes := make([]byte, 512)
//
// fmt.Println(bytes) l, _ := client.Read(bytes)
//
// b := ssh.Match(0, packet.NewPacket(bytes, l), nil) fmt.Println(bytes)
//
// fmt.Println(b) b := NewSSHMatcher().Match(0, packet.NewPacket(bytes, l), nil)
//
//} fmt.Println(b)
}

62
matcher/telnet/telnet_test.go
View File

@ -1,33 +1,33 @@
package telnet package telnet
//import ( import (
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/core/scan/service/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/types"
// "net" "net"
// "testing" "testing"
//) )
//
//func TestTelnetMatcher_Match(t *testing.T) { func TestTelnetMatcher_Match(t *testing.T) {
//
// port := types.NewPort("23", types.NewHost("192.168.1.210"), types.TYPE_TCP) //port := types.NewPort("23", types.NewHost("192.168.1.210"), types.TYPE_TCP)
// telnet := NewTelnetMatcher() //telnet := NewTelnetMatcher()
// //
// var ipport string //var ipport string
// ipport = port.Host.Ip + ":" + string(port.Port) //ipport = port.Host.Ip + ":" + string(port.Port)
//
// client, _ := net.Dial("tcp", ipport) client, _ := net.Dial("tcp", "192.168.1.105:23")
//
// defer client.Close() defer client.Close()
//
// bytes := make([]byte, 512) bytes := make([]byte, 512)
//
// l, _ := client.Read(bytes) l, _ := client.Read(bytes)
//
// fmt.Println("length :", l) fmt.Println("length :", l)
// fmt.Println(bytes) fmt.Println(bytes)
//
// b := telnet.Match(0, packet.NewPacket(bytes, l), nil) b := NewTelnetMatcher().Match(0, packet.NewPacket(bytes, l), nil)
//
// fmt.Println(b) fmt.Println(b)
//} }

98
matcher/wmi/wmi_test.go
View File

@ -1,51 +1,51 @@
package wmi package wmi
//import ( import (
// "fmt" "fmt"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/scan/matcher/packet" "git.loafle.net/overflow/overflow_probe/matcher/packet"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/scan/matcher/scaninfo" //"git.loafle.net/overflow/overflow_probe/collector/discovery/scan/matcher/scaninfo"
// "git.loafle.net/overflow/overflow_probe/collector/discovery/types" //"git.loafle.net/overflow/overflow_probe/collector/discovery/types"
// "net" "net"
// "testing" "testing"
//) )
//
//func TestWMI(t *testing.T) { func TestWMI(t *testing.T) {
//
// lm := NewWMIMatcher() lm := NewWMIMatcher()
//
// port := types.NewPort("135", types.NewHost("192.168.1.1"), types.TYPE_TCP) //port := types.NewPort("135", types.NewHost("192.168.1.1"), types.TYPE_TCP)
// scanInfo := scaninfo.NewServiceScanInfo(port) //scanInfo := scaninfo.NewServiceScanInfo(port)
// var ipport string //var ipport string
// ipport = port.Host.Ip + ":" + string(port.Port) //ipport = port.Host.Ip + ":" + string(port.Port)
//
// fmt.Println(ipport) //fmt.Println(ipport)
// client, _ := net.Dial("tcp", ipport) client, _ := net.Dial("tcp", "192.168.1.106:135")
//
// defer client.Close() defer client.Close()
//
// fmt.Println(lm.PacketCount()) fmt.Println(lm.PacketCount())
//
// for ii := 0; ii < lm.PacketCount(); ii++ { for ii := 0; ii < lm.PacketCount(); ii++ {
//
// pack := lm.Packet(ii) pack := lm.Packet(ii)
//
// fmt.Println(pack) fmt.Println(pack)
//
// client.Write(pack.Buffer) client.Write(pack.Buffer)
//
// bytes := make([]byte, 1024) bytes := make([]byte, 1024)
//
// read, _ := client.Read(bytes) read, _ := client.Read(bytes)
//
// //fmt.Println(bytes) //fmt.Println(bytes)
//
// b := lm.Match(ii, packet.NewPacket(bytes, read), scanInfo) b := lm.Match(ii, packet.NewPacket(bytes, read), nil)
//
// if b { if b {
// fmt.Println("Good") fmt.Println("Good")
// } }
//
// } }
//
// t.Log(scanInfo)
//} }