AtlatestRepositorysigil-quic

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

1(import (sigil test)
2 (sigil io)
3 (sigil process)
4 (sigil math)
5 (sigil crypto)
6 (sigil quic bytes)
7 (sigil quic wire)
8 (sigil quic retry token))
9
10(define rt-key (make-bytevector 32 17))
11(define rt-address #u8(127 0 0 1 31 144))
12(define rt-original #u8(1 2 3 4 5 6 7 8))
13(define rt-retry #u8(11 12 13 14 15 16 17 18))
14(define rt-client #u8(21 22 23 24 25 26 27 28))
16(define (rt-with-manager procedure (keys: (lifetime 10000) (key rt-key)))
17 (let ((manager (make-retry-token-manager lifetime: lifetime key: key)))
18 (dynamic-wind
19 (lambda () #t)
20 (lambda () (procedure manager))
21 (lambda () (close-retry-token-manager! manager)))))
23(define (rt-mint manager now)
24 (make-retry-token manager rt-address rt-original rt-retry rt-client now))
26(define (rt-open manager token now)
27 (validate-retry-token manager rt-address rt-retry rt-client token now))
29;; This test-side signer uses the documented private wire format and a supplied
30;; fixture key. It never reads the manager's private key or implementation.
31(define (rt-independent-tag body address retry client)
32 (hmac-sha256-bytes rt-key
33 (bytes-append (string->utf8 "sigil quic Retry token v1")
34 (bytevector (bytevector-length address)) address
35 (bytevector (bytevector-length retry)) retry
36 (bytevector (bytevector-length client)) client body)))
38(define (rt-sign body)
39 (bytes-append body (rt-independent-tag body rt-address rt-retry rt-client)))
41(test-group "Bounded private Retry address tokens"
42 (test "ql12-token-vector: independent HMAC covers purpose body address and both current CIDs"
43 (rt-with-manager
44 (lambda (manager)
45 (let* ((token (rt-mint manager 100))
46 (end (- (bytevector-length token) 32))
47 (expected (rt-independent-tag (bytevector-copy token 0 end) rt-address rt-retry rt-client)))
48 (assert-true
49 (bytes=? (if (equal? "1" (getenv "QUIC_RETRY_TOKEN_RED")) (flip-byte expected 0) expected)
50 (bytevector-copy token end)))))))
51 (test "ql12-token-control: exact version timestamp and original-ID format round trips"
52 (rt-with-manager
53 (lambda (manager)
54 (let ((token (rt-mint manager 16909060)))
55 (assert-equal 67 (bytevector-length token))
56 (assert-equal #u8(82 1 0 0 0 0 1 2 3 4) (bytevector-copy token 0 10))
57 (assert-equal (bytes-append #u8(8) rt-original) (bytevector-copy token 26 35))
58 (assert-equal rt-original (rt-open manager token 16909060))))))
59 (test "ql12-token-control: every wire bit truncation and excessive peer length is a drop"
60 (rt-with-manager
61 (lambda (manager)
62 (let ((token (rt-mint manager 100)))
63 (do ((index 0 (+ index 1))) ((= index (bytevector-length token)))
64 (do ((bit 1 (* bit 2))) ((= bit 256))
65 (let* ((changed (bytevector-copy token)) (value (bytevector-u8-ref changed index)))
66 (bytevector-u8-set! changed index (bitwise-xor value bit))
67 (assert-false (rt-open manager changed 100)))))
68 (do ((end 0 (+ end 1))) ((= end (bytevector-length token)))
69 (assert-false (rt-open manager (bytevector-copy token 0 end) 100)))
70 (for-each (lambda (bad) (assert-false (rt-open manager bad 100)))
71 (list #f "token" (make-bytevector 1024 0) (bytes-append token #u8(0))))
72 (assert-equal rt-original (rt-open manager token 100))))))
73 (test "ql12-token-control: changed IP port Retry CID client CID or manager cannot validate"
74 (rt-with-manager
75 (lambda (manager)
76 (let ((token (rt-mint manager 100)))
77 (do ((index 0 (+ index 1))) ((= index (bytevector-length rt-address)))
78 (assert-false (validate-retry-token manager (flip-byte rt-address index) rt-retry rt-client token 100)))
79 (do ((index 0 (+ index 1))) ((= index 8))
80 (assert-false (validate-retry-token manager rt-address (flip-byte rt-retry index) rt-client token 100))
81 (assert-false (validate-retry-token manager rt-address rt-retry (flip-byte rt-client index) token 100)))
82 (rt-with-manager (lambda (other) (assert-false (rt-open other token 100))) key: #f)
83 (rt-with-manager (lambda (shared) (assert-equal rt-original (rt-open shared token 100))))))))
84 (test "ql12-token-control: future time and the exact expiry boundary reject"
85 (rt-with-manager
86 (lambda (manager)
87 (let ((token (rt-mint manager 100)))
88 (assert-false (rt-open manager token 99))
89 (assert-equal rt-original (rt-open manager token 100))
90 (assert-equal rt-original (rt-open manager token 109))
91 (assert-false (rt-open manager token 110))
92 (assert-false (rt-open manager token 111)))) lifetime: 10))
93 (test "ql12-token-control: zero and maximum context fields are length-delimited"
94 (rt-with-manager
95 (lambda (manager)
96 (for-each
97 (lambda (fields)
98 (let* ((address (car fields)) (original (cadr fields))
99 (retry (caddr fields)) (client (cadddr fields))
100 (token (make-retry-token manager address original retry client 0)))
101 (assert-equal original (validate-retry-token manager address retry client token 0))))
102 (list (list #u8(1) rt-original #u8() #u8())
103 (list (make-bytevector 64 1) (make-bytevector 20 2)
104 (make-bytevector 20 3) (make-bytevector 20 4))))
105 (let ((token (make-retry-token manager #u8(1) rt-original #u8(2 3) rt-client 0)))
106 (assert-false (validate-retry-token manager #u8(1 2) #u8(3) rt-client token 0))))))
107 (test "ql12-token-control: repeated issuance uses independent random nonce bytes"
108 (rt-with-manager
109 (lambda (manager)
110 (let ((first (rt-mint manager 100)) (second (rt-mint manager 100)))
111 (assert-false (bytes=? (bytevector-copy first 10 26) (bytevector-copy second 10 26)))
112 (assert-equal rt-original (rt-open manager first 100))
113 (assert-equal rt-original (rt-open manager second 100))))))
114 (test "ql12-token-control: supplied keys inputs and validated original IDs have separate ownership"
115 (let ((key (bytevector-copy rt-key)) (original (bytevector-copy rt-original)))
116 (rt-with-manager
117 (lambda (manager)
118 (let* ((token (make-retry-token manager rt-address original rt-retry rt-client 100))
119 (saved (bytevector-copy token)) (decoded (rt-open manager token 100)))
120 (assert-equal rt-original original)
121 (assert-equal rt-key key)
122 (bytevector-u8-set! key 0 0)
123 (bytevector-u8-set! original 0 0)
124 (bytevector-u8-set! decoded 0 0)
125 (assert-equal rt-original (rt-open manager token 100))
126 (assert-equal saved token)
127 (close-retry-token-manager! manager)
128 (assert-equal 0 (bytevector-u8-ref key 0))
129 (assert-equal 17 (bytevector-u8-ref key 1)))) key: key)))
130 (test "ql12-token-control: close is idempotent and all subsequent token operations raise"
131 (rt-with-manager
132 (lambda (manager)
133 (let ((token (rt-mint manager 100)))
134 (assert-true (retry-token-manager? manager))
135 (close-retry-token-manager! manager)
136 (close-retry-token-manager! manager)
137 (assert-error (rt-mint manager 100))
138 (assert-error (rt-open manager token 100))
139 (assert-error (close-retry-token-manager! #f))))))
140 (test "ql12-token-control: invalid local context or original IDs raise without closing the manager"
141 (rt-with-manager
142 (lambda (manager)
143 (let ((token (rt-mint manager 100)))
144 (for-each
145 (lambda (bad) (assert-error (make-retry-token manager rt-address bad rt-retry rt-client 100)))
146 (list #f "id" #u8() (make-bytevector 7 0) (make-bytevector 21 0) rt-retry))
147 (for-each
148 (lambda (bad)
149 (assert-error (make-retry-token manager rt-address rt-original bad rt-client 100))
150 (assert-error (validate-retry-token manager rt-address rt-retry bad token 100)))
151 (list #f "id" (make-bytevector 21 0)))
152 (for-each
153 (lambda (bad) (assert-error (validate-retry-token manager bad rt-retry rt-client token 100)))
154 (list #f "address" #u8() (make-bytevector 65 0)))
155 (for-each (lambda (bad) (assert-error (rt-open manager token bad)))
156 (list -1 1.5 #f (+ quic-varint-maximum 1)))
157 (assert-equal rt-original (rt-open manager token 100))))))
158 (test "ql12-token-control: manager rejects invalid keys and lifetimes before use"
159 (for-each (lambda (bad) (assert-error (make-retry-token-manager key: bad)))
160 (list "key" #u8() (make-bytevector 31 0) (make-bytevector 33 0)))
161 (for-each (lambda (bad) (assert-error (make-retry-token-manager lifetime: bad)))
162 (list #f 0 -1 1.5 60001))
163 (rt-with-manager
164 (lambda (manager)
165 (let ((token (rt-mint manager 0)))
166 (assert-equal rt-original (rt-open manager token 59999))
167 (assert-false (rt-open manager token 60000)))) lifetime: 60000))
168 (test "ql12-token-control: even independently authenticated forbidden bodies cannot validate"
169 (rt-with-manager
170 (lambda (manager)
171 (let* ((token (rt-mint manager 100)) (body (bytevector-copy token 0 35))
172 (same-source (bytes-append (bytevector-copy body 0 27) rt-retry))
173 (other-purpose (bytevector-copy body)) (future (bytevector-copy body)))
174 (bytevector-u8-set! other-purpose 0 78)
175 (bytevector-u8-set! future 2 255)
176 (for-each (lambda (bad) (assert-false (rt-open manager (rt-sign bad) 100)))
177 (list same-source other-purpose future
178 (bytes-append (bytevector-copy body 0 26) #u8(7) (make-bytevector 7 0))
179 (bytes-append (bytevector-copy body 0 26) #u8(21) (make-bytevector 21 0)))))))))