1 files changed, 418 insertions, 0 deletions

diff --git a/eme_interception.js b/eme_interception.js
new file mode 100644
index 0000000..d676881
--- /dev/null
+++ b/eme_interception.js
@@ -0,0 +1,418 @@
+/**

+ * Hooks EME calls and forwards them for analysis and decryption.

+ * 

+ * Most of the code here was borrowed from https://github.com/google/eme_logger/blob/master/eme_listeners.js

+ */

+

+ var lastReceivedLicenseRequest = null;

+ var lastReceivedLicenseResponse = null;

+

+ /** Set up the EME listeners. */

+function startEMEInterception() 

+{

+  var listener = new EmeInterception();

+  listener.setUpListeners();

+}

+

+ /**

+ * Gets called whenever an EME method is getting called or an EME event fires

+ */

+EmeInterception.onOperation = function(operationType, args) 

+{

+    if (operationType == "GenerateRequestCall")

+    {

+       // got initData

+       // console.log(args);

+    }

+    else if (operationType == "MessageEvent")

+    {

+        var licenseRequest = args.message;

+        lastReceivedLicenseRequest = licenseRequest;

+    }

+    else if (operationType == "UpdateCall")

+    {

+        var licenseResponse = args[0];

+        lastReceivedLicenseResponse = licenseResponse;

+

+        // OK, let's try to decrypt it, assuming the response correlates to the request

+        WidevineCrypto.decryptContentKey(lastReceivedLicenseRequest, lastReceivedLicenseResponse);

+    }

+};

+

+

+/**

+ * Manager for EME event and method listeners.

+ * @constructor

+ */

+function EmeInterception() 

+{

+  this.unprefixedEmeEnabled = Navigator.prototype.requestMediaKeySystemAccess ? true : false;

+  this.prefixedEmeEnabled = HTMLMediaElement.prototype.webkitGenerateKeyRequest ? true : false;

+}

+

+

+/**

+ * The number of types of HTML Media Elements to track.

+ * @const {number}

+ */

+EmeInterception.NUM_MEDIA_ELEMENT_TYPES = 3;

+

+

+/**

+ * Sets up EME listeners for whichever type of EME is enabled.

+ */

+EmeInterception.prototype.setUpListeners = function() 

+{

+  if (!this.unprefixedEmeEnabled && !this.prefixedEmeEnabled) {

+    // EME is not enabled, just ignore

+    return;

+  }

+  if (this.unprefixedEmeEnabled) {

+    this.addListenersToNavigator_();

+  }

+  if (this.prefixedEmeEnabled) {

+    // Prefixed EME is enabled

+  }

+  this.addListenersToAllEmeElements_();

+};

+

+

+/**

+ * Adds listeners to the EME methods on the Navigator object.

+ * @private

+ */

+EmeInterception.prototype.addListenersToNavigator_ = function() 

+{

+  if (navigator.listenersAdded_) 

+    return;

+

+  var originalRequestMediaKeySystemAccessFn = EmeInterception.extendEmeMethod(

+      navigator,

+      navigator.requestMediaKeySystemAccess,

+      "RequestMediaKeySystemAccessCall");

+

+  navigator.requestMediaKeySystemAccess = function() 

+  {

+    var options = arguments[1];

+

+    // slice "It is recommended that a robustness level be specified" warning

+    var modifiedArguments = arguments;

+    var modifiedOptions = EmeInterception.addRobustnessLevelIfNeeded(options);

+    modifiedArguments[1] = modifiedOptions;

+

+    var result = originalRequestMediaKeySystemAccessFn.apply(null, modifiedArguments);

+    // Attach listeners to returned MediaKeySystemAccess object

+    return result.then(function(mediaKeySystemAccess) 

+    {

+      this.addListenersToMediaKeySystemAccess_(mediaKeySystemAccess);

+      return Promise.resolve(mediaKeySystemAccess);

+    }.bind(this));

+

+  }.bind(this);

+

+  navigator.listenersAdded_ = true;

+};

