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.    * @param {string} uriString
  66.    * @return {?string}
  67.    */
  68.   static defaultGetKeyId(uriString) {
  69.     const uri = new goog.Uri(uriString);
  70.     const contentId = uri.getDomain();
  71.     const keyId = contentId.replace(/-/g, '').toLowerCase();
  72.     if (keyId.length === 32 && /^[0-9a-f]+$/.test(keyId)) {
  73.       return keyId;
  74.     }
  75.     return null;
  76.   }
  78.   /**
  79.    * Transforms the init data buffer using the given data.  The format is:
  80.    *
  81.    * <pre>
  82.    * [4 bytes] initDataSize
  83.    * [initDataSize bytes] initData
  84.    * [4 bytes] contentIdSize
  85.    * [contentIdSize bytes] contentId
  86.    * [4 bytes] certSize
  87.    * [certSize bytes] cert
  88.    * </pre>
  89.    *
  90.    * @param {!BufferSource} initData
  91.    * @param {!BufferSource|string} contentId
  92.    * @param {?BufferSource} cert  The server certificate; this will throw if not
  93.    *   provided.
  94.    * @return {!Uint8Array}
  95.    * @export
  96.    */
  97.   static initDataTransform(initData, contentId, cert) {
  98.     if (!cert || !cert.byteLength) {
  99.       throw new shaka.util.Error(
  100.           shaka.util.Error.Severity.CRITICAL,
  101.           shaka.util.Error.Category.DRM,
  102.           shaka.util.Error.Code.SERVER_CERTIFICATE_REQUIRED);
  103.     }
  105.     // From that, we build a new init data to use in the session.  This is
  106.     // composed of several parts.  First, the init data as a UTF-16 sdk:// URL.
  107.     // Second, a 4-byte LE length followed by the content ID in UTF-16-LE.
  108.     // Third, a 4-byte LE length followed by the certificate.
  109.     /** @type {BufferSource} */
  110.     let contentIdArray;
  111.     if (typeof contentId == 'string') {
  112.       contentIdArray =
  113.           shaka.util.StringUtils.toUTF16(contentId, /* littleEndian= */ true);
  114.     } else {
  115.       contentIdArray = contentId;
  116.     }
  118.     // The init data we get is a UTF-8 string; convert that to a UTF-16 string.
  119.     const sdkUri = shaka.util.StringUtils.fromBytesAutoDetect(initData);
  120.     const utf16 =
  121.         shaka.util.StringUtils.toUTF16(sdkUri, /* littleEndian= */ true);
  123.     const rebuiltInitData = new Uint8Array(
  124.         12 + utf16.byteLength + contentIdArray.byteLength + cert.byteLength);
  126.     let offset = 0;
  127.     /** @param {BufferSource} array */
  128.     const append = (array) => {
  129.       rebuiltInitData.set(shaka.util.BufferUtils.toUint8(array), offset);
  130.       offset += array.byteLength;
  131.     };
  132.     /** @param {BufferSource} array */
  133.     const appendWithLength = (array) => {
  134.       const view = shaka.util.BufferUtils.toDataView(rebuiltInitData);
  135.       const value = array.byteLength;
  136.       view.setUint32(offset, value, /* littleEndian= */ true);
  137.       offset += 4;
  138.       append(array);
  139.     };
  141.     appendWithLength(utf16);
  142.     appendWithLength(contentIdArray);
  143.     appendWithLength(cert);
  145.     goog.asserts.assert(
  146.         offset == rebuiltInitData.length, 'Inconsistent init data length');
  147.     return rebuiltInitData;
  148.   }
  150.   /**
  151.    * Basic initDataTransform configuration.
  152.    *
  153.    * @param {!Uint8Array} initData
  154.    * @param {string} initDataType
  155.    * @param {?shaka.extern.DrmInfo} drmInfo
  156.    * @return {!Uint8Array}
  157.    * @private
  158.    */
  159.   static basicInitDataTransform_(initData, initDataType, drmInfo) {
  160.     if (initDataType !== 'skd') {
  161.       return initData;
  162.     }
  163.     const StringUtils = shaka.util.StringUtils;
  164.     const cert = drmInfo.serverCertificate;
  165.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  166.     const contentId = initDataAsString.split('skd://').pop();
  167.     return shaka.drm.FairPlay.initDataTransform(initData, contentId, cert);
  168.   }
  170.   /**
  171.    * Verimatrix 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 verimatrixInitDataTransform(initData, initDataType, drmInfo) {
  180.     return shaka.drm.FairPlay.basicInitDataTransform_(
  181.         initData, initDataType, drmInfo);
  182.   }
  184.   /**
  185.    * EZDRM initDataTransform configuration.
  186.    *
  187.    * @param {!Uint8Array} initData
  188.    * @param {string} initDataType
  189.    * @param {?shaka.extern.DrmInfo} drmInfo
  190.    * @return {!Uint8Array}
  191.    * @export
  192.    */
  193.   static ezdrmInitDataTransform(initData, initDataType, drmInfo) {
  194.     if (initDataType !== 'skd') {
  195.       return initData;
  196.     }
  197.     const StringUtils = shaka.util.StringUtils;
  198.     const cert = drmInfo.serverCertificate;
  199.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  200.     const contentId = initDataAsString.split(';').pop();
  201.     return shaka.drm.FairPlay.initDataTransform(initData, contentId, cert);
  202.   }
  204.   /**
  205.    * Conax initDataTransform configuration.
  206.    *
  207.    * @param {!Uint8Array} initData
  208.    * @param {string} initDataType
  209.    * @param {?shaka.extern.DrmInfo} drmInfo
  210.    * @return {!Uint8Array}
  211.    * @export
  212.    */
  213.   static conaxInitDataTransform(initData, initDataType, drmInfo) {
  214.     if (initDataType !== 'skd') {
  215.       return initData;
  216.     }
  217.     const StringUtils = shaka.util.StringUtils;
  218.     const cert = drmInfo.serverCertificate;
  219.     const initDataAsString = StringUtils.fromBytesAutoDetect(initData);
  220.     const skdValue = initDataAsString.split('skd://').pop().split('?').shift();
  221.     const stringToArray = (string) => {
  222.       // 2 bytes for each char
  223.       const buffer = new ArrayBuffer(string.length * 2);
  224.       const array = shaka.util.BufferUtils.toUint16(buffer);
  225.       for (let i = 0, strLen = string.length; i < strLen; i++) {
  226.         array[i] = string.charCodeAt(i);
  227.       }
  228.       return array;
  229.     };
  230.     const contentId = stringToArray(window.atob(skdValue));
  231.     return shaka.drm.FairPlay.initDataTransform(initData, contentId, cert);
  232.   }
  234.   /**
  235.    * ExpressPlay 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 expressplayInitDataTransform(initData, initDataType, drmInfo) {
  244.     return shaka.drm.FairPlay.basicInitDataTransform_(
  245.         initData, initDataType, drmInfo);
  246.   }
  248.   /**
  249.    * Mux initDataTransform configuration.
  250.    *
  251.    * @param {!Uint8Array} initData
  252.    * @param {string} initDataType
  253.    * @param {?shaka.extern.DrmInfo} drmInfo
  254.    * @return {!Uint8Array}
  255.    * @export
  256.    */
  257.   static muxInitDataTransform(initData, initDataType, drmInfo) {
  258.     return shaka.drm.FairPlay.basicInitDataTransform_(
  259.         initData, initDataType, drmInfo);
  260.   }
  262.   /**
  263.    * Verimatrix FairPlay request.
  264.    *
  265.    * @param {shaka.net.NetworkingEngine.RequestType} type
  266.    * @param {shaka.extern.Request} request
  267.    * @param {shaka.extern.RequestContext=} context
  268.    * @export
  269.    */
  270.   static verimatrixFairPlayRequest(type, request, context) {
  271.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  272.       return;
  273.     }
  275.     const drmInfo = request.drmInfo;
  276.     if (!drmInfo ||
  277.         !shaka.drm.DrmUtils.isFairPlayKeySystem(drmInfo.keySystem)) {
  278.       return;
  279.     }
  281.     const body = /** @type {!(ArrayBuffer|ArrayBufferView)} */(request.body);
  282.     const originalPayload = shaka.util.BufferUtils.toUint8(body);
  283.     const base64Payload = shaka.util.Uint8ArrayUtils.toBase64(originalPayload);
  284.     request.headers['Content-Type'] = 'application/x-www-form-urlencoded';
  285.     request.body = shaka.util.StringUtils.toUTF8('spc=' + base64Payload);
  286.   }
  288.   /**
  289.    * Set content-type to application/octet-stream in a FairPlay request.
  290.    *
  291.    * @param {shaka.net.NetworkingEngine.RequestType} type
  292.    * @param {shaka.extern.Request} request
  293.    * @param {shaka.extern.RequestContext=} context
  294.    * @private
  295.    */
  296.   static octetStreamFairPlayRequest_(type, request, context) {
  297.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  298.       return;
  299.     }
  301.     const drmInfo = request.drmInfo;
  302.     if (!drmInfo ||
  303.         !shaka.drm.DrmUtils.isFairPlayKeySystem(drmInfo.keySystem)) {
  304.       return;
  305.     }
  307.     request.headers['Content-Type'] = 'application/octet-stream';
  308.   }
  310.   /**
  311.    * EZDRM FairPlay request.
  312.    *
  313.    * @param {shaka.net.NetworkingEngine.RequestType} type
  314.    * @param {shaka.extern.Request} request
  315.    * @param {shaka.extern.RequestContext=} context
  316.    * @export
  317.    */
  318.   static ezdrmFairPlayRequest(type, request, context) {
  319.     shaka.drm.FairPlay.octetStreamFairPlayRequest_(type, request);
  320.   }
  322.   /**
  323.    * Conax FairPlay request.
  324.    *
  325.    * @param {shaka.net.NetworkingEngine.RequestType} type
  326.    * @param {shaka.extern.Request} request
  327.    * @param {shaka.extern.RequestContext=} context
  328.    * @export
  329.    */
  330.   static conaxFairPlayRequest(type, request, context) {
  331.     shaka.drm.FairPlay.octetStreamFairPlayRequest_(type, request);
  332.   }
  334.   /**
  335.    * ExpressPlay FairPlay request.
  336.    *
  337.    * @param {shaka.net.NetworkingEngine.RequestType} type
  338.    * @param {shaka.extern.Request} request
  339.    * @param {shaka.extern.RequestContext=} context
  340.    * @export
  341.    */
  342.   static expressplayFairPlayRequest(type, request, context) {
  343.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  344.       return;
  345.     }
  347.     const drmInfo = request.drmInfo;
  348.     if (!drmInfo ||
  349.         !shaka.drm.DrmUtils.isFairPlayKeySystem(drmInfo.keySystem)) {
  350.       return;
  351.     }
  353.     shaka.drm.FairPlay.octetStreamFairPlayRequest_(type, request);
  354.   }
  356.   /**
  357.    * Mux FairPlay request.
  358.    *
  359.    * @param {shaka.net.NetworkingEngine.RequestType} type
  360.    * @param {shaka.extern.Request} request
  361.    * @param {shaka.extern.RequestContext=} context
  362.    * @export
  363.    */
  364.   static muxFairPlayRequest(type, request, context) {
  365.     shaka.drm.FairPlay.octetStreamFairPlayRequest_(type, request);
  366.   }
  368.   /**
  369.    * Common FairPlay response transform for some DRMs providers.
  370.    *
  371.    * @param {shaka.net.NetworkingEngine.RequestType} type
  372.    * @param {shaka.extern.Response} response
  373.    * @param {shaka.extern.RequestContext=} context
  374.    * @export
  375.    */
  376.   static commonFairPlayResponse(type, response, context) {
  377.     if (type !== shaka.net.NetworkingEngine.RequestType.LICENSE) {
  378.       return;
  379.     }
  381.     const drmInfo = response.originalRequest.drmInfo;
  382.     if (!drmInfo ||
  383.         !shaka.drm.DrmUtils.isFairPlayKeySystem(drmInfo.keySystem)) {
  384.       return;
  385.     }
  387.     // In Apple's docs, responses can be of the form:
  388.     //   '\n<ckc>base64encoded</ckc>\n' or 'base64encoded'
  389.     // We have also seen responses in JSON format from some of our partners.
  390.     // In all of these text-based formats, the CKC data is base64-encoded.
  392.     let responseText;
  393.     try {
  394.       // Convert it to text for further processing.
  395.       responseText = shaka.util.StringUtils.fromUTF8(response.data);
  396.     } catch (error) {
  397.       // Assume it's not a text format of any kind and leave it alone.
  398.       return;
  399.     }
  401.     let licenseProcessing = false;
  403.     // Trim whitespace.
  404.     responseText = responseText.trim();
  406.     // Look for <ckc> wrapper and remove it.
  407.     if (responseText.substr(0, 5) === '<ckc>' &&
  408.         responseText.substr(-6) === '</ckc>') {
  409.       responseText = responseText.slice(5, -6);
  410.       licenseProcessing = true;
  411.     }
  413.     if (!licenseProcessing) {
  414.       // Look for a JSON wrapper and remove it.
  415.       try {
  416.         const responseObject = /** @type {!Object} */(JSON.parse(responseText));
  417.         if (responseObject['ckc']) {
  418.           responseText = responseObject['ckc'];
  419.           licenseProcessing = true;
  420.         }
  421.         if (responseObject['CkcMessage']) {
  422.           responseText = responseObject['CkcMessage'];
  423.           licenseProcessing = true;
  424.         }
  425.         if (responseObject['License']) {
  426.           responseText = responseObject['License'];
  427.           licenseProcessing = true;
  428.         }
  429.       } catch (err) {
  430.         // It wasn't JSON.  Fall through with other transformations.
  431.       }
  432.     }
  434.     if (licenseProcessing) {
  435.       // Decode the base64-encoded data into the format the browser expects.
  436.       // It's not clear why FairPlay license servers don't just serve this
  437.       // directly.
  438.       response.data = shaka.util.BufferUtils.toArrayBuffer(
  439.           shaka.util.Uint8ArrayUtils.fromBase64(responseText));
  440.     }
  441.   }
  442. };