Source: lib/dash/content_protection.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.dash.ContentProtection');
  9. goog.require('goog.asserts');
  10. goog.require('shaka.log');
  11. goog.require('shaka.util.BufferUtils');
  12. goog.require('shaka.util.Error');
  13. goog.require('shaka.util.ManifestParserUtils');
  14. goog.require('shaka.util.Platform');
  15. goog.require('shaka.util.Pssh');
  16. goog.require('shaka.util.StringUtils');
  17. goog.require('shaka.util.TXml');
  18. goog.require('shaka.util.Uint8ArrayUtils');
  21. /**
  22.  * @summary A set of functions for parsing and interpreting ContentProtection
  23.  *   elements.
  24.  */
  25. shaka.dash.ContentProtection = class {
  26.   /**
  27.    * Parses info from the ContentProtection elements at the AdaptationSet level.
  28.    *
  29.    * @param {!Array.<!shaka.extern.xml.Node>} elems
  30.    * @param {boolean} ignoreDrmInfo
  31.    * @param {!Object.<string, string>} keySystemsByURI
  32.    * @return {shaka.dash.ContentProtection.Context}
  33.    */
  34.   static parseFromAdaptationSet(elems, ignoreDrmInfo, keySystemsByURI) {
  35.     const ContentProtection = shaka.dash.ContentProtection;
  36.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  37.     const parsed = ContentProtection.parseElements_(elems);
  38.     /** @type {Array.<shaka.extern.InitDataOverride>} */
  39.     let defaultInit = null;
  40.     /** @type {!Array.<shaka.extern.DrmInfo>} */
  41.     let drmInfos = [];
  42.     let parsedNonCenc = [];
  43.     /** @type {?shaka.dash.ContentProtection.Aes128Info} */
  44.     let aes128Info = null;
  46.     // Get the default key ID; if there are multiple, they must all match.
  47.     const keyIds = new Set(parsed.map((element) => element.keyId));
  48.     // Remove any possible null value (elements may have no key ids).
  49.     keyIds.delete(null);
  51.     let encryptionScheme = 'cenc';
  53.     if (keyIds.size > 1) {
  54.       throw new shaka.util.Error(
  55.           shaka.util.Error.Severity.CRITICAL,
  56.           shaka.util.Error.Category.MANIFEST,
  57.           shaka.util.Error.Code.DASH_CONFLICTING_KEY_IDS);
  58.     }
  60.     if (!ignoreDrmInfo) {
  61.       const aes128Elements = parsed.filter((elem) => {
  62.         return elem.schemeUri == ContentProtection.Aes128Protection_;
  63.       });
  65.       if (aes128Elements.length > 1) {
  66.         throw new shaka.util.Error(
  67.             shaka.util.Error.Severity.CRITICAL,
  68.             shaka.util.Error.Category.MANIFEST,
  69.             shaka.util.Error.Code.DASH_CONFLICTING_AES_128);
  70.       }
  72.       if (aes128Elements.length) {
  73.         aes128Info = ContentProtection.parseAes128_(aes128Elements[0]);
  74.       }
  76.       const mp4ProtectionParsed = parsed.find((elem) => {
  77.         return elem.schemeUri == ContentProtection.MP4Protection_;
  78.       });
  80.       if (mp4ProtectionParsed && mp4ProtectionParsed.encryptionScheme) {
  81.         encryptionScheme = mp4ProtectionParsed.encryptionScheme;
  82.       }
  84.       // Find the default key ID and init data.  Create a new array of all the
  85.       // non-CENC elements.
  86.       parsedNonCenc = parsed.filter((elem) => {
  87.         if (elem.schemeUri == ContentProtection.MP4Protection_) {
  88.           goog.asserts.assert(!elem.init || elem.init.length,
  89.               'Init data must be null or non-empty.');
  90.           defaultInit = elem.init || defaultInit;
  91.           return false;
  92.         } else {
  93.           return elem.schemeUri != ContentProtection.Aes128Protection_;
  94.         }
  95.       });
  97.       if (parsedNonCenc.length) {
  98.         drmInfos = ContentProtection.convertElements_(defaultInit,
  99.             encryptionScheme, parsedNonCenc, keySystemsByURI, keyIds);
  101.         // If there are no drmInfos after parsing, then add a dummy entry.
  102.         // This may be removed in parseKeyIds.
  103.         if (drmInfos.length == 0) {
  104.           drmInfos = [ManifestParserUtils.createDrmInfo(
  105.               '', encryptionScheme, defaultInit)];
  106.         }
  107.       }
  108.     }
  110.     // If there are only CENC element(s) or ignoreDrmInfo flag is set, assume
  111.     // all key-systems are supported.
  112.     if (parsed.length && !aes128Info &&
  113.         (ignoreDrmInfo || !parsedNonCenc.length)) {
  114.       drmInfos = [];
  116.       for (const keySystem of Object.values(keySystemsByURI)) {
  117.         // If the manifest doesn't specify any key systems, we shouldn't
  118.         // put clearkey in this list.  Otherwise, it may be triggered when
  119.         // a real key system should be used instead.
  120.         if (keySystem != 'org.w3.clearkey') {
  121.           const info = ManifestParserUtils.createDrmInfo(
  122.               keySystem, encryptionScheme, defaultInit);
  123.           drmInfos.push(info);
  124.         }
  125.       }
  126.     }
  128.     // If we have a default key id, apply it to every initData.
  129.     const defaultKeyId = Array.from(keyIds)[0] || null;
  131.     if (defaultKeyId) {
  132.       for (const info of drmInfos) {
  133.         for (const initData of info.initData) {
  134.           initData.keyId = defaultKeyId;
  135.         }
  136.       }
  137.     }
  139.     return {
  140.       defaultKeyId: defaultKeyId,
  141.       defaultInit: defaultInit,
  142.       drmInfos: drmInfos,
  143.       aes128Info: aes128Info,
  144.       firstRepresentation: true,
  145.     };
  146.   }
  148.   /**
  149.    * Parses the given ContentProtection elements found at the Representation
  150.    * level.  This may update the |context|.
  151.    *
  152.    * @param {!Array.<!shaka.extern.xml.Node>} elems
  153.    * @param {shaka.dash.ContentProtection.Context} context
  154.    * @param {boolean} ignoreDrmInfo
  155.    * @param {!Object.<string, string>} keySystemsByURI
  156.    * @return {?string} The parsed key ID
  157.    */
  158.   static parseFromRepresentation(
  159.       elems, context, ignoreDrmInfo, keySystemsByURI) {
  160.     const ContentProtection = shaka.dash.ContentProtection;
  161.     const repContext = ContentProtection.parseFromAdaptationSet(
  162.         elems, ignoreDrmInfo, keySystemsByURI);
  164.     if (context.firstRepresentation) {
  165.       const asUnknown = context.drmInfos.length == 1 &&
  166.           !context.drmInfos[0].keySystem;
  167.       const asUnencrypted = context.drmInfos.length == 0;
  168.       const repUnencrypted = repContext.drmInfos.length == 0;
  170.       // There are two cases where we need to replace the |drmInfos| in the
  171.       // context with those in the Representation:
  172.       //   1. The AdaptationSet does not list any ContentProtection.
  173.       //   2. The AdaptationSet only lists unknown key-systems.
  174.       if (asUnencrypted || (asUnknown && !repUnencrypted)) {
  175.         context.drmInfos = repContext.drmInfos;
  176.       }
  177.       context.firstRepresentation = false;
  178.     } else if (repContext.drmInfos.length > 0) {
  179.       // If this is not the first Representation, then we need to remove entries
  180.       // from the context that do not appear in this Representation.
  181.       context.drmInfos = context.drmInfos.filter((asInfo) => {
  182.         return repContext.drmInfos.some((repInfo) => {
  183.           return repInfo.keySystem == asInfo.keySystem;
  184.         });
  185.       });
  186.       // If we have filtered out all key-systems, throw an error.
  187.       if (context.drmInfos.length == 0) {
  188.         throw new shaka.util.Error(
  189.             shaka.util.Error.Severity.CRITICAL,
  190.             shaka.util.Error.Category.MANIFEST,
  191.             shaka.util.Error.Code.DASH_NO_COMMON_KEY_SYSTEM);
  192.       }
  193.     }
  195.     return repContext.defaultKeyId || context.defaultKeyId;
  196.   }
  198.   /**
  199.    * Gets a FairPlay license URL from a content protection element
  200.    * containing a 'dashif:Laurl' element
  201.    *
  202.    * @param {shaka.dash.ContentProtection.Element} element
  203.    * @return {string}
  204.    */
  205.   static getFairPlayLicenseUrl(element) {
  206.     if (shaka.util.Platform.isMediaKeysPolyfilled('apple')) {
  207.       throw new shaka.util.Error(
  208.           shaka.util.Error.Severity.CRITICAL,
  209.           shaka.util.Error.Category.MANIFEST,
  210.           shaka.util.Error.Code
  211.               .DASH_MSE_ENCRYPTED_LEGACY_APPLE_MEDIA_KEYS_NOT_SUPPORTED);
  212.     }
  213.     const dashIfLaurlNode = shaka.util.TXml.findChildNS(
  214.         element.node, shaka.dash.ContentProtection.DashIfNamespaceUri_,
  215.         'Laurl',
  216.     );
  217.     if (dashIfLaurlNode) {
  218.       const textContents = shaka.util.TXml.getTextContents(dashIfLaurlNode);
  219.       if (textContents) {
  220.         return textContents;
  221.       }
  222.     }
  223.     return '';
  224.   }
  226.   /**
  227.    * Gets a Widevine license URL from a content protection element
  228.    * containing a custom `ms:laurl` or 'dashif:Laurl' elements
  229.    *
  230.    * @param {shaka.dash.ContentProtection.Element} element
  231.    * @return {string}
  232.    */
  233.   static getWidevineLicenseUrl(element) {
  234.     const StringUtils = shaka.util.StringUtils;
  235.     const dashIfLaurlNode = shaka.util.TXml.findChildNS(
  236.         element.node, shaka.dash.ContentProtection.DashIfNamespaceUri_,
  237.         'Laurl',
  238.     );
  239.     if (dashIfLaurlNode) {
  240.       const textContents = shaka.util.TXml.getTextContents(dashIfLaurlNode);
  241.       if (textContents) {
  242.         return textContents;
  243.       }
  244.     }
  245.     const mslaurlNode = shaka.util.TXml.findChildNS(
  246.         element.node, 'urn:microsoft', 'laurl');
  247.     if (mslaurlNode) {
  248.       return StringUtils.htmlUnescape(
  249.           mslaurlNode.attributes['licenseUrl']) || '';
  250.     }
  251.     return '';
  252.   }
  254.   /**
  255.    * Gets a ClearKey license URL from a content protection element
  256.    * containing a custom `clearkey::Laurl` or 'dashif:Laurl' elements
  257.    *
  258.    * @param {shaka.dash.ContentProtection.Element} element
  259.    * @return {string}
  260.    */
  261.   static getClearKeyLicenseUrl(element) {
  262.     const dashIfLaurlNode = shaka.util.TXml.findChildNS(
  263.         element.node, shaka.dash.ContentProtection.DashIfNamespaceUri_,
  264.         'Laurl',
  265.     );
  266.     if (dashIfLaurlNode) {
  267.       const textContents = shaka.util.TXml.getTextContents(dashIfLaurlNode);
  268.       if (textContents) {
  269.         return textContents;
  270.       }
  271.     }
  272.     const clearKeyLaurlNode = shaka.util.TXml.findChildNS(
  273.         element.node, shaka.dash.ContentProtection.ClearKeyNamespaceUri_,
  274.         'Laurl',
  275.     );
  276.     if (clearKeyLaurlNode &&
  277.         clearKeyLaurlNode.attributes['Lic_type'] === 'EME-1.0') {
  278.       if (clearKeyLaurlNode) {
  279.         const textContents = shaka.util.TXml.getTextContents(clearKeyLaurlNode);
  280.         if (textContents) {
  281.           return textContents;
  282.         }
  283.       }
  284.     }
  285.     return '';
  286.   }
  288.   /**
  289.    * Parses an Array buffer starting at byteOffset for PlayReady Object Records.
  290.    * Each PRO Record is preceded by its PlayReady Record type and length in
  291.    * bytes.
  292.    *
  293.    * PlayReady Object Record format: https://goo.gl/FTcu46
  294.    *
  295.    * @param {!DataView} view
  296.    * @param {number} byteOffset
  297.    * @return {!Array.<shaka.dash.ContentProtection.PlayReadyRecord>}
  298.    * @private
  299.    */
  300.   static parseMsProRecords_(view, byteOffset) {
  301.     const records = [];
  303.     while (byteOffset < view.byteLength - 1) {
  304.       const type = view.getUint16(byteOffset, true);
  305.       byteOffset += 2;
  307.       const byteLength = view.getUint16(byteOffset, true);
  308.       byteOffset += 2;
  310.       if ((byteLength & 1) != 0 || byteLength + byteOffset > view.byteLength) {
  311.         shaka.log.warning('Malformed MS PRO object');
  312.         return [];
  313.       }
  315.       const recordValue = shaka.util.BufferUtils.toUint8(
  316.           view, byteOffset, byteLength);
  317.       records.push({
  318.         type: type,
  319.         value: recordValue,
  320.       });
  322.       byteOffset += byteLength;
  323.     }
  325.     return records;
  326.   }
  328.   /**
  329.    * Parses a buffer for PlayReady Objects.  The data
  330.    * should contain a 32-bit integer indicating the length of
  331.    * the PRO in bytes.  Following that, a 16-bit integer for
  332.    * the number of PlayReady Object Records in the PRO.  Lastly,
  333.    * a byte array of the PRO Records themselves.
  334.    *
  335.    * PlayReady Object format: https://goo.gl/W8yAN4
  336.    *
  337.    * @param {BufferSource} data
  338.    * @return {!Array.<shaka.dash.ContentProtection.PlayReadyRecord>}
  339.    * @private
  340.    */
  341.   static parseMsPro_(data) {
  342.     let byteOffset = 0;
  343.     const view = shaka.util.BufferUtils.toDataView(data);
  345.     // First 4 bytes is the PRO length (DWORD)
  346.     const byteLength = view.getUint32(byteOffset, /* littleEndian= */ true);
  347.     byteOffset += 4;
  349.     if (byteLength != data.byteLength) {
  350.       // Malformed PRO
  351.       shaka.log.warning('PlayReady Object with invalid length encountered.');
  352.       return [];
  353.     }
  355.     // Skip PRO Record count (WORD)
  356.     byteOffset += 2;
  358.     // Rest of the data contains the PRO Records
  359.     const ContentProtection = shaka.dash.ContentProtection;
  360.     return ContentProtection.parseMsProRecords_(view, byteOffset);
  361.   }
  363.   /**
  364.    * PlayReady Header format: https://goo.gl/dBzxNA
  365.    *
  366.    * @param {!shaka.extern.xml.Node} xml
  367.    * @return {string}
  368.    * @private
  369.    */
  370.   static getLaurl_(xml) {
  371.     const TXml = shaka.util.TXml;
  372.     // LA_URL element is optional and no more than one is
  373.     // allowed inside the DATA element. Only absolute URLs are allowed.
  374.     // If the LA_URL element exists, it must not be empty.
  375.     for (const elem of TXml.getElementsByTagName(xml, 'DATA')) {
  376.       if (elem.children) {
  377.         for (const child of elem.children) {
  378.           if (child.tagName == 'LA_URL') {
  379.             return /** @type{string} */(shaka.util.TXml.getTextContents(child));
  380.           }
  381.         }
  382.       }
  383.     }
  385.     // Not found
  386.     return '';
  387.   }
  389.   /**
  390.    * Gets a PlayReady license URL from a content protection element
  391.    * containing a PlayReady Header Object
  392.    *
  393.    * @param {shaka.dash.ContentProtection.Element} element
  394.    * @return {string}
  395.    */
  396.   static getPlayReadyLicenseUrl(element) {
  397.     const dashIfLaurlNode = shaka.util.TXml.findChildNS(
  398.         element.node, shaka.dash.ContentProtection.DashIfNamespaceUri_,
  399.         'Laurl',
  400.     );
  401.     if (dashIfLaurlNode) {
  402.       const textContents = shaka.util.TXml.getTextContents(dashIfLaurlNode);
  403.       if (textContents) {
  404.         return textContents;
  405.       }
  406.     }
  408.     const proNode = shaka.util.TXml.findChildNS(
  409.         element.node, 'urn:microsoft:playready', 'pro');
  411.     if (!proNode || !shaka.util.TXml.getTextContents(proNode)) {
  412.       return '';
  413.     }
  415.     const ContentProtection = shaka.dash.ContentProtection;
  416.     const PLAYREADY_RECORD_TYPES = ContentProtection.PLAYREADY_RECORD_TYPES;
  418.     const textContent =
  419.     /** @type {string} */ (shaka.util.TXml.getTextContents(proNode));
  420.     const bytes = shaka.util.Uint8ArrayUtils.fromBase64(textContent);
  421.     const records = ContentProtection.parseMsPro_(bytes);
  422.     const record = records.filter((record) => {
  423.       return record.type === PLAYREADY_RECORD_TYPES.RIGHTS_MANAGEMENT;
  424.     })[0];
  426.     if (!record) {
  427.       return '';
  428.     }
  430.     const xml = shaka.util.StringUtils.fromUTF16(record.value, true);
  431.     const rootElement = shaka.util.TXml.parseXmlString(xml, 'WRMHEADER');
  432.     if (!rootElement) {
  433.       return '';
  434.     }
  436.     return ContentProtection.getLaurl_(rootElement);
  437.   }
  439.   /**
  440.    * Gets a PlayReady initData from a content protection element
  441.    * containing a PlayReady Pro Object
  442.    *
  443.    * @param {shaka.dash.ContentProtection.Element} element
  444.    * @return {?Array.<shaka.extern.InitDataOverride>}
  445.    * @private
  446.    */
  447.   static getInitDataFromPro_(element) {
  448.     const proNode = shaka.util.TXml.findChildNS(
  449.         element.node, 'urn:microsoft:playready', 'pro');
  450.     if (!proNode || !shaka.util.TXml.getTextContents(proNode)) {
  451.       return null;
  452.     }
  454.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  455.     const textContent =
  456.     /** @type{string} */ (shaka.util.TXml.getTextContents(proNode));
  457.     const data = Uint8ArrayUtils.fromBase64(textContent);
  458.     const systemId = new Uint8Array([
  459.       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  460.       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  461.     ]);
  462.     const keyIds = new Set();
  463.     const psshVersion = 0;
  464.     const pssh =
  465.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  466.     return [
  467.       {
  468.         initData: pssh,
  469.         initDataType: 'cenc',
  470.         keyId: element.keyId,
  471.       },
  472.     ];
  473.   }
  475.   /**
  476.    * Creates ClearKey initData from Default_KID value retrieved from previously
  477.    * parsed ContentProtection tag.
  478.    * @param {shaka.dash.ContentProtection.Element} element
  479.    * @param {!Set.<string>} keyIds
  480.    * @return {?Array.<shaka.extern.InitDataOverride>}
  481.    * @private
  482.    */
  483.   static getInitDataClearKey_(element, keyIds) {
  484.     if (keyIds.size == 0) {
  485.       return null;
  486.     }
  488.     const systemId = new Uint8Array([
  489.       0x10, 0x77, 0xef, 0xec, 0xc0, 0xb2, 0x4d, 0x02,
  490.       0xac, 0xe3, 0x3c, 0x1e, 0x52, 0xe2, 0xfb, 0x4b,
  491.     ]);
  492.     const data = new Uint8Array([]);
  493.     const psshVersion = 1;
  494.     const pssh =
  495.          shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  497.     return [
  498.       {
  499.         initData: pssh,
  500.         initDataType: 'cenc',
  501.         keyId: element.keyId,
  502.       },
  503.     ];
  504.   }
  506.   /**
  507.    * Creates DrmInfo objects from the given element.
  508.    *
  509.    * @param {Array.<shaka.extern.InitDataOverride>} defaultInit
  510.    * @param {string} encryptionScheme
  511.    * @param {!Array.<shaka.dash.ContentProtection.Element>} elements
  512.    * @param {!Object.<string, string>} keySystemsByURI
  513.    * @param {!Set.<string>} keyIds
  514.    * @return {!Array.<shaka.extern.DrmInfo>}
  515.    * @private
  516.    */
  517.   static convertElements_(defaultInit, encryptionScheme, elements,
  518.       keySystemsByURI, keyIds) {
  519.     const ContentProtection = shaka.dash.ContentProtection;
  520.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  521.     const licenseUrlParsers = ContentProtection.licenseUrlParsers_;
  523.     /** @type {!Array.<shaka.extern.DrmInfo>} */
  524.     const out = [];
  526.     for (const element of elements) {
  527.       const keySystem = keySystemsByURI[element.schemeUri];
  528.       if (keySystem) {
  529.         goog.asserts.assert(
  530.             !element.init || element.init.length,
  531.             'Init data must be null or non-empty.');
  533.         const proInitData = ContentProtection.getInitDataFromPro_(element);
  534.         let clearKeyInitData = null;
  535.         if (element.schemeUri ===
  536.               shaka.dash.ContentProtection.ClearKeySchemeUri_) {
  537.           clearKeyInitData =
  538.             ContentProtection.getInitDataClearKey_(element, keyIds);
  539.         }
  540.         const initData = element.init || defaultInit || proInitData ||
  541.           clearKeyInitData;
  542.         const info = ManifestParserUtils.createDrmInfo(
  543.             keySystem, encryptionScheme, initData);
  544.         const licenseParser = licenseUrlParsers.get(keySystem);
  545.         if (licenseParser) {
  546.           info.licenseServerUri = licenseParser(element);
  547.         }
  549.         out.push(info);
  550.       }
  551.     }
  553.     return out;
  554.   }
  556.   /**
  557.    * Parses the given ContentProtection elements.  If there is an error, it
  558.    * removes those elements.
  559.    *
  560.    * @param {!Array.<!shaka.extern.xml.Node>} elems
  561.    * @return {!Array.<shaka.dash.ContentProtection.Element>}
  562.    * @private
  563.    */
  564.   static parseElements_(elems) {
  565.     /** @type {!Array.<shaka.dash.ContentProtection.Element>} */
  566.     const out = [];
  568.     for (const elem of elems) {
  569.       const parsed = shaka.dash.ContentProtection.parseElement_(elem);
  570.       if (parsed) {
  571.         out.push(parsed);
  572.       }
  573.     }
  575.     return out;
  576.   }
  578.   /**
  579.    * Parses the given ContentProtection element.
  580.    *
  581.    * @param {!shaka.extern.xml.Node} elem
  582.    * @return {?shaka.dash.ContentProtection.Element}
  583.    * @private
  584.    */
  585.   static parseElement_(elem) {
  586.     const NS = shaka.dash.ContentProtection.CencNamespaceUri_;
  587.     const TXml = shaka.util.TXml;
  589.     /** @type {?string} */
  590.     let schemeUri = elem.attributes['schemeIdUri'];
  591.     /** @type {?string} */
  592.     let keyId = TXml.getAttributeNS(elem, NS, 'default_KID');
  593.     /** @type {!Array.<string>} */
  594.     const psshs = TXml.findChildrenNS(elem, NS, 'pssh')
  595.         .map(TXml.getContents);
  597.     const encryptionScheme = elem.attributes['value'];
  599.     if (!schemeUri) {
  600.       shaka.log.error('Missing required schemeIdUri attribute on',
  601.           'ContentProtection element', elem);
  602.       return null;
  603.     }
  605.     schemeUri = schemeUri.toLowerCase();
  606.     if (keyId) {
  607.       keyId = keyId.replace(/-/g, '').toLowerCase();
  608.       if (keyId.includes(' ')) {
  609.         throw new shaka.util.Error(
  610.             shaka.util.Error.Severity.CRITICAL,
  611.             shaka.util.Error.Category.MANIFEST,
  612.             shaka.util.Error.Code.DASH_MULTIPLE_KEY_IDS_NOT_SUPPORTED);
  613.       }
  614.     }
  616.     /** @type {!Array.<shaka.extern.InitDataOverride>} */
  617.     let init = [];
  618.     try {
  619.       // Try parsing PSSH data.
  620.       init = psshs.map((pssh) => {
  621.         return {
  622.           initDataType: 'cenc',
  623.           initData: shaka.util.Uint8ArrayUtils.fromBase64(pssh),
  624.           keyId: null,
  625.         };
  626.       });
  627.     } catch (e) {
  628.       throw new shaka.util.Error(
  629.           shaka.util.Error.Severity.CRITICAL,
  630.           shaka.util.Error.Category.MANIFEST,
  631.           shaka.util.Error.Code.DASH_PSSH_BAD_ENCODING);
  632.     }
  634.     return {
  635.       node: elem,
  636.       schemeUri,
  637.       keyId,
  638.       init: (init.length > 0 ? init : null),
  639.       encryptionScheme,
  640.     };
  641.   }
  643.   /**
  644.    * Parses the given AES-128 ContentProtection element.
  645.    *
  646.    * @param {shaka.dash.ContentProtection.Element} element
  647.    * @return {?shaka.dash.ContentProtection.Aes128Info}
  648.    * @private
  649.    */
  650.   static parseAes128_(element) {
  651.     // Check if the Web Crypto API is available.
  652.     if (!window.crypto || !window.crypto.subtle) {
  653.       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
  654.           'AES-128. (Web Crypto only exists in secure origins like https)');
  655.       throw new shaka.util.Error(
  656.           shaka.util.Error.Severity.CRITICAL,
  657.           shaka.util.Error.Category.MANIFEST,
  658.           shaka.util.Error.Code.NO_WEB_CRYPTO_API);
  659.     }
  661.     const namespace = 'urn:mpeg:dash:schema:sea:2012';
  662.     const segmentEncryption = shaka.util.TXml.findChildNS(
  663.         element.node, namespace, 'SegmentEncryption');
  665.     if (!segmentEncryption) {
  666.       throw new shaka.util.Error(
  667.           shaka.util.Error.Severity.CRITICAL,
  668.           shaka.util.Error.Category.MANIFEST,
  669.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  670.     }
  672.     const aesSchemeIdUri = 'urn:mpeg:dash:sea:aes128-cbc:2013';
  673.     const segmentEncryptionSchemeIdUri =
  674.         segmentEncryption.attributes['schemeIdUri'];
  675.     if (segmentEncryptionSchemeIdUri != aesSchemeIdUri) {
  676.       throw new shaka.util.Error(
  677.           shaka.util.Error.Severity.CRITICAL,
  678.           shaka.util.Error.Category.MANIFEST,
  679.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  680.     }
  682.     const cryptoPeriod = shaka.util.TXml.findChildNS(
  683.         element.node, namespace, 'CryptoPeriod');
  685.     if (!cryptoPeriod) {
  686.       throw new shaka.util.Error(
  687.           shaka.util.Error.Severity.CRITICAL,
  688.           shaka.util.Error.Category.MANIFEST,
  689.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  690.     }
  692.     const ivHex = cryptoPeriod.attributes['IV'];
  693.     const keyUri = shaka.util.StringUtils.htmlUnescape(
  694.         cryptoPeriod.attributes['keyUriTemplate']);
  695.     if (!ivHex || !keyUri) {
  696.       throw new shaka.util.Error(
  697.           shaka.util.Error.Severity.CRITICAL,
  698.           shaka.util.Error.Category.MANIFEST,
  699.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  700.     }
  702.     // Exclude 0x at the start of string.
  703.     const iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
  704.     if (iv.byteLength != 16) {
  705.       throw new shaka.util.Error(
  706.           shaka.util.Error.Severity.CRITICAL,
  707.           shaka.util.Error.Category.MANIFEST,
  708.           shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
  709.     }
  711.     return {
  712.       keyUri,
  713.       iv,
  714.     };
  715.   }
  716. };
  718. /**
  719.  * @typedef {{
  720.  *   type: number,
  721.  *   value: !Uint8Array
  722.  * }}
  723.  *
  724.  * @description
  725.  * The parsed result of a PlayReady object record.
  726.  *
  727.  * @property {number} type
  728.  *   Type of data stored in the record.
  729.  * @property {!Uint8Array} value
  730.  *   Record content.
  731.  */
  732. shaka.dash.ContentProtection.PlayReadyRecord;
  734. /**
  735.  * Enum for PlayReady record types.
  736.  * @enum {number}
  737.  */
  738. shaka.dash.ContentProtection.PLAYREADY_RECORD_TYPES = {
  739.   RIGHTS_MANAGEMENT: 0x001,
  740.   RESERVED: 0x002,
  741.   EMBEDDED_LICENSE: 0x003,
  742. };
  744. /**
  745.  * @typedef {{
  746.  *   defaultKeyId: ?string,
  747.  *   defaultInit: Array.<shaka.extern.InitDataOverride>,
  748.  *   drmInfos: !Array.<shaka.extern.DrmInfo>,
  749.  *   aes128Info: ?shaka.dash.ContentProtection.Aes128Info,
  750.  *   firstRepresentation: boolean
  751.  * }}
  752.  *
  753.  * @description
  754.  * Contains information about the ContentProtection elements found at the
  755.  * AdaptationSet level.
  756.  *
  757.  * @property {?string} defaultKeyId
  758.  *   The default key ID to use.  This is used by parseKeyIds as a default.  This
  759.  *   can be null to indicate that there is no default.
  760.  * @property {Array.<shaka.extern.InitDataOverride>} defaultInit
  761.  *   The default init data override.  This can be null to indicate that there
  762.  *   is no default.
  763.  * @property {!Array.<shaka.extern.DrmInfo>} drmInfos
  764.  *   The DrmInfo objects.
  765.  * @property {?shaka.dash.ContentProtection.Aes128Info} aes128Info
  766.  *   The AES-128 key info.
  767.  * @property {boolean} firstRepresentation
  768.  *   True when first parsed; changed to false after the first call to
  769.  *   parseKeyIds.  This is used to determine if a dummy key-system should be
  770.  *   overwritten; namely that the first representation can replace the dummy
  771.  *   from the AdaptationSet.
  772.  */
  773. shaka.dash.ContentProtection.Context;
  775. /**
  776.  * @typedef {{
  777.  *   keyUri: string,
  778.  *   iv: !Uint8Array
  779.  * }}
  780.  *
  781.  * @description
  782.  * Contains information about the AES-128 keyUri and IV found at the
  783.  * AdaptationSet level.
  784.  *
  785.  * @property {string} method
  786.  *   The keyUri in the manifest.
  787.  * @property {!Uint8Array} iv
  788.  *   The IV in the manifest.
  789.  */
  790. shaka.dash.ContentProtection.Aes128Info;
  792. /**
  793.  * @typedef {{
  794.  *   node: !shaka.extern.xml.Node,
  795.  *   schemeUri: string,
  796.  *   keyId: ?string,
  797.  *   init: Array.<shaka.extern.InitDataOverride>,
  798.  *   encryptionScheme: ?string
  799.  * }}
  800.  *
  801.  * @description
  802.  * The parsed result of a single ContentProtection element.
  803.  *
  804.  * @property {!shaka.extern.xml.Node} node
  805.  *   The ContentProtection XML element.
  806.  * @property {string} schemeUri
  807.  *   The scheme URI.
  808.  * @property {?string} keyId
  809.  *   The default key ID, if present.
  810.  * @property {Array.<shaka.extern.InitDataOverride>} init
  811.  *   The init data, if present.  If there is no init data, it will be null.  If
  812.  *   this is non-null, there is at least one element.
  813.  * @property {?string} encryptionScheme
  814.  *   The encryption scheme, if present.
  815.  */
  816. shaka.dash.ContentProtection.Element;
  818. /**
  819.  * A map of key system name to license server url parser.
  820.  *
  821.  * @const {!Map.<string, function(shaka.dash.ContentProtection.Element)>}
  822.  * @private
  823.  */
  824. shaka.dash.ContentProtection.licenseUrlParsers_ = new Map()
  825.     .set('com.apple.fps',
  826.         shaka.dash.ContentProtection.getFairPlayLicenseUrl)
  827.     .set('com.widevine.alpha',
  828.         shaka.dash.ContentProtection.getWidevineLicenseUrl)
  829.     .set('com.microsoft.playready',
  830.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  831.     .set('com.microsoft.playready.recommendation',
  832.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  833.     .set('com.microsoft.playready.software',
  834.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  835.     .set('com.microsoft.playready.hardware',
  836.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  837.     .set('org.w3.clearkey',
  838.         shaka.dash.ContentProtection.getClearKeyLicenseUrl);
  840. /**
  841.  * @const {string}
  842.  * @private
  843.  */
  844. shaka.dash.ContentProtection.MP4Protection_ =
  845.     'urn:mpeg:dash:mp4protection:2011';
  847. /**
  848.  * @const {string}
  849.  * @private
  850.  */
  851. shaka.dash.ContentProtection.Aes128Protection_ =
  852.     'urn:mpeg:dash:sea:2012';
  855. /**
  856.  * @const {string}
  857.  * @private
  858.  */
  859. shaka.dash.ContentProtection.CencNamespaceUri_ = 'urn:mpeg:cenc:2013';
  861. /**
  862.  * @const {string}
  863.  * @private
  864.  */
  865. shaka.dash.ContentProtection.ClearKeyNamespaceUri_ =
  866.   'http://dashif.org/guidelines/clearKey';
  869. /**
  870.  * @const {string}
  871.  * @private
  872.  */
  873. shaka.dash.ContentProtection.ClearKeySchemeUri_ =
  874.     'urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e';
  877. /**
  878.  * @const {string}
  879.  * @private
  880.  */
  881. shaka.dash.ContentProtection.DashIfNamespaceUri_ =
  882.   'https://dashif.org/CPS';