node_modules ignore

server/node_modules/hls.js/src/crypt/aes-crypto.ts

@@ -0,0 +1,13 @@
+export default class AESCrypto {
+  private subtle: SubtleCrypto;
+  private aesIV: Uint8Array;
+
+  constructor(subtle: SubtleCrypto, iv: Uint8Array) {
+    this.subtle = subtle;
+    this.aesIV = iv;
+  }
+
+  decrypt(data: ArrayBuffer, key: CryptoKey) {
+    return this.subtle.decrypt({ name: 'AES-CBC', iv: this.aesIV }, key, data);
+  }
+}

server/node_modules/hls.js/src/crypt/aes-decryptor.ts

@@ -0,0 +1,337 @@
+import { sliceUint8 } from '../utils/typed-array';
+
+// PKCS7
+export function removePadding(array: Uint8Array): Uint8Array {
+  const outputBytes = array.byteLength;
+  const paddingBytes =
+    outputBytes && new DataView(array.buffer).getUint8(outputBytes - 1);
+  if (paddingBytes) {
+    return sliceUint8(array, 0, outputBytes - paddingBytes);
+  }
+  return array;
+}
+
+export default class AESDecryptor {
+  private rcon: Array<number> = [
+    0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36,
+  ];
+  private subMix: Array<Uint32Array> = [
+    new Uint32Array(256),
+    new Uint32Array(256),
+    new Uint32Array(256),
+    new Uint32Array(256),
+  ];
+  private invSubMix: Array<Uint32Array> = [
+    new Uint32Array(256),
+    new Uint32Array(256),
+    new Uint32Array(256),
+    new Uint32Array(256),
+  ];
+  private sBox: Uint32Array = new Uint32Array(256);
+  private invSBox: Uint32Array = new Uint32Array(256);
+  private key: Uint32Array = new Uint32Array(0);
+
+  private ksRows: number = 0;
+  private keySize: number = 0;
+  private keySchedule!: Uint32Array;
+  private invKeySchedule!: Uint32Array;
+
+  constructor() {
+    this.initTable();
+  }
+
+  // Using view.getUint32() also swaps the byte order.
+  uint8ArrayToUint32Array_(arrayBuffer) {
+    const view = new DataView(arrayBuffer);
+    const newArray = new Uint32Array(4);
+    for (let i = 0; i < 4; i++) {
+      newArray[i] = view.getUint32(i * 4);
+    }
+
+    return newArray;
+  }
+
+  initTable() {
+    const sBox = this.sBox;
+    const invSBox = this.invSBox;
+    const subMix = this.subMix;
+    const subMix0 = subMix[0];
+    const subMix1 = subMix[1];
+    const subMix2 = subMix[2];
+    const subMix3 = subMix[3];
+    const invSubMix = this.invSubMix;
+    const invSubMix0 = invSubMix[0];
+    const invSubMix1 = invSubMix[1];
+    const invSubMix2 = invSubMix[2];
+    const invSubMix3 = invSubMix[3];
+
+    const d = new Uint32Array(256);
+    let x = 0;
+    let xi = 0;
+    let i = 0;
+    for (i = 0; i < 256; i++) {
+      if (i < 128) {
+        d[i] = i << 1;
+      } else {
+        d[i] = (i << 1) ^ 0x11b;
+      }
+    }
+
+    for (i = 0; i < 256; i++) {
+      let sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
+      sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
+      sBox[x] = sx;
+      invSBox[sx] = x;
+
+      // Compute multiplication
+      const x2 = d[x];
+      const x4 = d[x2];
+      const x8 = d[x4];
+
+      // Compute sub/invSub bytes, mix columns tables
+      let t = (d[sx] * 0x101) ^ (sx * 0x1010100);
+      subMix0[x] = (t << 24) | (t >>> 8);
+      subMix1[x] = (t << 16) | (t >>> 16);
+      subMix2[x] = (t << 8) | (t >>> 24);
+      subMix3[x] = t;
+
+      // Compute inv sub bytes, inv mix columns tables
+      t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
+      invSubMix0[sx] = (t << 24) | (t >>> 8);
+      invSubMix1[sx] = (t << 16) | (t >>> 16);
+      invSubMix2[sx] = (t << 8) | (t >>> 24);
+      invSubMix3[sx] = t;
+
+      // Compute next counter
+      if (!x) {
+        x = xi = 1;
+      } else {
+        x = x2 ^ d[d[d[x8 ^ x2]]];
+        xi ^= d[d[xi]];
+      }
+    }
+  }
+
+  expandKey(keyBuffer: ArrayBuffer) {
+    // convert keyBuffer to Uint32Array
+    const key = this.uint8ArrayToUint32Array_(keyBuffer);
+    let sameKey = true;
+    let offset = 0;
+
+    while (offset < key.length && sameKey) {
+      sameKey = key[offset] === this.key[offset];
+      offset++;
+    }
+
+    if (sameKey) {
+      return;
+    }
+
+    this.key = key;
+    const keySize = (this.keySize = key.length);
+
+    if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
+      throw new Error('Invalid aes key size=' + keySize);
+    }
+
+    const ksRows = (this.ksRows = (keySize + 6 + 1) * 4);
+    let ksRow;
+    let invKsRow;
+
+    const keySchedule = (this.keySchedule = new Uint32Array(ksRows));
+    const invKeySchedule = (this.invKeySchedule = new Uint32Array(ksRows));
+    const sbox = this.sBox;
+    const rcon = this.rcon;
+
+    const invSubMix = this.invSubMix;
+    const invSubMix0 = invSubMix[0];
+    const invSubMix1 = invSubMix[1];
+    const invSubMix2 = invSubMix[2];
+    const invSubMix3 = invSubMix[3];
+
+    let prev;
+    let t;
+
+    for (ksRow = 0; ksRow < ksRows; ksRow++) {
+      if (ksRow < keySize) {
+        prev = keySchedule[ksRow] = key[ksRow];
+        continue;
+      }
+      t = prev;
+
+      if (ksRow % keySize === 0) {
+        // Rot word
+        t = (t << 8) | (t >>> 24);
+
+        // Sub word
+        t =
+          (sbox[t >>> 24] << 24) |
+          (sbox[(t >>> 16) & 0xff] << 16) |
+          (sbox[(t >>> 8) & 0xff] << 8) |
+          sbox[t & 0xff];
+
+        // Mix Rcon
+        t ^= rcon[(ksRow / keySize) | 0] << 24;
+      } else if (keySize > 6 && ksRow % keySize === 4) {
+        // Sub word
+        t =
+          (sbox[t >>> 24] << 24) |
+          (sbox[(t >>> 16) & 0xff] << 16) |
+          (sbox[(t >>> 8) & 0xff] << 8) |
+          sbox[t & 0xff];
+      }
+
+      keySchedule[ksRow] = prev = (keySchedule[ksRow - keySize] ^ t) >>> 0;
+    }
+
+    for (invKsRow = 0; invKsRow < ksRows; invKsRow++) {
+      ksRow = ksRows - invKsRow;
+      if (invKsRow & 3) {
+        t = keySchedule[ksRow];
+      } else {
+        t = keySchedule[ksRow - 4];
+      }
+
+      if (invKsRow < 4 || ksRow <= 4) {
+        invKeySchedule[invKsRow] = t;
+      } else {
+        invKeySchedule[invKsRow] =
+          invSubMix0[sbox[t >>> 24]] ^
+          invSubMix1[sbox[(t >>> 16) & 0xff]] ^
+          invSubMix2[sbox[(t >>> 8) & 0xff]] ^
+          invSubMix3[sbox[t & 0xff]];
+      }
+
+      invKeySchedule[invKsRow] = invKeySchedule[invKsRow] >>> 0;
+    }
+  }
+
+  // Adding this as a method greatly improves performance.
+  networkToHostOrderSwap(word) {
+    return (
+      (word << 24) |
+      ((word & 0xff00) << 8) |
+      ((word & 0xff0000) >> 8) |
+      (word >>> 24)
+    );
+  }
+
+  decrypt(inputArrayBuffer: ArrayBuffer, offset: number, aesIV: ArrayBuffer) {
+    const nRounds = this.keySize + 6;
+    const invKeySchedule = this.invKeySchedule;
+    const invSBOX = this.invSBox;
+
+    const invSubMix = this.invSubMix;
+    const invSubMix0 = invSubMix[0];
+    const invSubMix1 = invSubMix[1];
+    const invSubMix2 = invSubMix[2];
+    const invSubMix3 = invSubMix[3];
+
+    const initVector = this.uint8ArrayToUint32Array_(aesIV);
+    let initVector0 = initVector[0];
+    let initVector1 = initVector[1];
+    let initVector2 = initVector[2];
+    let initVector3 = initVector[3];
+
+    const inputInt32 = new Int32Array(inputArrayBuffer);
+    const outputInt32 = new Int32Array(inputInt32.length);
+
+    let t0, t1, t2, t3;
+    let s0, s1, s2, s3;
+    let inputWords0, inputWords1, inputWords2, inputWords3;
+
+    let ksRow, i;
+    const swapWord = this.networkToHostOrderSwap;
+
+    while (offset < inputInt32.length) {
+      inputWords0 = swapWord(inputInt32[offset]);
+      inputWords1 = swapWord(inputInt32[offset + 1]);
+      inputWords2 = swapWord(inputInt32[offset + 2]);
+      inputWords3 = swapWord(inputInt32[offset + 3]);
+
+      s0 = inputWords0 ^ invKeySchedule[0];
+      s1 = inputWords3 ^ invKeySchedule[1];
+      s2 = inputWords2 ^ invKeySchedule[2];
+      s3 = inputWords1 ^ invKeySchedule[3];
+
+      ksRow = 4;
+
+      // Iterate through the rounds of decryption
+      for (i = 1; i < nRounds; i++) {
+        t0 =
+          invSubMix0[s0 >>> 24] ^
+          invSubMix1[(s1 >> 16) & 0xff] ^
+          invSubMix2[(s2 >> 8) & 0xff] ^
+          invSubMix3[s3 & 0xff] ^
+          invKeySchedule[ksRow];
+        t1 =
+          invSubMix0[s1 >>> 24] ^
+          invSubMix1[(s2 >> 16) & 0xff] ^
+          invSubMix2[(s3 >> 8) & 0xff] ^
+          invSubMix3[s0 & 0xff] ^
+          invKeySchedule[ksRow + 1];
+        t2 =
+          invSubMix0[s2 >>> 24] ^
+          invSubMix1[(s3 >> 16) & 0xff] ^
+          invSubMix2[(s0 >> 8) & 0xff] ^
+          invSubMix3[s1 & 0xff] ^
+          invKeySchedule[ksRow + 2];
+        t3 =
+          invSubMix0[s3 >>> 24] ^
+          invSubMix1[(s0 >> 16) & 0xff] ^
+          invSubMix2[(s1 >> 8) & 0xff] ^
+          invSubMix3[s2 & 0xff] ^
+          invKeySchedule[ksRow + 3];
+        // Update state
+        s0 = t0;
+        s1 = t1;
+        s2 = t2;
+        s3 = t3;
+
+        ksRow = ksRow + 4;
+      }
+
+      // Shift rows, sub bytes, add round key
+      t0 =
+        (invSBOX[s0 >>> 24] << 24) ^
+        (invSBOX[(s1 >> 16) & 0xff] << 16) ^
+        (invSBOX[(s2 >> 8) & 0xff] << 8) ^
+        invSBOX[s3 & 0xff] ^
+        invKeySchedule[ksRow];
+      t1 =
+        (invSBOX[s1 >>> 24] << 24) ^
+        (invSBOX[(s2 >> 16) & 0xff] << 16) ^
+        (invSBOX[(s3 >> 8) & 0xff] << 8) ^
+        invSBOX[s0 & 0xff] ^
+        invKeySchedule[ksRow + 1];
+      t2 =
+        (invSBOX[s2 >>> 24] << 24) ^
+        (invSBOX[(s3 >> 16) & 0xff] << 16) ^
+        (invSBOX[(s0 >> 8) & 0xff] << 8) ^
+        invSBOX[s1 & 0xff] ^
+        invKeySchedule[ksRow + 2];
+      t3 =
+        (invSBOX[s3 >>> 24] << 24) ^
+        (invSBOX[(s0 >> 16) & 0xff] << 16) ^
+        (invSBOX[(s1 >> 8) & 0xff] << 8) ^
+        invSBOX[s2 & 0xff] ^
+        invKeySchedule[ksRow + 3];
+
+      // Write
+      outputInt32[offset] = swapWord(t0 ^ initVector0);
+      outputInt32[offset + 1] = swapWord(t3 ^ initVector1);
+      outputInt32[offset + 2] = swapWord(t2 ^ initVector2);
+      outputInt32[offset + 3] = swapWord(t1 ^ initVector3);
+
+      // reset initVector to last 4 unsigned int
+      initVector0 = inputWords0;
+      initVector1 = inputWords1;
+      initVector2 = inputWords2;
+      initVector3 = inputWords3;
+
+      offset = offset + 4;
+    }
+
+    return outputInt32.buffer;
+  }
+}

