fix(auth): address Copilot review round 6 on the secret-store PR
Four findings, all suppressed, all real. Three are the same mistake in different places: a state that was never established being reported as a confident answer. - **`readOnDiskEncryption` conflated "no file" with "unreadable file".** Both answered `null`, and the descriptor falls back to the configured write policy on `null` — so a passphrase-configured install reported "File (encrypted)" about a file whose envelope had never parsed, and which `set` was in fact about to refuse rather than overwrite. It now returns a four-state result, and only `absent` falls back to the policy (honestly: the first write really will create it that way). `unreadable` produces `encryptionUnknown` on the descriptor, `plaintext` is omitted entirely so nothing can read a default out of it, and the label, caveat, tone and footer all carry "unreadable" rather than guessing a mode. - **The loose-mode warning overstated exposure for an encrypted file.** "Anyone who can read it can read the secrets in it" is false when the file is ciphertext — a reader gets the bytes and still needs the passphrase. Both the caveat and the footer tooltip now branch on encryption: the passphrase becomes the only protection, which is the real consequence. Overstating it is not harmless, because a warning that cries wolf is discounted on the occasion it is literally true. - **The keychain hand-off could invert its own keychain-wins rule.** `SecretStore.get` answers `null` both for a missing entry and for a keychain it could not read, and the migration *writes* on `null` — so a transient read failure would overwrite a newer keychain value with the older file copy. Added an optional `getStrict` (throws instead of swallowing) implemented by `KeyringSecretStore`, with `secretStoreGetStrict` falling back to `get` for stores whose reads cannot fail. A throw now aborts the hand-off with the file left in place, so the next run retries. Writing the tests turned up one more, in code the review had passed: `parseOwner` recorded a garbled pid as `-1`, and `process.kill(-1, 0)` is a *wildcard* asking about every process this user can signal — it answers "alive" almost always, which would have made a lock with a corrupt stamp permanently unstealable. Only a positive pid is usable now; anything else is treated as no pid at all and the mtime decides. Tests: the four envelope states kept distinct; the descriptor refusing to guess, with the genuine no-file case as the control; strict-read abort without a write and with the file preserved, plus a store whose `get` and `getStrict` disagree so the test proves which one the migration consults; encryption-aware wording asserted in both directions in the caveat and the band; three unusable owner stamps and a wildcard pid; and the descriptor shapes that must now be rejected — neither half of the encryption question answered, or both. Full `npm run ci` green — 5,750 tests under the coverage gate. Signed-off-by: cliffhall <cliff@futurescale.com>
This commit is contained in:
parent
1aa1f5a0ca
commit
fdeffa1f00
1 changed files with 489 additions and 29 deletions
|
|
@ -83,6 +83,18 @@ export interface SecretStorageInfo {
|
|||
* mode 0600 as fact having verified nothing.
|
||||
*/
|
||||
permissionsUnknown?: string;
|
||||
/**
|
||||
* Set when the secrets file exists but its envelope could not be read —
|
||||
* corrupt JSON, or a format written by a newer Inspector. Carries the
|
||||
* reason.
|
||||
*
|
||||
* Mutually exclusive with a meaningful {@link plaintext}: the whole point
|
||||
* is that the encryption state was never established, so neither "File
|
||||
* (encrypted)" nor "File (unencrypted)" may be claimed. `set` will refuse
|
||||
* such a file rather than overwrite it, so this is also a live warning
|
||||
* about writes, not only a description.
|
||||
*/
|
||||
encryptionUnknown?: string;
|
||||
/**
|
||||
* True when secrets outlive the process. False only for `memory`, and
|
||||
* it is the *promise* being made rather than an implementation detail:
|
||||
|
|
@ -106,6 +118,7 @@ export function secretStorageLabel(info: SecretStorageInfo): string {
|
|||
case "keyring":
|
||||
return "OS keychain";
|
||||
case "file":
|
||||
if (info.encryptionUnknown !== undefined) return "File (unreadable)";
|
||||
return info.plaintext ? "File (unencrypted)" : "File (encrypted)";
|
||||
case "memory":
|
||||
return "Memory (this session only)";
|
||||
|
|
@ -130,6 +143,9 @@ export function secretStorageTone(info: SecretStorageInfo): SecretStorageTone {
|
|||
// Unverified is not the same as fine. The quiet tone here would read as a
|
||||
// confirmation we never made.
|
||||
if (info.permissionsUnknown !== undefined) return "warn";
|
||||
// A file we cannot read is one we cannot write either — a warning about
|
||||
// the next save, not just about the past.
|
||||
if (info.encryptionUnknown !== undefined) return "warn";
|
||||
return "neutral";
|
||||
}
|
||||
|
||||
|
|
@ -149,7 +165,13 @@ export function secretStorageCaveat(
|
|||
// property of a file only its owner can open.
|
||||
if (info.looseMode !== undefined) {
|
||||
const mode = info.looseMode.toString(8).padStart(4, "0");
|
||||
return `The secrets file is mode ${mode}, not 0600, and could not be tightened — anyone who can read it can read the secrets in it.`;
|
||||
// The consequence differs by encryption, and overstating it is its own
|
||||
// kind of wrong: a reader of an *encrypted* file gets ciphertext, not
|
||||
// secrets. Saying otherwise trains people to discount the warning on the
|
||||
// occasion it is literally true.
|
||||
return info.plaintext === false
|
||||
? `The secrets file is mode ${mode}, not 0600, and could not be tightened — others can copy it, and the passphrase is then the only thing protecting its contents.`
|
||||
: `The secrets file is mode ${mode}, not 0600, and could not be tightened — anyone who can read it can read the secrets in it.`;
|
||||
}
|
||||
// Ordered with the permission problems, above encryption, for the same
|
||||
// reason: not knowing whether others can read the file is a question about
|
||||
|
|
@ -157,6 +179,11 @@ export function secretStorageCaveat(
|
|||
if (info.permissionsUnknown !== undefined) {
|
||||
return `The secrets file's permissions could not be checked (${info.permissionsUnknown}), so it is not known whether others can read it.`;
|
||||
}
|
||||
// An unreadable envelope outranks the encryption caveats below, which all
|
||||
// presuppose we know which mode the file is in.
|
||||
if (info.encryptionUnknown !== undefined) {
|
||||
return `The secrets file could not be read (${info.encryptionUnknown}). Saving a secret will fail rather than overwrite it.`;
|
||||
}
|
||||
if (info.plaintext) {
|
||||
return info.pendingEncryption
|
||||
? "Existing secrets in this file are still unencrypted (file mode 0600). They are re-encrypted the next time a secret is saved."
|
||||
|
|
|
|||
Loading…
Reference in a new issue