AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-tls-handshake.sgl

1(import (sigil test)
2 (sigil process)
3 (sigil crypto)
4 (sigil quic bytes)
5 (sigil quic tls)
6 (sigil quic tls codec)
7 (sigil quic tls messages)
8 (sigil quic tls extensions)
9 (sigil quic tls authentication))
11;; Synthetic leaf bytes exercise the explicit pin-verifier contract, not X.509.
12(define (engine-pair defer? accept?)
13 (let* ((key (ecdsa-p256-generate-keypair))
14 (client (make-tls-client (list #u8(113 49)) "example.test"
15 (list (cons 15 #u8(1)))
16 (lambda (chain name)
17 (and accept? (equal? name "example.test")
18 (equal? chain (list #u8(48 1 0))) (cdr key)))
19 defer-key-share?: defer?))
20 (server (make-tls-server (list #u8(113 49))
21 (list (cons 0 #u8(9)) (cons 15 #u8(2)))
22 (list #u8(48 1 0)) (car key))))
23 (tls-bind-peer! client #u8(9) #u8(2) #f)
24 (tls-bind-peer! server #u8(9) #u8(1) #f)
25 (vector client server '() '())))
27(define (engine-feed! target event fragment?)
28 (when (eq? (tls-event-kind event) 'crypto)
29 (let ((wire (tls-event-data event)) (level (tls-event-level event)))
30 (if fragment?
31 (do ((i 0 (+ i 1))) ((= i (bytevector-length wire)))
32 (tls-input! target level (bytevector-copy wire i (+ i 1))))
33 (tls-input! target level wire)))))
35(define (engine-deliver! pair side fragment?)
36 (let ((events (tls-take-events! (vector-ref pair side))))
37 (vector-set! pair (+ side 2) (append (vector-ref pair (+ side 2)) events))
38 (for-each (lambda (event) (engine-feed! (vector-ref pair (- 1 side)) event fragment?)) events)))
40(define (engine-run defer? fragment?)
41 (let ((pair (engine-pair defer? #t)))
42 (tls-start! (vector-ref pair 0))
43 (do ((i 0 (+ i 1))) ((= i 4))
44 (engine-deliver! pair 0 fragment?)
45 (engine-deliver! pair 1 fragment?))
46 pair))
48(define (engine-secret events level direction)
49 (let loop ((rest events))
50 (if (null? rest)
51 #f
52 (let ((event (car rest)))
53 (if (and (eq? (tls-event-kind event) 'secrets)
54 (eq? (tls-event-level event) level)
55 (if (eq? direction 'read) (car (tls-event-data event))
56 (cdr (tls-event-data event))))
57 (if (eq? direction 'read) (car (tls-event-data event)) (cdr (tls-event-data event)))
58 (loop (cdr rest)))))))
60(define (engine-control expected actual)
61 (assert-equal
62 (if (equal? (getenv "QUIC_TLS_ENGINE_RED") "1") (flip-byte expected 0) expected)
63 actual))
65(define (engine-flight pair)
66 (tls-start! (vector-ref pair 0))
67 (engine-deliver! pair 0 #f)
68 (tls-take-events! (vector-ref pair 1)))
70(define (engine-reject-flight type offset)
71 (let* ((pair (engine-pair #f #t))
72 (client (vector-ref pair 0))
73 (flight (engine-flight pair)))
74 (assert-error
75 (for-each
76 (lambda (event)
77 (when (eq? (tls-event-kind event) 'crypto)
78 (let ((wire (tls-event-data event)))
79 (tls-input! client (tls-event-level event)
80 (if (= (bytevector-u8-ref wire 0) type)
81 (flip-byte wire (- (bytevector-length wire) offset)) wire)))))
82 flight))
83 (assert-true (tls-failed? client))
84 (assert-equal '() (tls-take-events! client))
85 (assert-false (tls-peer-parameters client))
86 (assert-error (tls-input! client 'handshake #u8()))))
88(test-group "QUIC TLS client/server engine"
89 (test "engine-control: client handshake read matches server write"
90 (let ((pair (engine-run #f #f)))
91 (engine-control (engine-secret (vector-ref pair 3) 'handshake 'write)
92 (engine-secret (vector-ref pair 2) 'handshake 'read))))
93 (test "engine-control: server handshake read matches client write"
94 (let ((pair (engine-run #f #f)))
95 (engine-control (engine-secret (vector-ref pair 2) 'handshake 'write)
96 (engine-secret (vector-ref pair 3) 'handshake 'read))))
97 (test "engine-control: client application read matches server write"
98 (let ((pair (engine-run #f #f)))
99 (engine-control (engine-secret (vector-ref pair 3) 'application 'write)
100 (engine-secret (vector-ref pair 2) 'application 'read))))
101 (test "engine-control: server application read matches client write"
102 (let ((pair (engine-run #f #f)))
103 (engine-control (engine-secret (vector-ref pair 2) 'application 'write)
104 (engine-secret (vector-ref pair 3) 'application 'read))))
105 (test "both roles complete with authenticated ALPN and copied parameters"
106 (let* ((pair (engine-run #f #f)) (client (vector-ref pair 0)) (server (vector-ref pair 1)))
107 (assert-true (tls-complete? client))
108 (assert-true (tls-complete? server))
109 (assert-equal #u8(113 49) (tls-negotiated-alpn client))
110 (assert-equal #u8(113 49) (tls-negotiated-alpn server))
111 (assert-equal #u8(1) (cdr (assoc 15 (tls-peer-parameters server))))
112 (let ((parameters (tls-peer-parameters client)))
113 (bytevector-u8-set! (cdr (assoc 15 parameters)) 0 99)
114 (assert-equal #u8(2) (cdr (assoc 15 (tls-peer-parameters client)))))))
115 (test "one-byte CRYPTO fragmentation completes both roles"
116 (let ((pair (engine-run #f #t)))
117 (assert-true (tls-complete? (vector-ref pair 0)))
118 (assert-true (tls-complete? (vector-ref pair 1)))))
119 (test "HRR with deferred X25519 share completes under one-byte fragmentation"
120 (let* ((pair (engine-run #t #t))
121 (initial-count
122 (length (filter (lambda (event)
123 (and (eq? (tls-event-kind event) 'crypto)
124 (eq? (tls-event-level event) 'initial)))
125 (vector-ref pair 2)))))
126 (assert-equal 2 initial-count)
127 (assert-true (tls-complete? (vector-ref pair 0)))
128 (assert-true (tls-complete? (vector-ref pair 1)))))
129 (test "peer parameters and application read secrets wait for Finished"
130 (let* ((pair (engine-pair #f #t)) (client (vector-ref pair 0))
131 (server (vector-ref pair 1)) (flight (engine-flight pair)))
132 (assert-false (tls-peer-parameters server))
133 (assert-false (tls-negotiated-alpn server))
134 (assert-false (engine-secret flight 'application 'read))
135 (for-each
136 (lambda (event)
137 (unless (and (eq? (tls-event-kind event) 'crypto)
138 (= (bytevector-u8-ref (tls-event-data event) 0) 20))
139 (engine-feed! client event #f))) flight)
140 (assert-false (tls-peer-parameters client))
141 (assert-false (tls-negotiated-alpn client))
142 (assert-false (tls-complete? client))))
143 (test "explicit certificate rejection permanently fails and discards queued output"
144 (let* ((pair (engine-pair #f #f)) (client (vector-ref pair 0)) (flight (engine-flight pair)))
145 (assert-error (for-each (lambda (event) (engine-feed! client event #f)) flight))
146 (assert-true (tls-failed? client))
147 (assert-equal '() (tls-take-events! client))))
148 (test "corrupted CertificateVerify is rejected"
149 (engine-reject-flight 15 1))
150 (test "each corrupted Finished byte is rejected"
151 (do ((offset 1 (+ offset 1))) ((= offset 33)) (engine-reject-flight 20 offset)))
152 (test "server rejects corrupted client Finished without installing application read keys"
153 (let* ((pair (engine-pair #f #t)) (client (vector-ref pair 0)) (server (vector-ref pair 1))
154 (flight (engine-flight pair)))
155 (for-each (lambda (event) (engine-feed! client event #f)) flight)
156 (assert-error
157 (for-each
158 (lambda (event)
159 (when (eq? (tls-event-kind event) 'crypto)
160 (let ((wire (tls-event-data event)))
161 (tls-input! server 'handshake (flip-byte wire (- (bytevector-length wire) 1))))))
162 (tls-take-events! client)))
163 (assert-true (tls-failed? server))
164 (assert-equal '() (tls-take-events! server))))
165 (test "wrong encryption level fails before processing input"
166 (let ((client (vector-ref (engine-pair #f #t) 0)))
167 (tls-start! client)
168 (assert-error (tls-input! client 'handshake #u8(2 0 0 0)))
169 (assert-true (tls-failed? client))))
170 (test "oversized declared message fails with header alone"
171 (let ((server (vector-ref (engine-pair #f #t) 1)))
172 (assert-error (tls-input! server 'initial #u8(1 255 255 255)))
173 (assert-true (tls-failed? server))))
174 (test "unexpected message order is rejected"
175 (let ((client (vector-ref (engine-pair #f #t) 0)))
176 (tls-start! client)
177 (assert-error (tls-input! client 'initial (encode-finished (make-bytevector 32 0))))))
178 (test "starting twice fails and clears queued ClientHello"
179 (let ((client (vector-ref (engine-pair #f #t) 0)))
180 (tls-start! client)
181 (assert-error (tls-start! client))
182 (assert-equal '() (tls-take-events! client))))
183 (test "peer IDs bind once and are mandatory before peer parameters"
184 (let ((client (vector-ref (engine-pair #f #t) 0)))
185 (assert-error (tls-bind-peer! client #u8(9) #u8(2) #f)))
186 (let ((server (make-tls-server (list #u8(113 49))
187 (list (cons 0 #u8(9)) (cons 15 #u8(2)))
188 (list #u8(48)) (car (ecdsa-p256-generate-keypair))))
189 (client (vector-ref (engine-pair #f #t) 0)))
190 (tls-start! client)
191 (assert-error
192 (for-each (lambda (event) (engine-feed! server event #f)) (tls-take-events! client)))))
193 (test "mismatched transport connection ID is rejected"
194 (let* ((pair (engine-pair #f #t))
195 (client (make-tls-client (list #u8(113 49)) "example.test"
196 (list (cons 15 #u8(77))) (lambda (chain name) #f)))
197 (server (vector-ref pair 1)))
198 (tls-start! client)
199 (assert-error
200 (for-each (lambda (event) (engine-feed! server event #f)) (tls-take-events! client)))))
201 (test "HRR requests an unoffered group once and CH2 cannot change ALPN"
202 (let* ((pair (engine-pair #t #t)) (client (vector-ref pair 0)) (server (vector-ref pair 1)))
203 (tls-start! client)
204 (engine-deliver! pair 0 #f)
205 (engine-deliver! pair 1 #f)
206 (let* ((event (car (tls-take-events! client)))
207 (hello (decode-client-hello (tls-event-data event)))
208 (extensions (map (lambda (entry)
209 (if (= (car entry) 16) (cons 16 (encode-alpn (list #u8(120)))) entry))
210 (tls-client-hello-extensions hello))))
211 (assert-error
212 (tls-input! server 'initial
213 (encode-client-hello (tls-client-hello-random hello)
214 (tls-client-hello-session-id hello) (tls-client-hello-cipher-suites hello) extensions))))))
215 (test "replayed HRR is rejected"
216 (let* ((pair (engine-pair #t #t)) (client (vector-ref pair 0)) (server (vector-ref pair 1)))
217 (tls-start! client)
218 (engine-deliver! pair 0 #f)
219 (let ((retry (car (tls-take-events! server))))
220 (engine-feed! client retry #f)
221 (assert-error (engine-feed! client retry #f)))))
222 (test "already offered HRR group is rejected"
223 (let ((client (vector-ref (engine-pair #f #t) 0)))
224 (tls-start! client)
225 (assert-error
226 (tls-input! client 'initial
227 (encode-server-hello
228 (hex->bytes "cf21ad74e59a6111be1d8c021e65b891c2a211167abb8c5e079e09e2c8a8339c")
229 #u8() 4865 (list (cons 43 #u8(3 4)) (cons 51 #u8(0 29))))))))
230 (test "bounded post-handshake tickets are discarded without resumption"
231 (let* ((client (vector-ref (engine-run #f #f) 0))
232 (ticket (encode-handshake 4 #u8(0 0 0 1 0 0 0 0 0 0 1 42 0 0))))
233 (do ((i 0 (+ i 1))) ((= i 64)) (tls-input! client 'application ticket))
234 (assert-true (tls-complete? client))
235 (assert-equal '() (tls-take-events! client))
236 (assert-error (tls-input! client 'application ticket))))
237 (test "QUIC forbids TLS KeyUpdate"
238 (let ((client (vector-ref (engine-run #f #f) 0)))
239 (assert-error (tls-input! client 'application (encode-handshake 24 #u8(0))))))
240 (test "no certificate verifier default exists"
241 (assert-error
242 (make-tls-client (list #u8(113 49)) "example.test" (list (cons 15 #u8(1))) #f)))
243 (test "large ClientHello is accepted in one-byte fragments"
244 (let* ((pair (engine-pair #f #t)) (client (vector-ref pair 0)) (server (vector-ref pair 1)))
245 (tls-start! client)
246 (let* ((event (car (tls-take-events! client)))
247 (hello (decode-client-hello (tls-event-data event)))
248 (wire (encode-client-hello (tls-client-hello-random hello)
249 (tls-client-hello-session-id hello) (tls-client-hello-cipher-suites hello)
250 (append (tls-client-hello-extensions hello)
251 (list (cons 21 (make-bytevector 12000 0)))))))
252 (do ((i 0 (+ i 1))) ((= i (bytevector-length wire)))
253 (tls-input! server 'initial (bytevector-copy wire i (+ i 1))))
254 (assert-equal 'client-finished (tls-state server)))))
255 (test "coalesced authentication flight completes the handshake"
256 (let* ((pair (engine-pair #f #t)) (client (vector-ref pair 0)) (server (vector-ref pair 1))
257 (flight (engine-flight pair)) (parts '()))
258 (for-each
259 (lambda (event)
260 (when (eq? (tls-event-kind event) 'crypto)
261 (if (eq? (tls-event-level event) 'initial)
262 (engine-feed! client event #f)
263 (set! parts (cons (tls-event-data event) parts))))) flight)
264 (tls-input! client 'handshake (apply bytes-append (reverse parts)))
265 (assert-true (tls-complete? client))
266 (engine-deliver! pair 0 #f)
267 (assert-true (tls-complete? server))))
268 (test "messages cannot straddle QUIC encryption levels"
269 (let* ((pair (engine-pair #f #t)) (client (vector-ref pair 0))
270 (flight (engine-flight pair))
271 (wires (map tls-event-data
272 (filter (lambda (event) (eq? (tls-event-kind event) 'crypto)) flight))))
273 (assert-error (tls-input! client 'initial (bytes-append (car wires) (cadr wires))))
274 (assert-true (tls-failed? client))
275 (assert-equal '() (tls-take-events! client)))))