2024-04-03 18:52:04 -06:00
|
|
|
package pnyx
|
|
|
|
|
|
|
|
import (
|
2024-04-06 16:38:14 -06:00
|
|
|
"crypto/aes"
|
|
|
|
"crypto/cipher"
|
|
|
|
"crypto/ed25519"
|
|
|
|
"crypto/rand"
|
2024-04-03 18:52:04 -06:00
|
|
|
"encoding/binary"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
2024-04-06 16:38:14 -06:00
|
|
|
mrand "math/rand"
|
2024-04-03 18:52:04 -06:00
|
|
|
"net"
|
2024-04-06 16:38:14 -06:00
|
|
|
"os"
|
2024-04-03 18:52:04 -06:00
|
|
|
"sync/atomic"
|
|
|
|
|
|
|
|
"github.com/google/uuid"
|
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
SERVER_UDP_BUFFER_SIZE = 2048
|
|
|
|
)
|
|
|
|
|
|
|
|
type SessionID uuid.UUID
|
2024-04-06 16:38:14 -06:00
|
|
|
func(id SessionID) String() string {
|
|
|
|
return uuid.UUID(id).String()
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
type Session struct {
|
2024-04-06 17:03:31 -06:00
|
|
|
ID SessionID
|
2024-04-06 16:38:14 -06:00
|
|
|
remote *net.UDPAddr
|
2024-04-06 17:03:31 -06:00
|
|
|
Peer ClientID
|
2024-04-06 16:38:14 -06:00
|
|
|
secret []byte
|
|
|
|
cipher cipher.Block
|
|
|
|
iv_generator mrand.Source64
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
type Server struct {
|
2024-04-06 16:38:14 -06:00
|
|
|
key ed25519.PrivateKey
|
2024-04-03 18:52:04 -06:00
|
|
|
active atomic.Bool
|
|
|
|
connection *net.UDPConn
|
|
|
|
stopped chan error
|
|
|
|
|
2024-04-06 16:38:14 -06:00
|
|
|
sessions map[SessionID]*Session
|
|
|
|
channels map[ChannelID]*Channel
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
|
2024-04-06 16:38:14 -06:00
|
|
|
func NewServer(key ed25519.PrivateKey) (*Server, error) {
|
|
|
|
if key == nil {
|
|
|
|
var err error
|
|
|
|
_, key, err = ed25519.GenerateKey(rand.Reader)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
2024-04-03 18:52:04 -06:00
|
|
|
server := &Server{
|
2024-04-06 16:38:14 -06:00
|
|
|
key: key,
|
2024-04-03 18:52:04 -06:00
|
|
|
connection: nil,
|
|
|
|
active: atomic.Bool{},
|
|
|
|
stopped: make(chan error, 0),
|
2024-04-06 16:38:14 -06:00
|
|
|
|
|
|
|
sessions: map[SessionID]*Session{},
|
|
|
|
channels: map[ChannelID]*Channel{},
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
server.active.Store(false)
|
2024-04-06 16:38:14 -06:00
|
|
|
return server, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check if the client has permission for the command on the channel
|
|
|
|
// If it's not specified, check the permission on the parent
|
|
|
|
func Allowed(server *Server, client ClientID, channel_id ChannelID, mode ModeID, command CommandID) bool {
|
|
|
|
channel, exists := server.channels[channel_id]
|
|
|
|
if exists == false {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
if channel.permissions != nil {
|
|
|
|
client_perms, exists := channel.permissions[client]
|
|
|
|
if exists {
|
|
|
|
if client_perms == nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
mode_perms, exists := client_perms[mode]
|
|
|
|
if exists {
|
|
|
|
if mode_perms == nil {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
allowed, exists := mode_perms[command]
|
|
|
|
if exists {
|
|
|
|
return allowed
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prevent a cycle on the root channel
|
|
|
|
if channel_id == RootChannelID {
|
|
|
|
return false
|
|
|
|
} else {
|
|
|
|
return Allowed(server, client, channel.parent, mode, command)
|
|
|
|
}
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
func (server *Server) Log(format string, fields ...interface{}) {
|
|
|
|
fmt.Fprint(os.Stderr, fmt.Sprintf(format, fields...) + "\n")
|
|
|
|
}
|
|
|
|
|
|
|
|
func(server *Server) Stop() error {
|
|
|
|
was_active := server.active.CompareAndSwap(true, false)
|
|
|
|
if was_active {
|
|
|
|
err := server.connection.Close()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
return <-server.stopped
|
|
|
|
} else {
|
|
|
|
return fmt.Errorf("Called stop func on stopped server")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func(server *Server) run() {
|
|
|
|
server.Log("Started server on %s", server.connection.LocalAddr())
|
|
|
|
|
|
|
|
var buf [SERVER_UDP_BUFFER_SIZE]byte
|
|
|
|
for true {
|
2024-04-06 16:38:14 -06:00
|
|
|
read, from, err := server.connection.ReadFromUDP(buf[:])
|
2024-04-03 18:52:04 -06:00
|
|
|
if err == nil {
|
2024-04-06 16:38:14 -06:00
|
|
|
var packet_type PacketType = PacketType(buf[0])
|
2024-04-03 18:52:04 -06:00
|
|
|
switch packet_type {
|
2024-04-06 16:38:14 -06:00
|
|
|
case SESSION_OPEN:
|
|
|
|
client_pubkey, ecdh_public, err := ParseSessionOpen(buf[COMMAND_LENGTH:read])
|
|
|
|
if err != nil {
|
|
|
|
server.Log("ParseSessionOpen error - %s: %x", err, buf[COMMAND_LENGTH:read])
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
client_id := ID[ClientID](client_pubkey)
|
|
|
|
|
|
|
|
session_open, ecdh_private, err := NewSessionOpen(server.key)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("NewSessionOpen error - %s: %x", err, buf[COMMAND_LENGTH:read])
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
_, err = server.connection.WriteToUDP(session_open, from)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("WriteToUDP error %s", err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
session_secret, err := ECDH(ecdh_public, ecdh_private)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("ECDH error %s", err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
session_id := ID[SessionID](session_secret)
|
|
|
|
|
|
|
|
session_cipher, err := aes.NewCipher(session_secret)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("AES error %s", err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
seed_bytes := make([]byte, 8)
|
|
|
|
read, err := rand.Read(seed_bytes)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("IV Seed error: %s", err)
|
|
|
|
continue
|
|
|
|
} else if read != 8 {
|
|
|
|
server.Log("IV Seed error: not enough bytes read %d/4", read)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
session := &Session{
|
2024-04-06 17:03:31 -06:00
|
|
|
ID: session_id,
|
2024-04-06 16:38:14 -06:00
|
|
|
remote: nil,
|
2024-04-06 17:03:31 -06:00
|
|
|
Peer: client_id,
|
2024-04-06 16:38:14 -06:00
|
|
|
secret: session_secret,
|
|
|
|
cipher: session_cipher,
|
|
|
|
iv_generator: mrand.NewSource(int64(binary.BigEndian.Uint64(seed_bytes))).(mrand.Source64),
|
|
|
|
}
|
|
|
|
server.sessions[session_id] = session
|
|
|
|
|
|
|
|
server.Log("Started session %s with %s", session_id, client_id)
|
|
|
|
case SESSION_CONNECT:
|
|
|
|
session_id := SessionID(buf[COMMAND_LENGTH:COMMAND_LENGTH+ID_LENGTH])
|
|
|
|
session, exists := server.sessions[session_id]
|
|
|
|
if exists == false {
|
|
|
|
server.Log("Session %s does not exist, can't connect", session_id)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
client_addr, err := ParseSessionConnect(buf[COMMAND_LENGTH+ID_LENGTH:read], session.secret)
|
|
|
|
if err != nil {
|
|
|
|
server.Log("Error parsing session connect: %s", err)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
session.remote = client_addr
|
2024-04-06 17:03:31 -06:00
|
|
|
server.Log("Got SESSION_CONNECT for client %s at address %s", session.Peer, session.remote)
|
2024-04-06 16:38:14 -06:00
|
|
|
|
|
|
|
// TODO: Send server hello back
|
2024-04-03 18:52:04 -06:00
|
|
|
default:
|
2024-04-06 16:38:14 -06:00
|
|
|
server.Log("Unhandled packet type 0x%04x from %s: %+v", packet_type, from, buf[COMMAND_LENGTH:read])
|
2024-04-03 18:52:04 -06:00
|
|
|
}
|
|
|
|
} else if errors.Is(err, net.ErrClosed) {
|
|
|
|
server.Log("UDP_CLOSE: %s", server.connection.LocalAddr())
|
|
|
|
break
|
|
|
|
} else {
|
|
|
|
server.Log("UDP_READ_ERROR: %s", err)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
server.Log("Shut down server on %s", server.connection.LocalAddr())
|
|
|
|
server.stopped <- nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func(server *Server) Start(listen string) error {
|
|
|
|
was_inactive := server.active.CompareAndSwap(false, true)
|
|
|
|
if was_inactive == false {
|
|
|
|
return fmt.Errorf("Server already active")
|
|
|
|
}
|
|
|
|
|
|
|
|
address, err := net.ResolveUDPAddr("udp", listen)
|
|
|
|
if err != nil {
|
|
|
|
server.active.Store(false)
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
server.connection, err = net.ListenUDP("udp", address)
|
|
|
|
if err != nil {
|
|
|
|
server.active.Store(false)
|
|
|
|
return fmt.Errorf("Failed to create udp server: %w", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
go server.run()
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|