mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 07:04:53 +00:00
* 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>
137 lines
5.3 KiB
JavaScript
137 lines
5.3 KiB
JavaScript
const test = require("node:test");
|
||
const assert = require("node:assert/strict");
|
||
|
||
const {
|
||
ENC_PREFIX,
|
||
MIN_V10_V11_CIPHERTEXT_BYTES,
|
||
MIN_DPAPI_CIPHERTEXT_BYTES,
|
||
encryptCredentialValue,
|
||
decryptCredentialValue,
|
||
looksLikeEncryptedCredential,
|
||
} = require("./credentialBridge.cjs");
|
||
|
||
function fakeSafeStorage({ decryptThrows = false } = {}) {
|
||
const blobs = new Map();
|
||
let nextId = 1;
|
||
return {
|
||
isEncryptionAvailable: () => true,
|
||
encryptString(plaintext) {
|
||
const id = `cipher-${nextId++}`;
|
||
// Pad to a complete CBC-sized blob (header + one AES block).
|
||
const body = Buffer.alloc(MIN_V10_V11_CIPHERTEXT_BYTES, 0);
|
||
Buffer.from("v10", "utf8").copy(body, 0);
|
||
Buffer.from(id, "utf8").copy(body, 3);
|
||
blobs.set(body.toString("base64"), plaintext);
|
||
return body;
|
||
},
|
||
decryptString(buffer) {
|
||
if (decryptThrows) throw new Error("decrypt failed");
|
||
const key = Buffer.from(buffer).toString("base64");
|
||
if (!blobs.has(key)) throw new Error("unknown cipher");
|
||
return blobs.get(key);
|
||
},
|
||
};
|
||
}
|
||
|
||
function completeCiphertextPlaceholder(seed = "stale-key-material") {
|
||
const body = Buffer.alloc(MIN_V10_V11_CIPHERTEXT_BYTES, 0);
|
||
Buffer.from("v10", "utf8").copy(body, 0);
|
||
Buffer.from(seed, "utf8").copy(body, 3);
|
||
return `${ENC_PREFIX}${body.toString("base64")}`;
|
||
}
|
||
|
||
test("looksLikeEncryptedCredential accepts complete CBC-sized v10 payloads", () => {
|
||
assert.equal(looksLikeEncryptedCredential(completeCiphertextPlaceholder()), true);
|
||
});
|
||
|
||
test("looksLikeEncryptedCredential rejects impossible intermediate v10 lengths", () => {
|
||
// 20–30 bytes starting with v10 cannot be CBC (19+16n) or GCM (>=31).
|
||
const body = Buffer.alloc(24, 0);
|
||
Buffer.from("v10", "utf8").copy(body, 0);
|
||
assert.equal(looksLikeEncryptedCredential(`${ENC_PREFIX}${body.toString("base64")}`), false);
|
||
});
|
||
|
||
test("looksLikeEncryptedCredential accepts GCM-sized v10 payloads", () => {
|
||
const body = Buffer.alloc(31, 0);
|
||
Buffer.from("v10", "utf8").copy(body, 0);
|
||
assert.equal(looksLikeEncryptedCredential(`${ENC_PREFIX}${body.toString("base64")}`), true);
|
||
});
|
||
|
||
test("looksLikeEncryptedCredential accepts real Windows DPAPI base64 prefixes", () => {
|
||
// Version + provider GUID {df9d8cd0-1501-11d1-8c7a-00c04fc297eb} + payload.
|
||
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(looksLikeEncryptedCredential(`${ENC_PREFIX}${encoded}`), true);
|
||
});
|
||
|
||
test("looksLikeEncryptedCredential rejects version-only DPAPI-looking blobs", () => {
|
||
const body = Buffer.alloc(MIN_DPAPI_CIPHERTEXT_BYTES, 0);
|
||
body[0] = 0x01;
|
||
body[4] = 0xd0;
|
||
body[5] = 0x8c;
|
||
assert.equal(looksLikeEncryptedCredential(`${ENC_PREFIX}${body.toString("base64")}`), false);
|
||
});
|
||
|
||
test("looksLikeEncryptedCredential rejects header-only enc:v1 payloads", () => {
|
||
assert.equal(looksLikeEncryptedCredential(`${ENC_PREFIX}djEw`), false);
|
||
assert.equal(looksLikeEncryptedCredential(`${ENC_PREFIX}not-real-ciphertext`), false);
|
||
assert.equal(looksLikeEncryptedCredential("password"), false);
|
||
});
|
||
|
||
test("encrypt leaves undecryptable DPAPI enc:v1 ciphertext unchanged", () => {
|
||
const storage = fakeSafeStorage({ decryptThrows: true });
|
||
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 stale = `${ENC_PREFIX}${body.toString("base64")}`;
|
||
assert.equal(encryptCredentialValue(stale, storage), stale);
|
||
});
|
||
|
||
test("encrypt leaves undecryptable complete enc:v1 ciphertext unchanged instead of wrapping again", () => {
|
||
const storage = fakeSafeStorage({ decryptThrows: true });
|
||
const stale = completeCiphertextPlaceholder("stale-key-material");
|
||
const result = encryptCredentialValue(stale, storage);
|
||
assert.equal(result, stale);
|
||
});
|
||
|
||
test("encrypt encrypts header-only enc:v1 coincidence instead of leaving it plaintext", () => {
|
||
const storage = fakeSafeStorage();
|
||
const coincidence = `${ENC_PREFIX}djEw`;
|
||
const result = encryptCredentialValue(coincidence, storage);
|
||
assert.notEqual(result, coincidence);
|
||
assert.ok(result.startsWith(ENC_PREFIX));
|
||
assert.equal(decryptCredentialValue(result, storage), coincidence);
|
||
});
|
||
|
||
test("encrypt still encrypts coincidental plaintext that starts with enc:v1:", () => {
|
||
const storage = fakeSafeStorage();
|
||
const coincidence = `${ENC_PREFIX}totally-plain-password`;
|
||
const result = encryptCredentialValue(coincidence, storage);
|
||
assert.notEqual(result, coincidence);
|
||
assert.ok(result.startsWith(ENC_PREFIX));
|
||
assert.equal(decryptCredentialValue(result, storage), coincidence);
|
||
});
|
||
|
||
test("encrypt round-trips plaintext and does not double-encrypt", () => {
|
||
const storage = fakeSafeStorage();
|
||
const once = encryptCredentialValue("secret", storage);
|
||
const twice = encryptCredentialValue(once, storage);
|
||
assert.equal(twice, once);
|
||
assert.equal(decryptCredentialValue(once, storage), "secret");
|
||
});
|
||
|
||
test("decrypt returns ciphertext unchanged when safeStorage cannot decrypt", () => {
|
||
const storage = fakeSafeStorage({ decryptThrows: true });
|
||
const stale = completeCiphertextPlaceholder("stale");
|
||
assert.equal(decryptCredentialValue(stale, storage), stale);
|
||
});
|