AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-reassembly.sgl

1(import (sigil test)
2 (sigil process)
3 (sigil crypto)
4 (sigil quic bytes)
5 (sigil quic wire)
6 (sigil quic frame)
7 (sigil quic reassembly)
8 (sigil quic tls)
9 (sigil quic vectors))
11(define (check-reassembly-bytes expected actual)
12 (assert-equal
13 (if (equal? (getenv "QUIC_REASSEMBLY_RED") "1") (flip-byte expected 0) expected) actual))
15(define (reassembly-level-index level)
16 (case level ((initial) 0) ((handshake) 1) ((application) 2)
17 (else (error "unexpected test level"))))
19;; Actual TLS events cross CRYPTO encode/decode, reversed half-message
20;; fragments and independent receive windows. Offset counters persist across
21;; flights, including CH1/CH2 and HRR/ServerHello in the Initial space.
22(define (relay-reassembled! sender target receivers offsets)
23 (for-each
24 (lambda (event)
25 (when (eq? (tls-event-kind event) 'crypto)
26 (let* ((level (tls-event-level event)) (index (reassembly-level-index level))
27 (receiver (vector-ref receivers index)) (offset (vector-ref offsets index))
28 (wire (tls-event-data event)) (middle (quotient (bytevector-length wire) 2)))
29 (for-each
30 (lambda (part)
31 (let* ((frame-wire (encode-frames
32 (list (make-quic-frame 6
33 (list (cons 'offset (+ offset (car part))) (cons 'data (cdr part)))))
34 level (tls-role sender)))
35 (frame (car (decode-frames frame-wire level (tls-role sender)))))
36 (reassembler-insert! receiver (frame-ref frame 'offset) (frame-ref frame 'data))))
37 (list (cons middle (bytevector-copy wire middle)) (cons 0 (bytevector-copy wire 0 middle))))
38 (vector-set! offsets index (+ offset (bytevector-length wire)))
39 (tls-input! target level (reassembler-read! receiver)))))
40 (tls-take-events! sender)))
42(test-group "bounded byte-offset reassembly"
43 (test "reassembly-control: reversed fragments yield contiguous bytes"
44 (let ((receiver (make-byte-reassembler 8)))
45 (reassembler-insert! receiver 4 #u8(5 6))
46 (reassembler-insert! receiver 0 #u8(1 2))
47 (reassembler-insert! receiver 2 #u8(3 4))
48 (check-reassembly-bytes #u8(1 2 3 4 5 6) (reassembler-read! receiver))))
49 (test "reassembly-control: matching overlap is delivered once"
50 (let ((receiver (make-byte-reassembler 8)))
51 (assert-equal 4 (reassembler-insert! receiver 2 #u8(3 4 5 6)))
52 (assert-equal 2 (reassembler-insert! receiver 0 #u8(1 2 3 4)))
53 (check-reassembly-bytes #u8(1 2 3 4 5 6) (reassembler-read! receiver))))
54 (test "reassembly-control: ring wrap preserves pending bytes"
55 (let ((receiver (make-byte-reassembler 4)))
56 (reassembler-insert! receiver 0 #u8(1 2 3 4))
57 (assert-equal #u8(1 2 3) (reassembler-read! receiver 3))
58 (reassembler-insert! receiver 4 #u8(5 6))
59 (check-reassembly-bytes #u8(4 5 6) (reassembler-read! receiver))))
60 (test "reassembly-control: published RFC9001 CRYPTO bytes reassemble"
61 (let* ((data (bytevector-copy (fixture 'quic-client-payload) 4))
62 (receiver (make-byte-reassembler 4096)))
63 (reassembler-insert! receiver 160 (bytevector-copy data 160))
64 (reassembler-insert! receiver 0 (bytevector-copy data 0 80))
65 (reassembler-insert! receiver 80 (bytevector-copy data 80 160))
66 (check-reassembly-bytes data (reassembler-read! receiver))))
67 (test "fresh windows and zero-length operations preserve counters"
68 (let ((receiver (make-byte-reassembler 8)))
69 (assert-equal 8 (reassembler-capacity receiver))
70 (assert-equal 0 (reassembler-offset receiver))
71 (assert-equal 0 (reassembler-highest receiver))
72 (assert-equal 0 (reassembler-buffered receiver))
73 (assert-equal #u8() (reassembler-read! receiver))
74 (assert-equal 0 (reassembler-insert! receiver quic-varint-maximum #u8()))
75 (assert-equal 0 (reassembler-highest receiver))))
76 (test "capacity budgets reject invalid exactness and oversized allocation"
77 (for-each (lambda (capacity) (assert-error (make-byte-reassembler capacity)))
78 (list 0 -1 1.0 #f (+ reassembly-capacity-limit 1))))
79 (test "gaps cannot be delivered and duplicate buffered bytes do not add credit"
80 (let ((receiver (make-byte-reassembler 8)))
81 (assert-equal 2 (reassembler-insert! receiver 2 #u8(3 4)))
82 (assert-equal 0 (reassembler-insert! receiver 2 #u8(3 4)))
83 (assert-equal 2 (reassembler-buffered receiver))
84 (assert-equal 4 (reassembler-highest receiver))
85 (assert-equal #u8() (reassembler-read! receiver))
86 (assert-equal 0 (reassembler-offset receiver))))
87 (test "conflicting overlap fails atomically before new prefix writes"
88 (let ((receiver (make-byte-reassembler 8)))
89 (reassembler-insert! receiver 4 #u8(5 6))
90 (assert-error (reassembler-insert! receiver 2 #u8(3 4 99 6)))
91 (assert-equal 2 (reassembler-buffered receiver))
92 (assert-equal 6 (reassembler-highest receiver))
93 (assert-equal #u8() (reassembler-read! receiver))
94 (reassembler-insert! receiver 0 #u8(1 2 3 4))
95 (assert-equal #u8(1 2 3 4 5 6) (reassembler-read! receiver))))
96 (test "already delivered prefixes are discarded while new suffixes are retained"
97 (let ((receiver (make-byte-reassembler 4)))
98 (reassembler-insert! receiver 0 #u8(1 2 3 4))
99 (reassembler-read! receiver)
100 (assert-equal 2 (reassembler-insert! receiver 2 #u8(99 99 5 6)))
101 (assert-equal #u8(5 6) (reassembler-read! receiver))
102 (assert-equal 0 (reassembler-insert! receiver 0 #u8(77 77)))
103 (assert-equal 6 (reassembler-offset receiver))
104 (assert-equal 6 (reassembler-highest receiver))))
105 (test "sparse offsets and window exhaustion allocate no offset-sized storage"
106 (let ((receiver (make-byte-reassembler 8)))
107 (assert-error (reassembler-insert! receiver 8 #u8(9)))
108 (assert-error (reassembler-insert! receiver (- quic-varint-maximum 1) #u8(9)))
109 (assert-equal 0 (reassembler-buffered receiver))
110 (assert-equal 0 (reassembler-highest receiver))
111 (assert-equal 1 (reassembler-insert! receiver 7 #u8(8)))
112 (assert-equal 8 (reassembler-highest receiver))))
113 (test "offset length and exactness checks precede mutation"
114 (let ((receiver (make-byte-reassembler 8)))
115 (for-each
116 (lambda (offset) (assert-error (reassembler-insert! receiver offset #u8(1))))
117 (list -1 1.0 #f (+ quic-varint-maximum 1) quic-varint-maximum))
118 (assert-error (reassembler-insert! receiver 0 #f))
119 (assert-error (reassembler-insert! receiver 0 (make-bytevector (+ reassembly-capacity-limit 1) 0)))
120 (assert-equal 0 (reassembler-buffered receiver))))
121 (test "limited reads advance only delivered bytes and retain following data"
122 (let ((receiver (make-byte-reassembler 4)))
123 (reassembler-insert! receiver 0 #u8(1 2 3 4))
124 (assert-equal #u8() (reassembler-read! receiver 0))
125 (assert-equal #u8(1 2) (reassembler-read! receiver 2))
126 (assert-equal 2 (reassembler-offset receiver))
127 (assert-equal 2 (reassembler-buffered receiver))
128 (assert-error (reassembler-read! receiver -1))
129 (assert-error (reassembler-read! receiver 5))
130 (assert-error (reassembler-read! receiver 1.0))
131 (assert-error (reassembler-read! receiver 1 2))
132 (assert-equal #u8(3 4) (reassembler-read! receiver))
133 (assert-equal 4 (reassembler-offset receiver))))
134 (test "advancing the window permits further offsets without moving pending data"
135 (let ((receiver (make-byte-reassembler 4)))
136 (reassembler-insert! receiver 3 #u8(4))
137 (reassembler-insert! receiver 0 #u8(1 2))
138 (assert-equal #u8(1 2) (reassembler-read! receiver))
139 (reassembler-insert! receiver 4 #u8(5 6))
140 (assert-equal #u8() (reassembler-read! receiver))
141 (reassembler-insert! receiver 2 #u8(3))
142 (assert-equal #u8(3 4 5 6) (reassembler-read! receiver))))
143 (test "insertion copies input and returned data does not alias pending data"
144 (let ((receiver (make-byte-reassembler 4)) (input (bytevector 1 2 3 4)))
145 (reassembler-insert! receiver 0 input)
146 (bytevector-u8-set! input 0 99)
147 (let ((prefix (reassembler-read! receiver 2)))
148 (assert-equal #u8(1 2) prefix)
149 (bytevector-u8-set! prefix 0 88))
150 (assert-equal #u8(3 4) (reassembler-read! receiver))))
151 (test "independent instances never share bytes or offsets"
152 (let ((initial (make-byte-reassembler 4)) (handshake (make-byte-reassembler 4)))
153 (reassembler-insert! initial 0 #u8(1 2))
154 (assert-equal #u8() (reassembler-read! handshake))
155 (reassembler-insert! handshake 0 #u8(3 4))
156 (assert-equal #u8(1 2) (reassembler-read! initial))
157 (assert-equal #u8(3 4) (reassembler-read! handshake))))
158 (test "close clears byte count is idempotent and rejects further operations"
159 (let ((receiver (make-byte-reassembler 4)))
160 (reassembler-insert! receiver 1 #u8(2 3))
161 (reassembler-close! receiver)
162 (reassembler-close! receiver)
163 (assert-true (reassembler-closed? receiver))
164 (assert-equal 0 (reassembler-buffered receiver))
165 (assert-error (reassembler-read! receiver))
166 (assert-error (reassembler-insert! receiver 0 #u8()))))
167 (test "CRYPTO windows support 4096 out-of-order bytes before a gap"
168 (let ((receiver (make-byte-reassembler 8192)))
169 (reassembler-insert! receiver 4096 (make-bytevector 4096 2))
170 (assert-equal 4096 (reassembler-buffered receiver))
171 (assert-equal #u8() (reassembler-read! receiver))
172 (reassembler-insert! receiver 0 (make-bytevector 4096 1))
173 (assert-equal (make-bytevector 4096 1) (reassembler-read! receiver 4096))
174 (assert-equal (make-bytevector 4096 2) (reassembler-read! receiver))))
175 (test "reordered windows remain correct across many ring wraps"
176 (let ((receiver (make-byte-reassembler 17)))
177 (do ((round 0 (+ round 1))) ((= round 100))
178 (let ((data (make-bytevector 16 (modulo round 256))) (base (* round 16)))
179 (reassembler-insert! receiver (+ base 8) (bytevector-copy data 8))
180 (reassembler-insert! receiver base (bytevector-copy data 0 8))
181 (assert-equal 0 (reassembler-insert! receiver (+ base 4) (bytevector-copy data 4 12)))
182 (assert-equal data (reassembler-read! receiver))
183 (assert-equal 0 (reassembler-buffered receiver))
184 (assert-equal (+ base 16) (reassembler-offset receiver))))))
185 (test "TLS HRR handshake completes through reordered CRYPTO frame bytes"
186 (let* ((key (ecdsa-p256-generate-keypair))
187 (client (make-tls-client (list #u8(113 49)) "reassembly.test" (list (cons 15 #u8(1)))
188 (lambda (chain name)
189 (and (equal? chain (list #u8(48 1 0))) (equal? name "reassembly.test") (cdr key)))
190 defer-key-share?: #t))
191 (server (make-tls-server (list #u8(113 49)) (list (cons 0 #u8(9)) (cons 15 #u8(2)))
192 (list #u8(48 1 0)) (car key)))
193 (client-input (vector (make-byte-reassembler 4096) (make-byte-reassembler 4096) (make-byte-reassembler 4096)))
194 (server-input (vector (make-byte-reassembler 4096) (make-byte-reassembler 4096) (make-byte-reassembler 4096)))
195 (client-offsets (vector 0 0 0)) (server-offsets (vector 0 0 0)))
196 (tls-bind-peer! client #u8(9) #u8(2) #f)
197 (tls-bind-peer! server #u8(9) #u8(1) #f)
198 (tls-start! client)
199 (do ((round 0 (+ round 1))) ((= round 4))
200 (relay-reassembled! client server server-input client-offsets)
201 (relay-reassembled! server client client-input server-offsets))
202 (assert-true (tls-complete? client))
203 (assert-true (tls-complete? server))
204 (assert-equal #u8(113 49) (tls-negotiated-alpn client))
205 (assert-equal (vector-ref client-offsets 0) (reassembler-offset (vector-ref server-input 0)))
206 (assert-equal (vector-ref server-offsets 1) (reassembler-offset (vector-ref client-input 1))))))