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

added crawler

Browse Source
This commit is contained in:
snoop 2017-08-04 11:27:37 +09:00
parent 4b2ea88929
commit 7ec9a326fd
59 changed files with 6399 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

79
crawler/crawler.go Normal file
View File

@ -0,0 +1,79 @@
package crawler
import (
"encoding/json"
"errors"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
"log"
)
type Internal interface {
Internal(params config.Config) ([]byte, error)
}
type Crawler interface {
Init(path []byte) ([]byte, error)
Add(data []byte) ([]byte, error)
Remove(id string) ([]byte, error)
Get(id string) ([]byte, error)
}
type CrawlerImpl struct {
Crawler
configs map[string]config.Config
internal Internal
}
func (c *CrawlerImpl) Init(data []byte) ([]byte, error) {
if c.configs == nil {
c.configs = make(map[string]config.Config, 0)
}
_, err := c.Add(data)
if err != nil {
log.Fatal(err)
}
// load all file in path
return json.Marshal(true)
}
func (c *CrawlerImpl) Add(data []byte) ([]byte, error) {
var m = config.Config{}
json.Unmarshal(data, &m)
c.configs[m.Id] = m
return json.Marshal(true)
}
func (c *CrawlerImpl) Remove(id string) ([]byte, error) {
//remove in config
delete(c.configs, id)
return json.Marshal(true)
}
func (c *CrawlerImpl) Get(id string) ([]byte, error) {
if c.internal != nil {
out, err := c.internal.Internal(c.GetConfig(id))
if err != nil {
//set error fail, message
return nil, err
}
return out, nil
}
return nil, errors.New("Not Assigned")
}
// internal methods
func (c *CrawlerImpl) GetConfig(id string) config.Config {
return c.configs[id]
}
func (c *CrawlerImpl) SetInternal(i Internal) {
c.internal = i
}
func (c *CrawlerImpl) PutConfig(name string, m config.Config) {
if c.configs == nil {
c.configs = make(map[string]config.Config, 0)
}
c.configs[name] = m
}

47
crawler/crawler_generalization_test.go Normal file
View File

@ -0,0 +1,47 @@
package crawler
import (
"fmt"
"testing"
)
type Super interface {
Method()
}
type sss struct{}
func (s *sss) Method() {
fmt.Println("Super")
}
type Child struct {
sss
}
func (c *Child) Method() {
c.sss.Method()
fmt.Println("Child")
}
func TestGene(t *testing.T) {
c := Child{}
c.Method()
var s Super = &Child{}
s.Method()
}
func TestExistInterface(t *testing.T) {
m := make(map[string]Super, 0)
m["test"] = &Child{}
_, ok := m["test1"]
if ok {
fmt.Println(ok)
} else {
fmt.Println(ok)
}
}

19
crawler/crawler_map_convert_test.go Normal file
View File

@ -0,0 +1,19 @@
package crawler
import (
"fmt"
"testing"
)
func TestInterfaceValueToTypeCast(t *testing.T) {
m := make(map[string]interface{})
m["a"] = "1"
m["b"] = 2
m["c"] = false
fmt.Println(m["a"].(string))
fmt.Println(m["b"].(int))
fmt.Println(m["c"].(bool))
}

1
crawler/grpc/cmd.txt Normal file
View File

@ -0,0 +1 @@
protoc -I grpc/ grpc/grpc.proto --go_out=plugins=grpc:grpc

612
crawler/grpc/grpc.pb.go Normal file
View File

