Source: lib/dash/content_protection.js

  1. /**
  2.  * @license
  3.  * Copyright 2016 Google Inc.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  18. goog.provide('shaka.dash.ContentProtection');
  20. goog.require('goog.asserts');
  21. goog.require('shaka.log');
  22. goog.require('shaka.util.Error');
  23. goog.require('shaka.util.ManifestParserUtils');
  24. goog.require('shaka.util.Pssh');
  25. goog.require('shaka.util.Uint8ArrayUtils');
  26. goog.require('shaka.util.XmlUtils');
  29. /**
  30.  * @namespace shaka.dash.ContentProtection
  31.  * @summary A set of functions for parsing and interpreting ContentProtection
  32.  *   elements.
  33.  */
  36. /**
  37.  * @typedef {{
  38.  *   defaultKeyId: ?string,
  39.  *   defaultInit: Array.<shaka.extern.InitDataOverride>,
  40.  *   drmInfos: !Array.<shaka.extern.DrmInfo>,
  41.  *   firstRepresentation: boolean
  42.  * }}
  43.  *
  44.  * @description
  45.  * Contains information about the ContentProtection elements found at the
  46.  * AdaptationSet level.
  47.  *
  48.  * @property {?string} defaultKeyId
  49.  *   The default key ID to use.  This is used by parseKeyIds as a default.  This
  50.  *   can be null to indicate that there is no default.
  51.  * @property {Array.<shaka.extern.InitDataOverride>} defaultInit
  52.  *   The default init data override.  This can be null to indicate that there
  53.  *   is no default.
  54.  * @property {!Array.<shaka.extern.DrmInfo>} drmInfos
  55.  *   The DrmInfo objects.
  56.  * @property {boolean} firstRepresentation
  57.  *   True when first parsed; changed to false after the first call to
  58.  *   parseKeyIds.  This is used to determine if a dummy key-system should be
  59.  *   overwritten; namely that the first representation can replace the dummy
  60.  *   from the AdaptationSet.
  61.  */
  62. shaka.dash.ContentProtection.Context;
  65. /**
  66.  * @typedef {{
  67.  *   node: !Element,
  68.  *   schemeUri: string,
  69.  *   keyId: ?string,
  70.  *   init: Array.<shaka.extern.InitDataOverride>
  71.  * }}
  72.  *
  73.  * @description
  74.  * The parsed result of a single ContentProtection element.
  75.  *
  76.  * @property {!Element} node
  77.  *   The ContentProtection XML element.
  78.  * @property {string} schemeUri
  79.  *   The scheme URI.
  80.  * @property {?string} keyId
  81.  *   The default key ID, if present.
  82.  * @property {Array.<shaka.extern.InitDataOverride>} init
  83.  *   The init data, if present.  If there is no init data, it will be null.  If
  84.  *   this is non-null, there is at least one element.
  85.  */
  86. shaka.dash.ContentProtection.Element;
  89. /**
  90.  * A map of scheme URI to key system name.
  91.  *
  92.  * @const {!Map.<string, string>}
  93.  * @private
  94.  */
  95. shaka.dash.ContentProtection.defaultKeySystems_ = new Map()
  96.     .set('urn:uuid:1077efec-c0b2-4d02-ace3-3c1e52e2fb4b',
  97.          'org.w3.clearkey')
  98.     .set('urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
  99.          'com.widevine.alpha')
  100.     .set('urn:uuid:9a04f079-9840-4286-ab92-e65be0885f95',
  101.          'com.microsoft.playready')
  102.     .set('urn:uuid:79f0049a-4098-8642-ab92-e65be0885f95',
  103.         'com.microsoft.playready')
  104.     .set('urn:uuid:f239e769-efa3-4850-9c16-a903c6932efb',
  105.          'com.adobe.primetime');
  108. /**
  109.  * @const {string}
  110.  * @private
  111.  */
  112. shaka.dash.ContentProtection.MP4Protection_ =
  113.     'urn:mpeg:dash:mp4protection:2011';
  116. /**
  117.  * @const {string}
  118.  * @private
  119.  */
  120. shaka.dash.ContentProtection.CencNamespaceUri_ = 'urn:mpeg:cenc:2013';
  123. /**
  124.  * Parses info from the ContentProtection elements at the AdaptationSet level.
  125.  *
  126.  * @param {!Array.<!Element>} elems
  127.  * @param {shaka.extern.DashContentProtectionCallback} callback
  128.  * @param {boolean} ignoreDrmInfo
  129.  * @return {shaka.dash.ContentProtection.Context}
  130.  */
  131. shaka.dash.ContentProtection.parseFromAdaptationSet = function(
  132.     elems, callback, ignoreDrmInfo) {
  133.   const ContentProtection = shaka.dash.ContentProtection;
  134.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  135.   let parsed = ContentProtection.parseElements_(elems);
  136.   /** @type {Array.<shaka.extern.InitDataOverride>} */
  137.   let defaultInit = null;
  138.   /** @type {!Array.<shaka.extern.DrmInfo>} */
  139.   let drmInfos = [];
  140.   let parsedNonCenc = [];
  142.   // Get the default key ID; if there are multiple, they must all match.
  143.   const keyIds = new Set(parsed.map((element) => element.keyId));
  144.   // Remove any possible null value (elements may have no key ids).
  145.   keyIds.delete(null);
  147.   if (keyIds.size > 1) {
  148.     throw new shaka.util.Error(
  149.         shaka.util.Error.Severity.CRITICAL,
  150.         shaka.util.Error.Category.MANIFEST,
  151.         shaka.util.Error.Code.DASH_CONFLICTING_KEY_IDS);
  152.   }
  154.   if (!ignoreDrmInfo) {
  155.     // Find the default key ID and init data.  Create a new array of all the
  156.     // non-CENC elements.
  157.     parsedNonCenc = parsed.filter(function(elem) {
  158.       if (elem.schemeUri == ContentProtection.MP4Protection_) {
  159.         goog.asserts.assert(!elem.init || elem.init.length,
  160.                             'Init data must be null or non-empty.');
  161.         defaultInit = elem.init || defaultInit;
  162.         return false;
  163.       } else {
  164.         return true;
  165.       }
  166.     });
  168.     if (parsedNonCenc.length) {
  169.       drmInfos = ContentProtection.convertElements_(
  170.           defaultInit, callback, parsedNonCenc);
  172.       // If there are no drmInfos after parsing, then add a dummy entry.
  173.       // This may be removed in parseKeyIds.
  174.       if (drmInfos.length == 0) {
  175.         drmInfos = [ManifestParserUtils.createDrmInfo('', defaultInit)];
  176.       }
  177.     }
  178.   }
  180.   // If there are only CENC element(s) or ignoreDrmInfo flag is set, assume all
  181.   // key-systems are supported.
  182.   if (parsed.length && (ignoreDrmInfo || !parsedNonCenc.length)) {
  183.     drmInfos = [];
  185.     const keySystems = ContentProtection.defaultKeySystems_;
  186.     for (const keySystem of keySystems.values()) {
  187.       // If the manifest doesn't specify any key systems, we shouldn't
  188.       // put clearkey in this list.  Otherwise, it may be triggered when
  189.       // a real key system should be used instead.
  190.       if (keySystem != 'org.w3.clearkey') {
  191.         const info = ManifestParserUtils.createDrmInfo(keySystem, defaultInit);
  192.         drmInfos.push(info);
  193.       }
  194.     }
  195.   }
  197.   // If we have a default key id, apply it to every initData.
  198.   const defaultKeyId = Array.from(keyIds)[0] || null;
  200.   if (defaultKeyId) {
  201.     for (const info of drmInfos) {
  202.       for (const initData of info.initData) {
  203.         initData.keyId = defaultKeyId;
  204.       }
  205.     }
  206.   }
  208.   return {
  209.     defaultKeyId: defaultKeyId,
  210.     defaultInit: defaultInit,
  211.     drmInfos: drmInfos,
  212.     firstRepresentation: true,
  213.   };
  214. };
  217. /**
  218.  * Parses the given ContentProtection elements found at the Representation
  219.  * level.  This may update the |context|.
  220.  *
  221.  * @param {!Array.<!Element>} elems
  222.  * @param {shaka.extern.DashContentProtectionCallback} callback
  223.  * @param {shaka.dash.ContentProtection.Context} context
  224.  * @param {boolean} ignoreDrmInfo
  225.  * @return {?string} The parsed key ID
  226.  */
  227. shaka.dash.ContentProtection.parseFromRepresentation = function(
  228.     elems, callback, context, ignoreDrmInfo) {
  229.   const ContentProtection = shaka.dash.ContentProtection;
  230.   let repContext = ContentProtection.parseFromAdaptationSet(
  231.       elems, callback, ignoreDrmInfo);
  233.   if (context.firstRepresentation) {
  234.     let asUnknown = context.drmInfos.length == 1 &&
  235.         !context.drmInfos[0].keySystem;
  236.     let asUnencrypted = context.drmInfos.length == 0;
  237.     let repUnencrypted = repContext.drmInfos.length == 0;
  239.     // There are two cases where we need to replace the |drmInfos| in the
  240.     // context with those in the Representation:
  241.     //   1. The AdaptationSet does not list any ContentProtection.
  242.     //   2. The AdaptationSet only lists unknown key-systems.
  243.     if (asUnencrypted || (asUnknown && !repUnencrypted)) {
  244.       context.drmInfos = repContext.drmInfos;
  245.     }
  246.     context.firstRepresentation = false;
  247.   } else if (repContext.drmInfos.length > 0) {
  248.     // If this is not the first Representation, then we need to remove entries
  249.     // from the context that do not appear in this Representation.
  250.     context.drmInfos = context.drmInfos.filter(function(asInfo) {
  251.       return repContext.drmInfos.some(function(repInfo) {
  252.         return repInfo.keySystem == asInfo.keySystem;
  253.       });
  254.     });
  255.     // If we have filtered out all key-systems, throw an error.
  256.     if (context.drmInfos.length == 0) {
  257.       throw new shaka.util.Error(
  258.           shaka.util.Error.Severity.CRITICAL,
  259.           shaka.util.Error.Category.MANIFEST,
  260.           shaka.util.Error.Code.DASH_NO_COMMON_KEY_SYSTEM);
  261.     }
  262.   }
  264.   return repContext.defaultKeyId || context.defaultKeyId;
  265. };
  268. /**
  269.  * Gets a Widevine license URL from a content protection element
  270.  * containing a custom `ms:laurl` element
  271.  *
  272.  * @param {shaka.dash.ContentProtection.Element} element
  273.  * @return {string}
  274.  */
  275. shaka.dash.ContentProtection.getWidevineLicenseUrl = function(element) {
  276.   const mslaurlNode = shaka.util.XmlUtils.findChildNS(
  277.     element.node, 'urn:microsoft', 'laurl');
  278.   if (mslaurlNode) {
  279.     return mslaurlNode.getAttribute('licenseUrl') || '';
  280.   }
  281.   return '';
  282. };
  285. /**
  286.  * @typedef {{
  287.  *   type: number,
  288.  *   value: !Uint8Array
  289.  * }}
  290.  *
  291.  * @description
  292.  * The parsed result of a PlayReady object record.
  293.  *
  294.  * @property {number} type
  295.  *   Type of data stored in the record.
  296.  * @property {!Uint8Array} value
  297.  *   Record content.
  298.  */
  299. shaka.dash.ContentProtection.PlayReadyRecord;
  301. /**
  302.  * Enum for PlayReady record types.
  303.  * @enum {number}
  304.  */
  305. shaka.dash.ContentProtection.PLAYREADY_RECORD_TYPES = {
  306.   RIGHTS_MANAGEMENT: 0x001,
  307.   RESERVED: 0x002,
  308.   EMBEDDED_LICENSE: 0x003,
  309. };
  312. /**
  313.  * Parses an Array buffer starting at byteOffset for PlayReady Object Records.
  314.  * Each PRO Record is preceded by its PlayReady Record type and length in bytes.
  315.  *
  316.  * PlayReady Object Record format: https://goo.gl/FTcu46
  317.  *
  318.  * @param {!ArrayBuffer} recordData
  319.  * @param {number} byteOffset
  320.  * @return {!Array.<shaka.dash.ContentProtection.PlayReadyRecord>}
  321.  * @private
  322.  */
  323. shaka.dash.ContentProtection.parseMsProRecords_ = function(
  324.   recordData, byteOffset) {
  325.   const records = [];
  326.   const view = new DataView(recordData);
  328.   while (byteOffset < recordData.byteLength - 1) {
  329.     const type = view.getUint16(byteOffset, true);
  330.     byteOffset += 2;
  332.     const byteLength = view.getUint16(byteOffset, true);
  333.     byteOffset += 2;
  335.     goog.asserts.assert(
  336.       (byteLength & 1) === 0,
  337.       'expected byteLength to be an even number');
  339.     const recordValue = new Uint8Array(recordData, byteOffset, byteLength);
  341.     records.push({
  342.       type: type,
  343.       value: recordValue,
  344.     });
  346.     byteOffset += byteLength;
  347.   }
  349.   return records;
  350. };
  353. /**
  354.  * Parses an ArrayBuffer for PlayReady Objects.  The data
  355.  * should contain a 32-bit integer indicating the length of
  356.  * the PRO in bytes.  Following that, a 16-bit integer for
  357.  * the number of PlayReady Object Records in the PRO.  Lastly,
  358.  * a byte array of the PRO Records themselves.
  359.  *
  360.  * PlayReady Object format: https://goo.gl/W8yAN4
  361.  *
  362.  * @param {!ArrayBuffer} data
  363.  * @return {!Array.<shaka.dash.ContentProtection.PlayReadyRecord>}
  364.  * @private
  365.  */
  366. shaka.dash.ContentProtection.parseMsPro_ = function(data) {
  367.   let byteOffset = 0;
  368.   const view = new DataView(data);
  370.   // First 4 bytes is the PRO length (DWORD)
  371.   const byteLength = view.getUint32(byteOffset, true /* littleEndian */);
  372.   byteOffset += 4;
  374.   if (byteLength !== data.byteLength) {
  375.     // Malformed PRO
  376.     shaka.log.warning('PlayReady Object with invalid length encountered.');
  377.     return [];
  378.   }
  380.   // Skip PRO Record count (WORD)
  381.   byteOffset += 2;
  383.   // Rest of the data contains the PRO Records
  384.   const ContentProtection = shaka.dash.ContentProtection;
  385.   return ContentProtection.parseMsProRecords_(data, byteOffset);
  386. };
  389. /**
  390.  * PlayReady Header format: https://goo.gl/dBzxNA
  391.  *
  392.  * @param {!Element} xml
  393.  * @return {string}
  394.  * @private
  395.  */
  396. shaka.dash.ContentProtection.getLaurl_ = function(xml) {
  397.   // LA_URL element is optional and no more than one is
  398.   // allowed inside the DATA element. Only absolute URLs are allowed.
  399.   // If the LA_URL element exists, it must not be empty.
  400.   for (const elem of xml.getElementsByTagName('DATA')) {
  401.     for (const child of elem.childNodes) {
  402.       if (child instanceof Element && child.tagName == 'LA_URL') {
  403.         return child.textContent;
  404.       }
  405.     }
  406.   }
  408.   // Not found
  409.   return '';
  410. };
  413. /**
  414.  * Gets a PlayReady license URL from a content protection element
  415.  * containing a PlayReady Header Object
  416.  *
  417.  * @param {shaka.dash.ContentProtection.Element} element
  418.  * @return {string}
  419.  */
  420. shaka.dash.ContentProtection.getPlayReadyLicenseUrl = function(element) {
  421.   const proNode = shaka.util.XmlUtils.findChildNS(
  422.     element.node, 'urn:microsoft:playready', 'pro');
  424.   if (!proNode) {
  425.     return '';
  426.   }
  428.   const ContentProtection = shaka.dash.ContentProtection;
  429.   const PLAYREADY_RECORD_TYPES = ContentProtection.PLAYREADY_RECORD_TYPES;
  431.   const bytes = shaka.util.Uint8ArrayUtils.fromBase64(proNode.textContent);
  432.   const records = ContentProtection.parseMsPro_(bytes.buffer);
  433.   const record = records.filter((record) => {
  434.     return record.type === PLAYREADY_RECORD_TYPES.RIGHTS_MANAGEMENT;
  435.   })[0];
  437.   if (!record) {
  438.     return '';
  439.   }
  441.   const xml = shaka.util.StringUtils.fromUTF16(record.value, true);
  442.   const rootElement = shaka.util.XmlUtils.parseXmlString(xml, 'WRMHEADER');
  443.   if (!rootElement) {
  444.     return '';
  445.   }
  447.   return ContentProtection.getLaurl_(rootElement);
  448. };
  451. /**
  452.  * Gets a PlayReady initData from a content protection element
  453.  * containing a PlayReady Pro Object
  454.  *
  455.  * @param {shaka.dash.ContentProtection.Element} element
  456.  * @return {?Array.<shaka.extern.InitDataOverride>}
  457.  * @private
  458.  */
  459. shaka.dash.ContentProtection.getInitDataFromPro_ = function(element) {
  460.   const proNode = shaka.util.XmlUtils.findChildNS(
  461.       element.node, 'urn:microsoft:playready', 'pro');
  462.   if (!proNode) {
  463.     return null;
  464.   }
  465.   const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  466.   const data = Uint8ArrayUtils.fromBase64(proNode.textContent);
  467.   const systemId = new Uint8Array([
  468.     0x9a, 0x04, 0xf0, 0x79, 0x98, 0x40, 0x42, 0x86,
  469.     0xab, 0x92, 0xe6, 0x5b, 0xe0, 0x88, 0x5f, 0x95,
  470.   ]);
  471.   const pssh = shaka.util.Pssh.createPssh(data, systemId);
  472.   return [
  473.     {
  474.       initData: pssh,
  475.       initDataType: 'cenc',
  476.       keyId: element.keyId,
  477.     },
  478.   ];
  479. };
  481. /**
  482.  * Creates DrmInfo objects from the given element.
  483.  *
  484.  * @param {Array.<shaka.extern.InitDataOverride>} defaultInit
  485.  * @param {shaka.extern.DashContentProtectionCallback} callback
  486.  * @param {!Array.<shaka.dash.ContentProtection.Element>} elements
  487.  * @return {!Array.<shaka.extern.DrmInfo>}
  488.  * @private
  489.  */
  490. shaka.dash.ContentProtection.convertElements_ = function(
  491.   defaultInit, callback, elements) {
  492.   const ContentProtection = shaka.dash.ContentProtection;
  493.   const ManifestParserUtils = shaka.util.ManifestParserUtils;
  494.   const defaultKeySystems = ContentProtection.defaultKeySystems_;
  495.   const licenseUrlParsers = ContentProtection.licenseUrlParsers_;
  497.   /** @type {!Array.<shaka.extern.DrmInfo>} */
  498.   const out = [];
  500.   for (const element of elements) {
  501.     const keySystem = defaultKeySystems.get(element.schemeUri);
  502.     if (keySystem) {
  503.       goog.asserts.assert(
  504.           !element.init || element.init.length,
  505.           'Init data must be null or non-empty.');
  507.         const proInitData = ContentProtection.getInitDataFromPro_(element);
  508.         const initData = element.init || defaultInit || proInitData;
  509.       const info = ManifestParserUtils.createDrmInfo(keySystem, initData);
  510.       const licenseParser = licenseUrlParsers.get(keySystem);
  511.       if (licenseParser) {
  512.         info.licenseServerUri = licenseParser(element);
  513.       }
  515.       out.push(info);
  516.     } else {
  517.       goog.asserts.assert(callback, 'ContentProtection callback is required');
  518.       const infos = callback(element.node) || [];
  519.       for (const info of infos) {
  520.         out.push(info);
  521.       }
  522.     }
  523.   }
  525.   return out;
  526. };
  529. /**
  530.  * A map of key system name to license server url parser.
  531.  *
  532.  * @const {!Map.<string, function(shaka.dash.ContentProtection.Element)>}
  533.  * @private
  534.  */
  535. shaka.dash.ContentProtection.licenseUrlParsers_ = new Map()
  536.     .set('com.widevine.alpha',
  537.          shaka.dash.ContentProtection.getWidevineLicenseUrl)
  538.     .set('com.microsoft.playready',
  539.          shaka.dash.ContentProtection.getPlayReadyLicenseUrl);
  542. /**
  543.  * Parses the given ContentProtection elements.  If there is an error, it
  544.  * removes those elements.
  545.  *
  546.  * @param {!Array.<!Element>} elems
  547.  * @return {!Array.<shaka.dash.ContentProtection.Element>}
  548.  * @private
  549.  */
  550. shaka.dash.ContentProtection.parseElements_ = function(elems) {
  551.   /** @type {!Array.<shaka.dash.ContentProtection.Element>} */
  552.   const out = [];
  554.   for (const elem of elems) {
  555.     const parsed = shaka.dash.ContentProtection.parseElement_(elem);
  556.     if (parsed) {
  557.       out.push(parsed);
  558.     }
  559.   }
  561.   return out;
  562. };
  565. /**
  566.  * Parses the given ContentProtection element.
  567.  *
  568.  * @param {!Element} elem
  569.  * @return {?shaka.dash.ContentProtection.Element}
  570.  * @private
  571.  */
  572. shaka.dash.ContentProtection.parseElement_ = function(elem) {
  573.   const NS = shaka.dash.ContentProtection.CencNamespaceUri_;
  575.   /** @type {?string} */
  576.   let schemeUri = elem.getAttribute('schemeIdUri');
  577.   /** @type {?string} */
  578.   let keyId = shaka.util.XmlUtils.getAttributeNS(elem, NS, 'default_KID');
  579.   /** @type {!Array.<string>} */
  580.   const psshs = shaka.util.XmlUtils.findChildrenNS(elem, NS, 'pssh')
  581.                   .map(shaka.util.XmlUtils.getContents);
  583.   if (!schemeUri) {
  584.     shaka.log.error('Missing required schemeIdUri attribute on',
  585.                     'ContentProtection element', elem);
  586.     return null;
  587.   }
  589.   schemeUri = schemeUri.toLowerCase();
  590.   if (keyId) {
  591.     keyId = keyId.replace(/-/g, '').toLowerCase();
  592.     if (keyId.includes(' ')) {
  593.       throw new shaka.util.Error(
  594.           shaka.util.Error.Severity.CRITICAL,
  595.           shaka.util.Error.Category.MANIFEST,
  596.           shaka.util.Error.Code.DASH_MULTIPLE_KEY_IDS_NOT_SUPPORTED);
  597.     }
  598.   }
  600.   /** @type {!Array.<shaka.extern.InitDataOverride>} */
  601.   let init = [];
  602.   try {
  603.     // Try parsing PSSH data.
  604.     init = psshs.map((pssh) => {
  605.       return {
  606.         initDataType: 'cenc',
  607.         initData: shaka.util.Uint8ArrayUtils.fromBase64(pssh),
  608.         keyId: null,
  609.       };
  610.     });
  611.   } catch (e) {
  612.     throw new shaka.util.Error(
  613.         shaka.util.Error.Severity.CRITICAL,
  614.         shaka.util.Error.Category.MANIFEST,
  615.         shaka.util.Error.Code.DASH_PSSH_BAD_ENCODING);
  616.   }
  618.   return {
  619.     node: elem,
  620.     schemeUri: schemeUri,
  621.     keyId: keyId,
  622.     init: (init.length > 0 ? init : null),
  623.   };
  624. };