146 lines
2.8 KiB
Go
146 lines
2.8 KiB
Go
package pnyx
|
|
|
|
import (
|
|
"crypto/ed25519"
|
|
"crypto/rand"
|
|
"crypto/sha512"
|
|
"net"
|
|
"sync"
|
|
"fmt"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type PeerID uuid.UUID
|
|
func(id PeerID) String() string {
|
|
return uuid.UUID(id).String()
|
|
}
|
|
|
|
type ClientState uint8
|
|
|
|
const (
|
|
CLIENT_SESSION_CREATE ClientState = iota
|
|
CLIENT_SESSION_CONNECT
|
|
CLIENT_SESSION_CONNECTED
|
|
)
|
|
|
|
type Client struct {
|
|
Key ed25519.PrivateKey
|
|
Session Session
|
|
ConnectionLock sync.Mutex
|
|
Connection *net.UDPConn
|
|
}
|
|
|
|
func ID[T ~[16]byte, V ~[]byte](data V) T {
|
|
hash := sha512.Sum512(data)
|
|
return (T)(hash[0:16])
|
|
}
|
|
|
|
func NewClient(key ed25519.PrivateKey, remote string) (*Client, error) {
|
|
if key == nil {
|
|
var err error
|
|
_, key, err = ed25519.GenerateKey(rand.Reader)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
|
|
seed_bytes := make([]byte, 8)
|
|
read, err := rand.Read(seed_bytes)
|
|
if err != nil {
|
|
return nil, err
|
|
} else if read != 8 {
|
|
return nil, fmt.Errorf("Failed to create IV seed for client")
|
|
}
|
|
|
|
address, err := net.ResolveUDPAddr("udp", remote)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
connection, err := net.DialUDP("udp", nil, address)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
session_open, ecdh_private, err := NewSessionOpen(key)
|
|
if err != nil {
|
|
connection.Close()
|
|
return nil, err
|
|
}
|
|
|
|
_, err = connection.Write(session_open)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var response = [512]byte{}
|
|
read, _, err = connection.ReadFromUDP(response[:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if response[0] != byte(SESSION_OPEN) {
|
|
return nil, fmt.Errorf("Invalid SESSION_OPEN response: %x", response[0])
|
|
}
|
|
|
|
session, err := ParseSessionOpen(ecdh_private, response[COMMAND_LENGTH:read])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
session_connect := NewSessionConnect(connection.LocalAddr().(*net.UDPAddr), session.secret)
|
|
_, err = connection.Write(session_connect)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
read, _, err = connection.ReadFromUDP(response[:])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Client{
|
|
Key: key,
|
|
Session: session,
|
|
Connection: connection,
|
|
}, nil
|
|
}
|
|
|
|
func(client *Client) Send(packet *Packet) error {
|
|
client.ConnectionLock.Lock()
|
|
defer client.ConnectionLock.Unlock()
|
|
|
|
if client.Connection == nil {
|
|
return fmt.Errorf("Client is not connected")
|
|
}
|
|
|
|
data, err := packet.MarshalBinary()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
wrapped, err := NewSessionData(&client.Session, data)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = client.Connection.Write(wrapped)
|
|
return err
|
|
}
|
|
|
|
func(client *Client) Close() error {
|
|
client.ConnectionLock.Lock()
|
|
defer client.ConnectionLock.Unlock()
|
|
|
|
if client.Connection == nil {
|
|
return fmt.Errorf("No connection to close")
|
|
}
|
|
|
|
client.Connection.Write(NewSessionClose(&client.Session))
|
|
err := client.Connection.Close()
|
|
client.Connection = nil
|
|
|
|
return err
|
|
}
|