feat: Add Be and tbd skill, also added Roadmap file

Skills/@be/node_modules/hls.js/lib/crypt/aes-crypto.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var AESCrypto = function () {
+  function AESCrypto(subtle, iv) {
+    _classCallCheck(this, AESCrypto);
+
+    this.subtle = subtle;
+    this.aesIV = iv;
+  }
+
+  _createClass(AESCrypto, [{
+    key: 'decrypt',
+    value: function decrypt(data, key) {
+      return this.subtle.decrypt({ name: 'AES-CBC', iv: this.aesIV }, key, data);
+    }
+  }]);
+
+  return AESCrypto;
+}();
+
+exports.default = AESCrypto;

Skills/@be/node_modules/hls.js/lib/crypt/aes-decryptor.js

@@ -0,0 +1,305 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var AESDecryptor = function () {
+  function AESDecryptor() {
+    _classCallCheck(this, AESDecryptor);
+
+    // Static after running initTable
+    this.rcon = [0x0, 0x1, 0x2, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
+    this.subMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
+    this.invSubMix = [new Uint32Array(256), new Uint32Array(256), new Uint32Array(256), new Uint32Array(256)];
+    this.sBox = new Uint32Array(256);
+    this.invSBox = new Uint32Array(256);
+
+    // Changes during runtime
+    this.key = new Uint32Array(0);
+
+    this.initTable();
+  }
+
+  // Using view.getUint32() also swaps the byte order.
+
+
+  _createClass(AESDecryptor, [{
+    key: 'uint8ArrayToUint32Array_',
+    value: function uint8ArrayToUint32Array_(arrayBuffer) {
+      var view = new DataView(arrayBuffer);
+      var newArray = new Uint32Array(4);
+      for (var i = 0; i < 4; i++) {
+        newArray[i] = view.getUint32(i * 4);
+      }
+      return newArray;
+    }
+  }, {
+    key: 'initTable',
+    value: function initTable() {
+      var sBox = this.sBox;
+      var invSBox = this.invSBox;
+      var subMix = this.subMix;
+      var subMix0 = subMix[0];
+      var subMix1 = subMix[1];
+      var subMix2 = subMix[2];
+      var subMix3 = subMix[3];
+      var invSubMix = this.invSubMix;
+      var invSubMix0 = invSubMix[0];
+      var invSubMix1 = invSubMix[1];
+      var invSubMix2 = invSubMix[2];
+      var invSubMix3 = invSubMix[3];
+
+      var d = new Uint32Array(256);
+      var x = 0;
+      var xi = 0;
+      var 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++) {
+        var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
+        sx = sx >>> 8 ^ sx & 0xff ^ 0x63;
+        sBox[x] = sx;
+        invSBox[sx] = x;
+
+        // Compute multiplication
+        var x2 = d[x];
+        var x4 = d[x2];
+        var x8 = d[x4];
+
+        // Compute sub/invSub bytes, mix columns tables
+        var 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]];
+        }
+      }
+    }
+  }, {
+    key: 'expandKey',
+    value: function expandKey(keyBuffer) {
+      // convert keyBuffer to Uint32Array
+      var key = this.uint8ArrayToUint32Array_(keyBuffer);
+      var sameKey = true;
+      var offset = 0;
+
+      while (offset < key.length && sameKey) {
+        sameKey = key[offset] === this.key[offset];
+        offset++;
+      }
+
+      if (sameKey) {
+        return;
+      }
+
+      this.key = key;
+      var keySize = this.keySize = key.length;
+
+      if (keySize !== 4 && keySize !== 6 && keySize !== 8) {
+        throw new Error('Invalid aes key size=' + keySize);
+      }
+
+      var ksRows = this.ksRows = (keySize + 6 + 1) * 4;
+      var ksRow = void 0;
+      var invKsRow = void 0;
+
+      var keySchedule = this.keySchedule = new Uint32Array(ksRows);
+      var invKeySchedule = this.invKeySchedule = new Uint32Array(ksRows);
+      var sbox = this.sBox;
+      var rcon = this.rcon;
+
+      var invSubMix = this.invSubMix;
+      var invSubMix0 = invSubMix[0];
+      var invSubMix1 = invSubMix[1];
+      var invSubMix2 = invSubMix[2];
+      var invSubMix3 = invSubMix[3];
+
+      var prev = void 0;
+      var t = void 0;
+
+      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.
+
+  }, {
+    key: 'networkToHostOrderSwap',
+    value: function networkToHostOrderSwap(word) {
+      return word << 24 | (word & 0xff00) << 8 | (word & 0xff0000) >> 8 | word >>> 24;
+    }
+  }, {
+    key: 'decrypt',
+    value: function decrypt(inputArrayBuffer, offset, aesIV) {
+      var nRounds = this.keySize + 6;
+      var invKeySchedule = this.invKeySchedule;
+      var invSBOX = this.invSBox;
+
+      var invSubMix = this.invSubMix;
+      var invSubMix0 = invSubMix[0];
+      var invSubMix1 = invSubMix[1];
+      var invSubMix2 = invSubMix[2];
+      var invSubMix3 = invSubMix[3];
+
+      var initVector = this.uint8ArrayToUint32Array_(aesIV);
+      var initVector0 = initVector[0];
+      var initVector1 = initVector[1];
+      var initVector2 = initVector[2];
+      var initVector3 = initVector[3];
+
+      var inputInt32 = new Int32Array(inputArrayBuffer);
+      var outputInt32 = new Int32Array(inputInt32.length);
+
+      var t0 = void 0,
+          t1 = void 0,
+          t2 = void 0,
+          t3 = void 0;
+      var s0 = void 0,
+          s1 = void 0,
+          s2 = void 0,
+          s3 = void 0;
+      var inputWords0 = void 0,
+          inputWords1 = void 0,
+          inputWords2 = void 0,
+          inputWords3 = void 0;
+
+      var ksRow, i;
+      var 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];
+        ksRow = 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;
+    }
+  }, {
+    key: 'destroy',
+    value: function destroy() {
+      this.key = undefined;
+      this.keySize = undefined;
+      this.ksRows = undefined;
+
+      this.sBox = undefined;
+      this.invSBox = undefined;
+      this.subMix = undefined;
+      this.invSubMix = undefined;
+      this.keySchedule = undefined;
+      this.invKeySchedule = undefined;
+
+      this.rcon = undefined;
+    }
+  }]);
+
+  return AESDecryptor;
+}();
+
+exports.default = AESDecryptor;

