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.