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