AtlatestRepositorysigil-quic

sigil-quic / tree / scriptsfactory-cleanup-tests.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil quic bytes)
4 (sigil quic packet)
5 (sigil quic tests factory spy))
6
7;; Explicit remote instrumented suite. Teardown runs after every assertion,
8;; including failed baseline ones; no captured secret bytes are copied.
9(define (factory-cleanup-zero? bytes)
10 (let loop ((i 0))
11 (or (= i (bytevector-length bytes))
12 (and (= (bytevector-u8-ref bytes i) 0) (loop (+ i 1))))))
14(define (factory-cleanup-wipe! bytes)
15 (do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
16 (bytevector-u8-set! bytes i 0)))
18(define (factory-cleanup-with-state procedure)
19 (let ((owned '()))
20 (define (own value)
21 (set! owned (cons value owned))
22 value)
23 (dynamic-wind
24 factory-spy-reset!
25 (lambda () (procedure own))
26 (lambda ()
27 (for-each
28 (lambda (value)
29 (if (vector? value) (discard-packet-keys! value) (factory-cleanup-wipe! value))) owned)
30 (for-each (lambda (entry) (factory-cleanup-wipe! (vector-ref entry 1)))
31 (factory-spy-records))
32 (factory-spy-reset!)))))
34(define (factory-cleanup-find kind)
35 (filter (lambda (entry) (string=? kind (vector-ref entry 0))) (factory-spy-records)))
37(define (factory-cleanup-entries expected)
38 (let ((entries (factory-spy-records)))
39 (assert-equal (length expected) (length entries))
40 (for-each (lambda (kind) (assert-equal 1 (length (factory-cleanup-find kind)))) expected)
41 (for-each
42 (lambda (entry)
43 (assert-true (vector-ref entry 2))
44 (assert-equal
45 (cond
46 ((member (vector-ref entry 0) '("initial root" "client in" "server in" "quic ku" "copy secret")) 32)
47 ((string=? (vector-ref entry 0) "quic iv") 12)
48 (else 16))
49 (bytevector-length (vector-ref entry 1)))) entries)
50 entries))
52(define (factory-cleanup-all-zero? entries)
53 (let loop ((remaining entries))
54 (or (null? remaining)
55 (and (factory-cleanup-zero? (vector-ref (car remaining) 1))
56 (loop (cdr remaining))))))
58(define (factory-cleanup-failure! operation mode)
59 (factory-spy-fail! mode)
60 (let ((failure (guard (exception (else exception)) (operation) #f)))
61 (assert-true (error-object? failure))
62 (assert-equal "QL7 injected factory failure" (error-object-message failure))
63 (assert-equal (list mode) (error-object-irritants failure))))
65(define (factory-cleanup-initial! side mode)
66 (factory-cleanup-with-state
67 (lambda (own)
68 (let* ((id #u8(10 11 12 13 14 15 16 17))
69 (before (own (bytevector-copy id)))
70 (label (if (eq? side 'client) "client in" "server in")))
71 (if mode
72 (factory-cleanup-failure! (lambda () (initial-keys id side)) mode)
73 (let* ((material (own (initial-keys id side)))
74 (wire (seal-quic-packet material 'initial #u8(1) #u8(2) 0 #u8(1)))
75 (opened (open-quic-packet wire 0 1 material -1)))
76 (assert-equal '(32 16 12 16) (map bytevector-length (vector->list material)))
77 (for-each (lambda (bytes) (assert-false (factory-cleanup-zero? bytes)))
78 (vector->list material))
79 (assert-true (opened-quic-packet? opened))
80 (assert-equal #u8(1) (opened-quic-packet-payload opened))))
81 (assert-equal before id)
82 (let* ((expected
83 (cond
84 ((not mode) (list "initial root" label "copy secret" "quic key" "quic iv" "quic hp"))
85 ((string=? mode label) '("initial root"))
86 (else (list "initial root" label "copy secret"))))
87 (entries (factory-cleanup-entries expected))
88 (temporary (if mode entries
89 (append (factory-cleanup-find "initial root") (factory-cleanup-find label)))))
90 (assert-true (factory-cleanup-all-zero? temporary)))))))
92(define (factory-cleanup-traffic! mode)
93 (factory-cleanup-with-state
94 (lambda (own)
95 (let* ((secret (own (make-bytevector 32 7))) (before (own (bytevector-copy secret)))
96 (expected
97 (cond
98 ((string=? mode "quic key") '("copy secret"))
99 ((string=? mode "quic iv") '("copy secret" "quic key"))
100 (else '("copy secret" "quic key" "quic iv")))))
101 (factory-cleanup-failure! (lambda () (traffic-keys secret)) mode)
102 (assert-equal before secret)
103 (assert-true (factory-cleanup-all-zero? (factory-cleanup-entries expected)))))))
105(define (factory-cleanup-update! mode)
106 (factory-cleanup-with-state
107 (lambda (own)
108 (let* ((secret (own (make-bytevector 32 7))) (material (own (traffic-keys secret)))
109 (before (map (lambda (bytes) (own (bytevector-copy bytes))) (vector->list material)))
110 (required
111 (cond
112 ((string=? mode "quic key") '("quic ku"))
113 ((string=? mode "quic iv") '("quic ku" "quic key"))
114 (else '("quic ku" "quic key" "quic iv")))))
115 (factory-spy-reset!)
116 (factory-cleanup-failure! (lambda () (next-traffic-keys material)) mode)
117 (assert-equal before (vector->list material))
118 (assert-equal (make-bytevector 32 7) secret)
119 ;; The shared transfer scope now copies the returned secret first;
120 ;; the baseline copies it only after all other operations succeed.
121 (assert-true (<= (length (factory-cleanup-find "copy secret")) 1))
122 (let ((expected (append required
123 (if (null? (factory-cleanup-find "copy secret")) '() '("copy secret")))))
124 (assert-true (factory-cleanup-all-zero? (factory-cleanup-entries expected))))))))
126(test-group "Packet-factory owned allocation cleanup"
127 (test "ql7-factory: client Initial root clears on return"
128 (factory-cleanup-initial! 'client #f))
129 (test "ql7-factory: server Initial root clears on return"
130 (factory-cleanup-initial! 'server #f))
131 (test "ql7-factory: client Initial expansion failure clears root"
132 (factory-cleanup-initial! 'client "client in"))
133 (test "ql7-factory: server Initial expansion failure clears root"
134 (factory-cleanup-initial! 'server "server in"))
135 (test "ql7-factory: client packet-key failure clears Initial intermediates"
136 (factory-cleanup-initial! 'client "quic key"))
137 (test "ql7-factory: server packet-key failure clears Initial intermediates"
138 (factory-cleanup-initial! 'server "quic key"))
139 (test "ql7-factory: key failure clears partial traffic material"
140 (factory-cleanup-traffic! "quic key"))
141 (test "ql7-factory: IV failure clears partial traffic material"
142 (factory-cleanup-traffic! "quic iv"))
143 (test "ql7-factory: HP failure clears partial traffic material"
144 (factory-cleanup-traffic! "quic hp"))
145 (test "ql7-factory-control: update key failure preserves cleanup and input ownership"
146 (factory-cleanup-update! "quic key"))
147 (test "ql7-factory-control: update IV failure preserves cleanup and input ownership"
148 (factory-cleanup-update! "quic iv"))
149 (test "ql7-factory-control: update HP-copy failure preserves cleanup and input ownership"
150 (factory-cleanup-update! "copy hp"))
151 (test "ql7-factory-control: standalone Initial extraction remains caller-owned"
152 (factory-cleanup-with-state
153 (lambda (own)
154 (let ((root (own (initial-secret #u8(10 11 12 13 14 15 16 17)))))
155 (factory-cleanup-entries '("initial root"))
156 (assert-equal 32 (bytevector-length root))
157 (assert-false (factory-cleanup-zero? root))))))
158 (test "ql7-factory-control: successful returned material and stable HP remain caller-owned"
159 (factory-cleanup-with-state
160 (lambda (own)
161 (let* ((secret (own (make-bytevector 32 7))) (material (own (traffic-keys secret)))
162 (hp (own (bytevector-copy (vector-ref material 3)))))
163 (factory-spy-reset!)
164 (let ((next (own (next-traffic-keys material))))
165 (factory-cleanup-entries '("quic ku" "copy secret" "quic key" "quic iv" "copy hp"))
166 (assert-true (factory-cleanup-zero? (vector-ref (car (factory-cleanup-find "quic ku")) 1)))
167 (assert-equal '(32 16 12 16) (map bytevector-length (vector->list next)))
168 (for-each (lambda (bytes) (assert-false (factory-cleanup-zero? bytes))) (vector->list next))
169 (assert-equal hp (vector-ref next 3))
170 (discard-packet-keys! material)
171 (assert-equal (make-bytevector 32 7) secret)
172 (assert-equal hp (vector-ref next 3))))))))