unified-video-framework 1.4.411 → 1.4.412

package/packages/web/src/drm/DRMManager.ts

@@ -0,0 +1,99 @@
+/**
+ * DRM Manager
+ * Main orchestrator for web DRM - detects browser and initializes appropriate handler
+ */
+
+import { IDRMHandler, WebDRMConfig, DRMError } from './types/DRMTypes';
+import { WidevineDRMHandler } from './WidevineDRMHandler';
+import { FairPlayDRMHandler } from './FairPlayDRMHandler';
+
+export class DRMManager {
+  private handler: IDRMHandler | null = null;
+  private config: WebDRMConfig;
+
+  constructor(config: WebDRMConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Detect browser and return appropriate DRM handler
+   */
+  private detectDRMHandler(): IDRMHandler {
+    const userAgent = navigator.userAgent.toLowerCase();
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+
+    if (isSafari) {
+      console.log('[DRM] Detected Safari - using FairPlay DRM');
+      return new FairPlayDRMHandler(this.config);
+    } else {
+      console.log('[DRM] Detected non-Safari browser - using Widevine DRM');
+      return new WidevineDRMHandler(this.config);
+    }
+  }
+
+  /**
+   * Initialize DRM system
+   */
+  async initialize(): Promise<void> {
+    console.log('[DRM] Initializing DRM Manager...');
+
+    try {
+      // Detect and create appropriate handler
+      this.handler = this.detectDRMHandler();
+
+      // Check if DRM is supported
+      if (!this.handler.isSupported()) {
+        throw new DRMError(
+          'DRM is not supported in this browser',
+          'DRM_NOT_SUPPORTED'
+        );
+      }
+
+      // Initialize the handler
+      await this.handler.initialize();
+      console.log('[DRM] DRM Manager initialized successfully');
+
+    } catch (error) {
+      console.error('[DRM] Failed to initialize DRM Manager:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Setup DRM for video element and manifest
+   */
+  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
+    if (!this.handler) {
+      throw new DRMError('DRM Manager not initialized', 'DRM_NOT_INITIALIZED');
+    }
+
+    console.log('[DRM] Setting up DRM for video element');
+    await this.handler.setupDRM(videoElement, manifestUrl);
+  }
+
+  /**
+   * Check if DRM is currently active
+   */
+  isActive(): boolean {
+    return this.handler !== null;
+  }
+
+  /**
+   * Get current DRM handler type
+   */
+  getHandlerType(): 'widevine' | 'fairplay' | null {
+    if (!this.handler) return null;
+    return this.handler instanceof FairPlayDRMHandler ? 'fairplay' : 'widevine';
+  }
+
+  /**
+   * Cleanup DRM resources
+   */
+  destroy(): void {
+    if (this.handler) {
+      console.log('[DRM] Destroying DRM Manager');
+      this.handler.destroy();
+      this.handler = null;
+    }
+  }
+}

package/packages/web/src/drm/FairPlayDRMHandler.ts

@@ -0,0 +1,322 @@
+/**
+ * FairPlay DRM Handler
+ * Implements DRM for Safari using FairPlay Streaming
+ */
+
+import { IDRMHandler, WebDRMConfig, DRMError } from './types/DRMTypes';
+import { BunnyCDNDRMProvider } from './BunnyCDNDRMProvider';
+
+export class FairPlayDRMHandler implements IDRMHandler {
+  private config: WebDRMConfig;
+  private bunnyProvider: BunnyCDNDRMProvider | null = null;
+  private videoElement: HTMLVideoElement | null = null;
+  private certificateData: ArrayBuffer | null = null;
+  private pendingSessions: Set<any> = new Set();
+
+  constructor(config: WebDRMConfig) {
+    this.config = config;
+
+    if (config.provider === 'bunny' && config.bunny) {
+      this.bunnyProvider = new BunnyCDNDRMProvider(config.bunny);
+    }
+  }
+
+  /**
+   * Check if FairPlay is supported (Safari only)
+   */
+  isSupported(): boolean {
+    // FairPlay is only supported in Safari
+    const isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+    return !!(
+      isSafari &&
+      (window as any).WebKitMediaKeys &&
+      navigator.requestMediaKeySystemAccess
+    );
+  }
+
+  /**
+   * Initialize FairPlay DRM system
+   */
+  async initialize(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new DRMError(
+        'FairPlay DRM is not supported in this browser',
+        'FAIRPLAY_NOT_SUPPORTED'
+      );
+    }
+
+    console.log('[FairPlay] Initializing DRM system...');
+
+    try {
+      // Fetch FairPlay certificate
+      this.certificateData = await this.fetchCertificate();
+      console.log('[FairPlay] Certificate loaded:', this.certificateData.byteLength, 'bytes');
+
+    } catch (error) {
+      console.error('[FairPlay] Failed to initialize:', error);
+      throw new DRMError(
+        'Failed to initialize FairPlay DRM',
+        'FAIRPLAY_INIT_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Fetch FairPlay certificate from server
+   */
+  private async fetchCertificate(): Promise<ArrayBuffer> {
+    const certificateUrl = this.getCertificateUrl();
+    const headers = this.getCertificateHeaders();
+
+    console.log('[FairPlay] Fetching certificate from:', certificateUrl);
+
+    try {
+      const response = await fetch(certificateUrl, { headers });
+
+      if (!response.ok) {
+        throw new Error(`Certificate fetch failed: ${response.status} ${response.statusText}`);
+      }
+
+      const certificate = await response.arrayBuffer();
+      return certificate;
+
+    } catch (error) {
+      console.error('[FairPlay] Certificate fetch failed:', error);
+      throw new DRMError(
+        'Failed to fetch FairPlay certificate',
+        'CERTIFICATE_FETCH_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Get certificate URL based on provider
+   */
+  private getCertificateUrl(): string {
+    if (this.config.provider === 'bunny' && this.bunnyProvider) {
+      return this.bunnyProvider.getFairPlayCertificateUrl();
+    } else if (this.config.provider === 'generic' && this.config.generic) {
+      if (!this.config.generic.certificateUrl) {
+        throw new DRMError('FairPlay certificate URL is required', 'NO_CERTIFICATE_URL');
+      }
+      return this.config.generic.certificateUrl;
+    }
+    throw new DRMError('No certificate URL configured', 'NO_CERTIFICATE_URL');
+  }
+
+  /**
+   * Get headers for certificate request
+   */
+  private getCertificateHeaders(): Record<string, string> {
+    if (this.config.provider === 'generic' && this.config.generic?.certificateHeaders) {
+      return this.config.generic.certificateHeaders;
+    }
+    return {};
+  }
+
+  /**
+   * Setup DRM for video element
+   */
+  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
+    if (!this.certificateData) {
+      throw new DRMError('Certificate not loaded', 'CERTIFICATE_NOT_LOADED');
+    }
+
+    this.videoElement = videoElement;
+
+    // Listen for 'webkitneedkey' event (Safari specific)
+    videoElement.addEventListener('webkitneedkey', this.onWebkitNeedKey.bind(this) as any);
+
+    console.log('[FairPlay] DRM setup complete, waiting for key requests');
+  }
+
+  /**
+   * Handle 'webkitneedkey' event (Safari specific)
+   */
+  private async onWebkitNeedKey(event: any): Promise<void> {
+    console.log('[FairPlay] Key request event received');
+
+    try {
+      if (!this.certificateData || !this.videoElement) {
+        throw new DRMError('DRM not properly initialized', 'DRM_NOT_INITIALIZED');
+      }
+
+      // Extract content ID from init data
+      const contentId = this.extractContentId(event.initData);
+      const keySession = event.target.webkitKeys.createSession('video/mp4', event.initData);
+
+      if (!keySession) {
+        throw new DRMError('Failed to create key session', 'SESSION_CREATE_ERROR');
+      }
+
+      this.pendingSessions.add(keySession);
+
+      // Handle key request message
+      keySession.addEventListener('webkitkeymessage', async (messageEvent: any) => {
+        await this.onKeyMessage(keySession, messageEvent, contentId);
+      });
+
+      // Handle key added
+      keySession.addEventListener('webkitkeyadded', () => {
+        console.log('[FairPlay] Key added successfully');
+        this.pendingSessions.delete(keySession);
+      });
+
+      // Handle key error
+      keySession.addEventListener('webkitkeyerror', () => {
+        console.error('[FairPlay] Key error:', keySession.error);
+        this.pendingSessions.delete(keySession);
+      });
+
+    } catch (error) {
+      console.error('[FairPlay] Failed to handle key request:', error);
+      throw new DRMError(
+        'Failed to process FairPlay key request',
+        'KEY_REQUEST_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Extract content ID from init data
+   */
+  private extractContentId(initData: Uint8Array | ArrayBuffer): string {
+    // Convert init data to string to extract content ID
+    const initDataString = String.fromCharCode.apply(null, Array.from(new Uint8Array(initData)));
+
+    // Extract content ID from URI (format: skd://contentId)
+    const contentIdMatch = initDataString.match(/skd:\/\/([^"'\s]+)/);
+    if (contentIdMatch && contentIdMatch[1]) {
+      return contentIdMatch[1];
+    }
+
+    // Fallback: use entire init data as content ID
+    return initDataString;
+  }
+
+  /**
+   * Handle key message (license request)
+   */
+  private async onKeyMessage(
+    keySession: any,
+    event: any,
+    contentId: string
+  ): Promise<void> {
+    console.log('[FairPlay] Key message received, requesting license');
+
+    try {
+      // Prepare SPC (Server Playback Context) data
+      const spcData = event.message;
+
+      // Request CKC (Content Key Context) from license server
+      const ckcData = await this.requestLicense(spcData, contentId);
+
+      // Update key session with CKC
+      keySession.update(new Uint8Array(ckcData));
+      console.log('[FairPlay] License applied successfully');
+
+    } catch (error) {
+      console.error('[FairPlay] Failed to process license:', error);
+      throw new DRMError(
+        'Failed to process FairPlay license',
+        'LICENSE_PROCESS_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Request license from license server
+   */
+  private async requestLicense(spcData: Uint8Array, contentId: string): Promise<ArrayBuffer> {
+    const licenseUrl = this.getLicenseUrl(contentId);
+    const headers = await this.getLicenseHeaders();
+
+    console.log('[FairPlay] Requesting license from:', licenseUrl);
+
+    try {
+      const response = await fetch(licenseUrl, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          'Content-Type': 'application/octet-stream'
+        },
+        body: spcData
+      });
+
+      if (!response.ok) {
+        throw new Error(`License request failed: ${response.status} ${response.statusText}`);
+      }
+
+      const ckcData = await response.arrayBuffer();
+      console.log('[FairPlay] License received:', ckcData.byteLength, 'bytes');
+
+      return ckcData;
+
+    } catch (error) {
+      console.error('[FairPlay] License request failed:', error);
+      throw new DRMError(
+        'Failed to retrieve FairPlay license',
+        'LICENSE_FETCH_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Get license URL based on provider
+   */
+  private getLicenseUrl(contentId: string): string {
+    if (this.config.provider === 'bunny' && this.bunnyProvider) {
+      return this.bunnyProvider.getFairPlayLicenseUrl();
+    } else if (this.config.provider === 'generic' && this.config.generic) {
+      return this.config.generic.licenseUrl;
+    }
+    throw new DRMError('No license URL configured', 'NO_LICENSE_URL');
+  }
+
+  /**
+   * Get headers for license request
+   */
+  private async getLicenseHeaders(): Promise<Record<string, string>> {
+    if (this.config.provider === 'bunny' && this.bunnyProvider) {
+      return await this.bunnyProvider.getLicenseHeaders();
+    } else if (this.config.provider === 'generic' && this.config.generic) {
+      return this.config.generic.headers || {};
+    }
+    return {};
+  }
+
+  /**
+   * Handle license request (called by DRM manager)
+   */
+  async onLicenseRequest(licenseRequest: ArrayBuffer): Promise<ArrayBuffer> {
+    return await this.requestLicense(new Uint8Array(licenseRequest), '');
+  }
+
+  /**
+   * Cleanup resources
+   */
+  destroy(): void {
+    if (this.videoElement) {
+      this.videoElement.removeEventListener('webkitneedkey', this.onWebkitNeedKey.bind(this) as any);
+      this.videoElement = null;
+    }
+
+    // Close all pending sessions
+    this.pendingSessions.forEach(session => {
+      try {
+        session.close();
+      } catch (e) {
+        // Ignore errors during cleanup
+      }
+    });
+    this.pendingSessions.clear();
+
+    this.certificateData = null;
+    this.bunnyProvider = null;
+  }
+}

package/packages/web/src/drm/WidevineDRMHandler.ts

@@ -0,0 +1,246 @@
+/**
+ * Widevine DRM Handler
+ * Implements DRM for Chrome, Edge, Firefox using Encrypted Media Extensions (EME)
+ */
+
+import { IDRMHandler, WebDRMConfig, DRM_KEY_SYSTEMS, DRMError } from './types/DRMTypes';
+import { BunnyCDNDRMProvider } from './BunnyCDNDRMProvider';
+
+export class WidevineDRMHandler implements IDRMHandler {
+  private mediaKeys: MediaKeys | null = null;
+  private config: WebDRMConfig;
+  private bunnyProvider: BunnyCDNDRMProvider | null = null;
+  private videoElement: HTMLVideoElement | null = null;
+  private pendingLicenseRequests: Map<string, (license: ArrayBuffer) => void> = new Map();
+
+  constructor(config: WebDRMConfig) {
+    this.config = config;
+
+    if (config.provider === 'bunny' && config.bunny) {
+      this.bunnyProvider = new BunnyCDNDRMProvider(config.bunny);
+    }
+  }
+
+  /**
+   * Check if Widevine is supported in current browser
+   */
+  isSupported(): boolean {
+    return !!(
+      typeof navigator.requestMediaKeySystemAccess === 'function' &&
+      typeof window.MediaKeySystemAccess !== 'undefined'
+    );
+  }
+
+  /**
+   * Initialize Widevine DRM system
+   */
+  async initialize(): Promise<void> {
+    if (!this.isSupported()) {
+      throw new DRMError(
+        'Widevine DRM is not supported in this browser',
+        'WIDEVINE_NOT_SUPPORTED'
+      );
+    }
+
+    console.log('[Widevine] Initializing DRM system...');
+
+    try {
+      // Request access to Widevine key system
+      const keySystemAccess = await navigator.requestMediaKeySystemAccess(
+        DRM_KEY_SYSTEMS.WIDEVINE,
+        this.getKeySystemConfiguration()
+      );
+
+      // Create MediaKeys instance
+      this.mediaKeys = await keySystemAccess.createMediaKeys();
+
+      console.log('[Widevine] MediaKeys created successfully');
+    } catch (error) {
+      console.error('[Widevine] Failed to initialize:', error);
+      throw new DRMError(
+        'Failed to initialize Widevine DRM',
+        'WIDEVINE_INIT_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Get key system configuration for Widevine
+   */
+  private getKeySystemConfiguration(): MediaKeySystemConfiguration[] {
+    return [{
+      initDataTypes: ['cenc', 'webm'],
+      audioCapabilities: [
+        { contentType: 'audio/mp4; codecs="mp4a.40.2"' },
+        { contentType: 'audio/webm; codecs="opus"' }
+      ],
+      videoCapabilities: [
+        { contentType: 'video/mp4; codecs="avc1.42E01E"' },
+        { contentType: 'video/mp4; codecs="avc1.4D401E"' },
+        { contentType: 'video/mp4; codecs="avc1.640028"' },
+        { contentType: 'video/webm; codecs="vp9"' }
+      ],
+      distinctiveIdentifier: 'optional',
+      persistentState: 'optional',
+      sessionTypes: ['temporary']
+    }];
+  }
+
+  /**
+   * Setup DRM for video element
+   */
+  async setupDRM(videoElement: HTMLVideoElement, manifestUrl: string): Promise<void> {
+    if (!this.mediaKeys) {
+      throw new DRMError('MediaKeys not initialized', 'MEDIAKEYS_NOT_INITIALIZED');
+    }
+
+    this.videoElement = videoElement;
+
+    // Attach MediaKeys to video element
+    await videoElement.setMediaKeys(this.mediaKeys);
+    console.log('[Widevine] MediaKeys attached to video element');
+
+    // Listen for encrypted events
+    videoElement.addEventListener('encrypted', this.onEncrypted.bind(this));
+  }
+
+  /**
+   * Handle 'encrypted' event from video element
+   */
+  private async onEncrypted(event: MediaEncryptedEvent): Promise<void> {
+    console.log('[Widevine] Encrypted event received:', event.initDataType);
+
+    try {
+      if (!this.mediaKeys) {
+        throw new DRMError('MediaKeys not available', 'MEDIAKEYS_NOT_AVAILABLE');
+      }
+
+      // Create media key session
+      const session = this.mediaKeys.createSession();
+
+      // Listen for message event (license request)
+      session.addEventListener('message', async (messageEvent: MediaKeyMessageEvent) => {
+        await this.onMessage(session, messageEvent);
+      });
+
+      // Generate license request
+      await session.generateRequest(event.initDataType!, event.initData!);
+      console.log('[Widevine] License request generated');
+
+    } catch (error) {
+      console.error('[Widevine] Failed to handle encrypted event:', error);
+      throw new DRMError(
+        'Failed to process encrypted media',
+        'ENCRYPTED_EVENT_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Handle license request message
+   */
+  private async onMessage(
+    session: MediaKeySession,
+    event: MediaKeyMessageEvent
+  ): Promise<void> {
+    console.log('[Widevine] License request message:', event.messageType);
+
+    try {
+      // Get license from server
+      const license = await this.requestLicense(event.message);
+
+      // Update session with license
+      await session.update(license);
+      console.log('[Widevine] License applied successfully');
+
+    } catch (error) {
+      console.error('[Widevine] Failed to process license:', error);
+      throw new DRMError(
+        'Failed to process DRM license',
+        'LICENSE_REQUEST_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Request license from license server
+   */
+  private async requestLicense(challenge: ArrayBuffer): Promise<ArrayBuffer> {
+    const licenseUrl = this.getLicenseUrl();
+    const headers = await this.getLicenseHeaders();
+
+    console.log('[Widevine] Requesting license from:', licenseUrl);
+
+    try {
+      const response = await fetch(licenseUrl, {
+        method: 'POST',
+        headers,
+        body: challenge
+      });
+
+      if (!response.ok) {
+        throw new Error(`License request failed: ${response.status} ${response.statusText}`);
+      }
+
+      const license = await response.arrayBuffer();
+      console.log('[Widevine] License received:', license.byteLength, 'bytes');
+
+      return license;
+
+    } catch (error) {
+      console.error('[Widevine] License request failed:', error);
+      throw new DRMError(
+        'Failed to retrieve DRM license',
+        'LICENSE_FETCH_ERROR',
+        error
+      );
+    }
+  }
+
+  /**
+   * Get license URL based on provider
+   */
+  private getLicenseUrl(): string {
+    if (this.config.provider === 'bunny' && this.bunnyProvider) {
+      return this.bunnyProvider.getWidevineLicenseUrl();
+    } else if (this.config.provider === 'generic' && this.config.generic) {
+      return this.config.generic.licenseUrl;
+    }
+    throw new DRMError('No license URL configured', 'NO_LICENSE_URL');
+  }
+
+  /**
+   * Get headers for license request
+   */
+  private async getLicenseHeaders(): Promise<Record<string, string>> {
+    if (this.config.provider === 'bunny' && this.bunnyProvider) {
+      return await this.bunnyProvider.getLicenseHeaders();
+    } else if (this.config.provider === 'generic' && this.config.generic) {
+      return this.config.generic.headers || { 'Content-Type': 'application/octet-stream' };
+    }
+    return { 'Content-Type': 'application/octet-stream' };
+  }
+
+  /**
+   * Handle license request (called by DRM manager)
+   */
+  async onLicenseRequest(licenseRequest: ArrayBuffer): Promise<ArrayBuffer> {
+    return await this.requestLicense(licenseRequest);
+  }
+
+  /**
+   * Cleanup resources
+   */
+  destroy(): void {
+    if (this.videoElement) {
+      this.videoElement.removeEventListener('encrypted', this.onEncrypted.bind(this));
+      this.videoElement = null;
+    }
+    this.mediaKeys = null;
+    this.bunnyProvider = null;
+    this.pendingLicenseRequests.clear();
+  }
+}