AtlatestRepositorysigil-quic

sigil-quic / tree / testtest-tls-codec.sgl

1(import (sigil test)
2 (sigil crypto)
3 (sigil process)
4 (sigil quic bytes)
5 (sigil quic vectors)
6 (sigil quic tls codec)
7 (sigil quic tls messages)
8 (sigil quic tls signature))
9
10;; Four independent known-byte comparisons go red before the green run.
11(define (check-wire expected actual)
12 (assert-equal
13 (if (equal? (getenv "QUIC_TLS_CODEC_RED") "1")
14 (flip-byte expected 0)
15 expected)
16 actual))
18(define (reencode-client hello)
19 (encode-client-hello
20 (tls-client-hello-random hello)
21 (tls-client-hello-session-id hello)
22 (tls-client-hello-cipher-suites hello)
23 (tls-client-hello-extensions hello)))
25(define (reencode-server hello)
26 (encode-server-hello
27 (tls-server-hello-random hello)
28 (tls-server-hello-session-id hello)
29 (tls-server-hello-cipher-suite hello)
30 (tls-server-hello-extensions hello)))
32(test-group "TLS wire codec"
33 (test "uint32 published wire order"
34 (check-wire #u8(18 52 86 120) (tls-uint 305419896 4)))
35 (test "integer readers accept boundary values without truncation"
36 (for-each
37 (lambda (pair)
38 (let ((reader (make-tls-reader (tls-uint (cdr pair) (car pair)))))
39 (assert-equal (cdr pair) (tls-read-uint! reader (car pair)))
40 (assert-equal 0 (tls-remaining reader))
41 (assert-true (tls-finish! reader))))
42 '((1 . 0) (1 . 255) (2 . 65535) (3 . 16777215) (4 . 4294967295))))
43 (test "integer width and overflow rejected"
44 (assert-error (tls-uint -1 1))
45 (assert-error (tls-uint 256 1))
46 (assert-error (tls-uint 4294967296 4))
47 (assert-error (tls-uint 1 0))
48 (assert-error (tls-uint 1 5))
49 (assert-error (tls-read-uint! (make-tls-reader #u8(1)) 2)))
50 (test "reader cannot slice beyond input or accept trailing bytes"
51 (let ((reader (make-tls-reader #u8(1 2))))
52 (assert-error (tls-read-bytes! reader 3))
53 (assert-error (tls-read-bytes! reader -1))
54 (assert-equal 2 (tls-remaining reader))
55 (assert-error (tls-finish! reader))
56 (assert-equal #u8(1 2) (tls-read-bytes! reader 2))
57 (assert-true (tls-finish! reader))))
58 (test "vector lower upper and input bounds enforced"
59 (assert-error (tls-read-vector! (make-tls-reader #u8(0)) 1 1 255))
60 (assert-error (tls-read-vector! (make-tls-reader #u8(3 1 2)) 1 0 255))
61 (assert-error (tls-read-vector! (make-tls-reader #u8(3 1 2 3)) 1 0 2))
62 (assert-error (tls-vector #u8() 1 1 255))
63 (assert-error (tls-vector #u8() 1 0 256)))
64 (test "oversized handshake rejected before body allocation"
65 (assert-error (decode-handshake #u8(1 16 0 1)))
66 (assert-error (decode-handshake #u8(1 255 255 255)))
67 (assert-error (make-tls-reader (make-bytevector (+ tls-handshake-limit 5)))))
68 (test "handshake trailing bytes rejected"
69 (assert-error (decode-handshake #u8(20 0 0 0 0))))
70 (test "unknown extensions preserved and duplicate types rejected"
71 (let* ((entries (list (cons 65000 #u8(1 2)) (cons 43 #u8(3 4))))
72 (wire (encode-extensions entries)))
73 (assert-equal entries (decode-extensions wire)))
74 (assert-error (encode-extensions (list (cons 43 #u8()) (cons 43 #u8(3 4)))))
75 (assert-error (decode-extensions #u8(0 8 0 43 0 0 0 43 0 0)))
76 (assert-error (decode-extensions #u8(0 4 0 43 0 1)))
77 (assert-error (decode-extensions #u8(0 0 0))))
78 (test "RFC8448 ClientHello byte-for-byte"
79 (check-wire (fixture 'ClientHello)
80 (reencode-client (decode-client-hello (fixture 'ClientHello)))))
81 (test "RFC8448 ServerHello byte-for-byte"
82 (check-wire (fixture 'ServerHello)
83 (reencode-server (decode-server-hello (fixture 'ServerHello)))))
84 (test "RFC8448 fields and extensions decoded independently"
85 (let* ((client (decode-client-hello (fixture 'ClientHello)))
86 (server (decode-server-hello (fixture 'ServerHello)))
87 (extensions (tls-client-hello-extensions client)))
88 (assert-equal 32 (bytevector-length (tls-client-hello-random client)))
89 (assert-equal #u8() (tls-client-hello-session-id client))
90 (assert-equal #u8(19 1 19 3 19 2) (tls-client-hello-cipher-suites client))
91 (assert-equal #u8(2 3 4) (cdr (assoc 43 extensions)))
92 (assert-equal 4865 (tls-server-hello-cipher-suite server))
93 (assert-equal #u8(3 4) (cdr (assoc 43 (tls-server-hello-extensions server))))
94 (assert-false (hello-retry-request? server))))
95 (test "all truncated RFC Hellos rejected"
96 (for-each
97 (lambda (pair)
98 (let ((wire (fixture (car pair))) (decode (cdr pair)))
99 (do ((n 0 (+ n 1))) ((= n (bytevector-length wire)))
100 (assert-error (decode (bytevector-copy wire 0 n))))))
101 (list (cons 'ClientHello decode-client-hello)
102 (cons 'ServerHello decode-server-hello))))
103 (test "wrong message and invalid legacy fields rejected"
104 (assert-error (decode-client-hello (fixture 'ServerHello)))
105 (let ((bad (bytevector-copy (fixture 'ClientHello))))
106 (bytevector-u8-set! bad 5 1)
107 (assert-error (decode-client-hello bad)))
108 (assert-error (encode-client-hello (make-bytevector 31) #u8() #u8(19 1) '()))
109 (assert-error (encode-client-hello (make-bytevector 32) (make-bytevector 33) #u8(19 1) '()))
110 (assert-error (encode-client-hello (make-bytevector 32) #u8() #u8(19) '())))
111 (test "HRR random recognized without accepting it as a negotiated handshake"
112 (let ((hello (decode-server-hello
113 (encode-server-hello
114 (hex->bytes "cf21ad74e59a6111be1d8c021e65b891c2a211167abb8c5e079e09e2c8a8339c")
115 #u8() 4865 (list (cons 43 #u8(3 4)) (cons 51 #u8(0 29)))))))
116 (assert-true (hello-retry-request? hello)))))
118(define (small-signature)
119 (let ((raw (make-bytevector 64 0)))
120 (bytevector-u8-set! raw 31 1)
121 (bytevector-u8-set! raw 63 2)
122 raw))
124(test-group "TLS ECDSA signatures"
125 (test "DER known minimal scalar pair"
126 (check-wire #u8(48 6 2 1 1 2 1 2) (encode-p256-signature (small-signature))))
127 (test "DER sign padding and 32-byte scalar boundary"
128 (let* ((raw (small-signature))
129 (padding (bytevector-u8-set! raw 0 128))
130 (der (encode-p256-signature raw)))
131 (assert-equal 40 (bytevector-length der))
132 (assert-equal 33 (bytevector-u8-ref der 3))
133 (assert-equal 0 (bytevector-u8-ref der 4))
134 (assert-equal 128 (bytevector-u8-ref der 5))
135 (assert-equal raw (decode-p256-signature der))))
136 (test "DER rejects negative zero redundant padding and noncanonical lengths"
137 (for-each
138 (lambda (wire) (assert-error (decode-p256-signature (hex->bytes wire))))
139 '("3006020180020101" "3006020100020101" "300702020001020101"
140 "308106020101020102" "300602010102010200" "3006020101030102"))
141 (assert-error (encode-p256-signature (make-bytevector 64 0)))
142 (assert-error (encode-p256-signature (make-bytevector 63 0))))
143 (test "every DER truncation is rejected"
144 (let ((wire (encode-p256-signature (small-signature))))
145 (do ((n 0 (+ n 1))) ((= n (bytevector-length wire)))
146 (assert-error (decode-p256-signature (bytevector-copy wire 0 n))))))
147 (test "CertificateVerify binds role transcript and signing key"
148 (let* ((keys (ecdsa-p256-generate-keypair))
149 (other (ecdsa-p256-generate-keypair))
150 (hash (sha256-bytes "handshake transcript"))
151 (signature (sign-certificate-verify (car keys) 'server hash)))
152 (assert-true (verify-certificate-verify (cdr keys) 'server hash signature))
153 (assert-false (verify-certificate-verify (cdr keys) 'client hash signature))
154 (assert-false (verify-certificate-verify (cdr keys) 'server (flip-byte hash 0) signature))
155 (assert-false (verify-certificate-verify (cdr other) 'server hash signature))
156 (assert-false (verify-certificate-verify (cdr keys) 'server hash (flip-byte signature 0)))))
157 (test "CertificateVerify input arguments checked"
158 (assert-error (certificate-verify-input 'peer (make-bytevector 32)))
159 (assert-error (certificate-verify-input 'server (make-bytevector 31)))))