diff options
| author | Onur Gündüz <ogunduz@gmail.com> | 2026-03-10 11:58:37 +0100 |
|---|---|---|
| committer | Onur Gündüz <ogunduz@gmail.com> | 2026-03-10 11:58:37 +0100 |
| commit | 03b95111f19a93ccee00e8e8e0afaab8112f5484 (patch) | |
| tree | c0bfd7c5c768b441c901645a5a9a83c533eaf56f | |
| parent | bcb40853f819cdbea99ec5d0ab2ee7594efd7690 (diff) | |
| download | noise-03b95111f19a93ccee00e8e8e0afaab8112f5484.tar.gz noise-03b95111f19a93ccee00e8e8e0afaab8112f5484.zip | |
Init package
| -rw-r--r-- | README.md | 149 | ||||
| -rw-r--r-- | cipher.go | 123 | ||||
| -rw-r--r-- | dh.go | 87 | ||||
| -rw-r--r-- | example_test.go | 173 | ||||
| -rw-r--r-- | go.mod | 7 | ||||
| -rw-r--r-- | go.sum | 4 | ||||
| -rw-r--r-- | hkdf.go | 51 | ||||
| -rw-r--r-- | noise.go | 544 | ||||
| -rw-r--r-- | noise_test.go | 557 | ||||
| -rw-r--r-- | symmetric_state.go | 144 |
10 files changed, 1839 insertions, 0 deletions
@@ -1 +1,150 @@ # noisehandshake + +A pure Go implementation of the core [Noise Protocol](https://noiseprotocol.org/) handshake patterns. + +**Supported patterns**: + +- **NN**: Basic ephemeral key exchange (no authentication) +- **XX**: Full mutual authentication with ephemeral and static keys +- **IK**: Initiator knows responder's static key in advance +- **XK**: Initiator knows responder's static key, delayed authentication +- **PSK variants**: NNpsk0, XXpsk0 for pre-shared key authentication + +## Usage + +### Basic XX handshake + +```go +package main + +import ( + "fmt" + "log" + + nhs "github.com/tetsuo/noisehandshake" +) + +func main() { + // Create initiator and responder + initiator, err := nhs.NewNoiseState( + nhs.PatternXX, + true, // initiator role + &nhs.Config{}, + ) + if err != nil { + log.Fatal(err) + } + + responder, err := nhs.NewNoiseState( + nhs.PatternXX, + false, // responder role + &nhs.Config{}, + ) + if err != nil { + log.Fatal(err) + } + + // Initialize with prologue (optional metadata) + prologue := []byte("MyApplication v1.0") + initiator.Initialize(prologue, nil) + responder.Initialize(prologue, nil) + + // Perform handshake (3 messages for XX pattern) + // Message 1: initiator -> responder + msg1, _ := initiator.Send([]byte("Hello")) + payload1, _ := responder.Recv(msg1) + fmt.Printf("Received: %s\n", payload1) + + // Message 2: responder -> initiator + msg2, _ := responder.Send([]byte("World")) + payload2, _ := initiator.Recv(msg2) + fmt.Printf("Received: %s\n", payload2) + + // Message 3: initiator -> responder (finalizes handshake) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + // Handshake complete: now use transport keys + if initiator.IsComplete() && responder.IsComplete() { + fmt.Println("Handshake complete!") + + // Get handshake hash (can be used for channel binding) + hash := initiator.GetHash() + fmt.Printf("Handshake hash: %x\n", hash) + + // Get transport cipher states + txInit := initiator.GetTX() + rxInit := initiator.GetRX() + txResp := responder.GetTX() + rxResp := responder.GetRX() + + // Send encrypted messages + plaintext := []byte("Secret message") + ciphertext, _ := txInit.Encrypt(plaintext, nil) + decrypted, _ := rxResp.Decrypt(ciphertext, nil) + fmt.Printf("Decrypted: %s\n", decrypted) + } +} +``` + +### PSK handshake + +```go +// Use a pre-shared key for authentication +psk := []byte("my-32-byte-pre-shared-key-here!!") + +initiator, _ := nhs.NewNoiseState( + nhs.PatternXXpsk0, + true, + &nhs.Config{PSK: psk}, +) + +responder, _ := nhs.NewNoiseState( + nhs.PatternXXpsk0, + false, + &nhs.Config{PSK: psk}, +) +``` + +### IK pattern (pre-known responder key) + +```go +// Responder's static public key is known in advance +responderStaticKey := getResponderPublicKey() + +initiator, _ := nhs.NewNoiseState( + nhs.PatternIK, + true, + &nhs.Config{}, +) + +// Initialize with remote static key +initiator.Initialize(prologue, responderStaticKey) +``` + +### Using custom static keys + +```go +// Generate or load static keypair +curve := nhs.DefaultCurve +staticKeypair, _ := curve.GenerateKeyPair(nil) + +// Or use a seed for deterministic keys +seed := make([]byte, 32) +// ... fill seed ... +staticKeypair, _ = curve.GenerateKeyPair(seed) + +initiator, _ := nhs.NewNoiseState( + nhs.PatternXX, + true, + &nhs.Config{StaticKeypair: staticKeypair}, +) +``` + +## References + +- [Noise Protocol Framework](https://noiseprotocol.org/) +- [Noise Protocol Specification (Revision 34)](https://noiseprotocol.org/noise.html) +- [RFC 7539: ChaCha20-Poly1305](https://tools.ietf.org/html/rfc7539) +- [RFC 7748: Curve25519](https://tools.ietf.org/html/rfc7748) +- [RFC 7693: BLAKE2](https://tools.ietf.org/html/rfc7693) diff --git a/cipher.go b/cipher.go new file mode 100644 index 0000000..057cf97 --- /dev/null +++ b/cipher.go @@ -0,0 +1,123 @@ +package noisehandshake + +import ( + "crypto/cipher" + "encoding/binary" + "errors" + "fmt" + + "golang.org/x/crypto/chacha20poly1305" +) + +const ( + // MaxMessageLength is the maximum Noise message size. + MaxMessageLength = 65535 + // KeyBytes is the cipher key size. For ChaCha20Poly1305, this is 32 bytes. + KeyBytes = 32 + // MacBytes is the MAC size. + MacBytes = 16 +) + +var ( + // ErrCiphertextTooLong indicates message exceeds maximum length. + ErrCiphertextTooLong = errors.New("ciphertext exceeds maximum message length") + // ErrInvalidKeySize indicates invalid key size. + ErrInvalidKeySize = errors.New("invalid key size for ChaCha20Poly1305") +) + +// CipherState represents the cipher state in Noise Protocol. +type CipherState struct { + key []byte + aead cipher.AEAD // Reuse AEAD instance for performance + nonce uint64 + nonceBuf [chacha20poly1305.NonceSize]byte +} + +// newCipherState creates a new cipher state with an optional key. +func newCipherState(key []byte) (*CipherState, error) { + cs := &CipherState{ + nonce: 0, + } + if key != nil { + if len(key) != KeyBytes { + return nil, ErrInvalidKeySize + } + cs.initializeKey(key) + } + return cs, nil +} + +// initializeKey sets the key and resets the nonce. +// This assumes key is a valid 32-byte slice. Caller should ensure this is the case. +func (cs *CipherState) initializeKey(key []byte) { + cs.key = make([]byte, len(key)) + copy(cs.key, key) + + // Initialize the AEAD once for reuse + var err error + cs.aead, err = chacha20poly1305.New(cs.key) + if err != nil { + // Should never happen with 32-byte key + panic(fmt.Sprintf("cipher: failed to initialize AEAD: %v", err)) + } + + cs.nonce = 0 +} + +// HasKey returns true if the cipher state has a key. +func (cs *CipherState) HasKey() bool { + return cs.aead != nil +} + +// Encrypt encrypts plaintext with associated data, appending the result to dst. +// If no key is set, it appends the plaintext unchanged. +func (cs *CipherState) Encrypt(dst, plaintext, ad []byte) ([]byte, error) { + if !cs.HasKey() { + return append(dst, plaintext...), nil + } + + binary.LittleEndian.PutUint64(cs.nonceBuf[4:], cs.nonce) + + ret := cs.aead.Seal(dst, cs.nonceBuf[:], plaintext, ad) + + if len(ret)-len(dst) > MaxMessageLength { + return nil, ErrCiphertextTooLong + } + + cs.nonce++ + return ret, nil +} + +// Decrypt decrypts ciphertext with associated data, appending the result to dst. +// If no key is set, it appends the ciphertext unchanged. +func (cs *CipherState) Decrypt(dst, ciphertext, ad []byte) ([]byte, error) { + if !cs.HasKey() { + return append(dst, ciphertext...), nil + } + + if len(ciphertext) > MaxMessageLength { + return nil, ErrCiphertextTooLong + } + + binary.LittleEndian.PutUint64(cs.nonceBuf[4:], cs.nonce) + + ret, err := cs.aead.Open(dst, cs.nonceBuf[:], ciphertext, ad) + if err != nil { + return nil, fmt.Errorf("decryption failed: %w", err) + } + + cs.nonce++ + return ret, nil +} + +// Clear clears the key from memory. +func (cs *CipherState) Clear() { + if cs.key != nil { + for i := range cs.key { + cs.key[i] = 0 + } + cs.key = nil + } + cs.aead = nil + cs.nonce = 0 +} @@ -0,0 +1,87 @@ +package noisehandshake + +import ( + "crypto/rand" + "fmt" + "io" + + "golang.org/x/crypto/curve25519" +) + +const ( + // DiffieHellmanLength is the Diffie-Hellman output length. + DiffieHellmanLength = 32 + // PublicKeyLength is the public key length. + PublicKeyLength = 32 + // SecretKeyLength is the secret key length. + SecretKeyLength = 32 + // DiffieHellmanAlgorithm is the DH algorithm name. + DiffieHellmanAlgorithm = "25519" +) + +// KeyPair is a Curve25519 key pair. +type KeyPair struct { + PublicKey []byte + SecretKey []byte +} + +// Curve represents the Curve25519 DH operations. +type Curve struct{} + +// DefaultCurve is the default Curve25519 implementation. +var DefaultCurve = &Curve{} + +// GenerateKeyPair creates a new Curve25519 key pair. +// If privKey is provided, it derives the public key from it. +// For deterministic key generation, pass a 32-byte seed as privKey. +func (c *Curve) GenerateKeyPair(privKey []byte) (*KeyPair, error) { + secretKey := make([]byte, SecretKeyLength) + + if privKey != nil { + if len(privKey) != SecretKeyLength { + return nil, fmt.Errorf("noise: invalid private key length %d, expected %d", len(privKey), SecretKeyLength) + } + copy(secretKey, privKey) + } else { + // Generate random secret key + if _, err := io.ReadFull(rand.Reader, secretKey); err != nil { + return nil, fmt.Errorf("noise: failed to generate random key: %w", err) + } + } + + // Calculate public key: publicKey = basePoint * secretKey + // curve25519.X25519 handles the clamping internally + publicKey, err := curve25519.X25519(secretKey, curve25519.Basepoint) + if err != nil { + return nil, fmt.Errorf("noise: X25519 operation failed: %w", err) + } + + return &KeyPair{ + PublicKey: publicKey, + SecretKey: secretKey, + }, nil +} + +// DH performs Diffie-Hellman calculation. +// It takes the remote party's public key and the local party's key pair, +// and returns the shared secret. +func (c *Curve) DH(publicKey []byte, localKey *KeyPair) ([]byte, error) { + if len(publicKey) != PublicKeyLength { + return nil, fmt.Errorf("noise: invalid public key length %d, expected %d", len(publicKey), PublicKeyLength) + } + if len(localKey.SecretKey) != SecretKeyLength { + return nil, fmt.Errorf("noise: invalid secret key length %d, expected %d", len(localKey.SecretKey), SecretKeyLength) + } + + // Perform scalar multiplication: output = secretKey * publicKey + sharedSecret, err := curve25519.X25519(localKey.SecretKey, publicKey) + if err != nil { + return nil, fmt.Errorf("noise: DH calculation failed: %w", err) + } + + return sharedSecret, nil +} + +func (c *Curve) ALG() string { + return DiffieHellmanAlgorithm +} diff --git a/example_test.go b/example_test.go new file mode 100644 index 0000000..46a81b3 --- /dev/null +++ b/example_test.go @@ -0,0 +1,173 @@ +package noisehandshake_test + +import ( + "fmt" + "log" + + nhs "github.com/tetsuo/noisehandshake" +) + +// Example demonstrates a basic XX handshake pattern. +func Example() { + // Create initiator and responder + initiator, err := nhs.NewNoiseState( + nhs.PatternXX, + true, + &nhs.Config{}, + ) + if err != nil { + log.Fatal(err) + } + + responder, err := nhs.NewNoiseState( + nhs.PatternXX, + false, + &nhs.Config{}, + ) + if err != nil { + log.Fatal(err) + } + + // Initialize with prologue + prologue := []byte("MyProtocol v1.0") + initiator.Initialize(prologue, nil) + responder.Initialize(prologue, nil) + + // Perform handshake + // Message 1: initiator -> responder + msg1, _ := initiator.Send([]byte("Hello")) + payload1, _ := responder.Recv(msg1) + fmt.Printf("Responder received: %s\n", payload1) + + // Message 2: responder -> initiator + msg2, _ := responder.Send([]byte("World")) + payload2, _ := initiator.Recv(msg2) + fmt.Printf("Initiator received: %s\n", payload2) + + // Message 3: initiator -> responder (finalizes) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + // Handshake complete + if initiator.IsComplete() && responder.IsComplete() { + fmt.Println("Handshake complete!") + + // Use transport keys for encrypted communication + plaintext := []byte("Secret") + ciphertext, _ := initiator.GetTX().Encrypt(nil, plaintext, nil) + decrypted, _ := responder.GetRX().Decrypt(nil, ciphertext, nil) + fmt.Printf("Transport message: %s\n", decrypted) + } + + // Output: + // Responder received: Hello + // Initiator received: World + // Handshake complete! + // Transport message: Secret +} + +// ExamplePSK demonstrates PSK handshake. +func Example_psk() { + psk := []byte("my-32-byte-pre-shared-key-here!!") + + initiator, _ := nhs.NewNoiseState( + nhs.PatternXXpsk0, + true, + &nhs.Config{PSK: psk}, + ) + + responder, _ := nhs.NewNoiseState( + nhs.PatternXXpsk0, + false, + &nhs.Config{PSK: psk}, + ) + + prologue := []byte("PSK Demo") + initiator.Initialize(prologue, nil) + responder.Initialize(prologue, nil) + + // Complete handshake + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + fmt.Printf("PSK handshake complete: %v\n", initiator.IsComplete()) + + // Output: + // PSK handshake complete: true +} + +// Example_ik demonstrates IK pattern with pre-known responder key. +func Example_ik() { + // Responder has a known static key + responder, _ := nhs.NewNoiseState( + nhs.PatternIK, + false, + &nhs.Config{}, + ) + responderPublicKey := responder.GetStaticPublicKey() + + // Initiator knows responder's key in advance + initiator, _ := nhs.NewNoiseState( + nhs.PatternIK, + true, + &nhs.Config{}, + ) + + prologue := []byte("IK Demo") + initiator.Initialize(prologue, responderPublicKey) + responder.Initialize(prologue, nil) + + // Complete 2-message handshake + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + + fmt.Printf("IK handshake complete: %v\n", initiator.IsComplete()) + + // Output: + // IK handshake complete: true +} + +// Example_customKeys demonstrates using custom static keypairs. +func Example_customKeys() { + curve := nhs.DefaultCurve + + // Generate static keypairs + initiatorStatic, _ := curve.GenerateKeyPair(nil) + responderStatic, _ := curve.GenerateKeyPair(nil) + + // Create states with custom keys + initiator, _ := nhs.NewNoiseState( + nhs.PatternXX, + true, + &nhs.Config{StaticKeypair: initiatorStatic}, + ) + + responder, _ := nhs.NewNoiseState( + nhs.PatternXX, + false, + &nhs.Config{StaticKeypair: responderStatic}, + ) + + prologue := []byte{} + initiator.Initialize(prologue, nil) + responder.Initialize(prologue, nil) + + // Complete handshake + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + fmt.Printf("Custom keys handshake: %v\n", initiator.IsComplete()) + + // Output: + // Custom keys handshake: true +} @@ -0,0 +1,7 @@ +module github.com/tetsuo/noisehandshake + +go 1.25.0 + +require golang.org/x/crypto v0.48.0 + +require golang.org/x/sys v0.41.0 // indirect @@ -0,0 +1,4 @@ +golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts= +golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos= +golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= +golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= @@ -0,0 +1,51 @@ +package noisehandshake + +import ( + "crypto/hmac" + "fmt" + "hash" + + "golang.org/x/crypto/blake2b" +) + +const ( + hashLen = 64 +) + +// newBLAKE2b512 returns a new BLAKE2b-512 hash. +func newBLAKE2b512() hash.Hash { + h, err := blake2b.New512(nil) + if err != nil { + panic(fmt.Sprintf("noisehandshake: could not create BLAKE2b-512 hash: %v", err)) + } + return h +} + +// hkdf performs HMAC-based Extract-and-Expand Key Derivation Function. +// Returns numChunks of hashLen-sized outputs. +func hkdf(salt, inputKeyMaterial, info []byte, numChunks int) [][]byte { + // Extract phase: PRK = HMAC-Hash(salt, ikm) + extractMac := hmac.New(newBLAKE2b512, salt) + extractMac.Write(inputKeyMaterial) + prk := extractMac.Sum(nil) + + // Expand phase: generate numChunks outputs + results := make([][]byte, numChunks) + var lastChunk []byte + + for i := range numChunks { + expandMac := hmac.New(newBLAKE2b512, prk) + + // T(i) = HMAC(PRK, T(i-1) || info || i) + if lastChunk != nil { + expandMac.Write(lastChunk) + } + expandMac.Write(info) + expandMac.Write([]byte{byte(i + 1)}) + + lastChunk = expandMac.Sum(nil) + results[i] = lastChunk + } + + return results +} diff --git a/noise.go b/noise.go new file mode 100644 index 0000000..4ed792d --- /dev/null +++ b/noise.go @@ -0,0 +1,544 @@ +package noisehandshake + +import ( + "bytes" + "errors" + "fmt" + "slices" +) + +// Token represents a handshake pattern token. +type Token int + +const ( + // Preshare tokens. + TokenPreshareIS Token = iota - 2 + TokenPreshareRS + + // Message tokens. + TokenPSK + TokenE + TokenS + TokenEE + TokenES + TokenSE + TokenSS +) + +// HandshakePattern defines a Noise handshake pattern. +type HandshakePattern struct { + Name string + Messages [][]Token + Preshare []Token +} + +// Predefined handshake patterns. +var ( + // PatternNN is the NN handshake pattern. + // No static keys, no pre-shared keys. + PatternNN = &HandshakePattern{ + Name: "NN", + Messages: [][]Token{ + {TokenE}, + {TokenE, TokenEE}, + }, + } + + // PatternNNpsk0 is the NN handshake pattern with a pre-shared key. + // Both parties mix the PSK before sending their ephemeral key. + PatternNNpsk0 = &HandshakePattern{ + Name: "NNpsk0", + Messages: [][]Token{ + {TokenPSK, TokenE}, + {TokenE, TokenEE}, + }, + } + + // PatternXX is the XX handshake pattern. + // Both parties have static keys, but they are not pre-shared. + PatternXX = &HandshakePattern{ + Name: "XX", + Messages: [][]Token{ + {TokenE}, + {TokenE, TokenEE, TokenS, TokenES}, + {TokenS, TokenSE}, + }, + } + + // PatternXXpsk0 is the XX handshake pattern with a pre-shared key. + // Both parties mix the PSK before sending their ephemeral key. + PatternXXpsk0 = &HandshakePattern{ + Name: "XXpsk0", + Messages: [][]Token{ + {TokenPSK, TokenE}, + {TokenE, TokenEE, TokenS, TokenES}, + {TokenS, TokenSE}, + }, + } + + // PatternIK is the IK handshake pattern. + // The initiator knows the responder's static public key in advance. + PatternIK = &HandshakePattern{ + Name: "IK", + Preshare: []Token{TokenPreshareRS}, + Messages: [][]Token{ + {TokenE, TokenES, TokenS, TokenSS}, + {TokenE, TokenEE, TokenSE}, + }, + } + + // PatternXK is the XK handshake pattern. + // The responder has a static key, but the initiator does not know it in advance. + PatternXK = &HandshakePattern{ + Name: "XK", + Preshare: []Token{TokenPreshareRS}, + Messages: [][]Token{ + {TokenE, TokenES}, + {TokenE, TokenEE}, + {TokenS, TokenSE}, + }, + } +) + +// NoiseState represents a Noise Protocol handshake state. +type NoiseState struct { + *symmetricState + + // Static and ephemeral keypairs. + s *KeyPair + e *KeyPair + + // Remote keys. + re []byte + rs []byte + + // PSK. Only used if handshake pattern includes PSK token. + psk []byte + + // Pattern and state. + pattern *HandshakePattern + handshakeQueue [][]Token + initiator bool + isPskHandshake bool + complete bool + + // Final transport keys and hash. + tx *CipherState + rx *CipherState + hash []byte +} + +// Config holds configuration for NoiseState. +type Config struct { + Curve *Curve + StaticKeypair *KeyPair + PSK []byte +} + +// NewNoiseState creates a new Noise Protocol state. +func NewNoiseState(pattern *HandshakePattern, initiator bool, config *Config) (*NoiseState, error) { + if config == nil { + config = &Config{} + } + if config.Curve == nil { + config.Curve = DefaultCurve + } + + // Generate static keypair if not provided + staticKP := config.StaticKeypair + if staticKP == nil { + var err error + staticKP, err = config.Curve.GenerateKeyPair(nil) + if err != nil { + return nil, err + } + } + + // Copy handshake pattern + handshakeQueue := make([][]Token, 0) + if pattern.Preshare != nil { + for _, t := range pattern.Preshare { + handshakeQueue = append(handshakeQueue, []Token{t}) + } + } + for _, msg := range pattern.Messages { + msgCopy := make([]Token, len(msg)) + copy(msgCopy, msg) + handshakeQueue = append(handshakeQueue, msgCopy) + } + + if config.PSK != nil && len(config.PSK) != 32 { + return nil, fmt.Errorf("noise: PSK must be exactly 32 bytes, got %d", len(config.PSK)) + } + + isPskHandshake := config.PSK != nil && hasPskToken(handshakeQueue) + + ns := &NoiseState{ + symmetricState: newSymmetricState(config.Curve), + s: staticKP, + e: nil, + re: nil, + rs: nil, + psk: config.PSK, + pattern: pattern, + handshakeQueue: handshakeQueue, + initiator: initiator, + isPskHandshake: isPskHandshake, + complete: false, + tx: nil, + rx: nil, + hash: nil, + } + + return ns, nil +} + +// Initialize initializes the handshake with prologue and optional remote static key. +func (ns *NoiseState) Initialize(prologue, remoteStatic []byte) error { + // Build protocol name + protocolName := fmt.Sprintf("Noise_%s_%s_%s_BLAKE2b", + ns.pattern.Name, + ns.curve.ALG(), + "ChaChaPoly") + + // Initialize symmetric state with protocol name + ns.initializeSymmetric([]byte(protocolName)) + + // Mix prologue + ns.mixHash(prologue) + + // Process preshare tokens + for len(ns.handshakeQueue) > 0 && len(ns.handshakeQueue[0]) == 1 { + token := ns.handshakeQueue[0][0] + if token != TokenPreshareRS && token != TokenPreshareIS { + break + } + + ns.handshakeQueue = ns.handshakeQueue[1:] + + takeRemoteKey := (ns.initiator && token == TokenPreshareRS) || + (!ns.initiator && token == TokenPreshareIS) + + if takeRemoteKey { + if remoteStatic == nil { + return errors.New("remote static key required for preshare") + } + ns.rs = make([]byte, len(remoteStatic)) + copy(ns.rs, remoteStatic) + } + + var key []byte + if takeRemoteKey { + key = ns.rs + } else { + key = ns.s.PublicKey + } + + ns.mixHash(key) + } + + return nil +} + +// Send sends a handshake message with optional payload. +func (ns *NoiseState) Send(payload []byte) ([]byte, error) { + if len(ns.handshakeQueue) == 0 { + return nil, errors.New("handshake already complete") + } + + if payload == nil { + payload = []byte{} + } + + var buf bytes.Buffer + patterns := ns.handshakeQueue[0] + ns.handshakeQueue = ns.handshakeQueue[1:] + + for _, token := range patterns { + switch token { + case TokenPSK: + ns.mixKeyAndHash(ns.psk) + + case TokenE: + if ns.e == nil { + var err error + ns.e, err = ns.curve.GenerateKeyPair(nil) + if err != nil { + return nil, err + } + } + ns.mixHash(ns.e.PublicKey) + if ns.isPskHandshake { + ns.mixKeyNormal(ns.e.PublicKey) + } + buf.Write(ns.e.PublicKey) + + case TokenS: + ciphertext, err := ns.encryptAndHash(ns.s.PublicKey) + if err != nil { + return nil, err + } + buf.Write(ciphertext) + + case TokenEE, TokenES, TokenSE, TokenSS: + useStatic := getKeyPattern(token, ns.initiator) + localKey := ns.s + if !useStatic.local { + localKey = ns.e + } + remoteKey := ns.rs + if !useStatic.remote { + remoteKey = ns.re + } + if err := ns.mixKey(remoteKey, localKey); err != nil { + return nil, err + } + + default: + return nil, fmt.Errorf("unexpected token: %d", token) + } + } + + // Encrypt payload + ciphertext, err := ns.encryptAndHash(payload) + if err != nil { + return nil, err + } + buf.Write(ciphertext) + + // Finalize if handshake complete + if len(ns.handshakeQueue) == 0 { + if err := ns.final(); err != nil { + return nil, err + } + } + + return buf.Bytes(), nil +} + +// Recv receives and processes a handshake message. +func (ns *NoiseState) Recv(message []byte) ([]byte, error) { + if len(ns.handshakeQueue) == 0 { + return nil, errors.New("handshake already complete") + } + + offset := 0 + patterns := ns.handshakeQueue[0] + ns.handshakeQueue = ns.handshakeQueue[1:] + + for _, token := range patterns { + switch token { + case TokenPSK: + ns.mixKeyAndHash(ns.psk) + + case TokenE: + if offset+PublicKeyLength > len(message) { + return nil, errors.New("insufficient bytes for public key") + } + ns.re = make([]byte, PublicKeyLength) + copy(ns.re, message[offset:offset+PublicKeyLength]) + offset += PublicKeyLength + + ns.mixHash(ns.re) + if ns.isPskHandshake { + ns.mixKeyNormal(ns.re) + } + + case TokenS: + klen := PublicKeyLength + if ns.cs.HasKey() { + klen = PublicKeyLength + MacBytes + } + if offset+klen > len(message) { + return nil, errors.New("insufficient bytes for static key") + } + var err error + ns.rs, err = ns.decryptAndHash(message[offset : offset+klen]) + if err != nil { + return nil, err + } + offset += klen + + case TokenEE, TokenES, TokenSE, TokenSS: + useStatic := getKeyPattern(token, ns.initiator) + localKey := ns.s + if !useStatic.local { + localKey = ns.e + } + remoteKey := ns.rs + if !useStatic.remote { + remoteKey = ns.re + } + if err := ns.mixKey(remoteKey, localKey); err != nil { + return nil, err + } + + default: + return nil, fmt.Errorf("unexpected token: %d", token) + } + } + + // Decrypt payload + payload, err := ns.decryptAndHash(message[offset:]) + if err != nil { + return nil, err + } + + // Finalize if handshake complete + if len(ns.handshakeQueue) == 0 { + if err := ns.final(); err != nil { + return nil, err + } + } + + return payload, nil +} + +// final completes the handshake and derives transport keys. +func (ns *NoiseState) final() error { + ns.hash = ns.getHandshakeHash() + + keys, err := ns.split() + if err != nil { + return err + } + + if ns.initiator { + ns.tx = keys[0] + ns.rx = keys[1] + } else { + ns.tx = keys[1] + ns.rx = keys[0] + } + + ns.complete = true + + // Clear handshake state + ns.clearHandshake() + + return nil +} + +// clearHandshake clears sensitive handshake data. +func (ns *NoiseState) clearHandshake() { + if ns.e != nil { + for i := range ns.e.SecretKey { + ns.e.SecretKey[i] = 0 + } + for i := range ns.e.PublicKey { + ns.e.PublicKey[i] = 0 + } + ns.e = nil + } + if ns.re != nil { + for i := range ns.re { + ns.re[i] = 0 + } + ns.re = nil + } + // Zero static private key + if ns.s != nil { + for i := range ns.s.SecretKey { + ns.s.SecretKey[i] = 0 + } + } + // Zero PSK + if ns.psk != nil { + for i := range ns.psk { + ns.psk[i] = 0 + } + ns.psk = nil + } +} + +// IsComplete returns true if handshake is complete. +func (ns *NoiseState) IsComplete() bool { + return ns.complete +} + +// GetHash returns the handshake hash (only valid after completion). +func (ns *NoiseState) GetHash() []byte { + if ns.hash != nil { + result := make([]byte, len(ns.hash)) + copy(result, ns.hash) + return result + } + return nil +} + +// GetTX returns the transmit cipher state (only valid after completion). +func (ns *NoiseState) GetTX() *CipherState { + return ns.tx +} + +// GetRX returns the receive cipher state (only valid after completion). +func (ns *NoiseState) GetRX() *CipherState { + return ns.rx +} + +// GetStaticPublicKey returns the local static public key. +func (ns *NoiseState) GetStaticPublicKey() []byte { + if ns.s != nil { + key := make([]byte, len(ns.s.PublicKey)) + copy(key, ns.s.PublicKey) + return key + } + return nil +} + +// GetRemoteStaticPublicKey returns a copy of the remote static public key (rs). +func (ns *NoiseState) GetRemoteStaticPublicKey() []byte { + if ns.rs == nil { + return nil + } + key := make([]byte, len(ns.rs)) + copy(key, ns.rs) + return key +} + +// keyPatternResult holds which keys to use. +type keyPatternResult struct { + local bool + remote bool +} + +// getKeyPattern determines which keys to use based on token and role. +func getKeyPattern(token Token, initiator bool) keyPatternResult { + result := keyPatternResult{} + + switch token { + case TokenEE: + // Both ephemeral + result.local = false + result.remote = false + + case TokenES: + // Initiator: ephemeral local, static remote + // Responder: static local, ephemeral remote + result.local = !initiator + result.remote = initiator + + case TokenSE: + // Initiator: static local, ephemeral remote + // Responder: ephemeral local, static remote + result.local = initiator + result.remote = !initiator + + case TokenSS: + // Both static + result.local = true + result.remote = true + } + + return result +} + +// hasPskToken checks if handshake pattern contains PSK token. +func hasPskToken(handshake [][]Token) bool { + for _, msg := range handshake { + if slices.Contains(msg, TokenPSK) { + return true + } + } + return false +} diff --git a/noise_test.go b/noise_test.go new file mode 100644 index 0000000..a0932ed --- /dev/null +++ b/noise_test.go @@ -0,0 +1,557 @@ +package noisehandshake_test + +import ( + "bytes" + "testing" + + nhs "github.com/tetsuo/noisehandshake" +) + +func TestBasicHandshakeXX(t *testing.T) { + // Create initiator + initiatorConfig := &nhs.Config{} + initiator, err := nhs.NewNoiseState(nhs.PatternXX, true, initiatorConfig) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + // Create responder + responderConfig := &nhs.Config{} + responder, err := nhs.NewNoiseState(nhs.PatternXX, false, responderConfig) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte("MyProtocol") + + // Initialize both sides + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Message 1: initiator -> responder + msg1, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + + payload1, err := responder.Recv(msg1) + if err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + if len(payload1) != 0 { + t.Errorf("Expected empty payload, got %d bytes", len(payload1)) + } + + // Message 2: responder -> initiator + msg2, err := responder.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + + payload2, err := initiator.Recv(msg2) + if err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + if len(payload2) != 0 { + t.Errorf("Expected empty payload, got %d bytes", len(payload2)) + } + + // Message 3: initiator -> responder + msg3, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 3: %v", err) + } + + payload3, err := responder.Recv(msg3) + if err != nil { + t.Fatalf("Failed to receive message 3: %v", err) + } + if len(payload3) != 0 { + t.Errorf("Expected empty payload, got %d bytes", len(payload3)) + } + + // Verify handshake is complete + if !initiator.IsComplete() { + t.Error("Initiator handshake not complete") + } + if !responder.IsComplete() { + t.Error("Responder handshake not complete") + } + + // Verify handshake hashes match and are non-zero + initHash := initiator.GetHash() + respHash := responder.GetHash() + if !bytes.Equal(initHash, respHash) { + t.Error("Handshake hashes do not match") + } + allZero := true + for _, b := range initHash { + if b != 0 { + allZero = false + break + } + } + if allZero { + t.Error("Handshake hash is all zeros") + } +} + +func TestHandshakeWithPayloadXX(t *testing.T) { + // Create initiator and responder + initiator, err := nhs.NewNoiseState(nhs.PatternXX, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + responder, err := nhs.NewNoiseState(nhs.PatternXX, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte("TestProtocol") + + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Message 1 with payload + payload1 := []byte("Hello from initiator") + msg1, err := initiator.Send(payload1) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + + recvPayload1, err := responder.Recv(msg1) + if err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + if !bytes.Equal(payload1, recvPayload1) { + t.Errorf("Payload mismatch: expected %s, got %s", payload1, recvPayload1) + } + + // Message 2 with payload + payload2 := []byte("Hello from responder") + msg2, err := responder.Send(payload2) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + + recvPayload2, err := initiator.Recv(msg2) + if err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + if !bytes.Equal(payload2, recvPayload2) { + t.Errorf("Payload mismatch: expected %s, got %s", payload2, recvPayload2) + } + + // Message 3 + msg3, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 3: %v", err) + } + + _, err = responder.Recv(msg3) + if err != nil { + t.Fatalf("Failed to receive message 3: %v", err) + } + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("Handshake not complete") + } +} + +func TestTransportMessagesXX(t *testing.T) { + // Complete a handshake + initiator, err := nhs.NewNoiseState(nhs.PatternXX, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + responder, err := nhs.NewNoiseState(nhs.PatternXX, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte{} + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Complete handshake + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + // Test transport messages + plaintext := []byte("Secret message") + + // Initiator sends to responder + ciphertext, err := initiator.GetTX().Encrypt(nil, plaintext, nil) + if err != nil { + t.Fatalf("Failed to encrypt: %v", err) + } + + decrypted, err := responder.GetRX().Decrypt(nil, ciphertext, nil) + if err != nil { + t.Fatalf("Failed to decrypt: %v", err) + } + + if !bytes.Equal(plaintext, decrypted) { + t.Errorf("Transport message mismatch: expected %s, got %s", plaintext, decrypted) + } + + // Responder sends to initiator + plaintext2 := []byte("Secret reply") + ciphertext2, err := responder.GetTX().Encrypt(nil, plaintext2, nil) + if err != nil { + t.Fatalf("Failed to encrypt reply: %v", err) + } + + decrypted2, err := initiator.GetRX().Decrypt(nil, ciphertext2, nil) + if err != nil { + t.Fatalf("Failed to decrypt reply: %v", err) + } + + if !bytes.Equal(plaintext2, decrypted2) { + t.Errorf("Transport reply mismatch: expected %s, got %s", plaintext2, decrypted2) + } +} + +func TestNNPattern(t *testing.T) { + initiator, err := nhs.NewNoiseState(nhs.PatternNN, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + responder, err := nhs.NewNoiseState(nhs.PatternNN, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte("NN_Test") + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Message 1 + msg1, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + + _, err = responder.Recv(msg1) + if err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + + // Message 2 + msg2, err := responder.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + + _, err = initiator.Recv(msg2) + if err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("NN handshake not complete") + } +} + +func TestPSKHandshakeXXpsk0(t *testing.T) { + psk := []byte("my-shared-secret-key-32-bytes!!!") + + initiator, err := nhs.NewNoiseState(nhs.PatternXXpsk0, true, &nhs.Config{PSK: psk}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + responder, err := nhs.NewNoiseState(nhs.PatternXXpsk0, false, &nhs.Config{PSK: psk}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte("PSK_Test") + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Complete handshake + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("PSK handshake not complete") + } + + // Verify hashes match and are non-zero + if !bytes.Equal(initiator.GetHash(), responder.GetHash()) { + t.Error("PSK handshake hashes do not match") + } + hash := initiator.GetHash() + allZero := true + for _, b := range hash { + if b != 0 { + allZero = false + break + } + } + if allZero { + t.Error("PSK handshake hash is all zeros") + } +} + +func TestIKPattern(t *testing.T) { + // Responder generates static key in advance + responder, err := nhs.NewNoiseState(nhs.PatternIK, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + responderStaticPub := responder.GetStaticPublicKey() + + // Initiator knows responder's static public key + initiator, err := nhs.NewNoiseState(nhs.PatternIK, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + prologue := []byte("IK_Test") + if err := initiator.Initialize(prologue, responderStaticPub); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // Complete handshake + msg1, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + + _, err = responder.Recv(msg1) + if err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + + msg2, err := responder.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + + _, err = initiator.Recv(msg2) + if err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("IK handshake not complete") + } +} + +func TestXKPattern(t *testing.T) { + // Responder has a known static key; initiator knows it in advance + responder, err := nhs.NewNoiseState(nhs.PatternXK, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + responderStaticPub := responder.GetStaticPublicKey() + + initiator, err := nhs.NewNoiseState(nhs.PatternXK, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + + prologue := []byte("XK_Test") + if err := initiator.Initialize(prologue, responderStaticPub); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + // 3-message XK handshake + msg1, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + if _, err = responder.Recv(msg1); err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + + msg2, err := responder.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + if _, err = initiator.Recv(msg2); err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + + msg3, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 3: %v", err) + } + if _, err = responder.Recv(msg3); err != nil { + t.Fatalf("Failed to receive message 3: %v", err) + } + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("XK handshake not complete") + } + + // Both sides should arrive at the same hash + if !bytes.Equal(initiator.GetHash(), responder.GetHash()) { + t.Error("XK handshake hashes do not match") + } + + // Transport: initiator -> responder and back + plain := []byte("XK transport test") + ct, err := initiator.GetTX().Encrypt(nil, plain, nil) + if err != nil { + t.Fatalf("Failed to encrypt: %v", err) + } + got, err := responder.GetRX().Decrypt(nil, ct, nil) + if err != nil { + t.Fatalf("Failed to decrypt: %v", err) + } + if !bytes.Equal(plain, got) { + t.Errorf("XK transport mismatch: got %s", got) + } +} + +func TestNNpsk0Pattern(t *testing.T) { + psk := []byte("nNpsk0-shared-secret-32-bytes!!!") + + initiator, err := nhs.NewNoiseState(nhs.PatternNNpsk0, true, &nhs.Config{PSK: psk}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + responder, err := nhs.NewNoiseState(nhs.PatternNNpsk0, false, &nhs.Config{PSK: psk}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + prologue := []byte("NNpsk0_Test") + if err := initiator.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize initiator: %v", err) + } + if err := responder.Initialize(prologue, nil); err != nil { + t.Fatalf("Failed to initialize responder: %v", err) + } + + msg1, err := initiator.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 1: %v", err) + } + if _, err = responder.Recv(msg1); err != nil { + t.Fatalf("Failed to receive message 1: %v", err) + } + + msg2, err := responder.Send(nil) + if err != nil { + t.Fatalf("Failed to send message 2: %v", err) + } + if _, err = initiator.Recv(msg2); err != nil { + t.Fatalf("Failed to receive message 2: %v", err) + } + + if !initiator.IsComplete() || !responder.IsComplete() { + t.Error("NNpsk0 handshake not complete") + } + if !bytes.Equal(initiator.GetHash(), responder.GetHash()) { + t.Error("NNpsk0 handshake hashes do not match") + } +} + +func TestGetRemoteStaticPublicKey(t *testing.T) { + // After an XX handshake, each side should know the other's static public key + initiator, err := nhs.NewNoiseState(nhs.PatternXX, true, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create initiator: %v", err) + } + responder, err := nhs.NewNoiseState(nhs.PatternXX, false, &nhs.Config{}) + if err != nil { + t.Fatalf("Failed to create responder: %v", err) + } + + initStaticPub := initiator.GetStaticPublicKey() + respStaticPub := responder.GetStaticPublicKey() + + prologue := []byte("remote-static-test") + initiator.Initialize(prologue, nil) + responder.Initialize(prologue, nil) + + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + msg3, _ := initiator.Send(nil) + responder.Recv(msg3) + + // Initiator should have learned responder's static key + if !bytes.Equal(initiator.GetRemoteStaticPublicKey(), respStaticPub) { + t.Error("Initiator has wrong remote static public key") + } + // Responder should have learned initiator's static key + if !bytes.Equal(responder.GetRemoteStaticPublicKey(), initStaticPub) { + t.Error("Responder has wrong remote static public key") + } +} + +func TestSendAfterComplete(t *testing.T) { + initiator, _ := nhs.NewNoiseState(nhs.PatternNN, true, &nhs.Config{}) + responder, _ := nhs.NewNoiseState(nhs.PatternNN, false, &nhs.Config{}) + initiator.Initialize(nil, nil) + responder.Initialize(nil, nil) + + msg1, _ := initiator.Send(nil) + responder.Recv(msg1) + msg2, _ := responder.Send(nil) + initiator.Recv(msg2) + + // Both complete; further Send/Recv must return an error + if _, err := initiator.Send(nil); err == nil { + t.Error("Expected error sending after handshake complete") + } + if _, err := responder.Recv([]byte("junk")); err == nil { + t.Error("Expected error receiving after handshake complete") + } +} + +func TestPSKInvalidLength(t *testing.T) { + _, err := nhs.NewNoiseState(nhs.PatternXXpsk0, true, &nhs.Config{PSK: []byte("short")}) + if err == nil { + t.Error("Expected error for PSK shorter than 32 bytes") + } + + longPSK := make([]byte, 33) + _, err = nhs.NewNoiseState(nhs.PatternXXpsk0, true, &nhs.Config{PSK: longPSK}) + if err == nil { + t.Error("Expected error for PSK longer than 32 bytes") + } +} diff --git a/symmetric_state.go b/symmetric_state.go new file mode 100644 index 0000000..4ecbfa7 --- /dev/null +++ b/symmetric_state.go @@ -0,0 +1,144 @@ +package noisehandshake + +// symmetricState extends CipherState with hashing and key derivation. +type symmetricState struct { + cs CipherState + curve *Curve + digest []byte + chainingKey []byte +} + +// newSymmetricState creates a new symmetric state. +func newSymmetricState(curve *Curve) *symmetricState { + if curve == nil { + curve = DefaultCurve + } + return &symmetricState{ + curve: curve, + digest: make([]byte, hashLen), + chainingKey: make([]byte, hashLen), + } +} + +// initializeSymmetric initializes the symmetric state with protocol name. +func (ss *symmetricState) initializeSymmetric(protocolName []byte) { + if len(protocolName) <= hashLen { + copy(ss.chainingKey, protocolName) + copy(ss.digest, protocolName) + for i := len(protocolName); i < hashLen; i++ { + ss.chainingKey[i] = 0 + ss.digest[i] = 0 + } + } else { + h := newBLAKE2b512() + h.Write(protocolName) + hashed := h.Sum(nil) + copy(ss.chainingKey, hashed) + copy(ss.digest, hashed) + } +} + +// mixHash mixes data into the digest. +func (ss *symmetricState) mixHash(data []byte) { + h := newBLAKE2b512() + h.Write(ss.digest) + h.Write(data) + ss.digest = h.Sum(ss.digest[:0]) +} + +// mixKeyAndHash mixes a key into both the chaining key and digest. +func (ss *symmetricState) mixKeyAndHash(key []byte) { + outputs := hkdf(ss.chainingKey, key, nil, 3) + + ss.chainingKey = outputs[0] + ss.mixHash(outputs[1]) + ss.cs.initializeKey(outputs[2][:32]) +} + +// mixKeyNormal mixes a key into the chaining key. +func (ss *symmetricState) mixKeyNormal(key []byte) { + outputs := hkdf(ss.chainingKey, key, nil, 2) + + ss.chainingKey = outputs[0] + ss.cs.initializeKey(outputs[1][:32]) +} + +// mixKey performs DH and mixes the result into the chaining key. +func (ss *symmetricState) mixKey(remoteKey []byte, localKey *KeyPair) error { + dh, err := ss.curve.DH(remoteKey, localKey) + if err != nil { + return err + } + + outputs := hkdf(ss.chainingKey, dh, nil, 2) + + ss.chainingKey = outputs[0] + ss.cs.initializeKey(outputs[1][:32]) + return nil +} + +// encryptAndHash encrypts plaintext and mixes ciphertext into digest. +func (ss *symmetricState) encryptAndHash(plaintext []byte) ([]byte, error) { + ciphertext, err := ss.cs.Encrypt(nil, plaintext, ss.digest) + if err != nil { + return nil, err + } + ss.mixHash(ciphertext) + return ciphertext, nil +} + +// decryptAndHash decrypts ciphertext and mixes it into digest. +func (ss *symmetricState) decryptAndHash(ciphertext []byte) ([]byte, error) { + plaintext, err := ss.cs.Decrypt(nil, ciphertext, ss.digest) + if err != nil { + return nil, err + } + ss.mixHash(ciphertext) + return plaintext, nil +} + +// getHandshakeHash returns the current handshake hash. +func (ss *symmetricState) getHandshakeHash() []byte { + hash := make([]byte, hashLen) + copy(hash, ss.digest) + return hash +} + +// split derives two cipher states from the current state. +// Clears the symmetric state for forward secrecy. +func (ss *symmetricState) split() ([]*CipherState, error) { + outputs := hkdf(ss.chainingKey, []byte{}, nil, 2) + + k1, err := newCipherState(outputs[0][:32]) + if err != nil { + return nil, err + } + k2, err := newCipherState(outputs[1][:32]) + if err != nil { + return nil, err + } + + ss.clear() + + return []*CipherState{k1, k2}, nil +} + +// clear clears sensitive data. +func (ss *symmetricState) clear() { + ss.cs.Clear() + + if ss.digest != nil { + for i := range ss.digest { + ss.digest[i] = 0 + } + } + if ss.chainingKey != nil { + for i := range ss.chainingKey { + ss.chainingKey[i] = 0 + } + } + + ss.digest = nil + ss.chainingKey = nil + ss.curve = nil +} |