@ -0,0 +1,612 @@
// Code generated by protoc-gen-go.
// source: grpc.proto
// DO NOT EDIT!
/*
Package grpc is a generated protocol buffer package.
It is generated from these files:
grpc.proto
It has these top-level messages:
Empty
Boolean
InputArray
Init
Input
InputAdd
Output
*/
package grpc
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import (
context "golang.org/x/net/context"
grpc1 "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Crawlers int32
const (
Crawlers_HEALTH_ACTIVEDIRECTORY Crawlers = 0
Crawlers_HEALTH_DNS Crawlers = 1
Crawlers_HEALTH_FTP Crawlers = 2
Crawlers_HEALTH_FTPS Crawlers = 3
Crawlers_HEALTH_IMAP Crawlers = 4
Crawlers_HEALTH_LDAP Crawlers = 5
Crawlers_HEALTH_MONGODB Crawlers = 6
Crawlers_HEALTH_MSSQL Crawlers = 7
Crawlers_HEALTH_MYSQL Crawlers = 8
Crawlers_HEALTH_MARIADB Crawlers = 9
Crawlers_HEALTH_PGSQL Crawlers = 10
Crawlers_HEALTH_NETBIOS Crawlers = 11
Crawlers_HEALTH_ORACLE Crawlers = 12
Crawlers_HEALTH_POP3 Crawlers = 13
Crawlers_HEALTH_REDIS Crawlers = 14
Crawlers_HEALTH_RMI Crawlers = 15
Crawlers_HEALTH_SMB Crawlers = 16
Crawlers_HEALTH_SMTP Crawlers = 17
Crawlers_HEALTH_SNMPV2C Crawlers = 18
Crawlers_HEALTH_SNMPV3 Crawlers = 19
Crawlers_HEALTH_SSH Crawlers = 20
Crawlers_HEALTH_TELNET Crawlers = 21
Crawlers_HEALTH_WMI Crawlers = 22
Crawlers_HEALTH_CASSANDRA Crawlers = 23
Crawlers_HEALTH_HTTP Crawlers = 24
Crawlers_SQL Crawlers = 25
Crawlers_SNMP Crawlers = 26
Crawlers_WMI Crawlers = 27
Crawlers_JMX Crawlers = 28
Crawlers_REDIS Crawlers = 29
Crawlers_MONGODB Crawlers = 30
)
var Crawlers_name = map[int32]string{
0: "HEALTH_ACTIVEDIRECTORY",
1: "HEALTH_DNS",
2: "HEALTH_FTP",
3: "HEALTH_FTPS",
4: "HEALTH_IMAP",
5: "HEALTH_LDAP",
6: "HEALTH_MONGODB",
7: "HEALTH_MSSQL",
8: "HEALTH_MYSQL",
9: "HEALTH_MARIADB",
10: "HEALTH_PGSQL",
11: "HEALTH_NETBIOS",
12: "HEALTH_ORACLE",
13: "HEALTH_POP3",
14: "HEALTH_REDIS",
15: "HEALTH_RMI",
16: "HEALTH_SMB",
17: "HEALTH_SMTP",
18: "HEALTH_SNMPV2C",
19: "HEALTH_SNMPV3",
20: "HEALTH_SSH",
21: "HEALTH_TELNET",
22: "HEALTH_WMI",
23: "HEALTH_CASSANDRA",
24: "HEALTH_HTTP",
25: "SQL",
26: "SNMP",
27: "WMI",
28: "JMX",
29: "REDIS",
30: "MONGODB",
}
var Crawlers_value = map[string]int32{
"HEALTH_ACTIVEDIRECTORY": 0,
"HEALTH_DNS": 1,
"HEALTH_FTP": 2,
"HEALTH_FTPS": 3,
"HEALTH_IMAP": 4,
"HEALTH_LDAP": 5,
"HEALTH_MONGODB": 6,
"HEALTH_MSSQL": 7,
"HEALTH_MYSQL": 8,
"HEALTH_MARIADB": 9,
"HEALTH_PGSQL": 10,
"HEALTH_NETBIOS": 11,
"HEALTH_ORACLE": 12,
"HEALTH_POP3": 13,
"HEALTH_REDIS": 14,
"HEALTH_RMI": 15,
"HEALTH_SMB": 16,
"HEALTH_SMTP": 17,
"HEALTH_SNMPV2C": 18,
"HEALTH_SNMPV3": 19,
"HEALTH_SSH": 20,
"HEALTH_TELNET": 21,
"HEALTH_WMI": 22,
"HEALTH_CASSANDRA": 23,
"HEALTH_HTTP": 24,
"SQL": 25,
"SNMP": 26,
"WMI": 27,
"JMX": 28,
"REDIS": 29,
"MONGODB": 30,
}
func (x Crawlers) String() string {
return proto.EnumName(Crawlers_name, int32(x))
}
func (Crawlers) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
type Empty struct {
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
func (*Empty) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
type Boolean struct {
Check bool `protobuf:"varint,1,opt,name=check" json:"check,omitempty"`
}
func (m *Boolean) Reset() { *m = Boolean{} }
func (m *Boolean) String() string { return proto.CompactTextString(m) }
func (*Boolean) ProtoMessage() {}
func (*Boolean) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
func (m *Boolean) GetCheck() bool {
if m != nil {
return m.Check
}
return false
}
type InputArray struct {
In []*Init `protobuf:"bytes,1,rep,name=in" json:"in,omitempty"`
}
func (m *InputArray) Reset() { *m = InputArray{} }
func (m *InputArray) String() string { return proto.CompactTextString(m) }
func (*InputArray) ProtoMessage() {}
func (*InputArray) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }
func (m *InputArray) GetIn() []*Init {
if m != nil {
return m.In
}
return nil
}
type Init struct {
Name Crawlers `protobuf:"varint,1,opt,name=name,enum=Crawlers" json:"name,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *Init) Reset() { *m = Init{} }
func (m *Init) String() string { return proto.CompactTextString(m) }
func (*Init) ProtoMessage() {}
func (*Init) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} }
func (m *Init) GetName() Crawlers {
if m != nil {
return m.Name
}
return Crawlers_HEALTH_ACTIVEDIRECTORY
}
func (m *Init) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type Input struct {
Name Crawlers `protobuf:"varint,1,opt,name=name,enum=Crawlers" json:"name,omitempty"`
Id string `protobuf:"bytes,2,opt,name=id" json:"id,omitempty"`
}
func (m *Input) Reset() { *m = Input{} }
func (m *Input) String() string { return proto.CompactTextString(m) }
func (*Input) ProtoMessage() {}
func (*Input) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} }
func (m *Input) GetName() Crawlers {
if m != nil {
return m.Name
}
return Crawlers_HEALTH_ACTIVEDIRECTORY
}
func (m *Input) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type InputAdd struct {
Name Crawlers `protobuf:"varint,1,opt,name=name,enum=Crawlers" json:"name,omitempty"`
Data []byte `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *InputAdd) Reset() { *m = InputAdd{} }
func (m *InputAdd) String() string { return proto.CompactTextString(m) }
func (*InputAdd) ProtoMessage() {}
func (*InputAdd) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} }
func (m *InputAdd) GetName() Crawlers {
if m != nil {
return m.Name
}
return Crawlers_HEALTH_ACTIVEDIRECTORY
}
func (m *InputAdd) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
// response models
type Output struct {
StartDate int64 `protobuf:"varint,1,opt,name=startDate" json:"startDate,omitempty"`
EndDate int64 `protobuf:"varint,2,opt,name=endDate" json:"endDate,omitempty"`
Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
}
func (m *Output) Reset() { *m = Output{} }
func (m *Output) String() string { return proto.CompactTextString(m) }
func (*Output) ProtoMessage() {}
func (*Output) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} }
func (m *Output) GetStartDate() int64 {
if m != nil {
return m.StartDate
}
return 0
}
func (m *Output) GetEndDate() int64 {
if m != nil {
return m.EndDate
}
return 0
}
func (m *Output) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func init() {
proto.RegisterType((*Empty)(nil), "Empty")
proto.RegisterType((*Boolean)(nil), "Boolean")
proto.RegisterType((*InputArray)(nil), "InputArray")
proto.RegisterType((*Init)(nil), "Init")
proto.RegisterType((*Input)(nil), "Input")
proto.RegisterType((*InputAdd)(nil), "InputAdd")
proto.RegisterType((*Output)(nil), "Output")
proto.RegisterEnum("Crawlers", Crawlers_name, Crawlers_value)
}
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc1.ClientConn
// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc1.SupportPackageIsVersion4
// Client API for Config service
type ConfigClient interface {
Add(ctx context.Context, in *InputAdd, opts ...grpc1.CallOption) (*Output, error)
Remove(ctx context.Context, in *Input, opts ...grpc1.CallOption) (*Output, error)
Init(ctx context.Context, in *InputArray, opts ...grpc1.CallOption) (*Output, error)
}
type configClient struct {
cc *grpc1.ClientConn
}
func NewConfigClient(cc *grpc1.ClientConn) ConfigClient {
return &configClient{cc}
}
func (c *configClient) Add(ctx context.Context, in *InputAdd, opts ...grpc1.CallOption) (*Output, error) {
out := new(Output)
err := grpc1.Invoke(ctx, "/Config/Add", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *configClient) Remove(ctx context.Context, in *Input, opts ...grpc1.CallOption) (*Output, error) {
out := new(Output)
err := grpc1.Invoke(ctx, "/Config/Remove", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *configClient) Init(ctx context.Context, in *InputArray, opts ...grpc1.CallOption) (*Output, error) {
out := new(Output)
err := grpc1.Invoke(ctx, "/Config/Init", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Config service
type ConfigServer interface {
Add(context.Context, *InputAdd) (*Output, error)
Remove(context.Context, *Input) (*Output, error)
Init(context.Context, *InputArray) (*Output, error)
}
func RegisterConfigServer(s *grpc1.Server, srv ConfigServer) {
s.RegisterService(&_Config_serviceDesc, srv)
}
func _Config_Add_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(InputAdd)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConfigServer).Add(ctx, in)
}
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/Config/Add",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConfigServer).Add(ctx, req.(*InputAdd))
}
return interceptor(ctx, in, info, handler)
}
func _Config_Remove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(Input)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConfigServer).Remove(ctx, in)
}
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/Config/Remove",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConfigServer).Remove(ctx, req.(*Input))
}
return interceptor(ctx, in, info, handler)
}
func _Config_Init_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(InputArray)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ConfigServer).Init(ctx, in)
}
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/Config/Init",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ConfigServer).Init(ctx, req.(*InputArray))
}
return interceptor(ctx, in, info, handler)
}
var _Config_serviceDesc = grpc1.ServiceDesc{
ServiceName: "Config",
HandlerType: (*ConfigServer)(nil),
Methods: []grpc1.MethodDesc{
{
MethodName: "Add",
Handler: _Config_Add_Handler,
},
{
MethodName: "Remove",
Handler: _Config_Remove_Handler,
},
{
MethodName: "Init",
Handler: _Config_Init_Handler,
},
},
Streams: []grpc1.StreamDesc{},
Metadata: "grpc.proto",
}
// Client API for Data service
type DataClient interface {
Get(ctx context.Context, in *Input, opts ...grpc1.CallOption) (*Output, error)
}
type dataClient struct {
cc *grpc1.ClientConn
}
func NewDataClient(cc *grpc1.ClientConn) DataClient {
return &dataClient{cc}
}
func (c *dataClient) Get(ctx context.Context, in *Input, opts ...grpc1.CallOption) (*Output, error) {
out := new(Output)
err := grpc1.Invoke(ctx, "/Data/Get", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Data service
type DataServer interface {
Get(context.Context, *Input) (*Output, error)
}
func RegisterDataServer(s *grpc1.Server, srv DataServer) {
s.RegisterService(&_Data_serviceDesc, srv)
}
func _Data_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(Input)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(DataServer).Get(ctx, in)
}
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/Data/Get",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(DataServer).Get(ctx, req.(*Input))
}
return interceptor(ctx, in, info, handler)
}
var _Data_serviceDesc = grpc1.ServiceDesc{
ServiceName: "Data",
HandlerType: (*DataServer)(nil),
Methods: []grpc1.MethodDesc{
{
MethodName: "Get",
Handler: _Data_Get_Handler,
},
},
Streams: []grpc1.StreamDesc{},
Metadata: "grpc.proto",
}
// Client API for Status service
type StatusClient interface {
Status(ctx context.Context, in *Empty, opts ...grpc1.CallOption) (*Boolean, error)
}
type statusClient struct {
cc *grpc1.ClientConn
}
func NewStatusClient(cc *grpc1.ClientConn) StatusClient {
return &statusClient{cc}
}
func (c *statusClient) Status(ctx context.Context, in *Empty, opts ...grpc1.CallOption) (*Boolean, error) {
out := new(Boolean)
err := grpc1.Invoke(ctx, "/Status/Status", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for Status service
type StatusServer interface {
Status(context.Context, *Empty) (*Boolean, error)
}
func RegisterStatusServer(s *grpc1.Server, srv StatusServer) {
s.RegisterService(&_Status_serviceDesc, srv)
}
func _Status_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc1.UnaryServerInterceptor) (interface{}, error) {
in := new(Empty)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(StatusServer).Status(ctx, in)
}
info := &grpc1.UnaryServerInfo{
Server: srv,
FullMethod: "/Status/Status",
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(StatusServer).Status(ctx, req.(*Empty))
}
return interceptor(ctx, in, info, handler)
}
var _Status_serviceDesc = grpc1.ServiceDesc{
ServiceName: "Status",
HandlerType: (*StatusServer)(nil),
Methods: []grpc1.MethodDesc{
{
MethodName: "Status",
Handler: _Status_Status_Handler,
},
},
Streams: []grpc1.StreamDesc{},
Metadata: "grpc.proto",
}
func init() { proto.RegisterFile("grpc.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 576 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0x4d, 0x6f, 0xd3, 0x40,
0x10, 0x6d, 0x6c, 0xc7, 0x4e, 0x26, 0x6d, 0x3a, 0x1d, 0xda, 0x12, 0xd2, 0x0f, 0x22, 0x23, 0xa1,
0x8a, 0x83, 0x0f, 0xa9, 0x84, 0xc4, 0x81, 0x83, 0x63, 0x9b, 0xc6, 0x28, 0x8e, 0xcd, 0xae, 0x55,
0xe8, 0x09, 0xb9, 0x8d, 0x29, 0x11, 0xad, 0x13, 0xb9, 0x1b, 0x50, 0xff, 0x05, 0x3f, 0x19, 0xf9,
0x23, 0xcd, 0x1e, 0x90, 0x90, 0xb8, 0xcd, 0x7b, 0x6f, 0xf6, 0xbd, 0x5d, 0x7b, 0x77, 0x00, 0x6e,
0xf3, 0xe5, 0x8d, 0xb5, 0xcc, 0x17, 0x62, 0x61, 0x1a, 0xd0, 0xf4, 0xee, 0x97, 0xe2, 0xd1, 0x7c,
0x09, 0xc6, 0x68, 0xb1, 0xb8, 0x4b, 0x93, 0x8c, 0xf6, 0xa1, 0x79, 0xf3, 0x3d, 0xbd, 0xf9, 0xd1,
0x6b, 0x0c, 0x1a, 0x67, 0x2d, 0x56, 0x01, 0xf3, 0x15, 0x80, 0x9f, 0x2d, 0x57, 0xc2, 0xce, 0xf3,
0xe4, 0x91, 0x0e, 0x40, 0x99, 0x67, 0xbd, 0xc6, 0x40, 0x3d, 0xeb, 0x0c, 0x9b, 0x96, 0x9f, 0xcd,
0x05, 0x53, 0xe6, 0x99, 0xf9, 0x0e, 0xb4, 0xa2, 0xa6, 0x13, 0xd0, 0xb2, 0xe4, 0x3e, 0x2d, 0x1d,
0xba, 0xc3, 0xb6, 0xe5, 0xe4, 0xc9, 0xaf, 0xbb, 0x34, 0x7f, 0x60, 0x25, 0x4d, 0x04, 0xda, 0x2c,
0x11, 0x49, 0x4f, 0x19, 0x34, 0xce, 0xb6, 0x59, 0x59, 0x9b, 0x6f, 0xa1, 0x59, 0xfa, 0xff, 0x6b,
0x6d, 0x17, 0x94, 0xf9, 0xac, 0x5c, 0xd9, 0x66, 0xca, 0x7c, 0x66, 0xbe, 0x87, 0x56, 0xb5, 0xaf,
0xd9, 0xec, 0x7f, 0x62, 0x63, 0xd0, 0xc3, 0x95, 0x28, 0x72, 0x8f, 0xa1, 0xfd, 0x20, 0x92, 0x5c,
0xb8, 0x89, 0xa8, 0x1c, 0x54, 0xb6, 0x21, 0xa8, 0x07, 0x46, 0x9a, 0xcd, 0x4a, 0x4d, 0x29, 0xb5,
0x35, 0x7c, 0x72, 0x55, 0x37, 0xae, 0x6f, 0x7e, 0x6b, 0xd0, 0x5a, 0x87, 0x53, 0x1f, 0x0e, 0xc7,
0x9e, 0x3d, 0x89, 0xc7, 0x5f, 0x6d, 0x27, 0xf6, 0x2f, 0x3d, 0xd7, 0x67, 0x9e, 0x13, 0x87, 0xec,
0x0a, 0xb7, 0xa8, 0x0b, 0x50, 0x6b, 0xee, 0x94, 0x63, 0x43, 0xc2, 0x1f, 0xe2, 0x08, 0x15, 0xda,
0x85, 0xce, 0x06, 0x73, 0x54, 0x25, 0xc2, 0x0f, 0xec, 0x08, 0x35, 0x89, 0x98, 0xb8, 0x76, 0x84,
0x4d, 0x22, 0xe8, 0xd6, 0x44, 0x10, 0x4e, 0x2f, 0x42, 0x77, 0x84, 0x3a, 0x21, 0x6c, 0xaf, 0x39,
0xce, 0x3f, 0x4d, 0xd0, 0x90, 0x99, 0xab, 0x82, 0x69, 0xc9, 0xeb, 0x6c, 0xe6, 0xdb, 0xee, 0x08,
0xdb, 0x52, 0x57, 0x74, 0x51, 0x74, 0x81, 0xd4, 0x35, 0xf5, 0xe2, 0x91, 0x1f, 0x72, 0xec, 0xd0,
0x1e, 0xec, 0xd4, 0x5c, 0xc8, 0x6c, 0x67, 0xe2, 0xe1, 0xb6, 0xb4, 0xab, 0x28, 0x8c, 0xce, 0x71,
0x47, 0x72, 0x62, 0x9e, 0xeb, 0x73, 0xec, 0x4a, 0x47, 0x65, 0x81, 0x8f, 0xbb, 0x12, 0xe6, 0xc1,
0x08, 0x51, 0xb2, 0xe0, 0x41, 0x1c, 0xe1, 0x9e, 0x14, 0xcd, 0xa7, 0x41, 0x74, 0x39, 0x74, 0x90,
0xa4, 0xe8, 0x92, 0x3b, 0xc7, 0x67, 0xb2, 0x0f, 0x1f, 0xe3, 0xbe, 0xd4, 0x12, 0x7b, 0x93, 0xa9,
0x17, 0xe3, 0x81, 0xd4, 0xf2, 0x39, 0xf0, 0xf1, 0x90, 0xf6, 0x01, 0x6b, 0xec, 0xd8, 0x9c, 0xdb,
0x53, 0x97, 0xd9, 0xf8, 0x5c, 0xda, 0xc0, 0x38, 0x8e, 0x23, 0xec, 0x91, 0x01, 0x6a, 0xf1, 0x11,
0x5e, 0x50, 0x0b, 0xb4, 0x22, 0x0e, 0xfb, 0x05, 0x55, 0x58, 0x1c, 0x15, 0xc5, 0xc7, 0xe0, 0x0b,
0x1e, 0x53, 0x1b, 0x9a, 0xd5, 0x09, 0x4f, 0xa8, 0x03, 0xc6, 0xfa, 0x17, 0x9c, 0x0e, 0xaf, 0x41,
0x77, 0x16, 0xd9, 0xb7, 0xf9, 0x2d, 0x1d, 0x81, 0x5a, 0x5c, 0xd6, 0xb6, 0xb5, 0xbe, 0xb7, 0x7d,
0xc3, 0xaa, 0xee, 0xa0, 0xb9, 0x45, 0x47, 0xa0, 0xb3, 0xf4, 0x7e, 0xf1, 0x33, 0x25, 0xbd, 0xd2,
0x65, 0xf1, 0xb4, 0x7e, 0x5e, 0x1d, 0x6b, 0xf3, 0x14, 0x25, 0x7d, 0x38, 0x00, 0xcd, 0x4d, 0x44,
0x42, 0x3d, 0x50, 0x2f, 0x52, 0xf1, 0x17, 0x87, 0xe1, 0x6b, 0xd0, 0xb9, 0x48, 0xc4, 0xea, 0x81,
0x8e, 0x9f, 0x2a, 0xdd, 0x2a, 0x47, 0x40, 0xbf, 0x65, 0xd5, 0x13, 0xc0, 0xdc, 0xba, 0xd6, 0xcb,
0xf1, 0x70, 0xfe, 0x27, 0x00, 0x00, 0xff, 0xff, 0xe6, 0x5f, 0x44, 0x44, 0x2c, 0x04, 0x00, 0x00,
}

83
crawler/grpc/grpc.proto Normal file
View File

@ -0,0 +1,83 @@
syntax = "proto3";
enum Crawlers {
HEALTH_ACTIVEDIRECTORY = 0;
HEALTH_DNS = 1;
HEALTH_FTP = 2;
HEALTH_FTPS = 3;
HEALTH_IMAP = 4;
HEALTH_LDAP = 5;
HEALTH_MONGODB = 6;
HEALTH_MSSQL = 7;
HEALTH_MYSQL = 8;
HEALTH_MARIADB = 9;
HEALTH_PGSQL = 10;
HEALTH_NETBIOS = 11;
HEALTH_ORACLE = 12;
HEALTH_POP3 = 13;
HEALTH_REDIS = 14;
HEALTH_RMI = 15;
HEALTH_SMB = 16;
HEALTH_SMTP = 17;
HEALTH_SNMPV2C = 18;
HEALTH_SNMPV3 = 19;
HEALTH_SSH = 20;
HEALTH_TELNET = 21;
HEALTH_WMI = 22;
HEALTH_CASSANDRA = 23;
HEALTH_HTTP = 24;
SQL = 25;
SNMP = 26;
WMI = 27;
JMX = 28;
REDIS = 29;
MONGODB = 30;
}
// services
service Config {
rpc Add (InputAdd) returns (Output) {}
rpc Remove (Input) returns (Output) {}
rpc Init (InputArray) returns (Output) {}
}
service Data {
rpc Get (Input) returns (Output) {}
}
service Status {
rpc Status(Empty) returns (Boolean) {}
}
message Empty {}
message Boolean {
bool check = 1;
}
message InputArray {
repeated Init in = 1;
}
message Init {
Crawlers name = 1;
bytes data = 2;
}
message Input {
Crawlers name = 1;
string id =2;
}
message InputAdd {
Crawlers name = 1;
bytes data =2;
}
// response models
message Output {
int64 startDate = 1;
int64 endDate = 2;
bytes data = 3;
}

29
crawler/health_crawler/activedirectory_protocol_crawler_go/ad_protocol_crawler.go Normal file
View File

@ -0,0 +1,29 @@
package activedirectory_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/activedirectory"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
"git.loafle.net/overflow/overflow_probe/crawler"
)
type ActiveDirectoryHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *ActiveDirectoryHealthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewActiveDirectoryHealthCrawler() *ActiveDirectoryHealthCrawler {
ad := &ActiveDirectoryHealthCrawler{}
ad.SetInternal(ad)
ad.SetMatcher(activedirectory.NewActiveDirectoryMatcher())
return ad
}

