惯例明码加密
样例：
import { CryptoJs } from "@/js/crypto.js"; let passwordVal = CryptoJs().Base64.stringify(CryptoJs().HmacSha256(this.password, 'Meiauto$'));crypto.js 源码
export const CryptoJs = () => { const CryptoJs = {} class Base { /** * Extends this object and runs the init method. * Arguments to create() will be passed to init(). * * @return {Object} The new object. * * @static * * @example * * var instance = MyType.create(); */ static create(...args) { return new this(...args); } /** * Copies properties into this object. * * @param {Object} properties The properties to mix in. * * @example * * MyType.mixIn({ * field: 'value' * }); */ mixIn(properties) { return Object.assign(this, properties); } /** * Creates a copy of this object. * * @return {Object} The clone. * * @example * * var clone = instance.clone(); */ clone() { const clone = new this.constructor(); Object.assign(clone, this); return clone; } } class WordArray extends Base { /** * Initializes a newly created word array. * * @param {Array} words (Optional) An array of 32-bit words. * @param {number} sigBytes (Optional) The number of significant bytes in the words. * * @example * * var wordArray = CryptoJS.lib.WordArray.create(); * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]); * var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6); */ constructor(words = [], sigBytes = words.length * 4) { super(); let typedArray = words; // Convert buffers to uint8 if (typedArray instanceof ArrayBuffer) { typedArray = new Uint8Array(typedArray); } // Convert other array views to uint8 if ( typedArray instanceof Int8Array || typedArray instanceof Uint8ClampedArray || typedArray instanceof Int16Array || typedArray instanceof Uint16Array || typedArray instanceof Int32Array || typedArray instanceof Uint32Array || typedArray instanceof Float32Array || typedArray instanceof Float64Array ) { typedArray = new Uint8Array(typedArray.buffer, typedArray.byteOffset, typedArray.byteLength); } // Handle Uint8Array if (typedArray instanceof Uint8Array) { // Shortcut const typedArrayByteLength = typedArray.byteLength; // Extract bytes const _words = []; for (let i = 0; i < typedArrayByteLength; i += 1) { _words[i >>> 2] |= typedArray[i] << (24 - (i % 4) * 8); } // Initialize this word array this.words = _words; this.sigBytes = typedArrayByteLength; } else { // Else call normal init this.words = words; this.sigBytes = sigBytes; } } /** * Creates a word array filled with random bytes. * * @param {number} nBytes The number of random bytes to generate. * * @return {WordArray} The random word array. * * @static * * @example * * var wordArray = CryptoJS.lib.WordArray.random(16); */ static random(nBytes) { const words = []; const r = (m_w) => { let _m_w = m_w; let _m_z = 0x3ade68b1; const mask = 0xffffffff; return () => { _m_z = (0x9069 * (_m_z & 0xFFFF) + (_m_z >> 0x10)) & mask; _m_w = (0x4650 * (_m_w & 0xFFFF) + (_m_w >> 0x10)) & mask; let result = ((_m_z << 0x10) + _m_w) & mask; result /= 0x100000000; result += 0.5; return result * (Math.random() > 0.5 ? 1 : -1); }; }; for (let i = 0, rcache; i < nBytes; i += 4) { const _r = r((rcache || Math.random()) * 0x100000000); rcache = _r() * 0x3ade67b7; words.push((_r() * 0x100000000) | 0); } return new WordArray(words, nBytes); } /** * Converts this word array to a string. * * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex * * @return {string} The stringified word array. * * @example * * var string = wordArray + ''; * var string = wordArray.toString(); * var string = wordArray.toString(CryptoJS.enc.Utf8); */ toString(encoder = Hex) { return encoder.stringify(this); } /** * Concatenates a word array to this word array. * * @param {WordArray} wordArray The word array to append. * * @return {WordArray} This word array. * * @example * * wordArray1.concat(wordArray2); */ concat(wordArray) { // Shortcuts const thisWords = this.words; const thatWords = wordArray.words; const thisSigBytes = this.sigBytes; const thatSigBytes = wordArray.sigBytes; // Clamp excess bits this.clamp(); // Concat if (thisSigBytes % 4) { // Copy one byte at a time for (let i = 0; i < thatSigBytes; i += 1) { const thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8); } } else { // Copy one word at a time for (let i = 0; i < thatSigBytes; i += 4) { thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2]; } } this.sigBytes += thatSigBytes; // Chainable return this; } /** * Removes insignificant bits. * * @example * * wordArray.clamp(); */ clamp() { // Shortcuts const { words, sigBytes } = this; // Clamp words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8); words.length = Math.ceil(sigBytes / 4); } /** * Creates a copy of this word array. * * @return {WordArray} The clone. * * @example * * var clone = wordArray.clone(); */ clone() { const clone = super.clone.call(this); clone.words = this.words.slice(0); return clone; } } const Latin1 = { /** * Converts a word array to a Latin1 string. * * @param {WordArray} wordArray The word array. * * @return {string} The Latin1 string. * * @static * * @example * * var latin1String = CryptoJS.enc.Latin1.stringify(wordArray); */ stringify(wordArray) { // Shortcuts const { words, sigBytes } = wordArray; // Convert const latin1Chars = []; for (let i = 0; i < sigBytes; i += 1) { const bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; latin1Chars.push(String.fromCharCode(bite)); } return latin1Chars.join(''); }, /** * Converts a Latin1 string to a word array. * * @param {string} latin1Str The Latin1 string. * * @return {WordArray} The word array. * * @static * * @example * * var wordArray = CryptoJS.enc.Latin1.parse(latin1String); */ parse(latin1Str) { // Shortcut const latin1StrLength = latin1Str.length; // Convert const words = []; for (let i = 0; i < latin1StrLength; i += 1) { words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8); } return new WordArray(words, latin1StrLength); }, }; const Utf8 = { /** * Converts a word array to a UTF-8 string. * * @param {WordArray} wordArray The word array. * * @return {string} The UTF-8 string. * * @static * * @example * * var utf8String = CryptoJS.enc.Utf8.stringify(wordArray); */ stringify(wordArray) { try { return decodeURIComponent(escape(Latin1.stringify(wordArray))); } catch (e) { throw new Error('Malformed UTF-8 data'); } }, /** * Converts a UTF-8 string to a word array. * * @param {string} utf8Str The UTF-8 string. * * @return {WordArray} The word array. * * @static * * @example * * var wordArray = CryptoJS.enc.Utf8.parse(utf8String); */ parse(utf8Str) { return Latin1.parse(unescape(encodeURIComponent(utf8Str))); }, }; class BufferedBlockAlgorithm extends Base { constructor() { super(); this._minBufferSize = 0; } /** * Resets this block algorithm's data buffer to its initial state. * * @example * * bufferedBlockAlgorithm.reset(); */ reset() { // Initial values this._data = new WordArray(); this._nDataBytes = 0; } /** * Adds new data to this block algorithm's buffer. * * @param {WordArray|string} data * * The data to append. Strings are converted to a WordArray using UTF-8. * * @example * * bufferedBlockAlgorithm._append('data'); * bufferedBlockAlgorithm._append(wordArray); */ _append(data) { let m_data = data; // Convert string to WordArray, else assume WordArray already if (typeof m_data === 'string') { m_data = Utf8.parse(m_data); } // Append this._data.concat(m_data); this._nDataBytes += m_data.sigBytes; } /** * Processes available data blocks. * * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype. * * @param {boolean} doFlush Whether all blocks and partial blocks should be processed. * * @return {WordArray} The processed data. * * @example * * var processedData = bufferedBlockAlgorithm._process(); * var processedData = bufferedBlockAlgorithm._process(!!'flush'); */ _process(doFlush) { let processedWords; // Shortcuts const { _data: data, blockSize } = this; const dataWords = data.words; const dataSigBytes = data.sigBytes; const blockSizeBytes = blockSize * 4; // Count blocks ready let nBlocksReady = dataSigBytes / blockSizeBytes; if (doFlush) { // Round up to include partial blocks nBlocksReady = Math.ceil(nBlocksReady); } else { // Round down to include only full blocks, // less the number of blocks that must remain in the buffer nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0); } // Count words ready const nWordsReady = nBlocksReady * blockSize; // Count bytes ready const nBytesReady = Math.min(nWordsReady * 4, dataSigBytes); // Process blocks if (nWordsReady) { for (let offset = 0; offset < nWordsReady; offset += blockSize) { // Perform concrete-algorithm logic this._doProcessBlock(dataWords, offset); } // Remove processed words processedWords = dataWords.splice(0, nWordsReady); data.sigBytes -= nBytesReady; } // Return processed words return new WordArray(processedWords, nBytesReady); } /** * Creates a copy of this object. * * @return {Object} The clone. * * @example * * var clone = bufferedBlockAlgorithm.clone(); */ clone() { const clone = super.clone.call(this); clone._data = this._data.clone(); return clone; } } class Hasher extends BufferedBlockAlgorithm { constructor(cfg) { super(); this.blockSize = 512 / 32; /** * Configuration options. */ this.cfg = Object.assign(new Base(), cfg); // Set initial values this.reset(); } /** * Creates a shortcut function to a hasher's object interface. * * @param {Hasher} SubHasher The hasher to create a helper for. * * @return {Function} The shortcut function. * * @static * * @example * * var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256); */ static _createHelper(SubHasher) { return (message, cfg) => new SubHasher(cfg).finalize(message); } /** * Creates a shortcut function to the HMAC's object interface. * * @param {Hasher} SubHasher The hasher to use in this HMAC helper. * * @return {Function} The shortcut function. * * @static * * @example * * var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256); */ static _createHmacHelper(SubHasher) { return (message, key) => new HMAC(SubHasher, key).finalize(message); } /** * Resets this hasher to its initial state. * * @example * * hasher.reset(); */ reset() { // Reset data buffer super.reset.call(this); // Perform concrete-hasher logic this._doReset(); } /** * Updates this hasher with a message. * * @param {WordArray|string} messageUpdate The message to append. * * @return {Hasher} This hasher. * * @example * * hasher.update('message'); * hasher.update(wordArray); */ update(messageUpdate) { // Append this._append(messageUpdate); // Update the hash this._process(); // Chainable return this; } /** * Finalizes the hash computation. * Note that the finalize operation is effectively a destructive, read-once operation. * * @param {WordArray|string} messageUpdate (Optional) A final message update. * * @return {WordArray} The hash. * * @example * * var hash = hasher.finalize(); * var hash = hasher.finalize('message'); * var hash = hasher.finalize(wordArray); */ finalize(messageUpdate) { // Final message update if (messageUpdate) { this._append(messageUpdate); } // Perform concrete-hasher logic const hash = this._doFinalize(); return hash; } } class HMAC extends Base { /** * Initializes a newly created HMAC. * * @param {Hasher} SubHasher The hash algorithm to use. * @param {WordArray|string} key The secret key. * * @example * * var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key); */ constructor(SubHasher, key) { super(); const hasher = new SubHasher(); this._hasher = hasher; // Convert string to WordArray, else assume WordArray already let _key = key; if (typeof _key === 'string') { _key = Utf8.parse(_key); } // Shortcuts const hasherBlockSize = hasher.blockSize; const hasherBlockSizeBytes = hasherBlockSize * 4; // Allow arbitrary length keys if (_key.sigBytes > hasherBlockSizeBytes) { _key = hasher.finalize(key); } // Clamp excess bits _key.clamp(); // Clone key for inner and outer pads const oKey = _key.clone(); this._oKey = oKey; const iKey = _key.clone(); this._iKey = iKey; // Shortcuts const oKeyWords = oKey.words; const iKeyWords = iKey.words; // XOR keys with pad constants for (let i = 0; i < hasherBlockSize; i += 1) { oKeyWords[i] ^= 0x5c5c5c5c; iKeyWords[i] ^= 0x36363636; } oKey.sigBytes = hasherBlockSizeBytes; iKey.sigBytes = hasherBlockSizeBytes; // Set initial values this.reset(); } /** * Resets this HMAC to its initial state. * * @example * * hmacHasher.reset(); */ reset() { // Shortcut const hasher = this._hasher; // Reset hasher.reset(); hasher.update(this._iKey); } /** * Updates this HMAC with a message. * * @param {WordArray|string} messageUpdate The message to append. * * @return {HMAC} This HMAC instance. * * @example * * hmacHasher.update('message'); * hmacHasher.update(wordArray); */ update(messageUpdate) { this._hasher.update(messageUpdate); // Chainable return this; } /** * Finalizes the HMAC computation. * Note that the finalize operation is effectively a destructive, read-once operation. * * @param {WordArray|string} messageUpdate (Optional) A final message update. * * @return {WordArray} The HMAC. * * @example * * var hmac = hmacHasher.finalize(); * var hmac = hmacHasher.finalize('message'); * var hmac = hmacHasher.finalize(wordArray); */ finalize(messageUpdate) { // Shortcut const hasher = this._hasher; // Compute HMAC const innerHash = hasher.finalize(messageUpdate); hasher.reset(); const hmac = hasher.finalize(this._oKey.clone().concat(innerHash)); return hmac; } } // Initialization and round constants tables const H = []; const K = []; // Compute constants const isPrime = (n) => { const sqrtN = Math.sqrt(n); for (let factor = 2; factor <= sqrtN; factor += 1) { if (!(n % factor)) { return false; } } return true; }; const getFractionalBits = n => ((n - (n | 0)) * 0x100000000) | 0; let n = 2; let nPrime = 0; while (nPrime < 64) { if (isPrime(n)) { if (nPrime < 8) { H[nPrime] = getFractionalBits(n ** (1 / 2)); } K[nPrime] = getFractionalBits(n ** (1 / 3)); nPrime += 1; } n += 1; } // Reusable object const W = []; class SHA256Algo extends Hasher { _doReset() { this._hash = new WordArray(H.slice(0)); } _doProcessBlock(M, offset) { // Shortcut const _H = this._hash.words; // Working variables let a = _H[0]; let b = _H[1]; let c = _H[2]; let d = _H[3]; let e = _H[4]; let f = _H[5]; let g = _H[6]; let h = _H[7]; // Computation for (let i = 0; i < 64; i += 1) { if (i < 16) { W[i] = M[offset + i] | 0; } else { const gamma0x = W[i - 15]; const gamma0 = ((gamma0x << 25) | (gamma0x >>> 7)) ^ ((gamma0x << 14) | (gamma0x >>> 18)) ^ (gamma0x >>> 3); const gamma1x = W[i - 2]; const gamma1 = ((gamma1x << 15) | (gamma1x >>> 17)) ^ ((gamma1x << 13) | (gamma1x >>> 19)) ^ (gamma1x >>> 10); W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]; } const ch = (e & f) ^ (~e & g); const maj = (a & b) ^ (a & c) ^ (b & c); const sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22)); const sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7) | (e >>> 25)); const t1 = h + sigma1 + ch + K[i] + W[i]; const t2 = sigma0 + maj; h = g; g = f; f = e; e = (d + t1) | 0; d = c; c = b; b = a; a = (t1 + t2) | 0; } // Intermediate hash value _H[0] = (_H[0] + a) | 0; _H[1] = (_H[1] + b) | 0; _H[2] = (_H[2] + c) | 0; _H[3] = (_H[3] + d) | 0; _H[4] = (_H[4] + e) | 0; _H[5] = (_H[5] + f) | 0; _H[6] = (_H[6] + g) | 0; _H[7] = (_H[7] + h) | 0; } _doFinalize() { // Shortcuts const data = this._data; const dataWords = data.words; const nBitsTotal = this._nDataBytes * 8; const nBitsLeft = data.sigBytes * 8; // Add padding dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - (nBitsLeft % 32)); dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000); dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal; data.sigBytes = dataWords.length * 4; // Hash final blocks this._process(); // Return final computed hash return this._hash; } clone() { const clone = super.clone.call(this); clone._hash = this._hash.clone(); return clone; } } CryptoJs.HmacSha256 = Hasher._createHmacHelper(SHA256Algo); CryptoJs.Base64 = { stringify: function (wordArray) { // Shortcuts const words = wordArray.words; const sigBytes = wordArray.sigBytes; const map = this._map; // Clamp excess bits wordArray.clamp(); // Convert const base64Chars = []; for (let i = 0; i < sigBytes; i += 3) { const byte1 = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff; const byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff; const byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff; const triplet = (byte1 << 16) | (byte2 << 8) | byte3; for (let j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) { base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f)); } } // Add padding const paddingChar = map.charAt(64); if (paddingChar) { while (base64Chars.length % 4) { base64Chars.push(paddingChar); } } return base64Chars.join(''); }, _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=' } return CryptoJs}