rx-player 3.26.2 → 3.27.0-dev.20220317

package/src/core/decrypt/get_media_keys.ts

@@ -0,0 +1,145 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  ICustomMediaKeys,
+  ICustomMediaKeySystemAccess,
+} from "../../compat";
+import { EncryptedMediaError } from "../../errors";
+import log from "../../log";
+import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import { CancellationSignal } from "../../utils/task_canceller";
+import getMediaKeySystemAccess from "./find_key_system";
+import {
+  IKeySystemOption,
+  IMediaKeySessionStores,
+} from "./types";
+import LoadedSessionsStore from "./utils/loaded_sessions_store";
+import MediaKeysInfosStore from "./utils/media_keys_infos_store";
+import PersistentSessionsStore from "./utils/persistent_sessions_store";
+import ServerCertificateStore from "./utils/server_certificate_store";
+
+/**
+ * @throws {EncryptedMediaError}
+ * @param {Object} keySystemOptions
+ * @returns {Object|null}
+ */
+function createPersistentSessionsStorage(
+  keySystemOptions : IKeySystemOption
+) : PersistentSessionsStore|null {
+  if (keySystemOptions.persistentLicense !== true) {
+    return null;
+  }
+
+  const { licenseStorage } = keySystemOptions;
+  if (licenseStorage == null) {
+    throw new EncryptedMediaError("INVALID_KEY_SYSTEM",
+                                  "No license storage found for persistent license.");
+  }
+
+  log.debug("DRM: Set the given license storage");
+  return new PersistentSessionsStore(licenseStorage);
+}
+
+/** Object returned by `getMediaKeysInfos`. */
+export interface IMediaKeysInfos {
+  /** The MediaKeySystemAccess which allowed to create the MediaKeys instance. */
+  mediaKeySystemAccess: MediaKeySystemAccess |
+                        ICustomMediaKeySystemAccess;
+  /** The MediaKeys instance. */
+  mediaKeys : MediaKeys |
+              ICustomMediaKeys;
+  /** Stores allowing to create and retrieve MediaKeySessions. */
+  stores : IMediaKeySessionStores;
+  /** IKeySystemOption compatible to the created MediaKeys instance. */
+  options : IKeySystemOption;
+}
+
+/**
+ * Create a MediaKeys instance and associated structures (or just return the
+ * current ones if sufficient) based on a wanted configuration.
+ * @param {HTMLMediaElement} mediaElement - The HTMLMediaElement on which you
+ * will attach the MediaKeys instance.
+ * This Element is here only used to check if the current MediaKeys and
+ * MediaKeySystemAccess instances are sufficient
+ * @param {Array.<Object>} keySystemsConfigs - The key system configuration.
+ * Needed to ask the right MediaKeySystemAccess.
+ * @param {Object} cancelSignal - CancellationSignal allowing to cancel the
+ * creation of the MediaKeys instance while the task is still pending.
+ * @returns {Promise.<Object>}
+ */
+export default async function getMediaKeysInfos(
+  mediaElement : HTMLMediaElement,
+  keySystemsConfigs: IKeySystemOption[],
+  cancelSignal : CancellationSignal
+) : Promise<IMediaKeysInfos> {
+  const evt = await getMediaKeySystemAccess(mediaElement,
+                                            keySystemsConfigs,
+                                            cancelSignal);
+  if (cancelSignal.cancellationError !== null) {
+    throw cancelSignal.cancellationError;
+  }
+
+  const { options, mediaKeySystemAccess } = evt.value;
+  const currentState = MediaKeysInfosStore.getState(mediaElement);
+  const persistentSessionsStore = createPersistentSessionsStorage(options);
+
+  if (currentState !== null && evt.type === "reuse-media-key-system-access") {
+    const { mediaKeys, loadedSessionsStore } = currentState;
+
+    // We might just rely on the currently attached MediaKeys instance.
+    // First check if server certificate parameters are the same than in the
+    // current MediaKeys instance. If not, re-create MediaKeys from scratch.
+    if (ServerCertificateStore.hasOne(mediaKeys) === false ||
+        (!isNullOrUndefined(options.serverCertificate) &&
+         ServerCertificateStore.has(mediaKeys, options.serverCertificate)))
+    {
+      return { mediaKeys,
+               mediaKeySystemAccess,
+               stores: { loadedSessionsStore, persistentSessionsStore },
+               options };
+
+    }
+  }
+
+  const mediaKeys = await createMediaKeys(mediaKeySystemAccess);
+  log.info("DRM: MediaKeys created with success");
+  const loadedSessionsStore = new LoadedSessionsStore(mediaKeys);
+  return { mediaKeys,
+           mediaKeySystemAccess,
+           stores: { loadedSessionsStore, persistentSessionsStore },
+           options };
+}
+
+/**
+ * Create `MediaKeys` from the `MediaKeySystemAccess` given.
+ * Throws the right formatted error if it fails.
+ * @param {MediaKeySystemAccess} mediaKeySystemAccess
+ * @returns {Observable.<MediaKeys>}
+ */
+async function createMediaKeys(
+  mediaKeySystemAccess : MediaKeySystemAccess | ICustomMediaKeySystemAccess
+) : Promise<MediaKeys | ICustomMediaKeys> {
+  log.info("DRM: Calling createMediaKeys on the MediaKeySystemAccess");
+  try {
+    const mediaKeys = await mediaKeySystemAccess.createMediaKeys();
+    return mediaKeys;
+  } catch (error) {
+    const message = error instanceof Error ? error.message :
+                                             "Unknown error when creating MediaKeys.";
+    throw new EncryptedMediaError("CREATE_MEDIA_KEYS_ERROR", message);
+  }
+}