109
crawler/health_crawler/activedirectory_protocol_crawler_go/ad_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,109 @@
package activedirectory_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.1", 389, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckSSL(t *testing.T) {
// b, _ := check("192.168.1.1", 636, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.1", Port: 389, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}
func setConfig() crawler.Crawler {
r := NewActiveDirectoryHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.1"
m["port"] = "389"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}

28
crawler/health_crawler/cassandra_protocol_crawler_go/cassandra_protocol_crawler.go Normal file
View File

@ -0,0 +1,28 @@
package cassandra_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/cassandra"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type CassandraHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *CassandraHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewCassandraHealthCrawler() *CassandraHealthCrawler {
r := &CassandraHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(cassandra.NewCassandraMatcher())
return r
}

104
crawler/health_crawler/cassandra_protocol_crawler_go/cassandra_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,104 @@
package cassandra_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewCassandraHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.104"
m["port"] = "9042"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.104", 9042, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: true}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.104", Port: 9042, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HeahthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

28
crawler/health_crawler/dns_protocol_crawler_go/dns_protocol_crawler.go Normal file
View File

@ -0,0 +1,28 @@
package dns_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/dns"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type DNSHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *DNSHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewDNSHealthCrawler() *DNSHealthCrawler {
r := &DNSHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(dns.NewDnsMatcher())
return r
}

