Initiliazation

vv1/server/conn/agent.go

@@ -0,0 +1,18 @@
+package conn
+
+import (
+	"angel_server/consts"
+	"angel_server/cryptmeow"
+	"log/slog"
+	"net"
+)
+
+func agent_impl(conn net.Conn, layer_id int) {
+	var publicKey, _ [32]byte = cryptmeow.Gen_keypair()
+
+	_, err := conn.Write(publicKey[:])
+	if err != nil {
+		consts.Logger.Error("failed to send public key", slog.String("error", err.Error()))
+		return
+	}
+}

vv1/server/conn/conn.go

@@ -0,0 +1,43 @@
+package conn
+
+import (
+	"angel_server/consts"
+	"angel_server/extra"
+	"fmt"
+	"log/slog"
+	"net"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func Start_serv() {
+	consts.Logger.Info("Starting tcp listener...")
+
+	ln, err := net.Listen("tcp", fmt.Sprintf(":%d", extra.Port))
+	if err != nil {
+		consts.Logger.Error("Error occurred during server start:", slog.Any("error", err))
+		return
+	}
+	defer ln.Close()
+
+	stop := make(chan os.Signal, 1)
+	signal.Notify(stop, os.Interrupt, syscall.SIGTERM)
+
+	go func() {
+		<-stop
+		consts.Logger.Info("Shutting down server...")
+		ln.Close()
+		os.Exit(0)
+	}()
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			consts.Logger.Error("Error accepting connection:", slog.Any("error", err))
+			continue
+		}
+
+		go handleConnection(conn)
+	}
+}

vv1/server/conn/controller.go

@@ -0,0 +1,7 @@
+package conn
+
+import "net"
+
+func controller_impl(conn net.Conn) {
+
+}

vv1/server/conn/handler.go

@@ -0,0 +1,36 @@
+package conn
+
+import (
+	"angel_server/consts"
+	"angel_server/db"
+	"bytes"
+	"log/slog"
+	"net"
+	"strconv"
+)
+
+func handleConnection(conn net.Conn) {
+	defer conn.Close()
+	consts.Logger.Info("Received conn", slog.String("remote", conn.RemoteAddr().String()))
+
+	role := make([]byte, 8)
+	n, err := conn.Read(role)
+	if err != nil {
+		consts.Logger.Error("Failed to read role", slog.String("error", err.Error()))
+		return
+	}
+
+	layer_id := string(bytes.TrimSpace(role[:n]))
+	consts.Logger.Debug(layer_id)
+
+	int_meow, _ := strconv.Atoi(layer_id)
+	if (int_meow == 0) {
+		controller_impl(conn)
+	} else if (db.CheckLayer(consts.Db, int_meow)) {
+		agent_impl(conn, int_meow)
+	} else {
+		conn.Close()
+	}
+
+	consts.Logger.Info("Lost conn", slog.String("remote", conn.RemoteAddr().String()))
+}

vv1/server/consts/consts.go

@@ -0,0 +1,11 @@
+package consts
+
+import (
+	"angel_server/logging"
+	"database/sql"
+)
+
+
+
+var Logger = logging.GetLogger()
+var Db *sql.DB

vv1/server/cryptmeow/cryptmeow.go

@@ -0,0 +1,23 @@
+package cryptmeow
+
+import (
+	"angel_server/consts"
+	"crypto/rand"
+
+	"golang.org/x/crypto/curve25519"
+)
+
+func Gen_keypair() (publicKey [32]byte, privateKey [32]byte) {
+	consts.Logger.Warn("Generating ephemeral keys for SSH authetification.")
+
+	_, err := rand.Read(privateKey[:])
+	if err != nil {
+		consts.Logger.Error("Failed to generate private key: " + err.Error())
+	}
+
+	curve25519.ScalarBaseMult(&publicKey, &privateKey)
+
+	return publicKey, privateKey
+}
+
+var ControllerPublicKey, ControllerPrivateKey [32]byte = Gen_keypair()

vv1/server/db/database.go

