129 lines
2.6 KiB
Go
129 lines
2.6 KiB
Go
package pnyx
|
|
|
|
import (
|
|
"crypto/ed25519"
|
|
"crypto/rand"
|
|
mrand "math/rand"
|
|
"encoding/binary"
|
|
"crypto/sha512"
|
|
"crypto/aes"
|
|
"net"
|
|
"sync"
|
|
"fmt"
|
|
|
|
"github.com/google/uuid"
|
|
)
|
|
|
|
type ClientID uuid.UUID
|
|
func(id ClientID) 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])
|
|
}
|
|
|
|
server_pubkey, ecdh_public, err := ParseSessionOpen(response[COMMAND_LENGTH:read])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
secret, err := ECDH(ecdh_public, ecdh_private)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
session_cipher, err := aes.NewCipher(secret)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
session_connect := NewSessionConnect(connection.LocalAddr().(*net.UDPAddr), 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{
|
|
ID: ID[SessionID](secret),
|
|
remote: address,
|
|
Peer: ID[ClientID](server_pubkey),
|
|
secret: secret,
|
|
cipher: session_cipher,
|
|
iv_generator: mrand.NewSource(int64(binary.BigEndian.Uint64(seed_bytes))).(mrand.Source64),
|
|
},
|
|
Connection: connection,
|
|
}, nil
|
|
}
|