Commit69e025f3Recorded18 Oct 2026Repositorysigil-quic

Pin TLS certificate shape and declined client authentication

Changed
 scripts/inject-certificate-faults.mjs |  20 +++++++++++++++
 scripts/native-tls-tests.mjs          |   7 +++++-
 test/test-tls-certificate-policy.sgl  | 205 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 231 insertions(+), 1 deletion(-)
Diff
scripts/inject-certificate-faults.mjsadded
@@ -0,0 +1,20 @@
+1
// Remote-only mutation sensitivity for certificate-policy tests.
+2
import { readFileSync, writeFileSync } from 'node:fs';
+3
+4
const [input, output] = process.argv.slice(2);
+5
if (!input || !output || input === output) {
+6
throw new Error('Usage: inject-certificate-faults.mjs INPUT OUTPUT');
+7
}
+8
let source = readFileSync(input, 'utf8');
+9
if (source.includes('TEST ONLY')) throw new Error('Expected canonical handshake source');
+10
function replaceOnce(before, after) {
+11
if (source.split(before).length !== 2) throw new Error('Expected one canonical certificate guard');
+12
source = source.replace(before, () => after);
+13
}
+14
replaceOnce(` (unless (and (bytes=? (tls-certificate-context certificate) #u8()) (pair? entries)
+15
(let loop ((rest entries))
+16
(or (null? rest) (and (null? (cdar rest)) (loop (cdr rest))))))
+17
(error "TLS: missing server certificate or unsolicited certificate extension"))`, ' #t');
+18
replaceOnce(` (when (tls-handshake-request? engine)
+19
(emit! engine 'handshake (encode-certificate #u8() '())))`, ' #t');
+20
writeFileSync(output, ';;; TEST ONLY: certificate guard and empty response removed for sensitivity.\n' + source);
scripts/native-tls-tests.mjsmodified
@@ -13,6 +13,7 @@ const files = [
13
'test-tls-codec.sgl', 'test-tls-extensions.sgl',
14
'test-tls-seen.sgl',
15
'test-tls-negotiation.sgl',
+16
'test-tls-certificate-policy.sgl',
17
'test-tls-authentication.sgl', 'test-tls-handshake.sgl',
18
'test-tls-input-bounds.sgl',
19
'test-tls-alerts.sgl',
@@ -60,7 +61,8 @@ const handlerReadiness = process.argv.includes('--handler-readiness');
61
const seenBudget = process.argv.includes('--seen-budget');
62
const ticketValidation = process.argv.includes('--ticket-validation');
63
const negotiation = process.argv.includes('--negotiation');
−63
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation].filter(Boolean).length > 1) {
+64
const certificatePolicy = process.argv.includes('--certificate-policy');
+65
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy].filter(Boolean).length > 1) {
66
throw new Error('Select one focused test suite');
67
}
68
if (cleanupFaults) {
@@ -108,6 +110,9 @@ if (ticketValidation) {
110
if (negotiation) {
111
files.splice(0, files.length, 'test-tls-negotiation.sgl');
112
}
+113
if (certificatePolicy) {
+114
files.splice(0, files.length, 'test-tls-certificate-policy.sgl');
+115
}
116
const bodies = files.map(file => {
117
const text = readFileSync(join(root, 'test', file), 'utf8');
118
const boundary = text.indexOf('\n\n');
test/test-tls-certificate-policy.sgladded
@@ -0,0 +1,205 @@
+1
(import (sigil test)
+2
(sigil crypto)
+3
(sigil quic bytes)
+4
(sigil quic tls)
+5
(sigil quic tls codec)
+6
(sigil quic tls extensions)
+7
(sigil quic tls authentication)
+8
(sigil quic tls transcript)
+9
(sigil quic tls signature))
+10
+11
(define (ql13c-wipe! bytes)
+12
(when (bytevector? bytes)
+13
(do ((i 0 (+ i 1))) ((= i (bytevector-length bytes)))
+14
(bytevector-u8-set! bytes i 0))))
+15
+16
(define (ql13c-wipe-events! events)
+17
(for-each
+18
(lambda (event)
+19
(when (eq? (tls-event-kind event) 'secrets)
+20
(ql13c-wipe! (car (tls-event-data event)))
+21
(ql13c-wipe! (cdr (tls-event-data event)))))
+22
events))
+23
+24
(define (ql13c-message events type)
+25
(let ((matches
+26
(filter
+27
(lambda (event)
+28
(and (eq? (tls-event-kind event) 'crypto)
+29
(= type (bytevector-u8-ref (tls-event-data event) 0))))
+30
events)))
+31
(unless (= 1 (length matches))
+32
(error "Certificate fixture did not produce the requested message" type))
+33
(tls-event-data (car matches))))
+34
+35
;; Synthetic leaf bytes are trusted only by this fixture. Its verifier records
+36
;; invocation so certificate-shape rejection must happen before that boundary.
+37
(define (ql13c-with-peer procedure)
+38
(let ((key (ecdsa-p256-generate-keypair))
+39
(client #f)
+40
(server #f)
+41
(flight '())
+42
(observations (vector 0 '()))
+43
(transcript (make-tls-transcript)))
+44
(dynamic-wind
+45
(lambda () #t)
+46
(lambda ()
+47
(set! client
+48
(make-tls-client (list #u8(113 49)) "certificate.test" (list (cons 15 #u8(1)))
+49
(lambda (chain name)
+50
(unless (equal? name "certificate.test")
+51
(error "Certificate fixture received the wrong verifier name"))
+52
(vector-set! observations 0 (+ 1 (vector-ref observations 0)))
+53
(vector-set! observations 1 chain)
+54
(cdr key))))
+55
(set! server
+56
(make-tls-server (list #u8(113 49))
+57
(list (cons 0 #u8(9)) (cons 15 #u8(2))) (list #u8(48 1 0)) (car key)))
+58
(tls-bind-peer! client #u8(9) #u8(2) #f)
+59
(tls-bind-peer! server #u8(9) #u8(1) #f)
+60
(tls-start! client)
+61
(let ((hello (ql13c-message (tls-take-events! client) 1)))
+62
(tls-input! server 'initial hello)
+63
(set! flight (tls-take-events! server))
+64
(unless (eq? (tls-state client) 'server-hello)
+65
(error "Certificate fixture client is not awaiting ServerHello"))
+66
(procedure client key hello flight observations transcript)))
+67
(lambda ()
+68
(when client
+69
(ql13c-wipe-events! (tls-take-events! client))
+70
(tls-abort! client))
+71
(when server (tls-abort! server))
+72
(ql13c-wipe-events! flight)
+73
(tls-transcript-clear! transcript)
+74
(ql13c-wipe! (car key))))))
+75
+76
(define (ql13c-ready! client flight)
+77
(tls-input! client 'initial (ql13c-message flight 2))
+78
(ql13c-wipe-events! (tls-take-events! client))
+79
(tls-input! client 'handshake (ql13c-message flight 8))
+80
(unless (eq? (tls-state client) 'certificate)
+81
(error "Certificate fixture did not reach the certificate boundary")))
+82
+83
(define (ql13c-rejected! client wire observations reason (keys: (alert #f)))
+84
(let* ((failure (guard (exn (else exn)) (tls-input! client 'handshake wire) #f))
+85
(events (tls-take-events! client))
+86
(rejected?
+87
(and (error-object? failure)
+88
(equal? reason (error-object-message failure))
+89
(or (not alert) (and (tls-alert? failure) (= alert (tls-alert-code failure))))
+90
(tls-failed? client)
+91
(null? events)
+92
(= 0 (vector-ref observations 0))
+93
(not (tls-peer-parameters client))
+94
(not (tls-negotiated-alpn client)))))
+95
(ql13c-wipe-events! events)
+96
(assert-true rejected?)))
+97
+98
(define (ql13c-bad-certificate! context entries)
+99
(ql13c-with-peer
+100
(lambda (client key hello flight observations transcript)
+101
(ql13c-ready! client flight)
+102
(ql13c-rejected! client (encode-certificate context entries) observations
+103
"TLS: missing server certificate or unsolicited certificate extension"))))
+104
+105
(define (ql13c-request context)
+106
(encode-certificate-request context (list (cons 13 (encode-u16-list '(1027) 2)))))
+107
+108
(define (ql13c-handshake-secrets flight)
+109
(let ((matches
+110
(filter
+111
(lambda (event)
+112
(and (eq? (tls-event-kind event) 'secrets)
+113
(eq? (tls-event-level event) 'handshake)))
+114
flight)))
+115
(unless (= 1 (length matches))
+116
(error "Certificate fixture lacks the peer-owned handshake secrets"))
+117
(let ((secrets (tls-event-data (car matches))))
+118
(unless (and (bytevector? (car secrets)) (= 32 (bytevector-length (car secrets)))
+119
(bytevector? (cdr secrets)) (= 32 (bytevector-length (cdr secrets))))
+120
(error "Certificate fixture received invalid handshake secrets"))
+121
secrets)))
+122
+123
;; Rebuild the peer's authentication transcript using its own signing key and
+124
;; public TLS-event secrets. Never alter a production engine's private state.
+125
(define (ql13c-complete! request? fragment?)
+126
(ql13c-with-peer
+127
(lambda (client key hello flight observations transcript)
+128
(let* ((server-hello (ql13c-message flight 2))
+129
(extensions (ql13c-message flight 8))
+130
(certificate (ql13c-message flight 11))
+131
(secrets (ql13c-handshake-secrets flight))
+132
(messages
+133
(append (list extensions) (if request? (list (ql13c-request #u8())) '())
+134
(list certificate))))
+135
(for-each (lambda (wire) (tls-transcript-add! transcript wire))
+136
(append (list hello server-hello) messages))
+137
(let* ((signature (sign-certificate-verify (car key) 'server (tls-transcript-hash transcript)))
+138
(verify (and signature (encode-certificate-verify 1027 signature))))
+139
(unless verify (error "Certificate fixture peer could not sign its own flight"))
+140
(tls-transcript-add! transcript verify)
+141
(let* ((finished (encode-finished
+142
(finished-verify-data (cdr secrets) (tls-transcript-hash transcript))))
+143
(wire (apply bytes-append (append messages (list verify finished)))))
+144
(tls-transcript-add! transcript finished)
+145
(tls-input! client 'initial server-hello)
+146
(ql13c-wipe-events! (tls-take-events! client))
+147
(if fragment?
+148
(do ((i 0 (+ i 1))) ((= i (bytevector-length wire)))
+149
(tls-input! client 'handshake (bytevector-copy wire i (+ i 1))))
+150
(tls-input! client 'handshake wire))
+151
(let ((output (tls-take-events! client)))
+152
(dynamic-wind
+153
(lambda () #t)
+154
(lambda ()
+155
(let* ((crypto (filter (lambda (event) (eq? (tls-event-kind event) 'crypto)) output))
+156
(types (map (lambda (event) (bytevector-u8-ref (tls-event-data event) 0)) crypto))
+157
(empty-certificate (encode-certificate #u8() '())))
+158
(when request? (tls-transcript-add! transcript empty-certificate))
+159
(assert-true
+160
(and (tls-complete? client)
+161
(equal? #u8(113 49) (tls-negotiated-alpn client))
+162
(equal? #u8(2) (cdr (assoc 15 (tls-peer-parameters client))))
+163
(= 1 (vector-ref observations 0))
+164
(equal? (list #u8(48 1 0)) (vector-ref observations 1))
+165
(equal? types (if request? '(11 20) '(20)))
+166
(or (not request?)
+167
(bytes=? empty-certificate (ql13c-message output 11)))
+168
(bytes=?
+169
(finished-verify-data (car secrets) (tls-transcript-hash transcript))
+170
(decode-finished (ql13c-message output 20)))))))
+171
(lambda () (ql13c-wipe-events! output))))))))))
+172
+173
(test-group "Certificate shape and declined client authentication"
+174
(test "ql13-certificate: nonempty server context fails before verifier invocation"
+175
(ql13c-bad-certificate! #u8(1) (list (cons #u8(48 1 0) '()))))
+176
(test "ql13-certificate: unsolicited entry extension fails before verifier invocation"
+177
(ql13c-bad-certificate! #u8() (list (cons #u8(48 1 0) (list (cons 1234 #u8(1)))))))
+178
(test "ql13-certificate: empty server chain fails before verifier invocation"
+179
(ql13c-bad-certificate! #u8() '()))
+180
(test "ql13-certificate: fragmented request emits empty Certificate authenticated by Finished"
+181
(ql13c-complete! #t #t))
+182
(test "ql13-certificate-control: ordinary coalesced flight completes with Finished only"
+183
(ql13c-complete! #f #f))
+184
(test "ql13-certificate-control: initial request context must be empty"
+185
(ql13c-with-peer
+186
(lambda (client key hello flight observations transcript)
+187
(ql13c-ready! client flight)
+188
(ql13c-rejected! client (ql13c-request #u8(1)) observations
+189
"TLS: nonempty initial CertificateRequest context"))))
+190
(test "ql13-certificate-control: request must carry signature algorithms"
+191
(ql13c-with-peer
+192
(lambda (client key hello flight observations transcript)
+193
(ql13c-ready! client flight)
+194
(ql13c-rejected! client
+195
(encode-certificate-request #u8() (list (cons 1234 #u8(1)))) observations
+196
"TLS: missing required extension" alert: 109))))
+197
(test "ql13-certificate-control: a second request is rejected at its header"
+198
(ql13c-with-peer
+199
(lambda (client key hello flight observations transcript)
+200
(ql13c-ready! client flight)
+201
(tls-input! client 'handshake (ql13c-request #u8()))
+202
(unless (eq? (tls-state client) 'certificate)
+203
(error "Certificate fixture first request did not leave the expected state"))
+204
(ql13c-rejected! client (ql13c-request #u8()) observations
+205
"TLS: unexpected handshake type at header" alert: 10)))))