惯例明码加密
样例：
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
}