server/node_modules/hls.js/src/crypt/decrypter.ts

@@ -0,0 +1,209 @@
+import AESCrypto from './aes-crypto';
+import FastAESKey from './fast-aes-key';
+import AESDecryptor, { removePadding } from './aes-decryptor';
+import { logger } from '../utils/logger';
+import { appendUint8Array } from '../utils/mp4-tools';
+import { sliceUint8 } from '../utils/typed-array';
+import type { HlsConfig } from '../config';
+
+const CHUNK_SIZE = 16; // 16 bytes, 128 bits
+
+export default class Decrypter {
+  private logEnabled: boolean = true;
+  private removePKCS7Padding: boolean;
+  private subtle: SubtleCrypto | null = null;
+  private softwareDecrypter: AESDecryptor | null = null;
+  private key: ArrayBuffer | null = null;
+  private fastAesKey: FastAESKey | null = null;
+  private remainderData: Uint8Array | null = null;
+  private currentIV: ArrayBuffer | null = null;
+  private currentResult: ArrayBuffer | null = null;
+  private useSoftware: boolean;
+
+  constructor(config: HlsConfig, { removePKCS7Padding = true } = {}) {
+    this.useSoftware = config.enableSoftwareAES;
+    this.removePKCS7Padding = removePKCS7Padding;
+    // built in decryptor expects PKCS7 padding
+    if (removePKCS7Padding) {
+      try {
+        const browserCrypto = self.crypto;
+        if (browserCrypto) {
+          this.subtle =
+            browserCrypto.subtle ||
+            ((browserCrypto as any).webkitSubtle as SubtleCrypto);
+        }
+      } catch (e) {
+        /* no-op */
+      }
+    }
+
+    this.useSoftware = !this.subtle;
+  }
+
+  destroy() {
+    this.subtle = null;
+    this.softwareDecrypter = null;
+    this.key = null;
+    this.fastAesKey = null;
+    this.remainderData = null;
+    this.currentIV = null;
+    this.currentResult = null;
+  }
+
+  public isSync() {
+    return this.useSoftware;
+  }
+
+  public flush(): Uint8Array | null {
+    const { currentResult, remainderData } = this;
+    if (!currentResult || remainderData) {
+      this.reset();
+      return null;
+    }
+    const data = new Uint8Array(currentResult);
+    this.reset();
+    if (this.removePKCS7Padding) {
+      return removePadding(data);
+    }
+    return data;
+  }
+
+  public reset() {
+    this.currentResult = null;
+    this.currentIV = null;
+    this.remainderData = null;
+    if (this.softwareDecrypter) {
+      this.softwareDecrypter = null;
+    }
+  }
+
+  public decrypt(
+    data: Uint8Array | ArrayBuffer,
+    key: ArrayBuffer,
+    iv: ArrayBuffer,
+  ): Promise<ArrayBuffer> {
+    if (this.useSoftware) {
+      return new Promise((resolve, reject) => {
+        this.softwareDecrypt(new Uint8Array(data), key, iv);
+        const decryptResult = this.flush();
+        if (decryptResult) {
+          resolve(decryptResult.buffer);
+        } else {
+          reject(new Error('[softwareDecrypt] Failed to decrypt data'));
+        }
+      });
+    }
+    return this.webCryptoDecrypt(new Uint8Array(data), key, iv);
+  }
+
+  // Software decryption is progressive. Progressive decryption may not return a result on each call. Any cached
+  // data is handled in the flush() call
+  public softwareDecrypt(
+    data: Uint8Array,
+    key: ArrayBuffer,
+    iv: ArrayBuffer,
+  ): ArrayBuffer | null {
+    const { currentIV, currentResult, remainderData } = this;
+    this.logOnce('JS AES decrypt');
+    // The output is staggered during progressive parsing - the current result is cached, and emitted on the next call
+    // This is done in order to strip PKCS7 padding, which is found at the end of each segment. We only know we've reached
+    // the end on flush(), but by that time we have already received all bytes for the segment.
+    // Progressive decryption does not work with WebCrypto
+
+    if (remainderData) {
+      data = appendUint8Array(remainderData, data);
+      this.remainderData = null;
+    }
+
+    // Byte length must be a multiple of 16 (AES-128 = 128 bit blocks = 16 bytes)
+    const currentChunk = this.getValidChunk(data);
+    if (!currentChunk.length) {
+      return null;
+    }
+
+    if (currentIV) {
+      iv = currentIV;
+    }
+
+    let softwareDecrypter = this.softwareDecrypter;
+    if (!softwareDecrypter) {
+      softwareDecrypter = this.softwareDecrypter = new AESDecryptor();
+    }
+    softwareDecrypter.expandKey(key);
+
+    const result = currentResult;
+
+    this.currentResult = softwareDecrypter.decrypt(currentChunk.buffer, 0, iv);
+    this.currentIV = sliceUint8(currentChunk, -16).buffer;
+
+    if (!result) {
+      return null;
+    }
+    return result;
+  }
+
+  public webCryptoDecrypt(
+    data: Uint8Array,
+    key: ArrayBuffer,
+    iv: ArrayBuffer,
+  ): Promise<ArrayBuffer> {
+    if (this.key !== key || !this.fastAesKey) {
+      if (!this.subtle) {
+        return Promise.resolve(this.onWebCryptoError(data, key, iv));
+      }
+      this.key = key;
+      this.fastAesKey = new FastAESKey(this.subtle, key);
+    }
+    return this.fastAesKey
+      .expandKey()
+      .then((aesKey) => {
+        // decrypt using web crypto
+        if (!this.subtle) {
+          return Promise.reject(new Error('web crypto not initialized'));
+        }
+        this.logOnce('WebCrypto AES decrypt');
+        const crypto = new AESCrypto(this.subtle, new Uint8Array(iv));
+        return crypto.decrypt(data.buffer, aesKey);
+      })
+      .catch((err) => {
+        logger.warn(
+          `[decrypter]: WebCrypto Error, disable WebCrypto API, ${err.name}: ${err.message}`,
+        );
+
+        return this.onWebCryptoError(data, key, iv);
+      });
+  }
+
+  private onWebCryptoError(
+    data: Uint8Array,
+    key: ArrayBuffer,
+    iv: ArrayBuffer,
+  ): ArrayBuffer | never {
+    this.useSoftware = true;
+    this.logEnabled = true;
+    this.softwareDecrypt(data, key, iv);
+    const decryptResult = this.flush();
+    if (decryptResult) {
+      return decryptResult.buffer;
+    }
+    throw new Error('WebCrypto and softwareDecrypt: failed to decrypt data');
+  }
+
+  private getValidChunk(data: Uint8Array): Uint8Array {
+    let currentChunk = data;
+    const splitPoint = data.length - (data.length % CHUNK_SIZE);
+    if (splitPoint !== data.length) {
+      currentChunk = sliceUint8(data, 0, splitPoint);
+      this.remainderData = sliceUint8(data, splitPoint);
+    }
+    return currentChunk;
+  }
+
+  private logOnce(msg: string) {
+    if (!this.logEnabled) {
+      return;
+    }
+    logger.log(`[decrypter]: ${msg}`);
+    this.logEnabled = false;
+  }
+}

server/node_modules/hls.js/src/crypt/fast-aes-key.ts

@@ -0,0 +1,16 @@
+export default class FastAESKey {
+  private subtle: SubtleCrypto;
+  private key: ArrayBuffer;
+
+  constructor(subtle: SubtleCrypto, key: ArrayBuffer) {
+    this.subtle = subtle;
+    this.key = key;
+  }
+
+  expandKey() {
+    return this.subtle.importKey('raw', this.key, { name: 'AES-CBC' }, false, [
+      'encrypt',
+      'decrypt',
+    ]);
+  }
+}