+

+

+/**

+ * Adds listeners to the EME methods on a MediaKeySystemAccess object.

+ * @param {MediaKeySystemAccess} mediaKeySystemAccess A MediaKeySystemAccess

+ *     object to add listeners to.

+ * @private

+ */

+EmeInterception.prototype.addListenersToMediaKeySystemAccess_ = function(mediaKeySystemAccess) 

+{

+  if (mediaKeySystemAccess.listenersAdded_) {

+    return;

+  }

+  mediaKeySystemAccess.originalGetConfiguration = mediaKeySystemAccess.getConfiguration;

+  mediaKeySystemAccess.getConfiguration = EmeInterception.extendEmeMethod(

+      mediaKeySystemAccess,

+      mediaKeySystemAccess.getConfiguration,

+      "GetConfigurationCall");

+

+  var originalCreateMediaKeysFn = EmeInterception.extendEmeMethod(

+      mediaKeySystemAccess,

+      mediaKeySystemAccess.createMediaKeys,

+      "CreateMediaKeysCall");

+

+  mediaKeySystemAccess.createMediaKeys = function() 

+  {

+    var result = originalCreateMediaKeysFn.apply(null, arguments);

+    // Attach listeners to returned MediaKeys object

+    return result.then(function(mediaKeys) {

+      mediaKeys.keySystem_ = mediaKeySystemAccess.keySystem;

+      this.addListenersToMediaKeys_(mediaKeys);

+      return Promise.resolve(mediaKeys);

+    }.bind(this));

+

+  }.bind(this);

+

+  mediaKeySystemAccess.listenersAdded_ = true;

+};

+

+

+/**

+ * Adds listeners to the EME methods on a MediaKeys object.

+ * @param {MediaKeys} mediaKeys A MediaKeys object to add listeners to.

+ * @private

+ */

+EmeInterception.prototype.addListenersToMediaKeys_ = function(mediaKeys) 

+{

+  if (mediaKeys.listenersAdded_) {

+    return;

+  }

+  var originalCreateSessionFn = EmeInterception.extendEmeMethod(mediaKeys, mediaKeys.createSession, "CreateSessionCall");

+  mediaKeys.createSession = function() 

+  {

+    var result = originalCreateSessionFn.apply(null, arguments);

+    result.keySystem_ = mediaKeys.keySystem_;

+    // Attach listeners to returned MediaKeySession object

+    this.addListenersToMediaKeySession_(result);

+    return result;

+  }.bind(this);

+

+  mediaKeys.setServerCertificate = EmeInterception.extendEmeMethod(mediaKeys, mediaKeys.setServerCertificate, "SetServerCertificateCall");

+  mediaKeys.listenersAdded_ = true;

+};

+

+

+/** Adds listeners to the EME methods and events on a MediaKeySession object.

+ * @param {MediaKeySession} session A MediaKeySession object to add

+ *     listeners to.

+ * @private

+ */

+EmeInterception.prototype.addListenersToMediaKeySession_ = function(session) 

+{

+  if (session.listenersAdded_) {

+    return;

+  }

+

+  session.generateRequest = EmeInterception.extendEmeMethod(session,session.generateRequest, "GenerateRequestCall");

+  session.load = EmeInterception.extendEmeMethod(session, session.load, "LoadCall");

+  session.update = EmeInterception.extendEmeMethod(session,session.update, "UpdateCall");

+  session.close = EmeInterception.extendEmeMethod(session, session.close, "CloseCall");

+  session.remove = EmeInterception.extendEmeMethod(session, session.remove, "RemoveCall");

+

+  session.addEventListener('message', function(e) 

+  {

+    e.keySystem = session.keySystem_;

+    EmeInterception.interceptEvent("MessageEvent", e);

+  });

+

+  session.addEventListener('keystatuseschange', EmeInterception.interceptEvent.bind(null, "KeyStatusesChangeEvent"));

+

+  session.listenersAdded_ = true;

+};

