Source: lib/mss/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.mss.ContentProtection');
  9. goog.require('shaka.log');
  10. goog.require('shaka.util.BufferUtils');
  11. goog.require('shaka.util.ManifestParserUtils');
  12. goog.require('shaka.util.Pssh');
  13. goog.require('shaka.util.StringUtils');
  14. goog.require('shaka.util.TXml');
  15. goog.require('shaka.util.Uint8ArrayUtils');
  18. /**
  19.  * @summary A set of functions for parsing and interpreting Protection
  20.  *   elements.
  21.  */
  22. shaka.mss.ContentProtection = class {
  23.   /**
  24.    * Parses info from the Protection elements.
  25.    *
  26.    * @param {!Array.<!shaka.extern.xml.Node>} elems
  27.    * @param {!Object.<string, string>} keySystemsBySystemId
  28.    * @return {!Array.<shaka.extern.DrmInfo>}
  29.    */
  30.   static parseFromProtection(elems, keySystemsBySystemId) {
  31.     const ContentProtection = shaka.mss.ContentProtection;
  32.     const TXml = shaka.util.TXml;
  34.     /** @type {!Array.<!shaka.extern.xml.Node>} */
  35.     let protectionHeader = [];
  36.     for (const elem of elems) {
  37.       protectionHeader = protectionHeader.concat(
  38.           TXml.findChildren(elem, 'ProtectionHeader'));
  39.     }
  40.     if (!protectionHeader.length) {
  41.       return [];
  42.     }
  43.     return ContentProtection.convertElements_(
  44.         protectionHeader, keySystemsBySystemId);
  45.   }
  47.   /**
  48.    * Parses an Array buffer starting at byteOffset for PlayReady Object Records.
  49.    * Each PRO Record is preceded by its PlayReady Record type and length in
  50.    * bytes.
  51.    *
  52.    * PlayReady Object Record format: https://goo.gl/FTcu46
  53.    *
  54.    * @param {!DataView} view
  55.    * @param {number} byteOffset
  56.    * @return {!Array.<shaka.mss.ContentProtection.PlayReadyRecord>}
  57.    * @private
  58.    */
  59.   static parseMsProRecords_(view, byteOffset) {
  60.     const records = [];
  62.     while (byteOffset < view.byteLength - 1) {
  63.       const type = view.getUint16(byteOffset, true);
  64.       byteOffset += 2;
  66.       const byteLength = view.getUint16(byteOffset, true);
  67.       byteOffset += 2;
  69.       if ((byteLength & 1) != 0 || byteLength + byteOffset > view.byteLength) {
  70.         shaka.log.warning('Malformed MS PRO object');
  71.         return [];
  72.       }
  74.       const recordValue = shaka.util.BufferUtils.toUint8(
  75.           view, byteOffset, byteLength);
  76.       records.push({
  77.         type: type,
  78.         value: recordValue,
  79.       });
  81.       byteOffset += byteLength;
  82.     }
  84.     return records;
  85.   }
  87.   /**
  88.    * Parses a buffer for PlayReady Objects.  The data
  89.    * should contain a 32-bit integer indicating the length of
  90.    * the PRO in bytes.  Following that, a 16-bit integer for
  91.    * the number of PlayReady Object Records in the PRO.  Lastly,
  92.    * a byte array of the PRO Records themselves.
  93.    *
  94.    * PlayReady Object format: https://goo.gl/W8yAN4
  95.    *
  96.    * @param {BufferSource} data
  97.    * @return {!Array.<shaka.mss.ContentProtection.PlayReadyRecord>}
  98.    * @private
  99.    */
  100.   static parseMsPro_(data) {
  101.     let byteOffset = 0;
  102.     const view = shaka.util.BufferUtils.toDataView(data);
  104.     // First 4 bytes is the PRO length (DWORD)
  105.     const byteLength = view.getUint32(byteOffset, /* littleEndian= */ true);
  106.     byteOffset += 4;
  108.     if (byteLength != data.byteLength) {
  109.       // Malformed PRO
  110.       shaka.log.warning('PlayReady Object with invalid length encountered.');
  111.       return [];
  112.     }
  114.     // Skip PRO Record count (WORD)
  115.     byteOffset += 2;
  117.     // Rest of the data contains the PRO Records
  118.     const ContentProtection = shaka.mss.ContentProtection;
  119.     return ContentProtection.parseMsProRecords_(view, byteOffset);
  120.   }
  122.   /**
  123.    * Parse a PlayReady Header format: https://goo.gl/dBzxNA
  124.    * a try to find the LA_URL value.
  125.    *
  126.    * @param {!shaka.extern.xml.Node} xml
  127.    * @return {string}
  128.    * @private
  129.    */
  130.   static getLaurl_(xml) {
  131.     const TXml = shaka.util.TXml;
  132.     // LA_URL element is optional and no more than one is
  133.     // allowed inside the DATA element. Only absolute URLs are allowed.
  134.     // If the LA_URL element exists, it must not be empty.
  135.     for (const elem of TXml.getElementsByTagName(xml, 'DATA')) {
  136.       const laUrl = TXml.findChild(elem, 'LA_URL');
  137.       if (laUrl) {
  138.         return /** @type {string} */ (shaka.util.TXml.getTextContents(laUrl));
  139.       }
  140.     }
  142.     // Not found
  143.     // We return a empty string instead null because is the default value for
  144.     // a License in our model.
  145.     return '';
  146.   }
  148.   /**
  149.    * Gets a PlayReady license URL from a protection element
  150.    * containing a PlayReady Header Object
  151.    *
  152.    * @param {!shaka.extern.xml.Node} element
  153.    * @return {string}
  154.    */
  155.   static getPlayReadyLicenseUrl(element) {
  156.     const ContentProtection = shaka.mss.ContentProtection;
  157.     const rootElement = ContentProtection.getPlayReadyHeaderObject_(element);
  158.     if (!rootElement) {
  159.       return '';
  160.     }
  162.     return ContentProtection.getLaurl_(rootElement);
  163.   }
  165.   /**
  166.    * Parse a PlayReady Header format: https://goo.gl/dBzxNA
  167.    * a try to find the KID value.
  168.    *
  169.    * @param {!shaka.extern.xml.Node} xml
  170.    * @return {?string}
  171.    * @private
  172.    */
  173.   static getKID_(xml) {
  174.     const TXml = shaka.util.TXml;
  175.     // KID element is optional and no more than one is
  176.     // allowed inside the DATA element.
  177.     for (const elem of TXml.getElementsByTagName(xml, 'DATA')) {
  178.       const kid = TXml.findChild(elem, 'KID');
  179.       if (kid) {
  180.         // GUID: [DWORD, WORD, WORD, 8-BYTE]
  181.         const guidBytes =
  182.             shaka.util.Uint8ArrayUtils.fromBase64(
  183.                 /** @type{string} */ (shaka.util.TXml.getTextContents(kid)));
  184.         // Reverse byte order from little-endian to big-endian
  185.         const kidBytes = new Uint8Array([
  186.           guidBytes[3], guidBytes[2], guidBytes[1], guidBytes[0],
  187.           guidBytes[5], guidBytes[4],
  188.           guidBytes[7], guidBytes[6],
  189.           ...guidBytes.slice(8),
  190.         ]);
  191.         return shaka.util.Uint8ArrayUtils.toHex(kidBytes);
  192.       }
  193.     }
  195.     // Not found
  196.     return null;
  197.   }
  199.   /**
  200.    * Gets a PlayReady KID from a protection element
  201.    * containing a PlayReady Header Object
  202.    *
  203.    * @param {!shaka.extern.xml.Node} element
  204.    * @return {?string}
  205.    * @private
  206.    */
  207.   static getPlayReadyKID_(element) {
  208.     const ContentProtection = shaka.mss.ContentProtection;
  209.     const rootElement = ContentProtection.getPlayReadyHeaderObject_(element);
  210.     if (!rootElement) {
  211.       return null;
  212.     }
  214.     return ContentProtection.getKID_(rootElement);
  215.   }
  217.   /**
  218.    * Gets a PlayReady Header Object from a protection element
  219.    *
  220.    * @param {!shaka.extern.xml.Node} element
  221.    * @return {?shaka.extern.xml.Node}
  222.    * @private
  223.    */
  224.   static getPlayReadyHeaderObject_(element) {
  225.     const ContentProtection = shaka.mss.ContentProtection;
  226.     const PLAYREADY_RECORD_TYPES = ContentProtection.PLAYREADY_RECORD_TYPES;
  228.     const bytes = shaka.util.Uint8ArrayUtils.fromBase64(
  229.         /** @type{string} */ (shaka.util.TXml.getTextContents(element)));
  230.     const records = ContentProtection.parseMsPro_(bytes);
  231.     const record = records.filter((record) => {
  232.       return record.type === PLAYREADY_RECORD_TYPES.RIGHTS_MANAGEMENT;
  233.     })[0];
  235.     if (!record) {
  236.       return null;
  237.     }
  239.     const xml = shaka.util.StringUtils.fromUTF16(record.value, true);
  240.     const rootElement = shaka.util.TXml.parseXmlString(xml, 'WRMHEADER');
  241.     if (!rootElement) {
  242.       return null;
  243.     }
  244.     return rootElement;
  245.   }
  247.   /**
  248.    * Gets a initData from a protection element.
  249.    *
  250.    * @param {!shaka.extern.xml.Node} element
  251.    * @param {string} systemID
  252.    * @param {?string} keyId
  253.    * @return {?Array.<shaka.extern.InitDataOverride>}
  254.    * @private
  255.    */
  256.   static getInitDataFromPro_(element, systemID, keyId) {
  257.     const Uint8ArrayUtils = shaka.util.Uint8ArrayUtils;
  258.     const data = Uint8ArrayUtils.fromBase64(
  259.         /** @type{string} */ (shaka.util.TXml.getTextContents(element)));
  260.     const systemId = Uint8ArrayUtils.fromHex(systemID.replace(/-/g, ''));
  261.     const keyIds = new Set();
  262.     const psshVersion = 0;
  263.     const pssh =
  264.         shaka.util.Pssh.createPssh(data, systemId, keyIds, psshVersion);
  265.     return [
  266.       {
  267.         initData: pssh,
  268.         initDataType: 'cenc',
  269.         keyId: keyId,
  270.       },
  271.     ];
  272.   }
  274.   /**
  275.    * Creates DrmInfo objects from an array of elements.
  276.    *
  277.    * @param {!Array.<!shaka.extern.xml.Node>} elements
  278.    * @param {!Object.<string, string>} keySystemsBySystemId
  279.    * @return {!Array.<shaka.extern.DrmInfo>}
  280.    * @private
  281.    */
  282.   static convertElements_(elements, keySystemsBySystemId) {
  283.     const ContentProtection = shaka.mss.ContentProtection;
  284.     const ManifestParserUtils = shaka.util.ManifestParserUtils;
  285.     const licenseUrlParsers = ContentProtection.licenseUrlParsers_;
  287.     /** @type {!Array.<shaka.extern.DrmInfo>} */
  288.     const out = [];
  290.     for (let i = 0; i < elements.length; i++) {
  291.       const element = elements[i];
  292.       const systemID = element.attributes['SystemID'].toLowerCase();
  293.       const keySystem = keySystemsBySystemId[systemID];
  294.       if (keySystem) {
  295.         const KID = ContentProtection.getPlayReadyKID_(element);
  296.         const initData = ContentProtection.getInitDataFromPro_(
  297.             element, systemID, KID);
  299.         const info = ManifestParserUtils.createDrmInfo(
  300.             keySystem, /* encryptionScheme= */ 'cenc', initData);
  301.         if (KID) {
  302.           info.keyIds.add(KID);
  303.         }
  305.         const licenseParser = licenseUrlParsers.get(keySystem);
  306.         if (licenseParser) {
  307.           info.licenseServerUri = licenseParser(element);
  308.         }
  310.         out.push(info);
  311.       }
  312.     }
  314.     return out;
  315.   }
  316. };
  318. /**
  319.  * @typedef {{
  320.  *   type: number,
  321.  *   value: !Uint8Array
  322.  * }}
  323.  *
  324.  * @description
  325.  * The parsed result of a PlayReady object record.
  326.  *
  327.  * @property {number} type
  328.  *   Type of data stored in the record.
  329.  * @property {!Uint8Array} value
  330.  *   Record content.
  331.  */
  332. shaka.mss.ContentProtection.PlayReadyRecord;
  334. /**
  335.  * Enum for PlayReady record types.
  336.  * @enum {number}
  337.  */
  338. shaka.mss.ContentProtection.PLAYREADY_RECORD_TYPES = {
  339.   RIGHTS_MANAGEMENT: 0x001,
  340.   RESERVED: 0x002,
  341.   EMBEDDED_LICENSE: 0x003,
  342. };
  344. /**
  345.  * A map of key system name to license server url parser.
  346.  *
  347.  * @const {!Map.<string, function(!shaka.extern.xml.Node)>}
  348.  * @private
  349.  */
  350. shaka.mss.ContentProtection.licenseUrlParsers_ = new Map()
  351.     .set('com.microsoft.playready',
  352.         shaka.mss.ContentProtection.getPlayReadyLicenseUrl)
  353.     .set('com.microsoft.playready.recommendation',
  354.         shaka.mss.ContentProtection.getPlayReadyLicenseUrl)
  355.     .set('com.microsoft.playready.software',
  356.         shaka.mss.ContentProtection.getPlayReadyLicenseUrl)
  357.     .set('com.microsoft.playready.hardware',
  358.         shaka.mss.ContentProtection.getPlayReadyLicenseUrl);