AtlatestRepositorysigil-quic

sigil-quic / tree / scriptshandshake-cleanup-tests.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil quic bytes)
4 (sigil quic tls)
5 (sigil quic tls codec)
6 (sigil quic tests handshake spy))
7
8;; Explicit remote instrumented suite. Assertions precede fixture cleanup;
9;; captured entries contain the actual buffer and its nonzero-at-return flag.
10(define (handshake-cleanup-wipe! bytes)
11 (when (bytevector? bytes)
12 (do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
13 (bytevector-u8-set! bytes i 0))))
15(define (handshake-cleanup-zero? bytes)
16 (let loop ((i 0))
17 (or (= i (bytevector-length bytes))
18 (and (= (bytevector-u8-ref bytes i) 0) (loop (+ i 1))))))
20(define (handshake-cleanup-with-pair procedure defer?)
21 (let ((key (ecdsa-p256-generate-keypair)) (client #f) (server #f) (pair #f))
22 (dynamic-wind
23 handshake-spy-reset!
24 (lambda ()
25 (set! client
26 (make-tls-client (list #u8(113 49)) 'pinned-key (list (cons 15 #u8(1)))
27 (make-tls-pin-verifier (cdr key)) defer-key-share?: defer?))
28 (set! server
29 (make-tls-server (list #u8(113 49))
30 (list (cons 0 #u8(9)) (cons 15 #u8(2))) (list #u8(48 1 0)) (car key)))
31 (set! pair (vector client server '() '() '()))
32 (tls-bind-peer! client #u8(9) #u8(2) #f)
33 (tls-bind-peer! server #u8(9) #u8(1) #f)
34 (procedure pair))
35 (lambda ()
36 (when client (tls-abort! client))
37 (when server (tls-abort! server))
38 (when pair
39 (for-each
40 (lambda (event)
41 (when (eq? (tls-event-kind event) 'secrets)
42 (handshake-cleanup-wipe! (car (tls-event-data event)))
43 (handshake-cleanup-wipe! (cdr (tls-event-data event)))))
44 (append (vector-ref pair 2) (vector-ref pair 3)))
45 (for-each
46 (lambda (entry) (handshake-cleanup-wipe! (vector-ref entry 1)))
47 (vector-ref pair 4)))
48 (for-each
49 (lambda (entry) (handshake-cleanup-wipe! (vector-ref entry 1)))
50 (append (handshake-spy-inputs) (handshake-spy-shares)))
51 (handshake-spy-reset!)
52 (handshake-cleanup-wipe! (car key))))))
54(define (handshake-cleanup-take! pair side)
55 (let ((events (tls-take-events! (vector-ref pair side))))
56 (vector-set! pair (+ side 2) (append (vector-ref pair (+ side 2)) events))
57 events))
59(define (handshake-cleanup-feed! target event fragment?)
60 (when (eq? (tls-event-kind event) 'crypto)
61 (let ((wire (tls-event-data event)) (level (tls-event-level event)))
62 (if fragment?
63 (do ((i 0 (+ i 1))) ((= i (bytevector-length wire)))
64 (tls-input! target level (bytevector-copy wire i (+ i 1))))
65 (tls-input! target level wire)))))
67(define (handshake-cleanup-deliver! pair side fragment?)
68 (for-each
69 (lambda (event)
70 (handshake-cleanup-feed! (vector-ref pair (- 1 side)) event fragment?))
71 (handshake-cleanup-take! pair side)))
73(define (handshake-cleanup-type event)
74 (and (eq? (tls-event-kind event) 'crypto)
75 (car (decode-handshake (tls-event-data event)))))
77(define (handshake-cleanup-reset! pair)
78 (vector-set! pair 4 (append (handshake-spy-inputs) (vector-ref pair 4)))
79 (handshake-spy-reset!))
81(define (handshake-cleanup-entries expected)
82 (let ((entries (reverse (handshake-spy-inputs))))
83 (assert-equal expected (map (lambda (entry) (vector-ref entry 0)) entries))
84 (for-each
85 (lambda (entry)
86 (assert-true (vector-ref entry 2))
87 (assert-equal 32 (bytevector-length (vector-ref entry 1)))) entries)
88 entries))
90(define (handshake-cleanup-all-zero? entries)
91 (let loop ((remaining entries))
92 (or (null? remaining)
93 (and (handshake-cleanup-zero? (vector-ref (car remaining) 1))
94 (loop (cdr remaining))))))
96(define (handshake-cleanup-failure! side stage)
97 (handshake-cleanup-with-pair
98 (lambda (pair)
99 (tls-start! (vector-ref pair 0))
100 (let ((input
101 (if (= side 1)
102 (car (filter
103 (lambda (event) (eqv? (handshake-cleanup-type event) 1))
104 (handshake-cleanup-take! pair 0)))
105 (begin
106 (handshake-cleanup-deliver! pair 0 #f)
107 (car (filter
108 (lambda (event) (eqv? (handshake-cleanup-type event) 2))
109 (handshake-cleanup-take! pair 1)))))))
110 (handshake-cleanup-reset! pair)
111 (handshake-spy-fail! stage)
112 (let* ((engine (vector-ref pair side))
113 (failure
114 (guard (exception (else exception))
115 (handshake-cleanup-feed! engine input #f)
116 #f))
117 (expected
118 (case stage
119 ((early) '(private shared))
120 ((handshake) '(private shared early))
121 ((transcript client-traffic) '(private shared early handshake))
122 ((server-traffic) '(private shared early handshake client-traffic))
123 ((master) '(private shared early handshake client-traffic server-traffic)))))
124 (assert-true (error-object? failure))
125 (assert-equal "QL7 injected handshake failure" (error-object-message failure))
126 (assert-equal (list stage) (error-object-irritants failure))
127 (assert-true (tls-failed? engine))
128 (assert-false (tls-complete? engine))
129 (assert-false (tls-peer-parameters engine))
130 (assert-equal 0 (tls-retained-input-bytes engine))
131 (assert-equal '() (tls-take-events! engine))
132 (assert-true (handshake-cleanup-all-zero?
133 (handshake-cleanup-entries expected)))))) #f))
135(define (handshake-cleanup-normal! defer? fragment?)
136 (handshake-cleanup-with-pair
137 (lambda (pair)
138 (tls-start! (vector-ref pair 0))
139 (handshake-cleanup-deliver! pair 0 fragment?)
140 (when defer?
141 (assert-equal 'client-hello (tls-state (vector-ref pair 1)))
142 (handshake-cleanup-deliver! pair 1 fragment?)
143 (handshake-cleanup-deliver! pair 0 fragment?))
144 (assert-equal 'client-finished (tls-state (vector-ref pair 1)))
145 (let ((server-entries (handshake-cleanup-entries
146 '(private shared early handshake client-traffic server-traffic master)))
147 (flight (handshake-cleanup-take! pair 1)))
148 ;; Only the client's read secret is still needed by this server.
149 (for-each
150 (lambda (entry)
151 (if (eq? (vector-ref entry 0) 'client-traffic)
152 (assert-false (handshake-cleanup-zero? (vector-ref entry 1)))
153 (assert-true (handshake-cleanup-zero? (vector-ref entry 1))))) server-entries)
154 (handshake-cleanup-reset! pair)
155 (for-each
156 (lambda (event)
157 (when (eqv? (handshake-cleanup-type event) 2)
158 (handshake-cleanup-feed! (vector-ref pair 0) event fragment?))) flight)
159 (assert-equal 'encrypted-extensions (tls-state (vector-ref pair 0)))
160 (let ((client-entries (handshake-cleanup-entries
161 '(private shared early handshake client-traffic server-traffic master))))
162 (for-each
163 (lambda (entry)
164 (if (memq (vector-ref entry 0) '(client-traffic server-traffic master))
165 (assert-false (handshake-cleanup-zero? (vector-ref entry 1)))
166 (assert-true (handshake-cleanup-zero? (vector-ref entry 1))))) client-entries)
167 (for-each
168 (lambda (event)
169 (unless (eqv? (handshake-cleanup-type event) 2)
170 (handshake-cleanup-feed! (vector-ref pair 0) event fragment?))) flight)
171 (handshake-cleanup-deliver! pair 0 fragment?)
172 (assert-true (tls-complete? (vector-ref pair 0)))
173 (assert-true (tls-complete? (vector-ref pair 1)))
174 (assert-equal #u8(113 49) (tls-negotiated-alpn (vector-ref pair 0)))
175 (assert-equal #u8(1) (cdr (assoc 15 (tls-peer-parameters (vector-ref pair 1)))))
176 (assert-true (handshake-cleanup-all-zero? server-entries))
177 (assert-true (handshake-cleanup-all-zero? client-entries))
178 (let ((events (filter
179 (lambda (event)
180 (and (eq? (tls-event-kind event) 'secrets)
181 (eq? (tls-event-level event) 'handshake)))
182 (append (vector-ref pair 2) (vector-ref pair 3)))))
183 (assert-equal 2 (length events))
184 (for-each
185 (lambda (event)
186 (assert-false (handshake-cleanup-zero? (car (tls-event-data event))))
187 (assert-false (handshake-cleanup-zero? (cdr (tls-event-data event))))) events))))) defer?))
189(test-group "Owned TLS handshake intermediates on exception"
190 (test "ql7-handshake: server early failure clears owned intermediates"
191 (handshake-cleanup-failure! 1 'early))
192 (test "ql7-handshake: server handshake failure clears owned intermediates"
193 (handshake-cleanup-failure! 1 'handshake))
194 (test "ql7-handshake: server transcript failure clears owned intermediates"
195 (handshake-cleanup-failure! 1 'transcript))
196 (test "ql7-handshake: server client-traffic failure clears owned intermediates"
197 (handshake-cleanup-failure! 1 'client-traffic))
198 (test "ql7-handshake: server server-traffic failure clears owned intermediates"
199 (handshake-cleanup-failure! 1 'server-traffic))
200 (test "ql7-handshake: server master failure clears owned intermediates"
201 (handshake-cleanup-failure! 1 'master))
202 (test "ql7-handshake: client early failure clears owned intermediates"
203 (handshake-cleanup-failure! 0 'early))
204 (test "ql7-handshake: client handshake failure clears owned intermediates"
205 (handshake-cleanup-failure! 0 'handshake))
206 (test "ql7-handshake: client transcript failure clears owned intermediates"
207 (handshake-cleanup-failure! 0 'transcript))
208 (test "ql7-handshake: client client-traffic failure clears owned intermediates"
209 (handshake-cleanup-failure! 0 'client-traffic))
210 (test "ql7-handshake: client server-traffic failure clears owned intermediates"
211 (handshake-cleanup-failure! 0 'server-traffic))
212 (test "ql7-handshake: client master failure clears owned intermediates"
213 (handshake-cleanup-failure! 0 'master))
214 (test "ql7-handshake-control: normal derivation preserves key ownership"
215 (handshake-cleanup-normal! #f #f))
216 (test "ql7-handshake-control: fragmented exchange preserves key ownership"
217 (handshake-cleanup-normal! #f #t))
218 (test "ql7-handshake-control: HRR exchange preserves key ownership"
219 (handshake-cleanup-normal! #t #t)))
221(define (share-cleanup-failure! location mode)
222 (handshake-cleanup-with-pair
223 (lambda (pair)
224 (let* ((client (vector-ref pair 0))
225 (server (vector-ref pair 1))
226 (target (if (eq? location 'server) server client))
227 (operation
228 (case location
229 ((client) (lambda () (tls-start! client)))
230 ((server)
231 (tls-start! client)
232 (let ((hello (car (filter
233 (lambda (event) (eqv? (handshake-cleanup-type event) 1))
234 (handshake-cleanup-take! pair 0)))))
235 (lambda () (handshake-cleanup-feed! server hello #f))))
236 ((retry)
237 (tls-start! client)
238 (handshake-cleanup-deliver! pair 0 #f)
239 (assert-equal 'client-hello (tls-state server))
240 (let ((retry (car (filter
241 (lambda (event) (eqv? (handshake-cleanup-type event) 2))
242 (handshake-cleanup-take! pair 1)))))
243 (lambda () (handshake-cleanup-feed! client retry #f)))))))
244 (handshake-spy-reset!)
245 (handshake-spy-fail! mode)
246 (let ((failure
247 (guard (exception (else exception))
248 (operation)
249 #f)))
250 (assert-true (error-object? failure))
251 (if (eq? mode 'key-generation-null)
252 (assert-equal "TLS: X25519 key generation failed" (error-object-message failure))
253 (begin
254 (assert-equal "QL7 injected handshake failure" (error-object-message failure))
255 (assert-equal (list mode) (error-object-irritants failure))))
256 (assert-true (tls-failed? target))
257 (assert-false (tls-complete? target))
258 (assert-false (tls-peer-parameters target))
259 (assert-equal 0 (tls-retained-input-bytes target))
260 (assert-equal '() (tls-take-events! target))
261 (assert-equal '() (handshake-spy-inputs))
262 (let ((entries (handshake-spy-shares)))
263 (assert-equal 1 (length entries))
264 (assert-equal 'key-private (vector-ref (car entries) 0))
265 (assert-true (vector-ref (car entries) 2))
266 (assert-equal 32 (bytevector-length (vector-ref (car entries) 1)))
267 (assert-true (handshake-cleanup-all-zero? entries))))))
268 (eq? location 'retry)))
270(define (share-cleanup-normal! defer? fragment?)
271 (handshake-cleanup-with-pair
272 (lambda (pair)
273 (tls-start! (vector-ref pair 0))
274 (if defer?
275 (assert-equal '() (handshake-spy-shares))
276 (begin
277 (assert-equal 1 (length (handshake-spy-shares)))
278 (assert-false (handshake-cleanup-zero?
279 (vector-ref (car (handshake-spy-shares)) 1)))))
280 (handshake-cleanup-deliver! pair 0 fragment?)
281 (when defer?
282 (assert-equal 'client-hello (tls-state (vector-ref pair 1)))
283 (handshake-cleanup-deliver! pair 1 fragment?)
284 (assert-equal 1 (length (handshake-spy-shares)))
285 (assert-false (handshake-cleanup-zero?
286 (vector-ref (car (handshake-spy-shares)) 1)))
287 (handshake-cleanup-deliver! pair 0 fragment?))
288 (assert-equal 'server-hello (tls-state (vector-ref pair 0)))
289 (assert-equal 'client-finished (tls-state (vector-ref pair 1)))
290 (let ((entries (reverse (handshake-spy-shares))))
291 (assert-equal 2 (length entries))
292 (for-each
293 (lambda (entry)
294 (assert-equal 'key-private (vector-ref entry 0))
295 (assert-true (vector-ref entry 2))
296 (assert-equal 32 (bytevector-length (vector-ref entry 1)))) entries)
297 ;; The client has not consumed ServerHello and still needs its key.
298 (assert-false (handshake-cleanup-zero? (vector-ref (car entries) 1)))
299 (assert-true (handshake-cleanup-zero? (vector-ref (cadr entries) 1)))
300 (do ((i 0 (+ i 1))) ((= i 4))
301 (handshake-cleanup-deliver! pair 1 fragment?)
302 (handshake-cleanup-deliver! pair 0 fragment?))
303 (assert-true (tls-complete? (vector-ref pair 0)))
304 (assert-true (tls-complete? (vector-ref pair 1)))
305 (assert-equal #u8(113 49) (tls-negotiated-alpn (vector-ref pair 0)))
306 (assert-equal #u8(1) (cdr (assoc 15 (tls-peer-parameters (vector-ref pair 1)))))
307 (assert-true (handshake-cleanup-all-zero? entries)))) defer?))
309(test-group "Owned key-generation inputs on exception"
310 (test "ql7-share: client failure before key generation clears private bytes"
311 (share-cleanup-failure! 'client 'key-generation-before))
312 (test "ql7-share: server failure before key generation clears private bytes"
313 (share-cleanup-failure! 'server 'key-generation-before))
314 (test "ql7-share: HRR client failure before key generation clears private bytes"
315 (share-cleanup-failure! 'retry 'key-generation-before))
316 (test "ql7-share: client failure after key generation clears private bytes"
317 (share-cleanup-failure! 'client 'key-generation-after))
318 (test "ql7-share: server failure after key generation clears private bytes"
319 (share-cleanup-failure! 'server 'key-generation-after))
320 (test "ql7-share: HRR client failure after key generation clears private bytes"
321 (share-cleanup-failure! 'retry 'key-generation-after))
322 (test "ql7-share-control: client false result clears private bytes"
323 (share-cleanup-failure! 'client 'key-generation-null))
324 (test "ql7-share-control: server false result clears private bytes"
325 (share-cleanup-failure! 'server 'key-generation-null))
326 (test "ql7-share-control: HRR client false result clears private bytes"
327 (share-cleanup-failure! 'retry 'key-generation-null))
328 (test "ql7-share-control: normal exchange preserves live private ownership"
329 (share-cleanup-normal! #f #f))
330 (test "ql7-share-control: fragmented exchange preserves live private ownership"
331 (share-cleanup-normal! #f #t))
332 (test "ql7-share-control: HRR exchange preserves live private ownership"
333 (share-cleanup-normal! #t #t)))