+

+

+/**

+ * Adds listeners to all currently created media elements (audio, video) and sets up a

+ * mutation-summary observer to add listeners to any newly created media

+ * elements.

+ * @private

+ */

+EmeInterception.prototype.addListenersToAllEmeElements_ = function() 

+{

+  this.addEmeInterceptionToInitialMediaElements_();

+

+  // TODO: Use MutationObserver directry

+  // var observer = new MutationSummary({

+  //   callback: function(summaries) {

+  //     applyListeners(summaries);

+  //   },

+  //   queries: [{element: 'video'}, {element: 'audio'}, {element: 'media'}]

+  // });

+

+  // var applyListeners = function(summaries) {

+  //   for (var i = 0; i < EmeInterception.NUM_MEDIA_ELEMENT_TYPES; i++) {

+  //     var elements = summaries[i];

+  //     elements.added.forEach(function(element) {

+  //       this.addListenersToEmeElement_(element, true);

+  //     }.bind(this));

+  //   }

+  // }.bind(this);

+};

+

+

+/**

+ * Adds listeners to the EME elements currently in the document.

+ * @private

+ */

+EmeInterception.prototype.addEmeInterceptionToInitialMediaElements_ = function() 

+{

+  var audioElements = document.getElementsByTagName('audio');

+  for (var i = 0; i < audioElements.length; ++i) {

+    this.addListenersToEmeElement_(audioElements[i], false);

+  }

+  var videoElements = document.getElementsByTagName('video');

+  for (var i = 0; i < videoElements.length; ++i) {

+    this.addListenersToEmeElement_(videoElements[i], false);

+  }

+  var mediaElements = document.getElementsByTagName('media');

+  for (var i = 0; i < mediaElements.length; ++i) {

+    this.addListenersToEmeElement_(mediaElements[i], false);

+  }

+};

+

+

+/**

+ * Adds method and event listeners to media element.

+ * @param {HTMLMediaElement} element A HTMLMedia element to add listeners to.

+ * @private

+ */

+EmeInterception.prototype.addListenersToEmeElement_ = function(element) 

+{

+  this.addEmeEventListeners_(element);

+  this.addEmeMethodListeners_(element);

+  console.info('EME listeners successfully added to:', element);

+};

+

+

+/**

+ * Adds event listeners to a media element.

+ * @param {HTMLMediaElement} element A HTMLMedia element to add listeners to.

+ * @private

+ */

+EmeInterception.prototype.addEmeEventListeners_ = function(element) 

+{

+  if (element.eventListenersAdded_) {

+    return;

+  }

+

+  if (this.prefixedEmeEnabled) 

+  {

+    element.addEventListener('webkitneedkey', EmeInterception.interceptEvent.bind(null, "NeedKeyEvent"));

+    element.addEventListener('webkitkeymessage', EmeInterception.interceptEvent.bind(null, "KeyMessageEvent"));

+    element.addEventListener('webkitkeyadded', EmeInterception.interceptEvent.bind(null, "KeyAddedEvent"));

+    element.addEventListener('webkitkeyerror', EmeInterception.interceptEvent.bind(null, "KeyErrorEvent"));

+  }

+

+  element.addEventListener('encrypted', EmeInterception.interceptEvent.bind(null, "EncryptedEvent"));

+  element.addEventListener('play', EmeInterception.interceptEvent.bind(null, "PlayEvent"));

+

+  element.addEventListener('error', function(e) {

+    console.error('Error Event');

+    EmeInterception.interceptEvent("ErrorEvent", e);

+  });

+

+  element.eventListenersAdded_ = true;

+};

+

+

+/**

+ * Adds method listeners to a media element.

+ * @param {HTMLMediaElement} element A HTMLMedia element to add listeners to.

+ * @private

+ */

+EmeInterception.prototype.addEmeMethodListeners_ = function(element) 

