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