Skills/@be/node_modules/hls.js/lib/crypt/decrypter.js

@@ -0,0 +1,117 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+var _aesCrypto = require('./aes-crypto');
+
+var _aesCrypto2 = _interopRequireDefault(_aesCrypto);
+
+var _fastAesKey = require('./fast-aes-key');
+
+var _fastAesKey2 = _interopRequireDefault(_fastAesKey);
+
+var _aesDecryptor = require('./aes-decryptor');
+
+var _aesDecryptor2 = _interopRequireDefault(_aesDecryptor);
+
+var _errors = require('../errors');
+
+var _logger = require('../utils/logger');
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/*globals self: false */
+
+var Decrypter = function () {
+  function Decrypter(observer, config) {
+    _classCallCheck(this, Decrypter);
+
+    this.observer = observer;
+    this.config = config;
+    this.logEnabled = true;
+    try {
+      var browserCrypto = crypto ? crypto : self.crypto;
+      this.subtle = browserCrypto.subtle || browserCrypto.webkitSubtle;
+    } catch (e) {}
+    this.disableWebCrypto = !this.subtle;
+  }
+
+  _createClass(Decrypter, [{
+    key: 'isSync',
+    value: function isSync() {
+      return this.disableWebCrypto && this.config.enableSoftwareAES;
+    }
+  }, {
+    key: 'decrypt',
+    value: function decrypt(data, key, iv, callback) {
+      var _this = this;
+
+      if (this.disableWebCrypto && this.config.enableSoftwareAES) {
+        if (this.logEnabled) {
+          _logger.logger.log('JS AES decrypt');
+          this.logEnabled = false;
+        }
+        var decryptor = this.decryptor;
+        if (!decryptor) {
+          this.decryptor = decryptor = new _aesDecryptor2.default();
+        }
+        decryptor.expandKey(key);
+        callback(decryptor.decrypt(data, 0, iv));
+      } else {
+        if (this.logEnabled) {
+          _logger.logger.log('WebCrypto AES decrypt');
+          this.logEnabled = false;
+        }
+        var subtle = this.subtle;
+        if (this.key !== key) {
+          this.key = key;
+          this.fastAesKey = new _fastAesKey2.default(subtle, key);
+        }
+
+        this.fastAesKey.expandKey().then(function (aesKey) {
+          // decrypt using web crypto
+          var crypto = new _aesCrypto2.default(subtle, iv);
+          crypto.decrypt(data, aesKey).catch(function (err) {
+            _this.onWebCryptoError(err, data, key, iv, callback);
+          }).then(function (result) {
+            callback(result);
+          });
+        }).catch(function (err) {
+          _this.onWebCryptoError(err, data, key, iv, callback);
+        });
+      }
+    }
+  }, {
+    key: 'onWebCryptoError',
+    value: function onWebCryptoError(err, data, key, iv, callback) {
+      if (this.config.enableSoftwareAES) {
+        _logger.logger.log('WebCrypto Error, disable WebCrypto API');
+        this.disableWebCrypto = true;
+        this.logEnabled = true;
+        this.decrypt(data, key, iv, callback);
+      } else {
+        _logger.logger.error('decrypting error : ' + err.message);
+        this.observer.trigger(Event.ERROR, { type: _errors.ErrorTypes.MEDIA_ERROR, details: _errors.ErrorDetails.FRAG_DECRYPT_ERROR, fatal: true, reason: err.message });
+      }
+    }
+  }, {
+    key: 'destroy',
+    value: function destroy() {
+      var decryptor = this.decryptor;
+      if (decryptor) {
+        decryptor.destroy();
+        this.decryptor = undefined;
+      }
+    }
+  }]);
+
+  return Decrypter;
+}();
+
+exports.default = Decrypter;

Skills/@be/node_modules/hls.js/lib/crypt/fast-aes-key.js

@@ -0,0 +1,29 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+var FastAESKey = function () {
+  function FastAESKey(subtle, key) {
+    _classCallCheck(this, FastAESKey);
+
+    this.subtle = subtle;
+    this.key = key;
+  }
+
+  _createClass(FastAESKey, [{
+    key: 'expandKey',
+    value: function expandKey() {
+      return this.subtle.importKey('raw', this.key, { name: 'AES-CBC' }, false, ['encrypt', 'decrypt']);
+    }
+  }]);
+
+  return FastAESKey;
+}();
+
+exports.default = FastAESKey;