@gct-paas/core 0.1.4-dev.2 → 0.1.4-dev.3

package/es/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/aes.mjs

@@ -0,0 +1,255 @@
+import '../../../../../_virtual/_commonjsHelpers.mjs';
+import { __module as aes$1 } from '../../../../../_virtual/aes.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireEncBase64 } from './enc-base64.mjs';
+import { __require as requireMd5 } from './md5.mjs';
+import { __require as requireEvpkdf } from './evpkdf.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var aes = aes$1.exports;
+
+var hasRequiredAes;
+
+function requireAes () {
+	if (hasRequiredAes) return aes$1.exports;
+	hasRequiredAes = 1;
+	(function (module, exports) {
+		;(function (root, factory, undef) {
+			if ('object' === "object") {
+				// CommonJS
+				module.exports = exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+			}
+			else if (typeof undefined === "function" && undefined.amd) {
+				// AMD
+				undefined(["./core", "./enc-base64", "./md5", "./evpkdf", "./cipher-core"], factory);
+			}
+			else {
+				// Global (browser)
+				factory(root.CryptoJS);
+			}
+		}(aes, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var BlockCipher = C_lib.BlockCipher;
+			    var C_algo = C.algo;
+
+			    // Lookup tables
+			    var SBOX = [];
+			    var INV_SBOX = [];
+			    var SUB_MIX_0 = [];
+			    var SUB_MIX_1 = [];
+			    var SUB_MIX_2 = [];
+			    var SUB_MIX_3 = [];
+			    var INV_SUB_MIX_0 = [];
+			    var INV_SUB_MIX_1 = [];
+			    var INV_SUB_MIX_2 = [];
+			    var INV_SUB_MIX_3 = [];
+
+			    // Compute lookup tables
+			    (function () {
+			        // Compute double table
+			        var d = [];
+			        for (var i = 0; i < 256; i++) {
+			            if (i < 128) {
+			                d[i] = i << 1;
+			            } else {
+			                d[i] = (i << 1) ^ 0x11b;
+			            }
+			        }
+
+			        // Walk GF(2^8)
+			        var x = 0;
+			        var xi = 0;
+			        for (var i = 0; i < 256; i++) {
+			            // Compute sbox
+			            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
+			            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
+			            SBOX[x] = sx;
+			            INV_SBOX[sx] = x;
+
+			            // Compute multiplication
+			            var x2 = d[x];
+			            var x4 = d[x2];
+			            var x8 = d[x4];
+
+			            // Compute sub bytes, mix columns tables
+			            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
+			            SUB_MIX_0[x] = (t << 24) | (t >>> 8);
+			            SUB_MIX_1[x] = (t << 16) | (t >>> 16);
+			            SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
+			            SUB_MIX_3[x] = t;
+
+			            // Compute inv sub bytes, inv mix columns tables
+			            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
+			            INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
+			            INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
+			            INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
+			            INV_SUB_MIX_3[sx] = t;
+
+			            // Compute next counter
+			            if (!x) {
+			                x = xi = 1;
+			            } else {
+			                x = x2 ^ d[d[d[x8 ^ x2]]];
+			                xi ^= d[d[xi]];
+			            }
+			        }
+			    }());
+
+			    // Precomputed Rcon lookup
+			    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
+
+			    /**
+			     * AES block cipher algorithm.
+			     */
+			    var AES = C_algo.AES = BlockCipher.extend({
+			        _doReset: function () {
+			            var t;
+
+			            // Skip reset of nRounds has been set before and key did not change
+			            if (this._nRounds && this._keyPriorReset === this._key) {
+			                return;
+			            }
+
+			            // Shortcuts
+			            var key = this._keyPriorReset = this._key;
+			            var keyWords = key.words;
+			            var keySize = key.sigBytes / 4;
+
+			            // Compute number of rounds
+			            var nRounds = this._nRounds = keySize + 6;
+
+			            // Compute number of key schedule rows
+			            var ksRows = (nRounds + 1) * 4;
+
+			            // Compute key schedule
+			            var keySchedule = this._keySchedule = [];
+			            for (var ksRow = 0; ksRow < ksRows; ksRow++) {
+			                if (ksRow < keySize) {
+			                    keySchedule[ksRow] = keyWords[ksRow];
+			                } else {
+			                    t = keySchedule[ksRow - 1];
+
+			                    if (!(ksRow % keySize)) {
+			                        // 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] = keySchedule[ksRow - keySize] ^ t;
+			                }
+			            }
+
+			            // Compute inv key schedule
+			            var invKeySchedule = this._invKeySchedule = [];
+			            for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
+			                var ksRow = ksRows - invKsRow;
+
+			                if (invKsRow % 4) {
+			                    var t = keySchedule[ksRow];
+			                } else {
+			                    var t = keySchedule[ksRow - 4];
+			                }
+
+			                if (invKsRow < 4 || ksRow <= 4) {
+			                    invKeySchedule[invKsRow] = t;
+			                } else {
+			                    invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
+			                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
+			                }
+			            }
+			        },
+
+			        encryptBlock: function (M, offset) {
+			            this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+			        },
+
+			        decryptBlock: function (M, offset) {
+			            // Swap 2nd and 4th rows
+			            var t = M[offset + 1];
+			            M[offset + 1] = M[offset + 3];
+			            M[offset + 3] = t;
+
+			            this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+
+			            // Inv swap 2nd and 4th rows
+			            var t = M[offset + 1];
+			            M[offset + 1] = M[offset + 3];
+			            M[offset + 3] = t;
+			        },
+
+			        _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
+			            // Shortcut
+			            var nRounds = this._nRounds;
+
+			            // Get input, add round key
+			            var s0 = M[offset]     ^ keySchedule[0];
+			            var s1 = M[offset + 1] ^ keySchedule[1];
+			            var s2 = M[offset + 2] ^ keySchedule[2];
+			            var s3 = M[offset + 3] ^ keySchedule[3];
+
+			            // Key schedule row counter
+			            var ksRow = 4;
+
+			            // Rounds
+			            for (var round = 1; round < nRounds; round++) {
+			                // Shift rows, sub bytes, mix columns, add round key
+			                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
+			                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
+			                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
+			                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
+
+			                // Update state
+			                s0 = t0;
+			                s1 = t1;
+			                s2 = t2;
+			                s3 = t3;
+			            }
+
+			            // Shift rows, sub bytes, add round key
+			            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
+			            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
+			            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
+			            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
+
+			            // Set output
+			            M[offset]     = t0;
+			            M[offset + 1] = t1;
+			            M[offset + 2] = t2;
+			            M[offset + 3] = t3;
+			        },
+
+			        keySize: 256/32
+			    });
+
+			    /**
+			     * Shortcut functions to the cipher's object interface.
+			     *
+			     * @example
+			     *
+			     *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
+			     *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
+			     */
+			    C.AES = BlockCipher._createHelper(AES);
+			}());
+
+
+			return CryptoJS.AES;
+
+		})); 
+	} (aes$1, aes$1.exports));
+	return aes$1.exports;
+}
+
+export { requireAes as __require };