Add m-esr52 at 52.6.0

1 files changed, 612 insertions, 0 deletions

diff --git a/dom/secureelement/DOMSecureElement.js b/dom/secureelement/DOMSecureElement.js
new file mode 100644
index 000000000..48f7053b5
--- /dev/null
+++ b/dom/secureelement/DOMSecureElement.js
@@ -0,0 +1,612 @@
+/* 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/. */
+
+/* Copyright © 2014, Deutsche Telekom, Inc. */
+
+"use strict";
+
+/* globals dump, Components, XPCOMUtils, DOMRequestIpcHelper, cpmm, SE  */
+
+const DEBUG = false;
+function debug(s) {
+  if (DEBUG) {
+    dump("-*- SecureElement DOM: " + s + "\n");
+  }
+}
+
+const Ci = Components.interfaces;
+const Cu = Components.utils;
+
+Cu.import("resource://gre/modules/XPCOMUtils.jsm");
+Cu.import("resource://gre/modules/Services.jsm");
+Cu.import("resource://gre/modules/DOMRequestHelper.jsm");
+
+XPCOMUtils.defineLazyServiceGetter(this, "cpmm",
+                                   "@mozilla.org/childprocessmessagemanager;1",
+                                   "nsISyncMessageSender");
+
+XPCOMUtils.defineLazyGetter(this, "SE", function() {
+  let obj = {};
+  Cu.import("resource://gre/modules/se_consts.js", obj);
+  return obj;
+});
+
+// Extend / Inherit from Error object
+function SEError(name, message) {
+  this.name = name || SE.ERROR_GENERIC;
+  this.message = message || "";
+}
+
+SEError.prototype = {
+  __proto__: Error.prototype,
+};
+
+function PromiseHelpersSubclass(win) {
+  this._window = win;
+}
+
+PromiseHelpersSubclass.prototype = {
+  __proto__: DOMRequestIpcHelper.prototype,
+
+  _window: null,
+
+  _context: [],
+
+  createSEPromise: function createSEPromise(callback, /* optional */ ctx) {
+    let ctxCallback = (resolverId) => {
+      if (ctx) {
+        this._context[resolverId] = ctx;
+      }
+
+      callback(resolverId);
+    };
+
+    return this.createPromiseWithId((aResolverId) => {
+      ctxCallback(aResolverId);
+    });
+  },
+
+  takePromise: function takePromise(resolverId) {
+    let resolver = this.takePromiseResolver(resolverId);
+    if (!resolver) {
+      return;
+    }
+
+    // Get the context associated with this resolverId
+    let context = this._context[resolverId];
+    delete this._context[resolverId];
+
+    return {resolver: resolver, context: context};
+  },
+
+  rejectWithSEError: function rejectWithSEError(name, message) {
+    let error = new SEError(name, message);
+    debug("rejectWithSEError - " + error.toString());
+
+    return this._window.Promise.reject(Cu.cloneInto(error, this._window));
+  }
+};
+
+// Helper wrapper class to do promises related chores
+var PromiseHelpers;
+
+/**
+ * Instance of 'SEReaderImpl' class is the connector to a secure element.
+ * A reader may or may not have a secure element present, since some
+ * secure elements are removable in nature (eg:- 'uicc'). These
+ * Readers can be physical devices or virtual devices.
+ */
+function SEReaderImpl() {}
+
+SEReaderImpl.prototype = {
+  _window: null,
+
+  _sessions: [],
+
+  type: null,
+  _isSEPresent: false,
+
+  classID: Components.ID("{1c7bdba3-cd35-4f8b-a546-55b3232457d5}"),
+  contractID: "@mozilla.org/secureelement/reader;1",
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  // Chrome-only function
+  onSessionClose: function onSessionClose(sessionCtx) {
+    let index = this._sessions.indexOf(sessionCtx);
+    if (index != -1) {
+      this._sessions.splice(index, 1);
+    }
+  },
+
+  initialize: function initialize(win, type, isPresent) {
+    this._window = win;
+    this.type = type;
+    this._isSEPresent = isPresent;
+  },
+
+  _checkPresence: function _checkPresence() {
+    if (!this._isSEPresent) {
+      throw new Error(SE.ERROR_NOTPRESENT);
+    }
+  },
+
+  openSession: function openSession() {
+    this._checkPresence();
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      let sessionImpl = new SESessionImpl();
+      sessionImpl.initialize(this._window, this);
+      this._window.SESession._create(this._window, sessionImpl);
+      this._sessions.push(sessionImpl);
+      PromiseHelpers.takePromiseResolver(resolverId)
+                    .resolve(sessionImpl.__DOM_IMPL__);
+    });
+  },
+
+  closeAll: function closeAll() {
+    this._checkPresence();
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      let promises = [];
+      for (let session of this._sessions) {
+        if (!session.isClosed) {
+          promises.push(session.closeAll());
+        }
+      }
+
+      let resolver = PromiseHelpers.takePromiseResolver(resolverId);
+      // Wait till all the promises are resolved
+      Promise.all(promises).then(() => {
+        this._sessions = [];
+        resolver.resolve();
+      }, (reason) => {
+        let error = new SEError(SE.ERROR_BADSTATE,
+          "Unable to close all channels associated with this reader");
+        resolver.reject(Cu.cloneInto(error, this._window));
+      });
+    });
+  },
+
+  updateSEPresence: function updateSEPresence(isSEPresent) {
+    if (!isSEPresent) {
+      this.invalidate();
+      return;
+    }
+
+    this._isSEPresent = isSEPresent;
+  },
+
+  invalidate: function invalidate() {
+    debug("Invalidating SE reader: " + this.type);
+    this._isSEPresent = false;
+    this._sessions.forEach(s => s.invalidate());
+    this._sessions = [];
+  },
+
+  get isSEPresent() {
+    return this._isSEPresent;
+  }
+};
+
+/**
+ * Instance of 'SESessionImpl' object represent a connection session
+ * to one of the secure elements available on the device.
+ * These objects can be used to get a communication channel with an application
+ * hosted by the Secure Element.
+ */
+function SESessionImpl() {}
+
+SESessionImpl.prototype = {
+  _window: null,
+
+  _channels: [],
+
+  _isClosed: false,
+
+  _reader: null,
+
+  classID: Components.ID("{2b1809f8-17bd-4947-abd7-bdef1498561c}"),
+  contractID: "@mozilla.org/secureelement/session;1",
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  // Chrome-only function
+  onChannelOpen: function onChannelOpen(channelCtx) {
+    this._channels.push(channelCtx);
+  },
+
+  // Chrome-only function
+  onChannelClose: function onChannelClose(channelCtx) {
+    let index = this._channels.indexOf(channelCtx);
+    if (index != -1) {
+      this._channels.splice(index, 1);
+    }
+  },
+
+  initialize: function initialize(win, readerCtx) {
+    this._window = win;
+    this._reader = readerCtx;
+  },
+
+  openLogicalChannel: function openLogicalChannel(aid) {
+    if (this._isClosed) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_BADSTATE,
+             "Session Already Closed!");
+    }
+
+    let aidLen = aid ? aid.length : 0;
+    if (aidLen < SE.MIN_AID_LEN || aidLen > SE.MAX_AID_LEN) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_ILLEGALPARAMETER,
+             "Invalid AID length - " + aidLen);
+    }
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      /**
+       * @params for 'SE:OpenChannel'
+       *
+       * resolverId  : ID that identifies this IPC request.
+       * aid         : AID that identifies the applet on SecureElement
+       * type        : Reader type ('uicc' / 'eSE')
+       * appId       : Current appId obtained from 'Principal' obj
+       */
+      cpmm.sendAsyncMessage("SE:OpenChannel", {
+        resolverId: resolverId,
+        aid: aid,
+        type: this.reader.type,
+        appId: this._window.document.nodePrincipal.appId
+      });
+    }, this);
+  },
+
+  closeAll: function closeAll() {
+    if (this._isClosed) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_BADSTATE,
+             "Session Already Closed!");
+    }
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      let promises = [];
+      for (let channel of this._channels) {
+        if (!channel.isClosed) {
+          promises.push(channel.close());
+        }
+      }
+
+      let resolver = PromiseHelpers.takePromiseResolver(resolverId);
+      Promise.all(promises).then(() => {
+        this._isClosed = true;
+        this._channels = [];
+        // Notify parent of this session instance's closure, so that its
+        // instance entry can be removed from the parent as well.
+        this._reader.onSessionClose(this.__DOM_IMPL__);
+        resolver.resolve();
+      }, (reason) => {
+        resolver.reject(new Error(SE.ERROR_BADSTATE +
+          "Unable to close all channels associated with this session"));
+      });
+    });
+  },
+
+  invalidate: function invlidate() {
+    this._isClosed = true;
+    this._channels.forEach(ch => ch.invalidate());
+    this._channels = [];
+  },
+
+  get reader() {
+    return this._reader.__DOM_IMPL__;
+  },
+
+  get isClosed() {
+    return this._isClosed;
+  },
+};
+
+/**
+ * Instance of 'SEChannelImpl' object represent an ISO/IEC 7816-4 specification
+ * channel opened to a secure element. It can be either a logical channel
+ * or basic channel.
+ */
+function SEChannelImpl() {}
+
+SEChannelImpl.prototype = {
+  _window: null,
+
+  _channelToken: null,
+
+  _isClosed: false,
+
+  _session: null,
+
+  openResponse: [],
+
+  type: null,
+
+  classID: Components.ID("{181ebcf4-5164-4e28-99f2-877ec6fa83b9}"),
+  contractID: "@mozilla.org/secureelement/channel;1",
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  // Chrome-only function
+  onClose: function onClose() {
+    this._isClosed = true;
+    // Notify the parent
+    this._session.onChannelClose(this.__DOM_IMPL__);
+  },
+
+  initialize: function initialize(win, channelToken, isBasicChannel,
+                                  openResponse, sessionCtx) {
+    this._window = win;
+    // Update the 'channel token' that identifies and represents this
+    // instance of the object
+    this._channelToken = channelToken;
+    // Update 'session' obj
+    this._session = sessionCtx;
+    this.openResponse = Cu.cloneInto(new Uint8Array(openResponse), win);
+    this.type = isBasicChannel ? "basic" : "logical";
+  },
+
+  transmit: function transmit(command) {
+    // TODO remove this once it will be possible to have a non-optional dict
+    // in the WebIDL
+    if (!command) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_ILLEGALPARAMETER,
+             "SECommand dict must be defined");
+    }
+
+    if (this._isClosed) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_BADSTATE,
+             "Channel Already Closed!");
+    }
+
+    let dataLen = command.data ? command.data.length : 0;
+    if (dataLen > SE.MAX_APDU_LEN) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_ILLEGALPARAMETER,
+             " Command data length exceeds max limit - 255. " +
+             " Extended APDU is not supported!");
+    }
+
+    if ((command.cla & 0x80 === 0) && ((command.cla & 0x60) !== 0x20)) {
+      if (command.ins === SE.INS_MANAGE_CHANNEL) {
+        return PromiseHelpers.rejectWithSEError(SE.ERROR_SECURITY,
+               "MANAGE CHANNEL command not permitted");
+      }
+      if ((command.ins === SE.INS_SELECT) && (command.p1 == 0x04)) {
+        // SELECT by DF Name (p1=04) is not allowed
+        return PromiseHelpers.rejectWithSEError(SE.ERROR_SECURITY,
+               "SELECT command not permitted");
+      }
+      debug("Attempting to transmit an ISO command");
+    } else {
+      debug("Attempting to transmit GlobalPlatform command");
+    }
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      /**
+       * @params for 'SE:TransmitAPDU'
+       *
+       * resolverId  : Id that identifies this IPC request.
+       * apdu        : Object containing APDU data
+       * channelToken: Token that identifies the current channel over which
+                       'c-apdu' is being sent.
+       * appId       : Current appId obtained from 'Principal' obj
+       */
+      cpmm.sendAsyncMessage("SE:TransmitAPDU", {
+        resolverId: resolverId,
+        apdu: command,
+        channelToken: this._channelToken,
+        appId: this._window.document.nodePrincipal.appId
+      });
+    }, this);
+  },
+
+  close: function close() {
+    if (this._isClosed) {
+      return PromiseHelpers.rejectWithSEError(SE.ERROR_BADSTATE,
+             "Channel Already Closed!");
+    }
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      /**
+       * @params for 'SE:CloseChannel'
+       *
+       * resolverId  : Id that identifies this IPC request.
+       * channelToken: Token that identifies the current channel over which
+                       'c-apdu' is being sent.
+       * appId       : Current appId obtained from 'Principal' obj
+       */
+      cpmm.sendAsyncMessage("SE:CloseChannel", {
+        resolverId: resolverId,
+        channelToken: this._channelToken,
+        appId: this._window.document.nodePrincipal.appId
+      });
+    }, this);
+  },
+
+  invalidate: function invalidate() {
+    this._isClosed = true;
+  },
+
+  get session() {
+    return this._session.__DOM_IMPL__;
+  },
+
+  get isClosed() {
+    return this._isClosed;
+  },
+};
+
+function SEResponseImpl() {}
+
+SEResponseImpl.prototype = {
+  sw1: 0x00,
+
+  sw2: 0x00,
+
+  data: null,
+
+  _channel: null,
+
+  classID: Components.ID("{58bc6c7b-686c-47cc-8867-578a6ed23f4e}"),
+  contractID: "@mozilla.org/secureelement/response;1",
+  QueryInterface: XPCOMUtils.generateQI([]),
+
+  initialize: function initialize(sw1, sw2, response, channelCtx) {
+    // Update the status bytes
+    this.sw1 = sw1;
+    this.sw2 = sw2;
+    this.data = response ? response.slice(0) : null;
+    // Update the channel obj
+    this._channel = channelCtx;
+  },
+
+  get channel() {
+    return this._channel.__DOM_IMPL__;
+  }
+};
+
+/**
+ * SEManagerImpl
+ */
+function SEManagerImpl() {}
+
+SEManagerImpl.prototype = {
+  __proto__: DOMRequestIpcHelper.prototype,
+
+  _window: null,
+
+  classID: Components.ID("{4a8b6ec0-4674-11e4-916c-0800200c9a66}"),
+  contractID: "@mozilla.org/secureelement/manager;1",
+  QueryInterface: XPCOMUtils.generateQI([
+    Ci.nsIDOMGlobalPropertyInitializer,
+    Ci.nsISupportsWeakReference,
+    Ci.nsIObserver
+  ]),
+
+  _readers: [],
+
+  init: function init(win) {
+    this._window = win;
+    PromiseHelpers = new PromiseHelpersSubclass(this._window);
+
+    // Add the messages to be listened to.
+    const messages = ["SE:GetSEReadersResolved",
+                      "SE:OpenChannelResolved",
+                      "SE:CloseChannelResolved",
+                      "SE:TransmitAPDUResolved",
+                      "SE:GetSEReadersRejected",
+                      "SE:OpenChannelRejected",
+                      "SE:CloseChannelRejected",
+                      "SE:TransmitAPDURejected",
+                      "SE:ReaderPresenceChanged"];
+
+    this.initDOMRequestHelper(win, messages);
+  },
+
+  // This function will be called from DOMRequestIPCHelper.
+  uninit: function uninit() {
+    // All requests that are still pending need to be invalidated
+    // because the context is no longer valid.
+    this.forEachPromiseResolver((k) => {
+      this.takePromiseResolver(k).reject("Window Context got destroyed!");
+    });
+    PromiseHelpers = null;
+    this._window = null;
+  },
+
+  getSEReaders: function getSEReaders() {
+    // invalidate previous readers on new request
+    if (this._readers.length) {
+      this._readers.forEach(r => r.invalidate());
+      this._readers = [];
+    }
+
+    return PromiseHelpers.createSEPromise((resolverId) => {
+      cpmm.sendAsyncMessage("SE:GetSEReaders", {
+        resolverId: resolverId,
+        appId: this._window.document.nodePrincipal.appId
+      });
+    });
+  },
+
+  receiveMessage: function receiveMessage(message) {
+    DEBUG && debug("Message received: " + JSON.stringify(message));
+
+    let result = message.data.result;
+    let resolver = null;
+    let context = null;
+
+    let promiseResolver = PromiseHelpers.takePromise(result.resolverId);
+    if (promiseResolver) {
+      resolver = promiseResolver.resolver;
+      // This 'context' is the instance that originated this IPC message.
+      context = promiseResolver.context;
+    }
+
+    switch (message.name) {
+      case "SE:GetSEReadersResolved":
+        let readers = new this._window.Array();
+        result.readers.forEach(reader => {
+          let readerImpl = new SEReaderImpl();
+          readerImpl.initialize(this._window, reader.type, reader.isPresent);
+          this._window.SEReader._create(this._window, readerImpl);
+
+          this._readers.push(readerImpl);
+          readers.push(readerImpl.__DOM_IMPL__);
+        });
+        resolver.resolve(readers);
+        break;
+      case "SE:OpenChannelResolved":
+        let channelImpl = new SEChannelImpl();
+        channelImpl.initialize(this._window,
+                               result.channelToken,
+                               result.isBasicChannel,
+                               result.openResponse,
+                               context);
+        this._window.SEChannel._create(this._window, channelImpl);
+        if (context) {
+          // Notify context's handler with SEChannel instance
+          context.onChannelOpen(channelImpl);
+        }
+        resolver.resolve(channelImpl.__DOM_IMPL__);
+        break;
+      case "SE:TransmitAPDUResolved":
+        let responseImpl = new SEResponseImpl();
+        responseImpl.initialize(result.sw1,
+                                result.sw2,
+                                result.response,
+                                context);
+        this._window.SEResponse._create(this._window, responseImpl);
+        resolver.resolve(responseImpl.__DOM_IMPL__);
+        break;
+      case "SE:CloseChannelResolved":
+        if (context) {
+          // Notify context's onClose handler
+          context.onClose();
+        }
+        resolver.resolve();
+        break;
+      case "SE:GetSEReadersRejected":
+      case "SE:OpenChannelRejected":
+      case "SE:CloseChannelRejected":
+      case "SE:TransmitAPDURejected":
+        let error = new SEError(result.error, result.reason);
+        resolver.reject(Cu.cloneInto(error, this._window));
+        break;
+      case "SE:ReaderPresenceChanged":
+        debug("Reader " + result.type + " present: " + result.isPresent);
+        let reader = this._readers.find(r => r.type === result.type);
+        if (reader) {
+          reader.updateSEPresence(result.isPresent);
+        }
+        break;
+      default:
+        debug("Could not find a handler for " + message.name);
+        resolver.reject(Cu.cloneInto(new SEError(), this._window));
+        break;
+    }
+  }
+};
+
+this.NSGetFactory = XPCOMUtils.generateNSGetFactory([
+  SEResponseImpl, SEChannelImpl, SESessionImpl, SEReaderImpl, SEManagerImpl
+]);