package/src/core/{eme → decrypt}/index.ts

@@ -19,17 +19,20 @@
  * It always should be imported through the `features` object.
  */
 
-import clearEMESession from "./clear_eme_session";
-import disposeEME from "./dispose_eme";
-import EMEManager from "./eme_manager";
+import clearOnStop from "./clear_on_stop";
+import ContentDecryptor, {
+  ContentDecryptorState,
+  IContentDecryptorEvent,
+} from "./content_decryptor";
+import disposeDecryptionResources from "./dispose_decryption_resources";
 import getCurrentKeySystem from "./get_current_key_system";
-import { IEMEManagerEvent } from "./types";
 export * from "./types";
 
-export default EMEManager;
+export default ContentDecryptor;
 export {
-  clearEMESession,
-  disposeEME,
+  clearOnStop,
+  ContentDecryptorState,
+  disposeDecryptionResources,
   getCurrentKeySystem,
-  IEMEManagerEvent,
+  IContentDecryptorEvent,
 };

package/src/core/decrypt/init_media_keys.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import log from "../../log";
+import { CancellationSignal } from "../../utils/task_canceller";
+import { disableMediaKeys } from "./attach_media_keys";
+import getMediaKeysInfos, {
+  IMediaKeysInfos,
+} from "./get_media_keys";
+import { IKeySystemOption } from "./types";
+
+/**
+ * Get media keys infos from key system configs then attach media keys to media element.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Array.<Object>} keySystemsConfigs
+ * @param {Object} cancelSignal
+ * @returns {Promise.<Object>}
+ */
+export default async function initMediaKeys(
+  mediaElement: HTMLMediaElement,
+  keySystemsConfigs: IKeySystemOption[],
+  cancelSignal: CancellationSignal
+): Promise<IMediaKeysInfos> {
+  const mediaKeysInfo =
+    await getMediaKeysInfos(mediaElement, keySystemsConfigs, cancelSignal);
+
+  const { mediaKeys } = mediaKeysInfo;
+  const shouldDisableOldMediaKeys =
+    mediaElement.mediaKeys !== null &&
+    mediaElement.mediaKeys !== undefined &&
+    mediaKeys !== mediaElement.mediaKeys;
+
+  if (shouldDisableOldMediaKeys) {
+    log.debug("DRM: Disabling old MediaKeys");
+    disableMediaKeys(mediaElement);
+  }
+  return mediaKeysInfo;
+}

package/src/core/{eme → decrypt}/session_events_listener.ts

@@ -21,15 +21,15 @@ import {
   defer as observableDefer,
   EMPTY,
   identity,
+  ignoreElements,
   map,
   merge as observableMerge,
   mergeMap,
   Observable,
   of as observableOf,
-  startWith,
   Subject,
-  takeUntil,
   tap,
+  takeUntil,
   timeout,
   TimeoutError,
 } from "rxjs";
