ing

service/matcher/http/http.go

@@ -0,0 +1,81 @@
+package http
+
+import (
+	"strings"
+
+	"git.loafle.net/overflow/overflow_discovery/service/matcher"
+)
+
+type HTTPMatcher struct {
+	matcher.Matchers
+}
+
+func (h *HTTPMatcher) ServiceName() string {
+	return "HTTP"
+}
+
+func (h *HTTPMatcher) IsPrePacket() bool {
+	return false
+}
+
+func (h *HTTPMatcher) HasResponse(index int) bool {
+	return true
+}
+
+func (h *HTTPMatcher) IsError(info matcher.MatchInfo, index int, packet *matcher.Packet) bool {
+	return false
+}
+
+func (h *HTTPMatcher) Match(info matcher.MatchInfo, index int, packet *matcher.Packet) bool {
+	result := false
+
+	if packet == nil || packet.Buffer == nil || packet.Len == 0 {
+		return result
+	}
+
+	str := string(packet.Buffer)
+	//fmt.Println(str)
+	elems := strings.Split(str, "\r\n")
+
+	if len(elems) <= 0 {
+		return result
+	}
+
+	protocol := (elems[0])[:8]
+
+	httpv0 := strings.Compare(protocol, "HTTP/1.0")
+	httpv1 := strings.Compare(protocol, "HTTP/1.1")
+	httpv2 := strings.Compare(protocol, "HTTP/1.2")
+
+	if 0 == httpv0 || 0 == httpv1 || 0 == httpv2 {
+		result = true
+	}
+
+	serverName := "Unknown Server"
+
+	for _, valueStr := range elems {
+		tempElems := strings.Split(valueStr, ":")
+
+		if 0 == strings.Compare(tempElems[0], "Server") {
+			serverName = tempElems[1]
+			break
+		}
+	}
+
+	strings.Compare(serverName, "Unknown")
+	//fmt.Println("HTTP Server Name: ", serverName)
+
+	return result
+}
+
+func NewMatcher() matcher.Matcher {
+
+	m := &HTTPMatcher{}
+	reqStr := "GET / HTTP/1.1\r\n\r\n"
+	byte := make([]byte, len(reqStr))
+	copy(byte[:], reqStr)
+
+	m.AddPacket(matcher.NewPacket(byte, len(reqStr)))
+
+	return m
+}

service/matcher/http/http_test.go

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

service/matcher/http/https_test.go

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