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)))))))