Use Widevine KEYID or parse Playready when level keys are present

Update keyUriToKeyIdMap set after KEY_LOADING
Fixes video-dev#7541 video-dev#7542

Author: robwalch

api-extractor/report/hls.js.api.md

@@ -3359,7 +3359,9 @@ export class LevelKey implements DecryptData {
     // (undocumented)
     readonly encrypted: boolean;
     // (undocumented)
-    getDecryptData(sn: number | 'initSegment'): LevelKey | null;
+    getDecryptData(sn: number | 'initSegment', levelKeys?: {
+        [key: string]: LevelKey | undefined;
+    }): LevelKey | null;
     // (undocumented)
     readonly isCommonEncryption: boolean;
     // (undocumented)

src/loader/fragment.ts

@@ -273,7 +273,7 @@ export class Fragment extends BaseSegment {
           const levelKey = (this._decryptdata =
             this.levelkeys[keyFormats[0]] || null);
           if (levelKey) {
-            return levelKey.getDecryptData(this.sn);
+            return levelKey.getDecryptData(this.sn, this.levelkeys);
           }
         } else {
           // Multiple keys. key-loader to call Fragment.setKeyFormat based on selected key-system.
@@ -364,10 +364,11 @@ export class Fragment extends BaseSegment {
   }
 
   setKeyFormat(keyFormat: KeySystemFormats) {
-    if (this.levelkeys) {
-      const key = this.levelkeys[keyFormat];
+    const levelkeys = this.levelkeys;
+    if (levelkeys) {
+      const key = levelkeys[keyFormat];
       if (key && !this._decryptdata) {
-        this._decryptdata = key.getDecryptData(this.sn);
+        this._decryptdata = key.getDecryptData(this.sn, this.levelkeys);
       }
     }
   }

src/loader/level-key.ts

@@ -100,7 +100,10 @@ export class LevelKey implements DecryptData {
     return false;
   }
 
-  public getDecryptData(sn: number | 'initSegment'): LevelKey | null {
+  public getDecryptData(
+    sn: number | 'initSegment',
+    levelKeys?: { [key: string]: LevelKey | undefined },
+  ): LevelKey | null {
     if (!this.encrypted || !this.uri) {
       return null;
     }
@@ -135,10 +138,19 @@ export class LevelKey implements DecryptData {
       return this;
     }
 
-    if (this.pssh && this.keyId) {
-      return this;
+    if (this.keyId) {
+      // Handle case where key id is changed in KEY_LOADING event handler #7542#issuecomment-3305203929
+      const assignedKeyId = keyUriToKeyIdMap[this.uri];
+      if (assignedKeyId && !arrayValuesMatch(this.keyId, assignedKeyId)) {
+        LevelKey.setKeyIdForUri(this.uri, this.keyId);
+      }
+
+      if (this.pssh) {
+        return this;
+      }
     }
 
+    // Key bytes are signalled the KEYID attribute, typically only found on WideVine KEY tags
     // Initialize keyId if possible
     const keyBytes = convertDataUriToArrayBytes(this.uri);
     if (keyBytes) {
@@ -156,8 +168,11 @@ export class LevelKey implements DecryptData {
             }
           }
           if (!this.keyId) {
-            const offset = keyBytes.length - 22;
-            this.keyId = keyBytes.subarray(offset, offset + 16);
+            this.keyId = getKeyIdFromPlayReadyKey(levelKeys);
+            if (!this.keyId) {
+              const offset = keyBytes.length - 22;
+              this.keyId = keyBytes.subarray(offset, offset + 16);
+            }
           }
           break;
         case KeySystemFormats.PLAYREADY: {
@@ -189,13 +204,20 @@ export class LevelKey implements DecryptData {
 
     // Default behavior: assign a new keyId for each uri
     if (!this.keyId || this.keyId.byteLength !== 16) {
-      let keyId = keyUriToKeyIdMap[this.uri];
+      let keyId: Uint8Array<ArrayBuffer> | null | undefined =
+        keyUriToKeyIdMap[this.uri];
       if (!keyId) {
-        const val =
-          Object.keys(keyUriToKeyIdMap).length % Number.MAX_SAFE_INTEGER;
-        keyId = new Uint8Array(16);
-        const dv = new DataView(keyId.buffer, 12, 4); // Just set the last 4 bytes
-        dv.setUint32(0, val);
+        keyId = getKeyIdFromWidevineKey(levelKeys);
+        if (!keyId) {
+          keyId = getKeyIdFromPlayReadyKey(levelKeys);
+          if (!keyId) {
+            const val =
+              Object.keys(keyUriToKeyIdMap).length % Number.MAX_SAFE_INTEGER;
+            keyId = new Uint8Array(16);
+            const dv = new DataView(keyId.buffer, 12, 4); // Just set the last 4 bytes
+            dv.setUint32(0, val);
+          }
+        }
         LevelKey.setKeyIdForUri(this.uri, keyId);
       }
       this.keyId = keyId;
@@ -205,6 +227,29 @@ export class LevelKey implements DecryptData {
   }
 }
 
+function getKeyIdFromWidevineKey(
+  levelKeys: { [key: string]: LevelKey | undefined } | undefined,
+) {
+  const widevineKey = levelKeys?.[KeySystemFormats.WIDEVINE];
+  if (widevineKey) {
+    return widevineKey.keyId;
+  }
+  return null;
+}
+
+function getKeyIdFromPlayReadyKey(
+  levelKeys: { [key: string]: LevelKey | undefined } | undefined,
+) {
+  const playReadyKey = levelKeys?.[KeySystemFormats.PLAYREADY];
+  if (playReadyKey) {
+    const playReadyKeyBytes = convertDataUriToArrayBytes(playReadyKey.uri);
+    if (playReadyKeyBytes) {
+      return parsePlayReadyWRM(playReadyKeyBytes);
+    }
+  }
+  return null;
+}
+
 function createInitializationVector(segmentNumber: number) {
   const uint8View = new Uint8Array(16);
   for (let i = 12; i < 16; i++) {

tests/unit/loader/m3u8-parser.ts

@@ -4,6 +4,8 @@ import { LoadStats } from '../../../src/loader/load-stats';
 import M3U8Parser from '../../../src/loader/m3u8-parser';
 import { PlaylistLevelType } from '../../../src/types/loader';
 import { AttrList } from '../../../src/utils/attr-list';
+import { arrayToHex } from '../../../src/utils/hex';
+import { KeySystemFormats } from '../../../src/utils/mediakeys-helper';
 import type { Fragment, Part } from '../../../src/loader/fragment';
 import type { LevelKey } from '../../../src/loader/level-key';
 
@@ -2414,6 +2416,59 @@ media_1638278.m4s`;
       .which.has.members([result.fragments[2], result.fragments[6]]);
   });
 
+  it('parse KEYID other keys when available', function () {
+    const level = `#EXTM3U
+#EXT-X-VERSION:6
+#EXT-X-TARGETDURATION:6
+#EXT-X-KEY:METHOD=SAMPLE-AES,URI="skd://any",KEYFORMAT="com.apple.streamingkeydelivery",KEYFORMATVERSIONS="1"
+#EXT-X-KEY:METHOD=SAMPLE-AES,URI="data:text/plain;base64,AAAA",KEYID=0x50906c6be9179460c3d1a59f16ee9804,KEYFORMAT="urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed",KEYFORMATVERSIONS="1"
+#EXT-X-KEY:METHOD=SAMPLE-AES,URI="data:text/plain;charset=UTF-16;base64,UAIA",KEYFORMATVERSIONS="1",KEYFORMAT="com.microsoft.playready"
+#EXT-X-MAP:URI="init.mp4"
+#EXTINF:5.0,
+1.mp4`;
+    const result = M3U8Parser.parseLevelPlaylist(
+      level,
+      'http://foo.com/adaptive/test.m3u8',
+      0,
+      PlaylistLevelType.MAIN,
+      0,
+      null,
+    );
+    expect(result.playlistParsingError).to.be.null;
+    expect(result.fragments.length).to.equal(1);
+    expect(result.fragments[0].levelkeys, 'first segment has three keys')
+      .to.be.an('object')
+      .with.keys([
+        'com.apple.streamingkeydelivery',
+        'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
+        'com.microsoft.playready',
+      ]);
+    const fragment = result.fragments[0];
+    expect(result)
+      .to.have.property('encryptedFragments')
+      .which.is.an('array')
+      .which.has.members([fragment]);
+    expect(
+      fragment.decryptdata,
+      'decryptdata should by null until format is selected',
+    ).to.be.null;
+    fragment.setKeyFormat(KeySystemFormats.FAIRPLAY);
+    expect(fragment.decryptdata)
+      .to.include({
+        uri: 'skd://any',
+        method: 'SAMPLE-AES',
+        keyFormat: 'com.apple.streamingkeydelivery',
+        encrypted: true,
+        isCommonEncryption: true,
+        pssh: null,
+      })
+      .and.have.property('keyId')
+      .which.is.a('Uint8Array');
+    expect(arrayToHex(fragment.decryptdata!.keyId!)).to.equal(
+      '50906c6be9179460c3d1a59f16ee9804',
+    );
+  });
+
   it('parses manifest with EXT-X-SESSION-KEYs', function () {
     const manifest = `#EXTM3U
 #EXT-X-SESSION-DATA:DATA-ID="key",VALUE="value"