Files
Netcatty/domain/credentials.test.ts
T
904af93a1d fix(credentials): 防止解密失败后二次加密污染本地与云端 (#2702) (#2770)
* fix(credentials): stop double-encrypting undecryptable safeStorage blobs

When local decrypt failed (e.g. OSCrypt key churn after reboot), encrypt
used to wrap the leftover enc:v1 ciphertext again, permanently poisoning
the vault. Startup sync could also push those placeholders to cloud and
make download restore the same poison.

- Keep real enc:v1 blobs unchanged on encrypt (header check, no wrap)
- Strip device-bound placeholders when applying portable sync payloads
- Guard startup local-wins / merge round-trips before upload
- Skip vault init re-encrypt writes when secrets are still undecrypted

Fixes #2702

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(sync): strip enc:v1 secrets from smart-merge uploads

Bugbot found that after local apply sanitized placeholders, legacy v1
smart-merge could still decrypt an unstripped remote, merge it, and
re-upload the poison. Strip device-bound credentials on remote decrypt
and again on the merged payload before upload.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): address Codex P2 review on #2702

- Always re-encrypt vault init batches so plaintext siblings are not
  left unprotected when one record is a stale enc:v1 placeholder
- Sanitize device-bound secrets before convergent restore prepare so
  CRDT replica commit matches vault import
- Require a complete safeStorage blob (header + min 31 bytes) before
  treating enc:v1 as ciphertext; encrypt header-only coincidences

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): address Codex P1 review on #2702

- Decode enc:v1 payloads with atob in the renderer-safe domain helper
- Heal poisoned remote secrets from local/base before smart-merge so
  good credentials are not discarded as remote-only deletions
- Keep post-merge strip so leftover enc:v1 never uploads

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): address Codex P1 CBC min and startup heal

- Accept 19-byte v10/v11 CBC OSCrypt blobs (not only 31-byte GCM)
- Heal poisoned remote secrets before startup smart-merge
- Strip unresolved placeholders on merge round-trip upload

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(sync): sanitize payloads at every apply/commit boundary

Codex P1: vault apply stripped enc:v1 while commitRemoteInspection and
convergent materialization could keep the poison. Sanitize merged/remote
payloads before apply+base commit, strip on CRDT materialization, and
sanitize convergent apply inputs.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(sync): heal local and remote secrets before smart-merge

Smart-merge could select a locally-changed entity whose only secret
delta was enc:v1 poison, then strip and upload empty secrets. Heal
both sides from the opposite payload/base before merge on all sync
paths.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(sync): keep enc:v1 intact during convergent materialize

Stripping device-bound secrets inside materializeSyncPayloadFromConvergentState
broke envelope validation for poisoned-but-consistent v2 snapshots, so decrypt
could not hydrate the clouds #2702 needs to recover. Portable stripping stays
at apply/upload boundaries.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): detect Windows DPAPI by decoded header bytes

Real DPAPI blobs start with 01 00 00 00 d0 8c... and base64-encode as
AQAAANCM..., so the previous AQAAAA string prefix rejected them and
allowed double-wrapping after key rotation. Match decoded headers in
both the main-process bridge and renderer predicate.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* test(credentials): use complete enc:v1 fixtures for stricter detector

Short placeholders like enc:v1:djEwAAAA no longer pass the platform
header + minimum-size checks. Update auth/SFTP/proxy/sync fixtures to
full v10-shaped blobs so npm test matches production validation.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(sync): treat preferred credential deletions as authoritative

When healing enc:v1 before merge, an empty/missing secret on a present
preferred entity is an intentional clear and must not be revived from
base. Only fall back to base when preferred is absent or also poisoned.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): reject impossible v10/v11 ciphertext lengths

Accept only CBC-aligned sizes (19+16n) or GCM-sized blobs (>=31) so
coincidental enc:v1 plaintext of intermediate length is encrypted instead
of treated as an undecryptable placeholder.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

* fix(credentials): require full DPAPI provider GUID signature

Accept Windows safeStorage blobs only when they start with version
01 00 00 00 plus provider GUID df9d8cd0-1501-11d1-8c7a-00c04fc297eb,
so coincidental 01 00 00 00 prefixes are not treated as ciphertext.

Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>

---------

Co-authored-by: Cursor Agent <cursoragent@cursor.com>
Co-authored-by: 陈大猫 <binaricat@users.noreply.github.com>
2026-08-06 13:17:24 +08:00

159 lines
4.8 KiB
TypeScript