104
crawler/health_crawler/dns_protocol_crawler_go/dns_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,104 @@
package dns_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewDNSHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "53"
m["portType"] = "udp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 53, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 53, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

121
crawler/health_crawler/ftp_protocol_crawler_go/ftp_health_matcher.go Normal file
View File

@ -0,0 +1,121 @@
package ftp_protocol_crawler_go
import (
"git.loafle.net/overflow/overflow_probe/matcher/packet"
"git.loafle.net/overflow/overflow_probe/model/scaninfo"
"log"
)
const (
statusReadyServer = "120"
statusOK = "200"
statusNewConnectOK = "220"
statusSystemNameOK = "215"
statusCloseConnect = "221"
statusUnkownCMD = "202"
statusTlsUseOK = "234"
statusCloseControlConnect = "421"
statusSyntaxErr = "500"
statusParamSyntaxErr = "501"
statusNotUseCMD = "502"
statusIncorrectCMD = "503"
statusUserLoginRequied = "530"
statusTlsNotUse = "534"
statusNeedUserId = "332"
)
type FTPMatcher struct {
sendPackets []*packet.Packet
isFtps bool
}
func NewFTPMatcher() *FTPMatcher {
ftm := FTPMatcher{}
sysStr := "SYST\r\n"
systByte := make([]byte, len(sysStr))
copy(systByte[:], sysStr)
ftm.sendPackets = append(ftm.sendPackets, packet.NewPacket(systByte, len(sysStr)))
passStr := "PASS \r\n"
passByte := make([]byte, len(passStr))
copy(passByte[:], passStr)
ftm.sendPackets = append(ftm.sendPackets, packet.NewPacket(passByte, len(passStr)))
quitStr := "QUIT\r\n"
quitByte := make([]byte, len(quitStr))
copy(quitByte[:], quitStr)
ftm.sendPackets = append(ftm.sendPackets, packet.NewPacket(quitByte, len(quitStr)))
return &ftm
}
func (r *FTPMatcher) Match(idx int, packet *packet.Packet, info scaninfo.ServiceScanInfo) bool {
result := false
if packet == nil || packet.Buffer == nil || packet.Len == 0 {
log.Println("Packet nil")
return result
}
str := string(packet.Buffer)
code := str[:3]
if idx == 0 {
switch code {
case statusNewConnectOK, statusReadyServer:
//fmt.Println(code)
result = true
break
}
} else if idx == 1 {
switch code {
case statusSystemNameOK, statusSyntaxErr, statusParamSyntaxErr, statusNotUseCMD, statusUserLoginRequied:
//fmt.Println(code)
result = true
break
}
} else if idx == 2 {
switch code {
case statusIncorrectCMD, statusParamSyntaxErr, statusNotUseCMD, statusNeedUserId, statusUserLoginRequied:
//fmt.Println(code)
result = true
break
}
} else if idx == 3 {
switch code {
case statusCloseConnect, statusSyntaxErr:
//fmt.Println(code)
result = true
break
}
}
return result
}
func (ftp *FTPMatcher) PacketCount() int {
return len(ftp.sendPackets)
}
func (ftp *FTPMatcher) Packet(index int) *packet.Packet {
return ftp.sendPackets[index]
}
func (ftp *FTPMatcher) ServiceName() string {
return "FTP"
}
func (ftp *FTPMatcher) IsError(index int, packet *packet.Packet, info scaninfo.ServiceScanInfo) bool {
return false
}
func (ftp *FTPMatcher) IsNoResponse(index int) bool {
return false
}
func (ftp *FTPMatcher) IsPrePacket() bool {
return true
}

179
crawler/health_crawler/ftp_protocol_crawler_go/ftp_protocol_crawler.go Normal file
View File

