Commit9db55fe5Recorded18 Oct 2026Repositorysigil-quic

Pin bounded early packet replay and handshake confirmation rules

Changed
 scripts/inject-early-faults.mjs |  25 +++++++++++
 scripts/native-tls-tests.mjs    |   7 +++-
 test/test-early-packets.sgl     | 367 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 398 insertions(+), 1 deletion(-)
Diff
scripts/inject-early-faults.mjsadded
@@ -0,0 +1,25 @@
+1
// Remote-only sensitivity mutations for early protected packet tests.
+2
import { readFileSync, writeFileSync } from 'node:fs';
+3
+4
const [kind, input, output] = process.argv.slice(2);
+5
if (!['connection', 'frame'].includes(kind) || !input || !output || input === output) {
+6
throw new Error('Usage: inject-early-faults.mjs connection|frame INPUT OUTPUT');
+7
}
+8
let source = readFileSync(input, 'utf8');
+9
if (source.includes('TEST ONLY')) throw new Error('Expected canonical source');
+10
function replaceOnce(before, after) {
+11
if (source.split(before).length !== 2) throw new Error('Expected one canonical early-packet guard');
+12
source = source.replace(before, () => after);
+13
}
+14
if (kind === 'connection') {
+15
replaceOnce(` (unless (quic-complete? connection)
+16
(raise-quic-error 10 30 "QUIC HANDSHAKE_DONE before client Finished was sent"))`, ' #t');
+17
replaceOnce('(< (length (connection-level-deferred state)) 16)',
+18
'(< (length (connection-level-deferred state)) 32)');
+19
replaceOnce('(<= (+ (connection-level-deferred-bytes state) size) 65536)',
+20
'(<= (+ (connection-level-deferred-bytes state) size) 131072)');
+21
} else {
+22
replaceOnce("(when (and (eq? sender 'client) (memv type '(7 30)))",
+23
"(when (and (eq? sender 'client) (memv type '(7)))");
+24
}
+25
writeFileSync(output, ';;; TEST ONLY: early-packet guards weakened for sensitivity.\n' + source);
scripts/native-tls-tests.mjsmodified
@@ -39,6 +39,7 @@ const files = [
39
'test-cid-zero.sgl',
40
'test-cid-sequence.sgl',
41
'test-handler-readiness.sgl',
+42
'test-early-packets.sgl',
43
'test-receive-bounds.sgl',
44
'test-handshake-probes.sgl',
45
'test-idle-timeout.sgl',
@@ -64,7 +65,8 @@ const ticketValidation = process.argv.includes('--ticket-validation');
65
const negotiation = process.argv.includes('--negotiation');
66
const certificatePolicy = process.argv.includes('--certificate-policy');
67
const retryPolicy = process.argv.includes('--retry-policy');
−67
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy].filter(Boolean).length > 1) {
+68
const earlyPackets = process.argv.includes('--early-packets');
+69
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets].filter(Boolean).length > 1) {
70
throw new Error('Select one focused test suite');
71
}
72
if (cleanupFaults) {
@@ -118,6 +120,9 @@ if (certificatePolicy) {
120
if (retryPolicy) {
121
files.splice(0, files.length, 'test-tls-retry-policy.sgl');
122
}
+123
if (earlyPackets) {
+124
files.splice(0, files.length, 'test-early-packets.sgl');
+125
}
126
const bodies = files.map(file => {
127
const text = readFileSync(join(root, 'test', file), 'utf8');
128
const boundary = text.indexOf('\n\n');
test/test-early-packets.sgladded
@@ -0,0 +1,367 @@
+1
(import (sigil test)
+2
(sigil crypto)
+3
(sigil quic bytes)
+4
(sigil quic wire)
+5
(sigil quic frame)
+6
(sigil quic packet)
+7
(sigil quic reassembly)
+8
(sigil quic connection)
+9
(sigil quic stream)
+10
(sigil quic error)
+11
(sigil quic tls))
+12
+13
;; A public TLS peer owns its keys. The target connection exposes no secrets.
+14
;; Fields: connection/TLS, read/write keys, peer PNs/target largest PNs,
+15
;; CRYPTO reassemblers/offsets, observed output/handler frames, time, peer role,
+16
;; HANDSHAKE_DONE flag, target/peer CID, pause flag and held CRYPTO events.
+17
(define early-original #u8(1 2 3 4 5 6 7 8))
+18
(define early-client-id #u8(11 12 13 14 15 16 17 18))
+19
(define early-server-id #u8(21 22 23 24 25 26 27 28))
+20
+21
(define (early-index level)
+22
(case level ((initial) 0) ((handshake) 1) ((application) 2)))
+23
+24
(define (early-wipe! bytes)
+25
(when (bytevector? bytes)
+26
(do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
+27
(bytevector-u8-set! bytes i 0))))
+28
+29
(define (early-build! peer level frames)
+30
(let* ((index (early-index level)) (numbers (vector-ref peer 4))
+31
(number (vector-ref numbers index)) (role (vector-ref peer 11))
+32
(destination (if (and (eq? role 'client) (eq? level 'initial)
+33
(= -1 (vector-ref (vector-ref peer 5) 0)))
+34
early-original (vector-ref peer 13)))
+35
(source (if (eq? level 'application) #u8() (vector-ref peer 14)))
+36
(body (encode-frames frames level role))
+37
(header (encode-packet-header level destination source #u8() number 4
+38
(+ 16 (bytevector-length body))
+39
length-width: (and (not (eq? level 'application)) 2)))
+40
(payload (if (eq? level 'initial)
+41
(bytes-append body
+42
(make-bytevector (- 1200 16 (bytevector-length header) (bytevector-length body)) 0))
+43
body)))
+44
(vector-set! numbers index (+ number 1))
+45
(cons number
+46
(seal-quic-packet (vector-ref (vector-ref peer 3) index) level destination source
+47
number payload length-width: (and (not (eq? level 'application)) 2)))))
+48
+49
(define (early-receive! peer packet now)
+50
(vector-set! peer 10 now)
+51
(quic-receive! (vector-ref peer 0) packet now))
+52
+53
(define (early-send! peer level frames)
+54
(let ((packet (early-build! peer level frames)))
+55
(early-receive! peer (cdr packet) (vector-ref peer 10))
+56
packet))
+57
+58
(define (early-crypto! peer event)
+59
(let* ((level (tls-event-level event))
+60
(index (early-index level))
+61
(data (tls-event-data event))
+62
(offsets (vector-ref peer 7))
+63
(offset (vector-ref offsets index)))
+64
(early-send! peer level
+65
(list (make-quic-frame 6 (list (cons 'offset offset) (cons 'data data)))))
+66
(vector-set! offsets index (+ offset (bytevector-length data)))))
+67
+68
(define (early-events! peer)
+69
(for-each
+70
(lambda (event)
+71
(let* ((index (early-index (tls-event-level event)))
+72
(data (tls-event-data event)))
+73
(case (tls-event-kind event)
+74
((secrets)
+75
(when (car data)
+76
(vector-set! (vector-ref peer 2) index (traffic-keys (car data)))
+77
(early-wipe! (car data)))
+78
(when (cdr data)
+79
(vector-set! (vector-ref peer 3) index (traffic-keys (cdr data)))
+80
(early-wipe! (cdr data))))
+81
((crypto)
+82
(if (vector-ref peer 15)
+83
(vector-set! peer 16 (append (vector-ref peer 16) (list event)))
+84
(early-crypto! peer event))))))
+85
(tls-take-events! (vector-ref peer 1)))
+86
(when (and (not (vector-ref peer 15)) (eq? (vector-ref peer 11) 'server)
+87
(tls-complete? (vector-ref peer 1)) (not (vector-ref peer 12)))
+88
(vector-set! peer 12 #t)
+89
(early-send! peer 'application (list (make-quic-frame 30 '())))))
+90
+91
(define (early-flush! peer level)
+92
(let ((pending (vector-ref peer 16)))
+93
(vector-set! peer 16
+94
(filter (lambda (event) (not (eq? level (tls-event-level event)))) pending))
+95
(for-each (lambda (event) (when (eq? level (tls-event-level event)) (early-crypto! peer event)))
+96
pending)))
+97
+98
(define (early-read! peer packet ack?)
+99
(let* ((header (decode-packet-header packet 0 8)) (level (quic-header-kind header))
+100
(index (early-index level)) (largest (vector-ref peer 5))
+101
(opened (open-quic-packet packet 0 8 (vector-ref (vector-ref peer 2) index)
+102
(vector-ref largest index))))
+103
(unless opened (error "Early-packet fixture target packet did not authenticate"))
+104
(let* ((number (opened-quic-packet-number opened))
+105
(frames (decode-frames (opened-quic-packet-payload opened) level
+106
(quic-role (vector-ref peer 0)))))
+107
(vector-set! largest index (max number (vector-ref largest index)))
+108
(vector-set! peer 8 (cons (list level number frames) (vector-ref peer 8)))
+109
(for-each
+110
(lambda (frame)
+111
(when (= (quic-frame-type frame) 6)
+112
(let ((receiver (vector-ref (vector-ref peer 6) index)))
+113
(reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))
+114
(let ((bytes (reassembler-read! receiver)))
+115
(when (> (bytevector-length bytes) 0)
+116
(tls-input! (vector-ref peer 1) level bytes)
+117
;; Install client-side Handshake keys before opening the
+118
;; next packet in the server's already returned flight.
+119
(early-events! peer)))))) frames)
+120
(when (and ack? (any frame-ack-eliciting? frames))
+121
(early-send! peer level
+122
(list (make-quic-frame 2
+123
(list (cons 'ranges (list (cons number number))) (cons 'delay 0)))))))))
+124
+125
(define (early-output! peer now (keys: (ack? #t)))
+126
(vector-set! peer 10 now)
+127
(let ((packets (quic-take-datagrams! (vector-ref peer 0) now)))
+128
(for-each
+129
(lambda (packet)
+130
(let ((index (early-index (quic-header-kind (decode-packet-header packet 0 8)))))
+131
(when (vector-ref (vector-ref peer 2) index) (early-read! peer packet ack?))))
+132
packets)
+133
packets))
+134
+135
(define (early-live? peer)
+136
(let ((connection (vector-ref peer 0)))
+137
(and (quic-confirmed? connection) (not (quic-closed? connection))
+138
(not (quic-failure connection)))))
+139
+140
(define (early-with-peer role procedure (keys: (paused? #f)))
+141
(let ((key (ecdsa-p256-generate-keypair)) (connection #f) (engine #f) (peer #f))
+142
(dynamic-wind
+143
(lambda () #t)
+144
(lambda ()
+145
(let* ((client? (eq? role 'client)) (peer-role (if client? 'server 'client))
+146
(target-id (if client? early-client-id early-server-id))
+147
(peer-id (if client? early-server-id early-client-id))
+148
(parameters
+149
(append (stream-transport-parameters peer-role receive-window: 64)
+150
(list (cons 1 (encode-varint 30000)) (cons 15 peer-id))
+151
(if client? (list (cons 0 early-original)) '()))))
+152
(set! connection
+153
(if client?
+154
(make-quic-client (list #u8(113 49)) 'pinned-key
+155
(stream-transport-parameters role receive-window: 64)
+156
(make-tls-pin-verifier (cdr key)) local-id: target-id destination-id: early-original)
+157
(make-quic-server (list #u8(113 49))
+158
(stream-transport-parameters role receive-window: 64)
+159
(list #u8(48 1 0)) (car key) early-original peer-id local-id: target-id)))
+160
(set! engine
+161
(if client?
+162
(make-tls-server (list #u8(113 49)) parameters (list #u8(48 1 0)) (car key))
+163
(make-tls-client (list #u8(113 49)) 'pinned-key parameters
+164
(make-tls-pin-verifier (cdr key)))))
+165
(set! peer
+166
(vector connection engine
+167
(vector (initial-keys early-original role) #f #f)
+168
(vector (initial-keys early-original peer-role) #f #f)
+169
(vector 0 0 0) (vector -1 -1 -1)
+170
(vector (make-byte-reassembler 65536) (make-byte-reassembler 65536)
+171
(make-byte-reassembler 65536))
+172
(vector 0 0 0) '() '() 0 peer-role #f target-id peer-id paused? '()))
+173
(tls-bind-peer! engine early-original target-id #f)
+174
(if client?
+175
(quic-start! connection 0)
+176
(begin (tls-start! engine) (early-events! peer)))
+177
(if paused?
+178
(begin
+179
(unless client? (error "Early-packet fixture pauses only a target client"))
+180
(early-output! peer 0)
+181
(unless (and (not (quic-closed? connection))
+182
(not (quic-peer-parameters connection))
+183
(vector-ref (vector-ref peer 3) 1)
+184
(vector-ref (vector-ref peer 3) 2)
+185
(pair? (vector-ref peer 16)))
+186
(error "Early-packet fixture did not pause before ServerHello")))
+187
(begin
+188
(do ((round 0 (+ round 1))) ((= round 12))
+189
(early-output! peer 0)
+190
(early-events! peer))
+191
(unless (and (early-live? peer) (tls-complete? engine)
+192
(vector-ref (vector-ref peer 2) 2) (vector-ref (vector-ref peer 3) 2))
+193
(error "Early-packet fixture protected handshake did not complete"))))
+194
(vector-set! peer 8 '())
+195
(procedure peer)))
+196
(lambda ()
+197
(when connection (quic-abort! connection))
+198
(when engine (tls-abort! engine))
+199
(when peer
+200
(for-each
+201
(lambda (keys) (when keys (discard-packet-keys! keys)))
+202
(append (vector->list (vector-ref peer 2)) (vector->list (vector-ref peer 3))))
+203
(for-each reassembler-close! (vector->list (vector-ref peer 6))))
+204
(early-wipe! (car key))))))
+205
+206
(define (early-build-raw! peer level body (keys: (size #f)))
+207
(unless (memq level '(handshake application))
+208
(error "Early-packet fixture raw sender requires protected non-Initial keys"))
+209
(let* ((index (early-index level))
+210
(numbers (vector-ref peer 4))
+211
(number (vector-ref numbers index))
+212
(destination (vector-ref peer 13))
+213
(source (if (eq? level 'application) #u8() (vector-ref peer 14)))
+214
(width (and (eq? level 'handshake) 4))
+215
(header (encode-packet-header level destination source #u8() number 4
+216
(+ 16 (bytevector-length body)) length-width: width))
+217
(base (+ 16 (bytevector-length header) (bytevector-length body))))
+218
(when (and size (< size base)) (error "Early-packet fixture requested an undersized packet"))
+219
(vector-set! numbers index (+ number 1))
+220
(let ((packet
+221
(seal-quic-packet (vector-ref (vector-ref peer 3) index) level destination source number
+222
(if size (bytes-append body (make-bytevector (- size base) 0)) body)
+223
length-width: width)))
+224
(when (and size (not (= size (bytevector-length packet))))
+225
(error "Early-packet fixture missed its exact packet-size boundary"))
+226
(cons number packet))))
+227
+228
(define (early-observed peer level type)
+229
(filter (lambda (frame) (= type (quic-frame-type frame)))
+230
(apply append
+231
(map caddr (filter (lambda (entry) (eq? level (car entry))) (vector-ref peer 8))))))
+232
+233
(define (early-acked? peer level number)
+234
(any
+235
(lambda (frame)
+236
(any (lambda (range) (<= (car range) number (cdr range))) (frame-ref frame 'ranges)))
+237
(early-observed peer level 2)))
+238
+239
(define (early-prefix-acked? peer count)
+240
(let loop ((number 0))
+241
(or (= number count)
+242
(and (early-acked? peer 'handshake number) (loop (+ number 1))))))
+243
+244
(define (early-before-finished! peer)
+245
(early-flush! peer 'initial)
+246
(early-flush! peer 'handshake)
+247
(let ((connection (vector-ref peer 0)))
+248
(unless (and (not (quic-closed? connection))
+249
(pair? (quic-peer-parameters connection))
+250
(equal? #u8(113 49) (quic-negotiated-alpn connection))
+251
(not (quic-complete? connection)) (not (quic-confirmed? connection)))
+252
(error "Early-packet fixture did not pause between TLS completion and Finished commitment"))))
+253
+254
(define (early-finish! peer)
+255
(vector-set! peer 15 #f)
+256
(early-flush! peer 'initial)
+257
(early-flush! peer 'handshake)
+258
(do ((round 0 (+ round 1))) ((= round 12))
+259
(early-output! peer 0)
+260
(early-events! peer)))
+261
+262
(define (early-typed-close? peer)
+263
(let* ((connection (vector-ref peer 0)) (failure (quic-failure connection)))
+264
(and (quic-closed? connection) (quic-error? failure)
+265
(= 10 (quic-error-code failure)) (= 30 (quic-error-frame-type failure))
+266
(begin
+267
(early-output! peer 0 ack?: #f)
+268
(any
+269
(lambda (frame)
+270
(and (= 10 (frame-ref frame 'error)) (= 30 (frame-ref frame 'frame-type))))
+271
(apply append
+272
(map (lambda (level) (early-observed peer level 28)) '(initial handshake application))))))))
+273
+274
(define (early-queued! peer count (keys: (size #f)))
+275
(let loop ((number 0) (packets '()))
+276
(if (= number count)
+277
(reverse packets)
+278
(let ((packet (early-build-raw! peer 'handshake #u8(1) size: size)))
+279
(early-receive! peer (cdr packet) 0)
+280
(loop (+ number 1) (cons packet packets))))))
+281
+282
(test-group "HANDSHAKE_DONE and bounded early protected input"
+283
(test "ql13-early: HANDSHAKE_DONE before client Finished commitment is a protected violation"
+284
(early-with-peer 'client
+285
(lambda (peer)
+286
(early-before-finished! peer)
+287
(let ((packet (early-build-raw! peer 'application #u8(30))))
+288
(early-receive! peer (cdr packet) 0))
+289
(assert-true (early-typed-close? peer)))
+290
paused?: #t))
+291
(test "ql13-early: HANDSHAKE_DONE from a client is a protected violation"
+292
(early-with-peer 'server
+293
(lambda (peer)
+294
(let ((packet (early-build-raw! peer 'application #u8(30))))
+295
(early-receive! peer (cdr packet) 0))
+296
(assert-true (early-typed-close? peer)))))
+297
(test "ql13-early: deferred handshake input retains sixteen packets and drops the next"
+298
(early-with-peer 'client
+299
(lambda (peer)
+300
(let ((packets (early-queued! peer 17)))
+301
(early-flush! peer 'initial)
+302
(early-output! peer 0)
+303
(assert-true (and (early-prefix-acked? peer 16) (not (early-acked? peer 'handshake 16))))
+304
(early-receive! peer (cdr (list-ref packets 16)) 0)
+305
(early-output! peer 0)
+306
(assert-true (early-prefix-acked? peer 17))
+307
(early-finish! peer)
+308
(assert-true (early-live? peer))))
+309
paused?: #t))
+310
(test "ql13-early: deferred handshake input admits exactly sixty-four KiB then waits for retransmission"
+311
(early-with-peer 'client
+312
(lambda (peer)
+313
(early-queued! peer 2 size: 32768)
+314
(let ((overflow (early-build-raw! peer 'handshake #u8(1))))
+315
(early-receive! peer (cdr overflow) 0)
+316
(early-flush! peer 'initial)
+317
(early-output! peer 0)
+318
(assert-true (and (early-prefix-acked? peer 2) (not (early-acked? peer 'handshake 2))))
+319
(early-receive! peer (cdr overflow) 0)
+320
(early-output! peer 0)
+321
(assert-true (early-prefix-acked? peer 3))
+322
(early-finish! peer)
+323
(assert-true (early-live? peer))))
+324
paused?: #t))
+325
(test "ql13-early-control: early one-RTT PING is replayed and acknowledged after key installation"
+326
(early-with-peer 'client
+327
(lambda (peer)
+328
(let ((packet (early-build-raw! peer 'application #u8(1))))
+329
(early-receive! peer (cdr packet) 0)
+330
(assert-false (quic-closed? (vector-ref peer 0)))
+331
(early-finish! peer)
+332
(assert-true (early-live? peer))
+333
(assert-true (early-acked? peer 'application (car packet)))))
+334
paused?: #t))
+335
(test "ql13-early-control: deferred input owns its bytes before the caller mutates the tag"
+336
(early-with-peer 'client
+337
(lambda (peer)
+338
(let* ((packet (early-build-raw! peer 'handshake #u8(1)))
+339
(wire (cdr packet)) (last (- (bytevector-length wire) 1)))
+340
(early-receive! peer wire 0)
+341
(bytevector-u8-set! wire last (modulo (+ 1 (bytevector-u8-ref wire last)) 256))
+342
(early-flush! peer 'initial)
+343
(early-output! peer 0)
+344
(assert-true (early-acked? peer 'handshake (car packet)))
+345
(early-finish! peer)
+346
(assert-true (early-live? peer))))
+347
paused?: #t))
+348
(test "ql13-early-control: forged early HANDSHAKE_DONE neither confirms nor prevents later completion"
+349
(early-with-peer 'client
+350
(lambda (peer)
+351
(early-before-finished! peer)
+352
(let* ((packet (early-build-raw! peer 'application #u8(30)))
+353
(wire (cdr packet)) (last (- (bytevector-length wire) 1)))
+354
(bytevector-u8-set! wire last (modulo (+ 1 (bytevector-u8-ref wire last)) 256))
+355
(early-receive! peer wire 0)
+356
(assert-false (quic-closed? (vector-ref peer 0)))
+357
(assert-false (quic-confirmed? (vector-ref peer 0)))
+358
(early-finish! peer)
+359
(assert-true (early-live? peer))
+360
(assert-false (early-acked? peer 'application (car packet)))))
+361
paused?: #t))
+362
(test "ql13-early-control: ordinary HANDSHAKE_DONE confirms after client Finished"
+363
(early-with-peer 'client
+364
(lambda (peer)
+365
(assert-true (early-live? peer))
+366
(assert-true (tls-complete? (vector-ref peer 1)))
+367
(assert-true (quic-complete? (vector-ref peer 0)))))))