mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-20 15:19:16 +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>
189 lines
6.5 KiB
JavaScript
189 lines
6.5 KiB
JavaScript
/**
|
|
* Credential Bridge - Field-level encryption for sensitive data at rest
|
|
*
|
|
* Uses Electron's safeStorage API to encrypt individual sensitive fields
|
|
* (passwords, tokens, private keys) before they are persisted to localStorage.
|
|
*
|
|
* Sentinel prefix "enc:v1:" on encrypted values enables:
|
|
* - Detection of already-encrypted vs plaintext (migration)
|
|
* - No double-encryption
|
|
* - Future re-keying with enc:v2: etc.
|
|
*
|
|
* When safeStorage is unavailable (e.g. Linux without libsecret), all values
|
|
* pass through unmodified so the app still works.
|
|
*/
|
|
|
|
const ENC_PREFIX = "enc:v1:";
|
|
|
|
/**
|
|
* Chromium/Electron safeStorage ciphertext carries known platform headers:
|
|
* - macOS/Linux: plaintext bytes start with "v10" or "v11"
|
|
* - Windows (legacy DPAPI blob): leading bytes are 0x01 0x00 0x00 0x00
|
|
*
|
|
* Detect headers on *decoded* bytes. A four-byte DPAPI version alone is not
|
|
* enough — real blobs continue with provider GUID
|
|
* {df9d8cd0-1501-11d1-8c7a-00c04fc297eb} (base64 `AQAAANCMnd8...`).
|
|
*
|
|
* Keep in sync with domain/credentials.ts.
|
|
*
|
|
* v10/v11 CBC blobs are at least header(3) + one AES block(16) = 19 bytes.
|
|
* AES-GCM blobs are larger (nonce+tag), but CBC is the lower bound we must
|
|
* accept so short credentials are not mistaken for plaintext coincidences.
|
|
*/
|
|
const V10_HEADER = Buffer.from("v10", "utf8");
|
|
const V11_HEADER = Buffer.from("v11", "utf8");
|
|
// Version (4) + provider GUID {df9d8cd0-1501-11d1-8c7a-00c04fc297eb} (16).
|
|
const DPAPI_BLOB_PREFIX = Buffer.from([
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0xd0, 0x8c, 0x9d, 0xdf, 0x01, 0x15, 0xd1, 0x11,
|
|
0x8c, 0x7a, 0x00, 0xc0, 0x4f, 0xc2, 0x97, 0xeb,
|
|
]);
|
|
|
|
const MIN_V10_V11_CIPHERTEXT_BYTES = 19;
|
|
const MIN_V10_V11_GCM_CIPHERTEXT_BYTES = 31; // header(3) + nonce(12) + tag(16)
|
|
// Header alone is 20 bytes; require at least one trailing payload byte.
|
|
const MIN_DPAPI_CIPHERTEXT_BYTES = DPAPI_BLOB_PREFIX.byteLength + 1;
|
|
|
|
const BASE64_RE = /^[A-Za-z0-9+/]+=*$/;
|
|
|
|
let safeStorage = null;
|
|
|
|
function startsWithBytes(buffer, prefix) {
|
|
if (buffer.byteLength < prefix.byteLength) return false;
|
|
return buffer.subarray(0, prefix.byteLength).equals(prefix);
|
|
}
|
|
|
|
/** CBC is header(3) + 16-byte blocks; GCM is at least header+nonce+tag (31). */
|
|
function isValidV10V11CiphertextLength(byteLength) {
|
|
if (byteLength >= MIN_V10_V11_GCM_CIPHERTEXT_BYTES) return true;
|
|
return byteLength >= MIN_V10_V11_CIPHERTEXT_BYTES
|
|
&& (byteLength - 3) % 16 === 0;
|
|
}
|
|
|
|
function looksLikeEncryptedCredential(value) {
|
|
if (typeof value !== "string" || !value.startsWith(ENC_PREFIX)) {
|
|
return false;
|
|
}
|
|
const payload = value.slice(ENC_PREFIX.length);
|
|
if (!payload || !BASE64_RE.test(payload)) return false;
|
|
// Reject header-only / truncated base64 that is not a full platform blob.
|
|
let decoded;
|
|
try {
|
|
decoded = Buffer.from(payload, "base64");
|
|
} catch {
|
|
return false;
|
|
}
|
|
if (startsWithBytes(decoded, V10_HEADER) || startsWithBytes(decoded, V11_HEADER)) {
|
|
return isValidV10V11CiphertextLength(decoded.byteLength);
|
|
}
|
|
if (startsWithBytes(decoded, DPAPI_BLOB_PREFIX)) {
|
|
return decoded.byteLength >= MIN_DPAPI_CIPHERTEXT_BYTES;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Encrypt a credential field. Never wraps an existing complete device-bound
|
|
* enc:v1 blob again — even when trial decrypt fails (e.g. OSCrypt key
|
|
* rotated). Ambiguous `enc:v1:` prefixes that are not full ciphertext are
|
|
* treated as coincidental plaintext and encrypted normally.
|
|
*
|
|
* @param {string} plaintext
|
|
* @param {{ isEncryptionAvailable?: () => boolean, encryptString?: (v: string) => Buffer, decryptString?: (b: Buffer) => string } | null} storage
|
|
*/
|
|
function encryptCredentialValue(plaintext, storage = safeStorage) {
|
|
if (typeof plaintext !== "string" || plaintext.length === 0) {
|
|
return plaintext ?? "";
|
|
}
|
|
if (!storage?.isEncryptionAvailable?.()) {
|
|
return plaintext;
|
|
}
|
|
|
|
// Complete device-bound ciphertext: return as-is. Do not trial-decrypt then
|
|
// fall through to encryptString — that double-wraps when decrypt fails.
|
|
if (looksLikeEncryptedCredential(plaintext)) {
|
|
return plaintext;
|
|
}
|
|
|
|
// Ambiguous enc:v1: prefix (header-only / short coincidence): try decrypt.
|
|
// Success means a real blob we failed to classify — keep it. Failure means
|
|
// plaintext that happens to look prefixed — encrypt it.
|
|
if (plaintext.startsWith(ENC_PREFIX) && typeof storage.decryptString === "function") {
|
|
try {
|
|
const base64 = plaintext.slice(ENC_PREFIX.length);
|
|
const buf = Buffer.from(base64, "base64");
|
|
storage.decryptString(buf);
|
|
return plaintext;
|
|
} catch {
|
|
// coincidental plaintext — fall through
|
|
}
|
|
}
|
|
|
|
try {
|
|
const encrypted = storage.encryptString(plaintext);
|
|
return ENC_PREFIX + encrypted.toString("base64");
|
|
} catch (err) {
|
|
console.warn("[Credentials] encrypt failed, returning plaintext:", err?.message || err);
|
|
return plaintext;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Decrypt a credential field. On failure returns the ciphertext unchanged so
|
|
* callers can detect enc:v1 placeholders via looksLikeEncryptedCredential /
|
|
* isEncryptedCredentialPlaceholder.
|
|
*
|
|
* @param {string} value
|
|
* @param {{ isEncryptionAvailable?: () => boolean, decryptString?: (b: Buffer) => string } | null} storage
|
|
*/
|
|
function decryptCredentialValue(value, storage = safeStorage) {
|
|
if (typeof value !== "string" || value.length === 0) {
|
|
return value ?? "";
|
|
}
|
|
if (!value.startsWith(ENC_PREFIX)) {
|
|
return value;
|
|
}
|
|
if (!storage?.isEncryptionAvailable?.()) {
|
|
return value;
|
|
}
|
|
try {
|
|
const base64 = value.slice(ENC_PREFIX.length);
|
|
const buf = Buffer.from(base64, "base64");
|
|
return storage.decryptString(buf);
|
|
} catch (err) {
|
|
console.warn("[Credentials] decrypt failed:", err?.message || err);
|
|
return value;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Register IPC handlers for credential encryption/decryption
|
|
* @param {Electron.IpcMain} ipcMain
|
|
* @param {typeof Electron} electronModule
|
|
*/
|
|
function registerHandlers(ipcMain, electronModule) {
|
|
safeStorage = electronModule?.safeStorage ?? null;
|
|
|
|
ipcMain.handle("netcatty:credentials:available", () => {
|
|
return Boolean(safeStorage?.isEncryptionAvailable?.());
|
|
});
|
|
|
|
ipcMain.handle("netcatty:credentials:encrypt", (_event, plaintext) => {
|
|
return encryptCredentialValue(plaintext, safeStorage);
|
|
});
|
|
|
|
ipcMain.handle("netcatty:credentials:decrypt", (_event, value) => {
|
|
return decryptCredentialValue(value, safeStorage);
|
|
});
|
|
}
|
|
|
|
module.exports = {
|
|
ENC_PREFIX,
|
|
MIN_V10_V11_CIPHERTEXT_BYTES,
|
|
MIN_DPAPI_CIPHERTEXT_BYTES,
|
|
looksLikeEncryptedCredential,
|
|
encryptCredentialValue,
|
|
decryptCredentialValue,
|
|
registerHandlers,
|
|
};
|