aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorOnur Gündüz <ogunduz@gmail.com>2026-03-10 11:58:37 +0100
committerOnur Gündüz <ogunduz@gmail.com>2026-03-10 11:58:37 +0100
commit03b95111f19a93ccee00e8e8e0afaab8112f5484 (patch)
treec0bfd7c5c768b441c901645a5a9a83c533eaf56f
parentbcb40853f819cdbea99ec5d0ab2ee7594efd7690 (diff)
downloadnoise-03b95111f19a93ccee00e8e8e0afaab8112f5484.tar.gz
noise-03b95111f19a93ccee00e8e8e0afaab8112f5484.zip
Init package
-rw-r--r--README.md149
-rw-r--r--cipher.go123
-rw-r--r--dh.go87
-rw-r--r--example_test.go173
-rw-r--r--go.mod7
-rw-r--r--go.sum4
-rw-r--r--hkdf.go51
-rw-r--r--noise.go544
-rw-r--r--noise_test.go557
-rw-r--r--symmetric_state.go144
10 files changed, 1839 insertions, 0 deletions
diff --git a/README.md b/README.md
index b067a2b..e9775f1 100644
--- a/README.md
+++ b/README.md
@@ -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
+}
diff --git a/dh.go b/dh.go
new file mode 100644
index 0000000..b2180b8
--- /dev/null
+++ b/dh.go
@@ -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
+}
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..331580d
--- /dev/null
+++ b/go.mod
@@ -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
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..f13e109
--- /dev/null
+++ b/go.sum
@@ -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=
diff --git a/hkdf.go b/hkdf.go
new file mode 100644
index 0000000..264821f
--- /dev/null
+++ b/hkdf.go
@@ -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
+}