Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 402 insertions, 0 deletions

diff --git a/browser/components/migration/IEProfileMigrator.sys.mjs b/browser/components/migration/IEProfileMigrator.sys.mjs
new file mode 100644
index 0000000000..1a8c231b55
--- /dev/null
+++ b/browser/components/migration/IEProfileMigrator.sys.mjs
@@ -0,0 +1,402 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const kLoginsKey =
+  "Software\\Microsoft\\Internet Explorer\\IntelliForms\\Storage2";
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+import { MigrationUtils } from "resource:///modules/MigrationUtils.sys.mjs";
+import { MigratorBase } from "resource:///modules/MigratorBase.sys.mjs";
+import { MSMigrationUtils } from "resource:///modules/MSMigrationUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  OSCrypto: "resource://gre/modules/OSCrypto_win.sys.mjs",
+  PlacesUtils: "resource://gre/modules/PlacesUtils.sys.mjs",
+  ctypes: "resource://gre/modules/ctypes.sys.mjs",
+});
+
+// Resources
+
+function History() {}
+
+History.prototype = {
+  type: MigrationUtils.resourceTypes.HISTORY,
+
+  get exists() {
+    return true;
+  },
+
+  migrate: function H_migrate(aCallback) {
+    let pageInfos = [];
+    let typedURLs = MSMigrationUtils.getTypedURLs(
+      "Software\\Microsoft\\Internet Explorer"
+    );
+    let now = new Date();
+    let maxDate = new Date(
+      Date.now() - MigrationUtils.HISTORY_MAX_AGE_IN_MILLISECONDS
+    );
+
+    for (let entry of Cc[
+      "@mozilla.org/profile/migrator/iehistoryenumerator;1"
+    ].createInstance(Ci.nsISimpleEnumerator)) {
+      let url = entry.get("uri").QueryInterface(Ci.nsIURI);
+      // MSIE stores some types of URLs in its history that we don't handle,
+      // like HTMLHelp and others.  Since we don't properly map handling for
+      // all of them we just avoid importing them.
+      if (!["http", "https", "ftp", "file"].includes(url.scheme)) {
+        continue;
+      }
+
+      let title = entry.get("title");
+      // Embed visits have no title and don't need to be imported.
+      if (!title.length) {
+        continue;
+      }
+
+      // The typed urls are already fixed-up, so we can use them for comparison.
+      let transition = typedURLs.has(url.spec)
+        ? lazy.PlacesUtils.history.TRANSITIONS.LINK
+        : lazy.PlacesUtils.history.TRANSITIONS.TYPED;
+
+      let time = entry.get("time");
+
+      let visitDate = time ? lazy.PlacesUtils.toDate(time) : null;
+      if (visitDate && visitDate < maxDate) {
+        continue;
+      }
+
+      pageInfos.push({
+        url,
+        title,
+        visits: [
+          {
+            transition,
+            // use the current date if we have no visits for this entry.
+            date: visitDate ?? now,
+          },
+        ],
+      });
+    }
+
+    // Check whether there is any history to import.
+    if (!pageInfos.length) {
+      aCallback(true);
+      return;
+    }
+
+    MigrationUtils.insertVisitsWrapper(pageInfos).then(
+      () => aCallback(true),
+      () => aCallback(false)
+    );
+  },
+};
+
+// IE form password migrator supporting windows from XP until 7 and IE from 7 until 11
+function IE7FormPasswords() {
+  // used to distinguish between this migrator and other passwords migrators in tests.
+  this.name = "IE7FormPasswords";
+}
+
+IE7FormPasswords.prototype = {
+  type: MigrationUtils.resourceTypes.PASSWORDS,
+
+  get exists() {
+    // work only on windows until 7
+    if (AppConstants.isPlatformAndVersionAtLeast("win", "6.2")) {
+      return false;
+    }
+
+    try {
+      let nsIWindowsRegKey = Ci.nsIWindowsRegKey;
+      let key =
+        Cc["@mozilla.org/windows-registry-key;1"].createInstance(
+          nsIWindowsRegKey
+        );
+      key.open(
+        nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+        kLoginsKey,
+        nsIWindowsRegKey.ACCESS_READ
+      );
+      let count = key.valueCount;
+      key.close();
+      return count > 0;
+    } catch (e) {
+      return false;
+    }
+  },
+
+  async migrate(aCallback) {
+    let uris = []; // the uris of the websites that are going to be migrated
+    for (let entry of Cc[
+      "@mozilla.org/profile/migrator/iehistoryenumerator;1"
+    ].createInstance(Ci.nsISimpleEnumerator)) {
+      let uri = entry.get("uri").QueryInterface(Ci.nsIURI);
+      // MSIE stores some types of URLs in its history that we don't handle, like HTMLHelp
+      // and others. Since we are not going to import the logins that are performed in these URLs
+      // we can just skip them.
+      if (!["http", "https", "ftp"].includes(uri.scheme)) {
+        continue;
+      }
+
+      uris.push(uri);
+    }
+    await this._migrateURIs(uris);
+    aCallback(true);
+  },
+
+  /**
+   * Migrate the logins that were saved for the uris arguments.
+   *
+   * @param {nsIURI[]} uris - the uris that are going to be migrated.
+   */
+  async _migrateURIs(uris) {
+    this.ctypesKernelHelpers = new MSMigrationUtils.CtypesKernelHelpers();
+    this._crypto = new lazy.OSCrypto();
+    let nsIWindowsRegKey = Ci.nsIWindowsRegKey;
+    let key =
+      Cc["@mozilla.org/windows-registry-key;1"].createInstance(
+        nsIWindowsRegKey
+      );
+    key.open(
+      nsIWindowsRegKey.ROOT_KEY_CURRENT_USER,
+      kLoginsKey,
+      nsIWindowsRegKey.ACCESS_READ
+    );
+
+    let urlsSet = new Set(); // set of the already processed urls.
+    // number of the successfully decrypted registry values
+    let successfullyDecryptedValues = 0;
+    /* The logins are stored in the registry, where the key is a hashed URL and its
+     * value contains the encrypted details for all logins for that URL.
+     *
+     * First iterate through IE history, hashing each URL and looking for a match. If
+     * found, decrypt the value, using the URL as a salt. Finally add any found logins
+     * to the Firefox password manager.
+     */
+
+    let logins = [];
+    for (let uri of uris) {
+      try {
+        // remove the query and the ref parts of the URL
+        let urlObject = new URL(uri.spec);
+        let url = urlObject.origin + urlObject.pathname;
+        // if the current url is already processed, it should be skipped
+        if (urlsSet.has(url)) {
+          continue;
+        }
+        urlsSet.add(url);
+        // hash value of the current uri
+        let hashStr = this._crypto.getIELoginHash(url);
+        if (!key.hasValue(hashStr)) {
+          continue;
+        }
+        let value = key.readBinaryValue(hashStr);
+        // if no value was found, the uri is skipped
+        if (value == null) {
+          continue;
+        }
+        let data;
+        try {
+          // the url is used as salt to decrypt the registry value
+          data = this._crypto.decryptData(value, url);
+        } catch (e) {
+          continue;
+        }
+        // extract the login details from the decrypted data
+        let ieLogins = this._extractDetails(data, uri);
+        // if at least a credential was found in the current data, successfullyDecryptedValues should
+        // be incremented by one
+        if (ieLogins.length) {
+          successfullyDecryptedValues++;
+        }
+        for (let ieLogin of ieLogins) {
+          logins.push({
+            username: ieLogin.username,
+            password: ieLogin.password,
+            origin: ieLogin.url,
+            timeCreated: ieLogin.creation,
+          });
+        }
+      } catch (e) {
+        console.error("Error while importing logins for ", uri.spec, ": ", e);
+      }
+    }
+
+    if (logins.length) {
+      await MigrationUtils.insertLoginsWrapper(logins);
+    }
+
+    // if the number of the imported values is less than the number of values in the key, it means
+    // that not all the values were imported and an error should be reported
+    if (successfullyDecryptedValues < key.valueCount) {
+      console.error(
+        "We failed to decrypt and import some logins. " +
+          "This is likely because we didn't find the URLs where these " +
+          "passwords were submitted in the IE history and which are needed to be used " +
+          "as keys in the decryption."
+      );
+    }
+
+    key.close();
+    this._crypto.finalize();
+    this.ctypesKernelHelpers.finalize();
+  },
+
+  _crypto: null,
+
+  /**
+   * Extract the details of one or more logins from the raw decrypted data.
+   *
+   * @param {string} data - the decrypted data containing raw information.
+   * @param {nsURI} uri - the nsURI of page where the login has occur.
+   * @returns {object[]} array of objects where each of them contains the username, password, URL,
+   * and creation time representing all the logins found in the data arguments.
+   */
+  _extractDetails(data, uri) {
+    // the structure of the header of the IE7 decrypted data for all the logins sharing the same URL
+    let loginData = new lazy.ctypes.StructType("loginData", [
+      // Bytes 0-3 are not needed and not documented
+      { unknown1: lazy.ctypes.uint32_t },
+      // Bytes 4-7 are the header size
+      { headerSize: lazy.ctypes.uint32_t },
+      // Bytes 8-11 are the data size
+      { dataSize: lazy.ctypes.uint32_t },
+      // Bytes 12-19 are not needed and not documented
+      { unknown2: lazy.ctypes.uint32_t },
+      { unknown3: lazy.ctypes.uint32_t },
+      // Bytes 20-23 are the data count: each username and password is considered as a data
+      { dataMax: lazy.ctypes.uint32_t },
+      // Bytes 24-35 are not needed and not documented
+      { unknown4: lazy.ctypes.uint32_t },
+      { unknown5: lazy.ctypes.uint32_t },
+      { unknown6: lazy.ctypes.uint32_t },
+    ]);
+
+    // the structure of a IE7 decrypted login item
+    let loginItem = new lazy.ctypes.StructType("loginItem", [
+      // Bytes 0-3 are the offset of the username
+      { usernameOffset: lazy.ctypes.uint32_t },
+      // Bytes 4-11 are the date
+      { loDateTime: lazy.ctypes.uint32_t },
+      { hiDateTime: lazy.ctypes.uint32_t },
+      // Bytes 12-15 are not needed and not documented
+      { foo: lazy.ctypes.uint32_t },
+      // Bytes 16-19 are the offset of the password
+      { passwordOffset: lazy.ctypes.uint32_t },
+      // Bytes 20-31 are not needed and not documented
+      { unknown1: lazy.ctypes.uint32_t },
+      { unknown2: lazy.ctypes.uint32_t },
+      { unknown3: lazy.ctypes.uint32_t },
+    ]);
+
+    let url = uri.prePath;
+    let results = [];
+    let arr = this._crypto.stringToArray(data);
+    // convert data to ctypes.unsigned_char.array(arr.length)
+    let cdata = lazy.ctypes.unsigned_char.array(arr.length)(arr);
+    // Bytes 0-35 contain the loginData data structure for all the logins sharing the same URL
+    let currentLoginData = lazy.ctypes.cast(cdata, loginData);
+    let headerSize = currentLoginData.headerSize;
+    let currentInfoIndex = loginData.size;
+    // pointer to the current login item
+    let currentLoginItemPointer = lazy.ctypes.cast(
+      cdata.addressOfElement(currentInfoIndex),
+      loginItem.ptr
+    );
+    // currentLoginData.dataMax is the data count: each username and password is considered as
+    // a data. So, the number of logins is the number of data dived by 2
+    let numLogins = currentLoginData.dataMax / 2;
+    for (let n = 0; n < numLogins; n++) {
+      // Bytes 0-31 starting from currentInfoIndex contain the loginItem data structure for the
+      // current login
+      let currentLoginItem = currentLoginItemPointer.contents;
+      let creation =
+        this.ctypesKernelHelpers.fileTimeToSecondsSinceEpoch(
+          currentLoginItem.hiDateTime,
+          currentLoginItem.loDateTime
+        ) * 1000;
+      let currentResult = {
+        creation,
+        url,
+      };
+      // The username is UTF-16 and null-terminated.
+      currentResult.username = lazy.ctypes
+        .cast(
+          cdata.addressOfElement(
+            headerSize + 12 + currentLoginItem.usernameOffset
+          ),
+          lazy.ctypes.char16_t.ptr
+        )
+        .readString();
+      // The password is UTF-16 and null-terminated.
+      currentResult.password = lazy.ctypes
+        .cast(
+          cdata.addressOfElement(
+            headerSize + 12 + currentLoginItem.passwordOffset
+          ),
+          lazy.ctypes.char16_t.ptr
+        )
+        .readString();
+      results.push(currentResult);
+      // move to the next login item
+      currentLoginItemPointer = currentLoginItemPointer.increment();
+    }
+    return results;
+  },
+};
+
+/**
+ * Internet Explorer profile migrator
+ */
+export class IEProfileMigrator extends MigratorBase {
+  static get key() {
+    return "ie";
+  }
+
+  static get displayNameL10nID() {
+    return "migration-wizard-migrator-display-name-ie";
+  }
+
+  static get brandImage() {
+    return "chrome://browser/content/migration/brands/ie.png";
+  }
+
+  getResources() {
+    let resources = [MSMigrationUtils.getBookmarksMigrator(), new History()];
+    // Only support the form password migrator for Windows XP to 7.
+    if (AppConstants.isPlatformAndVersionAtMost("win", "6.1")) {
+      resources.push(new IE7FormPasswords());
+    }
+    let windowsVaultFormPasswordsMigrator =
+      MSMigrationUtils.getWindowsVaultFormPasswordsMigrator();
+    windowsVaultFormPasswordsMigrator.name = "IEVaultFormPasswords";
+    resources.push(windowsVaultFormPasswordsMigrator);
+    return resources.filter(r => r.exists);
+  }
+
+  async getLastUsedDate() {
+    const datePromises = ["Favs", "CookD"].map(dirId => {
+      const { path } = Services.dirsvc.get(dirId, Ci.nsIFile);
+      return IOUtils.stat(path)
+        .then(info => info.lastModified)
+        .catch(() => 0);
+    });
+
+    const dates = await Promise.all(datePromises);
+
+    try {
+      const typedURLs = MSMigrationUtils.getTypedURLs(
+        "Software\\Microsoft\\Internet Explorer"
+      );
+      // typedURLs.values() returns an array of PRTimes, which are in
+      // microseconds - convert to milliseconds
+      dates.push(Math.max(0, ...typedURLs.values()) / 1000);
+    } catch (ex) {}
+
+    return new Date(Math.max(...dates));
+  }
+}