+{

+  if (element.methodListenersAdded_) {

+    return;

+  }

+

+  element.play = EmeInterception.extendEmeMethod(element, element.play, "PlayCall");

+

+  if (this.prefixedEmeEnabled) {

+    element.canPlayType = EmeInterception.extendEmeMethod(element, element.canPlayType, "CanPlayTypeCall");

+

+    element.webkitGenerateKeyRequest = EmeInterception.extendEmeMethod(element, element.webkitGenerateKeyRequest, "GenerateKeyRequestCall");

+    element.webkitAddKey = EmeInterception.extendEmeMethod(element, element.webkitAddKey, "AddKeyCall");

+    element.webkitCancelKeyRequest = EmeInterception.extendEmeMethod(element, element.webkitCancelKeyRequest, "CancelKeyRequestCall");

+

+  }

+

+  if (this.unprefixedEmeEnabled) {

+    element.setMediaKeys = EmeInterception.extendEmeMethod(element, element.setMediaKeys, "SetMediaKeysCall");

+  }

+

+  element.methodListenersAdded_ = true;

+};

+

+

+/**

+ * Creates a wrapper function that logs calls to the given method.

+ * @param {!Object} element An element or object whose function

+ *    call will be logged.

+ * @param {!Function} originalFn The function to log.

+ * @param {!Function} type The constructor for a logger class that will

+ *    be instantiated to log the originalFn call.

+ * @return {!Function} The new version, with logging, of orginalFn.

+ */

+EmeInterception.extendEmeMethod = function(element, originalFn, type) 

+{

+  return function() 

+  {

+    try

+    {

+        var result = originalFn.apply(element, arguments);

+        var args = [].slice.call(arguments);

+        EmeInterception.interceptCall(type, args, result, element);

+    }

+    catch (e)

+    {

+      console.error(e);

+    }

+    

+

+    return result;

+  };

+};

+

+

+/**

+ * Intercepts a method call to the console and a separate frame.

+ * @param {!Function} constructor The constructor for a logger class that will

+ *    be instantiated to log this call.

+ * @param {Array} args The arguments this call was made with.

+ * @param {Object} result The result of this method call.

+ * @param {!Object} target The element this method was called on.

+ * @return {!eme.EmeMethodCall} The data that has been logged.

+ */

+EmeInterception.interceptCall = function(type, args, result, target) 

+{

+  EmeInterception.onOperation(type, args);

+  return args;

+};

+

+/**

+ * Intercepts an event to the console and a separate frame.

+ * @param {!Function} constructor The constructor for a logger class that will

+ *    be instantiated to log this event.

+ * @param {!Event} event An EME event.

+ * @return {!eme.EmeEvent} The data that has been logged.

+ */

+EmeInterception.interceptEvent = function(type, event) 

+{

+  EmeInterception.onOperation(type, event);

+  return event;

+};

+

+EmeInterception.addRobustnessLevelIfNeeded = function(options)

+{

+  for (var i = 0; i < options.length; i++)

+  {

+    var option = options[i];

+    var videoCapabilities = option["videoCapabilities"];

+    var audioCapabilties = option["audioCapabilities"];

+    if (videoCapabilities != null)

+    {

+      for (var j = 0; j < videoCapabilities.length; j++)

+        if (videoCapabilities[j]["robustness"] == undefined) videoCapabilities[j]["robustness"] = "SW_SECURE_CRYPTO";

+    }

+

+    if (audioCapabilties != null)

+    {

+      for (var j = 0; j < audioCapabilties.length; j++)

+        if (audioCapabilties[j]["robustness"] == undefined) audioCapabilties[j]["robustness"] = "SW_SECURE_CRYPTO";

+    }

+    

+    option["videoCapabilities"] = videoCapabilities;

+    option["audioCapabilities"] = audioCapabilties;

+    options[i] = option;

+  }

+

+  return options;

+}

+

+startEMEInterception();