Commit662f2899Recorded4 Nov 2026Repositorysigil-dbus

Add one-use sensitive string replies with owned buffer cleanup

Changed
 README.md                     | 14 ++++++++++++++
 src/sigil/dbus.sgl            |  3 ++-
 src/sigil/dbus/connection.sgl | 20 +++++++++++++++-----
 src/sigil/dbus/sensitive.sgl  | 73 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 src/sigil/dbus/service.sgl    |  7 +++++--
 src/sigil/dbus/wire.sgl       |  5 ++++-
 test/test-integration.sgl     | 18 ++++++++++++++++++
 test/test-sensitive.sgl       | 52 ++++++++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 183 insertions(+), 9 deletions(-)
Diff
README.mdmodified
@@ -177,8 +177,22 @@ and [standard interfaces](https://dbus.freedesktop.org/doc/dbus-specification.ht
177
178
## Tests
179
+180
Method handlers with output signature `s` may return
+181
`(dbus-sensitive-reply bytes)` instead of the usual argument list. This
+182
transfers ownership of a UTF-8 bytevector immediately. Do not retain a second
+183
copy or modify it afterward. A reply is usable once; call
+184
`dbus-sensitive-reply-clear!` to discard it before returning it.
+185
+186
Sensitive replies validate without decoding to a string and write directly
+187
into a single secret-bearing frame. The input and frame are overwritten on
+188
success, send failure, invalid output, and suppressed replies. This covers
+189
only those owned buffers. It does not erase copies previously made by the
+190
caller, operating system, bus daemon, recipient, runtime, or debugger. Avoid
+191
converting secrets from strings or logging handler inputs/results.
+192
193
```sh
194
sigil --no-auto-compile -L src eval -f test/test-wire.sgl
+195
sigil --no-auto-compile -L src eval -f test/test-sensitive.sgl
196
scripts/with-test-bus.sh sigil --no-auto-compile -L src eval -f test/test-integration.sgl
197
scripts/with-test-bus.sh sigil --no-auto-compile -L src eval -f test/test-transport.sgl
198
```
src/sigil/dbus.sglmodified
@@ -1,6 +1,6 @@
1
(define-library (sigil dbus)
2
(import (sigil dbus types) (sigil dbus wire) (sigil dbus message)
−3
(sigil dbus connection) (sigil dbus service))
+3
(sigil dbus connection) (sigil dbus service) (sigil dbus sensitive))
4
(export
5
dbus-variant dbus-variant? dbus-variant-signature dbus-variant-value
6
dbus-error dbus-error? dbus-error-name dbus-error-message
@@ -12,6 +12,7 @@
12
dbus-request-name! dbus-release-name! dbus-allow-replacement
13
dbus-replace-existing dbus-do-not-queue dbus-subscribe! dbus-unsubscribe!
14
dbus-send-signal! dbus-method dbus-property dbus-signal dbus-interface
+15
dbus-sensitive-reply dbus-sensitive-reply? dbus-sensitive-reply-clear!
16
dbus-export! dbus-unexport! dbus-introspect dbus-properties-changed!
17
dbus-message dbus-message? dbus-message-type dbus-message-flags
18
dbus-message-serial dbus-message-fields dbus-message-signature
src/sigil/dbus/connection.sglmodified
@@ -1,6 +1,7 @@
1
(define-library (sigil dbus connection)
2
(import (sigil dbus types) (sigil dbus message) (sigil dbus transport)
−3
(sigil dbus wire) (sigil async) (sigil process) (sigil string))
+3
(sigil dbus wire) (sigil dbus sensitive)
+4
(sigil async) (sigil process) (sigil string))
5
(export dbus-connect dbus-connect-session dbus-connect-system dbus-close!
6
dbus-closed? dbus-unique-name dbus-owned-names dbus-call dbus-call-async
7
dbus-await dbus-pending? dbus-pending-ready? dbus-pump! dbus-run!
@@ -146,16 +147,25 @@
147
25000))
148
149
(define (dbus-send-reply! c call signature result)
−149
(unless (odd? (dbus-message-flags call))
+150
(if (and (dbus-sensitive-reply? result) (odd? (dbus-message-flags call)))
+151
(dbus-sensitive-reply-clear! result)
+152
(unless (odd? (dbus-message-flags call))
153
(let ((fields (list (cons 5 (dbus-variant "u" (dbus-message-serial call)))))
154
(sender (dbus-message-field call 7)))
155
(when sender (set! fields (cons (cons 6 (dbus-variant "s" sender)) fields)))
−153
(if (dbus-error? result)
+156
(cond
+157
((dbus-sensitive-reply? result)
+158
(guard (e (else (dbus-sensitive-reply-clear! result) (dbus-close! c) (raise e)))
+159
(dbus-write-sensitive-reply!
+160
(dbus-message 2 (next-serial! c) fields signature '()) result
+161
(lambda (frame)
+162
(dbus-transport-write! (vector-ref c 0) frame timeout-ms: 25000)))))
+163
((dbus-error? result)
164
(send-message! c
165
(dbus-message 3 (next-serial! c)
166
(cons (cons 4 (dbus-variant "s" (dbus-error-name result))) fields)
−157
"s" (list (dbus-error-message result))) 25000)
−158
(send-message! c (dbus-message 2 (next-serial! c) fields signature result) 25000)))))
+167
"s" (list (dbus-error-message result))) 25000))
+168
(else (send-message! c (dbus-message 2 (next-serial! c) fields signature result) 25000)))))))
169
170
(define (quote-match value)
171
(unless (string? value) (error "D-Bus match values must be strings"))
src/sigil/dbus/sensitive.sgladded
@@ -0,0 +1,73 @@
+1
;;; One-use string replies keep credentials out of ordinary string marshalling.
+2
(define-library (sigil dbus sensitive)
+3
(import (sigil dbus message) (sigil dbus wire))
+4
(export dbus-sensitive-reply dbus-sensitive-reply? dbus-sensitive-reply-clear!
+5
dbus-validate-sensitive-reply! dbus-write-sensitive-reply!)
+6
(begin
+7
(define tag (list 'sensitive-reply))
+8
+9
;; Ownership transfers immediately; callers must not read or modify BYTES.
+10
(define (dbus-sensitive-reply bytes)
+11
(unless (bytevector? bytes) (error "Sensitive reply requires UTF-8 bytes"))
+12
(vector tag bytes #f))
+13
+14
(define (dbus-sensitive-reply? reply)
+15
(and (vector? reply) (= 3 (vector-length reply))
+16
(eq? tag (vector-ref reply 0))))
+17
+18
(define (clear! bytes)
+19
(let loop ((i 0))
+20
(when (< i (bytevector-length bytes))
+21
(bytevector-u8-set! bytes i 0)
+22
(loop (+ i 1)))))
+23
+24
(define (dbus-sensitive-reply-clear! reply)
+25
(clear! (vector-ref reply 1))
+26
(vector-set! reply 2 #t))
+27
+28
(define (dbus-validate-sensitive-reply! reply signature)
+29
(guard (e (else (dbus-sensitive-reply-clear! reply) (raise e)))
+30
(when (vector-ref reply 2) (error "Sensitive reply was already consumed"))
+31
(unless (string=? "s" signature)
+32
(error "Sensitive replies require one string output"))
+33
(unless (<= (bytevector-length (vector-ref reply 1)) dbus-max-message-size)
+34
(error "Sensitive reply exceeds byte limit"))
+35
(wire-check-utf8 (vector-ref reply 1))))
+36
+37
(define (uint32! bytes offset value)
+38
(let loop ((i 0))
+39
(when (< i 4)
+40
(bytevector-u8-set! bytes (+ offset i)
+41
(modulo (quotient value (expt 256 i)) 256))
+42
(loop (+ i 1)))))
+43
+44
;; WRITE consumes the frame synchronously. Neither input nor frame survives
+45
;; this scope with its original content, even if validation or WRITE fails.
+46
(define (dbus-write-sensitive-reply! message reply write)
+47
(dbus-validate-sensitive-reply! reply (dbus-message-signature message))
+48
(vector-set! reply 2 #t)
+49
(let ((frame #f) (bytes (vector-ref reply 1)))
+50
(dynamic-wind
+51
(lambda () #t)
+52
(lambda ()
+53
(unless (= 2 (dbus-message-type message))
+54
(error "Sensitive replies require a method return"))
+55
;; An empty public string produces the header without any secret
+56
;; copies. Replace its five-byte body directly in the final frame.
+57
(let* ((empty (dbus-encode-message
+58
(dbus-message 2 (dbus-message-serial message)
+59
(dbus-message-fields message) "s" '(""))
+60
endianness: 'little))
+61
(start (- (bytevector-length empty) 5))
+62
(n (bytevector-length bytes)))
+63
(unless (<= (+ start 5 n) dbus-max-message-size)
+64
(error "Sensitive reply exceeds byte limit"))
+65
(set! frame (make-bytevector (+ start 5 n) 0))
+66
(bytevector-copy! frame 0 empty 0 start)
+67
(uint32! frame 4 (+ n 5))
+68
(uint32! frame start n)
+69
(bytevector-copy! frame (+ start 4) bytes)
+70
(write frame)))
+71
(lambda ()
+72
(dbus-sensitive-reply-clear! reply)
+73
(when frame (clear! frame))))))))
src/sigil/dbus/service.sglmodified
@@ -1,6 +1,6 @@
1
(define-library (sigil dbus service)
2
(import (sigil dbus types) (sigil dbus wire) (sigil dbus message)
−3
(sigil dbus connection) (sigil string))
+3
(sigil dbus connection) (sigil dbus sensitive) (sigil string))
4
(export dbus-method dbus-property dbus-signal dbus-interface
5
dbus-export! dbus-unexport! dbus-introspect dbus-properties-changed!)
6
(begin
@@ -215,6 +215,8 @@
215
(expect-signature call (vector-ref method 1))
216
(let ((result (apply (vector-ref method 3) (dbus-message-body call))))
217
(when (dbus-error? result) (raise result))
+218
(when (dbus-sensitive-reply? result)
+219
(dbus-validate-sensitive-reply! result (vector-ref method 2)))
220
(cons (vector-ref method 2) result)))))))
221
222
(define (dispatch-call! c call)
@@ -224,7 +226,8 @@
226
(let ((reply (invoke c call)))
227
;; Validate handler output while exceptions can still turn
228
;; into a single Failed reply; never emit a partial frame.
−227
(dbus-marshal (car reply) (cdr reply))
+229
(unless (dbus-sensitive-reply? (cdr reply))
+230
(dbus-marshal (car reply) (cdr reply)))
231
reply))))
232
(if (dbus-error? reply)
233
(dbus-send-reply! c call "" reply)
src/sigil/dbus/wire.sglmodified
@@ -3,7 +3,8 @@
3
(export dbus-marshal dbus-unmarshal dbus-native-endianness
4
dbus-max-message-size dbus-max-array-size
5
wire-writer wire-reader wire-position wire-align! wire-put! wire-get!
−6
wire-uint! wire-read-uint! wire-finish wire-check! wire-limit!)
+6
wire-uint! wire-read-uint! wire-finish wire-check! wire-limit!
+7
wire-check-utf8)
8
(begin
9
;; Specification: Message Format and Marshalling Containers.
10
(define dbus-max-message-size 134217728)
@@ -130,6 +131,8 @@
131
(error "Non-scalar or overlong D-Bus UTF-8"))))
132
(loop (+ i width)))))))
133
+134
(define wire-check-utf8 check-utf8)
+135
136
(define (put-text! state text type)
137
(check-text text type)
138
(let ((bytes (string->utf8 text)))
test/test-integration.sglmodified
@@ -7,6 +7,10 @@
7
(define path "/org/example/Test")
8
(define iface "org.example.Test")
9
(define props "org.freedesktop.DBus.Properties")
+10
(define sensitive-input #f)
+11
(define (sensitive bytes)
+12
(set! sensitive-input bytes)
+13
(dbus-sensitive-reply bytes))
14
15
(with-async
16
(let ((server (dbus-connect-session)) (client (dbus-connect-system))
@@ -27,6 +31,9 @@
31
(lambda () (dbus-error "org.example.Error.Refused" "refused")))
32
(dbus-method "Throw" "" "" (lambda () (error "broken handler")))
33
(dbus-method "BadOutput" "" "u" (lambda () '("wrong")))
+34
(dbus-method "Sensitive" "" "s" (lambda () (sensitive (bytevector 97 98 99))))
+35
(dbus-method "SensitiveInvalid" "" "s" (lambda () (sensitive (bytevector 97 0 98))))
+36
(dbus-method "SensitiveWrongSignature" "" "u" (lambda () (sensitive (bytevector 97))))
37
(dbus-method "Slow" "u" "u" (lambda (delay) (sleep (/ delay 1000)) (list delay))))
38
properties:
39
(list (dbus-property "Counter" "u" (lambda () counter)
@@ -80,6 +87,17 @@
87
(test "handler survives previous exceptions"
88
(assert-equal '("still alive")
89
(dbus-call client service-name path iface "Echo" "s" '("still alive"))))
+90
(test "sensitive string reply clears its owned input"
+91
(assert-equal '("abc") (dbus-call client service-name path iface "Sensitive" "" '()))
+92
(assert-equal (bytevector 0 0 0) sensitive-input))
+93
(test "invalid sensitive output fails without closing the connection"
+94
(assert-equal "org.freedesktop.DBus.Error.Failed"
+95
(dbus-error-name (dbus-call client service-name path iface "SensitiveInvalid" "" '())))
+96
(assert-equal (bytevector 0 0 0) sensitive-input)
+97
(assert-equal "org.freedesktop.DBus.Error.Failed"
+98
(dbus-error-name (dbus-call client service-name path iface "SensitiveWrongSignature" "" '())))
+99
(assert-equal (bytevector 0) sensitive-input)
+100
(assert-equal '("alive") (dbus-call client service-name path iface "Echo" "s" '("alive"))))
101
(test "unknown method"
102
(assert-equal "org.freedesktop.DBus.Error.UnknownMethod"
103
(dbus-error-name (dbus-call client service-name path iface "Missing" "" '()))))
test/test-sensitive.sgladded
@@ -0,0 +1,52 @@
+1
(import (sigil dbus) (sigil dbus sensitive) (sigil dbus connection) (sigil test))
+2
+3
(define (zero? bytes)
+4
(let loop ((i 0))
+5
(or (= i (bytevector-length bytes))
+6
(and (= 0 (bytevector-u8-ref bytes i)) (loop (+ i 1))))))
+7
(define (message signature)
+8
(dbus-message 2 1 (list (cons 5 (dbus-variant "u" 7))) signature '()))
+9
+10
(test-group "owned sensitive reply buffers"
+11
(test "one correctly encoded UTF-8 string; input and final frame cleared"
+12
(let* ((bytes (string->utf8 "héλ🙂")) (reply (dbus-sensitive-reply bytes)) (sent #f))
+13
(dbus-write-sensitive-reply! (message "s") reply
+14
(lambda (frame)
+15
(set! sent frame)
+16
(assert-equal '("héλ🙂") (dbus-message-body (dbus-decode-message frame)))))
+17
(assert-true (zero? bytes))
+18
(assert-true (zero? sent))
+19
(assert-error (dbus-write-sensitive-reply! (message "s") reply (lambda (b) #t)))))
+20
(test "failed write clears both buffers"
+21
(let* ((bytes (bytevector 97 98 99)) (reply (dbus-sensitive-reply bytes)) (sent #f))
+22
(assert-error
+23
(dbus-write-sensitive-reply! (message "s") reply
+24
(lambda (frame) (set! sent frame) (error "forced transport failure"))))
+25
(assert-true (zero? bytes))
+26
(assert-true (zero? sent))))
+27
(test "invalid UTF-8 and embedded NUL rejected and cleared before writing"
+28
(for-each
+29
(lambda (bytes)
+30
(let ((writes 0) (reply (dbus-sensitive-reply bytes)))
+31
(assert-error (dbus-write-sensitive-reply! (message "s") reply
+32
(lambda (frame) (set! writes (+ writes 1)))))
+33
(assert-equal 0 writes)
+34
(assert-true (zero? bytes))))
+35
(list (bytevector 97 0 98) (bytevector 192 128) (bytevector 237 160 128)
+36
(bytevector 240 159))))
+37
(test "wrong output signature rejected and cleared"
+38
(let ((bytes (bytevector 97)))
+39
(assert-error (dbus-write-sensitive-reply! (message "u") (dbus-sensitive-reply bytes)
+40
(lambda (frame) (error "must not write"))))
+41
(assert-true (zero? bytes))))
+42
(test "no-reply call clears without touching transport"
+43
(let ((bytes (bytevector 97)))
+44
(dbus-send-reply! #f (dbus-message 1 7 '() "" '() flags: 1)
+45
"s" (dbus-sensitive-reply bytes))
+46
(assert-true (zero? bytes))))
+47
(test "explicit cancellation clears and prevents reuse"
+48
(let* ((bytes (bytevector 97)) (reply (dbus-sensitive-reply bytes)))
+49
(dbus-sensitive-reply-clear! reply)
+50
(assert-true (zero? bytes))
+51
(assert-error (dbus-write-sensitive-reply! (message "s") reply (lambda (b) #t))))))
+52
(unless (run-tests) (exit 1))