@lvce-editor/main-process 6.19.1 → 6.19.2

package/dist/mainProcessMain.js

@@ -11,6 +11,7 @@ import { dirname, join as join$1, isAbsolute } from 'node:path';
 import { homedir, tmpdir } from 'node:os';
 import { pbkdf2Sync, createDecipheriv, createHash } from 'node:crypto';
 import { DatabaseSync } from 'node:sqlite';
+import dbus, { Variant } from 'dbus-native';
 import { MessageChannel } from 'node:worker_threads';
 
 const scheme = 'lvce-oss';
@@ -4613,6 +4614,7 @@ const beep$1 = () => {
 };
 
 const chromeV10Prefix = Buffer.from('v10');
+const chromeV11Prefix = Buffer.from('v11');
 const chromeV10Key = pbkdf2Sync('peanuts', 'saltysalt', 1, 16, 'sha1');
 const chromeV10Iv = Buffer.alloc(16, 0x20);
 const domainHashLength = 32;
@@ -4622,13 +4624,25 @@ class UnsupportedChromeCookieEncryptionError extends Error {
     this.name = 'UnsupportedChromeCookieEncryptionError';
   }
 }
-const decrypt$1 = (hostKey, encryptedValue, databaseVersion) => {
+const isV11 = encryptedValue => {
+  return Buffer.from(encryptedValue).subarray(0, chromeV11Prefix.length).equals(chromeV11Prefix);
+};
+const decrypt$1 = (hostKey, encryptedValue, databaseVersion, chromeSafeStoragePassword) => {
   const buffer = Buffer.from(encryptedValue);
-  if (buffer.length <= chromeV10Prefix.length || !buffer.subarray(0, chromeV10Prefix.length).equals(chromeV10Prefix)) {
+  if (buffer.length <= chromeV10Prefix.length) {
+    throw new UnsupportedChromeCookieEncryptionError();
+  }
+  const prefix = buffer.subarray(0, chromeV10Prefix.length);
+  let key;
+  if (prefix.equals(chromeV10Prefix)) {
+    key = chromeV10Key;
+  } else if (prefix.equals(chromeV11Prefix) && chromeSafeStoragePassword !== undefined) {
+    key = pbkdf2Sync(chromeSafeStoragePassword, 'saltysalt', 1, 16, 'sha1');
+  } else {
     throw new UnsupportedChromeCookieEncryptionError();
   }
-  const decipher = createDecipheriv('aes-128-cbc', chromeV10Key, chromeV10Iv);
-  const plaintext = Buffer.concat([decipher.update(buffer.subarray(chromeV10Prefix.length)), decipher.final()]);
+  const decipher = createDecipheriv('aes-128-cbc', key, chromeV10Iv);
+  const plaintext = Buffer.concat([decipher.update(buffer.subarray(prefix.length)), decipher.final()]);
   if (databaseVersion < 24) {
     return plaintext.toString('utf8');
   }
@@ -4661,13 +4675,13 @@ const getExpirationDate = expiresUtc => {
   const chromeMicroseconds = BigInt(expiresUtc);
   return Number(chromeMicroseconds - chromeEpochOffsetMicroseconds) / Number(microsecondsPerSecond);
 };
-const getValue = (row, databaseVersion) => {
+const getValue = (row, databaseVersion, chromeSafeStoragePassword) => {
   if (row.value) {
     return row.value;
   }
-  return decrypt$1(row.hostKey, row.encryptedValue, databaseVersion);
+  return decrypt$1(row.hostKey, row.encryptedValue, databaseVersion, chromeSafeStoragePassword);
 };
-const convert$1 = (row, databaseVersion, now = Date.now() / 1000) => {
+const convert$1 = (row, databaseVersion, chromeSafeStoragePassword, now = Date.now() / 1000) => {
   if (!row.hostKey || row.topFrameSiteKey) {
     return undefined;
   }
@@ -4683,7 +4697,7 @@ const convert$1 = (row, databaseVersion, now = Date.now() / 1000) => {
     sameSite: getSameSite$1(row.sameSite),
     secure,
     url: `${secure ? 'https' : 'http'}://${host}/`,
-    value: getValue(row, databaseVersion)
+    value: getValue(row, databaseVersion, chromeSafeStoragePassword)
   };
   if (row.hostKey.startsWith('.')) {
     details.domain = row.hostKey;
@@ -4763,6 +4777,79 @@ const readCookies$1 = path => {
   });
 };
 
+const secretServiceName = 'org.freedesktop.secrets';
+const secretServicePath = '/org/freedesktop/secrets';
+const secretServiceInterface = 'org.freedesktop.Secret.Service';
+const secretCollectionInterface = 'org.freedesktop.Secret.Collection';
+const secretItemInterface = 'org.freedesktop.Secret.Item';
+const propertiesInterface = 'org.freedesktop.DBus.Properties';
+const defaultCollectionPath = '/org/freedesktop/secrets/aliases/default';
+const chromeSafeStorageLabel = 'Chrome Safe Storage';
+const getProperties = async (bus, path) => {
+  return bus.getService(secretServiceName).getInterface(path, propertiesInterface);
+};
+const findChromeSafeStorageItem = async (bus, service) => {
+  const [unlocked, locked] = await service.SearchItems({
+    application: 'chrome'
+  });
+  const matchingItems = [...unlocked, ...locked];
+  if (matchingItems.length > 0) {
+    return matchingItems[0];
+  }
+  const collectionProperties = await getProperties(bus, defaultCollectionPath);
+  const items = await collectionProperties.Get(secretCollectionInterface, 'Items');
+  for (const item of items) {
+    const itemProperties = await getProperties(bus, item);
+    const label = await itemProperties.Get(secretItemInterface, 'Label');
+    if (label === chromeSafeStorageLabel) {
+      return item;
+    }
+  }
+  throw new Error('Chrome Safe Storage password was not found in the Linux keyring');
+};
+const unlockItem = async (service, item) => {
+  const [unlocked, prompt] = await service.Unlock([item]);
+  if (unlocked.includes(item)) {
+    return;
+  }
+  if (prompt !== '/') {
+    throw new Error('Chrome Safe Storage is locked; unlock the desktop keyring and try again');
+  }
+  throw new Error('Chrome Safe Storage could not be unlocked');
+};
+const readPassword = async bus => {
+  const service = await bus.getService(secretServiceName).getInterface(secretServicePath, secretServiceInterface);
+  const [, sessionPath] = await service.OpenSession('plain', new Variant('s', ''));
+  const item = await findChromeSafeStorageItem(bus, service);
+  let secrets;
+  try {
+    secrets = await service.GetSecrets([item], sessionPath);
+  } catch {
+    await unlockItem(service, item);
+    secrets = await service.GetSecrets([item], sessionPath);
+  }
+  const secret = secrets[item];
+  if (!secret) {
+    throw new Error('Chrome Safe Storage password was not returned by the Linux keyring');
+  }
+  return Buffer.from(secret[2]).toString('utf8');
+};
+const getErrorMessage = error => {
+  return error instanceof Error ? error.message : String(error);
+};
+const getChromeSafeStoragePassword = async () => {
+  const bus = dbus.sessionBus({
+    timeout: 5000
+  });
+  try {
+    return await readPassword(bus);
+  } catch (error) {
+    throw new Error(`Failed to read Chrome Safe Storage password: ${getErrorMessage(error)}`);
+  } finally {
+    await bus.close();
+  }
+};
+
 const isValidProfileDirectory = value => {
   return value !== '' && value !== '.' && value !== '..' && !value.includes('/') && !value.includes('\\');
 };
@@ -4972,12 +5059,14 @@ const importFromDirectory$1 = async (chromeDataDirectory, session) => {
     rows,
     version
   } = readCookies$1(profile.cookieDatabasePath);
+  const requiresChromeSafeStoragePassword = rows.some(row => !row.value && isV11(row.encryptedValue));
+  const chromeSafeStoragePassword = requiresChromeSafeStoragePassword ? await getChromeSafeStoragePassword() : undefined;
   const cookies = [];
   let skipped = 0;
   let unsupportedEncryption = 0;
   for (const row of rows) {
     try {
-      const cookie = convert$1(row, version);
+      const cookie = convert$1(row, version, chromeSafeStoragePassword);
       if (cookie) {
         cookies.push(cookie);
       } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-process",
-  "version": "6.19.1",
+  "version": "6.19.2",
   "keywords": [
     "lvce-editor",
     "electron"
@@ -14,6 +14,7 @@
   "type": "module",
   "main": "dist/mainProcessMain.js",
   "dependencies": {
+    "dbus-native": "^0.15.1",
     "electron": "43.2.0"
   },
   "engines": {