AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-client-retry.sgl

1(import (sigil test)
2 (sigil math)
3 (sigil crypto)
4 (sigil quic bytes)
5 (sigil quic wire)
6 (sigil quic frame)
7 (sigil quic packet)
8 (sigil quic reassembly)
9 (sigil quic connection)
10 (sigil quic error)
11 (sigil quic tls)
12 (sigil quic tls messages))
14(define cr-original #u8(1 2 3 4 5 6 7 8))
15(define cr-client-id #u8(11 12 13 14 15 16 17 18))
16(define cr-retry-id #u8(21 22 23 24 25 26 27 28))
17(define cr-server-id #u8(31 32 33 34 35 36 37 38))
18(define cr-token #u8(91 92 93))
20;; Catch peer-fixture errors in positive baseline predicates, so a missing
21;; Retry feature is a named false predicate rather than a load/error result.
22(define (cr-positive procedure)
23 (assert-true (guard (exn (else #f)) (procedure))))
25(define (cr-with-client procedure
26 (keys: (protocols (list #u8(113 49))) (start? #t) (send? #t)
27 (local-id cr-client-id) (handshake-timeout 10000)))
28 (let ((client (make-quic-client protocols "example.test" '()
29 (lambda (chain name) #f)
30 local-id: local-id destination-id: cr-original
31 handshake-timeout: handshake-timeout)))
32 (dynamic-wind
33 (lambda () #t)
34 (lambda ()
35 (when start? (quic-start! client 0))
36 (procedure client (if (and start? send?) (quic-take-datagrams! client 0) '())))
37 (lambda () (quic-abort! client)))))
39(define (cr-retry (keys: (source cr-retry-id) (destination cr-client-id)
40 (original cr-original) (token cr-token)))
41 (encode-retry-packet original destination source token unused: 11))
43(define (cr-open packet destination side)
44 (let ((keys (initial-keys destination side)))
45 (dynamic-wind
46 (lambda () #t)
47 (lambda ()
48 (guard (exn (else #f)) (open-quic-packet packet 0 0 keys -1)))
49 (lambda () (discard-packet-keys! keys)))))
51;; Return observed contiguous CRYPTO bytes, PNs, and opened headers. No
52;; production connection state or key getter is involved.
53(define (cr-flight packets destination)
54 (let ((receiver (make-byte-reassembler 65536)) (numbers '()) (headers '()))
55 (dynamic-wind
56 (lambda () #t)
57 (lambda ()
58 (for-each
59 (lambda (packet)
60 (let ((opened (cr-open packet destination 'client)))
61 (unless opened (error "Retry fixture Initial did not authenticate"))
62 (let ((header (opened-quic-packet-header opened)))
63 (unless (eq? (quic-header-kind header) 'initial)
64 (error "Retry fixture expected only Initial packets"))
65 (set! numbers (cons (opened-quic-packet-number opened) numbers))
66 (set! headers (cons header headers)))
67 (for-each
68 (lambda (frame)
69 (when (= (quic-frame-type frame) 6)
70 (reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))))
71 (decode-frames (opened-quic-packet-payload opened) 'initial 'client))))
72 packets)
73 (vector (reassembler-read! receiver) (reverse numbers) (reverse headers)))
74 (lambda () (reassembler-close! receiver)))))
76(define (cr-increasing? numbers floor)
77 (or (null? numbers)
78 (and (> (car numbers) floor) (cr-increasing? (cdr numbers) (car numbers)))))
80(define (cr-headers? flight destination source token)
81 (and (pair? (vector-ref flight 2))
82 (every
83 (lambda (header)
84 (and (bytes=? destination (quic-header-destination-id header))
85 (bytes=? source (quic-header-source-id header))
86 (bytes=? token (quic-header-token header))
87 (= 1200 (quic-header-end header))))
88 (vector-ref flight 2))))
90(define (cr-server-initial destination number frames)
91 (let ((keys (initial-keys destination 'server)))
92 (dynamic-wind
93 (lambda () #t)
94 (lambda ()
95 (seal-quic-packet keys 'initial cr-client-id cr-server-id number
96 (encode-frames frames 'initial 'server)))
97 (lambda () (discard-packet-keys! keys)))))
99(define (cr-ack number)
100 (make-quic-frame 2 (list (cons 'ranges (list (cons number number))) (cons 'delay 0))))
102(define (cr-unchanged? client now)
103 (and (not (quic-closed? client)) (not (quic-failure client))
104 (bytes=? cr-original (quic-peer-id client))
105 (null? (quic-take-datagrams! client now))))
107;; A public TLS server peer owns all of its traffic keys and counters.
108(define (cr-peer-index level)
109 (case level ((initial) 0) ((handshake) 1) ((application) 2)))
111(define (cr-peer-wipe! bytes)
112 (when (bytevector? bytes)
113 (do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
114 (bytevector-u8-set! bytes i 0))))
116(define (cr-peer-build! peer level frames)
117 (let* ((index (cr-peer-index level)) (numbers (vector-ref peer 4))
118 (number (vector-ref numbers index)) (role (vector-ref peer 11))
119 (destination (if (and (eq? role 'client) (eq? level 'initial)
120 (= -1 (vector-ref (vector-ref peer 5) 0)))
121 cr-original (vector-ref peer 13)))
122 (source (if (eq? level 'application) #u8() (vector-ref peer 14)))
123 (body (encode-frames frames level role))
124 (header (encode-packet-header level destination source #u8() number 4
125 (+ 16 (bytevector-length body))
126 length-width: (and (not (eq? level 'application)) 2)))
127 (payload (if (eq? level 'initial)
128 (bytes-append body
129 (make-bytevector (- 1200 16 (bytevector-length header) (bytevector-length body)) 0))
130 body)))
131 (vector-set! numbers index (+ number 1))
132 (cons number
133 (seal-quic-packet (vector-ref (vector-ref peer 3) index) level destination source
134 number payload length-width: (and (not (eq? level 'application)) 2)))))
136(define (cr-peer-receive! peer packet now)
137 (vector-set! peer 10 now)
138 (quic-receive! (vector-ref peer 0) packet now))
140(define (cr-peer-send! peer level frames)
141 (let ((packet (cr-peer-build! peer level frames)))
142 (cr-peer-receive! peer (cdr packet) (vector-ref peer 10))
143 packet))
145(define (cr-peer-crypto! peer event)
146 (let* ((level (tls-event-level event))
147 (index (cr-peer-index level))
148 (data (tls-event-data event))
149 (offsets (vector-ref peer 7))
150 (offset (vector-ref offsets index)))
151 (cr-peer-send! peer level
152 (list (make-quic-frame 6 (list (cons 'offset offset) (cons 'data data)))))
153 (vector-set! offsets index (+ offset (bytevector-length data)))))
155(define (cr-peer-events! peer)
156 (for-each
157 (lambda (event)
158 (let* ((index (cr-peer-index (tls-event-level event)))
159 (data (tls-event-data event)))
160 (case (tls-event-kind event)
161 ((secrets)
162 (when (car data)
163 (vector-set! (vector-ref peer 2) index (traffic-keys (car data)))
164 (cr-peer-wipe! (car data)))
165 (when (cdr data)
166 (vector-set! (vector-ref peer 3) index (traffic-keys (cdr data)))
167 (cr-peer-wipe! (cdr data))))
168 ((crypto)
169 (if (vector-ref peer 15)
170 (vector-set! peer 16 (append (vector-ref peer 16) (list event)))
171 (cr-peer-crypto! peer event))))))
172 (tls-take-events! (vector-ref peer 1)))
173 (when (and (not (vector-ref peer 15)) (eq? (vector-ref peer 11) 'server)
174 (tls-complete? (vector-ref peer 1)) (not (vector-ref peer 12)))
175 (vector-set! peer 12 #t)
176 (cr-peer-send! peer 'application (list (make-quic-frame 30 '())))))
178(define (cr-peer-flush! peer level)
179 (let ((pending (vector-ref peer 16)))
180 (vector-set! peer 16
181 (filter (lambda (event) (not (eq? level (tls-event-level event)))) pending))
182 (for-each (lambda (event) (when (eq? level (tls-event-level event)) (cr-peer-crypto! peer event)))
183 pending)))
185(define (cr-peer-read! peer packet ack?)
186 (let* ((header (decode-packet-header packet 0 8)) (level (quic-header-kind header))
187 (index (cr-peer-index level)) (largest (vector-ref peer 5))
188 (opened (open-quic-packet packet 0 8 (vector-ref (vector-ref peer 2) index)
189 (vector-ref largest index))))
190 (unless opened (error "Early-packet fixture target packet did not authenticate"))
191 (let* ((number (opened-quic-packet-number opened))
192 (frames (decode-frames (opened-quic-packet-payload opened) level
193 (quic-role (vector-ref peer 0)))))
194 (vector-set! largest index (max number (vector-ref largest index)))
195 (vector-set! peer 8 (cons (list level number frames) (vector-ref peer 8)))
196 (for-each
197 (lambda (frame)
198 (when (= (quic-frame-type frame) 6)
199 (let ((receiver (vector-ref (vector-ref peer 6) index)))
200 (reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))
201 (let ((bytes (reassembler-read! receiver)))
202 (when (> (bytevector-length bytes) 0)
203 (tls-input! (vector-ref peer 1) level bytes)
204 ;; Install client-side Handshake keys before opening the
205 ;; next packet in the server's already returned flight.
206 (cr-peer-events! peer)))))) frames)
207 (when (and ack? (any frame-ack-eliciting? frames))
208 (cr-peer-send! peer level
209 (list (make-quic-frame 2
210 (list (cons 'ranges (list (cons number number))) (cons 'delay 0)))))))))
212(define (cr-peer-output! peer now (keys: (ack? #t)))
213 (vector-set! peer 10 now)
214 (let ((packets (quic-take-datagrams! (vector-ref peer 0) now)))
215 (for-each
216 (lambda (packet)
217 (let ((index (cr-peer-index (quic-header-kind (decode-packet-header packet 0 8)))))
218 (when (vector-ref (vector-ref peer 2) index) (cr-peer-read! peer packet ack?))))
219 packets)
220 packets))
222(define (cr-peer-live? peer)
223 (let ((connection (vector-ref peer 0)))
224 (and (quic-confirmed? connection) (not (quic-closed? connection))
225 (not (quic-failure connection)))))
228(define (cr-with-peer procedure (keys: (retry? #t) (binding 'correct)))
229 (let ((key (ecdsa-p256-generate-keypair)) (client #f) (engine #f) (peer #f))
230 (dynamic-wind
231 (lambda () #t)
232 (lambda ()
233 (set! client
234 (make-quic-client (list #u8(113 49)) 'pinned-key '() (make-tls-pin-verifier (cdr key))
235 local-id: cr-client-id destination-id: cr-original))
236 (set! engine
237 (make-tls-server (list #u8(113 49))
238 (append (list (cons 0 (if (eq? binding 'original) cr-retry-id cr-original))
239 (cons 15 cr-server-id))
240 (if (and retry? (not (eq? binding 'missing)))
241 (list (cons 16 (if (eq? binding 'retry) cr-original cr-retry-id))) '()))
242 (list #u8(48 1 0)) (car key)))
243 (let ((destination (if retry? cr-retry-id cr-original)))
244 (set! peer
245 (vector client engine
246 (vector (initial-keys destination 'client) #f #f)
247 (vector (initial-keys destination 'server) #f #f)
248 (vector 0 0 0) (vector -1 -1 -1)
249 (vector (make-byte-reassembler 65536) (make-byte-reassembler 65536)
250 (make-byte-reassembler 65536))
251 (vector 0 0 0) '() '() 0 'server #f cr-client-id cr-server-id #f '())))
252 (tls-bind-peer! engine cr-original cr-client-id #f)
253 (quic-start! client 0)
254 (when retry?
255 (quic-take-datagrams! client 0)
256 (quic-receive! client (cr-retry) 1)
257 (vector-set! peer 10 1))
258 (do ((round 0 (+ round 1))) ((or (= round 12) (quic-closed? client)))
259 (cr-peer-output! peer (vector-ref peer 10))
260 (cr-peer-events! peer))
261 (procedure peer))
262 (lambda ()
263 (when client (quic-abort! client))
264 (when engine (tls-abort! engine))
265 (when peer
266 (for-each
267 (lambda (keys) (when keys (discard-packet-keys! keys)))
268 (append (vector->list (vector-ref peer 2)) (vector->list (vector-ref peer 3))))
269 (for-each reassembler-close! (vector->list (vector-ref peer 6))))
270 (cr-peer-wipe! (car key))))))
273(define (cr-large-protocols)
274 (cons #u8(113 49)
275 (let loop ((index 0) (out '()))
276 (if (= index 48) (reverse out)
277 (loop (+ index 1) (cons (make-bytevector 255 (+ 80 index)) out))))))
279;; Explicit offsets detect duplicated old queued tails as well as missing
280;; bytes. Authenticated ACKs release the ordinary congestion/pending budgets.
281(define (cr-large-continuation! client before)
282 (let* ((first (cr-flight before cr-original))
283 (prefix (vector-ref first 0))
284 (declared (+ 4 (* 65536 (bytevector-u8-ref prefix 1))
285 (* 256 (bytevector-u8-ref prefix 2)) (bytevector-u8-ref prefix 3)))
286 (next-offset 0) (last-number (apply max (vector-ref first 1)))
287 (ack-number 0) (parts '()))
288 (unless (< (bytevector-length prefix) declared)
289 (error "Retry fixture did not leave an unsent ClientHello suffix"))
290 (quic-receive! client (cr-retry) 1)
291 (let loop ((round 0))
292 (let ((packets (quic-take-datagrams! client 1)))
293 (when (pair? packets)
294 (when (= round 8) (error "Retry large-flight fixture exceeded its round bound"))
295 (let ((flight (cr-flight packets cr-retry-id)))
296 (unless (and (cr-increasing? (vector-ref flight 1) last-number)
297 (cr-headers? flight (if (= round 0) cr-retry-id cr-server-id)
298 cr-client-id cr-token))
299 (error "Retry large-flight header or PN changed"))
300 (set! last-number (apply max (vector-ref flight 1))))
301 (for-each
302 (lambda (packet)
303 (let ((opened (cr-open packet cr-retry-id 'client)))
304 (for-each
305 (lambda (frame)
306 (when (= (quic-frame-type frame) 6)
307 (unless (= next-offset (frame-ref frame 'offset))
308 (error "Retry retained a duplicate or missing queued suffix"))
309 (set! parts (cons (frame-ref frame 'data) parts))
310 (set! next-offset (+ next-offset (bytevector-length (frame-ref frame 'data))))))
311 (decode-frames (opened-quic-packet-payload opened) 'initial 'client))
312 (quic-receive! client
313 (cr-server-initial cr-retry-id ack-number
314 (list (cr-ack (opened-quic-packet-number opened)))) 1)
315 (set! ack-number (+ ack-number 1)))) packets)
316 (loop (+ round 1)))))
317 (let ((hello (apply bytes-append (reverse parts))))
318 (and (not (quic-failure client)) (= declared next-offset)
319 (bytes=? prefix (bytevector-copy hello 0 (bytevector-length prefix)))
320 (tls-client-hello? (decode-client-hello hello))))))
322;; Sign intentionally forbidden shapes independently of the encoder's local
323;; validation so a valid public tag cannot conceal a policy/format mistake.
324(define (cr-signed-shape source token)
325 (let* ((unsigned (bytes-append #u8(240 0 0 0 1 8) cr-client-id
326 (bytevector (bytevector-length source)) source token))
327 (sealed (aes-128-gcm-encrypt (hex->bytes "be0c690b9f66575a1d766b54e368c84e")
328 (hex->bytes "461599d35d632bf2239825bb")
329 (bytes-append #u8(8) cr-original unsigned) #u8())))
330 (unless sealed (error "Retry malformed-shape fixture could not sign"))
331 (bytes-append unsigned (cdr sealed))))
333(test-group "QUIC client Retry continuation"
334 (test "ql12-client-retry: rekeyed Initial and PTO preserve hello IDs token and increasing PNs"
335 (cr-positive
336 (lambda ()
337 (cr-with-client
338 (lambda (client before)
339 (let ((first (cr-flight before cr-original)))
340 (quic-receive! client (cr-retry) 1)
341 (let* ((packets (quic-take-datagrams! client 1))
342 (second (cr-flight packets cr-retry-id)))
343 (quic-tick! client 1001)
344 (let ((third (cr-flight (quic-take-datagrams! client 1001) cr-retry-id)))
345 (and (not (quic-failure client))
346 (bytes=? cr-retry-id (quic-peer-id client))
347 (bytes=? (vector-ref first 0) (vector-ref second 0))
348 (bytes=? (vector-ref first 0) (vector-ref third 0))
349 (cr-headers? second cr-retry-id cr-client-id cr-token)
350 (cr-headers? third cr-retry-id cr-client-id cr-token)
351 (cr-increasing? (vector-ref second 1) (apply max (vector-ref first 1)))
352 (cr-increasing? (vector-ref third 1) (apply max (vector-ref second 1)))
353 (every (lambda (packet) (not (cr-open packet cr-original 'client))) packets))))))))))
354 (test "ql12-client-retry: maximum token fragments hello and input mutation cannot change retained bytes"
355 (cr-positive
356 (lambda ()
357 (cr-with-client
358 (lambda (client before)
359 (let* ((token (make-bytevector 1024 7))
360 (wire (cr-retry token: token))
361 (first (cr-flight before cr-original)))
362 (quic-receive! client wire 1)
363 (do ((index 0 (+ index 1))) ((= index (bytevector-length wire)))
364 (bytevector-u8-set! wire index 0))
365 (let* ((packets (quic-take-datagrams! client 1))
366 (second (cr-flight packets cr-retry-id)))
367 (and (> (length packets) 1) (not (quic-failure client))
368 (bytes=? (vector-ref first 0) (vector-ref second 0))
369 (cr-headers? second cr-retry-id cr-client-id token)))))))))
370 (test "ql12-client-retry: public TLS peer authenticates distinct original Retry and server Initial IDs"
371 (cr-positive
372 (lambda ()
373 (cr-with-peer
374 (lambda (peer)
375 (let ((client (vector-ref peer 0)))
376 (and (cr-peer-live? peer) (tls-complete? (vector-ref peer 1))
377 (bytes=? cr-server-id (quic-peer-id client))
378 (bytes=? cr-original (cdr (assoc 0 (quic-peer-parameters client))))
379 (bytes=? cr-retry-id (cdr (assoc 16 (quic-peer-parameters client))))
380 (bytes=? #u8(113 49) (quic-negotiated-alpn client)))))))))
381 (test "ql12-client-retry: duplicate Retry cannot replace committed ID token or pending hello"
382 (cr-positive
383 (lambda ()
384 (cr-with-client
385 (lambda (client before)
386 (quic-receive! client (cr-retry) 1)
387 (quic-receive! client (cr-retry source: cr-server-id token: #u8(1 2)) 2)
388 (let ((flight (cr-flight (quic-take-datagrams! client 2) cr-retry-id)))
389 (and (bytes=? cr-retry-id (quic-peer-id client))
390 (bytes=? (vector-ref (cr-flight before cr-original) 0) (vector-ref flight 0))
391 (cr-headers? flight cr-retry-id cr-client-id cr-token))))))))
392 (test "ql12-client-retry: old Initial keys are dropped and a new server Initial still pins its ID"
393 (cr-positive
394 (lambda ()
395 (cr-with-client
396 (lambda (client before)
397 (quic-receive! client (cr-retry) 1)
398 (let* ((flight (cr-flight (quic-take-datagrams! client 1) cr-retry-id))
399 (number (car (vector-ref flight 1))))
400 (quic-receive! client (cr-server-initial cr-original 0 (list (cr-ack number))) 2)
401 (let ((ignored? (bytes=? cr-retry-id (quic-peer-id client))))
402 (quic-receive! client (cr-server-initial cr-retry-id 0 (list (cr-ack number))) 3)
403 (quic-receive! client (cr-retry source: #u8(81)) 4)
404 (and ignored? (not (quic-failure client))
405 (bytes=? cr-server-id (quic-peer-id client))))))))))
406 (test "ql12-client-retry: missing or wrong authenticated transport ID bindings close with typed eight"
407 (cr-positive
408 (lambda ()
409 (every
410 (lambda (binding)
411 (cr-with-peer
412 (lambda (peer)
413 (let* ((client (vector-ref peer 0)) (failure (quic-failure client)))
414 (and (quic-closed? client) (not (quic-complete? client))
415 (quic-error? failure) (= 8 (quic-error-code failure)))))
416 binding: binding))
417 '(missing retry original)))))
418 (test "ql12-client-retry: zero-length Retry and client IDs are preserved as IDs rather than no Retry"
419 (cr-positive
420 (lambda ()
421 (cr-with-client
422 (lambda (client before)
423 (quic-receive! client (cr-retry source: #u8() destination: #u8()) 1)
424 (let ((flight (cr-flight (quic-take-datagrams! client 1) #u8())))
425 (and (bytes=? #u8() (quic-peer-id client))
426 (bytes=? (vector-ref (cr-flight before cr-original) 0) (vector-ref flight 0))
427 (cr-headers? flight #u8() #u8() cr-token))))
428 local-id: #u8()))))
429 (test "ql12-client-retry: sent and unsent large hello bytes are requeued once without holes"
430 (cr-positive
431 (lambda ()
432 (cr-with-client cr-large-continuation! protocols: (cr-large-protocols)))))
433 (test "ql12-client-control: malformed tag ODCID destination source and empty token cannot alter the flight"
434 (cr-with-client
435 (lambda (client before)
436 (let ((valid (cr-retry)))
437 (for-each
438 (lambda (wire)
439 (quic-receive! client wire 1)
440 (assert-true (cr-unchanged? client 1)))
441 (list (flip-byte valid (- (bytevector-length valid) 1))
442 (cr-retry original: cr-server-id)
443 (cr-retry destination: cr-server-id)
444 (cr-signed-shape cr-original cr-token)
445 (cr-signed-shape cr-retry-id #u8())
446 (bytevector-copy valid 0 (- (bytevector-length valid) 1)))))
447 (quic-tick! client 1000)
448 (let ((flight (cr-flight (quic-take-datagrams! client 1000) cr-original)))
449 (assert-equal (vector-ref (cr-flight before cr-original) 0) (vector-ref flight 0))
450 (assert-true (cr-headers? flight cr-original cr-client-id #u8()))))))
451 (test "ql12-client-control: Retry before start or before the first transmitted Initial is ignored"
452 (for-each
453 (lambda (started?)
454 (cr-with-client
455 (lambda (client before)
456 (quic-receive! client (cr-retry) 1)
457 (assert-equal cr-original (quic-peer-id client))
458 (unless started? (quic-start! client 1))
459 (let ((flight (cr-flight (quic-take-datagrams! client 1) cr-original)))
460 (assert-equal '(0) (vector-ref flight 1))
461 (assert-true (cr-headers? flight cr-original cr-client-id #u8()))))
462 start?: started? send?: #f)) '(#f #t)))
463 (test "ql12-client-control: a processed authenticated server Initial excludes a later Retry"
464 (cr-with-client
465 (lambda (client before)
466 (quic-receive! client (cr-server-initial cr-original 0 (list (cr-ack 0))) 1)
467 (assert-equal cr-server-id (quic-peer-id client))
468 (quic-receive! client (cr-retry) 2)
469 (assert-equal cr-server-id (quic-peer-id client))
470 (assert-false (quic-failure client))
471 (assert-equal '() (quic-take-datagrams! client 2)))))
472 (test "ql12-client-control: closed clients cannot be rearmed by Retry"
473 (cr-with-client
474 (lambda (client before)
475 (quic-abort! client)
476 (quic-receive! client (cr-retry) 1)
477 (assert-true (quic-closed? client))
478 (assert-equal cr-original (quic-peer-id client))
479 (assert-equal '() (quic-take-datagrams! client 1)))))
480 (test "ql12-client-control: a server cannot process a client-origin Retry"
481 (let* ((key (ecdsa-p256-generate-keypair))
482 (server (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) (car key)
483 cr-original cr-client-id local-id: cr-server-id)))
484 (dynamic-wind
485 (lambda () #t)
486 (lambda ()
487 (quic-receive! server (cr-retry destination: cr-server-id) 1)
488 (assert-false (quic-closed? server))
489 (assert-false (quic-failure server))
490 (assert-equal cr-client-id (quic-peer-id server))
491 (assert-equal '() (quic-take-datagrams! server 1)))
492 (lambda () (quic-abort! server) (cr-peer-wipe! (car key))))))
493 (test "ql12-client-control: token byte 1025 is a bounded drop without consuming the original flight"
494 (cr-with-client
495 (lambda (client before)
496 (quic-receive! client (cr-retry token: (make-bytevector 1025 7)) 1)
497 (assert-true (cr-unchanged? client 1))
498 (quic-tick! client 1000)
499 (let ((flight (cr-flight (quic-take-datagrams! client 1000) cr-original)))
500 (assert-equal (vector-ref (cr-flight before cr-original) 0) (vector-ref flight 0))
501 (assert-true (cr-headers? flight cr-original cr-client-id #u8()))))))
502 (test "ql12-client-control: Retry cannot extend the original handshake deadline"
503 (cr-with-client
504 (lambda (client before)
505 (quic-receive! client (cr-retry) 4)
506 (quic-tick! client 5)
507 (assert-true (quic-closed? client))
508 (assert-true (quic-error? (quic-failure client)))
509 (assert-equal 1 (quic-error-code (quic-failure client)))
510 (assert-equal "QUIC handshake deadline exceeded" (quic-error-reason (quic-failure client))))
511 handshake-timeout: 5))
512 (test "ql12-client-control: ordinary authenticated completion has no Retry transport binding"
513 (cr-with-peer
514 (lambda (peer)
515 (let ((client (vector-ref peer 0)))
516 (assert-true (cr-peer-live? peer))
517 (assert-true (tls-complete? (vector-ref peer 1)))
518 (assert-equal cr-server-id (quic-peer-id client))
519 (assert-false (assoc 16 (quic-peer-parameters client)))))
520 retry?: #f))