@@ -49,20 +49,14 @@ import retryObsWithBackoff, {
   IBackoffOptions,
 } from "../../utils/rx-retry_with_backoff";
 import tryCatch from "../../utils/rx-try_catch";
-import checkKeyStatuses, {
-  IKeyStatusesCheckingOptions,
-} from "./check_key_statuses";
 import {
-  IInitializationDataInfo,
   IEMEWarningEvent,
-  IKeyMessageHandledEvent,
-  IKeyStatusChangeHandledEvent,
   IKeySystemOption,
-  IKeysUpdateEvent,
-  INoUpdateEvent,
-  ISessionMessageEvent,
-  ISessionUpdatedEvent,
+  ILicense,
 } from "./types";
+import checkKeyStatuses, {
+  IKeyStatusesCheckingOptions,
+} from "./utils/check_key_statuses";
 
 const { onKeyError$,
         onKeyMessage$,
@@ -91,27 +85,20 @@ export class BlacklistedSessionError extends Error {
  * @param {MediaKeySession} session - The MediaKeySession concerned.
  * @param {Object} keySystemOptions - The key system options.
  * @param {String} keySystem - The configuration keySystem used for deciphering
- * @param {Object} initializationData - The initialization data linked to that
- * session.
  * @returns {Observable}
  */
 export default function SessionEventsListener(
   session: MediaKeySession | ICustomMediaKeySession,
   keySystemOptions: IKeySystemOption,
-  keySystem: string,
-  initializationData : IInitializationDataInfo
-) : Observable<IEMEWarningEvent |
-               ISessionMessageEvent |
-               INoUpdateEvent |
-               IKeysUpdateEvent |
-               ISessionUpdatedEvent>
-{
-  log.info("EME: Binding session events", session.sessionId);
+  keySystem: string
+) : Observable<IEMEWarningEvent | IKeysUpdateEvent> {
+  log.info("DRM: Binding session events", session.sessionId);
   const sessionWarningSubject$ = new Subject<IEMEWarningEvent>();
   const { getLicenseConfig = {} } = keySystemOptions;
 
-  const keyErrors : Observable<never> = onKeyError$(session)
-    .pipe(map((error) => { throw new EncryptedMediaError("KEY_ERROR", error.type); }));
+  const keyErrors = onKeyError$(session).pipe(map((error) : never => {
+    throw new EncryptedMediaError("KEY_ERROR", error.type);
+  }));
 
   const keyStatusesChange$ = onKeyStatusesChange$(session)
     .pipe(mergeMap((keyStatusesEvent: Event) =>
@@ -121,7 +108,6 @@ export default function SessionEventsListener(
                                    keyStatusesEvent)));
 
   const keyMessages$ : Observable<IEMEWarningEvent |
-                                  ISessionMessageEvent |
                                   IKeyMessageHandledEvent > =
     onKeyMessage$(session).pipe(mergeMap((messageEvent: MediaKeyMessageEvent) => {
       const message = new Uint8Array(messageEvent.message);
@@ -129,7 +115,7 @@ export default function SessionEventsListener(
         messageEvent.messageType :
         "license-request";
 
-      log.info(`EME: Received message event, type ${messageType}`,
+      log.info(`DRM: Received message event, type ${messageType}`,
                session.sessionId,
                messageEvent);
       const getLicense$ = observableDefer(() => {
@@ -156,36 +142,32 @@ export default function SessionEventsListener(
           if (!isNullOrUndefined(err)) {
             const { fallbackOnLastTry } = (err as { fallbackOnLastTry? : boolean });
             if (fallbackOnLastTry === true) {
-              log.warn("EME: Last `getLicense` attempt failed. " +
+              log.warn("DRM: Last `getLicense` attempt failed. " +
                        "Blacklisting the current session.");
               throw new BlacklistedSessionError(formattedError);
             }
           }
           throw formattedError;
-        }),
-        startWith({ type: "session-message" as const,
-                    value: { messageType, initializationData } })
-      );
+        }));
     }));
 
   const sessionUpdates = observableMerge(keyMessages$, keyStatusesChange$)
     .pipe(concatMap((
       evt : IEMEWarningEvent |
-            ISessionMessageEvent |
             IKeyMessageHandledEvent |
             IKeysUpdateEvent |
             IKeyStatusChangeHandledEvent
     ) : Observable< IEMEWarningEvent |
-                    ISessionMessageEvent |
-                    INoUpdateEvent |
-                    ISessionUpdatedEvent |
                     IKeysUpdateEvent > => {
       switch (evt.type) {
         case "key-message-handled":
         case "key-status-change-handled":
-          return updateSessionWithMessage(session,
-                                          evt.value.license,
-                                          initializationData);
+          if (isNullOrUndefined(evt.value.license)) {
+            log.info("DRM: No message given, skipping session.update");
+            return EMPTY;
+          }
+
+          return updateSessionWithMessage(session, evt.value.license);
         default:
           return observableOf(evt);
       }
@@ -266,31 +248,26 @@ function formatGetLicenseError(error: unknown) : ICustomError {
  * Returns the right event depending on the action taken.
  * @param {MediaKeySession} session
  * @param {ArrayBuffer|TypedArray|null} message
- * @param {Object} initializationData
  * @returns {Observable}
  */
 function updateSessionWithMessage(
   session : MediaKeySession | ICustomMediaKeySession,
-  message : BufferSource | null,
-  initializationData : IInitializationDataInfo
-) : Observable<INoUpdateEvent | ISessionUpdatedEvent> {
-  if (isNullOrUndefined(message)) {
-    log.info("EME: No message given, skipping session.update");
-    return observableOf({ type: "no-update" as const,
-                          value: { initializationData } });
-  }
-
-  log.info("EME: Updating MediaKeySession with message");
+  message : BufferSource
+) : Observable<never> {
+  log.info("DRM: Updating MediaKeySession with message");
   return castToObservable(session.update(message)).pipe(
     catchError((error: unknown) => {
       const reason = error instanceof Error ? error.toString() :
                                               "`session.update` failed";
       throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
     }),
-    tap(() => { log.info("EME: MediaKeySession update succeeded."); }),
-    map(() => ({ type: "session-updated" as const,
-                 value: { session, license: message, initializationData } }))
-  );
+    tap(() => { log.info("DRM: MediaKeySession update succeeded."); }),
+    // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+    // first type parameter as `any` instead of the perfectly fine `unknown`,
+    // leading to linter issues, as it forbids the usage of `any`.
+    // This is why we're disabling the eslint rule.
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+    ignoreElements());
 }
 
 /**
@@ -305,7 +282,7 @@ function handleKeyStatusesChangeEvent(
   keySystem : string,
   keyStatusesEvent : Event
 ) : Observable<IKeyStatusChangeHandledEvent | IKeysUpdateEvent | IEMEWarningEvent> {
-  log.info("EME: keystatuseschange event received", session.sessionId);
+  log.info("DRM: keystatuseschange event received", session.sessionId);
   const callback$ = observableDefer(() => {
     return tryCatch(() => {
       if (typeof keySystemOptions.onKeyStatusesChange !== "function") {
@@ -356,3 +333,64 @@ function getLicenseBackoffOptions(
                                     value: formatGetLicenseError(error) }),
   };
 }
+
+/**
+ * Some key ids have updated their status.
+ *
+ * We put them in two different list:
+ *
+ *   - `blacklistedKeyIDs`: Those key ids won't be used for decryption and the
+ *     corresponding media it decrypts should not be pushed to the buffer
+ *     Note that a blacklisted key id can become whitelisted in the future.
+ *
+ *   - `whitelistedKeyIds`: Those key ids were found and their corresponding
+ *     keys are now being considered for decryption.
+ *     Note that a whitelisted key id can become blacklisted in the future.
+ *
+ * Note that each `IKeysUpdateEvent` is independent of any other.
+ *
+ * A new `IKeysUpdateEvent` does not completely replace a previously emitted
+ * one, as it can for example be linked to a whole other decryption session.
+ *
+ * However, if a key id is encountered in both an older and a newer
+ * `IKeysUpdateEvent`, only the older status should be considered.
+ */
+export interface IKeysUpdateEvent {
+  type: "keys-update";
+  value: IKeyUpdateValue;
+}
+
+/** Information on key ids linked to a MediaKeySession. */
+export interface IKeyUpdateValue {
+  /**
+   * The list of key ids that are blacklisted.
+   * As such, their corresponding keys won't be used by that session, despite
+   * the fact that they were part of the pushed license.
+   *
+   * Reasons for blacklisting a keys depend on options, but mainly involve unmet
+   * output restrictions and CDM internal errors linked to that key id.
+   */
+  blacklistedKeyIDs : Uint8Array[];
+  /*
+   * The list of key id linked to that session which are not blacklisted.
+   * Together with `blacklistedKeyIDs` it regroups all key ids linked to the
+   * session.
+   */
+  whitelistedKeyIds : Uint8Array[];
+}
+
+/** Emitted after the `onKeyStatusesChange` callback has been called. */
+interface IKeyStatusChangeHandledEvent {
+  type: "key-status-change-handled";
+  value: { session: MediaKeySession |
+                    ICustomMediaKeySession;
+           license: ILicense|null; };
+}
+
+/** Emitted after the `getLicense` callback has been called */
+interface IKeyMessageHandledEvent {
+  type: "key-message-handled";
+  value: { session: MediaKeySession |
+                    ICustomMediaKeySession;
+           license: ILicense|null; };
+}

package/src/core/decrypt/set_server_certificate.ts

@@ -0,0 +1,104 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ICustomMediaKeys } from "../../compat";
+import {
+  EncryptedMediaError,
+  ICustomError,
+  isKnownError,
+} from "../../errors";
+import log from "../../log";
+import ServerCertificateStore from "./utils/server_certificate_store";
+
+/**
+ * Call the setServerCertificate API with the given certificate.
+ * Resolves on success, rejects on failure.
+ *
+ * TODO Handle returned value?
+ * From the spec:
+ *   - setServerCertificate resolves with true if everything worked
+ *   - it resolves with false if the CDM does not support server
+ *     certificates.
+ *
+ * @param {MediaKeys} mediaKeys
+ * @param {ArrayBuffer} serverCertificate
+ * @returns {Promise}
+ */
+async function setServerCertificate(
+  mediaKeys : ICustomMediaKeys|MediaKeys,
+  serverCertificate : BufferSource
+) : Promise<unknown> {
+  try {
+    const res = await (mediaKeys as MediaKeys).setServerCertificate(serverCertificate);
+    // Note: Even if `setServerCertificate` technically should return a
+    // Promise.<boolean>, this is not technically always true.
+    // Thus we prefer to return unknown here.
+    return res;
+  } catch (error) {
+    log.warn("DRM: mediaKeys.setServerCertificate returned an error", error);
+    const reason = error instanceof Error ? error.toString() :
+                                            "`setServerCertificate` error";
+    throw new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR", reason);
+  }
+}
+
+/**
+ * Call the setCertificate API. If it fails just emit the error as warning
+ * and complete.
+ * @param {MediaKeys} mediaKeys
+ * @param {ArrayBuffer} serverCertificate
+ * @returns {Observable}
+ */
+export default async function trySettingServerCertificate(
+  mediaKeys : ICustomMediaKeys|MediaKeys,
+  serverCertificate : BufferSource
+) : Promise<{ type: "success"; value: unknown } |
+            { type: "already-has-one" } |
+            { type: "method-not-implemented" } |
+            { type: "error"; value: ICustomError }> {
+  if (ServerCertificateStore.hasOne(mediaKeys) === true) {
+    log.info("DRM: The MediaKeys already has a server certificate, skipping...");
+    return { type: "already-has-one" };
+  }
+  if (typeof mediaKeys.setServerCertificate !== "function") {
+    log.warn("DRM: Could not set the server certificate." +
+             " mediaKeys.setServerCertificate is not a function");
+    return { type: "method-not-implemented" };
+  }
+
+  log.info("DRM: Setting server certificate on the MediaKeys");
+  // Because of browser errors, or a user action that can lead to interrupting
+  // server certificate setting, we might be left in a status where we don't
+  // know if we attached the server certificate or not.
+  // Calling `prepare` allow to invalidate temporarily that status.
+  ServerCertificateStore.prepare(mediaKeys);
+  try {
+    const result = await setServerCertificate(mediaKeys, serverCertificate);
+    ServerCertificateStore.set(mediaKeys, serverCertificate);
+    return { type: "success", value: result };
+  } catch (error) {
+    const formattedErr = isKnownError(error) ?
+      error :
+      new EncryptedMediaError("LICENSE_SERVER_CERTIFICATE_ERROR",
+                              "Unknown error when setting the server certificate.");
+    return { type: "error" as const, value: formattedErr };
+  }
+}
+
+export {
+  trySettingServerCertificate,
+  setServerCertificate,
+};