unified-video-framework 1.4.412 → 1.4.414

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

@@ -0,0 +1,68 @@
+/**
+ * Base DRM System
+ * Abstract base class for all DRM system implementations
+ */
+
+import { ExtendedDRMConfig, LicenseRequest, LicenseResponse } from '../types/DRMTypes';
+import { LicenseRequestHandler } from '../utils/LicenseRequestHandler';
+
+export abstract class BaseDRM {
+  protected videoElement: HTMLVideoElement;
+  protected config: ExtendedDRMConfig;
+  protected debug: boolean;
+  protected licenseHandler: LicenseRequestHandler;
+  protected mediaKeys: MediaKeys | null = null;
+  protected keySession: MediaKeySession | null = null;
+
+  constructor(videoElement: HTMLVideoElement, config: ExtendedDRMConfig, debug: boolean = false) {
+    this.videoElement = videoElement;
+    this.config = config;
+    this.debug = debug;
+    this.licenseHandler = new LicenseRequestHandler(config, debug);
+  }
+
+  /**
+   * Initialize DRM system
+   */
+  abstract initialize(): Promise<void>;
+
+  /**
+   * Get key system identifier
+   */
+  abstract getKeySystem(): string;
+
+  /**
+   * Get HLS.js configuration
+   */
+  abstract getHLSConfig(): any;
+
+  /**
+   * Get dash.js protection data
+   */
+  abstract getDashProtectionData(): any;
+
+  /**
+   * Cleanup resources
+   */
+  async destroy(): Promise<void> {
+    if (this.keySession) {
+      try {
+        await this.keySession.close();
+      } catch (error) {
+        this.log('Error closing key session:', error);
+      }
+      this.keySession = null;
+    }
+
+    this.mediaKeys = null;
+  }
+
+  /**
+   * Debug logging
+   */
+  protected log(...args: any[]): void {
+    if (this.debug) {
+      console.log(`[${this.constructor.name}]`, ...args);
+    }
+  }
+}

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

@@ -0,0 +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 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);
+  }
+}

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

@@ -0,0 +1,132 @@
+/**
+ * PlayReady DRM Implementation
+ * Implements PlayReady DRM for Edge and IE
+ */
+
+import { BaseDRM } from './BaseDRM';
+import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
+import type { DRMType } from '@unified-video/core';
+import { DRMErrorHandler } from '../utils/DRMErrorHandler';
+import { DRMType as DRMTypeEnum } from '@unified-video/core';
+
+export class PlayReadyDRM extends BaseDRM {
+  async initialize(): Promise<void> {
+    this.log('Initializing PlayReady DRM...');
+
+    // PlayReady is primarily configured through HLS.js and dash.js
+    // Basic EME setup for validation
+    try {
+      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+        this.getKeySystem(),
+        this.getKeySystemConfiguration()
+      );
+
+      this.log('PlayReady key system access granted');
+      this.mediaKeys = await keySystemAccess.createMediaKeys();
+
+      // For HLS.js and dash.js, they handle the actual EME setup
+      // We just validate that the system is available
+
+    } catch (error: any) {
+      // Try fallback key system
+      try {
+        const fallbackKeySystem = KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1];
+        const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+          fallbackKeySystem,
+          this.getKeySystemConfiguration()
+        );
+
+        this.log('PlayReady fallback key system access granted');
+        this.mediaKeys = await keySystemAccess.createMediaKeys();
+      } catch (fallbackError: any) {
+        this.log('PlayReady initialization failed:', fallbackError);
+        throw DRMErrorHandler.createError(
+          DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED,
+          'Failed to access PlayReady DRM system',
+          true,
+          fallbackError
+        );
+      }
+    }
+
+    this.log('PlayReady DRM initialized');
+  }
+
+  getKeySystem(): string {
+    return KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][0];
+  }
+
+  getHLSConfig(): any {
+    this.log('Generating HLS.js config for PlayReady');
+
+    return {
+      emeEnabled: true,
+      drmSystems: {
+        [this.getKeySystem()]: {
+          licenseUrl: this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl,
+          customData: this.config.customData || this.config.playreadyOptions?.customData,
+        },
+        // Add fallback key system
+        [KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1]]: {
+          licenseUrl: this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl,
+          customData: this.config.customData || this.config.playreadyOptions?.customData,
+        },
+      },
+      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
+    };
+  }
+
+  getDashProtectionData(): any {
+    this.log('Generating dash.js protection data for PlayReady');
+
+    const licenseUrl = this.config.licenseUrl || this.config.playreadyOptions?.licenseUrl;
+
+    const protectionData: any = {
+      [this.getKeySystem()]: {
+        serverURL: licenseUrl,
+      },
+      // Add fallback key system
+      [KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1]]: {
+        serverURL: licenseUrl,
+      },
+    };
+
+    // Add custom headers if provided
+    if (this.config.headers && Object.keys(this.config.headers).length > 0) {
+      protectionData[this.getKeySystem()].httpRequestHeaders = this.config.headers;
+      protectionData[KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1]].httpRequestHeaders = this.config.headers;
+    }
+
+    // Add custom data if provided
+    const customData = this.config.customData || this.config.playreadyOptions?.customData;
+    if (customData) {
+      protectionData[this.getKeySystem()].customData = customData;
+      protectionData[KEY_SYSTEMS[DRMTypeEnum.PLAYREADY][1]].customData = customData;
+    }
+
+    return protectionData;
+  }
+
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['cenc'],
+      audioCapabilities: [{
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        robustness: 'SW_SECURE_CRYPTO',
+      }],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+        {
+          contentType: 'video/mp4; codecs="avc1.4d401f"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+      ],
+      distinctiveIdentifier: 'not-allowed',
+      persistentState: 'not-allowed',
+      sessionTypes: ['temporary'],
+    }];
+  }
+}

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

