AtlatestRepositorysigil-quic

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

1(import (sigil test)
2 (sigil process)
3 (sigil crypto)
4 (sigil math)
5 (sigil quic bytes)
6 (sigil quic packet))
7
8(define retry-test-original (hex->bytes "8394c8f03e515708"))
9(define retry-test-source (hex->bytes "f067a5502a4262b5"))
10(define retry-test-token (hex->bytes "746f6b656e"))
11(define retry-test-wire
12 (hex->bytes "ff000000010008f067a5502a4262b5746f6b656e04a265ba2eff4d829058fb3f0f2496ba"))
14(define (retry-test-encoded)
15 (encode-retry-packet retry-test-original #u8() retry-test-source retry-test-token unused: 15))
17(define (retry-test-vector! expected actual)
18 (assert-true
19 (bytes=?
20 (if (equal? "1" (getenv "QUIC_RETRY_VECTOR_RED")) (flip-byte expected 0) expected)
21 actual)))
23;; Independently sign a forbidden shape with the standardized public constants.
24;; A valid tag must not bypass Retry's source-ID rule.
25(define (retry-test-sign original unsigned)
26 (let ((sealed
27 (aes-128-gcm-encrypt (hex->bytes "be0c690b9f66575a1d766b54e368c84e")
28 (hex->bytes "461599d35d632bf2239825bb")
29 (bytes-append (bytevector (bytevector-length original)) original unsigned) #u8())))
30 (unless sealed (error "Retry fixture could not compute the independent tag"))
31 (bytes-append unsigned (cdr sealed))))
33(test-group "QUIC v1 Retry integrity and bounded framing"
34 (test "ql12-retry-vector: RFC9001 Appendix A4 complete Retry packet"
35 (retry-test-vector! retry-test-wire (retry-test-encoded)))
36 (test "ql12-retry-vector: RFC9001 Appendix A4 Retry integrity tag"
37 (let ((wire (retry-test-encoded)))
38 (retry-test-vector! (hex->bytes "04a265ba2eff4d829058fb3f0f2496ba")
39 (bytevector-copy wire (- (bytevector-length wire) 16)))))
40 (test "ql12-retry-control: literal published packet validates and parses independently"
41 (assert-true (valid-retry-packet? retry-test-original retry-test-wire))
42 (let ((header (decode-packet-header retry-test-wire 0 0)))
43 (assert-equal 'retry (quic-header-kind header))
44 (assert-equal 1 (quic-header-version header))
45 (assert-equal #u8() (quic-header-destination-id header))
46 (assert-equal retry-test-source (quic-header-source-id header))
47 (assert-equal retry-test-token (quic-header-token header))
48 (assert-equal #f (quic-header-pn-offset header))
49 (assert-equal (bytevector-length retry-test-wire) (quic-header-end header))))
50 (test "ql12-retry-control: every single-bit mutation of the published packet is rejected"
51 (do ((index 0 (+ index 1))) ((= index (bytevector-length retry-test-wire)))
52 (do ((bit 1 (* bit 2))) ((= bit 256))
53 (let ((wire (bytevector-copy retry-test-wire)))
54 ;; Toggle using integer arithmetic so no mutation shares storage.
55 (let ((value (bytevector-u8-ref wire index)))
56 (bytevector-u8-set! wire index
57 (if (= 0 (modulo (quotient value bit) 2)) (+ value bit) (- value bit))))
58 (assert-false (valid-retry-packet? retry-test-original wire))))))
59 (test "ql12-retry-control: original destination bytes and length bind the integrity tag"
60 (do ((index 0 (+ index 1))) ((= index (bytevector-length retry-test-original)))
61 (assert-false (valid-retry-packet? (flip-byte retry-test-original index) retry-test-wire)))
62 (assert-false (valid-retry-packet? #u8() retry-test-wire))
63 (assert-false (valid-retry-packet? (bytes-append retry-test-original #u8(0)) retry-test-wire)))
64 (test "ql12-retry-control: all sixteen unused fields are accepted only with matching tags"
65 (do ((unused 0 (+ unused 1))) ((= unused 16))
66 (let ((wire (encode-retry-packet retry-test-original #u8() retry-test-source #u8(1) unused: unused)))
67 (assert-equal (+ 240 unused) (quic-header-first (decode-packet-header wire 0 0)))
68 (assert-true (valid-retry-packet? retry-test-original wire))
69 (assert-false (valid-retry-packet? retry-test-original (flip-byte wire 0))))))
70 (test "ql12-retry-control: empty and twenty-byte connection IDs remain bounded"
71 (for-each
72 (lambda (ids)
73 (let ((wire (encode-retry-packet (car ids) (cadr ids) (caddr ids) #u8(1))))
74 (assert-true (valid-retry-packet? (car ids) wire))
75 (assert-equal (cadr ids) (quic-header-destination-id (decode-packet-header wire 0 0)))
76 (assert-equal (caddr ids) (quic-header-source-id (decode-packet-header wire 0 0)))))
77 (list (list retry-test-original #u8() #u8())
78 (list #u8() #u8() #u8(1))
79 (list (make-bytevector 20 1) (make-bytevector 20 2) (make-bytevector 20 3)))))
80 (test "ql12-retry-control: maximal token fits exactly and its next byte is rejected"
81 (let* ((token (make-bytevector (- packet-datagram-limit 7 8 16) 7))
82 (wire (encode-retry-packet retry-test-original #u8() retry-test-source token)))
83 (assert-equal packet-datagram-limit (bytevector-length wire))
84 (assert-true (valid-retry-packet? retry-test-original wire))
85 (assert-error (encode-retry-packet retry-test-original #u8() retry-test-source
86 (bytes-append token #u8(0))))))
87 (test "ql12-retry-control: truncated malformed empty-token and oversized packets are drops"
88 (do ((end 0 (+ end 1))) ((= end (bytevector-length retry-test-wire)))
89 (assert-false (valid-retry-packet? retry-test-original (bytevector-copy retry-test-wire 0 end))))
90 (for-each
91 (lambda (wire) (assert-false (valid-retry-packet? retry-test-original wire)))
92 (list #f "not a packet" (make-bytevector (+ packet-datagram-limit 1) 0)
93 (bytes-append #u8(240 0 0 0 1 0 0) (make-bytevector 16 0))
94 (bytes-append retry-test-wire #u8(0)))))
95 (test "ql12-retry-control: even a matching tag cannot reuse the original destination as source"
96 (assert-error (encode-retry-packet retry-test-original #u8() retry-test-original #u8(1)))
97 (let ((unsigned (bytes-append #u8(240 0 0 0 1 0 8) retry-test-original #u8(1))))
98 (assert-false (valid-retry-packet? retry-test-original (retry-test-sign retry-test-original unsigned)))))
99 (test "ql12-retry-control: encoding and validation preserve and isolate caller-owned bytes"
100 (let* ((original (bytevector-copy retry-test-original))
101 (source (bytevector-copy retry-test-source))
102 (token (bytevector-copy retry-test-token))
103 (wire (encode-retry-packet original #u8() source token unused: 15))
104 (saved (bytevector-copy wire)))
105 (assert-true (valid-retry-packet? original wire))
106 (assert-equal retry-test-original original)
107 (assert-equal retry-test-source source)
108 (assert-equal retry-test-token token)
109 (bytevector-u8-set! source 0 0)
110 (bytevector-u8-set! token 0 0)
111 (assert-equal saved wire)
112 (assert-true (valid-retry-packet? original wire))
113 (bytevector-u8-set! original 0 0)
114 (assert-false (valid-retry-packet? original wire))
115 (assert-equal saved wire)))
116 (test "ql12-retry-control: invalid local IDs tokens and unused values raise before encoding"
117 (for-each
118 (lambda (bad)
119 (assert-error (encode-retry-packet bad #u8() retry-test-source #u8(1)))
120 (assert-error (encode-retry-packet retry-test-original bad retry-test-source #u8(1)))
121 (assert-error (encode-retry-packet retry-test-original #u8() bad #u8(1)))
122 (assert-error (valid-retry-packet? bad retry-test-wire)))
123 (list #f "id" (make-bytevector 21 0)))
124 (for-each
125 (lambda (bad) (assert-error (encode-retry-packet retry-test-original #u8() retry-test-source bad)))
126 (list #f "token" #u8() (make-bytevector packet-datagram-limit 0)))
127 (for-each
128 (lambda (bad)
129 (assert-error (encode-retry-packet retry-test-original #u8() retry-test-source #u8(1) unused: bad)))
130 (list -1 16 1.5 #f))))