unified-video-framework 1.4.410 → 1.4.412

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

@@ -0,0 +1,104 @@
+/**
+ * Bunny CDN DRM Provider
+ * Handles Bunny CDN specific URL construction and token injection
+ */
+
+import { BunnyCDNDRMConfig, DRMToken, DRMError } from './types/DRMTypes';
+
+export class BunnyCDNDRMProvider {
+  constructor(private config: BunnyCDNDRMConfig) {}
+
+  /**
+   * Get FairPlay certificate URL for Bunny CDN
+   */
+  getFairPlayCertificateUrl(): string {
+    if (this.config.certificateUrl) {
+      return this.config.certificateUrl;
+    }
+    return `https://video.bunnycdn.com/FairPlay/${this.config.libraryId}/certificate`;
+  }
+
+  /**
+   * Get FairPlay license URL for Bunny CDN
+   */
+  getFairPlayLicenseUrl(): string {
+    if (this.config.licenseUrl) {
+      return this.config.licenseUrl;
+    }
+    return `https://video.bunnycdn.com/FairPlay/${this.config.libraryId}/license/?videoId=${this.config.videoId}`;
+  }
+
+  /**
+   * Get Widevine license URL for Bunny CDN
+   */
+  getWidevineLicenseUrl(): string {
+    if (this.config.licenseUrl) {
+      return this.config.licenseUrl;
+    }
+    // Bunny CDN Widevine license endpoint
+    return `https://video.bunnycdn.com/Widevine/${this.config.libraryId}/license/?videoId=${this.config.videoId}`;
+  }
+
+  /**
+   * Get HLS manifest URL with token
+   */
+  async getManifestUrl(): Promise<string> {
+    const baseUrl = `https://${this.config.pullZoneUrl}.b-cdn.net/${this.config.videoId}/playlist.m3u8`;
+    const token = await this.config.tokenProvider.getManifestToken();
+
+    if (!token) {
+      throw new DRMError('No manifest token available', 'MANIFEST_TOKEN_ERROR');
+    }
+
+    return this.injectToken(baseUrl, token);
+  }
+
+  /**
+   * Inject token into URL as query parameters
+   */
+  injectToken(url: string, token: DRMToken): string {
+    const urlObj = new URL(url);
+    urlObj.searchParams.set('token', token.token);
+    urlObj.searchParams.set('expires', token.expires.toString());
+    if (token.tokenVer) {
+      urlObj.searchParams.set('token_ver', token.tokenVer);
+    }
+    return urlObj.toString();
+  }
+
+  /**
+   * Get headers for license requests including token
+   */
+  async getLicenseHeaders(): Promise<Record<string, string>> {
+    const token = await this.config.tokenProvider.getLicenseToken();
+
+    if (!token) {
+      throw new DRMError('No license token available', 'LICENSE_TOKEN_ERROR');
+    }
+
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/octet-stream',
+      'X-Bunny-Token': token.token,
+      'X-Bunny-Expires': token.expires.toString(),
+    };
+
+    if (token.tokenVer) {
+      headers['X-Bunny-Token-Version'] = token.tokenVer;
+    }
+
+    if (this.config.enableReferrerProtection) {
+      headers['Referer'] = window.location.origin;
+    }
+
+    return headers;
+  }
+
+  /**
+   * Check if token needs renewal (within 5 minutes of expiry)
+   */
+  shouldRenewToken(token: DRMToken): boolean {
+    const nowSeconds = Math.floor(Date.now() / 1000);
+    const bufferSeconds = 300; // 5 minutes
+    return token.expires - nowSeconds < bufferSeconds;
+  }
+}

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;
+  }
+}