unified-video-framework 1.4.411 → 1.4.413

package/packages/web/src/drm/providers/BunnyNetProvider.ts

@@ -0,0 +1,170 @@
+/**
+ * Bunny.net DRM Provider
+ * Helper utilities for Bunny.net MediaCage DRM integration
+ */
+
+import { DRMType, DRMConfig } from '@unified-video/core';
+import { ExtendedDRMConfig } from '../types/DRMTypes';
+import { BunnyNetConfig, BUNNY_NET_ENDPOINTS } from '../types/BunnyNetTypes';
+
+export class BunnyNetProvider {
+  /**
+   * Generate complete DRM config from Bunny.net credentials
+   */
+  static createDRMConfig(config: BunnyNetConfig): ExtendedDRMConfig {
+    const { libraryId, videoId, drmType = DRMType.WIDEVINE } = config;
+
+    const drmConfig: ExtendedDRMConfig = {
+      type: drmType,
+      licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      provider: 'bunny',
+      libraryId,
+      videoId,
+    };
+
+    // Add FairPlay-specific settings
+    if (drmType === DRMType.FAIRPLAY) {
+      drmConfig.certificateUrl = this.getCertificateUrl(libraryId);
+      drmConfig.fairplayOptions = {
+        certificateUrl: this.getCertificateUrl(libraryId),
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    // Add Widevine-specific settings
+    if (drmType === DRMType.WIDEVINE) {
+      drmConfig.widevineOptions = {
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    // Add PlayReady-specific settings
+    if (drmType === DRMType.PLAYREADY) {
+      drmConfig.playreadyOptions = {
+        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
+      };
+    }
+
+    return drmConfig;
+  }
+
+  /**
+   * Get license URL for specific DRM type
+   */
+  static getLicenseUrl(drmType: DRMType, libraryId: string, videoId: string): string {
+    switch (drmType) {
+      case DRMType.WIDEVINE:
+        return BUNNY_NET_ENDPOINTS.WIDEVINE_LICENSE(libraryId, videoId);
+
+      case DRMType.FAIRPLAY:
+        return BUNNY_NET_ENDPOINTS.FAIRPLAY_LICENSE(libraryId, videoId);
+
+      case DRMType.PLAYREADY:
+        return BUNNY_NET_ENDPOINTS.PLAYREADY_LICENSE(libraryId, videoId);
+
+      default:
+        throw new Error(`Unsupported DRM type for Bunny.net: ${drmType}`);
+    }
+  }
+
+  /**
+   * Get certificate URL (FairPlay only)
+   */
+  static getCertificateUrl(libraryId: string): string {
+    return BUNNY_NET_ENDPOINTS.FAIRPLAY_CERTIFICATE(libraryId);
+  }
+
+  /**
+   * Validate Bunny.net DRM configuration
+   */
+  static validateConfig(config: BunnyNetConfig): { valid: boolean; error?: string } {
+    if (!config.libraryId || !config.videoId) {
+      return {
+        valid: false,
+        error: 'Bunny.net DRM requires libraryId and videoId',
+      };
+    }
+
+    if (!/^\d+$/.test(config.libraryId)) {
+      return {
+        valid: false,
+        error: 'libraryId must be a numeric string',
+      };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Auto-detect if a DRM config is for Bunny.net
+   */
+  static isBunnyNetConfig(config: DRMConfig): boolean {
+    return !!(
+      config.licenseUrl?.includes('bunnycdn.com') ||
+      config.certificateUrl?.includes('bunnycdn.com') ||
+      config.fairplayOptions?.licenseUrl?.includes('bunnycdn.com') ||
+      config.fairplayOptions?.certificateUrl?.includes('bunnycdn.com') ||
+      config.widevineOptions?.licenseUrl?.includes('bunnycdn.com') ||
+      config.playreadyOptions?.licenseUrl?.includes('bunnycdn.com')
+    );
+  }
+
+  /**
+   * Extract library and video IDs from Bunny.net URLs
+   */
+  static extractIdsFromUrl(url: string): { libraryId?: string; videoId?: string } {
+    if (!url) return {};
+
+    const widevineMatch = url.match(/WidevineLicense\/([^/]+)\/([^/?]+)/);
+    const fairplayLicenseMatch = url.match(/FairPlay\/([^/]+)\/license.*videoId=([^&]+)/);
+    const fairplayCertMatch = url.match(/FairPlay\/([^/]+)\/certificate/);
+    const playreadyMatch = url.match(/PlayReadyLicense\/([^/]+)\/([^/?]+)/);
+
+    if (widevineMatch) {
+      return { libraryId: widevineMatch[1], videoId: widevineMatch[2] };
+    }
+    if (fairplayLicenseMatch) {
+      return { libraryId: fairplayLicenseMatch[1], videoId: fairplayLicenseMatch[2] };
+    }
+    if (fairplayCertMatch) {
+      return { libraryId: fairplayCertMatch[1] };
+    }
+    if (playreadyMatch) {
+      return { libraryId: playreadyMatch[1], videoId: playreadyMatch[2] };
+    }
+
+    return {};
+  }
+
+  /**
+   * Create multi-DRM config for Bunny.net (auto-detects browser)
+   */
+  static createMultiDRMConfig(libraryId: string, videoId: string): ExtendedDRMConfig {
+    // Primary Widevine config with FairPlay fallback
+    const config: ExtendedDRMConfig = {
+      type: DRMType.WIDEVINE,
+      licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
+      provider: 'bunny',
+      libraryId,
+      videoId,
+
+      // Widevine options
+      widevineOptions: {
+        licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
+      },
+
+      // FairPlay options (for Safari fallback)
+      fairplayOptions: {
+        certificateUrl: this.getCertificateUrl(libraryId),
+        licenseUrl: this.getLicenseUrl(DRMType.FAIRPLAY, libraryId, videoId),
+      },
+
+      // PlayReady options (for Edge fallback)
+      playreadyOptions: {
+        licenseUrl: this.getLicenseUrl(DRMType.PLAYREADY, libraryId, videoId),
+      },
+    };
+
+    return config;
+  }
+}

package/packages/web/src/drm/providers/GenericProvider.ts

@@ -0,0 +1,148 @@
+/**
+ * Generic DRM Provider
+ * Helper utilities for generic DRM configurations
+ */
+
+import { DRMType, DRMConfig } from '@unified-video/core';
+import { ExtendedDRMConfig } from '../types/DRMTypes';
+
+export class GenericProvider {
+  /**
+   * Create generic DRM config with sensible defaults
+   */
+  static createDRMConfig(config: {
+    drmType: DRMType;
+    licenseUrl: string;
+    certificateUrl?: string;
+    headers?: Record<string, string>;
+    customData?: string;
+  }): ExtendedDRMConfig {
+    const drmConfig: ExtendedDRMConfig = {
+      type: config.drmType,
+      licenseUrl: config.licenseUrl,
+      certificateUrl: config.certificateUrl,
+      headers: config.headers,
+      customData: config.customData,
+      provider: 'generic',
+    };
+
+    // Add type-specific options
+    switch (config.drmType) {
+      case DRMType.FAIRPLAY:
+        if (config.certificateUrl) {
+          drmConfig.fairplayOptions = {
+            certificateUrl: config.certificateUrl,
+            licenseUrl: config.licenseUrl,
+          };
+        }
+        break;
+
+      case DRMType.WIDEVINE:
+        drmConfig.widevineOptions = {
+          licenseUrl: config.licenseUrl,
+        };
+        break;
+
+      case DRMType.PLAYREADY:
+        drmConfig.playreadyOptions = {
+          licenseUrl: config.licenseUrl,
+          customData: config.customData,
+        };
+        break;
+    }
+
+    return drmConfig;
+  }
+
+  /**
+   * Validate generic DRM configuration
+   */
+  static validateConfig(config: DRMConfig): { valid: boolean; error?: string } {
+    if (!config.type) {
+      return {
+        valid: false,
+        error: 'DRM type is required',
+      };
+    }
+
+    if (!config.licenseUrl) {
+      return {
+        valid: false,
+        error: 'License URL is required',
+      };
+    }
+
+    // FairPlay requires certificate URL
+    if (config.type === DRMType.FAIRPLAY) {
+      const certificateUrl = config.certificateUrl || config.fairplayOptions?.certificateUrl;
+      if (!certificateUrl) {
+        return {
+          valid: false,
+          error: 'FairPlay requires certificateUrl',
+        };
+      }
+    }
+
+    // Validate URL format
+    try {
+      new URL(config.licenseUrl);
+    } catch (e) {
+      return {
+        valid: false,
+        error: 'Invalid license URL format',
+      };
+    }
+
+    if (config.certificateUrl) {
+      try {
+        new URL(config.certificateUrl);
+      } catch (e) {
+        return {
+          valid: false,
+          error: 'Invalid certificate URL format',
+        };
+      }
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Create multi-DRM config for generic provider
+   */
+  static createMultiDRMConfig(config: {
+    widevine: { licenseUrl: string };
+    fairplay: { licenseUrl: string; certificateUrl: string };
+    playready?: { licenseUrl: string; customData?: string };
+    headers?: Record<string, string>;
+  }): ExtendedDRMConfig {
+    // Primary Widevine config with FairPlay and PlayReady fallbacks
+    const drmConfig: ExtendedDRMConfig = {
+      type: DRMType.WIDEVINE,
+      licenseUrl: config.widevine.licenseUrl,
+      provider: 'generic',
+      headers: config.headers,
+
+      // Widevine options
+      widevineOptions: {
+        licenseUrl: config.widevine.licenseUrl,
+      },
+
+      // FairPlay options
+      fairplayOptions: {
+        certificateUrl: config.fairplay.certificateUrl,
+        licenseUrl: config.fairplay.licenseUrl,
+      },
+
+      // PlayReady options (optional)
+      playreadyOptions: config.playready
+        ? {
+            licenseUrl: config.playready.licenseUrl,
+            customData: config.playready.customData,
+          }
+        : undefined,
+    };
+
+    return drmConfig;
+  }
+}

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,305 @@
+/**
+ * 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);
+  }
+}