AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-server-retry.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil quic bytes)
4 (sigil quic frame)
5 (sigil quic packet)
6 (sigil quic connection)
7 (sigil quic tls))
8
9(define sr-original #u8(1 2 3 4 5 6 7 8))
10(define sr-retry #u8(11 12 13 14 15 16 17 18))
11(define sr-client #u8(21 22 23 24 25 26 27 28))
12(define sr-server #u8(31 32 33 34 35 36 37 38))
13(define sr-token #u8(91 92 93))
15(define (sr-wipe! bytes)
16 (do ((index 0 (+ index 1))) ((= index (bytevector-length bytes)))
17 (bytevector-u8-set! bytes index 0)))
19(define (sr-positive procedure)
20 (assert-true (guard (exn (else #f)) (procedure))))
22;; Fields: client/server, observed client/server output, original/retried
23;; first flight, original/Retry/client/server IDs, token, primed flag.
24(define (sr-with-pair procedure
25 (keys: (retry? #t) (defer? #f) (mutate? #f)
26 (original sr-original) (retry sr-retry)
27 (client-id sr-client) (server-id sr-server)
28 (certificate #u8(48 1 0))))
29 (let ((key (ecdsa-p256-generate-keypair)) (client #f) (server #f))
30 (dynamic-wind
31 (lambda () #t)
32 (lambda ()
33 (let ((original-copy (bytevector-copy original)) (retry-copy (bytevector-copy retry))
34 (client-copy (bytevector-copy client-id)) (server-copy (bytevector-copy server-id)))
35 (set! client
36 (make-quic-client (list #u8(113 49)) 'pinned-key '() (make-tls-pin-verifier (cdr key))
37 local-id: client-copy destination-id: original-copy defer-key-share?: defer?))
38 (quic-start! client 0)
39 (let* ((before (quic-take-datagrams! client 0))
40 (after
41 (if retry?
42 (begin
43 (quic-receive! client
44 (encode-retry-packet original-copy client-copy retry-copy sr-token) 1)
45 (quic-take-datagrams! client 1))
46 before)))
47 (set! server
48 (if retry?
49 (make-quic-server (list #u8(113 49)) '() (list certificate) (car key)
50 original-copy client-copy local-id: server-copy retry-source-id: retry-copy)
51 (make-quic-server (list #u8(113 49)) '() (list certificate) (car key)
52 original-copy client-copy local-id: server-copy)))
53 (when mutate?
54 (for-each
55 (lambda (bytes)
56 (when (> (bytevector-length bytes) 0) (bytevector-u8-set! bytes 0 0)))
57 (list original-copy retry-copy client-copy server-copy)))
58 (procedure (vector client server after '() before after
59 original retry client-id server-id sr-token #f)))))
60 (lambda ()
61 (when client (quic-abort! client))
62 (when server (quic-abort! server))
63 (sr-wipe! (car key))))))
65(define (sr-prime! pair now)
66 (unless (vector-ref pair 11)
67 (vector-set! pair 11 #t)
68 (for-each (lambda (packet) (quic-receive! (vector-ref pair 1) packet now)) (vector-ref pair 5))))
70(define (sr-output! pair side now)
71 (let ((packets (quic-take-datagrams! (vector-ref pair side) now)))
72 (vector-set! pair (+ side 2) (append (vector-ref pair (+ side 2)) packets))
73 packets))
75(define (sr-run! pair now (keys: (reverse? #f) (duplicate? #f)))
76 (sr-prime! pair now)
77 (do ((round 0 (+ round 1))) ((= round 12))
78 (do ((side 0 (+ side 1))) ((= side 2))
79 (let* ((packets (sr-output! pair side now))
80 (ordered (if reverse? (reverse packets) packets))
81 (target (vector-ref pair (- 1 side))))
82 (for-each
83 (lambda (packet)
84 (quic-receive! target packet now)
85 (when duplicate? (quic-receive! target packet now))) ordered)))))
87(define (sr-live? pair)
88 (every
89 (lambda (connection)
90 (and (quic-complete? connection) (quic-confirmed? connection)
91 (not (quic-closed? connection)) (not (quic-failure connection))))
92 (list (vector-ref pair 0) (vector-ref pair 1))))
94(define (sr-initials packets)
95 (filter (lambda (packet) (eq? 'initial (quic-header-kind (decode-packet-header packet 0 0)))) packets))
97(define (sr-open packet destination side)
98 (let ((keys (initial-keys destination side)))
99 (dynamic-wind
100 (lambda () #t)
101 (lambda () (guard (exn (else #f)) (open-quic-packet packet 0 0 keys -1)))
102 (lambda () (discard-packet-keys! keys)))))
104(define (sr-parameters? pair)
105 (let ((peer (quic-peer-parameters (vector-ref pair 0)))
106 (local (quic-local-parameters (vector-ref pair 1))))
107 (and peer
108 (every
109 (lambda (parameters)
110 (and (bytes=? (vector-ref pair 6) (cdr (assoc 0 parameters)))
111 (bytes=? (vector-ref pair 9) (cdr (assoc 15 parameters)))
112 (bytes=? (vector-ref pair 7) (cdr (assoc 16 parameters)))))
113 (list peer local))
114 (bytes=? (vector-ref pair 8) (quic-peer-id (vector-ref pair 1)))
115 (bytes=? (vector-ref pair 9) (quic-peer-id (vector-ref pair 0))))))
117(define (sr-client-initials? pair)
118 (let loop ((packets (sr-initials (vector-ref pair 2))) (largest 0))
119 (or (null? packets)
120 (let* ((packet (car packets))
121 (opened (sr-open packet (vector-ref pair 7) 'client))
122 (header (and opened (opened-quic-packet-header opened))))
123 (and opened (> (opened-quic-packet-number opened) largest)
124 (bytes=? (vector-ref pair 10) (quic-header-token header))
125 (bytes=? (vector-ref pair 8) (quic-header-source-id header))
126 (or (bytes=? (vector-ref pair 7) (quic-header-destination-id header))
127 (bytes=? (vector-ref pair 9) (quic-header-destination-id header)))
128 (loop (cdr packets) (opened-quic-packet-number opened)))))))
130(define (sr-with-key procedure)
131 (let ((key (ecdsa-p256-generate-keypair)))
132 (dynamic-wind (lambda () #t) (lambda () (procedure (car key)))
133 (lambda () (sr-wipe! (car key))))))
135(test-group "Retry-aware server key and CID setup"
136 (test "ql12-server-retry: distinct original Retry and server IDs complete full authentication"
137 (sr-positive
138 (lambda ()
139 (sr-with-pair
140 (lambda (pair)
141 (sr-run! pair 1)
142 (let ((packets (sr-initials (vector-ref pair 3))))
143 (and (sr-live? pair) (sr-parameters? pair) (pair? packets)
144 (every (lambda (packet) (and (sr-open packet sr-retry 'server)
145 (not (sr-open packet sr-original 'server)))) packets))))))))
146 (test "ql12-server-retry: TLS HelloRetryRequest preserves Retry token and client Initial PN progression"
147 (sr-positive
148 (lambda ()
149 (sr-with-pair
150 (lambda (pair)
151 (sr-run! pair 1)
152 (and (sr-live? pair) (sr-parameters? pair) (sr-client-initials? pair)
153 (> (length (sr-initials (vector-ref pair 2))) 1))) defer?: #t))))
154 (test "ql12-server-retry: lost first server flight retransmits under Retry keys and confirms"
155 (sr-positive
156 (lambda ()
157 (sr-with-pair
158 (lambda (pair)
159 (sr-prime! pair 1)
160 (let ((lost (sr-output! pair 1 1)))
161 (quic-tick! (vector-ref pair 0) 1001)
162 (quic-tick! (vector-ref pair 1) 1001)
163 (sr-run! pair 1001 reverse?: #t duplicate?: #t)
164 (and (pair? lost) (sr-live? pair) (sr-parameters? pair) (sr-client-initials? pair))))))))
165 (test "ql12-server-retry: zero-length Retry and client IDs remain bound through full TLS"
166 (sr-positive
167 (lambda ()
168 (sr-with-pair
169 (lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair)))
170 retry: #u8() client-id: #u8()))))
171 (test "ql12-server-retry: twenty-byte IDs fit protected flights and preserve transport bindings"
172 (sr-positive
173 (lambda ()
174 (sr-with-pair
175 (lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair)))
176 original: (make-bytevector 20 1) retry: (make-bytevector 20 2)
177 client-id: (make-bytevector 20 3) server-id: (make-bytevector 20 4)))))
178 (test "ql12-server-retry: caller ID mutation cannot change retained routes keys or parameters"
179 (sr-positive
180 (lambda ()
181 (sr-with-pair
182 (lambda (pair) (sr-run! pair 1) (and (sr-live? pair) (sr-parameters? pair))) mutate?: #t))))
183 (test "ql12-server-retry: authenticated Retry-key Initial to the old original CID is an unrouted drop"
184 (sr-positive
185 (lambda ()
186 (sr-with-pair
187 (lambda (pair)
188 (let* ((server (vector-ref pair 1))
189 (opened (sr-open (car (vector-ref pair 5)) sr-retry 'client))
190 (keys (initial-keys sr-retry 'client)))
191 (dynamic-wind
192 (lambda () #t)
193 (lambda ()
194 (let ((wrong-route (seal-quic-packet keys 'initial sr-original sr-client
195 (opened-quic-packet-number opened) (opened-quic-packet-payload opened)
196 token: sr-token length-width: 2)))
197 (quic-receive! server wrong-route 1)
198 (let ((dropped? (and (null? (quic-take-datagrams! server 1))
199 (not (quic-peer-parameters server)) (not (quic-failure server)))))
200 (sr-run! pair 1)
201 (and dropped? (sr-live? pair) (sr-parameters? pair)))))
202 (lambda () (discard-packet-keys! keys)))))))))
203 (test "ql12-server-retry: Retry metadata alone cannot bypass the conservative amplification bound"
204 (sr-positive
205 (lambda ()
206 (sr-with-pair
207 (lambda (pair)
208 (sr-prime! pair 1)
209 (let ((packets (sr-output! pair 1 1)))
210 (and (pair? packets) (not (quic-failure (vector-ref pair 1)))
211 (not (quic-confirmed? (vector-ref pair 1)))
212 (<= (apply + (map bytevector-length packets))
213 (* 3 (apply + (map bytevector-length (vector-ref pair 5))))))))
214 certificate: (make-bytevector 12000 48)))))
215 (test "ql12-server-control: no-Retry peers still complete without transport parameter sixteen"
216 (sr-with-pair
217 (lambda (pair)
218 (sr-run! pair 1)
219 (assert-true (sr-live? pair))
220 (assert-false (assoc 16 (quic-local-parameters (vector-ref pair 1))))
221 (assert-false (assoc 16 (quic-peer-parameters (vector-ref pair 0))))) retry?: #f))
222 (test "ql12-server-control: invalid or unchanged Retry source IDs are local errors"
223 (sr-with-key
224 (lambda (key)
225 (for-each
226 (lambda (bad)
227 (assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key
228 sr-original sr-client local-id: sr-server retry-source-id: bad)))
229 (list #t "id" (make-bytevector 21 0) sr-original)))))
230 (test "ql12-server-control: callers cannot inject the reserved original source or Retry parameters"
231 (sr-with-key
232 (lambda (key)
233 (for-each
234 (lambda (id)
235 (assert-error (make-quic-server (list #u8(113 49)) (list (cons id sr-retry))
236 (list #u8(48 1 0)) key sr-original sr-client local-id: sr-server))
237 (assert-error (make-quic-server (list #u8(113 49)) (list (cons id sr-retry))
238 (list #u8(48 1 0)) key sr-original sr-client
239 local-id: sr-server retry-source-id: sr-retry))) '(0 15 16)))))
240 (test "ql12-server-control: ordinary original and peer ID bounds still reject malformed arguments"
241 (sr-with-key
242 (lambda (key)
243 (for-each
244 (lambda (bad)
245 (assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key
246 bad sr-client local-id: sr-server)))
247 (list #f "id" #u8() (make-bytevector 7 0) (make-bytevector 21 0)))
248 (for-each
249 (lambda (bad)
250 (assert-error (make-quic-server (list #u8(113 49)) '() (list #u8(48 1 0)) key
251 sr-original bad local-id: sr-server)))
252 (list #f "id" (make-bytevector 21 0)))))))