Commit6e7b68f6Recorded18 Oct 2026Repositorysigil-quic
Preserve original CID while deriving server Initial keys after Retry
Changed
README.md | 9 ++++++
scripts/native-tls-tests.mjs | 7 ++++-
src/sigil/quic/connection.sgl | 40 ++++++++++++++++++--------
test/test-server-retry.sgl | 252 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 296 insertions(+), 12 deletions(-)Diff
README.mdmodified
@@ -331,6 +331,15 @@ with `quic-receive! connection bytes now`, call `quic-tick! connection now`
331
and immediately send the ordered list from `quic-take-datagrams! connection now`. 332
Times are monotonic exact milliseconds. The endpoint owns one fixed peer address. 333
+334
After validating a Retry token, the caller can pass `retry-source-id:` to+335
`make-quic-server`. The original positional destination ID remains the first+336
client DCID; the keyword is the server's distinct Retry source CID. The server+337
derives Initial keys from the Retry CID and supplies both original and Retry+338
CID transport parameters. Retransmitted Initials route to the Retry or server+339
local CID. All supplied IDs are copied. This metadata does not validate an+340
address by itself: the caller owns token validation, and the constructor retains+341
the conservative amplification bound until authenticated Handshake traffic.+342
343
The connection pads Initial datagrams to 1200 bytes, limits unvalidated server 344
output to three times received bytes, bounds deferred packets/CRYPTO/queues, 345
tracks directional keys and PN spaces, and confirms with HANDSHAKE_DONE.scripts/native-tls-tests.mjsmodified
@@ -24,6 +24,7 @@ const files = [
24
'test-retry-packet.sgl', 25
'test-client-retry.sgl', 26
'test-retry-token.sgl',+27
'test-server-retry.sgl', 28
'test-connection-space.sgl', 29
'test-connection.sgl', 30
'test-aead-limits.sgl',@@ -72,7 +73,8 @@ const earlyPackets = process.argv.includes('--early-packets');
73
const retryPacket = process.argv.includes('--retry-packet'); 74
const clientRetry = process.argv.includes('--client-retry'); 75
const retryToken = process.argv.includes('--retry-token');−75
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken].filter(Boolean).length > 1) {+76
const serverRetry = process.argv.includes('--server-retry');+77
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry].filter(Boolean).length > 1) { 78
throw new Error('Select one focused test suite'); 79
} 80
if (cleanupFaults) {@@ -138,6 +140,9 @@ if (clientRetry) {
140
if (retryToken) { 141
files.splice(0, files.length, 'test-retry-token.sgl'); 142
}+143
if (serverRetry) {+144
files.splice(0, files.length, 'test-server-retry.sgl');+145
} 146
const bodies = files.map(file => { 147
const text = readFileSync(join(root, 'test', file), 'utf8'); 148
const boundary = text.indexOf('\n\n');src/sigil/quic/connection.sglmodified
@@ -115,7 +115,7 @@
115
(unless (and (bytevector? id) (<= minimum (bytevector-length id) 20)) 116
(error "QUIC connection: invalid connection ID"))) 117
−118
(define (parameters-with-ids parameters role original local)+118
(define (parameters-with-ids parameters role original local (keys: (retry-id #f))) 119
(unless (list? parameters) (error "QUIC connection: invalid local parameters")) 120
(for-each 121
(lambda (entry)@@ -124,7 +124,8 @@
124
(append parameters 125
(if (assoc 1 parameters) '() (list (cons 1 (encode-varint 30000)))) 126
(list (cons 15 (bytevector-copy local)))−127
(if (eq? role 'server) (list (cons 0 (bytevector-copy original))) '())))+127
(if (eq? role 'server) (list (cons 0 (bytevector-copy original))) '())+128
(if (and (eq? role 'server) retry-id) (list (cons 16 (bytevector-copy retry-id))) '()))) 129
130
(define (pto-duration state) 131
(* 1000 (expt 2 (min 5 (connection-level-retries state)))))@@ -186,13 +187,22 @@
187
material) 188
189
(define (install-initial! connection)−189
(let ((initial (level-state connection 'initial))−190
(local (quic-role connection))−191
(peer (if (eq? (quic-role connection) 'client) 'server 'client)))−192
(set-connection-level-read-keys! initial−193
(clear-packet-secret! (initial-keys (quic-connection-original-id connection) peer)))−194
(set-connection-level-write-keys! initial−195
(clear-packet-secret! (initial-keys (quic-connection-original-id connection) local)))))+190
(if (quic-connection-retry-id connection)+191
(let ((initial (level-state connection 'initial))+192
(destination (quic-connection-retry-id connection)))+193
;; Constructor cleanup owns each pair component before any later+194
;; derivation/clearing step can fail. Only servers start after Retry.+195
(set-connection-level-read-keys! initial (initial-keys destination 'client))+196
(clear-packet-secret! (connection-level-read-keys initial))+197
(set-connection-level-write-keys! initial (initial-keys destination 'server))+198
(clear-packet-secret! (connection-level-write-keys initial)))+199
(let ((initial (level-state connection 'initial))+200
(local (quic-role connection))+201
(peer (if (eq? (quic-role connection) 'client) 'server 'client)))+202
(set-connection-level-read-keys! initial+203
(clear-packet-secret! (initial-keys (quic-connection-original-id connection) peer)))+204
(set-connection-level-write-keys! initial+205
(clear-packet-secret! (initial-keys (quic-connection-original-id connection) local)))))) 206
207
;; Own the fresh TLS engine even if allocating its enclosing connection 208
;; fails. A connection transfers to its caller only after initialization.@@ -240,22 +250,29 @@
250
251
(define (make-quic-server protocols parameters certificates private-key original-id peer-id 252
(keys: (local-id (random-bytes 8)) (handshake-timeout 10000)+253
(retry-source-id #f) 254
(aead-packet-limit quic-aes-gcm-packet-limit) 255
(aead-failure-limit quic-aes-gcm-failure-limit))) 256
(check-id! original-id 8) 257
(check-id! peer-id 0) 258
(check-id! local-id 0)+259
(when retry-source-id+260
(check-id! retry-source-id 0)+261
(when (bytes=? original-id retry-source-id)+262
(error "QUIC connection: Retry source must differ from original destination"))) 263
(validate-aead-limits! aead-packet-limit aead-failure-limit) 264
(unless (and (integer? handshake-timeout) (exact? handshake-timeout) (<= 1 handshake-timeout 60000)) 265
(error "QUIC connection: invalid handshake timeout")) 266
(construct-connection 267
(lambda ()−253
(make-tls-server protocols (parameters-with-ids parameters 'server original-id local-id)+268
(make-tls-server protocols (parameters-with-ids parameters 'server original-id local-id+269
retry-id: retry-source-id) 270
certificates private-key)) 271
(lambda (engine) 272
(quic-connection role: 'server local-id: (bytevector-copy local-id) 273
issued-sequence: (if (assoc 13 parameters) 1 0) 274
original-id: (bytevector-copy original-id) peer-initial-id: (bytevector-copy peer-id)+275
retry-id: (and retry-source-id (bytevector-copy retry-source-id)) 276
peer-id: (bytevector-copy peer-id) idle-timeout: (transport-parameter-integer parameters 1 30000) 277
aead-packet-limit: aead-packet-limit aead-failure-limit: aead-failure-limit 278
levels: (connection-levels) deadline: handshake-timeout@@ -736,7 +753,8 @@
753
(> (bytevector-length (quic-header-token header)) 0))) 754
(or (bytes=? (quic-header-destination-id header) (quic-connection-local-id connection)) 755
(and (eq? (quic-role connection) 'server) (eq? (quic-header-kind header) 'initial)−739
(bytes=? (quic-header-destination-id header) (quic-connection-original-id connection))))+756
(bytes=? (quic-header-destination-id header)+757
(or (quic-connection-retry-id connection) (quic-connection-original-id connection))))) 758
(or (eq? (quic-header-kind header) 'application) 759
(not (quic-connection-peer-initial-id connection)) 760
(bytes=? (quic-header-source-id header) (quic-connection-peer-initial-id connection)))))test/test-server-retry.sgladded
@@ -0,0 +1,252 @@
+1
(import (sigil test)+2
(sigil crypto)+3
(sigil quic bytes)+4
(sigil quic frame)+5
(sigil quic packet)+6
(sigil quic connection)+7
(sigil quic tls))+8
+9
(define sr-original #u8(1 2 3 4 5 6 7 8))+10
(define sr-retry #u8(11 12 13 14 15 16 17 18))+11
(define sr-client #u8(21 22 23 24 25 26 27 28))+12
(define sr-server #u8(31 32 33 34 35 36 37 38))+13
(define sr-token #u8(91 92 93))+14
+15
(define (sr-wipe! bytes)+16
(do ((index 0 (+ index 1))) ((= index (bytevector-length bytes)))+17
(bytevector-u8-set! bytes index 0)))+18
+19
(define (sr-positive procedure)+20
(assert-true (guard (exn (else #f)) (procedure))))+21
+22
;; Fields: client/server, observed client/server output, original/retried+23
;; first flight, original/Retry/client/server IDs, token, primed flag.+24
(define (sr-with-pair procedure+25
(keys: (retry? #t) (defer? #f) (mutate? #f)+26
(original sr-original) (retry sr-retry)+27
(client-id sr-client) (server-id sr-server)+28
(certificate #u8(48 1 0))))+29
(let ((key (ecdsa-p256-generate-keypair)) (client #f) (server #f))+30
(dynamic-wind+31
(lambda () #t)+32
(lambda ()+33
(let ((original-copy (bytevector-copy original)) (retry-copy (bytevector-copy retry))+34
(client-copy (bytevector-copy client-id)) (server-copy (bytevector-copy server-id)))+35
(set! client+36
(make-quic-client (list #u8(113 49)) 'pinned-key '() (make-tls-pin-verifier (cdr key))+37
local-id: client-copy destination-id: original-copy defer-key-share?: defer?))+38
(quic-start! client 0)+39
(let* ((before (quic-take-datagrams! client 0))+40
(after+41
(if retry?+42
(begin+43
(quic-receive! client+44
(encode-retry-packet original-copy client-copy retry-copy sr-token) 1)+45
(quic-take-datagrams! client 1))+46
before)))+47
(set! server+48
(if retry?+49
(make-quic-server (list #u8(113 49)) '() (list certificate) (car key)+50
original-copy client-copy local-id: server-copy retry-source-id: retry-copy)+51
(make-quic-server (list #u8(113 49)) '() (list certificate) (car key)+52
original-copy client-copy local-id: server-copy)))+53
(when mutate?+54
(for-each+55
(lambda (bytes)+56
(when (> (bytevector-length bytes) 0) (bytevector-u8-set! bytes 0 0)))+57
(list original-copy retry-copy client-copy server-copy)))+58
(procedure (vector client server after '() before after+59
original retry client-id server-id sr-token #f)))))+60
(lambda ()+61
(when client (quic-abort! client))+62
(when server (quic-abort! server))+63
(sr-wipe! (car key))))))+64
+65
(define (sr-prime! pair now)+66
(unless (vector-ref pair 11)+67
(vector-set! pair 11 #t)+68
(for-each (lambda (packet) (quic-receive! (vector-ref pair 1) packet now)) (vector-ref pair 5))))+69
+70
(define (sr-output! pair side now)+71
(let ((packets (quic-take-datagrams! (vector-ref pair side) now)))+72
(vector-set! pair (+ side 2) (append (vector-ref pair (+ side 2)) packets))+73
packets))+74
+75
(define (sr-run! pair now (keys: (reverse? #f) (duplicate? #f)))+76
(sr-prime! pair now)+77
(do ((round 0 (+ round 1))) ((= round 12))+78
(do ((side 0 (+ side 1))) ((= side 2))+79
(let* ((packets (sr-output! pair side now))+80
(ordered (if reverse? (reverse packets) packets))+81
(target (vector-ref pair (- 1 side))))+82
(for-each+83
(lambda (packet)+84
(quic-receive! target packet now)+85
(when duplicate? (quic-receive! target packet now))) ordered)))))+86
+87
(define (sr-live? pair)+88
(every+89
(lambda (connection)+90
(and (quic-complete? connection) (quic-confirmed? connection)+91
(not (quic-closed? connection)) (not (quic-failure connection))))+92
(list (vector-ref pair 0) (vector-ref pair 1))))+93
+94
(define (sr-initials packets)+95
(filter (lambda (packet) (eq? 'initial (quic-header-kind (decode-packet-header packet 0 0)))) packets))+96
+97
(define (sr-open packet destination side)+98
(let ((keys (initial-keys destination side)))+99
(dynamic-wind+100
(lambda () #t)+101
(lambda () (guard (exn (else #f)) (open-quic-packet packet 0 0 keys -1)))+102
(lambda () (discard-packet-keys! keys)))))+103
+104
(define (sr-parameters? pair)+105
(let ((peer (quic-peer-parameters (vector-ref pair 0)))+106
(local (quic-local-parameters (vector-ref pair 1))))+107
(and peer+108
(every+109
(lambda (parameters)+110
(and (bytes=? (vector-ref pair 6) (cdr (assoc 0 parameters)))+111
(bytes=? (vector-ref pair 9) (cdr (assoc 15 parameters)))+112
(bytes=? (vector-ref pair 7) (cdr (assoc 16 parameters)))))+113
(list peer local))+114
(bytes=? (vector-ref pair 8) (quic-peer-id (vector-ref pair 1)))+115
(bytes=? (vector-ref pair 9) (quic-peer-id (vector-ref pair 0))))))+116
+117
(define (sr-client-initials? pair)+118
(let loop ((packets (sr-initials (vector-ref pair 2))) (largest 0))+119
(or (null? packets)+120
(let* ((packet (car packets))+121
(opened (sr-open packet (vector-ref pair 7) 'client))+122
(header (and opened (opened-quic-packet-header opened))))+123
(and opened (> (opened-quic-packet-number opened) largest)+124
(bytes=? (vector-ref pair 10) (quic-header-token header))+125
(bytes=? (vector-ref pair 8) (quic-header-source-id header))+126
(or (bytes=? (vector-ref pair 7) (quic-header-destination-id header))+127
(bytes=? (vector-ref pair 9) (quic-header-destination-id header)))+128
(loop (cdr packets) (opened-quic-packet-number opened)))))))+129
+130
(define (sr-with-key procedure)+131
(let ((key (ecdsa-p256-generate-keypair)))+132
(dynamic-wind (lambda () #t) (lambda () (procedure (car key)))+133
(lambda () (sr-wipe! (car key))))))+134
+135
(test-group "Retry-aware server key and CID setup"+136
(test "ql12-server-retry: distinct original Retry and server IDs complete full authentication"+137
(sr-positive+138
(lambda ()+139
(sr-with-pair+140
(lambda (pair)+141
(sr-run! pair 1)+142
(let ((packets (sr-initials (vector-ref pair 3))))+143
(and (sr-live? pair) (sr-parameters? pair) (pair? packets)+144
(every (lambda (packet) (and (sr-open packet sr-retry 'server)+145
(not (sr-open packet sr-original 'server)))) packets))))))))+146
(test "ql12-server-retry: TLS HelloRetryRequest preserves Retry token and client Initial PN progression"+147
(sr-positive+148
(lambda ()+149
(sr-with-pair+150
(lambda (pair)+151
(sr-run! pair 1)+152
(and (sr-live? pair) (sr-parameters? pair) (sr-client-initials? pair)+153
(> (length (sr-initials (vector-ref pair 2))) 1))) defer?: #t))))+154
(test "ql12-server-retry: lost first server flight retransmits under Retry keys and confirms"+155
(sr-positive+156
(lambda ()+157
(sr-with-pair+158
(lambda (pair)+159
(sr-prime! pair 1)+160
(let ((lost (sr-output! pair 1 1)))+161
(quic-tick! (vector-ref pair 0) 1001)+162
(quic-tick! (vector-ref pair 1) 1001)+163
(sr-run! pair 1001 reverse?: #t duplicate?: #t)+164
(and (pair? lost) (sr-live? pair) (sr-parameters? pair) (sr-client-initials? pair))))))))+165
(test "ql12-server-retry: zero-length Retry and client IDs remain bound through full TLS"+166
(sr-positive+167
(lambda ()+168
(sr-with-pair+169
(lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair)))+170
retry: #u8() client-id: #u8()))))+171
(test "ql12-server-retry: twenty-byte IDs fit protected flights and preserve transport bindings"+172
(sr-positive+173
(lambda ()+174
(sr-with-pair+175
(lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair)))+176
original: (make-bytevector 20 1) retry: (make-bytevector 20 2)+177
client-id: (make-bytevector 20 3) server-id: (make-bytevector 20 4)))))+178
(test "ql12-server-retry: caller ID mutation cannot change retained routes keys or parameters"+179
(sr-positive+180
(lambda ()+181
(sr-with-pair+182
(lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair))) mutate?: #t))))+183
(test "ql12-server-retry: authenticated Retry-key Initial to the old original CID is an unrouted drop"+184
(sr-positive+185
(lambda ()+186
(sr-with-pair+187
(lambda (pair)+188
(let* ((server (vector-ref pair 1))+189
(opened (sr-open (car (vector-ref pair 5)) sr-retry 'client))+190
(keys (initial-keys sr-retry 'client)))+191
(dynamic-wind+192
(lambda () #t)+193
(lambda ()+194
(let ((wrong-route (seal-quic-packet keys 'initial sr-original sr-client+195
(opened-quic-packet-number opened) (opened-quic-packet-payload opened)+196
token: sr-token length-width: 2)))+197
(quic-receive! server wrong-route 1)+198
(let ((dropped? (and (null? (quic-take-datagrams! server 1))+199
(not (quic-peer-parameters server)) (not (quic-failure server)))))+200
(sr-run! pair 1)+201
(and dropped? (sr-live? pair) (sr-parameters? pair)))))+202
(lambda () (discard-packet-keys! keys)))))))))+203
(test "ql12-server-retry: Retry metadata alone cannot bypass the conservative amplification bound"+204
(sr-positive+205
(lambda ()+206
(sr-with-pair+207
(lambda (pair)+208
(sr-prime! pair 1)+209
(let ((packets (sr-output! pair 1 1)))+210
(and (pair? packets) (not (quic-failure (vector-ref pair 1)))+211
(not (quic-confirmed? (vector-ref pair 1)))+212
(<= (apply + (map bytevector-length packets))+213
(* 3 (apply + (map bytevector-length (vector-ref pair 5))))))))+214
certificate: (make-bytevector 12000 48)))))+215
(test "ql12-server-control: no-Retry peers still complete without transport parameter sixteen"+216
(sr-with-pair+217
(lambda (pair)+218
(sr-run! pair 1)+219
(assert-true (sr-live? pair))+220
(assert-false (assoc 16 (quic-local-parameters (vector-ref pair 1))))+221
(assert-false (assoc 16 (quic-peer-parameters (vector-ref pair 0))))) retry?: #f))+222
(test "ql12-server-control: invalid or unchanged Retry source IDs are local errors"+223
(sr-with-key+224
(lambda (key)+225
(for-each+226
(lambda (bad)+227
(assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key+228
sr-original sr-client local-id: sr-server retry-source-id: bad)))+229
(list #t "id" (make-bytevector 21 0) sr-original)))))+230
(test "ql12-server-control: callers cannot inject the reserved original source or Retry parameters"+231
(sr-with-key+232
(lambda (key)+233
(for-each+234
(lambda (id)+235
(assert-error (make-quic-server (list #u8(113 49)) (list (cons id sr-retry))+236
(list #u8(48 1 0)) key sr-original sr-client local-id: sr-server))+237
(assert-error (make-quic-server (list #u8(113 49)) (list (cons id sr-retry))+238
(list #u8(48 1 0)) key sr-original sr-client+239
local-id: sr-server retry-source-id: sr-retry))) '(0 15 16)))))+240
(test "ql12-server-control: ordinary original and peer ID bounds still reject malformed arguments"+241
(sr-with-key+242
(lambda (key)+243
(for-each+244
(lambda (bad)+245
(assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key+246
bad sr-client local-id: sr-server)))+247
(list #f "id" #u8() (make-bytevector 7 0) (make-bytevector 21 0)))+248
(for-each+249
(lambda (bad)+250
(assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key+251
sr-original bad local-id: sr-server)))+252
(list #f "id" (make-bytevector 21 0)))))))