1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
# noise
[Noise Protocol Framework](https://noiseprotocol.org/) implementation in Go.
**Supported handshake 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
## Install
```sh
go get git.onurgunduz.com/noise@latest
```
## Usage
### Basic XX handshake
```go
package main
import (
"fmt"
"log"
"git.onurgunduz.com/noise"
)
func main() {
// Create initiator and responder
initiator, err := noise.NewNoiseState(
noise.PatternXX,
true, // initiator role
&noise.Config{},
)
if err != nil {
log.Fatal(err)
}
responder, err := noise.NewNoiseState(
noise.PatternXX,
false, // responder role
&noise.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!")
// Handshake hash (can be used for channel binding)
hash := initiator.Hash()
fmt.Printf("Handshake hash: %x\n", hash)
// Transport cipher states
txInit := initiator.Tx()
rxInit := initiator.Rx()
txResp := responder.Tx()
rxResp := responder.Rx()
// 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, _ := noise.NewNoiseState(
noise.PatternXXpsk0,
true,
&noise.Config{PSK: psk},
)
responder, _ := noise.NewNoiseState(
noise.PatternXXpsk0,
false,
&noise.Config{PSK: psk},
)
```
### IK pattern (pre-known responder key)
```go
// Responder's static public key is known in advance
responderStaticKey := getResponderPublicKey()
initiator, _ := noise.NewNoiseState(
noise.PatternIK,
true,
&noise.Config{},
)
// Initialize with remote static key
initiator.Initialize(prologue, responderStaticKey)
```
### Using custom static keys
```go
// Generate or load static keypair
curve := noise.DefaultCurve
staticKeypair, _ := curve.GenerateKeyPair(nil)
// Or use a seed for deterministic keys
seed := make([]byte, 32)
// ... fill seed ...
staticKeypair, _ = curve.GenerateKeyPair(seed)
initiator, _ := noise.NewNoiseState(
noise.PatternXX,
true,
&noise.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)
|