AtlatestRepositorysigil-noise

sigil-noise / tree / testtest-noise.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil math)
4 (sigil noise)
5 (sigil noise internal))
6
7(define (hex text)
8 (let* ((n (quotient (string-length text) 2))
9 (out (make-bytevector n)))
10 (do ((i 0 (+ i 1))) ((= i n) out)
11 (bytevector-u8-set! out i
12 (string->number (substring text (* i 2) (+ (* i 2) 2)) 16)))))
14;; Noise-C basic vectors, Noise_XX_25519_ChaChaPoly_SHA256.
15;; https://github.com/rweather/noise-c/blob/master/tests/vector/noise-c-basic.txt
16;; See THIRD-PARTY-NOTICES for the vector license.
17(define init-static (hex "e61ef9919cde45dd5f82166404bd08e38bceb5dfdfded0a34c8df7ed542214d1"))
18(define init-ephemeral (hex "893e28b9dc6ca8d611ab664754b8ceb7bac5117349a4439a6b0569da977c464a"))
19(define resp-static (hex "4a3acbfdb163dec651dfa3194dece676d437029c62a408b4c5ea9114246e4893"))
20(define resp-ephemeral (hex "bbdb4cdbd309f1a1f2e1456967fe288cadd6f712d65dc7b7793d5e63da6b375b"))
21(define init-prologue (hex "50726f6c6f677565313233"))
22(define handshake-hash (hex "852a28d2146785c54bd8334f4e460c80d7fe4fd0cc5bc0abef2a24a3c4d44d5f"))
23(define payloads
24 (list
25 (hex "4c756477696720766f6e204d69736573")
26 (hex "4d757272617920526f746862617264")
27 (hex "462e20412e20486179656b")
28 (hex "4361726c204d656e676572")
29 (hex "4a65616e2d426170746973746520536179")
30 (hex "457567656e2042f6686d20766f6e2042617765726b")))
31(define messages
32 (list
33 (hex "ca35def5ae56cec33dc2036731ab14896bc4c75dbb07a61f879f8e3afa4c79444c756477696720766f6e204d69736573")
34 (hex "95ebc60d2b1fa672c1f46a8aa265ef51bfe38e7ccb39ec5be34069f14480884381cbad1f276e038c48378ffce2b65285e08d6b68aaa3629a5a8639392490e5b94a6d8798832d5372f220f161d9c2df035528f8982ffe09be9b5c412f8a0db5d21351f20af1370d0bf8ef1a8c59a30e")
35 (hex "c7195ffacac1307ff99046f219750fc47693e23c3cb08b89c2af808b444850a8589981dfbd651e6ff4724a781cc2aa6158c9fea0d4ec82a286427484c5b8c8123a7a6002b1de9f9775fc97")
36 (hex "96763ed773f8e47bb3712f0e29b3060ffc956ffc146cee53d5e1df")
37 (hex "3e40f15f6f3a46ae446b253bf8b1d9ffb6ed9b174d272328ff91a7e2e5c79c07f5")
38 (hex "eb3f3515110702e047a6c9da4478b6ead94873c11c0f2d710ddb3f09fce024b3a58502ae3f")))
40(define (new-initiator)
41 (make-noise-handshake/internal #t init-static init-prologue init-ephemeral))
42(define (new-responder)
43 (make-noise-handshake/internal #f resp-static init-prologue resp-ephemeral))
44(define (exchange! i r)
45 (noise-read-message! r (noise-write-message! i #u8()))
46 (noise-read-message! i (noise-write-message! r #u8()))
47 (noise-read-message! r (noise-write-message! i #u8())))
48(define (transports)
49 (let ((i (new-initiator)) (r (new-responder)))
50 (exchange! i r)
51 (cons (noise-split! i) (noise-split! r))))
53(test "Noise-C XX handshake, transcript hash, and transport vectors"
54 (let ((i (new-initiator)) (r (new-responder)))
55 (let loop ((n 0) (ps payloads) (ms messages))
56 (when (< n 3)
57 (let ((sender (if (even? n) i r))
58 (receiver (if (even? n) r i)))
59 (assert-equal (car ms) (noise-write-message! sender (car ps)))
60 (assert-equal (car ps) (noise-read-message! receiver (car ms))))
61 (loop (+ n 1) (cdr ps) (cdr ms))))
62 (assert-true (noise-handshake-complete? i))
63 (assert-true (noise-handshake-complete? r))
64 (assert-equal handshake-hash (noise-handshake-hash i))
65 (assert-equal handshake-hash (noise-handshake-hash r))
66 (assert-equal (x25519-public-key resp-static) (noise-peer-static-key i))
67 (assert-equal (x25519-public-key init-static) (noise-peer-static-key r))
68 (let ((it (noise-split! i)) (rt (noise-split! r)))
69 (let loop ((n 3) (ps (cdddr payloads)) (ms (cdddr messages)))
70 (unless (null? ps)
71 (let ((sender (if (even? n) it rt))
72 (receiver (if (even? n) rt it)))
73 (assert-equal (car ms) (noise-encrypt! sender (car ps)))
74 (assert-equal (car ps) (noise-decrypt! receiver (car ms))))
75 (loop (+ n 1) (cdr ps) (cdr ms)))))))
77(test "public constructor produces fresh ephemeral keys and interoperates"
78 (let ((i (make-noise-handshake 'initiator init-static #u8()))
79 (r (make-noise-handshake 'responder resp-static #u8()))
80 (other (make-noise-handshake 'initiator init-static #u8())))
81 (let ((first (noise-write-message! i #u8())))
82 (assert-false (equal? first (noise-write-message! other #u8())))
83 (noise-read-message! r first))
84 (noise-read-message! i (noise-write-message! r #u8()))
85 (noise-read-message! r (noise-write-message! i #u8()))
86 (assert-equal (noise-handshake-hash i) (noise-handshake-hash r))
87 (noise-close! other)))
89(test "invalid constructors reject role and key lengths"
90 (assert-error (make-noise-handshake 'other init-static #u8()))
91 (assert-error (make-noise-handshake 'initiator (make-bytevector 31) #u8()))
92 (assert-error (make-noise-handshake 'initiator init-static "prologue")))
94(test "caller-owned static keys remain unchanged"
95 (let ((before (bytevector-copy init-static))
96 (i (new-initiator)))
97 (noise-close! i)
98 (assert-equal before init-static)))
100(test "wrong handshake direction closes the session"
101 (let ((i (new-initiator)) (r (new-responder)))
102 (assert-error (noise-read-message! i (car messages)))
103 (assert-error (noise-write-message! r #u8()))
104 (assert-error (noise-write-message! i #u8()))
105 (assert-false (noise-handshake-complete? i))))
107(test "metadata and transport are unavailable before completion"
108 (assert-error (noise-peer-static-key (new-initiator)))
109 (assert-error (noise-handshake-hash (new-initiator)))
110 (assert-error (noise-split! (new-initiator))))
112(test "split is one-shot and completed handshakes cannot be restarted"
113 (let ((i (new-initiator)) (r (new-responder)))
114 (exchange! i r)
115 (noise-split! i)
116 (assert-error (noise-split! i))
117 (assert-error (noise-write-message! r #u8()))))
119(test "handshake metadata is copied before returning"
120 (let ((i (new-initiator)) (r (new-responder)))
121 (exchange! i r)
122 (let ((hash (noise-handshake-hash i))
123 (peer (noise-peer-static-key i)))
124 (bytevector-u8-set! hash 0 0)
125 (bytevector-u8-set! peer 0 0)
126 (assert-equal (noise-handshake-hash r) (noise-handshake-hash i))
127 (assert-equal (x25519-public-key resp-static) (noise-peer-static-key i)))))
129(test "prologue mismatch fails authentication and closes the handshake"
130 (let ((i (new-initiator))
131 (r (make-noise-handshake/internal #f resp-static #u8() resp-ephemeral)))
132 (noise-read-message! r (noise-write-message! i #u8()))
133 (assert-error (noise-read-message! i (noise-write-message! r #u8())))
134 (assert-error (noise-write-message! i #u8()))))
136(test "tampered handshake keys and payloads fail closed"
137 (for-each
138 (lambda (index)
139 (let ((i (new-initiator)) (r (new-responder)))
140 (noise-read-message! r (noise-write-message! i #u8()))
141 (let ((message (noise-write-message! r #u8(42))))
142 (bytevector-u8-set! message index
143 (modulo (+ 1 (bytevector-u8-ref message index)) 256))
144 (assert-error (noise-read-message! i message))
145 (assert-error (noise-split! i)))))
146 '(0 32 79 80 96)))
148(test "low-order ephemeral key aborts before any encrypted response"
149 (let ((r (new-responder)))
150 (noise-read-message! r (make-bytevector 32 0))
151 (assert-error (noise-write-message! r #u8()))
152 (assert-error (noise-write-message! r #u8()))))
154(test "truncated handshake messages are rejected at every step"
155 (assert-error (noise-read-message! (new-responder) (make-bytevector 31)))
156 (let ((i (new-initiator)) (r (new-responder)))
157 (noise-read-message! r (noise-write-message! i #u8()))
158 (assert-error (noise-read-message! i (make-bytevector 95))))
159 (let ((i (new-initiator)) (r (new-responder)))
160 (noise-read-message! r (noise-write-message! i #u8()))
161 (noise-read-message! i (noise-write-message! r #u8()))
162 (assert-error (noise-read-message! r (make-bytevector 63)))))
164(test "maximum handshake messages work in all three flights"
165 (let ((i (new-initiator)) (r (new-responder)))
166 (for-each
167 (lambda (n)
168 (let* ((sender (if (= n 65439) r i))
169 (receiver (if (= n 65439) i r))
170 (payload (make-bytevector n 42))
171 (message (noise-write-message! sender payload)))
172 (assert-equal 65535 (bytevector-length message))
173 (assert-equal payload (noise-read-message! receiver message))))
174 '(65503 65439 65471))))
176(test "oversized handshake messages fail closed"
177 (assert-error (noise-write-message! (new-initiator) (make-bytevector 65504)))
178 (assert-error (noise-read-message! (new-responder) (make-bytevector 65536))))
180(test "bidirectional transports have independent nonce sequences"
181 (let* ((pair (transports)) (i (car pair)) (r (cdr pair)))
182 (do ((n 0 (+ n 1))) ((= n 260))
183 (assert-equal #u8(1 2 3) (noise-decrypt! r (noise-encrypt! i #u8(1 2 3)))))
184 (assert-equal #u8(4 5) (noise-decrypt! i (noise-encrypt! r #u8(4 5))))))
186(test "transport supports empty and maximum-size messages"
187 (let* ((pair (transports)) (i (car pair)) (r (cdr pair)))
188 (assert-equal #u8() (noise-decrypt! r (noise-encrypt! i #u8())))
189 (let ((payload (make-bytevector 65519 42)))
190 (assert-equal payload (noise-decrypt! r (noise-encrypt! i payload))))))
192(test "oversized or truncated transport records close both directions"
193 (let* ((pair (transports)) (r (cdr pair)))
194 (assert-error (noise-decrypt! r (make-bytevector 15)))
195 (assert-error (noise-encrypt! r #u8())))
196 (let* ((pair (transports)) (i (car pair)))
197 (assert-error (noise-encrypt! i (make-bytevector 65520)))
198 (assert-error (noise-decrypt! i (make-bytevector 16)))))
200(test "replayed records are rejected and close both directions"
201 (let* ((pair (transports)) (i (car pair)) (r (cdr pair))
202 (message (noise-encrypt! i #u8(1))))
203 (assert-equal #u8(1) (noise-decrypt! r message))
204 (assert-error (noise-decrypt! r message))
205 (assert-error (noise-encrypt! r #u8()))))
207(test "out-of-order records fail authentication"
208 (let* ((pair (transports)) (i (car pair)) (r (cdr pair)))
209 (noise-encrypt! i #u8(1))
210 (assert-error (noise-decrypt! r (noise-encrypt! i #u8(2))))))
212(test "closing sessions is idempotent and disables further use"
213 (let* ((pair (transports)) (i (car pair)))
214 (noise-close! i)
215 (noise-close! i)
216 (assert-error (noise-encrypt! i #u8())))
217 (let ((i (new-initiator)))
218 (noise-close! i)
219 (noise-close! i)
220 (assert-error (noise-write-message! i #u8()))))
222(test "reserved 64-bit nonce is never used"
223 (let* ((nonce (hex "00000000feffffffffffffff"))
224 (cipher (make-noise-cipher/internal (make-bytevector 32 7) nonce)))
225 (assert-equal 16 (bytevector-length (cipher 'encrypt #u8() #u8())))
226 (assert-error (cipher 'encrypt #u8() #u8()))))
228(test "cipher authentication failure does not advance the nonce"
229 (let* ((key (make-bytevector 32 7))
230 (nonce (make-bytevector 12 0))
231 (cipher (make-noise-cipher/internal key nonce))
232 (valid (chacha20-poly1305-encrypt key nonce #u8() #u8(42))))
233 (assert-error (cipher 'decrypt #u8() (make-bytevector 16 0)))
234 (assert-equal #u8(42) (cipher 'decrypt #u8() valid))))
236;; Expected tags generated independently with Node's OpenSSL-backed AEAD.
237(test "last permitted nonce matches independent AEAD output"
238 (let ((cipher (make-noise-cipher/internal (make-bytevector 32 7)
239 (hex "00000000feffffffffffffff"))))
240 (assert-equal (hex "a2e54bf973e09c248d95674e10650387") (cipher 'encrypt #u8() #u8()))))
242;; Expected tags generated independently with Node's OpenSSL-backed AEAD.
243(test "counter carry nonce matches independent AEAD output"
244 (let ((cipher (make-noise-cipher/internal (make-bytevector 32 7)
245 (hex "00000000ff00000000000000"))))
246 (assert-equal (hex "c60b502347bfb05aa442d685267252bf") (cipher 'encrypt #u8() #u8()))
247 (assert-equal (hex "05a7038f2016bfddd97166c7f0416492") (cipher 'encrypt #u8() #u8()))))
249(test "tampered third-flight static key and payload fail closed"
250 (for-each
251 (lambda (index)
252 (let ((i (new-initiator)) (r (new-responder)))
253 (noise-read-message! r (noise-write-message! i #u8()))
254 (noise-read-message! i (noise-write-message! r #u8()))
255 (let ((message (noise-write-message! i #u8(42))))
256 (bytevector-u8-set! message index
257 (modulo (+ 1 (bytevector-u8-ref message index)) 256))
258 (assert-error (noise-read-message! r message))
259 (assert-false (noise-handshake-complete? r))
260 (assert-error (noise-split! r)))))
261 '(0 31 32 47 48 64)))
263(test "second and third outbound flights enforce their payload limits"
264 (let ((i (new-initiator)) (r (new-responder)))
265 (noise-read-message! r (noise-write-message! i #u8()))
266 (assert-error (noise-write-message! r (make-bytevector 65440))))
267 (let ((i (new-initiator)) (r (new-responder)))
268 (noise-read-message! r (noise-write-message! i #u8()))
269 (noise-read-message! i (noise-write-message! r #u8()))
270 (assert-error (noise-write-message! i (make-bytevector 65472)))))
272(test "changed transport ciphertext and tag close both directions"
273 (for-each
274 (lambda (index)
275 (let* ((pair (transports)) (i (car pair)) (r (cdr pair))
276 (message (noise-encrypt! i #u8(42))))
277 (bytevector-u8-set! message index
278 (modulo (+ 1 (bytevector-u8-ref message index)) 256))
279 (assert-error (noise-decrypt! r message))
280 (assert-error (noise-encrypt! r #u8()))))
281 '(0 1 16)))