Source: lib/util/fairplay_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.FairPlayUtils');
  9. goog.require('goog.Uri');
  10. goog.require('goog.asserts');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.StringUtils');
  16. /**
  17.  * @summary A set of FairPlay utility functions.
  18.  * @export
  19.  */
  20. shaka.util.FairPlayUtils = class {
  21.   /**
  22.    * Using the default method, extract a content ID from the init data.  This is
  23.    * based on the FairPlay example documentation.
  24.    *
  25.    * @param {!BufferSource} initData
  26.    * @return {string}
  27.    * @export
  28.    */
  29.   static defaultGetContentId(initData) {
  30.     const uriString = shaka.util.StringUtils.fromBytesAutoDetect(initData);
  32.     // The domain of that URI is the content ID according to Apple's FPS
  33.     // sample.
  34.     const uri = new goog.Uri(uriString);
  35.     return uri.getDomain();
  36.   }
  38.   /**
  39.    * Transforms the init data buffer using the given data.  The format is:
  40.    *
  41.    * <pre>
  42.    * [4 bytes] initDataSize
  43.    * [initDataSize bytes] initData
  44.    * [4 bytes] contentIdSize
  45.    * [contentIdSize bytes] contentId
  46.    * [4 bytes] certSize
  47.    * [certSize bytes] cert
  48.    * </pre>
  49.    *
  50.    * @param {!BufferSource} initData
  51.    * @param {!BufferSource|string} contentId
  52.    * @param {?BufferSource} cert  The server certificate; this will throw if not
  53.    *   provided.
  54.    * @return {!Uint8Array}
  55.    * @export
  56.    */
  57.   static initDataTransform(initData, contentId, cert) {
  58.     if (!cert || !cert.byteLength) {
  59.       throw new shaka.util.Error(
  60.           shaka.util.Error.Severity.CRITICAL,
  61.           shaka.util.Error.Category.DRM,
  62.           shaka.util.Error.Code.SERVER_CERTIFICATE_REQUIRED);
  63.     }
  65.     // From that, we build a new init data to use in the session.  This is
  66.     // composed of several parts.  First, the init data as a UTF-16 sdk:// URL.
  67.     // Second, a 4-byte LE length followed by the content ID in UTF-16-LE.
  68.     // Third, a 4-byte LE length followed by the certificate.
  69.     /** @type {BufferSource} */
  70.     let contentIdArray;
  71.     if (typeof contentId == 'string') {
  72.       contentIdArray =
  73.           shaka.util.StringUtils.toUTF16(contentId, /* littleEndian= */ true);
  74.     } else {
  75.       contentIdArray = contentId;
  76.     }
  78.     // The init data we get is a UTF-8 string; convert that to a UTF-16 string.
  79.     const sdkUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
  80.     const utf16 =
  81.         shaka.util.StringUtils.toUTF16(sdkUri, /* littleEndian= */ true);
  83.     const rebuiltInitData = new Uint8Array(
  84.         12 + utf16.byteLength + contentIdArray.byteLength + cert.byteLength);
  86.     let offset = 0;
  87.     /** @param {BufferSource} array */
  88.     const append = (array) => {
  89.       rebuiltInitData.set(shaka.util.BufferUtils.toUint8(array), offset);
  90.       offset += array.byteLength;
  91.     };
  92.     /** @param {BufferSource} array */
  93.     const appendWithLength = (array) => {
  94.       const view = shaka.util.BufferUtils.toDataView(rebuiltInitData);
  95.       const value = array.byteLength;
  96.       view.setUint32(offset, value, /* littleEndian= */ true);
  97.       offset += 4;
  98.       append(array);
  99.     };
  101.     appendWithLength(utf16);
  102.     appendWithLength(contentIdArray);
  103.     appendWithLength(cert);
  105.     goog.asserts.assert(
  106.         offset == rebuiltInitData.length, 'Inconsistent init data length');
  107.     return rebuiltInitData;
  108.   }
  109. };