Commit1bf74dd6Recorded17 Oct 2026Repositorysigil-quic
Require an application handler before acknowledging stream input
Changed
README.md | 8 +++-
scripts/native-tls-tests.mjs | 7 ++-
src/sigil/quic/connection.sgl | 11 ++++-
test/test-handler-readiness.sgl | 373 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
4 files changed, 396 insertions(+), 3 deletions(-)Diff
README.mdmodified
@@ -303,7 +303,13 @@ listener is provided, and independent security review is still required.
303
Require `quic-complete?` for authenticated application delivery; 304
`quic-confirmed?` reports handshake confirmation. Attach an application-frame 305
handler with `quic-set-frame-handler!` and queue application frames with−306
`quic-send-frame!`. A frame exceeding the connection's 1,200-byte packet budget+306
`quic-send-frame!`. Before attachment, authenticated packets containing STREAM,+307
RESET_STREAM, STOP_SENDING or application flow-control frames are dropped whole,+308
without applying a prefix, recording their PN, acknowledging them or refreshing+309
idle activity. The peer can retransmit after attachment; no additional input+310
buffer is retained. Transport-only packets still drive handshake confirmation,+311
ACKs, path responses, CID validation and close without an application handler.+312
A frame exceeding the connection's 1,200-byte packet budget 313
(including its header and tag) raises synchronously before queue mutation; 314
previously queued work and the connection remain usable. On `quic-closed?`, 315
drain final close output and close the dedicated endpoint socket.scripts/native-tls-tests.mjsmodified
@@ -33,6 +33,7 @@ const files = [
33
'test-path-response.sgl', 34
'test-cid-zero.sgl', 35
'test-cid-sequence.sgl',+36
'test-handler-readiness.sgl', 37
'test-receive-bounds.sgl', 38
'test-handshake-probes.sgl', 39
'test-idle-timeout.sgl',@@ -52,7 +53,8 @@ const constructionCleanup = process.argv.includes('--construction-cleanup');
53
const pathResponse = process.argv.includes('--path-response'); 54
const cidZero = process.argv.includes('--cid-zero'); 55
const cidSequence = process.argv.includes('--cid-sequence');−55
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence].filter(Boolean).length > 1) {+56
const handlerReadiness = process.argv.includes('--handler-readiness');+57
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness].filter(Boolean).length > 1) { 58
throw new Error('Select one focused test suite'); 59
} 60
if (cleanupFaults) {@@ -88,6 +90,9 @@ if (cidZero) {
90
if (cidSequence) { 91
files.splice(0, files.length, 'test-cid-sequence.sgl'); 92
}+93
if (handlerReadiness) {+94
files.splice(0, files.length, 'test-handler-readiness.sgl');+95
} 96
const bodies = files.map(file => { 97
const text = readFileSync(join(root, 'test', file), 'utf8'); 98
const boundary = text.indexOf('\n\n');src/sigil/quic/connection.sglmodified
@@ -642,6 +642,10 @@
642
(tls-input! (quic-connection-tls connection) (connection-level-level state) bytes)) 643
(sync-tls! connection)))) 644
+645
(define (frame-needs-handler? frame)+646
(let ((type (quic-frame-type frame)))+647
(or (memv type '(4 5)) (<= 8 type 23))))+648
649
(define (apply-frame! connection state frame) 650
;; NEW IDs replace the outgoing destination CID; RETIRE refers to IDs 651
;; issued locally. Neither direction can switch to or from zero length.@@ -762,7 +766,12 @@
766
(status (packet-space-received-status space number))) 767
;; Tolerate short authenticated server Initials. The 768
;; server-side client-datagram minimum is checked earlier.−765
(when frames+769
;; Unowned application input cannot be retained. Drop the+770
;; whole packet before prefix effects, replay, ACK or idle+771
;; activity, so retransmission after attachment can work.+772
(when (and frames+773
(or (quic-connection-frame-handler connection)+774
(not (any frame-needs-handler? frames)))) 775
(when (and (eq? (quic-role connection) 'client) (eq? level 'initial) 776
(not (quic-connection-peer-initial-id connection))) 777
(set-quic-connection-peer-initial-id! connection (bytevector-copy (quic-header-source-id header)))test/test-handler-readiness.sgladded
@@ -0,0 +1,373 @@
+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 tls))+11
+12
;; A public TLS peer owns its keys. The target connection exposes no secrets.+13
;; Fields: connection/TLS, read/write keys, peer PNs/target largest PNs,+14
;; CRYPTO reassemblers/offsets, observed output/handler frames, time, peer role,+15
;; HANDSHAKE_DONE flag, target CID and peer CID.+16
(define owner-original #u8(1 2 3 4 5 6 7 8))+17
(define owner-client-id #u8(11 12 13 14 15 16 17 18))+18
(define owner-server-id #u8(21 22 23 24 25 26 27 28))+19
(define owner-data #u8(0 1 2 255))+20
(define owner-path-data #u8(0 1 0 3 4 0 6 255))+21
+22
(define (owner-index level)+23
(case level ((initial) 0) ((handshake) 1) ((application) 2)))+24
+25
(define (owner-wipe! bytes)+26
(when (bytevector? bytes)+27
(do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))+28
(bytevector-u8-set! bytes i 0))))+29
+30
(define (owner-build! peer level frames)+31
(let* ((index (owner-index level)) (numbers (vector-ref peer 4))+32
(number (vector-ref numbers index)) (role (vector-ref peer 11))+33
(destination (if (and (eq? role 'client) (eq? level 'initial)+34
(= -1 (vector-ref (vector-ref peer 5) 0)))+35
owner-original (vector-ref peer 13)))+36
(source (if (eq? level 'application) #u8() (vector-ref peer 14)))+37
(body (encode-frames frames level role))+38
(header (encode-packet-header level destination source #u8() number 4+39
(+ 16 (bytevector-length body))+40
length-width: (and (not (eq? level 'application)) 2)))+41
(payload (if (eq? level 'initial)+42
(bytes-append body+43
(make-bytevector (- 1200 16 (bytevector-length header) (bytevector-length body)) 0))+44
body)))+45
(vector-set! numbers index (+ number 1))+46
(cons number+47
(seal-quic-packet (vector-ref (vector-ref peer 3) index) level destination source+48
number payload length-width: (and (not (eq? level 'application)) 2)))))+49
+50
(define (owner-receive! peer packet now)+51
(vector-set! peer 10 now)+52
(quic-receive! (vector-ref peer 0) packet now))+53
+54
(define (owner-send! peer level frames)+55
(let ((packet (owner-build! peer level frames)))+56
(owner-receive! peer (cdr packet) (vector-ref peer 10))+57
packet))+58
+59
(define (owner-events! peer)+60
(for-each+61
(lambda (event)+62
(let* ((level (tls-event-level event)) (index (owner-index level))+63
(data (tls-event-data event)))+64
(case (tls-event-kind event)+65
((secrets)+66
(when (car data)+67
(vector-set! (vector-ref peer 2) index (traffic-keys (car data)))+68
(owner-wipe! (car data)))+69
(when (cdr data)+70
(vector-set! (vector-ref peer 3) index (traffic-keys (cdr data)))+71
(owner-wipe! (cdr data))))+72
((crypto)+73
(let* ((offsets (vector-ref peer 7)) (offset (vector-ref offsets index)))+74
(owner-send! peer level+75
(list (make-quic-frame 6 (list (cons 'offset offset) (cons 'data data)))))+76
(vector-set! offsets index (+ offset (bytevector-length data))))))))+77
(tls-take-events! (vector-ref peer 1)))+78
(when (and (eq? (vector-ref peer 11) 'server)+79
(tls-complete? (vector-ref peer 1)) (not (vector-ref peer 12)))+80
(vector-set! peer 12 #t)+81
(owner-send! peer 'application (list (make-quic-frame 30 '())))))+82
+83
(define (owner-read! peer packet ack?)+84
(let* ((header (decode-packet-header packet 0 8)) (level (quic-header-kind header))+85
(index (owner-index level)) (largest (vector-ref peer 5))+86
(opened (open-quic-packet packet 0 8 (vector-ref (vector-ref peer 2) index)+87
(vector-ref largest index))))+88
(unless opened (error "Readiness fixture target packet did not authenticate"))+89
(let* ((number (opened-quic-packet-number opened))+90
(frames (decode-frames (opened-quic-packet-payload opened) level+91
(quic-role (vector-ref peer 0)))))+92
(vector-set! largest index (max number (vector-ref largest index)))+93
(when (eq? level 'application)+94
(vector-set! peer 8 (cons (cons number frames) (vector-ref peer 8))))+95
(for-each+96
(lambda (frame)+97
(when (= (quic-frame-type frame) 6)+98
(let ((receiver (vector-ref (vector-ref peer 6) index)))+99
(reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))+100
(let ((bytes (reassembler-read! receiver)))+101
(when (> (bytevector-length bytes) 0)+102
(tls-input! (vector-ref peer 1) level bytes)+103
;; Install client-side Handshake keys before opening the+104
;; next packet in the server's already returned flight.+105
(owner-events! peer)))))) frames)+106
(when (and ack? (any frame-ack-eliciting? frames))+107
(owner-send! peer level+108
(list (make-quic-frame 2+109
(list (cons 'ranges (list (cons number number))) (cons 'delay 0)))))))))+110
+111
(define (owner-output! peer now (keys: (ack? #t)))+112
(vector-set! peer 10 now)+113
(let ((packets (quic-take-datagrams! (vector-ref peer 0) now)))+114
(for-each (lambda (packet) (owner-read! peer packet ack?)) packets)+115
packets))+116
+117
(define (owner-live? peer)+118
(let ((connection (vector-ref peer 0)))+119
(and (quic-confirmed? connection) (not (quic-closed? connection))+120
(not (quic-failure connection)))))+121
+122
(define (owner-with-peer role procedure)+123
(let ((key (ecdsa-p256-generate-keypair)) (connection #f) (engine #f) (peer #f))+124
(dynamic-wind+125
(lambda () #t)+126
(lambda ()+127
(let* ((client? (eq? role 'client)) (peer-role (if client? 'server 'client))+128
(target-id (if client? owner-client-id owner-server-id))+129
(peer-id (if client? owner-server-id owner-client-id))+130
(parameters+131
(append (stream-transport-parameters peer-role receive-window: 64)+132
(list (cons 1 (encode-varint 30000)) (cons 15 peer-id))+133
(if client? (list (cons 0 owner-original)) '()))))+134
(set! connection+135
(if client?+136
(make-quic-client (list #u8(113 49)) 'pinned-key+137
(stream-transport-parameters role receive-window: 64)+138
(make-tls-pin-verifier (cdr key)) local-id: target-id destination-id: owner-original)+139
(make-quic-server (list #u8(113 49))+140
(stream-transport-parameters role receive-window: 64)+141
(list #u8(48 1 0)) (car key) owner-original peer-id local-id: target-id)))+142
(set! engine+143
(if client?+144
(make-tls-server (list #u8(113 49)) parameters (list #u8(48 1 0)) (car key))+145
(make-tls-client (list #u8(113 49)) 'pinned-key parameters+146
(make-tls-pin-verifier (cdr key)))))+147
(set! peer+148
(vector connection engine+149
(vector (initial-keys owner-original role) #f #f)+150
(vector (initial-keys owner-original peer-role) #f #f)+151
(vector 0 0 0) (vector -1 -1 -1)+152
(vector (make-byte-reassembler 65536) (make-byte-reassembler 65536)+153
(make-byte-reassembler 65536))+154
(vector 0 0 0) '() '() 0 peer-role #f target-id peer-id))+155
(tls-bind-peer! engine owner-original target-id #f)+156
(if client?+157
(quic-start! connection 0)+158
(begin (tls-start! engine) (owner-events! peer)))+159
(do ((round 0 (+ round 1))) ((= round 12))+160
(owner-output! peer 0)+161
(owner-events! peer))+162
(unless (and (owner-live? peer) (tls-complete? engine)+163
(vector-ref (vector-ref peer 2) 2) (vector-ref (vector-ref peer 3) 2))+164
(error "Readiness fixture protected handshake did not complete"))+165
(vector-set! peer 8 '())+166
(procedure peer)))+167
(lambda ()+168
(when connection (quic-abort! connection))+169
(when engine (tls-abort! engine))+170
(when peer+171
(for-each+172
(lambda (keys) (when keys (discard-packet-keys! keys)))+173
(append (vector->list (vector-ref peer 2)) (vector->list (vector-ref peer 3))))+174
(for-each reassembler-close! (vector->list (vector-ref peer 6))))+175
(owner-wipe! (car key))))))+176
+177
(define (owner-attach! peer)+178
(quic-set-frame-handler! (vector-ref peer 0)+179
(lambda (frame) (vector-set! peer 9 (cons frame (vector-ref peer 9))))))+180
+181
(define (owner-frame type)+182
(make-quic-frame type+183
(cond+184
((<= 8 type 15)+185
(list (cons 'stream-id 0) (cons 'offset 0) (cons 'data owner-data)))+186
((= type 4) (list (cons 'stream-id 0) (cons 'error 0) (cons 'final-size 4)))+187
((= type 5) (list (cons 'stream-id 0) (cons 'error 0)))+188
((memv type '(17 21)) (list (cons 'stream-id 0) (cons 'maximum 64)))+189
(else (list (cons 'maximum (if (memv type '(18 19 22 23)) 1 64)))))))+190
+191
(define (owner-observed peer type)+192
(filter (lambda (frame) (= type (quic-frame-type frame)))+193
(apply append (map cdr (vector-ref peer 8)))))+194
+195
(define (owner-acked? peer number)+196
(any+197
(lambda (frame)+198
(any (lambda (range) (<= (car range) number (cdr range))) (frame-ref frame 'ranges)))+199
(append (owner-observed peer 2) (owner-observed peer 3))))+200
+201
(define (owner-late-stream! role)+202
(owner-with-peer role+203
(lambda (peer)+204
(let ((connection (vector-ref peer 0)))+205
;; The client initiates stream0 on the wire before a server response.+206
(when (eq? role 'client)+207
(quic-send-frame! connection+208
(make-quic-frame 14 (list (cons 'stream-id 0) (cons 'offset 0) (cons 'data #u8()))))+209
(owner-output! peer 0))+210
(let ((packet (owner-send! peer 'application (list (owner-frame 15)))))+211
(let* ((before (owner-output! peer 0)) (stream (make-quic-stream connection)))+212
(when (eq? role 'client)+213
(unless (= 1 (quic-stream-write! stream #u8(7)))+214
(error "Readiness fixture could not initialize the late client stream"))+215
(owner-output! peer 0))+216
(owner-receive! peer (cdr packet) 0)+217
(let ((received (quic-stream-read! stream)))+218
(owner-output! peer 0)+219
(owner-receive! peer (cdr packet) 0)+220
(owner-output! peer 0)+221
(assert-true+222
(and (null? before) (equal? owner-data received)+223
(= 0 (bytevector-length (quic-stream-read! stream)))+224
(quic-stream-eof? stream) (owner-live? peer)+225
(owner-acked? peer (car packet)))))))))))+226
+227
(define (owner-shapes! role)+228
(owner-with-peer role+229
(lambda (peer)+230
(let* ((types '(4 5 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23))+231
(packets (map (lambda (type) (owner-send! peer 'application (list (owner-frame type)))) types))+232
(before (owner-output! peer 0)))+233
(owner-attach! peer)+234
(for-each (lambda (packet) (owner-receive! peer (cdr packet) 0)) packets)+235
(owner-output! peer 0)+236
(for-each (lambda (packet) (owner-receive! peer (cdr packet) 0)) packets)+237
(owner-output! peer 0)+238
(assert-true+239
(and (null? before) (owner-live? peer)+240
(equal? types (map quic-frame-type (reverse (vector-ref peer 9))))+241
(not (any (lambda (packet) (not (owner-acked? peer (car packet)))) packets))))))))+242
+243
(define (owner-path-prefix! role)+244
(owner-with-peer role+245
(lambda (peer)+246
(let* ((packet (owner-send! peer 'application+247
(list (make-quic-frame 26 (list (cons 'data owner-path-data))) (owner-frame 10))))+248
(before (owner-output! peer 0)))+249
(owner-attach! peer)+250
(owner-receive! peer (cdr packet) 0)+251
(owner-output! peer 0)+252
(owner-receive! peer (cdr packet) 0)+253
(owner-output! peer 0)+254
(let ((responses (owner-observed peer 27)))+255
(assert-true+256
(and (null? before) (owner-live? peer) (= 1 (length (vector-ref peer 9)))+257
(= 1 (length responses)) (equal? owner-path-data (frame-ref (car responses) 'data))+258
(owner-acked? peer (car packet)))))))))+259
+260
(define (owner-ack-prefix! role)+261
(owner-with-peer role+262
(lambda (peer)+263
(let ((connection (vector-ref peer 0)))+264
(quic-send-frame! connection (make-quic-frame 1 '()))+265
(owner-output! peer 0 ack?: #f)+266
(let* ((number (caar (vector-ref peer 8)))+267
(packet (owner-send! peer 'application+268
(list (make-quic-frame 2+269
(list (cons 'ranges (list (cons number number))) (cons 'delay 0)))+270
(owner-frame 10))))+271
(before (owner-output! peer 0 ack?: #f)))+272
(quic-tick! connection 1000)+273
(owner-output! peer 1000 ack?: #f)+274
(let ((retransmitted? (= 2 (length (owner-observed peer 1)))))+275
(owner-attach! peer)+276
(owner-receive! peer (cdr packet) 1000)+277
(owner-output! peer 1000)+278
(owner-receive! peer (cdr packet) 1000)+279
(owner-output! peer 1000)+280
(assert-true+281
(and (null? before) retransmitted? (owner-live? peer)+282
(= 1 (length (vector-ref peer 9))) (owner-acked? peer (car packet))))))))))+283
+284
(define (owner-idle! role)+285
(owner-with-peer role+286
(lambda (peer)+287
(for-each+288
(lambda (now)+289
(let ((packet (owner-build! peer 'application (list (owner-frame 10)))))+290
(owner-receive! peer (cdr packet) now)))+291
'(10000 20000 29999))+292
(quic-tick! (vector-ref peer 0) 30000)+293
(assert-true+294
(and (quic-idle-expired? (vector-ref peer 0))+295
(null? (owner-output! peer 30000)))))))+296
+297
(define (owner-controls! role)+298
(owner-with-peer role+299
(lambda (peer)+300
(let ((ping (owner-send! peer 'application (list (make-quic-frame 1 '())))))+301
(owner-output! peer 0)+302
(owner-send! peer 'application (list (make-quic-frame 26 (list (cons 'data owner-path-data)))))+303
(owner-output! peer 0)+304
(let ((responses (owner-observed peer 27)))+305
(assert-true+306
(and (owner-live? peer) (owner-acked? peer (car ping))+307
(= 1 (length responses))+308
(equal? owner-path-data (frame-ref (car responses) 'data)))))))))+309
+310
(define (owner-attached! role forged?)+311
(owner-with-peer role+312
(lambda (peer)+313
(let ((packet (owner-build! peer 'application (list (owner-frame 16)))))+314
(when forged?+315
(owner-receive! peer (flip-byte (cdr packet) (- (bytevector-length (cdr packet)) 1)) 0))+316
(let ((before (owner-output! peer 0)))+317
(owner-attach! peer)+318
(owner-receive! peer (cdr packet) 0)+319
(owner-output! peer 0)+320
(owner-receive! peer (cdr packet) 0)+321
(owner-output! peer 0)+322
(assert-true+323
(and (null? before) (owner-live? peer) (= 1 (length (vector-ref peer 9)))+324
(= 16 (quic-frame-type (car (vector-ref peer 9))))+325
(owner-acked? peer (car packet)))))))))+326
+327
(define (owner-close! role)+328
(owner-with-peer role+329
(lambda (peer)+330
(owner-send! peer 'application+331
(list (make-quic-frame 29 (list (cons 'error 42) (cons 'reason #u8())))))+332
(let ((failure (quic-failure (vector-ref peer 0))))+333
(assert-true+334
(and (quic-closed? (vector-ref peer 0)) (quic-frame? failure)+335
(= 29 (quic-frame-type failure)) (= 42 (frame-ref failure 'error))))))))+336
+337
(test-group "Application handler admission before ACK"+338
(test "ql8-owner: client retains late stream retransmission and FIN"+339
(owner-late-stream! 'client))+340
(test "ql8-owner: server retains late stream retransmission and FIN"+341
(owner-late-stream! 'server))+342
(test "ql8-owner: client admits all application shapes only after attachment"+343
(owner-shapes! 'client))+344
(test "ql8-owner: server admits all application shapes only after attachment"+345
(owner-shapes! 'server))+346
(test "ql8-owner: client drops a mixed PATH prefix atomically"+347
(owner-path-prefix! 'client))+348
(test "ql8-owner: server drops a mixed PATH prefix atomically"+349
(owner-path-prefix! 'server))+350
(test "ql8-owner: client drops a mixed ACK prefix atomically"+351
(owner-ack-prefix! 'client))+352
(test "ql8-owner: server drops a mixed ACK prefix atomically"+353
(owner-ack-prefix! 'server))+354
(test "ql8-owner: client unowned input does not refresh idle lifetime"+355
(owner-idle! 'client))+356
(test "ql8-owner: server unowned input does not refresh idle lifetime"+357
(owner-idle! 'server))+358
(test "ql8-owner-control: client transport-only handshake and path stay usable"+359
(owner-controls! 'client))+360
(test "ql8-owner-control: server transport-only handshake and path stay usable"+361
(owner-controls! 'server))+362
(test "ql8-owner-control: client attached handler processes input once"+363
(owner-attached! 'client #f))+364
(test "ql8-owner-control: server attached handler processes input once"+365
(owner-attached! 'server #f))+366
(test "ql8-owner-control: client forged input leaves a valid replay eligible"+367
(owner-attached! 'client #t))+368
(test "ql8-owner-control: server forged input leaves a valid replay eligible"+369
(owner-attached! 'server #t))+370
(test "ql8-owner-control: client accepts application close without handler"+371
(owner-close! 'client))+372
(test "ql8-owner-control: server accepts application close without handler"+373
(owner-close! 'server)))