@@ -0,0 +1,22 @@
+package db
+
+import (
+	"angel_server/consts"
+	"database/sql"
+	"log"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func CheckLayer(db *sql.DB, layerID int) bool {
+	var exists bool
+
+	query := `SELECT EXISTS(SELECT 1 FROM layers WHERE layer_id = ?);`
+
+	err := consts.Db.QueryRow(query, layerID).Scan(&exists)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	return exists
+}

vv1/server/extra/conf.go

@@ -0,0 +1,3 @@
+package extra
+
+var Port int = 8080

vv1/server/extra/extra.go

@@ -0,0 +1,48 @@
+package extra
+
+import (
+	"angel_server/consts"
+	"angel_server/cryptmeow"
+	"database/sql"
+	"fmt"
+	"log"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func Init() {
+	consts.Logger.Warn("Welcome to angel net! To autheticate as the admin controller of the net, you'll need to use the following key via the ssh shell")
+	consts.Logger.Warn(fmt.Sprintf("%d", cryptmeow.ControllerPublicKey[:]))
+
+	var err error
+	consts.Db, err = sql.Open("sqlite3", "../angel_db.sqlite3")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer consts.Db.Close()
+
+	createTableSQL := `
+	CREATE TABLE IF NOT EXISTS layers (
+		layer_id INTEGER NOT NULL CHECK(layer_id >= 0 AND layer_id <= 8),
+		public_key BLOB NOT NULL CHECK(LENGTH(public_key) = 32),
+		secret_key BLOB NOT NULL CHECK(LENGTH(secret_key) = 32),
+		PRIMARY KEY (layer_id)
+	);`
+
+	_, err = consts.Db.Exec(createTableSQL)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	var array_pk, array_sk []byte
+	copy(array_pk, cryptmeow.ControllerPublicKey[:])
+	copy(array_sk, cryptmeow.ControllerPrivateKey[:])
+
+	insertSQL := `INSERT OR IGNORE INTO layers (layer_id, public_key, secret_key) VALUES (?, ?, ?);`
+	_, err = consts.Db.Exec(insertSQL, 0, array_pk, array_sk)
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	consts.Logger.Info("Database initialized and 'layers' table created successfully! Admin/controller handler has been added.")
+}

vv1/server/go.mod

@@ -0,0 +1,8 @@
+module angel_server
+
+go 1.23.3
+
+require (
+	github.com/mattn/go-sqlite3 v1.14.24 // indirect
+	golang.org/x/crypto v0.32.0 // indirect
+)

vv1/server/go.sum

@@ -0,0 +1,4 @@
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+golang.org/x/crypto v0.32.0 h1:euUpcYgM8WcP71gNpTqQCn6rC2t6ULUPiOzfWaXVVfc=
+golang.org/x/crypto v0.32.0/go.mod h1:ZnnJkOaASj8g0AjIduWNlq2NRxL0PlBrbKVyZ6V/Ugc=

vv1/server/logging/logging.go

@@ -0,0 +1,69 @@
+package logging
+
+import (
+	"context"
+	"log/slog"
+	"os"
+)
+
+var Logger *slog.Logger
+
+type MultiHandler struct {
+	handlers []slog.Handler
+}
+
+func (m *MultiHandler) Enabled(ctx context.Context, level slog.Level) bool {
+	for _, h := range m.handlers {
+		if h.Enabled(ctx, level) {
+			return true
+		}
+	}
+	return false
+}
+
+func (m *MultiHandler) Handle(ctx context.Context, record slog.Record) error {
+	for _, h := range m.handlers {
+		_ = h.Handle(ctx, record)
+	}
+	return nil
+}
+
+func (m *MultiHandler) WithAttrs(attrs []slog.Attr) slog.Handler {
+	newHandlers := make([]slog.Handler, len(m.handlers))
+	for i, h := range m.handlers {
+		newHandlers[i] = h.WithAttrs(attrs)
+	}
+	return &MultiHandler{handlers: newHandlers}
+}
+
+func (m *MultiHandler) WithGroup(name string) slog.Handler {
+	newHandlers := make([]slog.Handler, len(m.handlers))
+	for i, h := range m.handlers {
+		newHandlers[i] = h.WithGroup(name)
+	}
+	return &MultiHandler{handlers: newHandlers}
+}
+
+func InitLogger() {
+	logFile, err := os.OpenFile("../angel_api-server.log", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		slog.Default().Error("Error opening log file", "error", err)
+		return
+	}
+
+	fileHandler := slog.NewJSONHandler(logFile, &slog.HandlerOptions{Level: slog.LevelDebug})
+	consoleHandler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelDebug})
+
+	multiHandler := &MultiHandler{handlers: []slog.Handler{fileHandler, consoleHandler}}
+
+	Logger = slog.New(multiHandler)
+
+	slog.SetDefault(Logger)
+}
+
+func GetLogger() *slog.Logger {
+	if Logger == nil {
+		InitLogger()
+	}
+	return Logger
+}

vv1/server/main.go

@@ -0,0 +1,13 @@
+package main
+
+import (
+	"angel_server/conn"
+	"angel_server/extra"
+	"angel_server/logging"
+)
+
+func main() {
+	logging.InitLogger()
+	extra.Init()
+	conn.Start_serv()
+}