Source: lib/util/fairplay_utils.js

  1. /*! @license
  2.  * Shaka Player
  3.  * Copyright 2016 Google LLC
  4.  * SPDX-License-Identifier: Apache-2.0
  5.  */
  7. goog.provide('shaka.util.FairPlayUtils');
  9. goog.require('goog.Uri');
  10. goog.require('goog.asserts');
  11. goog.require('shaka.net.NetworkingEngine');
  12. goog.require('shaka.util.BufferUtils');
  13. goog.require('shaka.util.Error');
  14. goog.require('shaka.util.StringUtils');
  15. goog.require('shaka.util.Uint8ArrayUtils');
  18. /**
  19.  * @summary A set of FairPlay utility functions.
  20.  * @export
  21.  */
  22. shaka.util.FairPlayUtils = class {
  23.   /**
  24.    * Check if FairPlay is supported.
  25.    *
  26.    * @return {!Promise<boolean>}
  27.    * @export
  28.    */
  29.   static async isFairPlaySupported() {
  30.     const config = {
  31.       initDataTypes: ['cenc', 'sinf', 'skd'],
  32.       videoCapabilities: [
  33.         {
  34.           contentType: 'video/mp4; codecs="avc1.42E01E"',
  35.         },
  36.       ],
  37.     };
  38.     try {
  39.       await navigator.requestMediaKeySystemAccess('com.apple.fps', [config]);
  40.       return true;
  41.     } catch (err) {
  42.       return false;
  43.     }
  44.   }
  46.   /**
  47.    * Using the default method, extract a content ID from the init data.  This is
  48.    * based on the FairPlay example documentation.
  49.    *
  50.    * @param {!BufferSource} initData
  51.    * @return {string}
  52.    * @export
  53.    */
  54.   static defaultGetContentId(initData) {
  55.     const uriString = shaka.util.StringUtils.fromBytesAutoDetect(initData);
  57.     // The domain of that URI is the content ID according to Apple's FPS
  58.     // sample.
  59.     const uri = new goog.Uri(uriString);
  60.     return uri.getDomain();
  61.   }
  63.   /**
  64.    * Transforms the init data buffer using the given data.  The format is:
  65.    *
  66.    * <pre>
  67.    * [4 bytes] initDataSize
  68.    * [initDataSize bytes] initData
  69.    * [4 bytes] contentIdSize
  70.    * [contentIdSize bytes] contentId
  71.    * [4 bytes] certSize
  72.    * [certSize bytes] cert
  73.    * </pre>
  74.    *
  75.    * @param {!BufferSource} initData
  76.    * @param {!BufferSource|string} contentId
  77.    * @param {?BufferSource} cert  The server certificate; this will throw if not
  78.    *   provided.
  79.    * @return {!Uint8Array}
  80.    * @export
  81.    */
  82.   static initDataTransform(initData, contentId, cert) {
  83.     if (!cert || !cert.byteLength) {
  84.       throw new shaka.util.Error(
  85.           shaka.util.Error.Severity.CRITICAL,
  86.           shaka.util.Error.Category.DRM,
  87.           shaka.util.Error.Code.SERVER_CERTIFICATE_REQUIRED);
  88.     }
  90.     // From that, we build a new init data to use in the session.  This is
  91.     // composed of several parts.  First, the init data as a UTF-16 sdk:// URL.
  92.     // Second, a 4-byte LE length followed by the content ID in UTF-16-LE.
  93.     // Third, a 4-byte LE length followed by the certificate.
  94.     /** @type {BufferSource} */
  95.     let contentIdArray;
  96.     if (typeof contentId == 'string') {
  97.       contentIdArray =
  98.           shaka.util.StringUtils.toUTF16(contentId, /* littleEndian= */ true);
  99.     } else {
  100.       contentIdArray = contentId;
  101.     }
  103.     // The init data we get is a UTF-8 string; convert that to a UTF-16 string.
  104.     const sdkUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
  105.     const utf16 =
  106.         shaka.util.StringUtils.toUTF16(sdkUri, /* littleEndian= */ true);
  108.     const rebuiltInitData = new Uint8Array(
  109.         12 + utf16.byteLength + contentIdArray.byteLength + cert.byteLength);
  111.     let offset = 0;
  112.     /** @param {BufferSource} array */
  113.     const append = (array) => {
  114.       rebuiltInitData.set(shaka.util.BufferUtils.toUint8(array), offset);
  115.       offset += array.byteLength;
  116.     };
  117.     /** @param {BufferSource} array */
  118.     const appendWithLength = (array) => {
  119.       const view = shaka.util.BufferUtils.toDataView(rebuiltInitData);
  120.       const value = array.byteLength;
  121.       view.setUint32(offset, value, /* littleEndian= */ true);
  122.       offset += 4;
  123.       append(array);
  124.     };
  126.     appendWithLength(utf16);
  127.     appendWithLength(contentIdArray);
  128.     appendWithLength(cert);
  130.     goog.asserts.assert(
  131.         offset == rebuiltInitData.length, 'Inconsistent init data length');
  132.     return rebuiltInitData;
  133.   }
  135.   /**
  136.    * Basic initDataTransform configuration.
  137.    *
  138.    * @param {!Uint8Array} initData
  139.    * @param {string} initDataType
  140.    * @param {?shaka.extern.DrmInfo} drmInfo
  141.    * @return {!Uint8Array}
  142.    * @private
  143.    */
  144.   static basicInitDataTransform_(initData, initDataType, drmInfo) {
  145.     if (initDataType !== 'skd') {
  146.       return initData;
  147.     }
  148.     const StringUtils = shaka.util.StringUtils;
  149.     const FairPlayUtils = shaka.util.FairPlayUtils;
  150.     const cert = drmInfo.serverCertificate;
  151.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  152.     const contentId = initDataAsString.split('skd://').pop();
  153.     return FairPlayUtils.initDataTransform(initData, contentId, cert);
  154.   }
  156.   /**
  157.    * Verimatrix initDataTransform configuration.
  158.    *
  159.    * @param {!Uint8Array} initData
  160.    * @param {string} initDataType
  161.    * @param {?shaka.extern.DrmInfo} drmInfo
  162.    * @return {!Uint8Array}
  163.    * @export
  164.    */
  165.   static verimatrixInitDataTransform(initData, initDataType, drmInfo) {
  166.     return shaka.util.FairPlayUtils.basicInitDataTransform_(
  167.         initData, initDataType, drmInfo);
  168.   }
  170.   /**
  171.    * EZDRM initDataTransform configuration.
  172.    *
  173.    * @param {!Uint8Array} initData
  174.    * @param {string} initDataType
  175.    * @param {?shaka.extern.DrmInfo} drmInfo
  176.    * @return {!Uint8Array}
  177.    * @export
  178.    */
  179.   static ezdrmInitDataTransform(initData, initDataType, drmInfo) {
  180.     if (initDataType !== 'skd') {
  181.       return initData;
  182.     }
  183.     const StringUtils = shaka.util.StringUtils;
  184.     const FairPlayUtils = shaka.util.FairPlayUtils;
  185.     const cert = drmInfo.serverCertificate;
  186.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  187.     const contentId = initDataAsString.split(';').pop();
  188.     return FairPlayUtils.initDataTransform(initData, contentId, cert);
  189.   }
  191.   /**
  192.    * Conax initDataTransform configuration.
  193.    *
  194.    * @param {!Uint8Array} initData
  195.    * @param {string} initDataType
  196.    * @param {?shaka.extern.DrmInfo} drmInfo
  197.    * @return {!Uint8Array}
  198.    * @export
  199.    */
  200.   static conaxInitDataTransform(initData, initDataType, drmInfo) {
  201.     if (initDataType !== 'skd') {
  202.       return initData;
  203.     }
  204.     const StringUtils = shaka.util.StringUtils;
  205.     const FairPlayUtils = shaka.util.FairPlayUtils;
  206.     const cert = drmInfo.serverCertificate;
  207.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  208.     const skdValue = initDataAsString.split('skd://').pop().split('?').shift();
  209.     const stringToArray = (string) => {
  210.       // 2 bytes for each char
  211.       const buffer = new ArrayBuffer(string.length * 2);
  212.       const array = shaka.util.BufferUtils.toUint16(buffer);
  213.       for (let i = 0, strLen = string.length; i < strLen; i++) {
  214.         array[i] = string.charCodeAt(i);
  215.       }
  216.       return array;
  217.     };
  218.     const contentId = stringToArray(window.atob(skdValue));
  219.     return FairPlayUtils.initDataTransform(initData, contentId, cert);
  220.   }
  222.   /**
  223.    * ExpressPlay initDataTransform configuration.
  224.    *
  225.    * @param {!Uint8Array} initData
  226.    * @param {string} initDataType
  227.    * @param {?shaka.extern.DrmInfo} drmInfo
  228.    * @return {!Uint8Array}
  229.    * @export
  230.    */
  231.   static expressplayInitDataTransform(initData, initDataType, drmInfo) {
  232.     return shaka.util.FairPlayUtils.basicInitDataTransform_(
  233.         initData, initDataType, drmInfo);
  234.   }
  236.   /**
  237.    * Verimatrix FairPlay request.
  238.    *
  239.    * @param {shaka.net.NetworkingEngine.RequestType} type
  240.    * @param {shaka.extern.Request} request
  241.    * @param {shaka.extern.RequestContext=} context
  242.    * @export
  243.    */
  244.   static verimatrixFairPlayRequest(type, request, context) {
  245.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  246.       return;
  247.     }
  248.     const body = /** @type {!(ArrayBuffer|ArrayBufferView)} */(request.body);
  249.     const originalPayload = shaka.util.BufferUtils.toUint8(body);
  250.     const base64Payload = shaka.util.Uint8ArrayUtils.toBase64(originalPayload);
  251.     request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
  252.     request.body = shaka.util.StringUtils.toUTF8('spc=' + base64Payload);
  253.   }
  255.   /**
  256.    * Set content-type to application/octet-stream in a FairPlay request.
  257.    *
  258.    * @param {shaka.net.NetworkingEngine.RequestType} type
  259.    * @param {shaka.extern.Request} request
  260.    * @param {shaka.extern.RequestContext=} context
  261.    * @private
  262.    */
  263.   static octetStreamFairPlayRequest_(type, request, context) {
  264.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  265.       return;
  266.     }
  267.     request.headers['Content-Type'] = 'application/octet-stream';
  268.   }
  270.   /**
  271.    * EZDRM FairPlay request.
  272.    *
  273.    * @param {shaka.net.NetworkingEngine.RequestType} type
  274.    * @param {shaka.extern.Request} request
  275.    * @param {shaka.extern.RequestContext=} context
  276.    * @export
  277.    */
  278.   static ezdrmFairPlayRequest(type, request, context) {
  279.     shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
  280.   }
  282.   /**
  283.    * Conax FairPlay request.
  284.    *
  285.    * @param {shaka.net.NetworkingEngine.RequestType} type
  286.    * @param {shaka.extern.Request} request
  287.    * @param {shaka.extern.RequestContext=} context
  288.    * @export
  289.    */
  290.   static conaxFairPlayRequest(type, request, context) {
  291.     shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
  292.   }
  294.   /**
  295.    * ExpressPlay FairPlay request.
  296.    *
  297.    * @param {shaka.net.NetworkingEngine.RequestType} type
  298.    * @param {shaka.extern.Request} request
  299.    * @param {shaka.extern.RequestContext=} context
  300.    * @export
  301.    */
  302.   static expressplayFairPlayRequest(type, request, context) {
  303.     shaka.util.FairPlayUtils.octetStreamFairPlayRequest_(type, request);
  304.   }
  306.   /**
  307.    * Common FairPlay response transform for some DRMs providers.
  308.    *
  309.    * @param {shaka.net.NetworkingEngine.RequestType} type
  310.    * @param {shaka.extern.Response} response
  311.    * @param {shaka.extern.RequestContext=} context
  312.    * @export
  313.    */
  314.   static commonFairPlayResponse(type, response, context) {
  315.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  316.       return;
  317.     }
  319.     // In Apple's docs, responses can be of the form:
  320.     //   '\n<ckc>base64encoded</ckc>\n' or 'base64encoded'
  321.     // We have also seen responses in JSON format from some of our partners.
  322.     // In all of these text-based formats, the CKC data is base64-encoded.
  324.     let responseText;
  325.     try {
  326.       // Convert it to text for further processing.
  327.       responseText = shaka.util.StringUtils.fromUTF8(response.data);
  328.     } catch (error) {
  329.       // Assume it's not a text format of any kind and leave it alone.
  330.       return;
  331.     }
  333.     let licenseProcessing = false;
  335.     // Trim whitespace.
  336.     responseText = responseText.trim();
  338.     // Look for <ckc> wrapper and remove it.
  339.     if (responseText.substr(0, 5) === '<ckc>' &&
  340.         responseText.substr(-6) === '</ckc>') {
  341.       responseText = responseText.slice(5, -6);
  342.       licenseProcessing = true;
  343.     }
  345.     // Look for a JSON wrapper and remove it.
  346.     try {
  347.       const responseObject = /** @type {!Object} */(JSON.parse(responseText));
  348.       if (responseObject['ckc']) {
  349.         responseText = responseObject['ckc'];
  350.         licenseProcessing = true;
  351.       }
  352.       if (responseObject['CkcMessage']) {
  353.         responseText = responseObject['CkcMessage'];
  354.         licenseProcessing = true;
  355.       }
  356.       if (responseObject['License']) {
  357.         responseText = responseObject['License'];
  358.         licenseProcessing = true;
  359.       }
  360.     } catch (err) {
  361.       // It wasn't JSON.  Fall through with other transformations.
  362.     }
  364.     if (licenseProcessing) {
  365.       // Decode the base64-encoded data into the format the browser expects.
  366.       // It's not clear why FairPlay license servers don't just serve this
  367.       // directly.
  368.       response.data = shaka.util.BufferUtils.toArrayBuffer(
  369.           shaka.util.Uint8ArrayUtils.fromBase64(responseText));
  370.     }
  371.   }
  372. };