diff options
Diffstat (limited to 'toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm')
| -rw-r--r-- | toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm | 646 |
1 files changed, 646 insertions, 0 deletions
diff --git a/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm b/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm new file mode 100644 index 0000000000..1d667ab693 --- /dev/null +++ b/toolkit/mozapps/extensions/internal/AddonUpdateChecker.jsm @@ -0,0 +1,646 @@ +/* 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/. */ + +/** + * The AddonUpdateChecker is responsible for retrieving the update information + * from an add-on's remote update manifest. + */ + +"use strict"; + +var EXPORTED_SYMBOLS = ["AddonUpdateChecker"]; + +const TIMEOUT = 60 * 1000; +const TOOLKIT_ID = "toolkit@mozilla.org"; + +const lazy = {}; + +ChromeUtils.defineModuleGetter( + lazy, + "AddonManager", + "resource://gre/modules/AddonManager.jsm" +); +ChromeUtils.defineModuleGetter( + lazy, + "AddonManagerPrivate", + "resource://gre/modules/AddonManager.jsm" +); +ChromeUtils.defineModuleGetter( + lazy, + "Blocklist", + "resource://gre/modules/Blocklist.jsm" +); +ChromeUtils.defineESModuleGetters(lazy, { + CertUtils: "resource://gre/modules/CertUtils.sys.mjs", + ServiceRequest: "resource://gre/modules/ServiceRequest.sys.mjs", +}); +ChromeUtils.defineModuleGetter( + lazy, + "AddonSettings", + "resource://gre/modules/addons/AddonSettings.jsm" +); + +const { Log } = ChromeUtils.importESModule( + "resource://gre/modules/Log.sys.mjs" +); +const LOGGER_ID = "addons.update-checker"; + +// Create a new logger for use by the Addons Update Checker +// (Requires AddonManager.jsm) +var logger = Log.repository.getLogger(LOGGER_ID); + +const updateTypeHistogram = Services.telemetry.getHistogramById( + "EXTENSION_UPDATE_TYPE" +); + +/** + * Sanitizes the update URL in an update item, as returned by + * parseRDFManifest and parseJSONManifest. Ensures that: + * + * - The URL is secure, or secured by a strong enough hash. + * - The security principal of the update manifest has permission to + * load the URL. + * + * @param aUpdate + * The update item to sanitize. + * @param aRequest + * The XMLHttpRequest used to load the manifest. + * @param aHashPattern + * The regular expression used to validate the update hash. + * @param aHashString + * The human-readable string specifying which hash functions + * are accepted. + */ +function sanitizeUpdateURL(aUpdate, aRequest, aHashPattern, aHashString) { + if (aUpdate.updateURL) { + let scriptSecurity = Services.scriptSecurityManager; + let principal = scriptSecurity.getChannelURIPrincipal(aRequest.channel); + try { + // This logs an error on failure, so no need to log it a second time + scriptSecurity.checkLoadURIStrWithPrincipal( + principal, + aUpdate.updateURL, + scriptSecurity.DISALLOW_SCRIPT + ); + } catch (e) { + delete aUpdate.updateURL; + return; + } + + if ( + lazy.AddonManager.checkUpdateSecurity && + !aUpdate.updateURL.startsWith("https:") && + !aHashPattern.test(aUpdate.updateHash) + ) { + logger.warn( + `Update link ${aUpdate.updateURL} is not secure and is not verified ` + + `by a strong enough hash (needs to be ${aHashString}).` + ); + delete aUpdate.updateURL; + delete aUpdate.updateHash; + } + } +} + +/** + * Parses an JSON update manifest into an array of update objects. + * + * @param aId + * The ID of the add-on being checked for updates + * @param aRequest + * The XMLHttpRequest that has retrieved the update manifest + * @param aManifestData + * The pre-parsed manifest, as a JSON object tree + * @return an array of update objects + * @throws if the update manifest is invalid in any way + */ +function parseJSONManifest(aId, aRequest, aManifestData) { + let TYPE_CHECK = { + array: val => Array.isArray(val), + object: val => val && typeof val == "object" && !Array.isArray(val), + }; + + function getProperty(aObj, aProperty, aType, aDefault = undefined) { + if (!(aProperty in aObj)) { + return aDefault; + } + + let value = aObj[aProperty]; + + let matchesType = + aType in TYPE_CHECK ? TYPE_CHECK[aType](value) : typeof value == aType; + if (!matchesType) { + throw Components.Exception( + `Update manifest property '${aProperty}' has incorrect type (expected ${aType})` + ); + } + + return value; + } + + function getRequiredProperty(aObj, aProperty, aType) { + let value = getProperty(aObj, aProperty, aType); + if (value === undefined) { + throw Components.Exception( + `Update manifest is missing a required ${aProperty} property.` + ); + } + return value; + } + + let manifest = aManifestData; + + if (!TYPE_CHECK.object(manifest)) { + throw Components.Exception( + "Root element of update manifest must be a JSON object literal" + ); + } + + // The set of add-ons this manifest has updates for + let addons = getRequiredProperty(manifest, "addons", "object"); + + // The entry for this particular add-on + let addon = getProperty(addons, aId, "object"); + + // A missing entry doesn't count as a failure, just as no avialable update + // information + if (!addon) { + logger.warn("Update manifest did not contain an entry for " + aId); + return []; + } + + // The list of available updates + let updates = getProperty(addon, "updates", "array", []); + + let results = []; + + for (let update of updates) { + let version = getRequiredProperty(update, "version", "string"); + + logger.debug(`Found an update entry for ${aId} version ${version}`); + + let applications = getProperty(update, "applications", "object", { + gecko: {}, + }); + + // "gecko" is currently the only supported application entry. If + // it's missing, skip this update. + if (!("gecko" in applications)) { + logger.debug( + "gecko not in application entry, skipping update of ${addon}" + ); + continue; + } + + let app = getProperty(applications, "gecko", "object"); + + let appEntry = { + id: TOOLKIT_ID, + minVersion: getProperty( + app, + "strict_min_version", + "string", + lazy.AddonManagerPrivate.webExtensionsMinPlatformVersion + ), + maxVersion: "*", + }; + + let result = { + id: aId, + version, + updateURL: getProperty(update, "update_link", "string"), + updateHash: getProperty(update, "update_hash", "string"), + updateInfoURL: getProperty(update, "update_info_url", "string"), + strictCompatibility: false, + targetApplications: [appEntry], + }; + + if ("strict_max_version" in app) { + if ("advisory_max_version" in app) { + logger.warn( + "Ignoring 'advisory_max_version' update manifest property for " + + aId + + " property since 'strict_max_version' also present" + ); + } + + appEntry.maxVersion = getProperty(app, "strict_max_version", "string"); + result.strictCompatibility = appEntry.maxVersion != "*"; + } else if ("advisory_max_version" in app) { + appEntry.maxVersion = getProperty(app, "advisory_max_version", "string"); + } + + // Add an app entry for the current API ID, too, so that it overrides any + // existing app-specific entries, which would take priority over the toolkit + // entry. + // + // Note: This currently only has any effect on legacy extensions (mainly + // those used in tests), since WebExtensions cannot yet specify app-specific + // compatibility ranges. + result.targetApplications.push( + Object.assign({}, appEntry, { id: Services.appinfo.ID }) + ); + + // The JSON update protocol requires an SHA-2 hash. RDF still + // supports SHA-1, for compatibility reasons. + sanitizeUpdateURL(result, aRequest, /^sha(256|512):/, "sha256 or sha512"); + + results.push(result); + } + return results; +} + +/** + * Starts downloading an update manifest and then passes it to an appropriate + * parser to convert to an array of update objects + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUrl + * The URL of the update manifest + * @param aObserver + * An observer to pass results to + */ +function UpdateParser(aId, aUrl, aObserver) { + this.id = aId; + this.observer = aObserver; + this.url = aUrl; + + logger.debug("Requesting " + aUrl); + try { + this.request = new lazy.ServiceRequest({ mozAnon: true }); + this.request.open("GET", this.url, true); + this.request.channel.notificationCallbacks = new lazy.CertUtils.BadCertHandler( + !lazy.AddonSettings.UPDATE_REQUIREBUILTINCERTS + ); + this.request.channel.loadFlags |= Ci.nsIRequest.LOAD_BYPASS_CACHE; + // Prevent the request from writing to cache. + this.request.channel.loadFlags |= Ci.nsIRequest.INHIBIT_CACHING; + this.request.overrideMimeType("text/plain"); + this.request.timeout = TIMEOUT; + this.request.addEventListener("load", () => this.onLoad()); + this.request.addEventListener("error", () => this.onError()); + this.request.addEventListener("timeout", () => this.onTimeout()); + this.request.send(null); + } catch (e) { + logger.error("Failed to request update manifest", e); + } +} + +UpdateParser.prototype = { + id: null, + observer: null, + request: null, + url: null, + + /** + * Called when the manifest has been successfully loaded. + */ + onLoad() { + let request = this.request; + this.request = null; + this._doneAt = new Error("place holder"); + + try { + lazy.CertUtils.checkCert( + request.channel, + !lazy.AddonSettings.UPDATE_REQUIREBUILTINCERTS + ); + } catch (e) { + logger.warn("Request failed: " + this.url + " - " + e); + this.notifyError(lazy.AddonManager.ERROR_DOWNLOAD_ERROR); + return; + } + + if (!Components.isSuccessCode(request.status)) { + logger.warn("Request failed: " + this.url + " - " + request.status); + this.notifyError(lazy.AddonManager.ERROR_DOWNLOAD_ERROR); + return; + } + + let channel = request.channel; + if (channel instanceof Ci.nsIHttpChannel && !channel.requestSucceeded) { + logger.warn( + "Request failed: " + + this.url + + " - " + + channel.responseStatus + + ": " + + channel.responseStatusText + ); + this.notifyError(lazy.AddonManager.ERROR_DOWNLOAD_ERROR); + return; + } + + let results; + try { + let json = JSON.parse(request.responseText); + results = parseJSONManifest(this.id, request, json); + updateTypeHistogram.add("JSON"); + } catch (e) { + logger.warn("onUpdateCheckComplete failed to parse update manifest", e); + this.notifyError(lazy.AddonManager.ERROR_PARSE_ERROR); + return; + } + + if ("onUpdateCheckComplete" in this.observer) { + try { + this.observer.onUpdateCheckComplete(results); + } catch (e) { + logger.warn("onUpdateCheckComplete notification failed", e); + } + } else { + logger.warn( + "onUpdateCheckComplete may not properly cancel", + new Error("stack marker") + ); + } + }, + + /** + * Called when the request times out + */ + onTimeout() { + this.request = null; + this._doneAt = new Error("Timed out"); + logger.warn("Request for " + this.url + " timed out"); + this.notifyError(lazy.AddonManager.ERROR_TIMEOUT); + }, + + /** + * Called when the manifest failed to load. + */ + onError() { + if (!Components.isSuccessCode(this.request.status)) { + logger.warn("Request failed: " + this.url + " - " + this.request.status); + } else if (this.request.channel instanceof Ci.nsIHttpChannel) { + try { + if (this.request.channel.requestSucceeded) { + logger.warn( + "Request failed: " + + this.url + + " - " + + this.request.channel.responseStatus + + ": " + + this.request.channel.responseStatusText + ); + } + } catch (e) { + logger.warn("HTTP Request failed for an unknown reason"); + } + } else { + logger.warn("Request failed for an unknown reason"); + } + + this.request = null; + this._doneAt = new Error("UP_onError"); + + this.notifyError(lazy.AddonManager.ERROR_DOWNLOAD_ERROR); + }, + + /** + * Helper method to notify the observer that an error occurred. + */ + notifyError(aStatus) { + if ("onUpdateCheckError" in this.observer) { + try { + this.observer.onUpdateCheckError(aStatus); + } catch (e) { + logger.warn("onUpdateCheckError notification failed", e); + } + } + }, + + /** + * Called to cancel an in-progress update check. + */ + cancel() { + if (!this.request) { + logger.error("Trying to cancel already-complete request", this._doneAt); + return; + } + this.request.abort(); + this.request = null; + this._doneAt = new Error("UP_cancel"); + this.notifyError(lazy.AddonManager.ERROR_CANCELLED); + }, +}; + +/** + * Tests if an update matches a version of the application or platform + * + * @param aUpdate + * The available update + * @param aAppVersion + * The application version to use + * @param aPlatformVersion + * The platform version to use + * @param aIgnoreMaxVersion + * Ignore maxVersion when testing if an update matches. Optional. + * @param aIgnoreStrictCompat + * Ignore strictCompatibility when testing if an update matches. Optional. + * @return true if the update is compatible with the application/platform + */ +function matchesVersions( + aUpdate, + aAppVersion, + aPlatformVersion, + aIgnoreMaxVersion, + aIgnoreStrictCompat +) { + if (aUpdate.strictCompatibility && !aIgnoreStrictCompat) { + aIgnoreMaxVersion = false; + } + + let result = false; + for (let app of aUpdate.targetApplications) { + if (app.id == Services.appinfo.ID) { + return ( + Services.vc.compare(aAppVersion, app.minVersion) >= 0 && + (aIgnoreMaxVersion || + Services.vc.compare(aAppVersion, app.maxVersion) <= 0) + ); + } + if (app.id == TOOLKIT_ID) { + result = + Services.vc.compare(aPlatformVersion, app.minVersion) >= 0 && + (aIgnoreMaxVersion || + Services.vc.compare(aPlatformVersion, app.maxVersion) <= 0); + } + } + return result; +} + +var AddonUpdateChecker = { + /** + * Retrieves the best matching compatibility update for the application from + * a list of available update objects. + * + * @param aUpdates + * An array of update objects + * @param aVersion + * The version of the add-on to get new compatibility information for + * @param aIgnoreCompatibility + * An optional parameter to get the first compatibility update that + * is compatible with any version of the application or toolkit + * @param aAppVersion + * The version of the application or null to use the current version + * @param aPlatformVersion + * The version of the platform or null to use the current version + * @param aIgnoreMaxVersion + * Ignore maxVersion when testing if an update matches. Optional. + * @param aIgnoreStrictCompat + * Ignore strictCompatibility when testing if an update matches. Optional. + * @return an update object if one matches or null if not + */ + getCompatibilityUpdate( + aUpdates, + aVersion, + aIgnoreCompatibility, + aAppVersion, + aPlatformVersion, + aIgnoreMaxVersion, + aIgnoreStrictCompat + ) { + if (!aAppVersion) { + aAppVersion = Services.appinfo.version; + } + if (!aPlatformVersion) { + aPlatformVersion = Services.appinfo.platformVersion; + } + + for (let update of aUpdates) { + if (Services.vc.compare(update.version, aVersion) == 0) { + if (aIgnoreCompatibility) { + for (let targetApp of update.targetApplications) { + let id = targetApp.id; + if (id == Services.appinfo.ID || id == TOOLKIT_ID) { + return update; + } + } + } else if ( + matchesVersions( + update, + aAppVersion, + aPlatformVersion, + aIgnoreMaxVersion, + aIgnoreStrictCompat + ) + ) { + return update; + } + } + } + return null; + }, + + /** + * Asynchronously returns the newest available update from a list of update objects. + * + * @param aUpdates + * An array of update objects + * @param aAddon + * The add-on that is being updated. + * @param aAppVersion + * The version of the application or null to use the current version + * @param aPlatformVersion + * The version of the platform or null to use the current version + * @param aIgnoreMaxVersion + * When determining compatible updates, ignore maxVersion. Optional. + * @param aIgnoreStrictCompat + * When determining compatible updates, ignore strictCompatibility. Optional. + * @return an update object if one matches or null if not + */ + async getNewestCompatibleUpdate( + aUpdates, + aAddon, + aAppVersion, + aPlatformVersion, + aIgnoreMaxVersion, + aIgnoreStrictCompat + ) { + if (!aAppVersion) { + aAppVersion = Services.appinfo.version; + } + if (!aPlatformVersion) { + aPlatformVersion = Services.appinfo.platformVersion; + } + + let newestVersion = aAddon.version; + let newest = null; + let blocked = null; + let blockedState; + for (let update of aUpdates) { + if (!update.updateURL) { + continue; + } + if (Services.vc.compare(newestVersion, update.version) >= 0) { + // Update older than add-on version or older than previous result. + continue; + } + if ( + !matchesVersions( + update, + aAppVersion, + aPlatformVersion, + aIgnoreMaxVersion, + aIgnoreStrictCompat + ) + ) { + continue; + } + let state = await lazy.Blocklist.getAddonBlocklistState( + update, + aAppVersion, + aPlatformVersion + ); + if (state != Ci.nsIBlocklistService.STATE_NOT_BLOCKED) { + if ( + !blocked || + Services.vc.compare(blocked.version, update.version) < 0 + ) { + blocked = update; + blockedState = state; + } + continue; + } + newest = update; + newestVersion = update.version; + } + if ( + blocked && + (!newest || Services.vc.compare(blocked.version, newestVersion) >= 0) + ) { + // If |newest| has a higher version than |blocked|, then the add-on would + // not be considered for installation. But if |blocked| would otherwise + // be eligible for installation, then report to telemetry that installation + // has been blocked because of the blocklist. + lazy.Blocklist.recordAddonBlockChangeTelemetry( + { + id: aAddon.id, + version: blocked.version, + blocklistState: blockedState, + }, + "addon_update_check" + ); + } + return newest; + }, + + /** + * Starts an update check. + * + * @param aId + * The ID of the add-on being checked for updates + * @param aUrl + * The URL of the add-on's update manifest + * @param aObserver + * An observer to notify of results + * @return UpdateParser so that the caller can use UpdateParser.cancel() to shut + * down in-progress update requests + */ + checkForUpdates(aId, aUrl, aObserver) { + return new UpdateParser(aId, aUrl, aObserver); + }, +}; |