unified-video-framework 1.4.413 → 1.4.414

package/packages/web/src/drm/systems/FairPlayDRM.ts

@@ -1,305 +1,306 @@
-/**
- * FairPlay DRM Implementation
- * Implements FairPlay DRM for Safari/iOS using WebKit EME APIs
- */
-
-import { BaseDRM } from './BaseDRM';
-import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
-import { DRMType } from '@unified-video/core';
-import { CertificateManager } from '../utils/CertificateManager';
-import { DRMErrorHandler } from '../utils/DRMErrorHandler';
-
-// WebKit-specific types
-declare global {
-  interface HTMLVideoElement {
-    webkitSetMediaKeys?: (mediaKeys: any) => void;
-    webkitKeys?: any;
-  }
-
-  interface Window {
-    WebKitMediaKeys?: any;
-  }
-}
-
-export class FairPlayDRM extends BaseDRM {
-  private certificateManager: CertificateManager;
-  private serverCertificate: ArrayBuffer | null = null;
-  private encryptedEventHandler: ((event: any) => Promise<void>) | null = null;
-  private needKeyEventHandler: ((event: any) => Promise<void>) | null = null;
-
-  constructor(videoElement: HTMLVideoElement, config: any, debug: boolean = false) {
-    super(videoElement, config, debug);
-    this.certificateManager = CertificateManager.getInstance();
-  }
-
-  async initialize(): Promise<void> {
-    this.log('Initializing FairPlay DRM...');
-
-    // Load server certificate
-    await this.loadCertificate();
-
-    // Set up encrypted event listeners
-    this.setupEncryptedEventListeners();
-
-    this.log('FairPlay DRM initialized');
-  }
-
-  getKeySystem(): string {
-    return KEY_SYSTEMS[DRMType.FAIRPLAY][0];
-  }
-
-  getHLSConfig(): any {
-    this.log('Generating HLS.js config for FairPlay');
-
-    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
-    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-
-    return {
-      emeEnabled: true,
-      drmSystems: {
-        [this.getKeySystem()]: {
-          licenseUrl: licenseUrl,
-          serverCertificateUrl: certificateUrl,
-          serverCertificate: this.serverCertificate,
-        },
-      },
-      requestMediaKeySystemAccessFunc: this.createMediaKeySystemAccess.bind(this),
-    };
-  }
-
-  getDashProtectionData(): any {
-    this.log('Generating dash.js protection data for FairPlay');
-
-    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-
-    return {
-      [this.getKeySystem()]: {
-        serverURL: licenseUrl,
-        serverCertificate: this.serverCertificate,
-      },
-    };
-  }
-
-  async destroy(): Promise<void> {
-    // Remove event listeners
-    if (this.encryptedEventHandler) {
-      this.videoElement.removeEventListener('encrypted', this.encryptedEventHandler as any);
-      this.encryptedEventHandler = null;
-    }
-
-    if (this.needKeyEventHandler) {
-      this.videoElement.removeEventListener('webkitneedkey', this.needKeyEventHandler as any);
-      this.needKeyEventHandler = null;
-    }
-
-    await super.destroy();
-  }
-
-  private async loadCertificate(): Promise<void> {
-    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
-
-    if (!certificateUrl) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.CONFIGURATION_ERROR,
-        'FairPlay certificate URL not provided',
-        true
-      );
-    }
-
-    this.log('Loading FairPlay certificate from:', certificateUrl);
-
-    // Check cache first
-    const cached = this.certificateManager.getCertificate(certificateUrl);
-    if (cached) {
-      this.log('Using cached certificate');
-      this.serverCertificate = cached;
-      return;
-    }
-
-    // Fetch certificate
-    try {
-      const response = await fetch(certificateUrl);
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-
-      this.serverCertificate = await response.arrayBuffer();
-
-      // Cache for future use
-      this.certificateManager.setCertificate(certificateUrl, this.serverCertificate);
-
-      this.log('FairPlay certificate loaded, size:', this.serverCertificate.byteLength, 'bytes');
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.CERTIFICATE_LOAD_FAILED,
-        `Failed to load FairPlay certificate: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private setupEncryptedEventListeners(): void {
-    // Modern EME encrypted event
-    this.encryptedEventHandler = this.onEncrypted.bind(this);
-    this.videoElement.addEventListener('encrypted', this.encryptedEventHandler as any);
-
-    // Legacy WebKit needkey event
-    this.needKeyEventHandler = this.onWebKitNeedKey.bind(this);
-    this.videoElement.addEventListener('webkitneedkey', this.needKeyEventHandler as any);
-
-    this.log('FairPlay encrypted event listeners set up');
-  }
-
-  private async onEncrypted(event: any): Promise<void> {
-    this.log('Encrypted event received:', event);
-
-    try {
-      const initData = event.initData;
-      const initDataType = event.initDataType;
-
-      await this.createSession(initData, initDataType);
-    } catch (error) {
-      this.log('Error handling encrypted event:', error);
-      throw error;
-    }
-  }
-
-  private async onWebKitNeedKey(event: any): Promise<void> {
-    this.log('WebKit needkey event received');
-
-    try {
-      const initData = event.initData;
-      await this.createSession(initData, 'skd');
-    } catch (error) {
-      this.log('Error handling webkitneedkey event:', error);
-      throw error;
-    }
-  }
-
-  private async createSession(initData: ArrayBuffer, initDataType: string): Promise<void> {
-    // Create media keys if not already created
-    if (!this.mediaKeys) {
-      try {
-        const keySystemAccess = await navigator.requestMediaKeySystemAccess(
-          this.getKeySystem(),
-          this.getKeySystemConfiguration()
-        );
-        this.mediaKeys = await keySystemAccess.createMediaKeys();
-        await this.videoElement.setMediaKeys(this.mediaKeys);
-
-        this.log('FairPlay MediaKeys created and set');
-      } catch (error: any) {
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.MEDIA_KEYS_CREATION_FAILED,
-          `Failed to create FairPlay MediaKeys: ${error.message}`,
-          true,
-          error
-        );
-      }
-    }
-
-    // Create session
-    try {
-      this.keySession = this.mediaKeys.createSession();
-      this.log('FairPlay session created');
-
-      // Handle license request
-      this.keySession.addEventListener('message', async (event: any) => {
-        await this.onMessage(event);
-      });
-
-      // Generate license request
-      await this.keySession.generateRequest(initDataType, initData);
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.SESSION_CREATION_FAILED,
-        `Failed to create FairPlay session: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private async onMessage(event: any): Promise<void> {
-    this.log('FairPlay message event:', event.messageType);
-
-    try {
-      const message = event.message;
-
-      // Convert message to base64 for FairPlay license request
-      const messageBase64 = this.arrayBufferToBase64(message);
-
-      const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
-      if (!licenseUrl) {
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.CONFIGURATION_ERROR,
-          'FairPlay license URL not provided',
-          true
-        );
-      }
-
-      // Request license from server
-      const license = await this.licenseHandler.requestLicense({
-        url: licenseUrl,
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/octet-stream',
-          ...this.config.headers,
-        },
-        body: message,
-        responseType: 'arraybuffer',
-      });
-
-      // Update session with license (CKC - Content Key Context)
-      await this.keySession!.update(license.license);
-
-      this.log('FairPlay license applied successfully');
-    } catch (error: any) {
-      throw DRMErrorHandler.createError(
-        DRMErrorCode.LICENSE_REQUEST_FAILED,
-        `Failed to process FairPlay license: ${error.message}`,
-        true,
-        error
-      );
-    }
-  }
-
-  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
-    return [{
-      initDataTypes: ['sinf', 'skd'],
-      audioCapabilities: [{
-        contentType: 'audio/mp4; codecs="mp4a.40.2"',
-      }],
-      videoCapabilities: [
-        {
-          contentType: 'application/vnd.apple.mpegurl',
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-        {
-          contentType: 'video/mp4; codecs="avc1.42E01E"',
-          robustness: 'SW_SECURE_CRYPTO',
-        },
-      ],
-      distinctiveIdentifier: 'not-allowed',
-      persistentState: 'not-allowed',
-      sessionTypes: ['temporary'],
-    }];
-  }
-
-  private async createMediaKeySystemAccess(): Promise<MediaKeySystemAccess> {
-    return navigator.requestMediaKeySystemAccess(
-      this.getKeySystem(),
-      this.getKeySystemConfiguration()
-    );
-  }
-
-  private arrayBufferToBase64(buffer: ArrayBuffer): string {
-    const bytes = new Uint8Array(buffer);
-    let binary = '';
-    for (let i = 0; i < bytes.byteLength; i++) {
-      binary += String.fromCharCode(bytes[i]);
-    }
-    return btoa(binary);
-  }
-}
+/**
+ * FairPlay DRM Implementation
+ * Implements FairPlay DRM for Safari/iOS using WebKit EME APIs
+ */
+
+import { BaseDRM } from './BaseDRM';
+import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
+import type { DRMType } from '@unified-video/core';
+import { CertificateManager } from '../utils/CertificateManager';
+import { DRMErrorHandler } from '../utils/DRMErrorHandler';
+import { DRMType as DRMTypeEnum } from '@unified-video/core';
+
+// WebKit-specific types
+declare global {
+  interface HTMLVideoElement {
+    webkitSetMediaKeys?: (mediaKeys: any) => void;
+    webkitKeys?: any;
+  }
+
+  interface Window {
+    WebKitMediaKeys?: any;
+  }
+}
+
+export class FairPlayDRM extends BaseDRM {
+  private certificateManager: CertificateManager;
+  private serverCertificate: ArrayBuffer | null = null;
+  private encryptedEventHandler: ((event: any) => Promise<void>) | null = null;
+  private needKeyEventHandler: ((event: any) => Promise<void>) | null = null;
+
+  constructor(videoElement: HTMLVideoElement, config: any, debug: boolean = false) {
+    super(videoElement, config, debug);
+    this.certificateManager = CertificateManager.getInstance();
+  }
+
+  async initialize(): Promise<void> {
+    this.log('Initializing FairPlay DRM...');
+
+    // Load server certificate
+    await this.loadCertificate();
+
+    // Set up encrypted event listeners
+    this.setupEncryptedEventListeners();
+
+    this.log('FairPlay DRM initialized');
+  }
+
+  getKeySystem(): string {
+    return KEY_SYSTEMS[DRMTypeEnum.FAIRPLAY][0];
+  }
+
+  getHLSConfig(): any {
+    this.log('Generating HLS.js config for FairPlay');
+
+    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
+    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
+
+    return {
+      emeEnabled: true,
+      drmSystems: {
+        [this.getKeySystem()]: {
+          licenseUrl: licenseUrl,
+          serverCertificateUrl: certificateUrl,
+          serverCertificate: this.serverCertificate,
+        },
+      },
+      requestMediaKeySystemAccessFunc: this.createMediaKeySystemAccess.bind(this),
+    };
+  }
+
+  getDashProtectionData(): any {
+    this.log('Generating dash.js protection data for FairPlay');
+
+    const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
+
+    return {
+      [this.getKeySystem()]: {
+        serverURL: licenseUrl,
+        serverCertificate: this.serverCertificate,
+      },
+    };
+  }
+
+  async destroy(): Promise<void> {
+    // Remove event listeners
+    if (this.encryptedEventHandler) {
+      this.videoElement.removeEventListener('encrypted', this.encryptedEventHandler as any);
+      this.encryptedEventHandler = null;
+    }
+
+    if (this.needKeyEventHandler) {
+      this.videoElement.removeEventListener('webkitneedkey', this.needKeyEventHandler as any);
+      this.needKeyEventHandler = null;
+    }
+
+    await super.destroy();
+  }
+
+  private async loadCertificate(): Promise<void> {
+    const certificateUrl = this.config.certificateUrl || this.config.fairplayOptions?.certificateUrl;
+
+    if (!certificateUrl) {
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.CONFIGURATION_ERROR,
+        'FairPlay certificate URL not provided',
+        true
+      );
+    }
+
+    this.log('Loading FairPlay certificate from:', certificateUrl);
+
+    // Check cache first
+    const cached = this.certificateManager.getCertificate(certificateUrl);
+    if (cached) {
+      this.log('Using cached certificate');
+      this.serverCertificate = cached;
+      return;
+    }
+
+    // Fetch certificate
+    try {
+      const response = await fetch(certificateUrl);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      this.serverCertificate = await response.arrayBuffer();
+
+      // Cache for future use
+      this.certificateManager.setCertificate(certificateUrl, this.serverCertificate);
+
+      this.log('FairPlay certificate loaded, size:', this.serverCertificate.byteLength, 'bytes');
+    } catch (error: any) {
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.CERTIFICATE_LOAD_FAILED,
+        `Failed to load FairPlay certificate: ${error.message}`,
+        true,
+        error
+      );
+    }
+  }
+
+  private setupEncryptedEventListeners(): void {
+    // Modern EME encrypted event
+    this.encryptedEventHandler = this.onEncrypted.bind(this);
+    this.videoElement.addEventListener('encrypted', this.encryptedEventHandler as any);
+
+    // Legacy WebKit needkey event
+    this.needKeyEventHandler = this.onWebKitNeedKey.bind(this);
+    this.videoElement.addEventListener('webkitneedkey', this.needKeyEventHandler as any);
+
+    this.log('FairPlay encrypted event listeners set up');
+  }
+
+  private async onEncrypted(event: any): Promise<void> {
+    this.log('Encrypted event received:', event);
+
+    try {
+      const initData = event.initData;
+      const initDataType = event.initDataType;
+
+      await this.createSession(initData, initDataType);
+    } catch (error) {
+      this.log('Error handling encrypted event:', error);
+      throw error;
+    }
+  }
+
+  private async onWebKitNeedKey(event: any): Promise<void> {
+    this.log('WebKit needkey event received');
+
+    try {
+      const initData = event.initData;
+      await this.createSession(initData, 'skd');
+    } catch (error) {
+      this.log('Error handling webkitneedkey event:', error);
+      throw error;
+    }
+  }
+
+  private async createSession(initData: ArrayBuffer, initDataType: string): Promise<void> {
+    // Create media keys if not already created
+    if (!this.mediaKeys) {
+      try {
+        const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+          this.getKeySystem(),
+          this.getKeySystemConfiguration()
+        );
+        this.mediaKeys = await keySystemAccess.createMediaKeys();
+        await this.videoElement.setMediaKeys(this.mediaKeys);
+
+        this.log('FairPlay MediaKeys created and set');
+      } catch (error: any) {
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.MEDIA_KEYS_CREATION_FAILED,
+          `Failed to create FairPlay MediaKeys: ${error.message}`,
+          true,
+          error
+        );
+      }
+    }
+
+    // Create session
+    try {
+      this.keySession = this.mediaKeys.createSession();
+      this.log('FairPlay session created');
+
+      // Handle license request
+      this.keySession.addEventListener('message', async (event: any) => {
+        await this.onMessage(event);
+      });
+
+      // Generate license request
+      await this.keySession.generateRequest(initDataType, initData);
+    } catch (error: any) {
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.SESSION_CREATION_FAILED,
+        `Failed to create FairPlay session: ${error.message}`,
+        true,
+        error
+      );
+    }
+  }
+
+  private async onMessage(event: any): Promise<void> {
+    this.log('FairPlay message event:', event.messageType);
+
+    try {
+      const message = event.message;
+
+      // Convert message to base64 for FairPlay license request
+      const messageBase64 = this.arrayBufferToBase64(message);
+
+      const licenseUrl = this.config.licenseUrl || this.config.fairplayOptions?.licenseUrl;
+      if (!licenseUrl) {
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.CONFIGURATION_ERROR,
+          'FairPlay license URL not provided',
+          true
+        );
+      }
+
+      // Request license from server
+      const license = await this.licenseHandler.requestLicense({
+        url: licenseUrl,
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/octet-stream',
+          ...this.config.headers,
+        },
+        body: message,
+        responseType: 'arraybuffer',
+      });
+
+      // Update session with license (CKC - Content Key Context)
+      await this.keySession!.update(license.license);
+
+      this.log('FairPlay license applied successfully');
+    } catch (error: any) {
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.LICENSE_REQUEST_FAILED,
+        `Failed to process FairPlay license: ${error.message}`,
+        true,
+        error
+      );
+    }
+  }
+
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['sinf', 'skd'],
+      audioCapabilities: [{
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+      }],
+      videoCapabilities: [
+        {
+          contentType: 'application/vnd.apple.mpegurl',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+        {
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+      ],
+      distinctiveIdentifier: 'not-allowed',
+      persistentState: 'not-allowed',
+      sessionTypes: ['temporary'],
+    }];
+  }
+
+  private async createMediaKeySystemAccess(): Promise<MediaKeySystemAccess> {
+    return navigator.requestMediaKeySystemAccess(
+      this.getKeySystem(),
+      this.getKeySystemConfiguration()
+    );
+  }
+
+  private arrayBufferToBase64(buffer: ArrayBuffer): string {
+    const bytes = new Uint8Array(buffer);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+  }
+}