From dbb5513690e64e85d21accbc9b1eb14b604cc7df Mon Sep 17 00:00:00 2001 From: smallfawn <101914820+smallfawn@users.noreply.github.com> Date: Mon, 10 Jul 2023 19:14:08 +0800 Subject: [PATCH] Create sysxc_v2.js --- sysxc_v2.js | 1097 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1097 insertions(+) create mode 100644 sysxc_v2.js diff --git a/sysxc_v2.js b/sysxc_v2.js new file mode 100644 index 0000000..7d8559e --- /dev/null +++ b/sysxc_v2.js @@ -0,0 +1,1097 @@ +const cv = require("opencv4nodejs"); +const axios = require("axios"); + +var CryptoJS = + CryptoJS || + (function (Math, undefined) { + var crypto; + if (typeof window !== "undefined" && window.crypto) { + crypto = window.crypto; + } + if (typeof self !== "undefined" && self.crypto) { + crypto = self.crypto; + } + if (typeof globalThis !== "undefined" && globalThis.crypto) { + crypto = globalThis.crypto; + } + if (!crypto && typeof window !== "undefined" && window.msCrypto) { + crypto = window.msCrypto; + } + if (!crypto && typeof global !== "undefined" && global.crypto) { + crypto = global.crypto; + } + if (!crypto && typeof require === "function") { + try { + crypto = require("crypto"); + } catch (err) {} + } + var cryptoSecureRandomInt = function () { + if (crypto) { + if (typeof crypto.getRandomValues === "function") { + try { + return crypto.getRandomValues(new Uint32Array(1))[0]; + } catch (err) {} + } + if (typeof crypto.randomBytes === "function") { + try { + return crypto.randomBytes(4).readInt32LE(); + } catch (err) {} + } + } + throw new Error( + "Native crypto module could not be used to get secure random number." + ); + }; + var create = + Object.create || + (function () { + function F() {} + return function (obj) { + var subtype; + F.prototype = obj; + subtype = new F(); + F.prototype = null; + return subtype; + }; + })(); + var C = {}; + var C_lib = (C.lib = {}); + var Base = (C_lib.Base = (function () { + return { + extend: function (overrides) { + var subtype = create(this); + if (overrides) { + subtype.mixIn(overrides); + } + if (!subtype.hasOwnProperty("init") || this.init === subtype.init) { + subtype.init = function () { + subtype.$super.init.apply(this, arguments); + }; + } + subtype.init.prototype = subtype; + subtype.$super = this; + return subtype; + }, + create: function () { + var instance = this.extend(); + instance.init.apply(instance, arguments); + return instance; + }, + init: function () {}, + mixIn: function (properties) { + for (var propertyName in properties) { + if (properties.hasOwnProperty(propertyName)) { + this[propertyName] = properties[propertyName]; + } + } + if (properties.hasOwnProperty("toString")) { + this.toString = properties.toString; + } + }, + clone: function () { + return this.init.prototype.extend(this); + }, + }; + })()); + var WordArray = (C_lib.WordArray = Base.extend({ + init: function (words, sigBytes) { + words = this.words = words || []; + if (sigBytes != undefined) { + this.sigBytes = sigBytes; + } else { + this.sigBytes = words.length * 4; + } + }, + toString: function (encoder) { + return (encoder || Hex).stringify(this); + }, + concat: function (wordArray) { + var thisWords = this.words; + var thatWords = wordArray.words; + var thisSigBytes = this.sigBytes; + var thatSigBytes = wordArray.sigBytes; + this.clamp(); + if (thisSigBytes % 4) { + for (var i = 0; i < thatSigBytes; i++) { + var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + thisWords[(thisSigBytes + i) >>> 2] |= + thatByte << (24 - ((thisSigBytes + i) % 4) * 8); + } + } else { + for (var j = 0; j < thatSigBytes; j += 4) { + thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2]; + } + } + this.sigBytes += thatSigBytes; + return this; + }, + clamp: function () { + var words = this.words; + var sigBytes = this.sigBytes; + words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); + words.length = Math.ceil(sigBytes / 4); + }, + clone: function () { + var clone = Base.clone.call(this); + clone.words = this.words.slice(0); + return clone; + }, + random: function (nBytes) { + var words = []; + var r = function (m_w) { + var m_w = m_w; + var m_z = 0x3ade68b1; + var mask = 0xffffffff; + return function () { + m_z = (0x9069 * (m_z & 0xffff) + (m_z >> 0x10)) & mask; + m_w = (0x4650 * (m_w & 0xffff) + (m_w >> 0x10)) & mask; + var result = ((m_z << 0x10) + m_w) & mask; + result /= 0x100000000; + result += 0.5; + return result * (Math.random() > 0.5 ? 1 : -1); + }; + }; + var RANDOM = false, + _r; + try { + cryptoSecureRandomInt(); + RANDOM = true; + } catch (err) {} + for (var i = 0, rcache; i < nBytes; i += 4) { + if (!RANDOM) { + _r = r((rcache || Math.random()) * 0x100000000); + rcache = _r() * 0x3ade67b7; + words.push((_r() * 0x100000000) | 0); + continue; + } + words.push(cryptoSecureRandomInt()); + } + return new WordArray.init(words, nBytes); + }, + })); + var C_enc = (C.enc = {}); + var Hex = (C_enc.Hex = { + stringify: function (wordArray) { + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var hexChars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + hexChars.push((bite >>> 4).toString(16)); + hexChars.push((bite & 0x0f).toString(16)); + } + return hexChars.join(""); + }, + parse: function (hexStr) { + var hexStrLength = hexStr.length; + var words = []; + for (var i = 0; i < hexStrLength; i += 2) { + words[i >>> 3] |= + parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4); + } + return new WordArray.init(words, hexStrLength / 2); + }, + }); + var Latin1 = (C_enc.Latin1 = { + stringify: function (wordArray) { + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var latin1Chars = []; + for (var i = 0; i < sigBytes; i++) { + var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + latin1Chars.push(String.fromCharCode(bite)); + } + return latin1Chars.join(""); + }, + parse: function (latin1Str) { + var latin1StrLength = latin1Str.length; + var words = []; + for (var i = 0; i < latin1StrLength; i++) { + words[i >>> 2] |= + (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); + } + return new WordArray.init(words, latin1StrLength); + }, + }); + var Utf8 = (C_enc.Utf8 = { + stringify: function (wordArray) { + try { + return decodeURIComponent(escape(Latin1.stringify(wordArray))); + } catch (e) { + throw new Error("Malformed UTF-8 data"); + } + }, + parse: function (utf8Str) { + return Latin1.parse(unescape(encodeURIComponent(utf8Str))); + }, + }); + var BufferedBlockAlgorithm = (C_lib.BufferedBlockAlgorithm = Base.extend({ + reset: function () { + this._data = new WordArray.init(); + this._nDataBytes = 0; + }, + _append: function (data) { + if (typeof data == "string") { + data = Utf8.parse(data); + } + this._data.concat(data); + this._nDataBytes += data.sigBytes; + }, + _process: function (doFlush) { + var processedWords; + var data = this._data; + var dataWords = data.words; + var dataSigBytes = data.sigBytes; + var blockSize = this.blockSize; + var blockSizeBytes = blockSize * 4; + var nBlocksReady = dataSigBytes / blockSizeBytes; + if (doFlush) { + nBlocksReady = Math.ceil(nBlocksReady); + } else { + nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); + } + var nWordsReady = nBlocksReady * blockSize; + var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); + if (nWordsReady) { + for (var offset = 0; offset < nWordsReady; offset += blockSize) { + this._doProcessBlock(dataWords, offset); + } + processedWords = dataWords.splice(0, nWordsReady); + data.sigBytes -= nBytesReady; + } + return new WordArray.init(processedWords, nBytesReady); + }, + clone: function () { + var clone = Base.clone.call(this); + clone._data = this._data.clone(); + return clone; + }, + _minBufferSize: 0, + })); + var Hasher = (C_lib.Hasher = BufferedBlockAlgorithm.extend({ + cfg: Base.extend(), + init: function (cfg) { + this.cfg = this.cfg.extend(cfg); + this.reset(); + }, + reset: function () { + BufferedBlockAlgorithm.reset.call(this); + this._doReset(); + }, + update: function (messageUpdate) { + this._append(messageUpdate); + this._process(); + return this; + }, + finalize: function (messageUpdate) { + if (messageUpdate) { + this._append(messageUpdate); + } + var hash = this._doFinalize(); + return hash; + }, + blockSize: 512 / 32, + _createHelper: function (hasher) { + return function (message, cfg) { + return new hasher.init(cfg).finalize(message); + }; + }, + _createHmacHelper: function (hasher) { + return function (message, key) { + return new C_algo.HMAC.init(hasher, key).finalize(message); + }; + }, + })); + var C_algo = (C.algo = {}); + return C; + })(Math); + +(function () { + var C = CryptoJS; + var C_lib = C.lib; + var WordArray = C_lib.WordArray; + var C_enc = C.enc; + var Base64 = (C_enc.Base64 = { + stringify: function (wordArray) { + var words = wordArray.words; + var sigBytes = wordArray.sigBytes; + var map = this._map; + wordArray.clamp(); + var base64Chars = []; + for (var i = 0; i < sigBytes; i += 3) { + var byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; + var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; + var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; + var triplet = (byte1 << 16) | (byte2 << 8) | byte3; + for (var j = 0; j < 4 && i + j * 0.75 < sigBytes; j++) { + base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); + } + } + var paddingChar = map.charAt(64); + if (paddingChar) { + while (base64Chars.length % 4) { + base64Chars.push(paddingChar); + } + } + return base64Chars.join(""); + }, + parse: function (base64Str) { + var base64StrLength = base64Str.length; + var map = this._map; + var reverseMap = this._reverseMap; + if (!reverseMap) { + reverseMap = this._reverseMap = []; + for (var j = 0; j < map.length; j++) { + reverseMap[map.charCodeAt(j)] = j; + } + } + var paddingChar = map.charAt(64); + if (paddingChar) { + var paddingIndex = base64Str.indexOf(paddingChar); + if (paddingIndex !== -1) { + base64StrLength = paddingIndex; + } + } + return parseLoop(base64Str, base64StrLength, reverseMap); + }, + _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=", + }); + function parseLoop(base64Str, base64StrLength, reverseMap) { + var words = []; + var nBytes = 0; + for (var i = 0; i < base64StrLength; i++) { + if (i % 4) { + var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2); + var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2); + words[nBytes >>> 2] |= (bits1 | bits2) << (24 - (nBytes % 4) * 8); + nBytes++; + } + } + return WordArray.create(words, nBytes); + } +})(); + +CryptoJS.lib.Cipher || + (function (undefined) { + var C = CryptoJS; + var C_lib = C.lib; + var Base = C_lib.Base; + var WordArray = C_lib.WordArray; + var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm; + var C_enc = C.enc; + var Utf8 = C_enc.Utf8; + var Base64 = C_enc.Base64; + var C_algo = C.algo; + var EvpKDF = C_algo.EvpKDF; + var Cipher = (C_lib.Cipher = BufferedBlockAlgorithm.extend({ + cfg: Base.extend(), + createEncryptor: function (key, cfg) { + return this.create(this._ENC_XFORM_MODE, key, cfg); + }, + createDecryptor: function (key, cfg) { + return this.create(this._DEC_XFORM_MODE, key, cfg); + }, + init: function (xformMode, key, cfg) { + this.cfg = this.cfg.extend(cfg); + this._xformMode = xformMode; + this._key = key; + this.reset(); + }, + reset: function () { + BufferedBlockAlgorithm.reset.call(this); + this._doReset(); + }, + process: function (dataUpdate) { + this._append(dataUpdate); + return this._process(); + }, + finalize: function (dataUpdate) { + if (dataUpdate) { + this._append(dataUpdate); + } + var finalProcessedData = this._doFinalize(); + return finalProcessedData; + }, + keySize: 128 / 32, + ivSize: 128 / 32, + _ENC_XFORM_MODE: 1, + _DEC_XFORM_MODE: 2, + _createHelper: (function () { + function selectCipherStrategy(key) { + if (typeof key == "string") { + return PasswordBasedCipher; + } else { + return SerializableCipher; + } + } + return function (cipher) { + return { + encrypt: function (message, key, cfg) { + return selectCipherStrategy(key).encrypt( + cipher, + message, + key, + cfg + ); + }, + decrypt: function (ciphertext, key, cfg) { + return selectCipherStrategy(key).decrypt( + cipher, + ciphertext, + key, + cfg + ); + }, + }; + }; + })(), + })); + var StreamCipher = (C_lib.StreamCipher = Cipher.extend({ + _doFinalize: function () { + var finalProcessedBlocks = this._process(!!"flush"); + return finalProcessedBlocks; + }, + blockSize: 1, + })); + var C_mode = (C.mode = {}); + var BlockCipherMode = (C_lib.BlockCipherMode = Base.extend({ + createEncryptor: function (cipher, iv) { + return this.Encryptor.create(cipher, iv); + }, + createDecryptor: function (cipher, iv) { + return this.Decryptor.create(cipher, iv); + }, + init: function (cipher, iv) { + this._cipher = cipher; + this._iv = iv; + }, + })); + var CBC = (C_mode.CBC = (function () { + var CBC = BlockCipherMode.extend(); + CBC.Encryptor = CBC.extend({ + processBlock: function (words, offset) { + var cipher = this._cipher; + var blockSize = cipher.blockSize; + xorBlock.call(this, words, offset, blockSize); + cipher.encryptBlock(words, offset); + this._prevBlock = words.slice(offset, offset + blockSize); + }, + }); + CBC.Decryptor = CBC.extend({ + processBlock: function (words, offset) { + var cipher = this._cipher; + var blockSize = cipher.blockSize; + var thisBlock = words.slice(offset, offset + blockSize); + cipher.decryptBlock(words, offset); + xorBlock.call(this, words, offset, blockSize); + this._prevBlock = thisBlock; + }, + }); + + function xorBlock(words, offset, blockSize) { + var block; + var iv = this._iv; + if (iv) { + block = iv; + this._iv = undefined; + } else { + block = this._prevBlock; + } + for (var i = 0; i < blockSize; i++) { + words[offset + i] ^= block[i]; + } + } + return CBC; + })()); + var C_pad = (C.pad = {}); + var Pkcs7 = (C_pad.Pkcs7 = { + pad: function (data, blockSize) { + var blockSizeBytes = blockSize * 4; + var nPaddingBytes = blockSizeBytes - (data.sigBytes % blockSizeBytes); + var paddingWord = + (nPaddingBytes << 24) | + (nPaddingBytes << 16) | + (nPaddingBytes << 8) | + nPaddingBytes; + var paddingWords = []; + for (var i = 0; i < nPaddingBytes; i += 4) { + paddingWords.push(paddingWord); + } + var padding = WordArray.create(paddingWords, nPaddingBytes); + data.concat(padding); + }, + unpad: function (data) { + var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff; + data.sigBytes -= nPaddingBytes; + }, + }); + var BlockCipher = (C_lib.BlockCipher = Cipher.extend({ + cfg: Cipher.cfg.extend({ + mode: CBC, + padding: Pkcs7, + }), + reset: function () { + var modeCreator; + Cipher.reset.call(this); + var cfg = this.cfg; + var iv = cfg.iv; + var mode = cfg.mode; + if (this._xformMode == this._ENC_XFORM_MODE) { + modeCreator = mode.createEncryptor; + } else { + modeCreator = mode.createDecryptor; + this._minBufferSize = 1; + } + if (this._mode && this._mode.__creator == modeCreator) { + this._mode.init(this, iv && iv.words); + } else { + this._mode = modeCreator.call(mode, this, iv && iv.words); + this._mode.__creator = modeCreator; + } + }, + _doProcessBlock: function (words, offset) { + this._mode.processBlock(words, offset); + }, + _doFinalize: function () { + var finalProcessedBlocks; + var padding = this.cfg.padding; + if (this._xformMode == this._ENC_XFORM_MODE) { + padding.pad(this._data, this.blockSize); + finalProcessedBlocks = this._process(!!"flush"); + } else { + finalProcessedBlocks = this._process(!!"flush"); + padding.unpad(finalProcessedBlocks); + } + return finalProcessedBlocks; + }, + blockSize: 128 / 32, + })); + var CipherParams = (C_lib.CipherParams = Base.extend({ + init: function (cipherParams) { + this.mixIn(cipherParams); + }, + toString: function (formatter) { + return (formatter || this.formatter).stringify(this); + }, + })); + var C_format = (C.format = {}); + var OpenSSLFormatter = (C_format.OpenSSL = { + stringify: function (cipherParams) { + var wordArray; + var ciphertext = cipherParams.ciphertext; + var salt = cipherParams.salt; + if (salt) { + wordArray = WordArray.create([0x53616c74, 0x65645f5f]) + .concat(salt) + .concat(ciphertext); + } else { + wordArray = ciphertext; + } + return wordArray.toString(Base64); + }, + parse: function (openSSLStr) { + var salt; + var ciphertext = Base64.parse(openSSLStr); + var ciphertextWords = ciphertext.words; + if ( + ciphertextWords[0] == 0x53616c74 && + ciphertextWords[1] == 0x65645f5f + ) { + salt = WordArray.create(ciphertextWords.slice(2, 4)); + ciphertextWords.splice(0, 4); + ciphertext.sigBytes -= 16; + } + return CipherParams.create({ + ciphertext: ciphertext, + salt: salt, + }); + }, + }); + var SerializableCipher = (C_lib.SerializableCipher = Base.extend({ + cfg: Base.extend({ + format: OpenSSLFormatter, + }), + encrypt: function (cipher, message, key, cfg) { + cfg = this.cfg.extend(cfg); + var encryptor = cipher.createEncryptor(key, cfg); + var ciphertext = encryptor.finalize(message); + var cipherCfg = encryptor.cfg; + return CipherParams.create({ + ciphertext: ciphertext, + key: key, + iv: cipherCfg.iv, + algorithm: cipher, + mode: cipherCfg.mode, + padding: cipherCfg.padding, + blockSize: cipher.blockSize, + formatter: cfg.format, + }); + }, + decrypt: function (cipher, ciphertext, key, cfg) { + cfg = this.cfg.extend(cfg); + ciphertext = this._parse(ciphertext, cfg.format); + var plaintext = cipher + .createDecryptor(key, cfg) + .finalize(ciphertext.ciphertext); + return plaintext; + }, + _parse: function (ciphertext, format) { + if (typeof ciphertext == "string") { + return format.parse(ciphertext, this); + } else { + return ciphertext; + } + }, + })); + var C_kdf = (C.kdf = {}); + var OpenSSLKdf = (C_kdf.OpenSSL = { + execute: function (password, keySize, ivSize, salt, hasher) { + if (!salt) { + salt = WordArray.random(64 / 8); + } + if (!hasher) { + var key = EvpKDF.create({ + keySize: keySize + ivSize, + }).compute(password, salt); + } else { + var key = EvpKDF.create({ + keySize: keySize + ivSize, + hasher: hasher, + }).compute(password, salt); + } + var iv = WordArray.create(key.words.slice(keySize), ivSize * 4); + key.sigBytes = keySize * 4; + return CipherParams.create({ + key: key, + iv: iv, + salt: salt, + }); + }, + }); + var PasswordBasedCipher = (C_lib.PasswordBasedCipher = + SerializableCipher.extend({ + cfg: SerializableCipher.cfg.extend({ + kdf: OpenSSLKdf, + }), + encrypt: function (cipher, message, password, cfg) { + cfg = this.cfg.extend(cfg); + var derivedParams = cfg.kdf.execute( + password, + cipher.keySize, + cipher.ivSize, + cfg.salt, + cfg.hasher + ); + cfg.iv = derivedParams.iv; + var ciphertext = SerializableCipher.encrypt.call( + this, + cipher, + message, + derivedParams.key, + cfg + ); + ciphertext.mixIn(derivedParams); + return ciphertext; + }, + decrypt: function (cipher, ciphertext, password, cfg) { + cfg = this.cfg.extend(cfg); + ciphertext = this._parse(ciphertext, cfg.format); + var derivedParams = cfg.kdf.execute( + password, + cipher.keySize, + cipher.ivSize, + ciphertext.salt, + cfg.hasher + ); + cfg.iv = derivedParams.iv; + var plaintext = SerializableCipher.decrypt.call( + this, + cipher, + ciphertext, + derivedParams.key, + cfg + ); + return plaintext; + }, + })); + })(); + +CryptoJS.mode.ECB = (function () { + var ECB = CryptoJS.lib.BlockCipherMode.extend(); + ECB.Encryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.encryptBlock(words, offset); + }, + }); + ECB.Decryptor = ECB.extend({ + processBlock: function (words, offset) { + this._cipher.decryptBlock(words, offset); + }, + }); + return ECB; +})(); + +(function () { + var C = CryptoJS; + var C_lib = C.lib; + var BlockCipher = C_lib.BlockCipher; + var C_algo = C.algo; + 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 = []; + (function () { + var d = []; + for (var i = 0; i < 256; i++) { + if (i < 128) { + d[i] = i << 1; + } else { + d[i] = (i << 1) ^ 0x11b; + } + } + var x = 0; + var xi = 0; + for (var 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; + INV_SBOX[sx] = x; + var x2 = d[x]; + var x4 = d[x2]; + var x8 = d[x4]; + 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; + 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; + if (!x) { + x = xi = 1; + } else { + x = x2 ^ d[d[d[x8 ^ x2]]]; + xi ^= d[d[xi]]; + } + } + })(); + var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]; + var AES = (C_algo.AES = BlockCipher.extend({ + _doReset: function () { + if (this._nRounds && this._keyPriorReset === this._key) { + return; + } + var key = (this._keyPriorReset = this._key); + var keyWords = key.words; + var keySize = key.sigBytes / 4; + var nRounds = (this._nRounds = keySize + 6); + var ksRows = (nRounds + 1) * 4; + var keySchedule = (this._keySchedule = []); + for (var ksRow = 0; ksRow < ksRows; ksRow++) { + if (ksRow < keySize) { + keySchedule[ksRow] = keyWords[ksRow]; + } else { + var t = keySchedule[ksRow - 1]; + if (!(ksRow % keySize)) { + t = (t << 8) | (t >>> 24); + t = + (SBOX[t >>> 24] << 24) | + (SBOX[(t >>> 16) & 0xff] << 16) | + (SBOX[(t >>> 8) & 0xff] << 8) | + SBOX[t & 0xff]; + t ^= RCON[(ksRow / keySize) | 0] << 24; + } else if (keySize > 6 && ksRow % keySize == 4) { + t = + (SBOX[t >>> 24] << 24) | + (SBOX[(t >>> 16) & 0xff] << 16) | + (SBOX[(t >>> 8) & 0xff] << 8) | + SBOX[t & 0xff]; + } + keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t; + } + } + 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) { + 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 + ); + 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 + ) { + var nRounds = this._nRounds; + 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]; + var ksRow = 4; + for (var round = 1; round < nRounds; round++) { + 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++]; + s0 = t0; + s1 = t1; + s2 = t2; + s3 = t3; + } + 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++]; + M[offset] = t0; + M[offset + 1] = t1; + M[offset + 2] = t2; + M[offset + 3] = t3; + }, + keySize: 256 / 32, + })); + C.AES = BlockCipher._createHelper(AES); +})(); + +function AES_Encrypt(word, key) { + var key = CryptoJS.enc.Utf8.parse(key); + var srcs = CryptoJS.enc.Utf8.parse(word); + var encrypted = CryptoJS.AES.encrypt(srcs, key, { + mode: CryptoJS.mode.ECB, + padding: CryptoJS.pad.Pkcs7, + }); + return encrypted.toString(); +} +function AES_Decrypt(word, key) { + var key = CryptoJS.enc.Utf8.parse(key); + var srcs = word; + var decrypt = CryptoJS.AES.decrypt(srcs, key, { + mode: CryptoJS.mode.ECB, + padding: CryptoJS.pad.Pkcs7, + }); + return decrypt.toString(CryptoJS.enc.Utf8); +} + +class Env { + constructor(name) { + this.name = name; + console.log(`\ud83d\udd14${this.name},\u5f00\u59cb!`); + } + async get(url, headers) { + try { + this.result = await axios.get(url, { headers }); + return this.result.data; + } catch (err) { + console.log(`error:${err.message}`); + } + } + async post(url, data, headers) { + try { + this.result = await axios.post(url, data, { headers: headers }); + return this.result.data; + } catch (err) { + console.log(`error:${err.message}`); + } + } + async SendMsg(message) { + if (!message) return; + if (Notify > 0) { + var notify = require("./sendNotify"); + await notify.sendNotify(this.name, message); + } + } + addMsg(msg) { + if (!this._msg) this._msg = ""; + console.log(msg); + this._msg += msg + "\n"; + } + wait(delay) { + return new Promise((res) => { + setTimeout(res, delay * 1000); + }); + } + getToken(key) { + let tmp = process.env[key]; + if (!tmp) return ""; + + if (tmp.includes("@")) { + let arr = tmp.split("&"); + arr = arr.map((value) => { + let tmp = value.split("@"); + return [tmp[0], tmp[1]]; + }); + return arr.length > 0 ? arr : ""; + } + + let arr = tmp.split("&"); + return arr.length > 0 ? arr : ""; + } + done() { + console.log(`\ud83d\udd14${this.name},\u7ed3\u675f!`); + } +} + +let $ = new Env("书亦烧仙草"); + +const Notify = 1; + +async function signIn(auth) { + //getVCode + let headers = { + auth, + hostname: "scrm-prod.shuyi.org.cn", + "content-type": "application/json", + host: "scrm-prod.shuyi.org.cn", + "User-Agent": + "Mozilla/5.0 (Linux; Android 10; V2203A Build/SP1A.210812.003; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/107.0.5304.141 Mobile Safari/537.36 XWEB/5023 MMWEBSDK/20221012 MMWEBID/1571 MicroMessenger/8.0.30.2260(0x28001E55) WeChat/arm64 Weixin NetType/WIFI Language/zh_CN ABI/arm64 MiniProgramEnv/android", + }; + let url = + "https://scrm-prod.shuyi.org.cn/saas-gateway/api/agg-trade/v1/signIn/getVCode"; + let data = { + captchaType: "blockPuzzle", + clientUid: "", + ts: new Date().getTime(), + }; + let res = await $.post(url, data, headers); + let { + secretKey, + token, + jigsawImageBase64: img1, + originalImageBase64: img2, + } = res.data; + + img1 = cv.imdecode(Buffer.from(img1, "base64")); + + img2 = cv.imdecode(Buffer.from(img2, "base64")); + + const matched = img1.matchTemplate(img2, cv.TM_CCOEFF_NORMED); + const matchedPoints = matched.minMaxLoc(); + const x = matchedPoints.maxLoc.x; + + url = + "https://scrm-prod.shuyi.org.cn/saas-gateway/api/agg-trade/v1/signIn/checkVCode"; + let pointJson = AES_Encrypt(JSON.stringify({ x, y: 5 }), secretKey); + data = { captchaType: "blockPuzzle", pointJson, token }; + res = await $.post(url, data, headers); + + let captchaVerification = AES_Encrypt( + token + "---" + JSON.stringify({ x, y: 5 }), + secretKey + ); + url = + "https://scrm-prod.shuyi.org.cn/saas-gateway/api/agg-trade/v1/signIn/insertSignInV3"; + data = `{"captchaVerification":"${captchaVerification}"}`; + res = await $.post(url, data, headers); + if (res.resultMsg == "success") { + $.addMsg("签到成功"); + } else { + $.addMsg(res.resultMsg); + } +} + +(async () => { + let arr = $.getToken("sysxc"); + if (!arr) return await $.SendMsg("未填写token"); + + for (let index = 0; index < arr.length; index++) { + $.addMsg(`账号${index + 1}:`); + await signIn(arr[index]); + } + await $.SendMsg($._msg); + $.done(); +})();