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.drm.DrmUtils');
  12. goog.require('shaka.drm.PlayReady');
  13. goog.require('shaka.util.Error');
  14. goog.require('shaka.util.ManifestParserUtils');
  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>} elements
  30.    * @param {boolean} ignoreDrmInfo
  31.    * @param {!Object<string, string>} keySystemsByURI
  32.    * @return {shaka.dash.ContentProtection.Context}
  33.    */
  34.   static parseFromAdaptationSet(elements, ignoreDrmInfo, keySystemsByURI) {
  35.     const ContentProtection = shaka.dash.ContentProtection;
  36.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  37.     const parsed = ContentProtection.parseElements_(elements);
  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>} elements
  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.       elements, context, ignoreDrmInfo, keySystemsByURI) {
  160.     const ContentProtection = shaka.dash.ContentProtection;
  161.     const repContext = ContentProtection.parseFromAdaptationSet(
  162.         elements, 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.drm.DrmUtils.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.    * Gets a PlayReady license URL from a content protection element
  290.    * containing a PlayReady Header Object
  291.    *
  292.    * @param {shaka.dash.ContentProtection.Element} element
  293.    * @return {string}
  294.    */
  295.   static getPlayReadyLicenseUrl(element) {
  296.     const TXml = shaka.util.TXml;
  297.     const dashIfLaurlNode = TXml.findChildNS(
  298.         element.node, shaka.dash.ContentProtection.DashIfNamespaceUri_,
  299.         'Laurl',
  300.     );
  301.     if (dashIfLaurlNode) {
  302.       const textContents = TXml.getTextContents(dashIfLaurlNode);
  303.       if (textContents) {
  304.         return textContents;
  305.       }
  306.     }
  308.     const proNode = TXml.findChildNS(
  309.         element.node, 'urn:microsoft:playready', 'pro');
  310.     if (proNode) {
  311.       const textContents = TXml.getTextContents(proNode);
  312.       if (textContents) {
  313.         return shaka.drm.PlayReady.getLicenseUrl(proNode);
  314.       }
  315.     }
  317.     const psshNode = TXml.findChildNS(
  318.         element.node, shaka.dash.ContentProtection.CencNamespaceUri_, 'pssh');
  319.     if (psshNode) {
  320.       const textContents = TXml.getTextContents(psshNode);
  321.       if (textContents) {
  322.         const proData = shaka.util.Pssh.getPsshData(
  323.             shaka.util.Uint8ArrayUtils.fromBase64(textContents));
  324.         const proString = shaka.util.Uint8ArrayUtils.toStandardBase64(proData);
  325.         const reBuildProNode =
  326.             TXml.parseXmlString('<pro>' + proString + '</pro>');
  327.         goog.asserts.assert(reBuildProNode, 'Must have pro node');
  328.         return shaka.drm.PlayReady.getLicenseUrl(reBuildProNode);
  329.       }
  330.     }
  332.     return '';
  333.   }
  335.   /**
  336.    * Gets a PlayReady initData from a content protection element
  337.    * containing a PlayReady Pro Object
  338.    *
  339.    * @param {shaka.dash.ContentProtection.Element} element
  340.    * @return {?Array<shaka.extern.InitDataOverride>}
  341.    * @private
  342.    */
  343.   static getInitDataFromPro_(element) {
  344.     const proNode = shaka.util.TXml.findChildNS(
  345.         element.node, 'urn:microsoft:playready', 'pro');
  346.     if (!proNode || !shaka.util.TXml.getTextContents(proNode)) {
  347.       return null;
  348.     }
  350.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  351.     const textContent =
  352.     /** @type {string} */ (shaka.util.TXml.getTextContents(proNode));
  353.     const data = Uint8ArrayUtils.fromBase64(textContent);
  354.     const systemId = new Uint8Array([
  355.       0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  356.       0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  357.     ]);
  358.     const keyIds = new Set();
  359.     const psshVersion = 0;
  360.     const pssh =
  361.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  362.     return [
  363.       {
  364.         initData: pssh,
  365.         initDataType: 'cenc',
  366.         keyId: element.keyId,
  367.       },
  368.     ];
  369.   }
  371.   /**
  372.    * Creates ClearKey initData from Default_KID value retrieved from previously
  373.    * parsed ContentProtection tag.
  374.    * @param {shaka.dash.ContentProtection.Element} element
  375.    * @param {!Set<string>} keyIds
  376.    * @return {?Array<shaka.extern.InitDataOverride>}
  377.    * @private
  378.    */
  379.   static getInitDataClearKey_(element, keyIds) {
  380.     if (keyIds.size == 0) {
  381.       return null;
  382.     }
  384.     const systemId = new Uint8Array([
  385.       0x10, 0x77, 0xef, 0xec, 0xc0, 0xb2, 0x4d, 0x02,
  386.       0xac, 0xe3, 0x3c, 0x1e, 0x52, 0xe2, 0xfb, 0x4b,
  387.     ]);
  388.     const data = new Uint8Array([]);
  389.     const psshVersion = 1;
  390.     const pssh =
  391.          shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  393.     return [
  394.       {
  395.         initData: pssh,
  396.         initDataType: 'cenc',
  397.         keyId: element.keyId,
  398.       },
  399.     ];
  400.   }
  402.   /**
  403.    * Creates DrmInfo objects from the given element.
  404.    *
  405.    * @param {Array<shaka.extern.InitDataOverride>} defaultInit
  406.    * @param {string} encryptionScheme
  407.    * @param {!Array<shaka.dash.ContentProtection.Element>} elements
  408.    * @param {!Object<string, string>} keySystemsByURI
  409.    * @param {!Set<string>} keyIds
  410.    * @return {!Array<shaka.extern.DrmInfo>}
  411.    * @private
  412.    */
  413.   static convertElements_(defaultInit, encryptionScheme, elements,
  414.       keySystemsByURI, keyIds) {
  415.     const ContentProtection = shaka.dash.ContentProtection;
  416.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  417.     const licenseUrlParsers = ContentProtection.licenseUrlParsers_;
  419.     /** @type {!Array<shaka.extern.DrmInfo>} */
  420.     const out = [];
  422.     for (const element of elements) {
  423.       const keySystem = keySystemsByURI[element.schemeUri];
  424.       if (keySystem) {
  425.         goog.asserts.assert(
  426.             !element.init || element.init.length,
  427.             'Init data must be null or non-empty.');
  429.         const proInitData = ContentProtection.getInitDataFromPro_(element);
  430.         let clearKeyInitData = null;
  431.         if (element.schemeUri ===
  432.               shaka.dash.ContentProtection.ClearKeySchemeUri_) {
  433.           clearKeyInitData =
  434.             ContentProtection.getInitDataClearKey_(element, keyIds);
  435.         }
  436.         const initData = element.init || defaultInit || proInitData ||
  437.           clearKeyInitData;
  438.         const info = ManifestParserUtils.createDrmInfo(
  439.             keySystem, encryptionScheme, initData);
  440.         const licenseParser = licenseUrlParsers.get(keySystem);
  441.         if (licenseParser) {
  442.           info.licenseServerUri = licenseParser(element);
  443.         }
  445.         out.push(info);
  446.       }
  447.     }
  449.     return out;
  450.   }
  452.   /**
  453.    * Parses the given ContentProtection elements.  If there is an error, it
  454.    * removes those elements.
  455.    *
  456.    * @param {!Array<!shaka.extern.xml.Node>} elements
  457.    * @return {!Array<shaka.dash.ContentProtection.Element>}
  458.    * @private
  459.    */
  460.   static parseElements_(elements) {
  461.     /** @type {!Array<shaka.dash.ContentProtection.Element>} */
  462.     const out = [];
  464.     for (const element of elements) {
  465.       const parsed = shaka.dash.ContentProtection.parseElement_(element);
  466.       if (parsed) {
  467.         out.push(parsed);
  468.       }
  469.     }
  471.     return out;
  472.   }
  474.   /**
  475.    * Parses the given ContentProtection element.
  476.    *
  477.    * @param {!shaka.extern.xml.Node} elem
  478.    * @return {?shaka.dash.ContentProtection.Element}
  479.    * @private
  480.    */
  481.   static parseElement_(elem) {
  482.     const NS = shaka.dash.ContentProtection.CencNamespaceUri_;
  483.     const TXml = shaka.util.TXml;
  485.     /** @type {?string} */
  486.     let schemeUri = elem.attributes['schemeIdUri'];
  487.     /** @type {?string} */
  488.     let keyId = TXml.getAttributeNS(elem, NS, 'default_KID');
  489.     /** @type {!Array<string>} */
  490.     const psshs = TXml.findChildrenNS(elem, NS, 'pssh')
  491.         .map(TXml.getContents);
  493.     const encryptionScheme = elem.attributes['value'];
  495.     if (!schemeUri) {
  496.       shaka.log.error('Missing required schemeIdUri attribute on',
  497.           'ContentProtection element', elem);
  498.       return null;
  499.     }
  501.     schemeUri = schemeUri.toLowerCase();
  502.     if (keyId) {
  503.       keyId = keyId.replace(/-/g, '').toLowerCase();
  504.       if (keyId.includes(' ')) {
  505.         throw new shaka.util.Error(
  506.             shaka.util.Error.Severity.CRITICAL,
  507.             shaka.util.Error.Category.MANIFEST,
  508.             shaka.util.Error.Code.DASH_MULTIPLE_KEY_IDS_NOT_SUPPORTED);
  509.       }
  510.     }
  512.     /** @type {!Array<shaka.extern.InitDataOverride>} */
  513.     let init = [];
  514.     try {
  515.       // Try parsing PSSH data.
  516.       init = psshs.map((pssh) => {
  517.         return {
  518.           initDataType: 'cenc',
  519.           initData: shaka.util.Uint8ArrayUtils.fromBase64(pssh),
  520.           keyId: null,
  521.         };
  522.       });
  523.     } catch (e) {
  524.       throw new shaka.util.Error(
  525.           shaka.util.Error.Severity.CRITICAL,
  526.           shaka.util.Error.Category.MANIFEST,
  527.           shaka.util.Error.Code.DASH_PSSH_BAD_ENCODING);
  528.     }
  530.     return {
  531.       node: elem,
  532.       schemeUri,
  533.       keyId,
  534.       init: (init.length > 0 ? init : null),
  535.       encryptionScheme,
  536.     };
  537.   }
  539.   /**
  540.    * Parses the given AES-128 ContentProtection element.
  541.    *
  542.    * @param {shaka.dash.ContentProtection.Element} element
  543.    * @return {?shaka.dash.ContentProtection.Aes128Info}
  544.    * @private
  545.    */
  546.   static parseAes128_(element) {
  547.     // Check if the Web Crypto API is available.
  548.     if (!window.crypto || !window.crypto.subtle) {
  549.       shaka.log.alwaysWarn('Web Crypto API is not available to decrypt ' +
  550.           'AES-128. (Web Crypto only exists in secure origins like https)');
  551.       throw new shaka.util.Error(
  552.           shaka.util.Error.Severity.CRITICAL,
  553.           shaka.util.Error.Category.MANIFEST,
  554.           shaka.util.Error.Code.NO_WEB_CRYPTO_API);
  555.     }
  557.     const namespace = 'urn:mpeg:dash:schema:sea:2012';
  558.     const segmentEncryption = shaka.util.TXml.findChildNS(
  559.         element.node, namespace, 'SegmentEncryption');
  561.     if (!segmentEncryption) {
  562.       throw new shaka.util.Error(
  563.           shaka.util.Error.Severity.CRITICAL,
  564.           shaka.util.Error.Category.MANIFEST,
  565.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  566.     }
  568.     const aesSchemeIdUri = 'urn:mpeg:dash:sea:aes128-cbc:2013';
  569.     const segmentEncryptionSchemeIdUri =
  570.         segmentEncryption.attributes['schemeIdUri'];
  571.     if (segmentEncryptionSchemeIdUri != aesSchemeIdUri) {
  572.       throw new shaka.util.Error(
  573.           shaka.util.Error.Severity.CRITICAL,
  574.           shaka.util.Error.Category.MANIFEST,
  575.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  576.     }
  578.     const cryptoPeriod = shaka.util.TXml.findChildNS(
  579.         element.node, namespace, 'CryptoPeriod');
  581.     if (!cryptoPeriod) {
  582.       throw new shaka.util.Error(
  583.           shaka.util.Error.Severity.CRITICAL,
  584.           shaka.util.Error.Category.MANIFEST,
  585.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  586.     }
  588.     const ivHex = cryptoPeriod.attributes['IV'];
  589.     const keyUri = shaka.util.StringUtils.htmlUnescape(
  590.         cryptoPeriod.attributes['keyUriTemplate']);
  591.     if (!ivHex || !keyUri) {
  592.       throw new shaka.util.Error(
  593.           shaka.util.Error.Severity.CRITICAL,
  594.           shaka.util.Error.Category.MANIFEST,
  595.           shaka.util.Error.Code.DASH_UNSUPPORTED_AES_128);
  596.     }
  598.     // Exclude 0x at the start of string.
  599.     const iv = shaka.util.Uint8ArrayUtils.fromHex(ivHex.substr(2));
  600.     if (iv.byteLength != 16) {
  601.       throw new shaka.util.Error(
  602.           shaka.util.Error.Severity.CRITICAL,
  603.           shaka.util.Error.Category.MANIFEST,
  604.           shaka.util.Error.Code.AES_128_INVALID_IV_LENGTH);
  605.     }
  607.     return {
  608.       keyUri,
  609.       iv,
  610.     };
  611.   }
  612. };
  614. /**
  615.  * @typedef {{
  616.  *   defaultKeyId: ?string,
  617.  *   defaultInit: Array<shaka.extern.InitDataOverride>,
  618.  *   drmInfos: !Array<shaka.extern.DrmInfo>,
  619.  *   aes128Info: ?shaka.dash.ContentProtection.Aes128Info,
  620.  *   firstRepresentation: boolean
  621.  * }}
  622.  *
  623.  * @description
  624.  * Contains information about the ContentProtection elements found at the
  625.  * AdaptationSet level.
  626.  *
  627.  * @property {?string} defaultKeyId
  628.  *   The default key ID to use.  This is used by parseKeyIds as a default.  This
  629.  *   can be null to indicate that there is no default.
  630.  * @property {Array<shaka.extern.InitDataOverride>} defaultInit
  631.  *   The default init data override.  This can be null to indicate that there
  632.  *   is no default.
  633.  * @property {!Array<shaka.extern.DrmInfo>} drmInfos
  634.  *   The DrmInfo objects.
  635.  * @property {?shaka.dash.ContentProtection.Aes128Info} aes128Info
  636.  *   The AES-128 key info.
  637.  * @property {boolean} firstRepresentation
  638.  *   True when first parsed; changed to false after the first call to
  639.  *   parseKeyIds.  This is used to determine if a dummy key-system should be
  640.  *   overwritten; namely that the first representation can replace the dummy
  641.  *   from the AdaptationSet.
  642.  */
  643. shaka.dash.ContentProtection.Context;
  645. /**
  646.  * @typedef {{
  647.  *   keyUri: string,
  648.  *   iv: !Uint8Array
  649.  * }}
  650.  *
  651.  * @description
  652.  * Contains information about the AES-128 keyUri and IV found at the
  653.  * AdaptationSet level.
  654.  *
  655.  * @property {string} method
  656.  *   The keyUri in the manifest.
  657.  * @property {!Uint8Array} iv
  658.  *   The IV in the manifest.
  659.  */
  660. shaka.dash.ContentProtection.Aes128Info;
  662. /**
  663.  * @typedef {{
  664.  *   node: !shaka.extern.xml.Node,
  665.  *   schemeUri: string,
  666.  *   keyId: ?string,
  667.  *   init: Array<shaka.extern.InitDataOverride>,
  668.  *   encryptionScheme: ?string
  669.  * }}
  670.  *
  671.  * @description
  672.  * The parsed result of a single ContentProtection element.
  673.  *
  674.  * @property {!shaka.extern.xml.Node} node
  675.  *   The ContentProtection XML element.
  676.  * @property {string} schemeUri
  677.  *   The scheme URI.
  678.  * @property {?string} keyId
  679.  *   The default key ID, if present.
  680.  * @property {Array<shaka.extern.InitDataOverride>} init
  681.  *   The init data, if present.  If there is no init data, it will be null.  If
  682.  *   this is non-null, there is at least one element.
  683.  * @property {?string} encryptionScheme
  684.  *   The encryption scheme, if present.
  685.  */
  686. shaka.dash.ContentProtection.Element;
  688. /**
  689.  * A map of key system name to license server url parser.
  690.  *
  691.  * @const {!Map<string, function(shaka.dash.ContentProtection.Element)>}
  692.  * @private
  693.  */
  694. shaka.dash.ContentProtection.licenseUrlParsers_ = new Map()
  695.     .set('com.apple.fps',
  696.         shaka.dash.ContentProtection.getFairPlayLicenseUrl)
  697.     .set('com.widevine.alpha',
  698.         shaka.dash.ContentProtection.getWidevineLicenseUrl)
  699.     .set('com.microsoft.playready',
  700.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  701.     .set('com.microsoft.playready.recommendation',
  702.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  703.     .set('com.microsoft.playready.software',
  704.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  705.     .set('com.microsoft.playready.hardware',
  706.         shaka.dash.ContentProtection.getPlayReadyLicenseUrl)
  707.     .set('org.w3.clearkey',
  708.         shaka.dash.ContentProtection.getClearKeyLicenseUrl);
  710. /**
  711.  * @const {string}
  712.  * @private
  713.  */
  714. shaka.dash.ContentProtection.MP4Protection_ =
  715.     'urn:mpeg:dash:mp4protection:2011';
  717. /**
  718.  * @const {string}
  719.  * @private
  720.  */
  721. shaka.dash.ContentProtection.Aes128Protection_ =
  722.     'urn:mpeg:dash:sea:2012';
  725. /**
  726.  * @const {string}
  727.  * @private
  728.  */
  729. shaka.dash.ContentProtection.CencNamespaceUri_ = 'urn:mpeg:cenc:2013';
  731. /**
  732.  * @const {string}
  733.  * @private
  734.  */
  735. shaka.dash.ContentProtection.ClearKeyNamespaceUri_ =
  736.   'http://dashif.org/guidelines/clearKey';
  739. /**
  740.  * @const {string}
  741.  * @private
  742.  */
  743. shaka.dash.ContentProtection.ClearKeySchemeUri_ =
  744.     'urn:uuid:e2719d58-a985-b3c9-781a-b030af78d30e';
  747. /**
  748.  * @const {string}
  749.  * @private
  750.  */
  751. shaka.dash.ContentProtection.DashIfNamespaceUri_ =
  752.   'https://dashif.org/CPS';