☰

m3u8-hls

m3u8

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.gf.qytechs.cn/scripts/468820/1208011/m3u8-hls.js 

  1. //引用 https://github.com/video-dev/hls.js
  2.  
  3. function removePadding(buffer) {
  4.   const outputBytes = buffer.byteLength;
  5.   const paddingBytes = outputBytes && (new DataView(buffer)).getUint8(outputBytes - 1);
  6.   if (paddingBytes) {
  7.     return buffer.slice(0, outputBytes - paddingBytes);
  8.   } else {
  9.     return buffer;
  10.   }
  11. }
  12.  
  13. function AESDecryptor() {
  14.   return {
  15.     constructor() {
  16.       this.rcon = [0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
  17.       this.subMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
  18.       this.invSubMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
  19.       this.sBox = new Uint32Array(256);
  20.       this.invSBox = new Uint32Array(256);
  21.  
  22.       // Changes during runtime
  23.       this.key = new Uint32Array(0);
  24.  
  25.       this.initTable();
  26.     },
  27.  
  28.     // Using view.getUint32() also swaps the byte order.
  29.     uint8ArrayToUint32Array_(arrayBuffer) {
  30.       let view = new DataView(arrayBuffer);
  31.       let newArray = new Uint32Array(4);
  32.       for (let i = 0; i < 4; i++) {
  33.         newArray[i] = view.getUint32(i * 4);
  34.       }
  35.  
  36.       return newArray;
  37.     },
  38.  
  39.     initTable() {
  40.       let sBox = this.sBox;
  41.       let invSBox = this.invSBox;
  42.       let subMix = this.subMix;
  43.       let subMix0 = subMix[0];
  44.       let subMix1 = subMix[1];
  45.       let subMix2 = subMix[2];
  46.       let subMix3 = subMix[3];
  47.       let invSubMix = this.invSubMix;
  48.       let invSubMix0 = invSubMix[0];
  49.       let invSubMix1 = invSubMix[1];
  50.       let invSubMix2 = invSubMix[2];
  51.       let invSubMix3 = invSubMix[3];
  52.  
  53.       let d = new Uint32Array(256);
  54.       let x = 0;
  55.       let xi = 0;
  56.       let i = 0;
  57.       for (i = 0; i < 256; i++) {
  58.         if (i < 128) {
  59.           d[i] = i << 1;
  60.         } else {
  61.           d[i] = (i << 1) ^ 0x11b;
  62.         }
  63.       }
  64.  
  65.       for (i = 0; i < 256; i++) {
  66.         let sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
  67.         sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
  68.         sBox[x] = sx;
  69.         invSBox[sx] = x;
  70.  
  71.         // Compute multiplication
  72.         let x2 = d[x];
  73.         let x4 = d[x2];
  74.         let x8 = d[x4];
  75.  
  76.         // Compute sub/invSub bytes, mix columns tables
  77.         let t = (d[sx] * 0x101) ^ (sx * 0x1010100);
  78.         subMix0[x] = (t << 24) | (t >>> 8);
  79.         subMix1[x] = (t << 16) | (t >>> 16);
  80.         subMix2[x] = (t << 8) | (t >>> 24);
  81.         subMix3[x] = t;
  82.  
  83.         // Compute inv sub bytes, inv mix columns tables
  84.         t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
  85.         invSubMix0[sx] = (t << 24) | (t >>> 8);
  86.         invSubMix1[sx] = (t << 16) | (t >>> 16);
  87.         invSubMix2[sx] = (t << 8) | (t >>> 24);
  88.         invSubMix3[sx] = t;
  89.  
  90.         // Compute next counter
  91.         if (!x) {
  92.           x = xi = 1;
  93.         } else {
  94.           x = x2 ^ d[d[d[x8 ^ x2]]];
  95.           xi ^= d[d[xi]];
  96.         }
  97.       }
  98.     },
  99.  
  100.     expandKey(keyBuffer) {
  101.       // convert keyBuffer to Uint32Array
  102.       let key = this.uint8ArrayToUint32Array_(keyBuffer);
  103.       let sameKey = true;
  104.       let offset = 0;
  105.  
  106.       while (offset < key.length && sameKey) {
  107.         sameKey = (key[offset] === this.key[offset]);
  108.         offset++;
  109.       }
  110.  
  111.       if (sameKey) {
  112.         return;
  113.       }
  114.  
  115.       this.key = key;
  116.       let keySize = this.keySize = key.length;
  117.  
  118.       if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
  119.         throw new Error('Invalid aes key size=' + keySize);
  120.       }
  121.  
  122.       let ksRows = this.ksRows = (keySize + 6 + 1) * 4;
  123.       let ksRow;
  124.       let invKsRow;
  125.  
  126.       let keySchedule = this.keySchedule = new Uint32Array(ksRows);
  127.       let invKeySchedule = this.invKeySchedule = new Uint32Array(ksRows);
  128.       let sbox = this.sBox;
  129.       let rcon = this.rcon;
  130.  
  131.       let invSubMix = this.invSubMix;
  132.       let invSubMix0 = invSubMix[0];
  133.       let invSubMix1 = invSubMix[1];
  134.       let invSubMix2 = invSubMix[2];
  135.       let invSubMix3 = invSubMix[3];
  136.  
  137.       let prev;
  138.       let t;
  139.  
  140.       for (ksRow = 0; ksRow < ksRows; ksRow++) {
  141.         if (ksRow < keySize) {
  142.           prev = keySchedule[ksRow] = key[ksRow];
  143.           continue;
  144.         }
  145.         t = prev;
  146.  
  147.         if (ksRow % keySize === 0) {
  148.           // Rot word
  149.           t = (t << 8) | (t >>> 24);
  150.  
  151.           // Sub word
  152.           t = (sbox[t >>> 24] << 24) | (sbox[(t >>> 16) & 0xff] << 16) | (sbox[(t >>> 8) & 0xff] << 8) | sbox[t & 0xff];
  153.  
  154.           // Mix Rcon
  155.           t ^= rcon[(ksRow / keySize) | 0] << 24;
  156.         } else if (keySize > 6 && ksRow % keySize === 4) {
  157.           // Sub word
  158.           t = (sbox[t >>> 24] << 24) | (sbox[(t >>> 16) & 0xff] << 16) | (sbox[(t >>> 8) & 0xff] << 8) | sbox[t & 0xff];
  159.         }
  160.  
  161.         keySchedule[ksRow] = prev = (keySchedule[ksRow - keySize] ^ t) >>> 0;
  162.       }
  163.  
  164.       for (invKsRow = 0; invKsRow < ksRows; invKsRow++) {
  165.         ksRow = ksRows - invKsRow;
  166.         if (invKsRow & 3) {
  167.           t = keySchedule[ksRow];
  168.         } else {
  169.           t = keySchedule[ksRow - 4];
  170.         }
  171.  
  172.         if (invKsRow < 4 || ksRow <= 4) {
  173.           invKeySchedule[invKsRow] = t;
  174.         } else {
  175.           invKeySchedule[invKsRow] = invSubMix0[sbox[t >>> 24]] ^ invSubMix1[sbox[(t >>> 16) & 0xff]] ^ invSubMix2[sbox[(t >>> 8) & 0xff]] ^ invSubMix3[sbox[t & 0xff]];
  176.         }
  177.  
  178.         invKeySchedule[invKsRow] = invKeySchedule[invKsRow] >>> 0;
  179.       }
  180.     },
  181.  
  182.     // Adding this as a method greatly improves performance.
  183.     networkToHostOrderSwap(word) {
  184.       return (word << 24) | ((word & 0xff00) << 8) | ((word & 0xff0000) >> 8) | (word >>> 24);
  185.     },
  186.  
  187.     decrypt(inputArrayBuffer, offset, aesIV, removePKCS7Padding) {
  188.       let nRounds = this.keySize + 6;
  189.       let invKeySchedule = this.invKeySchedule;
  190.       let invSBOX = this.invSBox;
  191.  
  192.       let invSubMix = this.invSubMix;
  193.       let invSubMix0 = invSubMix[0];
  194.       let invSubMix1 = invSubMix[1];
  195.       let invSubMix2 = invSubMix[2];
  196.       let invSubMix3 = invSubMix[3];
  197.  
  198.       let initVector = this.uint8ArrayToUint32Array_(aesIV);
  199.       let initVector0 = initVector[0];
  200.       let initVector1 = initVector[1];
  201.       let initVector2 = initVector[2];
  202.       let initVector3 = initVector[3];
  203.  
  204.       let inputInt32 = new Int32Array(inputArrayBuffer);
  205.       let outputInt32 = new Int32Array(inputInt32.length);
  206.  
  207.       let t0, t1, t2, t3;
  208.       let s0, s1, s2, s3;
  209.       let inputWords0, inputWords1, inputWords2, inputWords3;
  210.  
  211.       let ksRow, i;
  212.       let swapWord = this.networkToHostOrderSwap;
  213.  
  214.       while (offset < inputInt32.length) {
  215.         inputWords0 = swapWord(inputInt32[offset]);
  216.         inputWords1 = swapWord(inputInt32[offset + 1]);
  217.         inputWords2 = swapWord(inputInt32[offset + 2]);
  218.         inputWords3 = swapWord(inputInt32[offset + 3]);
  219.  
  220.         s0 = inputWords0 ^ invKeySchedule[0];
  221.         s1 = inputWords3 ^ invKeySchedule[1];
  222.         s2 = inputWords2 ^ invKeySchedule[2];
  223.         s3 = inputWords1 ^ invKeySchedule[3];
  224.  
  225.         ksRow = 4;
  226.  
  227.         // Iterate through the rounds of decryption
  228.         for (i = 1; i < nRounds; i++) {
  229.           t0 = invSubMix0[s0 >>> 24] ^ invSubMix1[(s1 >> 16) & 0xff] ^ invSubMix2[(s2 >> 8) & 0xff] ^ invSubMix3[s3 & 0xff] ^ invKeySchedule[ksRow];
  230.           t1 = invSubMix0[s1 >>> 24] ^ invSubMix1[(s2 >> 16) & 0xff] ^ invSubMix2[(s3 >> 8) & 0xff] ^ invSubMix3[s0 & 0xff] ^ invKeySchedule[ksRow + 1];
  231.           t2 = invSubMix0[s2 >>> 24] ^ invSubMix1[(s3 >> 16) & 0xff] ^ invSubMix2[(s0 >> 8) & 0xff] ^ invSubMix3[s1 & 0xff] ^ invKeySchedule[ksRow + 2];
  232.           t3 = invSubMix0[s3 >>> 24] ^ invSubMix1[(s0 >> 16) & 0xff] ^ invSubMix2[(s1 >> 8) & 0xff] ^ invSubMix3[s2 & 0xff] ^ invKeySchedule[ksRow + 3];
  233.           // Update state
  234.           s0 = t0;
  235.           s1 = t1;
  236.           s2 = t2;
  237.           s3 = t3;
  238.  
  239.           ksRow = ksRow + 4;
  240.         }
  241.  
  242.         // Shift rows, sub bytes, add round key
  243.         t0 = ((invSBOX[s0 >>> 24] << 24) ^ (invSBOX[(s1 >> 16) & 0xff] << 16) ^ (invSBOX[(s2 >> 8) & 0xff] << 8) ^ invSBOX[s3 & 0xff]) ^ invKeySchedule[ksRow];
  244.         t1 = ((invSBOX[s1 >>> 24] << 24) ^ (invSBOX[(s2 >> 16) & 0xff] << 16) ^ (invSBOX[(s3 >> 8) & 0xff] << 8) ^ invSBOX[s0 & 0xff]) ^ invKeySchedule[ksRow + 1];
  245.         t2 = ((invSBOX[s2 >>> 24] << 24) ^ (invSBOX[(s3 >> 16) & 0xff] << 16) ^ (invSBOX[(s0 >> 8) & 0xff] << 8) ^ invSBOX[s1 & 0xff]) ^ invKeySchedule[ksRow + 2];
  246.         t3 = ((invSBOX[s3 >>> 24] << 24) ^ (invSBOX[(s0 >> 16) & 0xff] << 16) ^ (invSBOX[(s1 >> 8) & 0xff] << 8) ^ invSBOX[s2 & 0xff]) ^ invKeySchedule[ksRow + 3];
  247.         ksRow = ksRow + 3;
  248.  
  249.         // Write
  250.         outputInt32[offset] = swapWord(t0 ^ initVector0);
  251.         outputInt32[offset + 1] = swapWord(t3 ^ initVector1);
  252.         outputInt32[offset + 2] = swapWord(t2 ^ initVector2);
  253.         outputInt32[offset + 3] = swapWord(t1 ^ initVector3);
  254.  
  255.         // reset initVector to last 4 unsigned int
  256.         initVector0 = inputWords0;
  257.         initVector1 = inputWords1;
  258.         initVector2 = inputWords2;
  259.         initVector3 = inputWords3;
  260.  
  261.         offset = offset + 4;
  262.       }
  263.  
  264.       return removePKCS7Padding ? removePadding(outputInt32.buffer) : outputInt32.buffer;
  265.     },
  266.  
  267.     destroy() {
  268.       this.key = undefined;
  269.       this.keySize = undefined;
  270.       this.ksRows = undefined;
  271.  
  272.       this.sBox = undefined;
  273.       this.invSBox = undefined;
  274.       this.subMix = undefined;
  275.       this.invSubMix = undefined;
  276.       this.keySchedule = undefined;
  277.       this.invKeySchedule = undefined;
  278.  
  279.       this.rcon = undefined;
  280.     },
  281.   }
  282. }

欢迎访问Greasy Fork镜像

土豆服务器，请按需使用

镜像地址随时可能被墙，建议加群获取最新地址

加入Q群

QingJ © 2025

镜像随时可能失效，请加Q群300939539或关注我们的公众号极客氢云获取最新地址