AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-handler-readiness.sgl

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))
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))
22(define (owner-index level)
23 (case level ((initial) 0) ((handshake) 1) ((application) 2)))
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))))
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)))))
50(define (owner-receive! peer packet now)
51 (vector-set! peer 10 now)
52 (quic-receive! (vector-ref peer 0) packet now))
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))
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 '())))))
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)))))))))
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))
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)))))
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))))))
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))))))
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)))))))
191(define (owner-observed peer type)
192 (filter (lambda (frame) (= type (quic-frame-type frame)))
193 (apply append (map cdr (vector-ref peer 8)))))
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))))
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)))))))))))
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))))))))
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)))))))))
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))))))))))
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)))))))
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)))))))))
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)))))))))
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))))))))
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)))