@ -0,0 +1,179 @@
package ftp_protocol_crawler_go
import (
"git.loafle.net/overflow/overflow_probe/crawler"
"encoding/json"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type FTPHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *FTPHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewFTPHealthCrawler() *FTPHealthCrawler {
r := &FTPHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(NewFTPMatcher())
return r
}
////////////// Delegate.Get implement /////////////////
//type FTPProtocol struct{}
//
//func (r *FTPProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := ftp.NewFTPMatcher()
//
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
// if m.Match(0, p, nil) == false {
// return false, nil
// }
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
//
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if matchFtp(i+1, p) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func matchFtp(idx int, packet *packet.Packet) bool {
// result := false
//
// if packet == nil || packet.Buffer == nil || packet.Len == 0 {
// log.Println("Packet nil")
// return result
// }
//
// str := string(packet.Buffer)
//
// code := str[:3]
//
// if idx == 0 {
// switch code {
// case statusNewConnectOK, statusReadyServer:
// //fmt.Println(code)
// result = true
// break
// }
// } else if idx == 1 {
// switch code {
// case statusSystemNameOK, statusSyntaxErr, statusParamSyntaxErr, statusNotUseCMD, statusUserLoginRequied:
// //fmt.Println(code)
// result = true
// break
// }
// } else if idx == 2 {
// switch code {
// case statusIncorrectCMD, statusParamSyntaxErr, statusNotUseCMD, statusNeedUserId, statusUserLoginRequied:
// //fmt.Println(code)
// result = true
// break
// }
// } else if idx == 3 {
// switch code {
// case statusCloseConnect, statusSyntaxErr:
// //fmt.Println(code)
// result = true
// break
// }
// }
//
// return result
//}
//
//func start() {
//
// rpc.SetDelegate(new(FTPProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

93
crawler/health_crawler/ftp_protocol_crawler_go/ftp_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,93 @@
package ftp_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewFTPHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "21"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ftp", m)
return r
}
func TestMatch(t *testing.T) {
r := setConfig()
out := param.Output{}
r.Get("ftp", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ftp", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ftp",
Id: "ftp",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 21, false)
// assert.Equal(t, true, b)
//}
//
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 21, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

75
crawler/health_crawler/ftps_protocol_crawler_go/ftps_health_matcher.go Normal file
View File

@ -0,0 +1,75 @@
package ftps_protocol_crawler_go
import (
"git.loafle.net/overflow/overflow_probe/matcher/packet"
"git.loafle.net/overflow/overflow_probe/model/scaninfo"
)
const (
statusOK = "200"
statusNewConnectOK = "220"
)
type FTPSMatcher struct {
sendPackets []*packet.Packet
isFtps bool
}
func NewFTPSMatcher() *FTPSMatcher {
f := FTPSMatcher{}
pbs := "PBSZ 0\r\n"
pbsByte := make([]byte, len(pbs))
copy(pbsByte[:], pbs)
f.sendPackets = append(f.sendPackets, packet.NewPacket(pbsByte, len(pbs)))
prot := "PROT P\r\n"
protByte := make([]byte, len(prot))
copy(protByte[:], prot)
f.sendPackets = append(f.sendPackets, packet.NewPacket(protByte, len(prot)))
quitStr := "QUIT\r\n"
quitByte := make([]byte, len(quitStr))
copy(quitByte[:], quitStr)
f.sendPackets = append(f.sendPackets, packet.NewPacket(quitByte, len(quitStr)))
return &f
}
func (ftp *FTPSMatcher) Match(idx int, packet *packet.Packet, info scaninfo.ServiceScanInfo) bool {
result := false
str := string(packet.Buffer)
code := str[:3]
if code == statusOK || code == statusNewConnectOK {
result = true
}
return result
}
func (ftp *FTPSMatcher) PacketCount() int {
return len(ftp.sendPackets)
}
func (ftp *FTPSMatcher) Packet(index int) *packet.Packet {
return ftp.sendPackets[index]
}
func (ftp *FTPSMatcher) ServiceName() string {
return "FTPS"
}
func (ftp *FTPSMatcher) IsError(index int, packet *packet.Packet, info scaninfo.ServiceScanInfo) bool {
return false
}
func (ftp *FTPSMatcher) IsNoResponse(index int) bool {
return false
}
func (ftp *FTPSMatcher) IsPrePacket() bool {
return true
}

70
crawler/health_crawler/ftps_protocol_crawler_go/ftps_protocol_crawler.go Normal file
View File

@ -0,0 +1,70 @@
package ftps_protocol_crawler_go
import (
"git.loafle.net/overflow/overflow_probe/crawler"
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/ftp"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type FTPSHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *FTPSHealthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewFTPSHealthCrawler() *FTPSHealthCrawler {
r := &FTPSHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(ftp.NewFTPMatcher())
return r
}
////////////// Delegate.Get implement /////////////////
//type FTPSProtocol struct{}
//
//func (r *FTPSProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := ftp.StartCheckFTPS(input.Ip, strconv.Itoa(int(input.Port)))
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(FTPSProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

87
crawler/health_crawler/ftps_protocol_crawler_go/ftps_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,87 @@
package ftps_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewFTPSHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.103"
m["port"] = "2121"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ftps", m)
return r
}
func TestMatch(t *testing.T) {
r := setConfig()
out := param.Output{}
r.Get("ftps", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ftps", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ftps",
Id: "ftps",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 21, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, false, m.IsMatch)
//}

120
crawler/health_crawler/http_protocol_crawler_go/crawler_protocol_http.go Normal file
View File

@ -0,0 +1,120 @@
package http_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/http"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type HTTPHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *HTTPHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewHTTPHealthCrawler() *HTTPHealthCrawler {
r := &HTTPHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(http.NewHTTPMatcher())
return r
}
//package main
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "log"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "encoding/json"
// "strconv"
// "net"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/http"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// "git.loafle.net/overflow/collector/discovery/types/timestamp"
//)
//
//type HttpProtocol struct {
//
//}
//
//func (h *HttpProtocol) Get(input *param.Input, output *param.Output) error {
//
// log.Println("data : " + string(input.Data))
// pr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &pr)
//
// output.StartDate = timestamp.Now()
// match, err := check(input.Ip, input.Port)
//
// if err != nil {
// log.Println(err.Error())
// return err
// }
// output.EndDate = timestamp.Now()
//
// rres := &protocol.HealthResponse{IsMatch:match}
//
// b, err := json.Marshal(&rres)
//
// if err != nil {
// log.Println(err.Error())
// return err
// }
//
// *output = param.Output{Data:b}
//
// return nil
//}
//
//func check(ip string, port uint16) (bool,error) {
//
// var targetHost string = ip
// targetHost += ":"
// targetHost += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", targetHost)
//
//
// if err != nil {
// return false, err
// }
// defer conn.Close()
// hp := http.NewHTTPMatcher()
//
// for i := 0; i < hp.PacketCount(); i++ {
// pack := hp.Packet(i)
// conn.Write(pack.Buffer)
//
// bytes := make([]byte, 1024)
// l, _ := conn.Read(bytes)
//
// p := packet.NewPacket(bytes, l)
//
// if hp.Match(i, p, nil) == false{
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(HttpProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

87
crawler/health_crawler/http_protocol_crawler_go/crawler_protocol_http_test.go Normal file
View File

@ -0,0 +1,87 @@
package http_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewHTTPHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.105"
m["port"] = "80"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package main
//
//import (
// "testing"
// "github.com/stretchr/testify/assert"
//)
//
//func TestHttpProtocol_Get(t *testing.T) {
// b, err := check("192.168.1.105", 80)
// if err != nil {
// t.Error(err)
// }
// assert.Equal(t, true, b)
//}

129
crawler/health_crawler/imap_protocol_crawler_go/imap_protocol_crawler.go Normal file
View File

@ -0,0 +1,129 @@
package imap_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/imap"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type IMAPHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *IMAPHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewIMAPHealthCrawler() *IMAPHealthCrawler {
r := &IMAPHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(imap.NewIMAPMatcher())
return r
}
//package imap
//
//import (
// "crypto/tls"
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/imap"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type ImapProtocol struct{}
//
//func (r *ImapProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := imap.NewIMAPMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(ImapProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

110
crawler/health_crawler/imap_protocol_crawler_go/imap_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,110 @@
package imap_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewIMAPHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "993"
m["portType"] = "tcp"
m["ssl"] = true
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 143, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckSSL(t *testing.T) {
// b, _ := check("192.168.1.215", 993, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 143, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

132
crawler/health_crawler/ldap_protocol_crawler_go/ldap_protocol_crawler.go Normal file
View File

@ -0,0 +1,132 @@
package ldap_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/ldap"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type LDAPHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *LDAPHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewLDAPHealthCrawler() *LDAPHealthCrawler {
r := &LDAPHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(ldap.NewLDAPMatcher())
return r
}
//
//import (
// "crypto/tls"
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/ldap"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type LDAPProtocol struct{}
//
//func (r *LDAPProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := ldap.NewLDAPMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(LDAPProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

110
crawler/health_crawler/ldap_protocol_crawler_go/ldap_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,110 @@
package ldap_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewLDAPHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "389"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 389, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckSSL(t *testing.T) {
// b, _ := check("192.168.1.215", 636, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 389, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

128
crawler/health_crawler/mongodb_protocol_crawler_go/mongodb_protocol.go Normal file
View File

@ -0,0 +1,128 @@
package mongodb_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/mongodb"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type MongoDBHealthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *MongoDBHealthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewMongoDBHealthCrawler() *MongoDBHealthCrawler {
r := &MongoDBHealthCrawler{}
r.SetInternal(r)
r.SetMatcher(mongodb.NewMongoDBMatcher())
return r
}
//import (
// "crypto/tls"
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/mongodb"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type MongoDBProtocol struct{}
//
//func (r *MongoDBProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := mongodb.NewMongoDBMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
//
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(MongoDBProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

105
crawler/health_crawler/mongodb_protocol_crawler_go/mongodb_protocol_test.go Normal file
View File

@ -0,0 +1,105 @@
package mongodb_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewMongoDBHealthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.104"
m["port"] = "27017"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("ad", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("ad", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("ad", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "ad",
Id: "ad",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.104", 27017, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: true}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.104", Port: 27017, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

104
crawler/health_crawler/mssql_protocol_crawler_go/mssql_protocol.go Normal file
View File

@ -0,0 +1,104 @@
package mssql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/mssql"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type MSSqlHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *MSSqlHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewMSSqlHeahthCrawler() *MSSqlHeahthCrawler {
r := &MSSqlHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(mssql.NewMSSqlMatcher())
return r
}
//
//import (
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/mssql"
//)
//
//////////////// Delegate.Get implement /////////////////
//type MSSQLProtocol struct{}
//
//func (r *MSSQLProtocol) Get(input *param.Input, output *param.Output) error {
//
// log.Println("data : " + string(input.Data))
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func check(ip string, port uint16) (bool, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := mssql.NewMSSqlMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
//
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(MSSQLProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

86
crawler/health_crawler/mssql_protocol_crawler_go/mssql_protocol_test.go Normal file
View File

@ -0,0 +1,86 @@
package mssql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewMSSqlHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.106"
m["port"] = "1433"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "testing"
// "github.com/stretchr/testify/assert"
//)
//
//func TestMatch(t *testing.T) {
// b, err := check("192.168.1.106", 1433)
// if err != nil {
// t.Error(err)
// }
// assert.Equal(t, true, b)
//}

107
crawler/health_crawler/mysql_protocol_crawler_go/mysql_protocol.go Normal file
View File

@ -0,0 +1,107 @@
package mysql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/mysql"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type MysqlHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *MysqlHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewMysqlHeahthCrawler() *MysqlHeahthCrawler {
r := &MysqlHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(mysql.NewMySqlMatcher())
return r
}
//
//import (
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/mysql"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type MySQLProtocol struct{}
//
//func (r *MySQLProtocol) Get(input *param.Input, output *param.Output) error {
//
// log.Println("data : " + string(input.Data))
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func check(ip string, port uint16) (bool, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := mysql.NewMySqlMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
//
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(MySQLProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

86
crawler/health_crawler/mysql_protocol_crawler_go/mysql_protocol_test.go Normal file
View File

@ -0,0 +1,86 @@
package mysql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewMysqlHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.103"
m["port"] = "3306"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("redis", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("redis", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("redis", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "redis",
Id: "redis",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "github.com/stretchr/testify/assert"
// "testing"
//)
//
//func TestMatch(t *testing.T) {
// b, err := check("192.168.1.103", 3306)
// if err != nil {
// t.Error(err)
// }
// assert.Equal(t, true, b)
//}

109
crawler/health_crawler/netbios_protocol_crawler_go/netbios_protocol_crawler.go Normal file
View File

@ -0,0 +1,109 @@
package netbios_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/netbios"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type NetbiosHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *NetbiosHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewNetbiosHeahthCrawler() *NetbiosHeahthCrawler {
r := &NetbiosHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(netbios.NewNetBiosMatcher())
return r
}
//import (
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/netbios"
//)
//
//////////////// Delegate.Get implement /////////////////
//type NetBiosProtocol struct{}
//
//func (r *NetBiosProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := netbios.NewNetBiosMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(NetBiosProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

105
crawler/health_crawler/netbios_protocol_crawler_go/netbios_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,105 @@
package netbios_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewNetbiosHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.106"
m["port"] = "139"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.106", 139, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.106", Port: 139, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

147
crawler/health_crawler/oracle_protocol_crawler_go/oracle_protocol_crawler.go Normal file
View File

@ -0,0 +1,147 @@
package oracle_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/oracle"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type OracleHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *OracleHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewOracleHeahthCrawler() *OracleHeahthCrawler {
r := &OracleHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(oracle.NewOracleMatcher())
return r
}
//package oracle_protocol_crawler
//
//
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
// "crypto/tls"
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/oracle"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type OracleProtocol struct{}
//
//func (r *OracleProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := oracle.NewOracleMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
//
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(OracleProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

127
crawler/health_crawler/oracle_protocol_crawler_go/oracle_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,127 @@
package oracle_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewOracleHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.30"
m["port"] = "1521"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "testing"
// "github.com/stretchr/testify/assert"
//)
//
//func TestMatch(t *testing.T) {
// b, err := check("192.168.1.106", 1433)
// if err != nil {
// t.Error(err)
// }
// assert.Equal(t, true, b)
//}
//package oracle_protocol_crawler
//
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.30", 1521, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckTls(t *testing.T) {
// b, _ := check("192.168.1.215", 22, true)
// assert.Equal(t, true, b)
//}
//
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.30", Port: 1521, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

105
crawler/health_crawler/pgsql_protocol_crawler_go/pgsql_protocol.go Normal file
View File

@ -0,0 +1,105 @@
package pgsql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/pgsql"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type PGSqlHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *PGSqlHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewPGSqlHeahthCrawler() *PGSqlHeahthCrawler {
r := &PGSqlHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(pgsql.NewPostgreSQLMatcher())
return r
}
//
//import (
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/mssql"
//)
//
//////////////// Delegate.Get implement /////////////////
//type PGSQLProtocol struct{}
//
//func (r *PGSQLProtocol) Get(input *param.Input, output *param.Output) error {
//
// log.Println("data : " + string(input.Data))
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func check(ip string, port uint16) (bool, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := mssql.NewPGSqlMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
//
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(PGSQLProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

86
crawler/health_crawler/pgsql_protocol_crawler_go/pgsql_protocol_test.go Normal file
View File

@ -0,0 +1,86 @@
package pgsql_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewPGSqlHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.107"
m["port"] = "5432"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//
//import (
// "testing"
// "github.com/stretchr/testify/assert"
//)
//
//func TestMatch(t *testing.T) {
// b, err := check("192.168.1.106", 1433)
// if err != nil {
// t.Error(err)
// }
// assert.Equal(t, true, b)
//}

130
crawler/health_crawler/pop3_protocol_crawler_go/pop3_protocol_crawler.go Normal file
View File

@ -0,0 +1,130 @@
package pop3_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/pop"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type POP3HeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *POP3HeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewPOP3HeahthCrawler() *POP3HeahthCrawler {
r := &POP3HeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(pop.NewPOPMatcher())
return r
}
//package pop3
//
//import (
// "crypto/tls"
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/pop"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type Pop3Protocol struct{}
//
//func (r *Pop3Protocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
// //
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := pop.NewPOPMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(Pop3Protocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

111
crawler/health_crawler/pop3_protocol_crawler_go/pop3_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,111 @@
package pop3_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewPOP3HeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "110"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package pop3
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 110, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckSSL(t *testing.T) {
// b, _ := check("192.168.1.215", 995, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 143, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

28
crawler/health_crawler/redis_protocol_crawler_go/redis_protocol.go Normal file
View File

@ -0,0 +1,28 @@
package redis_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/redis"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type RedisHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *RedisHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewRedisHeahthCrawler() *RedisHeahthCrawler {
r := &RedisHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(redis.NewRedisMatcher())
return r
}

69
crawler/health_crawler/redis_protocol_crawler_go/redis_protocol_test.go Normal file
View File

@ -0,0 +1,69 @@
package redis_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/crawler"
"git.loafle.net/overflow/overflow_probe/crawler/config"
"github.com/stretchr/testify/assert"
"testing"
)
func setConfig() crawler.Crawler {
r := NewRedisHeahthCrawler()
m := config.Config{}
m.Target = config.Target{}
m.Target.Connection = config.Connection{}
m.Target.Connection.Ip = "192.168.1.104"
m.Target.Connection.Port = "6379"
m.Target.Connection.PortType = "tcp"
m.Target.Connection.SSL = false
r.PutConfig("redis", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
b, _ := r.Get("redis")
var check bool
json.Unmarshal(b, &check)
assert.Equal(t, true, check)
}
//
//func start() {
// r := setConfig()
//
// of_rpc.AddDelegate("redis", r)
// err := of_rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func TestRPC(t *testing.T) {
// go start()
// time.Sleep(2 * time.Second)
//
// in := param.Input{
// Name: "redis",
// Id: "redis",
// }
//
// result, err := client.InvokeJSONRPCGet("50000", in)
//
// if err != nil {
// t.Fatal(err)
// }
//
// var check bool
// json.Unmarshal(result.Data, &check)
// assert.Equal(t, true, check)
//}

107
crawler/health_crawler/rmi_protocol_crawler_go/rmi_protocol_crawler.go Normal file
View File

@ -0,0 +1,107 @@
package rmi_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/rmi"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type RMIHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *RMIHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewRMIHeahthCrawler() *RMIHeahthCrawler {
r := &RMIHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(rmi.NewRMIMatcher())
return r
}
//package imap
//
//import (
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/rmi"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type RMIProtocol struct{}
//
//func (r *RMIProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := rmi.NewRMIMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(RMIProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

106
crawler/health_crawler/rmi_protocol_crawler_go/rmi_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,106 @@
package rmi_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewRMIHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.103"
m["port"] = "9840"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package imap
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.103", 9840, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.103", Port: 9840, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

150
crawler/health_crawler/smb_protocol_crawler_go/smb_protocol_crawler.go Normal file
View File

@ -0,0 +1,150 @@
package smb_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/smb"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SMBHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *SMBHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewSMBHeahthCrawler() *SMBHeahthCrawler {
r := &SMBHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(smb.NewSMBMatcher())
return r
}
//package smb_protocol_crawler
//
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
//
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/smb"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
// "crypto/tls"
//)
//
//////////////// Delegate.Get implement /////////////////
//type SMBProtocol struct{}
//
//func (r *SMBProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := smb.NewSMBMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(SMBProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

108
crawler/health_crawler/smb_protocol_crawler_go/smb_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,108 @@
package smb_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewSMBHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.106"
m["port"] = "445"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package smb_protocol_crawler
//
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.106", 445, false)
// assert.Equal(t, true, b)
//}
//
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.106", Port: 445, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

137
crawler/health_crawler/smtp_protocol_crawler_go/smtp_protocol_crawler.go Normal file
View File

@ -0,0 +1,137 @@
package smtp_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/smtp"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SMTPHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *SMTPHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewSMTPHeahthCrawler() *SMTPHeahthCrawler {
r := &SMTPHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(smtp.NewSmtpMatcher())
return r
}
//package smtp
//
//import (
// "crypto/tls"
// "encoding/json"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/smtp"
// rpc "git.loafle.net/overflow/of_rpc/json"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "log"
// "net"
// "strconv"
//)
//
//////////////// Delegate.Get implement /////////////////
//type SMTPProtocol struct{}
//
//func (r *SMTPProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// rres := &protocol.HealthResponse{IsMatch: match}
//
// b, err := json.Marshal(&rres)
// if err != nil {
// return err
// }
// *output = param.Output{Data: b}
// return nil
//}
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := smtp.NewSmtpMatcher()
//
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
// if m.Match(0, p, nil) == false {
// return false, nil
// }
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
//
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i+1, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
// rpc.SetDelegate(new(SMTPProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

111
crawler/health_crawler/smtp_protocol_crawler_go/smtp_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,111 @@
package smtp_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewSMTPHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "25"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package smtp
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 25, false)
// assert.Equal(t, true, b)
//}
//
//func TestCheckSSL(t *testing.T) {
// b, _ := check("192.168.1.215", 465, true)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 25, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

137
crawler/health_crawler/snmpv2c_protocol_crawler_go/snmpv2c_protocol_crawler.go Normal file
View File

@ -0,0 +1,137 @@
package snmpv2c_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/snmp"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SNMPV2CHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *SNMPV2CHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewSNMPV2CHeahthCrawler() *SNMPV2CHeahthCrawler {
r := &SNMPV2CHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(snmp.NewSNMPv2Matcher())
return r
}
//package snmpv2c_protocol_crawler
//
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
//
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/snmp"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type SNMPv2cProtocol struct{}
//
//func (r *SNMPv2cProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("udp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//
// return nil, nil
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := snmp.NewSNMPv2Matcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(SNMPv2cProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

106
crawler/health_crawler/snmpv2c_protocol_crawler_go/snmpv2c_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,106 @@
package snmpv2c_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewSNMPV2CHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "161"
m["portType"] = "udp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package snmpv2c_protocol_crawler
//
//import (
// "github.com/stretchr/testify/assert"
// "time"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/json/client"
// "testing"
// "encoding/json"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 161, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 161, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

137
crawler/health_crawler/snmpv3_protocol_crawler_go/snmpv3_protocol_crawler.go Normal file
View File

@ -0,0 +1,137 @@
package snmpv3_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/snmp"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SNMPV3HeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *SNMPV3HeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewSNMPV3HeahthCrawler() *SNMPV3HeahthCrawler {
r := &SNMPV3HeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(snmp.NewSNMPv3Matcher())
return r
}
//package snmpv3_protocol_crawler
//
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
//
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/snmp"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type SNMPv3Protocol struct{}
//
//func (r *SNMPv3Protocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("udp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//
// return nil, nil
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := snmp.NewSNMPv3Matcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(SNMPv3Protocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

106
crawler/health_crawler/snmpv3_protocol_crawler_go/snmpv3_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,106 @@
package snmpv3_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewSNMPV3HeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.254"
m["port"] = "161"
m["portType"] = "udp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package snmpv3_protocol_crawler
//
//import (
// "github.com/stretchr/testify/assert"
// "time"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/json/client"
// "testing"
// "encoding/json"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.254", 161, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.254", Port: 161, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

152
crawler/health_crawler/ssh_protocol_crawler_go/ssh_protocol_crawler.go Normal file
View File

@ -0,0 +1,152 @@
package ssh_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/ssh"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SSHHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *SSHHeahthCrawler) Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewSSHHeahthCrawler() *SSHHeahthCrawler {
r := &SSHHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(ssh.NewSSHMatcher())
return r
}
//package ssh_protocol_crawler
//
//
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
// "crypto/tls"
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/ssh"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type SSHProtocol struct{}
//
//func (r *SSHProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := ssh.NewSSHMatcher()
//
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
// if m.Match(0, p, nil) == false {
// return false, nil
// }
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
//
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i+1, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(SSHProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

107
crawler/health_crawler/ssh_protocol_crawler_go/ssh_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,107 @@
package ssh_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewSSHHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "22"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package ssh_protocol_crawler
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 22, false)
// assert.Equal(t, true, b)
//}
//
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 22, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

151
crawler/health_crawler/telnet_protocol_crawler_go/crawler_protocol_telnet.go Normal file
View File

@ -0,0 +1,151 @@
package telnet_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/telnet"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type TelnetHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *TelnetHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewTelnetHeahthCrawler() *TelnetHeahthCrawler {
r := &TelnetHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(telnet.NewTelnetMatcher())
return r
}
//package main
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
// "crypto/tls"
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/telnet"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type TelnetProtocol struct{}
//
//func (r *TelnetProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// match, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = match
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := telnet.NewTelnetMatcher()
//
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
// if m.Match(0, p, nil) == false {
// return false, nil
// }
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
//
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.Match(i+1, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(TelnetProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

108
crawler/health_crawler/telnet_protocol_crawler_go/crawler_protocol_telnet_test.go Normal file
View File

@ -0,0 +1,108 @@
package telnet_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewTelnetHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.215"
m["port"] = "23"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package main
//
//
//import (
// "encoding/json"
// "github.com/stretchr/testify/assert"
// "git.loafle.net/overflow/of_rpc/json/client"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "testing"
// "time"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.215", 23, false)
// assert.Equal(t, true, b)
//}
//
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.215", Port: 23, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

148
crawler/health_crawler/wmi_protocol_crawler_go/wmi_protocol_crawler.go Normal file
View File

@ -0,0 +1,148 @@
package wmi_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/matcher/wmi"
"git.loafle.net/overflow/overflow_probe/crawler"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type WMIHeahthCrawler struct {
crawler.SocketHeahthCrawler
}
func (r *WMIHeahthCrawler)Internal(params config.Config) ([]byte, error) {
b, err := r.CheckHeahth(params)
if err != nil {
return nil, err
}
return json.Marshal(b)
}
func NewWMIHeahthCrawler() *WMIHeahthCrawler {
r := &WMIHeahthCrawler{}
r.SetInternal(r)
r.SetMatcher(wmi.NewWMIMatcher())
return r
}
//package wmi_protocol_crawler
//
//import (
// "git.loafle.net/overflow/of_rpc/models/param"
// "encoding/json"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "strconv"
// "crypto/tls"
// "net"
//
// "git.loafle.net/overflow/collector/core/scan/service/matcher/wmi"
// "git.loafle.net/overflow/collector/core/scan/service/matcher/packet"
// rpc "git.loafle.net/overflow/of_rpc/json"
//
// "log"
//)
//
//////////////// Delegate.Get implement /////////////////
//type WMIProtocol struct{}
//
//func (r *WMIProtocol) Get(input *param.Input, output *param.Output) error {
//
// rr := &protocol.HealthRequest{}
// json.Unmarshal(input.Data, &rr)
//
// rres, err := check(input.Ip, input.Port, rr.IsSSL)
//
// if err != nil {
// return err
// }
//
//
// retVal := &protocol.HealthResponse{}
// retVal.IsMatch = rres
//
// b, err := json.Marshal(retVal)
//
// if err != nil {
// return err
// }
//
// *output = param.Output{Data: b}
// return nil
//}
//
//
//func connect(ip string, port uint16, ssl bool) (net.Conn, error) {
//
// var addr string = ip
// addr += ":"
// addr += strconv.Itoa(int(port))
//
// if ssl == false {
// conn, err := net.Dial("tcp", addr)
// if err != nil {
// return nil, err
// }
// return conn, nil
// } else {
// conn, err := tls.Dial(
// "tcp",
// addr,
// &tls.Config{
// InsecureSkipVerify: true,
// ServerName: ip,
// },
// )
// if err != nil {
// return nil, err
// }
// return conn, nil
// }
//}
//
//
//
//func check(ip string, port uint16, ssl bool) (bool, error) {
//
// conn, err := connect(ip, port, ssl)
// if err != nil {
// return false, err
// }
// defer conn.Close()
//
// m := wmi.NewWMIMatcher()
//
// for i := 0; i < m.PacketCount(); i++ {
//
// pack := m.Packet(i)
// conn.Write(pack.Buffer)
// bytes := make([]byte, 1024)
// n, _ := conn.Read(bytes)
// p := packet.NewPacket(bytes, n)
//
// if m.IsNoResponse(i) == true { // empty last response
// break
// }
//
// if m.Match(i, p, nil) == false {
// return false, nil
// }
// }
//
// return true, nil
//}
//
//func start() {
//
// rpc.SetDelegate(new(WMIProtocol))
// err := rpc.StartJSONRPC()
// if err != nil {
// log.Fatal(err)
// }
//}
//
//func main() {
// start()
//}

106
crawler/health_crawler/wmi_protocol_crawler_go/wmi_protocol_crawler_test.go Normal file
View File

@ -0,0 +1,106 @@
package wmi_protocol_crawler_go
import (
"encoding/json"
"git.loafle.net/overflow/of_rpc_go"
"git.loafle.net/overflow/of_rpc_go/client"
"git.loafle.net/overflow/of_rpc_go/models/param"
"git.loafle.net/overflow/overflow_probe/crawler"
"github.com/stretchr/testify/assert"
"log"
"testing"
"time"
)
func setConfig() crawler.Crawler {
r := NewWMIHeahthCrawler()
m := make(map[string]interface{}, 0)
m["ip"] = "192.168.1.1"
m["port"] = "135"
m["portType"] = "tcp"
m["ssl"] = false
r.PutConfig("r", m)
return r
}
func TestMatch(t *testing.T) {
// test config
r := setConfig()
out := param.Output{}
r.Get("r", &out)
var check bool
json.Unmarshal(out.Data, &check)
assert.Equal(t, true, check)
}
func start() {
r := setConfig()
of_rpc.AddDelegate("r", r)
err := of_rpc.StartJSONRPC()
if err != nil {
log.Fatal(err)
}
}
func TestRPC(t *testing.T) {
go start()
time.Sleep(2 * time.Second)
in := param.Input{
Name: "r",
Id: "r",
}
result, err := client.InvokeJSONRPCGet("50000", in)
if err != nil {
t.Fatal(err)
}
var check bool
json.Unmarshal(result.Data, &check)
assert.Equal(t, true, check)
}
//package wmi_protocol_crawler
//
//import (
// "github.com/stretchr/testify/assert"
// "time"
// "git.loafle.net/overflow/of_rpc/models/protocol"
// "git.loafle.net/overflow/of_rpc/models/param"
// "git.loafle.net/overflow/of_rpc/json/client"
// "testing"
// "encoding/json"
//)
//
//func TestCheck(t *testing.T) {
// b, _ := check("192.168.1.1", 135, false)
// assert.Equal(t, true, b)
//}
//
//func TestRPC(t *testing.T) {
//
// go start()
// time.Sleep(time.Second * 2)
//
// p := protocol.HealthRequest{IsSSL: false}
// b, _ := json.Marshal(p)
//
// in := param.Input{Ip: "192.168.1.1", Port: 135, Data: b}
//
// re, _ := client.InvokeJSONRPC("50000", in)
// var m protocol.HealthResponse
// json.Unmarshal(re.Data, &m)
//
// assert.Equal(t, true, m.IsMatch)
//}

112
crawler/socket_health_crawler.go Normal file
View File

@ -0,0 +1,112 @@
package crawler
import (
"crypto/tls"
"git.loafle.net/overflow/overflow_probe/matcher"
"git.loafle.net/overflow/overflow_probe/matcher/packet"
"net"
"git.loafle.net/overflow/overflow_probe/model/scaninfo"
config "git.loafle.net/overflow/overflow_probe/agent_api/config_manager"
)
type SocketHeahthCrawler struct {
CrawlerImpl
m matcher.Matcher
}
func (s *SocketHeahthCrawler) SetMatcher(m matcher.Matcher) {
s.m = m
}
func (s *SocketHeahthCrawler) getConnection(params config.Config) (net.Conn, error) {
connection := params.Target.Connection
ip := connection.Ip
port := connection.Port
portType := connection.PortType
ssl := connection.SSL
var addr string = ip
addr += ":"
addr += port
if ssl == false {
conn, err := net.Dial(portType, addr)
if err != nil {
return nil, err
}
return conn, nil
} else {
conn, err := tls.Dial(
portType,
addr,
&tls.Config{
InsecureSkipVerify: true,
ServerName: ip,
ClientAuth: tls.RequestClientCert,
},
)
if err != nil {
return nil, err
}
return conn, nil
}
}
func (s *SocketHeahthCrawler) CheckHeahth(params config.Config) (bool, error) {
conn, err := s.getConnection(params)
if err != nil {
return false, err
}
defer conn.Close()
connection := params.Target.Connection
info := scaninfo.NewScanInfoImpl(connection.Ip,connection.Port)
if s.m.IsPrePacket() == true {
bytes := make([]byte, 1024)
n, _ := conn.Read(bytes)
p := packet.NewPacket(bytes, n)
if s.m.Match(0, p, info) == false {
return false, nil
} else {
for i := 0; i < s.m.PacketCount(); i++ {
pack := s.m.Packet(i)
conn.Write(pack.Buffer)
bytes := make([]byte, 1024)
n, _ := conn.Read(bytes)
if s.m.IsNoResponse(i+1) == true { // empty last response
break
}
p := packet.NewPacket(bytes, n)
if s.m.Match(i+1, p, info) == false {
return false, nil
}
}
}
} else {
for i := 0; i < s.m.PacketCount(); i++ {
pack := s.m.Packet(i)
conn.Write(pack.Buffer)
bytes := make([]byte, 1024)
n, _ := conn.Read(bytes)
if s.m.IsNoResponse(i) == true { // empty last response
break
}
p := packet.NewPacket(bytes, n)
if s.m.Match(i, p, info) == false {
return false, nil
}
}
}
return true, nil
}

93
crawler/test/crawler_test.go Normal file
View File

@ -0,0 +1,93 @@
package test
import (
"encoding/json"
"git.loafle.net/overflow/overflow_probe/crawler"
"git.loafle.net/overflow/overflow_probe/crawler/health_crawler/redis_protocol_crawler_go"
"github.com/stretchr/testify/assert"
"testing"
"io/ioutil"
)
func initConfig() crawler.CrawlerImpl {
c := crawler.CrawlerImpl{}
c.SetInternal(redis_protocol_crawler_go.NewRedisHeahthCrawler())
b, _ := ioutil.ReadFile("./example.json")
c.Init(b)
return c
}
func TestCrawlerInit(t *testing.T) {
c := initConfig()
m := c.GetConfig("test_id_001")
assert.Equal(t, m.Id, "test_id_001")
}
func TestCrawlerAdd(t *testing.T) {
c := initConfig()
c.Remove("test_id_001")
bb, _ := ioutil.ReadFile("./example.json")
b, _ := c.Add(bb)
var ck bool
json.Unmarshal(b, &ck)
assert.Equal(t, true, ck)
}
func TestCrawlerRemove(t *testing.T) {
c := initConfig()
b, _ := c.Remove("test_id_001")
var ck bool
json.Unmarshal(b, &ck)
assert.Equal(t, true, ck)
}
func TestCrawlerGet(t *testing.T) {
c := initConfig()
b, _ := c.Get("test_id_001")
var ck bool
json.Unmarshal(b, &ck)
assert.Equal(t, true, ck)
}
func TestFolder(t *testing.T) {
configPath := "./"
files, err := ioutil.ReadDir(configPath)
if err != nil {
t.Log(err)
}
for _, file := range files {
if file.IsDir() == true {
continue
}
t.Log(file.Name())
//_,err := c.Add(file.Name())
if err != nil {
t.Log(err)
}
}
}
func TestFile(t *testing.T) {
b, _ := ioutil.ReadFile("./example.json")
t.Log(string(b))
}

28
crawler/test/example.json Normal file
View File

@ -0,0 +1,28 @@
{
"id" : "test_id_001",
"target" : {
"connection" : {
"ip" : "192.168.1.104",
"port" : "6379",
"ssl" : false,
"portType" : "tcp"
},
"auth" : {
}
},
"schedule" : {
"interval" : "10"
},
"crawler" : {
"name":"redis_crawler",
"container":"java_proxy"
},
"items" : [
{
"type":"cpu",
"":[],
"":[],
}
]
}