Add ports listener feature

honeypot/ports/postgresstore.go

@@ -0,0 +1,71 @@
+package ports
+
+import (
+	"database/sql"
+	"time"
+
+	_ "github.com/jackc/pgx/v4/stdlib"
+)
+
+const DBSchema = `
+CREATE TABLE IF NOT EXISTS port_attempts(
+	id serial PRIMARY KEY,
+	date timestamptz,
+	remote_ip inet,
+	port varchar(5)
+);`
+
+type PostgresStore struct {
+	db *sql.DB
+}
+
+func NewPostgresStore(dsn string) (*PostgresStore, error) {
+	db, err := sql.Open("pgx", dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	s := &PostgresStore{db: db}
+	return s, nil
+}
+
+func (s *PostgresStore) InitDB() error {
+	_, err := s.db.Exec(DBSchema)
+	return err
+}
+
+func (s *PostgresStore) Add(attempt *ConnectionAttempt) error {
+	stmt := `INSERT INTO port_attempts(date, remote_ip, port)
+	VALUES ($1, $2, $3)`
+	tx, err := s.db.Begin()
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
+
+	_, err = tx.Exec(stmt, time.Now(), attempt.From, attempt.Port)
+	if err != nil {
+		return err
+	}
+	return tx.Commit()
+}
+
+func (s *PostgresStore) List() ([]*ConnectionAttempt, error) {
+	stmt := `SELECT remote_ip, port FROM port_attempts`
+	rows, err := s.db.Query(stmt)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var attempts []*ConnectionAttempt
+	for rows.Next() {
+		var a ConnectionAttempt
+		if err := rows.Scan(&a.From, &a.Port); err != nil {
+			return nil, err
+		}
+		attempts = append(attempts, &a)
+	}
+
+	return attempts, nil
+}

honeypot/ports/server.go

@@ -0,0 +1,96 @@
+package ports
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"time"
+
+	"go.uber.org/zap"
+)
+
+type Server struct {
+	EnabledPortsTCP []string
+	EnabledPortsUDP []string
+	IP              string
+	Logger          *zap.SugaredLogger
+
+	store Store
+}
+
+func New(store Store) *Server {
+	return &Server{store: store, Logger: zap.NewNop().Sugar()}
+}
+
+func (s *Server) Start(ctx context.Context) error {
+	for _, port := range s.EnabledPortsTCP {
+		portCtx, cancel := context.WithCancel(ctx)
+		go s.doListenTCP(portCtx, port)
+		defer cancel()
+	}
+
+	<-ctx.Done()
+	return nil
+}
+
+func (s *Server) AddTCPPort(port string) {
+	s.EnabledPortsTCP = append(s.EnabledPortsTCP, port)
+}
+
+func (s *Server) doListenTCP(ctx context.Context, port string) error {
+	lAddr, err := net.ResolveTCPAddr("tcp", net.JoinHostPort(s.IP, port))
+	if err != nil {
+		s.Logger.Warnw("Error resoling listening addr.", "network", "tcp", "port", port)
+		return fmt.Errorf("error resolving listening address: %w", err)
+	}
+
+	listener, err := net.ListenTCP("tcp", lAddr)
+	if err != nil {
+		return fmt.Errorf("error starting listener: %w", err)
+	}
+	defer listener.Close()
+
+	go func() {
+		<-ctx.Done()
+		s.Logger.Debug("Listener context cancelled.")
+		listener.Close()
+	}()
+
+	s.Logger.Infow("Listening for connections to TCP port.", "port", port)
+	for {
+		conn, err := listener.Accept()
+		if err != nil {
+			select {
+			case <-ctx.Done():
+				s.Logger.Infow("Listener shutting down.", "port", port, "network", "tcp")
+				return nil
+			default:
+				s.Logger.Infow("Error accepting connection.", "error", err)
+				continue
+			}
+		}
+
+		s.Logger.Infow("Got connection on port.", "port", port, "network", "tcp", "remote_addr", conn.RemoteAddr().String())
+
+		conn.SetReadDeadline(time.Now().Add(time.Second * 15))
+
+		buf := make([]byte, 256)
+
+		_, err = conn.Read(buf)
+		if err != nil {
+			buf = []byte{}
+		}
+
+		attempt := &ConnectionAttempt{
+			Port:    port,
+			Network: "tcp",
+			From:    conn.RemoteAddr().String(),
+			Data:    buf,
+		}
+		conn.Close()
+
+		if err := s.store.Add(attempt); err != nil {
+			s.Logger.Warnw("Error storing attempt in store.", "error", err)
+		}
+	}
+}

honeypot/ports/server_test.go

@@ -0,0 +1,45 @@
+package ports_test
+
+import (
+	"net"
+	"testing"
+	"time"
+
+	"context"
+
+	"github.uio.no/torjus/apiary/honeypot/ports"
+)
+
+func TestServer(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	store := &ports.MemoryStore{}
+	server := ports.New(store)
+	server.IP = "127.0.0.1"
+
+	server.AddTCPPort("25")
+
+	go server.Start(ctx)
+
+	rAddr, err := net.ResolveTCPAddr("tcp", net.JoinHostPort(server.IP, "25"))
+	if err != nil {
+		t.Fatalf("Error resolving remote address: %s", err)
+	}
+	conn, err := net.DialTCP("tcp", nil, rAddr)
+	if err != nil {
+		t.Fatalf("Dialing server returned error: %s", err)
+	}
+	conn.Write([]byte("LOL"))
+	conn.Close()
+	time.Sleep(1 * time.Second)
+	cancel()
+
+	attempts, err := store.List()
+	if err != nil {
+		t.Fatalf("Getting attempts from store returned error: %s", err)
+	}
+	if len(attempts) != 1 {
+		t.Fatalf("Wrong amount of attempts in store: %d", len(attempts))
+	}
+}

honeypot/ports/store.go

@@ -0,0 +1,26 @@
+package ports
+
+type ConnectionAttempt struct {
+	Port    string
+	Network string
+	From    string
+	Data    []byte
+}
+
+type Store interface {
+	Add(attempt *ConnectionAttempt) error
+	List() ([]*ConnectionAttempt, error)
+}
+
+type MemoryStore struct {
+	data []*ConnectionAttempt
+}
+
+func (s *MemoryStore) Add(attempt *ConnectionAttempt) error {
+	s.data = append(s.data, attempt)
+	return nil
+}
+
+func (s *MemoryStore) List() ([]*ConnectionAttempt, error) {
+	return s.data, nil
+}