Commit321f850cRecorded18 Oct 2026Repositorysigil-quic

Continue client handshakes after one validated QUIC Retry

Changed
 README.md                     |  16 +++--
 scripts/native-tls-tests.mjs  |   7 ++-
 src/sigil/quic/connection.sgl | 120 +++++++++++++++++++++++++++++++++-----
 test/test-client-retry.sgl    | 521 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 646 insertions(+), 18 deletions(-)
Diff
README.mdmodified
@@ -211,8 +211,8 @@ are available in `(sigil quic packet retry)` and re-exported by the packet faça
211
`valid-retry-packet? original-id wire`. The encoder accepts `unused:` from 0 to 15;
212
the validator drops malformed peer packets. Both bound CIDs and datagram size.
213
The standardized public integrity tag does not authenticate a server or validate
−214
an address. Connection Retry handling, private token admission, version negotiation
−215
and connection-ID policy remain separate; no listener uses these helpers yet.
+214
an address. Private token admission, version negotiation and connection-ID policy
+215
remain separate; no server listener issues Retry yet.
216
217
`(sigil quic packet)` re-exports those helpers and provides
218
`seal-quic-packet material kind dcid scid number plaintext` with optional
@@ -316,8 +316,16 @@ output to three times received bytes, bounds deferred packets/CRYPTO/queues,
316
tracks directional keys and PN spaces, and confirms with HANDSHAKE_DONE.
317
It uses immediate ACKs, a conservative send window, bounded fixed-base PTO
318
backoff and fresh-PN frame retransmission, rather than full RFC 9002 recovery.
−319
Handshake timeout defaults to 10 seconds. Retry, VN, key updates, migration and
−320
connection-ID rotation are not implemented. Stream ownership/flow control and
+319
Handshake timeout defaults to 10 seconds. A client accepts one valid routed Retry
+320
after sending its first Initial and before processing a server Initial. It keeps
+321
the original ClientHello, client source CID and packet-number progression, changes
+322
Initial keys and destination CID, and includes the copied token on retransmissions.
+323
Retry tokens over 1024 bytes are dropped; the retained first ClientHello is capped
+324
at 64 KiB. CRYPTO fragmentation accounts for the token within 1200-byte Initials.
+325
Retry does not restart the handshake deadline. The first accepted server Initial
+326
binds the original, server Initial and Retry source IDs to the TLS transport checks.
+327
Server Retry/token admission, VN, key updates, migration and connection-ID rotation
+328
are not implemented. Stream ownership/flow control and
329
path/CID policy still belong to the layers above this primitive. No public
330
listener is provided, and independent security review is still required.
331
scripts/native-tls-tests.mjsmodified
@@ -22,6 +22,7 @@ const files = [
22
'test-reassembly.sgl',
23
'test-packet.sgl',
24
'test-retry-packet.sgl',
+25
'test-client-retry.sgl',
26
'test-connection-space.sgl',
27
'test-connection.sgl',
28
'test-aead-limits.sgl',
@@ -68,7 +69,8 @@ const certificatePolicy = process.argv.includes('--certificate-policy');
69
const retryPolicy = process.argv.includes('--retry-policy');
70
const earlyPackets = process.argv.includes('--early-packets');
71
const retryPacket = process.argv.includes('--retry-packet');
−71
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket].filter(Boolean).length > 1) {
+72
const clientRetry = process.argv.includes('--client-retry');
+73
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry].filter(Boolean).length > 1) {
74
throw new Error('Select one focused test suite');
75
}
76
if (cleanupFaults) {
@@ -128,6 +130,9 @@ if (earlyPackets) {
130
if (retryPacket) {
131
files.splice(0, files.length, 'test-retry-packet.sgl');
132
}
+133
if (clientRetry) {
+134
files.splice(0, files.length, 'test-client-retry.sgl');
+135
}
136
const bodies = files.map(file => {
137
const text = readFileSync(join(root, 'test', file), 'utf8');
138
const boundary = text.indexOf('\n\n');
src/sigil/quic/connection.sglmodified
@@ -46,6 +46,9 @@
46
(local-id)
47
(issued-sequence default: 0 mutable: #t)
48
(original-id)
+49
(retry-id default: #f mutable: #t)
+50
(retry-token default: #u8() mutable: #t)
+51
(retry-hello default: #f mutable: #t)
52
(peer-initial-id default: #f mutable: #t)
53
(peer-id mutable: #t)
54
(levels)
@@ -276,7 +279,7 @@
279
(let ((header
280
(encode-packet-header level (quic-connection-peer-id connection)
281
(if (eq? level 'application) #u8() (quic-connection-local-id connection))
−279
#u8() 0 4 (+ (bytevector-length wire) 16)
+282
(initial-token connection level) 0 4 (+ (bytevector-length wire) 16)
283
length-width: (and (not (eq? level 'application)) 2))))
284
(<= (+ (bytevector-length header) (bytevector-length wire) 16) 1200)))
285
(error "QUIC connection: queued frame exceeds packet budget"))
@@ -296,6 +299,29 @@
299
(+ (connection-level-queue-bytes state) (bytevector-length wire)))
300
(set-connection-level-queue-count! state (+ 1 (connection-level-queue-count state)))))
301
+302
(define (initial-token connection level)
+303
(if (and (eq? level 'initial) (eq? (quic-role connection) 'client))
+304
(quic-connection-retry-token connection)
+305
#u8()))
+306
+307
;; Leave room for the largest CRYPTO offset/length encoding, including
+308
;; the Retry token in every size check and eventual protected header.
+309
(define (queue-crypto! connection level offset data)
+310
(let* ((header (encode-packet-header level (quic-connection-peer-id connection)
+311
(if (eq? level 'application) #u8() (quic-connection-local-id connection))
+312
(initial-token connection level) 0 4 16
+313
length-width: (and (not (eq? level 'application)) 2)))
+314
(limit (min 900 (- 1200 (bytevector-length header) 16 17))))
+315
(when (<= limit 0) (error "QUIC connection: no room for CRYPTO data"))
+316
(let loop ((position 0))
+317
(when (< position (bytevector-length data))
+318
(let ((end (min (+ position limit) (bytevector-length data))))
+319
(queue-frame! connection level
+320
(make-quic-frame 6
+321
(list (cons 'offset (+ offset position))
+322
(cons 'data (bytevector-copy data position end)))))
+323
(loop end))))))
+324
325
(define (front-frame state)
326
(when (null? (connection-level-queue-front state))
327
(set-connection-level-queue-front! state (reverse (connection-level-queue-back state)))
@@ -350,13 +376,12 @@
376
(wipe! (cdr data))))
377
((crypto)
378
(let ((offset (connection-level-send-offset state)))
−353
(let loop ((position 0))
−354
(when (< position (bytevector-length data))
−355
(let ((end (min (+ position 900) (bytevector-length data))))
−356
(queue-frame! connection level
−357
(make-quic-frame 6
−358
(list (cons 'offset (+ offset position)) (cons 'data (bytevector-copy data position end)))))
−359
(loop end))))
+379
(when (and (eq? (quic-role connection) 'client) (eq? level 'initial)
+380
(= offset 0) (not (quic-connection-peer-initial-id connection)))
+381
(when (> (bytevector-length data) 65536)
+382
(error "QUIC connection: outgoing ClientHello exceeds Retry buffer"))
+383
(set-quic-connection-retry-hello! connection (bytevector-copy data)))
+384
(queue-crypto! connection level offset data)
385
(set-connection-level-send-offset! state (+ offset (bytevector-length data)))))
386
(else (error "QUIC connection: unexpected TLS event")))))
387
events))))
@@ -379,7 +404,10 @@
404
(set-connection-level-ack! state #f)
405
(set-connection-level-sent! state '())
406
(set-connection-level-deferred! state '())
−382
(set-connection-level-deferred-bytes! state 0)))
+407
(set-connection-level-deferred-bytes! state 0)
+408
(when (eq? level 'initial)
+409
(set-quic-connection-retry-hello! connection #f)
+410
(set-quic-connection-retry-token! connection #u8()))))
411
412
(define (in-flight connection)
413
(apply + (map (lambda (level) (packet-space-pending-bytes (connection-level-space (level-state connection level))))
@@ -388,7 +416,8 @@
416
(define (packet-plaintext connection level number frame)
417
(let* ((body (encode-frames (list frame) level (quic-role connection)))
418
(header (encode-packet-header level (quic-connection-peer-id connection)
−391
(if (eq? level 'application) #u8() (quic-connection-local-id connection)) #u8()
+419
(if (eq? level 'application) #u8() (quic-connection-local-id connection))
+420
(initial-token connection level)
421
number 4 (+ (bytevector-length body) 16)
422
length-width: (and (not (eq? level 'application)) 2)))
423
(size (+ (bytevector-length header) (bytevector-length body) 16)))
@@ -409,7 +438,8 @@
438
(let* ((state (level-state connection level)) (space (connection-level-space state))
439
(number (packet-space-next space)) (payload (packet-plaintext connection level number frame))
440
(header (encode-packet-header level (quic-connection-peer-id connection)
−412
(if (eq? level 'application) #u8() (quic-connection-local-id connection)) #u8()
+441
(if (eq? level 'application) #u8() (quic-connection-local-id connection))
+442
(initial-token connection level)
443
number 4 (+ (bytevector-length payload) 16)
444
length-width: (and (not (eq? level 'application)) 2)))
445
(size (+ (bytevector-length header) (bytevector-length payload) 16))
@@ -431,7 +461,8 @@
461
(let ((packet (seal-quic-packet (connection-level-write-keys state) level
462
(quic-connection-peer-id connection)
463
(if (eq? level 'application) #u8() (quic-connection-local-id connection))
−434
number payload length-width: (and (not (eq? level 'application)) 2))))
+464
number payload token: (initial-token connection level)
+465
length-width: (and (not (eq? level 'application)) 2))))
466
(set-connection-level-sealed! state (+ 1 (connection-level-sealed state)))
467
(packet-space-record-sent! space number size now eliciting?)
468
(when eliciting?
@@ -777,7 +808,8 @@
808
(set-quic-connection-peer-initial-id! connection (bytevector-copy (quic-header-source-id header)))
809
(set-quic-connection-peer-id! connection (bytevector-copy (quic-header-source-id header)))
810
(tls-bind-peer! (quic-connection-tls connection) (quic-connection-original-id connection)
−780
(quic-header-source-id header) #f))
+811
(quic-header-source-id header) (quic-connection-retry-id connection))
+812
(set-quic-connection-retry-hello! connection #f))
813
(when (and (eq? (quic-role connection) 'server) (eq? level 'handshake))
814
(set-quic-connection-validated?! connection #t)
815
(discard-level! connection 'initial))
@@ -826,6 +858,66 @@
858
(set-quic-connection-sent-bytes! connection (+ (quic-connection-sent-bytes connection) size)))))
859
(quic-connection-close-packets connection))))))
860
+861
;; Retry has no packet number and is not an authenticated server flight.
+862
;; It neither binds TLS peer IDs nor extends the handshake/idle deadline.
+863
;; Its bounded token is copied into every subsequent client Initial.
+864
(define (receive-retry! connection datagram header)
+865
(let* ((state (level-state connection 'initial))
+866
(space (connection-level-space state))
+867
(hello (quic-connection-retry-hello connection)))
+868
(when (and (eq? (quic-role connection) 'client)
+869
(eq? (quic-connection-state connection) 'handshaking)
+870
(not (packet-space-discarded? space))
+871
(> (packet-space-next space) 0)
+872
hello (not (quic-connection-retry-id connection))
+873
(not (quic-connection-peer-initial-id connection))
+874
(bytes=? (quic-header-destination-id header) (quic-connection-local-id connection))
+875
(<= (bytevector-length (quic-header-token header)) 1024)
+876
(valid-retry-packet? (quic-connection-original-id connection)
+877
(bytevector-copy datagram (quic-header-start header) (quic-header-end header))))
+878
(let ((source (bytevector-copy (quic-header-source-id header)))
+879
(token (bytevector-copy (quic-header-token header)))
+880
(read #f) (write #f) (transferred? #f))
+881
(dynamic-wind
+882
(lambda () #t)
+883
(lambda ()
+884
;; Own both derivations before retiring the old key pair.
+885
(set! read (initial-keys source 'server))
+886
(clear-packet-secret! read)
+887
(set! write (initial-keys source 'client))
+888
(clear-packet-secret! write)
+889
(let ((old-read (connection-level-read-keys state))
+890
(old-write (connection-level-write-keys state)))
+891
(set-connection-level-read-keys! state #f)
+892
(set-connection-level-write-keys! state #f)
+893
(when old-read (discard-packet-keys! old-read))
+894
(when old-write (discard-packet-keys! old-write)))
+895
(set-connection-level-read-keys! state read)
+896
(set-connection-level-write-keys! state write)
+897
(set! transferred? #t)
+898
(set-quic-connection-retry-id! connection source)
+899
(set-quic-connection-peer-id! connection (bytevector-copy source))
+900
(set-quic-connection-retry-token! connection token)
+901
;; Retire old flights without resetting any PN or AEAD budget.
+902
(for-each
+903
(lambda (packet) (packet-space-retire! space (sent-packet-info-number packet)))
+904
(packet-space-pending space))
+905
(set-connection-level-sent! state '())
+906
(set-connection-level-queue-front! state '())
+907
(set-connection-level-queue-back! state '())
+908
(set-connection-level-queue-bytes! state 0)
+909
(set-connection-level-queue-count! state 0)
+910
(set-connection-level-ack! state #f)
+911
(set-connection-level-retries! state 0)
+912
(set-quic-connection-window! connection 12000)
+913
(set-quic-connection-threshold! connection #f)
+914
(set-quic-connection-probe-start! connection (quic-connection-now connection))
+915
(queue-crypto! connection 'initial 0 hello))
+916
(lambda ()
+917
(unless transferred?
+918
(when read (discard-packet-keys! read))
+919
(when write (discard-packet-keys! write)))))))))
+920
921
(define (quic-receive! connection datagram now)
922
(update-time! connection now)
923
(unless (bytevector? datagram) (error "QUIC connection: expected datagram bytes"))
@@ -842,6 +934,8 @@
934
(let ((header (guard (exn (else #f))
935
(decode-packet-header datagram offset (bytevector-length (quic-connection-local-id connection))))))
936
(when header
+937
(when (eq? (quic-header-kind header) 'retry)
+938
(receive-retry! connection datagram header))
939
(let ((admitted? (and (memq (quic-header-kind header) '(initial handshake application))
940
(routed-header? connection header)
941
(not (and (eq? (quic-role connection) 'server)
test/test-client-retry.sgladded
@@ -0,0 +1,521 @@
+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))
+13
+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))
+19
+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))))
+24
+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)))))
+38
+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))
+42
+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)))))
+50
+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)))))
+75
+76
(define (cr-increasing? numbers floor)
+77
(or (null? numbers)
+78
(and (> (car numbers) floor) (cr-increasing? (cdr numbers) (car numbers)))))
+79
+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))))
+89
+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)))))
+98
+99
(define (cr-ack number)
+100
(make-quic-frame 2 (list (cons 'ranges (list (cons number number))) (cons 'delay 0))))
+101
+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))))
+106
+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)))
+110
+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))))
+115
+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)))))
+135
+136
(define (cr-peer-receive! peer packet now)
+137
(vector-set! peer 10 now)
+138
(quic-receive! (vector-ref peer 0) packet now))
+139
+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))
+144
+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)))))
+154
+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 '())))))
+177
+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)))
+184
+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)))))))))
+211
+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))
+221
+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)))))
+226
+227
+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))))))
+271
+272
+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))))))
+278
+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))))))
+321
+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))))
+332
+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)))

Showing the first 500 of 522 diff lines for this file. This diff is INCOMPLETE; read the file or clone the repository for the rest.