Fix FairPlay encrypted event handling.

The 'webkitkeyneeded' and 'encrypted' events send similar data, but
they were incompatible with each other and our transform handling.
This makes our polyfill produce the same format as the browser for
cases where the browser may only fire the old event.  This also makes
our utilities work with the new format.

The 'webkitkeyneeded' event was a length-prefixed UTF-16 string while
the 'encrypted' event was just a UTF-8 string.

This also makes a breaking change in the transform callback to pass the
init data type.  This shouldn't break anyone that only uses the first
argument; the second argument was mainly added so we could have the
default transform work without knowing anything.

This change could also break people who use custom transform functions.
The init data format is changing, which could break people who read
it directly.  If they follow the tutorial and use our utilities, it
shouldn't break.  This also updates the tutorial to match the new format
and be more clear about the format.

Fixes #2214

Change-Id: I006382028e828e31e20e085114fd7fd85c0e1eaa

Author: TheModMaker

docs/tutorials/fairplay.md

@@ -25,8 +25,13 @@ is used by the browser to generate the license request.  If you don't use the
 default content ID derivation, you need to specify a custom init data transform:
 
 ```js
-player.configure('drm.initDataTransform', (initData) => {
-  const contentId = getMyContentId(initData);
+player.configure('drm.initDataTransform', (initData, initDataType) => {
+  if (initDataType != 'skd')
+    return initData;
+
+  // 'initData' is a buffer containing an 'skd://' URL as a UTF-8 string.
+  const skdUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
+  const contentId = getMyContentId(sdkUri);
   const cert = player.drmInfo().serverCertificate;
   return shaka.util.FairPlayUtils.initDataTransform(initData, contentId, cert);
 });

externs/shaka/player.js

@@ -520,7 +520,8 @@ shaka.extern.AdvancedDrmConfiguration;
  *   delayLicenseRequestUntilPlayed: boolean,
  *   advanced: Object.<string, shaka.extern.AdvancedDrmConfiguration>,
  *   initDataTransform:
- *       ((function(!Uint8Array, ?shaka.extern.DrmInfo):!Uint8Array)|undefined),
+ *       ((function(!Uint8Array, string, ?shaka.extern.DrmInfo):!Uint8Array)|
+ *         undefined),
  *   logLicenseExchange: boolean
  * }}
  *
@@ -543,7 +544,8 @@ shaka.extern.AdvancedDrmConfiguration;
  *   A dictionary which maps key system IDs to advanced DRM configuration for
  *   those key systems.
  * @property
- *     {((function(!Uint8Array, ?shaka.extern.DrmInfo):!Uint8Array)|undefined)}
+ *     {((function(!Uint8Array, string, ?shaka.extern.DrmInfo):!Uint8Array)|
+ *        undefined)}
  *   initDataTransform
  *   <i>Optional.</i><br>
  *   If given, this function is called with the init data from the

lib/media/drm_engine.js

@@ -1016,7 +1016,8 @@ shaka.media.DrmEngine = class {
     this.activeSessions_.set(session, metadata);
 
     try {
-      initData = this.config_.initDataTransform(initData, this.currentDrmInfo_);
+      initData = this.config_.initDataTransform(
+          initData, initDataType, this.currentDrmInfo_);
     } catch (error) {
       let shakaError = error;
       if (!(error instanceof shaka.util.Error)) {
@@ -1061,11 +1062,12 @@ shaka.media.DrmEngine = class {
 
   /**
    * @param {!Uint8Array} initData
+   * @param {string} initDataType
    * @param {?shaka.extern.DrmInfo} drmInfo
    * @return {!Uint8Array}
    */
-  static defaultInitDataTransform(initData, drmInfo) {
-    if (shaka.media.DrmEngine.keySystem(drmInfo).startsWith('com.apple.fps')) {
+  static defaultInitDataTransform(initData, initDataType, drmInfo) {
+    if (initDataType == 'skd') {
       const cert = drmInfo.serverCertificate;
       const contentId =
           shaka.util.FairPlayUtils.defaultGetContentId(initData);

lib/polyfill/patchedmediakeys_apple.js

@@ -150,12 +150,26 @@ shaka.polyfill.PatchedMediaKeysApple = class {
 
     goog.asserts.assert(event.initData != null, 'missing init data!');
 
+    // Convert the prefixed init data to match the native 'encrypted' event.
+    const uint8 = shaka.util.BufferUtils.toUint8(event.initData);
+    const dataview = shaka.util.BufferUtils.toDataView(uint8);
+    // The first part is a 4 byte little-endian int, which is the length of
+    // the second part.
+    const length = dataview.getUint32(
+        /* position= */ 0, /* littleEndian= */ true);
+    if (length + 4 != uint8.byteLength) {
+      throw new RangeError('Malformed FairPlay init data');
+    }
+    // The remainder is a UTF-16 skd URL.  Convert this to UTF-8 and pass on.
+    const str = shaka.util.StringUtils.fromUTF16(
+        uint8.subarray(4), /* littleEndian= */ true);
+    const initData = shaka.util.StringUtils.toUTF8(str);
+
     // NOTE: Because "this" is a real EventTarget, the event we dispatch here
     // must also be a real Event.
     const event2 = new Event('encrypted');
-    // TODO: validate this initDataType against the unprefixed version
-    event2.initDataType = 'cenc';
-    event2.initData = shaka.util.BufferUtils.toArrayBuffer(event.initData);
+    event2.initDataType = 'skd';
+    event2.initData = shaka.util.BufferUtils.toArrayBuffer(initData);
 
     this.dispatchEvent(event2);
   }

lib/util/fairplay_utils.js

@@ -6,6 +6,7 @@
 goog.provide('shaka.util.FairPlayUtils');
 
 goog.require('goog.Uri');
+goog.require('goog.asserts');
 goog.require('shaka.util.BufferUtils');
 
 
@@ -23,19 +24,7 @@ shaka.util.FairPlayUtils = class {
    * @export
    */
   static defaultGetContentId(initData) {
-    const uint8 = shaka.util.BufferUtils.toUint8(initData);
-    const dataview = shaka.util.BufferUtils.toDataView(uint8);
-    // The first part is a 4 byte little-endian int, which is the length of
-    // the second part.
-    const length = dataview.getUint32(
-        /* position= */ 0, /* littleEndian= */ true);
-    if (length + 4 != uint8.byteLength) {
-      throw new RangeError('Malformed FairPlay init data');
-    }
-
-    // The second part is a UTF-16 LE URI from the manifest.
-    const uriString = shaka.util.StringUtils.fromUTF16(
-        uint8.subarray(4), /* littleEndian= */ true);
+    const uriString = shaka.util.StringUtils.fromBytesAutoDetect(initData);
 
     // The domain of that URI is the content ID according to Apple's FPS
     // sample.
@@ -71,7 +60,7 @@ shaka.util.FairPlayUtils = class {
     }
 
     // From that, we build a new init data to use in the session.  This is
-    // composed of several parts.  First, the raw init data we already got.
+    // composed of several parts.  First, the init data as a UTF-16 sdk:// URL.
     // Second, a 4-byte LE length followed by the content ID in UTF-16-LE.
     // Third, a 4-byte LE length followed by the certificate.
     /** @type {BufferSource} */
@@ -83,8 +72,13 @@ shaka.util.FairPlayUtils = class {
       contentIdArray = contentId;
     }
 
+    // The init data we get is a UTF-8 string; convert that to a UTF-16 string.
+    const sdkUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
+    const utf16 =
+        shaka.util.StringUtils.toUTF16(sdkUri, /* littleEndian= */ true);
+
     const rebuiltInitData = new Uint8Array(
-        8 + initData.byteLength + contentIdArray.byteLength + cert.byteLength);
+        12 + utf16.byteLength + contentIdArray.byteLength + cert.byteLength);
 
     let offset = 0;
     /** @param {BufferSource} array */
@@ -101,10 +95,12 @@ shaka.util.FairPlayUtils = class {
       append(array);
     };
 
-    append(initData);
+    appendWithLength(utf16);
     appendWithLength(contentIdArray);
     appendWithLength(cert);
 
+    goog.asserts.assert(
+        offset == rebuiltInitData.length, 'Inconsistent init data length');
     return rebuiltInitData;
   }
 };