Source: lib/drm/fairplay.js

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