[WIP] Feature connector rework

config/config.go

@@ -52,7 +52,7 @@ var format = logging.MustStringFormatter(
 type Config struct {
 	Listener toml.Primitive `toml:"listener"`
 
-	Web toml.Primitive `toml:"web"`
+	Web      toml.Primitive `toml:"web"`
 	AbTester toml.Primitive `toml:"abtester"`
 
 	Services  map[string]toml.Primitive `toml:"service"`

connectors/connector.go

@@ -0,0 +1,80 @@
+package connectors
+
+import (
+	"context"
+	"github.com/honeytrap/honeytrap/director"
+	"github.com/honeytrap/honeytrap/pushers"
+	"github.com/honeytrap/honeytrap/scripter"
+	"github.com/honeytrap/honeytrap/services"
+)
+
+type BaseConnector struct {
+	name          string
+	connectorType string
+	ctx           context.Context
+	channel       pushers.Channel
+
+	connectorMode string
+
+	service  services.Servicer
+	director director.Director
+	scripter scripter.Scripter
+}
+
+func (c *BaseConnector) GetName() string {
+	return c.name
+}
+
+func (c *BaseConnector) GetType() string {
+	return c.connectorType
+}
+
+func (c *BaseConnector) SetMode(mode string) {
+	c.connectorMode = mode
+}
+
+func (c *BaseConnector) GetMode() string {
+	return c.connectorMode
+}
+
+func (c *BaseConnector) SetContext(ctx context.Context) {
+	c.ctx = ctx
+}
+
+func (c *BaseConnector) SetChannel(channel pushers.Channel) {
+	c.channel = channel
+}
+
+func (c *BaseConnector) GetContext() context.Context {
+	return c.ctx
+}
+
+func (c *BaseConnector) GetChannel() pushers.Channel {
+	return c.channel
+}
+
+
+func (c *BaseConnector) SetService(s services.Servicer) {
+	c.service = s
+}
+
+func (c *BaseConnector) SetDirector(d director.Director) {
+	c.director = d
+}
+
+func (c *BaseConnector) SetScripter(scr scripter.Scripter) {
+	c.scripter = scr
+}
+
+func (c *BaseConnector) GetService() services.Servicer {
+	return c.service
+}
+
+func (c *BaseConnector) GetDirector() director.Director {
+	return c.director
+}
+
+func (c *BaseConnector) GetScripter() scripter.Scripter {
+	return c.scripter
+}
+

connectors/connectorModes.go

@@ -0,0 +1,8 @@
+package connectors
+
+const (
+	MODE_TERMINATE = "TERMINATE"
+	MODE_SERVICE = "SERVICE"
+	MODE_DIRECTOR = "DIRECTOR"
+	MODE_SCRIPTER = "SCRIPTER"
+)

connectors/connectors.go

@@ -0,0 +1,182 @@
+package connectors
+
+import (
+	"context"
+	"github.com/BurntSushi/toml"
+	"github.com/honeytrap/honeytrap/director"
+	"github.com/honeytrap/honeytrap/pushers"
+	"github.com/honeytrap/honeytrap/scripter"
+	"github.com/honeytrap/honeytrap/services"
+	"github.com/op/go-logging"
+	"net"
+	"fmt"
+	"sync"
+)
+
+var (
+	log        = logging.MustGetLogger("connectors")
+	connectors = map[string]func(...ConnectorFunc) Connector{}
+)
+
+func Register(key string, fn func(...ConnectorFunc) Connector) func(...ConnectorFunc) Connector {
+	connectors[key] = fn
+	return fn
+}
+
+func Get(key string) (func(...ConnectorFunc) Connector, bool) {
+	if fn, ok := connectors[key]; ok {
+		return fn, true
+	}
+
+	return nil, false
+}
+
+func GetAvailableConnectorNames() []string {
+	var out []string
+	for key := range connectors {
+		out = append(out, key)
+	}
+	return out
+}
+
+
+type ConnectorFunc func(Connector) error
+
+type Connector interface {
+	GetName() string
+	GetType() string
+
+	SetMode(string)
+	GetMode() string
+
+	SetContext(ctx context.Context)
+	SetChannel(c pushers.Channel)
+
+	GetContext() context.Context
+	GetChannel() pushers.Channel
+
+	SetService(services.Servicer)
+	SetDirector(director.Director)
+	SetScripter(scripter.Scripter)
+
+	GetService() services.Servicer
+	GetDirector() director.Director
+	GetScripter() scripter.Scripter
+}
+
+type CanHandlerer interface {
+	CanHandle([]byte) bool
+}
+
+// Handshaker performs handshake on incoming connections if it is implemented
+type Handshaker interface {
+	Handshake(net.Conn) (sync.Map, error)
+}
+
+// ContainerConnector implements connection to the container
+type ContainerConnector interface {
+	DialContainer(net.Conn, interface{}) error
+}
+
+// ServiceConnector handles the connection in the service
+type ServiceConnector interface {
+	HandleService(net.Conn, interface{}) error
+}
+
+// ScripterConnector handles the connection in the scripter
+type ScripterConnector interface {
+	HandleScripter(net.Conn, interface{}) error
+}
+
+func HandleConn(c Connector, conn net.Conn) error {
+	var data interface{}
+
+	h, ok := c.(Handshaker)
+	if ok {
+		data, err := h.Handshake(conn)
+		if err != nil {
+			return err
+		}
+	}
+
+	for {
+		var err error
+
+		switch c.GetMode() {
+		case MODE_SERVICE:
+			s, ok := c.(ServiceConnector)
+			if !ok {
+				return fmt.Errorf("service mode is not implemented")
+			}
+			err = s.HandleService(conn, data)
+			break
+		case MODE_DIRECTOR:
+			cnt, ok := c.(ContainerConnector)
+			if !ok {
+				return fmt.Errorf("director mode is not implemented")
+			}
+			err = cnt.DialContainer(conn, data)
+			break
+		case MODE_SCRIPTER:
+			scr, ok := c.(ScripterConnector)
+			if !ok {
+				return fmt.Errorf("scripter mode is not implemented")
+			}
+			err = scr.HandleScripter(conn, data)
+			break
+		case MODE_TERMINATE:
+			// With MODE_TERMINATE we return successfully
+			return nil
+		default:
+			fmt.Errorf("unrecognized mode: '%s'", c.GetMode())
+		}
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func WithConfig(p toml.Primitive) ConnectorFunc {
+	return func(c Connector) error {
+		err := toml.PrimitiveDecode(p, c)
+		return err
+	}
+}
+
+func WithContext(ctx context.Context) ConnectorFunc {
+	return func(c Connector) error {
+		c.SetContext(ctx)
+		return nil
+	}
+}
+
+func WithChannel(eb pushers.Channel) ConnectorFunc {
+	return func(c Connector) error {
+		c.SetChannel(eb)
+		return nil
+	}
+}
+
+func WithService(s services.Servicer) ConnectorFunc {
+	return func(c Connector) error {
+		c.SetService(s)
+		return nil
+	}
+}
+
+func WithDirector(d director.Director) ConnectorFunc {
+	return func(c Connector) error {
+		c.SetDirector(d)
+		return nil
+	}
+}
+
+func WithScripter(scr scripter.Scripter) ConnectorFunc {
+	return func(c Connector) error {
+		c.SetScripter(scr)
+		return nil
+	}
+}

services/generic/generic.go → connectors/generic/generic.go

@@ -31,21 +31,18 @@
 package generic
 
 import (
-	"context"
-	"github.com/honeytrap/honeytrap/pushers"
-	"github.com/honeytrap/honeytrap/scripter"
-	"github.com/honeytrap/honeytrap/services"
 	"github.com/honeytrap/honeytrap/utils"
 	"github.com/op/go-logging"
 	"net"
+	"github.com/honeytrap/honeytrap/connectors"
 )
 
 var (
-	_   = services.Register("generic", Generic)
-	log = logging.MustGetLogger("services/generic")
+	_   = connectors.Register("generic", Generic)
+	log = logging.MustGetLogger("connectors/generic")
 )
 
-func Generic(options ...services.ServicerFunc) services.Servicer {
+func Generic(options ...connectors.ConnectorFunc) connectors.Connector {
 	s := &genericService{}
 
 	for _, o := range options {
@@ -56,30 +53,20 @@ func Generic(options ...services.ServicerFunc) services.Servicer {
 }
 
 type genericService struct {
-	scr scripter.Scripter
-	c   pushers.Channel
+	connectors.BaseConnector
 }
 
 func (s *genericService) CanHandle(payload []byte) bool {
-	return s.scr.CanHandle("generic", string(payload))
+	return s.GetScripter().CanHandle("generic", string(payload))
 }
 
-func (s *genericService) SetScripter(scr scripter.Scripter) {
-	s.scr = scr
-}
-
-func (s *genericService) SetChannel(c pushers.Channel) {
-	s.c = c
-}
-
-// Handle handles the request
-func (s *genericService) Handle(ctx context.Context, conn net.Conn) error {
+func (s *genericService) HandleScripter(conn net.Conn, cData interface{}) error {
 	buffer := make([]byte, 4096)
 	pConn := utils.PeekConnection(conn)
 	n, _ := pConn.Peek(buffer)
 
 	// Add the go methods that have to be exposed to the scripts
-	connW := s.scr.GetConnection("generic", pConn)
+	connW := s.GetScripter().GetConnection("generic", pConn)
 
 	s.setMethods(connW)