Commitdfb94889Recorded18 Oct 2026Repositorysigil-quic

Qualify Retry token key lifetime and failure cleanup

Changed
 scripts/inject-retry-spy.mjs    |  63 +++++++++++++++++++++++++++++++++++++
 scripts/native-tls-tests.mjs    |  12 ++++---
 scripts/retry-cleanup-tests.sgl | 277 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 scripts/retry-spy.sgl           |  79 ++++++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 427 insertions(+), 4 deletions(-)
Diff
scripts/inject-retry-spy.mjsadded
@@ -0,0 +1,63 @@
+1
// Remote-only ownership observations. Never execute on the development laptop.
+2
// Inputs and outputs must differ; shipping modules are restored by the gate.
+3
import {readFileSync,writeFileSync} from 'node:fs';
+4
const [kind,input,output]=process.argv.slice(2);
+5
if(!['token','endpoint','fixture'].includes(kind)||!input||!output||input===output){
+6
throw Error('Usage: inject-retry-spy.mjs token|endpoint|fixture INPUT OUTPUT');
+7
}
+8
let source=readFileSync(input,'utf8');
+9
function once(from,to){
+10
if(source.split(from).length!==2)throw Error('Retry observation site changed: '+from);
+11
source=source.replace(from,()=>to);
+12
}
+13
if(kind==='fixture'){
+14
const boundary=source.indexOf('\n\n'),end=source.indexOf('\n(test-group ');
+15
if(!source.startsWith('(import ')||boundary<0||end<boundary||!source.includes('(define (er-with-pair ')){
+16
throw Error('Expected public endpoint Retry fixture');
+17
}
+18
const imports=source.slice(0,boundary),helpers=source.slice(boundary+2,end);
+19
const names=[...helpers.matchAll(/^\(define (?:\(([^\s()]+)|([^\s()]+))/gm)].map(m=>m[1]||m[2]);
+20
if(names.length!==16||new Set(names).size!==16)throw Error('Public fixture definitions changed');
+21
writeFileSync(output,';;; TEST ONLY: shared public UDP fixture, no named tests.\n'+
+22
'(define-library (sigil quic tests retry fixture)\n '+imports+'\n'+
+23
' (export '+names.join(' ')+')\n (begin\n'+
+24
helpers.split('\n').map(line=>' '+line).join('\n')+'\n ))\n');
+25
}else{
+26
if(source.includes('retry-spy'))throw Error('Already instrumented');
+27
if(kind==='token'){
+28
if(!source.includes('(define-library (sigil quic retry token)'))throw Error('Expected token manager');
+29
once(' (set! owned (if key (bytevector-copy key) (random-bytes 32)))',
+30
' (set! owned (if key (bytevector-copy key) (random-bytes 32)))\n'+
+31
' (retry-spy-owned! owned)');
+32
once(' (let ((manager (retry-token-manager key: owned lifetime: lifetime)))',
+33
' (let ((manager (retry-token-manager key: owned lifetime: lifetime)))\n'+
+34
' (retry-spy-manager! manager)');
+35
once(' (wipe! key)))',
+36
" (wipe! key)\n (retry-spy-checkpoint! 'close-after)))");
+37
once('(hmac-sha256-bytes (retry-token-manager-key manager)',
+38
'(retry-spy-mac hmac-sha256-bytes (retry-token-manager-key manager)');
+39
if(source.split('(random-bytes ').length!==3)throw Error('Token random sites changed');
+40
source=source.replaceAll('(random-bytes ','(retry-spy-random random-bytes ');
+41
}else{
+42
if(!source.includes('(define-library (sigil quic endpoint)'))throw Error('Expected endpoint');
+43
once(' (set-quic-endpoint-retry-manager! endpoint manager)',
+44
' (set-quic-endpoint-retry-manager! endpoint manager)\n'+
+45
" (retry-spy-checkpoint! 'accept-after-manager)");
+46
once('(random-bytes 8)','(retry-spy-random random-bytes 8)');
+47
once('(encode-retry-packet original client retry token)',
+48
'(retry-spy-packet encode-retry-packet original client retry token)');
+49
once('\n (unless (and (quic-connection? connection) (eq? (quic-role connection) \'server)',
+50
'\n (retry-spy-candidate! connection)\n'+
+51
' (unless (and (quic-connection? connection) (eq? (quic-role connection) \'server)');
+52
const start=source.indexOf(' (define (send-retry!'),end=source.indexOf(' (define (admit-retry-connection!',start);
+53
if(start<0||end<start)throw Error('Retry send boundary changed');
+54
let body=source.slice(start,end);
+55
const send='(udp-send (quic-endpoint-socket endpoint) packet "127.0.0.1" peer-port)';
+56
if(body.split(send).length!==2)throw Error('Retry send operation changed');
+57
body=body.replace(send,()=>'(retry-spy-send udp-send (quic-endpoint-socket endpoint) packet "127.0.0.1" peer-port)');
+58
source=source.slice(0,start)+body+source.slice(end);
+59
}
+60
once('(import (sigil crypto)',
+61
'(import (sigil quic tests retry spy)\n (sigil crypto)');
+62
writeFileSync(output,';;; TEST ONLY: actual Retry key ownership/fault observations; never ship.\n'+source);
+63
}
scripts/native-tls-tests.mjsmodified
@@ -76,7 +76,8 @@ const clientRetry = process.argv.includes('--client-retry');
76
const retryToken = process.argv.includes('--retry-token');
77
const serverRetry = process.argv.includes('--server-retry');
78
const endpointRetry = process.argv.includes('--endpoint-retry');
−79
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry, endpointRetry].filter(Boolean).length > 1) {
+79
const retryCleanup = process.argv.includes('--retry-cleanup');
+80
if ([cleanupFaults, secretCleanup, secretRetention, handshakeCleanup, packetRetention, factoryCleanup, eventCleanup, constructionCleanup, pathResponse, cidZero, cidSequence, handlerReadiness, seenBudget, ticketValidation, negotiation, certificatePolicy, retryPolicy, earlyPackets, retryPacket, clientRetry, retryToken, serverRetry, endpointRetry, retryCleanup].filter(Boolean).length > 1) {
81
throw new Error('Select one focused test suite');
82
}
83
if (cleanupFaults) {
@@ -148,6 +149,9 @@ if (serverRetry) {
149
if (endpointRetry) {
150
files.splice(0, files.length, 'test-endpoint-retry.sgl');
151
}
+152
if (retryCleanup) {
+153
files.splice(0, files.length, '../scripts/retry-cleanup-tests.sgl');
+154
}
155
const bodies = files.map(file => {
156
const text = readFileSync(join(root, 'test', file), 'utf8');
157
const boundary = text.indexOf('\n\n');
@@ -161,14 +165,14 @@ writeFileSync(join(source, 'native.sgl'), `(define-library (sigil quic tests nat
165
(sigil math)
166
(sigil io)
167
(sigil socket)
−164
(sigil process)${files.includes('test-endpoint-retry.sgl') ? '\n (sigil time)' : ''}
+168
(sigil process)${files.includes('test-endpoint-retry.sgl') || retryCleanup ? '\n (sigil time)' : ''}
169
(sigil crypto)
170
(sigil quic bytes)
171
(sigil quic vectors)
172
(sigil quic wire)
173
(sigil quic frame)
174
(sigil quic reassembly)
−171
(sigil quic packet)${files.includes('test-retry-token.sgl') ? '\n (sigil quic retry token)' : ''}
+175
(sigil quic packet)${files.includes('test-retry-token.sgl') || retryCleanup ? '\n (sigil quic retry token)' : ''}
176
(sigil quic error)
177
(sigil quic connection space)
178
(sigil quic connection)
@@ -184,7 +188,7 @@ writeFileSync(join(source, 'native.sgl'), `(define-library (sigil quic tests nat
188
(sigil quic tls extensions)
189
(sigil quic tls authentication)
190
(sigil quic tls transcript)
−187
(sigil quic tls vectors)${secretCleanup || secretRetention ? '\n (sigil quic tests secret spy)' : ''}${handshakeCleanup ? '\n (sigil quic tests handshake spy)' : ''}${packetRetention ? '\n (sigil quic tests packet spy)' : ''}${factoryCleanup ? '\n (sigil quic tests factory spy)' : ''}${eventCleanup ? '\n (sigil quic tests event spy)' : ''}${constructionCleanup ? '\n (sigil quic tests construction spy)' : ''}${seenBudget ? '\n (sigil quic tests seen spy)' : ''})
+191
(sigil quic tls vectors)${secretCleanup || secretRetention ? '\n (sigil quic tests secret spy)' : ''}${handshakeCleanup ? '\n (sigil quic tests handshake spy)' : ''}${packetRetention ? '\n (sigil quic tests packet spy)' : ''}${factoryCleanup ? '\n (sigil quic tests factory spy)' : ''}${eventCleanup ? '\n (sigil quic tests event spy)' : ''}${constructionCleanup ? '\n (sigil quic tests construction spy)' : ''}${seenBudget ? '\n (sigil quic tests seen spy)' : ''}${retryCleanup ? '\n (sigil quic tests retry spy)\n (sigil quic tests retry fixture)' : ''})
192
(export main)
193
(begin
194
${bodies.map(body => body.split('\n').map(line => ' ' + line).join('\n')).join('\n\n')}
scripts/retry-cleanup-tests.sgladded
@@ -0,0 +1,277 @@
+1
(import (sigil test)
+2
(sigil io)
+3
(sigil crypto)
+4
(sigil quic bytes)
+5
(sigil quic packet)
+6
(sigil quic connection)
+7
(sigil quic stream)
+8
(sigil quic endpoint)
+9
(sigil quic retry token)
+10
(sigil quic tests retry spy)
+11
(sigil quic tests retry fixture))
+12
+13
;; Explicit remote-only observations of actual owned buffers. Predicates run
+14
;; before teardown; negative variants' stranded references are wiped afterward.
+15
(define (rc-wipe! bytes)
+16
(do ((index 0 (+ index 1))) ((= index (bytevector-length bytes)))
+17
(bytevector-u8-set! bytes index 0)))
+18
+19
(define (rc-zero? bytes)
+20
(let loop ((index 0))
+21
(or (= index (bytevector-length bytes))
+22
(and (= 0 (bytevector-u8-ref bytes index)) (loop (+ index 1))))))
+23
+24
(define (rc-with-spy procedure)
+25
(dynamic-wind
+26
retry-spy-reset!
+27
procedure
+28
(lambda ()
+29
(retry-spy-fail! #f)
+30
(retry-spy-send-mode! #f)
+31
(for-each
+32
(lambda (entry)
+33
(let ((manager (vector-ref entry 2)))
+34
(when manager
+35
(guard (exn (else #f)) (close-retry-token-manager! manager)))))
+36
(retry-spy-owned))
+37
(for-each
+38
(lambda (candidate)
+39
(when (quic-connection? candidate)
+40
(guard (exn (else #f)) (quic-abort! candidate))))
+41
(retry-spy-candidates))
+42
(for-each (lambda (entry) (rc-wipe! (vector-ref entry 0))) (retry-spy-owned))
+43
(retry-spy-reset!))))
+44
+45
(define (rc-record)
+46
(let ((entries (retry-spy-owned)))
+47
(unless (= 1 (length entries)) (error "Retry lifetime fixture: expected one owned key"))
+48
(car entries)))
+49
+50
(define (rc-captured? entry)
+51
(and (= 32 (bytevector-length (vector-ref entry 0))) (vector-ref entry 1)))
+52
+53
(define (rc-live? entry)
+54
(and (rc-captured? entry) (retry-token-manager? (vector-ref entry 2))
+55
(not (rc-zero? (vector-ref entry 0)))))
+56
+57
(define (rc-erased? entry)
+58
(and (rc-captured? entry) (rc-zero? (vector-ref entry 0))))
+59
+60
(define (rc-failure? stage procedure)
+61
(let ((failure (guard (exn (else exn)) (procedure) #f)))
+62
(and (error-object? failure)
+63
(equal? "QL12 injected Retry failure" (error-object-message failure))
+64
(equal? (list stage) (error-object-irritants failure)))))
+65
+66
(define (rc-message? message procedure)
+67
(let ((failure (guard (exn (else exn)) (procedure) #f)))
+68
(and (error-object? failure) (equal? message (error-object-message failure)))))
+69
+70
(define (rc-rebind? endpoint)
+71
(let ((replacement (open-quic-endpoint port: (quic-endpoint-port endpoint))))
+72
(quic-endpoint-close! replacement)
+73
#t))
+74
+75
(define (rc-closed? endpoint entry)
+76
(and (quic-endpoint-closed? endpoint) (rc-erased? entry) (rc-rebind? endpoint)))
+77
+78
(define (rc-candidate-closed? pair)
+79
(let ((candidate (vector-ref pair 5)) (stream (vector-ref pair 6)))
+80
(and candidate stream (quic-closed? candidate)
+81
(memq candidate (retry-spy-candidates))
+82
(guard (exn (else #t)) (quic-stream-read! stream) #f))))
+83
+84
(define (rc-step! pair)
+85
(quic-endpoint-step! (vector-ref pair 1) wait-ms: 1))
+86
+87
(define (rc-positive procedure)
+88
(assert-true (guard (exn (else #f)) (rc-with-spy procedure))))
+89
+90
;; The operation is armed only after fixture setup, while its key is live.
+91
(define (rc-challenge-failure? stage)
+92
(er-with-pair
+93
(lambda (pair)
+94
(let ((entry (rc-record)))
+95
(and (rc-live? entry)
+96
(begin
+97
(retry-spy-fail! stage)
+98
(and (rc-failure? stage (lambda () (er-challenge! pair)))
+99
(= 0 (vector-ref pair 7))
+100
(rc-closed? (vector-ref pair 1) entry))))))))
+101
+102
(test-group "Private Retry key lifetime and ordinary unwind failures"
+103
(test "ql12-retry-lifetime: unconfirmed endpoint close erases owned key and releases socket"
+104
(rc-positive
+105
(lambda ()
+106
(er-with-pair
+107
(lambda (pair)
+108
(let ((entry (rc-record)) (endpoint (vector-ref pair 1)))
+109
(and (rc-live? entry)
+110
(begin
+111
(quic-endpoint-close! endpoint)
+112
(quic-endpoint-close! endpoint)
+113
(and (= 0 (vector-ref pair 7)) (rc-closed? endpoint entry))))))))))
+114
(test "ql12-retry-lifetime: manager close erases owned copy and preserves caller key"
+115
(rc-positive
+116
(lambda ()
+117
(let ((borrowed (make-bytevector 32 90)))
+118
(dynamic-wind
+119
(lambda () #t)
+120
(lambda ()
+121
(let* ((manager (make-retry-token-manager key: borrowed)) (entry (rc-record)))
+122
(and (rc-live? entry) (eq? manager (vector-ref entry 2))
+123
(not (eq? borrowed (vector-ref entry 0)))
+124
(begin
+125
(close-retry-token-manager! manager)
+126
(close-retry-token-manager! manager)
+127
(and (rc-erased? entry) (bytes=? borrowed (make-bytevector 32 90)))))))
+128
(lambda () (rc-wipe! borrowed)))))))
+129
(test "ql12-retry-lifetime: next constructor operation failure wipes untransferred key"
+130
(rc-positive
+131
(lambda ()
+132
(retry-spy-fail! 'manager-next)
+133
(and (rc-failure? 'manager-next (lambda () (make-retry-token-manager)))
+134
(let ((entry (rc-record)))
+135
(and (not (vector-ref entry 2)) (rc-erased? entry)))))))
+136
(test "ql12-retry-lifetime: setup failure after endpoint takes manager releases key and socket"
+137
(rc-positive
+138
(lambda ()
+139
(let ((endpoint (open-quic-endpoint)))
+140
(dynamic-wind
+141
(lambda () #t)
+142
(lambda ()
+143
(retry-spy-fail! 'accept-after-manager)
+144
(and (rc-failure? 'accept-after-manager
+145
(lambda () (quic-endpoint-accept-retry! endpoint (lambda args #f))))
+146
(rc-closed? endpoint (rc-record))))
+147
(lambda () (quic-endpoint-close! endpoint)))))))
+148
(test "ql12-retry-lifetime: confirmation retires key before explicit endpoint close"
+149
(rc-positive
+150
(lambda ()
+151
(er-with-pair
+152
(lambda (pair)
+153
(let ((entry (rc-record)))
+154
(and (rc-live? entry)
+155
(begin
+156
(er-ready! pair)
+157
(and (not (quic-endpoint-closed? (vector-ref pair 1)))
+158
(quic-confirmed? (vector-ref pair 0))
+159
(quic-confirmed? (vector-ref pair 5)) (rc-erased? entry))))))))))
+160
(test "ql12-retry-lifetime: tentative TLS failure retains key until replacement confirms"
+161
(rc-positive
+162
(lambda ()
+163
(er-with-pair
+164
(lambda (pair)
+165
(let* ((entry (rc-record)) (challenge (er-challenge! pair))
+166
(header (decode-packet-header challenge 0 0)) (packet (er-retried! pair challenge)))
+167
(er-send! pair (er-forged header))
+168
(rc-step! pair)
+169
(and (= 1 (vector-ref pair 7)) (rc-candidate-closed? pair)
+170
(not (quic-endpoint-connection (vector-ref pair 1))) (rc-live? entry)
+171
(begin
+172
(let drain ((count 0))
+173
(when (and (< count 64) (er-read pair)) (drain (+ count 1))))
+174
(er-send! pair packet)
+175
(er-ready! pair)
+176
(and (= 2 (vector-ref pair 7)) (rc-erased? entry))))))))))
+177
(test "ql12-retry-lifetime: invalid token and Initial tag retain key until valid confirmation"
+178
(rc-positive
+179
(lambda ()
+180
(er-with-pair
+181
(lambda (pair)
+182
(let* ((entry (rc-record)) (challenge (er-challenge! pair))
+183
(header (decode-packet-header challenge 0 0)) (packet (er-retried! pair challenge))
+184
(token (quic-header-token header)))
+185
(and (er-drop? pair (er-forged header token: (flip-byte token (- (bytevector-length token) 1))))
+186
(rc-live? entry)
+187
(er-drop? pair (flip-byte packet (- (bytevector-length packet) 1)))
+188
(rc-live? entry)
+189
(begin
+190
(er-send! pair packet)
+191
(er-ready! pair)
+192
(and (= 1 (vector-ref pair 7)) (rc-erased? entry))))))))))
+193
(test "ql12-retry-lifetime: Retry ID random failure retires key and socket"
+194
(rc-positive (lambda () (rc-challenge-failure? 'retry-id))))
+195
(test "ql12-retry-lifetime: token nonce random failure retires key and socket"
+196
(rc-positive (lambda () (rc-challenge-failure? 'token-nonce))))
+197
(test "ql12-retry-lifetime: token mint MAC failure retires key and socket"
+198
(rc-positive (lambda () (rc-challenge-failure? 'token-mac))))
+199
(test "ql12-retry-lifetime: token validation MAC failure retires key before factory"
+200
(rc-positive
+201
(lambda ()
+202
(er-with-pair
+203
(lambda (pair)
+204
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair))))
+205
(and (rc-live? entry)
+206
(begin
+207
(retry-spy-fail! 'token-mac)
+208
(er-send! pair packet)
+209
(and (rc-failure? 'token-mac (lambda () (rc-step! pair)))
+210
(= 0 (vector-ref pair 7))
+211
(rc-closed? (vector-ref pair 1) entry))))))))))
+212
(test "ql12-retry-lifetime: Retry encoding failure retires key and socket"
+213
(rc-positive (lambda () (rc-challenge-failure? 'retry-packet))))
+214
(test "ql12-retry-lifetime: blocked send retains key and duplicate challenge later confirms"
+215
(rc-positive
+216
(lambda ()
+217
(er-with-pair
+218
(lambda (pair)
+219
(let ((entry (rc-record))
+220
(packet (car (quic-take-datagrams! (vector-ref pair 0) (er-now pair)))))
+221
(retry-spy-send-mode! 'blocked)
+222
(er-send! pair packet)
+223
(rc-step! pair)
+224
(and (er-empty? pair) (not (er-read pair)) (rc-live? entry)
+225
(begin
+226
(retry-spy-send-mode! #f)
+227
(er-send! pair packet)
+228
(rc-step! pair)
+229
(let ((challenge (er-read pair)))
+230
(and challenge (valid-retry-packet? er-original challenge)
+231
(begin
+232
(er-send! pair (er-retried! pair challenge))
+233
(er-ready! pair)
+234
(and (= 1 (vector-ref pair 7)) (rc-erased? entry)))))))))))))
+235
(test "ql12-retry-lifetime: partial Retry send raises and retires key and socket"
+236
(rc-positive
+237
(lambda ()
+238
(er-with-pair
+239
(lambda (pair)
+240
(let ((entry (rc-record)))
+241
(and (rc-live? entry)
+242
(begin
+243
(retry-spy-send-mode! 'partial)
+244
(and (rc-message? "QUIC endpoint: partial Retry datagram send"
+245
(lambda () (er-challenge! pair)))
+246
(= 0 (vector-ref pair 7))
+247
(rc-closed? (vector-ref pair 1) entry))))))))))
+248
(test "ql12-retry-lifetime: returned candidate failure aborts connection and retires key"
+249
(rc-positive
+250
(lambda ()
+251
(er-with-pair
+252
(lambda (pair)
+253
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair))))
+254
(and (rc-live? entry)
+255
(begin
+256
(retry-spy-fail! 'candidate-after)
+257
(er-send! pair packet)
+258
(and (rc-failure? 'candidate-after (lambda () (rc-step! pair)))
+259
(= 1 (vector-ref pair 7)) (rc-candidate-closed? pair)
+260
(not (quic-endpoint-connection (vector-ref pair 1)))
+261
(rc-closed? (vector-ref pair 1) entry))))))))))
+262
(test "ql12-retry-lifetime: post-wipe close failure still releases socket and tentative connection"
+263
(rc-positive
+264
(lambda ()
+265
(er-with-pair
+266
(lambda (pair)
+267
(let ((entry (rc-record)) (packet (er-retried! pair (er-challenge! pair)))
+268
(endpoint (vector-ref pair 1)))
+269
(er-send! pair packet)
+270
(rc-step! pair)
+271
(and (= 1 (vector-ref pair 7)) (vector-ref pair 5)
+272
(eq? (vector-ref pair 5) (quic-endpoint-connection endpoint))
+273
(not (quic-confirmed? (vector-ref pair 5))) (rc-live? entry)
+274
(begin
+275
(retry-spy-fail! 'close-after)
+276
(and (rc-failure? 'close-after (lambda () (quic-endpoint-close! endpoint)))
+277
(rc-candidate-closed? pair) (rc-closed? endpoint entry)))))))))))
scripts/retry-spy.sgladded
@@ -0,0 +1,79 @@
+1
;;; Remote test-only actual owned-buffer references and ordinary unwind faults.
+2
;;; No dependency on token/endpoint modules: they pass operations and identities.
+3
(define-library (sigil quic tests retry spy)
+4
(export retry-spy-reset! retry-spy-fail! retry-spy-send-mode!
+5
retry-spy-owned retry-spy-candidates retry-spy-owned!
+6
retry-spy-manager! retry-spy-candidate! retry-spy-checkpoint!
+7
retry-spy-random retry-spy-mac retry-spy-packet retry-spy-send)
+8
(begin
+9
(define owned '())
+10
(define candidates '())
+11
(define failure #f)
+12
(define send-mode #f)
+13
+14
;; Tests wipe stranded references after assertions before clearing records.
+15
(define (retry-spy-reset!)
+16
(set! owned '())
+17
(set! candidates '())
+18
(set! failure #f)
+19
(set! send-mode #f))
+20
+21
(define (retry-spy-owned) (reverse owned))
+22
(define (retry-spy-candidates) (reverse candidates))
+23
(define (retry-spy-fail! stage) (set! failure stage))
+24
+25
(define (retry-spy-send-mode! mode)
+26
(unless (memq mode '(#f blocked partial)) (error "Retry spy: invalid send mode"))
+27
(set! send-mode mode))
+28
+29
;; One-shot exceptions let production cleanup run without a second fault.
+30
(define (retry-spy-checkpoint! stage)
+31
(when (eq? failure stage)
+32
(set! failure #f)
+33
(error "QL12 injected Retry failure" stage)))
+34
+35
(define (nonzero? bytes)
+36
(let loop ((index 0))
+37
(and (< index (bytevector-length bytes))
+38
(or (not (= 0 (bytevector-u8-ref bytes index)))
+39
(loop (+ index 1))))))
+40
+41
;; Entry fields: actual owned key, nonzero at capture, opaque manager.
+42
;; Capture occurs after the real ownership assignment, before the next op.
+43
(define (retry-spy-owned! bytes)
+44
(set! owned (cons (vector bytes (nonzero? bytes) #f) owned))
+45
(retry-spy-checkpoint! 'manager-next))
+46
+47
(define (retry-spy-manager! manager)
+48
(unless (pair? owned) (error "Retry spy: manager without owned key"))
+49
(vector-set! (car owned) 2 manager)
+50
manager)
+51
+52
(define (retry-spy-candidate! candidate)
+53
(set! candidates (cons candidate candidates))
+54
(retry-spy-checkpoint! 'candidate-after)
+55
candidate)
+56
+57
(define (retry-spy-random procedure size)
+58
(retry-spy-checkpoint!
+59
(case size
+60
((32) 'manager-random)
+61
((16) 'token-nonce)
+62
((8) 'retry-id)
+63
(else (error "Retry spy: unexpected random request" size))))
+64
(procedure size))
+65
+66
(define (retry-spy-mac procedure key bytes)
+67
(retry-spy-checkpoint! 'token-mac)
+68
(procedure key bytes))
+69
+70
(define (retry-spy-packet procedure original client retry token)
+71
(retry-spy-checkpoint! 'retry-packet)
+72
(procedure original client retry token))
+73
+74
(define (retry-spy-send procedure socket bytes host port)
+75
(retry-spy-checkpoint! 'retry-send)
+76
(case send-mode
+77
((blocked) #f)
+78
((partial) (- (bytevector-length bytes) 1))
+79
(else (procedure socket bytes host port))))))