AtlatestRepositorysigil-quic

sigil-quic / tree / scriptssecret-retention-tests.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil quic bytes)
4 (sigil quic tls)
5 (sigil quic tls codec)
6 (sigil quic tests secret spy))
7
8;; Run explicitly against inject-retention-spy.mjs variants. Captured buffers
9;; belong to the engines; drained key-event copies belong to this fixture.
10(define (retention-wipe! bytes)
11 (when (bytevector? bytes)
12 (do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
13 (bytevector-u8-set! bytes i 0))))
15(define (retention-zero? bytes)
16 (let loop ((i 0))
17 (or (= i (bytevector-length bytes))
18 (and (= (bytevector-u8-ref bytes i) 0) (loop (+ i 1))))))
20(define (retention-with-pair procedure (keys: (defer? #f)))
21 (let ((key (ecdsa-p256-generate-keypair)) (client #f) (server #f) (pair #f))
22 (dynamic-wind
23 secret-spy-reset!
24 (lambda ()
25 (set! client
26 (make-tls-client (list #u8(113 49)) 'pinned-key (list (cons 15 #u8(1)))
27 (make-tls-pin-verifier (cdr key)) defer-key-share?: defer?))
28 (set! server
29 (make-tls-server (list #u8(113 49))
30 (list (cons 0 #u8(9)) (cons 15 #u8(2))) (list #u8(48 1 0)) (car key)))
31 (set! pair (vector client server '() '()))
32 (tls-bind-peer! client #u8(9) #u8(2) #f)
33 (tls-bind-peer! server #u8(9) #u8(1) #f)
34 (procedure pair))
35 (lambda ()
36 (when client (tls-abort! client))
37 (when server (tls-abort! server))
38 (when pair
39 (for-each
40 (lambda (event)
41 (when (eq? (tls-event-kind event) 'secrets)
42 (retention-wipe! (car (tls-event-data event)))
43 (retention-wipe! (cdr (tls-event-data event)))))
44 (append (vector-ref pair 2) (vector-ref pair 3))))
45 (for-each (lambda (entry) (retention-wipe! (vector-ref entry 1)))
46 (secret-spy-inputs))
47 (secret-spy-reset!)
48 (retention-wipe! (car key))))))
50(define (retention-owned tag)
51 (let loop ((entries (secret-spy-inputs)))
52 (when (null? entries) (error "Missing observed handshake secret" tag))
53 (let ((entry (car entries)))
54 (if (eq? tag (vector-ref entry 0))
55 (begin
56 (assert-true (vector-ref entry 2))
57 (assert-equal 32 (bytevector-length (vector-ref entry 1)))
58 (vector-ref entry 1))
59 (loop (cdr entries))))))
61(define (retention-take! pair side)
62 (let ((events (tls-take-events! (vector-ref pair side))))
63 (vector-set! pair (+ side 2) (append (vector-ref pair (+ side 2)) events))
64 events))
66(define (retention-feed! target event fragment?)
67 (when (eq? (tls-event-kind event) 'crypto)
68 (let ((wire (tls-event-data event)) (level (tls-event-level event)))
69 (if fragment?
70 (do ((i 0 (+ i 1))) ((= i (bytevector-length wire)))
71 (tls-input! target level (bytevector-copy wire i (+ i 1))))
72 (tls-input! target level wire)))))
74(define (retention-deliver! pair side fragment?)
75 (for-each
76 (lambda (event) (retention-feed! (vector-ref pair (- 1 side)) event fragment?))
77 (retention-take! pair side)))
79(define (retention-pause! pair defer? fragment?)
80 (tls-start! (vector-ref pair 0))
81 (retention-deliver! pair 0 fragment?)
82 (when defer?
83 (assert-equal 'client-hello (tls-state (vector-ref pair 1)))
84 (retention-deliver! pair 1 fragment?)
85 (retention-deliver! pair 0 fragment?))
86 (assert-equal 'client-finished (tls-state (vector-ref pair 1)))
87 (assert-false (tls-complete? (vector-ref pair 1)))
88 (assert-false (tls-peer-parameters (vector-ref pair 1))))
90(define (retention-finish! pair)
91 (do ((i 0 (+ i 1))) ((= i 4))
92 (retention-deliver! pair 1 #f)
93 (retention-deliver! pair 0 #f))
94 (assert-true (tls-complete? (vector-ref pair 0)))
95 (assert-true (tls-complete? (vector-ref pair 1)))
96 (assert-equal #u8(113 49) (tls-negotiated-alpn (vector-ref pair 0)))
97 (assert-equal #u8(1) (cdr (assoc 15 (tls-peer-parameters (vector-ref pair 1))))))
99(define (retention-crypto-type event)
100 (and (eq? (tls-event-kind event) 'crypto)
101 (car (decode-handshake (tls-event-data event)))))
103(define (retention-event-secret pair side direction)
104 (let loop ((events (vector-ref pair (+ side 2))))
105 (when (null? events) (error "Missing copied handshake key event"))
106 (let ((event (car events)))
107 (if (and (eq? (tls-event-kind event) 'secrets)
108 (eq? (tls-event-level event) 'handshake))
109 (if (eq? direction 'read) (car (tls-event-data event)) (cdr (tls-event-data event)))
110 (loop (cdr events))))))
112(test-group "Server handshake-secret retention"
113 (test "ql7-retention: server Finished releases its owned write secret"
114 (retention-with-pair
115 (lambda (pair)
116 (retention-pause! pair #f #f)
117 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
118 (retention-finish! pair))))
119 (test "ql7-retention: fragmented ClientHello releases the server write secret"
120 (retention-with-pair
121 (lambda (pair)
122 (retention-pause! pair #f #t)
123 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
124 (retention-finish! pair))))
125 (test "ql7-retention: HRR releases the server write secret before peer Finished"
126 (retention-with-pair
127 (lambda (pair)
128 (retention-pause! pair #t #t)
129 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
130 (retention-finish! pair)) defer?: #t))
131 (test "ql7-retention: early release preserves queued handshake key copies"
132 (retention-with-pair
133 (lambda (pair)
134 (retention-pause! pair #f #f)
135 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
136 (let ((flight (retention-take! pair 1)))
137 (for-each
138 (lambda (event)
139 (when (eqv? (retention-crypto-type event) 2)
140 (retention-feed! (vector-ref pair 0) event #f))) flight)
141 (retention-take! pair 0)
142 (let ((write (retention-event-secret pair 1 'write))
143 (read (retention-event-secret pair 0 'read)))
144 (assert-false (retention-zero? write))
145 (assert-equal write read))
146 (for-each
147 (lambda (event)
148 (unless (eqv? (retention-crypto-type event) 2)
149 (retention-feed! (vector-ref pair 0) event #f))) flight))
150 (retention-finish! pair))))
151 (test "ql7-retention: peer Finished remains mandatory after write-secret release"
152 (retention-with-pair
153 (lambda (pair)
154 (retention-pause! pair #f #f)
155 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
156 (retention-deliver! pair 1 #f)
157 (assert-false (retention-zero? (retention-owned 'server-client-hs)))
158 (let* ((events (retention-take! pair 0))
159 (finished (car (filter (lambda (event) (eqv? (retention-crypto-type event) 20)) events)))
160 (wire (tls-event-data finished))
161 (server (vector-ref pair 1))
162 (failure
163 (guard (exception (else exception))
164 (tls-input! server 'handshake (flip-byte wire (- (bytevector-length wire) 1)))
165 #f)))
166 (assert-equal "TLS: Finished verification failed" (and failure (error-object-message failure)))
167 (assert-true (tls-failed? server))
168 (assert-false (tls-peer-parameters server))
169 (assert-equal 0 (tls-retained-input-bytes server))
170 (assert-equal '() (tls-take-events! server))
171 (assert-true (retention-zero? (retention-owned 'server-client-hs)))))))
172 (test "ql7-retention-control: client server-secret survives until authentication"
173 (retention-with-pair
174 (lambda (pair)
175 (retention-pause! pair #f #f)
176 (let* ((flight (retention-take! pair 1))
177 (finished (car (filter (lambda (event) (eqv? (retention-crypto-type event) 20)) flight))))
178 (for-each
179 (lambda (event)
180 (unless (eqv? (retention-crypto-type event) 20)
181 (retention-feed! (vector-ref pair 0) event #f))) flight)
182 (assert-equal 'server-finished (tls-state (vector-ref pair 0)))
183 (assert-false (tls-complete? (vector-ref pair 0)))
184 (assert-false (retention-zero? (retention-owned 'client-server-hs)))
185 (retention-feed! (vector-ref pair 0) finished #f)
186 (assert-true (retention-zero? (retention-owned 'client-server-hs))))
187 (retention-finish! pair))))
188 (test "ql7-retention-control: server read-secret survives until peer Finished"
189 (retention-with-pair
190 (lambda (pair)
191 (retention-pause! pair #f #f)
192 (retention-deliver! pair 1 #f)
193 (assert-true (tls-complete? (vector-ref pair 0)))
194 (assert-false (retention-zero? (retention-owned 'server-client-hs)))
195 (retention-finish! pair)
196 (assert-true (retention-zero? (retention-owned 'server-client-hs))))))
197 (test "ql7-retention-control: abort clears owned secrets and drops queued events"
198 (retention-with-pair
199 (lambda (pair)
200 (retention-pause! pair #f #f)
201 (tls-abort! (vector-ref pair 1))
202 (tls-abort! (vector-ref pair 0))
203 (assert-true (retention-zero? (retention-owned 'server-server-hs)))
204 (assert-true (retention-zero? (retention-owned 'server-client-hs)))
205 (assert-equal '() (tls-take-events! (vector-ref pair 1)))
206 (assert-equal 0 (tls-retained-input-bytes (vector-ref pair 1)))))))