@shieldfive/cli 0.2.1 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,525 @@
1
+ // ShieldFive CLI — the agent process.
2
+ //
3
+ // Holds one signed-in session and the unwrapped vault root key, in memory only,
4
+ // and serves the write-only protocol in protocol.mjs on a Unix domain socket.
5
+ // See docs/agent-design.md for why it exists and what it will never do.
6
+
7
+ import { createHmac, randomUUID } from 'node:crypto'
8
+ import { chmod, open, readFile, rm, stat } from 'node:fs/promises'
9
+ import { connect, createServer } from 'node:net'
10
+ import { basename, dirname, join } from 'node:path'
11
+
12
+ import { refreshAccessToken, revokeSession } from '../auth.mjs'
13
+ import { MANIFEST_NAME, scanFiles } from '../sync.mjs'
14
+ import { appendEntry, classify, deriveLedgerKey, ledgerPath, macFile, readEntries } from './ledger.mjs'
15
+ import { ensurePrivateDir, ledgerDir } from './paths.mjs'
16
+ import { encode, fail, lineSplitter, ok, parseRequest } from './protocol.mjs'
17
+
18
+ export const DEFAULT_IDLE_MS = 8 * 60 * 60 * 1000
19
+
20
+ // Refresh a little before expiry rather than on a 401, so a long upload does
21
+ // not start with a token that dies halfway through.
22
+ const REFRESH_MARGIN_S = 120
23
+ const REFRESH_TIMEOUT_MS = 15_000
24
+
25
+ // Everything stop() does on the network — refreshing an expired token and
26
+ // revoking the session — shares one budget. Keys are wiped before it starts.
27
+ const STOP_NETWORK_BUDGET_MS = 5_000
28
+
29
+ // Only these count as use for the idle lock. A status probe does no work; if it
30
+ // counted, a shell prompt or a health check polling `sf status` would keep the
31
+ // agent unlocked forever.
32
+ const USE_OPS = new Set(['upload', 'sync', 'verify'])
33
+
34
+ class AgentError extends Error {
35
+ constructor(code, message) {
36
+ super(message)
37
+ this.code = code
38
+ }
39
+ }
40
+
41
+ /** Resolve true when something accepts a connection on `path`. */
42
+ export function socketAnswers(path, { timeoutMs = 500 } = {}) {
43
+ return new Promise((resolve) => {
44
+ const s = connect({ path })
45
+ const timer = setTimeout(() => {
46
+ s.destroy()
47
+ resolve(false)
48
+ }, timeoutMs)
49
+ s.on('connect', () => {
50
+ clearTimeout(timer)
51
+ s.destroy()
52
+ resolve(true)
53
+ })
54
+ s.on('error', () => {
55
+ clearTimeout(timer)
56
+ resolve(false)
57
+ })
58
+ })
59
+ }
60
+
61
+ function pidAlive(pid) {
62
+ try {
63
+ process.kill(pid, 0)
64
+ return true
65
+ } catch (err) {
66
+ // EPERM: the process exists but belongs to someone else. Treat it as alive.
67
+ return err.code === 'EPERM'
68
+ }
69
+ }
70
+
71
+ export function createAgent({
72
+ session,
73
+ rootKey,
74
+ config,
75
+ socket,
76
+ home,
77
+ device,
78
+ idleMs = DEFAULT_IDLE_MS,
79
+ uploadFile,
80
+ fetchImpl = fetch,
81
+ now = () => Date.now(),
82
+ log = () => {},
83
+ onStop = () => {},
84
+ stopBudgetMs = STOP_NETWORK_BUDGET_MS,
85
+ }) {
86
+ if (!session?.refreshToken) {
87
+ throw new AgentError(
88
+ 'no_refresh_token',
89
+ 'Sign-in did not produce a refresh token for the stepped-up session, so ' +
90
+ 'the agent would stop working within the hour. Run sf login again.',
91
+ )
92
+ }
93
+ if (!session.userId) throw new AgentError('no_account', 'Sign-in did not report an account id.')
94
+ if (!(rootKey instanceof Uint8Array) || rootKey.length !== 32) {
95
+ throw new AgentError('bad_key', 'The agent needs the 32-byte vault root key.')
96
+ }
97
+ if (typeof uploadFile !== 'function') throw new AgentError('bad_config', 'uploadFile is required.')
98
+ if (typeof device !== 'string' || !device) throw new AgentError('bad_config', 'A device id is required.')
99
+
100
+ // Copies this agent owns and overwrites on stop.
101
+ const key = Buffer.from(rootKey)
102
+ const ledgerKey = deriveLedgerKey(key)
103
+ const ledgerFile = ledgerPath(ledgerDir(home), session.userId)
104
+ const lockFile = join(dirname(socket), 'agent.lock')
105
+ const lockToken = `${process.pid}:${randomUUID()}`
106
+
107
+ let tokens = {
108
+ access: session.accessToken,
109
+ refresh: session.refreshToken,
110
+ expiresAt: session.expiresAt,
111
+ }
112
+ let refreshing = null
113
+ let server = null
114
+ let idleTimer = null
115
+ let inFlight = 0
116
+ let stopping = null
117
+ let idleDeadline = 0
118
+
119
+ function touch() {
120
+ clearTimeout(idleTimer)
121
+ idleDeadline = now() + idleMs
122
+ idleTimer = setTimeout(() => {
123
+ if (inFlight > 0) return touch()
124
+ stop('idle')
125
+ }, idleMs)
126
+ idleTimer.unref?.()
127
+ }
128
+
129
+ function assertRunning(what) {
130
+ if (stopping) {
131
+ throw new AgentError('locked', `The agent was locked or logged out ${what}.`)
132
+ }
133
+ }
134
+
135
+ async function accessToken() {
136
+ assertRunning('before this request could run')
137
+ if (tokens.expiresAt && now() / 1000 < tokens.expiresAt - REFRESH_MARGIN_S) {
138
+ return tokens.access
139
+ }
140
+ // Single flight. Supabase rotates refresh tokens, and presenting the same
141
+ // one twice outside its short grace window revokes the whole session, so
142
+ // three requests arriving at an expired token must share one refresh.
143
+ refreshing ??= refreshAccessToken({
144
+ supabaseUrl: config.supabaseUrl,
145
+ anonKey: config.anonKey,
146
+ refreshToken: tokens.refresh,
147
+ fetchImpl,
148
+ signal: AbortSignal.timeout(REFRESH_TIMEOUT_MS),
149
+ })
150
+ .then((s) => {
151
+ // A refresh that lands after stop() wiped the tokens must not put them
152
+ // back.
153
+ if (!stopping) tokens = { access: s.accessToken, refresh: s.refreshToken, expiresAt: s.expiresAt }
154
+ return s.accessToken
155
+ })
156
+ .catch((err) => {
157
+ if (err.status === 400 || err.status === 401) {
158
+ // Revoked elsewhere, or reused. Nothing this agent holds will work
159
+ // again, so stop instead of failing every request until idle.
160
+ stop('session_revoked', { revoke: false })
161
+ throw new AgentError('session_revoked', 'This session was signed out. Run sf login again.')
162
+ }
163
+ throw err
164
+ })
165
+ .finally(() => {
166
+ refreshing = null
167
+ })
168
+ return refreshing
169
+ }
170
+
171
+ async function verifyFileIds(ids) {
172
+ const token = await accessToken()
173
+ const res = await fetchImpl(new URL('/api/mobile/media/verify', config.apiBaseUrl), {
174
+ method: 'POST',
175
+ headers: { Authorization: `Bearer ${token}`, 'Content-Type': 'application/json' },
176
+ body: JSON.stringify({ fileIds: ids }),
177
+ })
178
+ const body = await res.json().catch(() => ({}))
179
+ if (!res.ok) {
180
+ // Fail the whole request rather than reporting everything `missing`. A
181
+ // verification that did not happen is not an answer of either kind.
182
+ throw new AgentError(
183
+ 'verify_failed',
184
+ `The server could not verify backups (HTTP ${res.status}${body.code ? `, ${body.code}` : ''}). ` +
185
+ 'Nothing was classified.',
186
+ )
187
+ }
188
+ return Array.isArray(body.verified) ? body.verified : []
189
+ }
190
+
191
+ async function upload(path) {
192
+ const before = await stat(path)
193
+ if (!before.isFile()) throw new AgentError('not_a_file', `${path} is not a regular file.`)
194
+ const token = await accessToken()
195
+
196
+ // The MAC recorded is the MAC of exactly the bytes that were encrypted, fed
197
+ // in chunk by chunk as uploadFile reads them. Hashing the file before and
198
+ // after the upload cannot see a change that is made and undone while it is
199
+ // being read: both reads agree, and the vault holds something else.
200
+ const hmac = createHmac('sha256', ledgerKey)
201
+ let streamed = 0
202
+
203
+ // uploadFile gets its own copy of the key, wiped when it returns. If a
204
+ // logout zeroed the agent's copy while an upload was still wrapping the
205
+ // file's content key, that key would be wrapped under zeros and the file in
206
+ // the vault would never decrypt.
207
+ const uploadKey = Buffer.from(key)
208
+ let fileId
209
+ try {
210
+ ;({ fileId } = await uploadFile({
211
+ apiBaseUrl: config.apiBaseUrl,
212
+ accessToken: token,
213
+ rootKey: uploadKey,
214
+ name: basename(path),
215
+ path,
216
+ size: before.size,
217
+ onPlaintextChunk: (chunk) => {
218
+ hmac.update(chunk)
219
+ streamed += chunk.length
220
+ },
221
+ }))
222
+ } finally {
223
+ uploadKey.fill(0)
224
+ }
225
+ const mac = hmac.digest('hex')
226
+
227
+ assertRunning(`while ${path} was uploading. It reached the vault but is not recorded, so sf verify will not vouch for it`)
228
+ if (streamed !== before.size) {
229
+ throw new AgentError(
230
+ 'not_recorded',
231
+ `${path} changed size while it was uploading (${before.size} bytes expected, ${streamed} read). ` +
232
+ 'It is not recorded as a backup.',
233
+ )
234
+ }
235
+
236
+ await appendEntry(
237
+ ledgerFile,
238
+ {
239
+ path,
240
+ size: streamed,
241
+ mtimeMs: before.mtimeMs,
242
+ mac,
243
+ fileId,
244
+ uploadedAt: new Date(now()).toISOString(),
245
+ device,
246
+ },
247
+ { ledgerKey },
248
+ )
249
+
250
+ // Whether the file on disk now is the one that was uploaded. It does not
251
+ // change what was recorded, which describes the upload; it tells push and
252
+ // sync whether this file needs uploading again.
253
+ let matchesFileNow = false
254
+ if (!stopping) {
255
+ try {
256
+ matchesFileNow = (await macFile(path, ledgerKey)) === mac
257
+ } catch {
258
+ // Unreadable now: leave it false.
259
+ }
260
+ }
261
+ return { fileId, size: streamed, matchesFileNow, mac }
262
+ }
263
+
264
+ async function sync(folder) {
265
+ const st = await stat(folder)
266
+ if (!st.isDirectory()) throw new AgentError('not_a_directory', `${folder} is not a directory.`)
267
+
268
+ const files = await scanFiles(folder, { exclude: [MANIFEST_NAME] })
269
+ const { entries } = await readEntries(ledgerFile, { ledgerKey })
270
+ const done = new Set(entries.filter((e) => e.device === device).map((e) => `${e.path}\u0000${e.mac}`))
271
+
272
+ let uploaded = 0
273
+ let skipped = 0
274
+ let failed = 0
275
+ let changed = 0
276
+ const errors = []
277
+ for (const f of files) {
278
+ assertRunning(`during sync, after uploading ${uploaded} file(s)`)
279
+ try {
280
+ const mac = await macFile(f.path, ledgerKey)
281
+ if (done.has(`${f.path}\u0000${mac}`)) {
282
+ skipped++
283
+ continue
284
+ }
285
+ const r = await upload(f.path)
286
+ uploaded++
287
+ done.add(`${f.path}\u0000${r.mac}`)
288
+ if (!r.matchesFileNow) changed++
289
+ } catch (err) {
290
+ if (err.code === 'session_revoked' || err.code === 'locked') throw err
291
+ failed++
292
+ errors.push({ path: f.path, message: err.message })
293
+ }
294
+ }
295
+ return { uploaded, skipped, failed, changed, errors }
296
+ }
297
+
298
+ async function handle(req) {
299
+ switch (req.op) {
300
+ case 'status':
301
+ return {
302
+ unlocked: !stopping,
303
+ account: session.userId,
304
+ idleLocksInSec: Math.max(0, Math.round((idleDeadline - now()) / 1000)),
305
+ pid: process.pid,
306
+ }
307
+ case 'upload': {
308
+ // The MAC stays in the ledger. A process on the socket has no use for a
309
+ // keyed digest.
310
+ const { fileId, size, matchesFileNow } = await upload(req.args.path)
311
+ return { fileId, size, matchesFileNow }
312
+ }
313
+ case 'sync':
314
+ return sync(req.args.folder)
315
+ case 'verify': {
316
+ const { entries } = await readEntries(ledgerFile, { ledgerKey })
317
+ return classify(req.args.paths, { entries, ledgerKey, verifyFileIds, device })
318
+ }
319
+ case 'lock': {
320
+ const { revoked, status } = await stop('lock')
321
+ return { locked: true, sessionRevoked: revoked, revokeStatus: status }
322
+ }
323
+ case 'logout': {
324
+ const everywhere = req.args.everywhere === true
325
+ const { revoked, status } = await stop('logout', { everywhere })
326
+ return { loggedOut: true, everywhere, sessionRevoked: revoked, revokeStatus: status }
327
+ }
328
+ default:
329
+ throw new AgentError('unknown_op', `Unknown operation ${req.op}.`)
330
+ }
331
+ }
332
+
333
+ function onConnection(conn) {
334
+ conn.setEncoding('utf8')
335
+ conn.on('error', () => {})
336
+ let handled = false
337
+
338
+ const reply = (message) => {
339
+ if (!conn.destroyed) conn.end(encode(message))
340
+ }
341
+
342
+ const feed = lineSplitter(async (line) => {
343
+ // One request per connection. Anything after the first line is ignored.
344
+ if (handled) return
345
+ handled = true
346
+
347
+ let req
348
+ try {
349
+ req = parseRequest(line)
350
+ } catch (err) {
351
+ return reply(fail(null, err.code ?? 'bad_request', err.message))
352
+ }
353
+ if (stopping && req.op !== 'status') {
354
+ return reply(fail(req.id, 'locked', 'The agent is locked. Run sf login.'))
355
+ }
356
+
357
+ inFlight++
358
+ let succeeded = false
359
+ try {
360
+ reply(ok(req.id, await handle(req)))
361
+ succeeded = true
362
+ } catch (err) {
363
+ reply(fail(req.id, err.code ?? 'error', err.message))
364
+ } finally {
365
+ inFlight--
366
+ if (!stopping && succeeded && USE_OPS.has(req.op)) touch()
367
+ }
368
+ })
369
+
370
+ conn.on('data', (chunk) => {
371
+ try {
372
+ feed(chunk)
373
+ } catch (err) {
374
+ reply(fail(null, err.code ?? 'bad_request', err.message))
375
+ }
376
+ })
377
+ }
378
+
379
+ async function acquireLock() {
380
+ for (let attempt = 0; attempt < 2; attempt++) {
381
+ try {
382
+ const handle = await open(lockFile, 'wx', 0o600)
383
+ try {
384
+ await handle.writeFile(lockToken)
385
+ } finally {
386
+ await handle.close()
387
+ }
388
+ return
389
+ } catch (err) {
390
+ if (err.code !== 'EEXIST') throw err
391
+ }
392
+ const held = (await readFile(lockFile, 'utf8').catch(() => '')).trim()
393
+ const [pidText] = held.split(':')
394
+ const pid = Number(pidText)
395
+ // Same process, different agent (tests do this): alive. Another process:
396
+ // alive if it still runs. Anything else was left by an agent that died.
397
+ const alive = pid === process.pid ? held !== lockToken : pid > 0 && pidAlive(pid)
398
+ if (alive) {
399
+ throw new AgentError('already_running', 'An agent is already running. Run sf status or sf logout.')
400
+ }
401
+ await rm(lockFile, { force: true })
402
+ }
403
+ throw new AgentError('already_running', 'Another agent is starting at the same moment. Try again.')
404
+ }
405
+
406
+ async function releaseLock() {
407
+ const held = (await readFile(lockFile, 'utf8').catch(() => '')).trim()
408
+ // Only ever remove our own lock. A lock that belongs to a newer agent is not
409
+ // ours to release.
410
+ if (held === lockToken) await rm(lockFile, { force: true })
411
+ }
412
+
413
+ async function revokeHeld(held, everywhere, signal) {
414
+ let access = held.access
415
+ const expired = !held.expiresAt || now() / 1000 >= held.expiresAt - REFRESH_MARGIN_S
416
+ if (expired && held.refresh) {
417
+ try {
418
+ access = (
419
+ await refreshAccessToken({
420
+ supabaseUrl: config.supabaseUrl,
421
+ anonKey: config.anonKey,
422
+ refreshToken: held.refresh,
423
+ fetchImpl,
424
+ signal,
425
+ })
426
+ ).accessToken
427
+ } catch {
428
+ // Fall back to the token we hold; the revoke says whether it worked.
429
+ }
430
+ }
431
+ return revokeSession({
432
+ supabaseUrl: config.supabaseUrl,
433
+ anonKey: config.anonKey,
434
+ accessToken: access,
435
+ scope: everywhere ? 'global' : 'local',
436
+ fetchImpl,
437
+ signal,
438
+ })
439
+ }
440
+
441
+ function stop(reason, { revoke = true, everywhere = false } = {}) {
442
+ if (stopping) return stopping
443
+ stopping = (async () => {
444
+ clearTimeout(idleTimer)
445
+ // Stop accepting connections. Node removes the socket file when a Unix
446
+ // server closes; nothing here deletes that path by name, because by the
447
+ // time a slow revoke finishes a newer agent may be listening there.
448
+ server?.close()
449
+
450
+ // Decryption material first, before anything touches the network, so a
451
+ // revoke that hangs cannot keep the vault key alive while it waits. An
452
+ // upload already running has its own copy, wiped when it returns.
453
+ key.fill(0)
454
+ ledgerKey.fill(0)
455
+ const held = tokens
456
+ tokens = { access: null, refresh: null, expiresAt: null }
457
+
458
+ let result = { revoked: false, status: 0 }
459
+ if (revoke) {
460
+ // A plain timer rather than AbortSignal.timeout: that one does not keep
461
+ // the process alive, and with the server closed nothing else might. The
462
+ // race means a request that ignores the signal cannot hold stop() open.
463
+ const controller = new AbortController()
464
+ const timer = setTimeout(() => controller.abort(), stopBudgetMs)
465
+ const outOfTime = new Promise((resolve) =>
466
+ controller.signal.addEventListener('abort', () => resolve({ revoked: false, status: 0 }), { once: true }),
467
+ )
468
+ try {
469
+ result = await Promise.race([revokeHeld(held, everywhere, controller.signal), outOfTime])
470
+ } catch {
471
+ // Unreachable. status stays 0, which callers report as "could not reach
472
+ // the server", distinct from a refusal.
473
+ } finally {
474
+ clearTimeout(timer)
475
+ }
476
+ }
477
+
478
+ await releaseLock()
479
+ log(`agent stopped (${reason})`)
480
+ onStop(reason, result)
481
+ return result
482
+ })()
483
+ return stopping
484
+ }
485
+
486
+ return {
487
+ async start() {
488
+ await ensurePrivateDir(dirname(socket))
489
+ await ensurePrivateDir(ledgerDir(home))
490
+ // The lock, not the socket, decides who may start. Checking the socket and
491
+ // then removing a stale one left a window in which two agents could both
492
+ // conclude nothing was listening.
493
+ await acquireLock()
494
+ try {
495
+ if (await socketAnswers(socket)) {
496
+ throw new AgentError('already_running', 'An agent is already running. Run sf status or sf logout.')
497
+ }
498
+ // We hold the lock and nothing answered, so whatever is at this path is
499
+ // a leftover from an agent that died.
500
+ await rm(socket, { force: true })
501
+
502
+ server = createServer(onConnection)
503
+ await new Promise((resolve, reject) => {
504
+ server.once('error', reject)
505
+ server.listen(socket, () => {
506
+ server.off('error', reject)
507
+ resolve()
508
+ })
509
+ })
510
+ // The directory is already 0700; this is the second lock on the same door.
511
+ await chmod(socket, 0o600)
512
+ } catch (err) {
513
+ server?.close()
514
+ await releaseLock()
515
+ throw err
516
+ }
517
+ touch()
518
+ log(`agent listening on ${socket}`)
519
+ },
520
+ stop,
521
+ get stopped() {
522
+ return Boolean(stopping)
523
+ },
524
+ }
525
+ }
package/src/argon2.mjs ADDED
@@ -0,0 +1,69 @@
1
+ import { hkdfSync } from 'node:crypto'
2
+
3
+ // Argon2id master-secret derivation, byte-identical to
4
+ // @shieldfive/crypto/kdf/argon2id deriveMasterSecret (the web's and the
5
+ // vault's reference implementation): libsodium presets, Argon2id v0x13,
6
+ // parallelism 1, 32-byte output, and salts longer than 16 bytes compressed
7
+ // through HKDF-SHA-256 (zero salt, info 'shieldfive/v1/argon2id/salt-compression').
8
+ //
9
+ // Two backends, same bytes:
10
+ //
11
+ // - native `argon2` (an optionalDependency): async, runs on the libuv thread
12
+ // pool so the event loop keeps turning, and several times faster.
13
+ // - @shieldfive/crypto over libsodium WASM: always installed. Used when the
14
+ // native module is missing, which is expected on platforms `argon2` ships no
15
+ // prebuilt binary for (Intel macOS, Windows on ARM) and where compiling it
16
+ // failed. npm drops a failed optional dependency instead of failing the
17
+ // install, so `npm i -g @shieldfive/cli` never hard-fails on it.
18
+ //
19
+ // Parameters are never reduced on either path. test/argon2.backends.test.mjs
20
+ // pins the two backends against each other and against web-produced vectors.
21
+
22
+ const PRESETS = {
23
+ moderate: { timeCost: 3, memoryCost: 262144 }, // OPSLIMIT/MEMLIMIT_MODERATE (256 MiB)
24
+ sensitive: { timeCost: 4, memoryCost: 1048576 }, // OPSLIMIT/MEMLIMIT_SENSITIVE (1 GiB)
25
+ }
26
+
27
+ let nativePromise
28
+ async function loadNative() {
29
+ if (process.env.SF_ARGON2_BACKEND === 'wasm') return null
30
+ nativePromise ??= import('argon2').then(
31
+ (m) => (typeof m.hash === 'function' ? m : m.default ?? null),
32
+ () => null,
33
+ )
34
+ return nativePromise
35
+ }
36
+
37
+ /** 'native' or 'wasm': which backend the next derivation will use. */
38
+ export async function argon2Backend() {
39
+ return (await loadNative()) ? 'native' : 'wasm'
40
+ }
41
+
42
+ function validate({ passphrase, salt, preset }) {
43
+ if (typeof passphrase !== 'string' || !passphrase) throw new Error('Passphrase is required')
44
+ if (!(salt instanceof Uint8Array) || salt.length < 16) throw new Error('Argon2id salt must be at least 16 bytes')
45
+ const params = Object.hasOwn(PRESETS, preset) ? PRESETS[preset] : null
46
+ if (!params) throw new Error(`Unsupported Argon2id preset: ${preset}`)
47
+ return params
48
+ }
49
+
50
+ export async function deriveMasterSecret({ passphrase, salt, preset = 'moderate' }) {
51
+ const params = validate({ passphrase, salt, preset })
52
+ const native = await loadNative()
53
+ if (!native) {
54
+ const { deriveMasterSecret: wasmDerive } = await import('@shieldfive/crypto/kdf/argon2id')
55
+ const { masterSecret } = await wasmDerive({ passphrase, salt, preset })
56
+ return { masterSecret, salt, preset }
57
+ }
58
+ const usableSalt = salt.length === 16 ? Buffer.from(salt) : Buffer.from(hkdfSync(
59
+ 'sha256', salt, Buffer.alloc(32), 'shieldfive/v1/argon2id/salt-compression', 16,
60
+ ))
61
+ const input = Buffer.from(passphrase, 'utf8')
62
+ try {
63
+ const masterSecret = await native.hash(input, {
64
+ ...params, salt: usableSalt, type: native.argon2id, version: 0x13,
65
+ parallelism: 1, hashLength: 32, raw: true,
66
+ })
67
+ return { masterSecret, salt, preset } // a Buffer, i.e. a Uint8Array the caller zeroes
68
+ } finally { input.fill(0); usableSalt.fill(0) }
69
+ }