@@ -0,0 +1,106 @@
+/**
+ * Widevine DRM Implementation
+ * Implements Widevine DRM for Chrome, Firefox, Edge, Android
+ */
+
+import { BaseDRM } from './BaseDRM';
+import { KEY_SYSTEMS, DRMErrorCode } from '../types/DRMTypes';
+import type { DRMType } from '@unified-video/core';
+import { DRMErrorHandler } from '../utils/DRMErrorHandler';
+import { DRMType as DRMTypeEnum } from '@unified-video/core';
+
+export class WidevineDRM extends BaseDRM {
+  async initialize(): Promise<void> {
+    this.log('Initializing Widevine DRM...');
+
+    // Widevine is primarily configured through HLS.js and dash.js
+    // Basic EME setup for validation
+    try {
+      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+        this.getKeySystem(),
+        this.getKeySystemConfiguration()
+      );
+
+      this.log('Widevine key system access granted');
+      this.mediaKeys = await keySystemAccess.createMediaKeys();
+
+      // For HLS.js and dash.js, they handle the actual EME setup
+      // We just validate that the system is available
+
+    } catch (error: any) {
+      this.log('Widevine initialization failed:', error);
+      throw DRMErrorHandler.createError(
+        DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED,
+        'Failed to access Widevine DRM system',
+        true,
+        error
+      );
+    }
+
+    this.log('Widevine DRM initialized');
+  }
+
+  getKeySystem(): string {
+    return KEY_SYSTEMS[DRMTypeEnum.WIDEVINE][0];
+  }
+
+  getHLSConfig(): any {
+    this.log('Generating HLS.js config for Widevine');
+
+    return {
+      emeEnabled: true,
+      drmSystems: {
+        [this.getKeySystem()]: {
+          licenseUrl: this.config.licenseUrl || this.config.widevineOptions?.licenseUrl,
+          serverCertificate: this.config.widevineOptions?.serverCertificate,
+        },
+      },
+      requestMediaKeySystemAccessFunc: navigator.requestMediaKeySystemAccess.bind(navigator),
+    };
+  }
+
+  getDashProtectionData(): any {
+    this.log('Generating dash.js protection data for Widevine');
+
+    const protectionData: any = {
+      [this.getKeySystem()]: {
+        serverURL: this.config.licenseUrl || this.config.widevineOptions?.licenseUrl,
+      },
+    };
+
+    // Add custom headers if provided
+    if (this.config.headers && Object.keys(this.config.headers).length > 0) {
+      protectionData[this.getKeySystem()].httpRequestHeaders = this.config.headers;
+    }
+
+    // Add server certificate if provided
+    if (this.config.widevineOptions?.serverCertificate) {
+      protectionData[this.getKeySystem()].serverCertificate = this.config.widevineOptions.serverCertificate;
+    }
+
+    return protectionData;
+  }
+
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['cenc'],
+      audioCapabilities: [{
+        contentType: 'audio/mp4; codecs="mp4a.40.2"',
+        robustness: 'SW_SECURE_CRYPTO',
+      }],
+      videoCapabilities: [
+        {
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+        {
+          contentType: 'video/mp4; codecs="avc1.4d401f"',
+          robustness: 'SW_SECURE_CRYPTO',
+        },
+      ],
+      distinctiveIdentifier: 'not-allowed',
+      persistentState: 'not-allowed',
+      sessionTypes: ['temporary'],
+    }];
+  }
+}

package/packages/web/src/drm/types/BunnyNetTypes.ts

@@ -0,0 +1,35 @@
+/**
+ * Bunny.net DRM Type Definitions
+ * Type definitions specific to Bunny.net MediaCage DRM integration
+ */
+
+import type { DRMType } from '@unified-video/core';
+
+export interface BunnyNetConfig {
+  libraryId: string;
+  videoId: string;
+  drmType?: DRMType;
+}
+
+export interface BunnyNetEndpoints {
+  widevine: string;
+  fairplayCert: string;
+  fairplayLicense: string;
+  playready: string;
+}
+
+export const BUNNY_NET_BASE_URL = 'https://video.bunnycdn.com';
+
+export const BUNNY_NET_ENDPOINTS = {
+  WIDEVINE_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/WidevineLicense/${libraryId}/${videoId}`,
+
+  FAIRPLAY_CERTIFICATE: (libraryId: string) =>
+    `${BUNNY_NET_BASE_URL}/FairPlay/${libraryId}/certificate`,
+
+  FAIRPLAY_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/FairPlay/${libraryId}/license/?videoId=${videoId}`,
+
+  PLAYREADY_LICENSE: (libraryId: string, videoId: string) =>
+    `${BUNNY_NET_BASE_URL}/PlayReadyLicense/${libraryId}/${videoId}`,
+};