import test from "node:test";
import assert from "node:assert/strict";
import {
findSyncPayloadEncryptedCredentialPaths,
healPoisonedSecretsForMerge,
isEncryptedCredentialPlaceholder,
stripSyncPayloadEncryptedCredentials,
} from "./credentials.ts";
import type { SyncPayload } from "./sync.ts";
const completeBlob = Buffer.alloc(19, 0);
Buffer.from("v10", "utf8").copy(completeBlob, 0);
const ENC = `enc:v1:${completeBlob.toString("base64")}`;
function samplePayload(overrides: Partial<SyncPayload> = {}): SyncPayload {
return {
hosts: [
{
id: "h1",
label: "prod",
hostname: "prod.example",
username: "root",
password: ENC,
port: 22,
os: "linux",
group: "",
tags: [],
protocol: "ssh",
},
],
keys: [
{
id: "k1",
label: "key",
type: "ED25519",
privateKey: ENC,
source: "imported",
category: "key",
created: 1,
},
],
identities: [],
snippets: [],
customGroups: [],
syncedAt: 1,
...overrides,
};
}
test("isEncryptedCredentialPlaceholder detects complete v10 device-bound ciphertext", () => {
assert.equal(isEncryptedCredentialPlaceholder(ENC), true);
});
test("isEncryptedCredentialPlaceholder rejects intermediate v10 lengths that are neither CBC nor GCM", () => {
const body = Buffer.alloc(24, 0);
Buffer.from("v10", "utf8").copy(body, 0);
assert.equal(isEncryptedCredentialPlaceholder(`enc:v1:${body.toString("base64")}`), false);
});
test("isEncryptedCredentialPlaceholder detects real Windows DPAPI base64 prefixes", () => {
const body = Buffer.from([
0x01, 0x00, 0x00, 0x00,
0xd0, 0x8c, 0x9d, 0xdf, 0x01, 0x15, 0xd1, 0x11,
0x8c, 0x7a, 0x00, 0xc0, 0x4f, 0xc2, 0x97, 0xeb,
0xaa,
]);
const encoded = body.toString("base64");
assert.equal(encoded.startsWith("AQAAANCMnd8"), true);
assert.equal(isEncryptedCredentialPlaceholder(`enc:v1:${encoded}`), true);
});
test("isEncryptedCredentialPlaceholder rejects header-only enc:v1 payloads", () => {
assert.equal(isEncryptedCredentialPlaceholder("enc:v1:djEw"), false);
});
test("findSyncPayloadEncryptedCredentialPaths reports host and key secrets", () => {
const paths = findSyncPayloadEncryptedCredentialPaths(samplePayload());
assert.deepEqual(paths, ["hosts[0].password", "keys[0].privateKey"]);
});
test("stripSyncPayloadEncryptedCredentials clears device-bound placeholders for recovery", () => {
const stripped = stripSyncPayloadEncryptedCredentials(samplePayload());
assert.equal(stripped.hosts[0]?.password, undefined);
assert.equal(stripped.keys[0]?.privateKey, "");
assert.equal(findSyncPayloadEncryptedCredentialPaths(stripped).length, 0);
});
test("healPoisonedSecretsForMerge keeps usable preferred passwords over poisoned enc:v1", () => {
const poisoned = samplePayload();
const preferred = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
password: "preferred-secret",
}],
keys: [{
...samplePayload().keys[0]!,
privateKey: "PREFERRED_PRIVATE_KEY",
}],
});
const fallback = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
password: "base-secret",
}],
});
const healed = healPoisonedSecretsForMerge(poisoned, preferred, fallback);
assert.equal(healed.hosts[0]?.password, "preferred-secret");
assert.equal(healed.keys[0]?.privateKey, "PREFERRED_PRIVATE_KEY");
});
test("healPoisonedSecretsForMerge heals local poison from remote then base", () => {
const local = samplePayload();
const remote = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
password: "remote-secret",
}],
keys: [{
...samplePayload().keys[0]!,
privateKey: ENC,
}],
});
const base = samplePayload({
keys: [{
...samplePayload().keys[0]!,
privateKey: "BASE_PRIVATE_KEY",
}],
});
const healed = healPoisonedSecretsForMerge(local, remote, base);
assert.equal(healed.hosts[0]?.password, "remote-secret");
assert.equal(healed.keys[0]?.privateKey, "BASE_PRIVATE_KEY");
});
test("healPoisonedSecretsForMerge preserves explicit preferred credential deletions", () => {
const poisoned = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
label: "renamed-on-poisoned-device",
password: ENC,
}],
});
const preferred = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
label: "renamed-on-poisoned-device",
password: undefined,
}],
});
const fallback = samplePayload({
hosts: [{
...samplePayload().hosts[0]!,
password: "base-secret",
}],
});
const healed = healPoisonedSecretsForMerge(poisoned, preferred, fallback);
assert.equal(healed.hosts[0]?.password, undefined);
assert.equal(healed.hosts[0]?.label, "renamed-on-poisoned-device");
});