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