You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3077 lines
76 KiB
3077 lines
76 KiB
|
|
;(function(root,factory){
|
|
if(typeof exports==="object"){
|
|
module.exports=exports=factory();
|
|
}else if(typeof define==="function"&&define.amd){
|
|
define([],factory);
|
|
}else{
|
|
root.CryptoJS=factory();
|
|
}
|
|
}(this,
|
|
function(){
|
|
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=[];
|
|
for(var i=0;i<nBytes;i+=4){
|
|
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(undefined){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var Base=C_lib.Base;
|
|
var X32WordArray=C_lib.WordArray;
|
|
var C_x64=C.x64={};
|
|
var X64Word=C_x64.Word=Base.extend({
|
|
init:function(high,low){
|
|
this.high=high;
|
|
this.low=low;
|
|
}
|
|
});
|
|
var X64WordArray=C_x64.WordArray=Base.extend({
|
|
init:function(words,sigBytes){
|
|
words=this.words=words||[];
|
|
if(sigBytes!=undefined){
|
|
this.sigBytes=sigBytes;
|
|
}else{
|
|
this.sigBytes=words.length*8;
|
|
}
|
|
},
|
|
toX32:function(){
|
|
var x64Words=this.words;
|
|
var x64WordsLength=x64Words.length;
|
|
var x32Words=[];
|
|
for(var i=0;i<x64WordsLength;i++){
|
|
var x64Word=x64Words[i];
|
|
x32Words.push(x64Word.high);
|
|
x32Words.push(x64Word.low);
|
|
}
|
|
return X32WordArray.create(x32Words,this.sigBytes);
|
|
},
|
|
clone:function(){
|
|
var clone=Base.clone.call(this);
|
|
var words=clone.words=this.words.slice(0);
|
|
var wordsLength=words.length;
|
|
for(var i=0;i<wordsLength;i++){
|
|
words[i]=words[i].clone();
|
|
}
|
|
return clone;
|
|
}
|
|
});
|
|
}());
|
|
(function(){
|
|
if(typeof ArrayBuffer!='function'){
|
|
return;
|
|
}
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var superInit=WordArray.init;
|
|
var subInit=WordArray.init=function(typedArray){
|
|
if(typedArray instanceof ArrayBuffer){
|
|
typedArray=new Uint8Array(typedArray);
|
|
}
|
|
if(typedArray instanceof Int8Array||(typeof Uint8ClampedArray!=="undefined"&&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);
|
|
}
|
|
if(typedArray instanceof Uint8Array){
|
|
var typedArrayByteLength=typedArray.byteLength;
|
|
var words=[];
|
|
for(var i=0;i<typedArrayByteLength;i++){
|
|
words[i>>>2]|=typedArray[i]<<(24-(i%4)*8);
|
|
}
|
|
superInit.call(this,words,typedArrayByteLength);
|
|
}else{
|
|
superInit.apply(this,arguments);
|
|
}
|
|
};
|
|
subInit.prototype=WordArray;
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var C_enc=C.enc;
|
|
var Utf16BE=C_enc.Utf16=C_enc.Utf16BE={
|
|
stringify:function(wordArray){
|
|
var words=wordArray.words;
|
|
var sigBytes=wordArray.sigBytes;
|
|
var utf16Chars=[];
|
|
for(var i=0;i<sigBytes;i+=2){
|
|
var codePoint=(words[i>>>2]>>>(16-(i%4)*8))&0xffff;
|
|
utf16Chars.push(String.fromCharCode(codePoint));
|
|
}
|
|
return utf16Chars.join('');
|
|
},
|
|
parse:function(utf16Str){
|
|
var utf16StrLength=utf16Str.length;
|
|
var words=[];
|
|
for(var i=0;i<utf16StrLength;i++){
|
|
words[i>>>1]|=utf16Str.charCodeAt(i)<<(16-(i%2)*16);
|
|
}
|
|
return WordArray.create(words,utf16StrLength*2);
|
|
}
|
|
};
|
|
C_enc.Utf16LE={
|
|
stringify:function(wordArray){
|
|
var words=wordArray.words;
|
|
var sigBytes=wordArray.sigBytes;
|
|
var utf16Chars=[];
|
|
for(var i=0;i<sigBytes;i+=2){
|
|
var codePoint=swapEndian((words[i>>>2]>>>(16-(i%4)*8))&0xffff);
|
|
utf16Chars.push(String.fromCharCode(codePoint));
|
|
}
|
|
return utf16Chars.join('');
|
|
},
|
|
parse:function(utf16Str){
|
|
var utf16StrLength=utf16Str.length;
|
|
var words=[];
|
|
for(var i=0;i<utf16StrLength;i++){
|
|
words[i>>>1]|=swapEndian(utf16Str.charCodeAt(i)<<(16-(i%2)*16));
|
|
}
|
|
return WordArray.create(words,utf16StrLength*2);
|
|
}
|
|
};
|
|
function swapEndian(word){
|
|
return((word<<8)&0xff00ff00)|((word>>>8)&0x00ff00ff);
|
|
}
|
|
}());
|
|
(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);
|
|
var bitsCombined=bits1|bits2;
|
|
words[nBytes>>>2]|=bitsCombined<<(24-(nBytes%4)*8);
|
|
nBytes++;
|
|
}
|
|
}
|
|
return WordArray.create(words,nBytes);
|
|
}
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var C_enc=C.enc;
|
|
var Base64url=C_enc.Base64url={
|
|
stringify:function(wordArray,urlSafe=true){
|
|
var words=wordArray.words;
|
|
var sigBytes=wordArray.sigBytes;
|
|
var map=urlSafe?this._safe_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,urlSafe=true){
|
|
var base64StrLength=base64Str.length;
|
|
var map=urlSafe?this._safe_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+/=',
|
|
_safe_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);
|
|
var bitsCombined=bits1|bits2;
|
|
words[nBytes>>>2]|=bitsCombined<<(24-(nBytes%4)*8);
|
|
nBytes++;
|
|
}
|
|
}
|
|
return WordArray.create(words,nBytes);
|
|
}
|
|
}());
|
|
(function(Math){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_algo=C.algo;
|
|
var T=[];
|
|
(function(){
|
|
for(var i=0;i<64;i++){
|
|
T[i]=(Math.abs(Math.sin(i+1))*0x100000000)|0;
|
|
}
|
|
}());
|
|
var MD5=C_algo.MD5=Hasher.extend({
|
|
_doReset:function(){
|
|
this._hash=new WordArray.init([0x67452301,0xefcdab89,0x98badcfe,0x10325476]);
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
for(var i=0;i<16;i++){
|
|
var offset_i=offset+i;
|
|
var M_offset_i=M[offset_i];
|
|
M[offset_i]=((((M_offset_i<<8)|(M_offset_i>>>24))&0x00ff00ff)|(((M_offset_i<<24)|(M_offset_i>>>8))&0xff00ff00));
|
|
}
|
|
var H=this._hash.words;
|
|
var M_offset_0=M[offset+0];
|
|
var M_offset_1=M[offset+1];
|
|
var M_offset_2=M[offset+2];
|
|
var M_offset_3=M[offset+3];
|
|
var M_offset_4=M[offset+4];
|
|
var M_offset_5=M[offset+5];
|
|
var M_offset_6=M[offset+6];
|
|
var M_offset_7=M[offset+7];
|
|
var M_offset_8=M[offset+8];
|
|
var M_offset_9=M[offset+9];
|
|
var M_offset_10=M[offset+10];
|
|
var M_offset_11=M[offset+11];
|
|
var M_offset_12=M[offset+12];
|
|
var M_offset_13=M[offset+13];
|
|
var M_offset_14=M[offset+14];
|
|
var M_offset_15=M[offset+15];
|
|
var a=H[0];
|
|
var b=H[1];
|
|
var c=H[2];
|
|
var d=H[3];
|
|
a=FF(a,b,c,d,M_offset_0,7,T[0]);
|
|
d=FF(d,a,b,c,M_offset_1,12,T[1]);
|
|
c=FF(c,d,a,b,M_offset_2,17,T[2]);
|
|
b=FF(b,c,d,a,M_offset_3,22,T[3]);
|
|
a=FF(a,b,c,d,M_offset_4,7,T[4]);
|
|
d=FF(d,a,b,c,M_offset_5,12,T[5]);
|
|
c=FF(c,d,a,b,M_offset_6,17,T[6]);
|
|
b=FF(b,c,d,a,M_offset_7,22,T[7]);
|
|
a=FF(a,b,c,d,M_offset_8,7,T[8]);
|
|
d=FF(d,a,b,c,M_offset_9,12,T[9]);
|
|
c=FF(c,d,a,b,M_offset_10,17,T[10]);
|
|
b=FF(b,c,d,a,M_offset_11,22,T[11]);
|
|
a=FF(a,b,c,d,M_offset_12,7,T[12]);
|
|
d=FF(d,a,b,c,M_offset_13,12,T[13]);
|
|
c=FF(c,d,a,b,M_offset_14,17,T[14]);
|
|
b=FF(b,c,d,a,M_offset_15,22,T[15]);
|
|
a=GG(a,b,c,d,M_offset_1,5,T[16]);
|
|
d=GG(d,a,b,c,M_offset_6,9,T[17]);
|
|
c=GG(c,d,a,b,M_offset_11,14,T[18]);
|
|
b=GG(b,c,d,a,M_offset_0,20,T[19]);
|
|
a=GG(a,b,c,d,M_offset_5,5,T[20]);
|
|
d=GG(d,a,b,c,M_offset_10,9,T[21]);
|
|
c=GG(c,d,a,b,M_offset_15,14,T[22]);
|
|
b=GG(b,c,d,a,M_offset_4,20,T[23]);
|
|
a=GG(a,b,c,d,M_offset_9,5,T[24]);
|
|
d=GG(d,a,b,c,M_offset_14,9,T[25]);
|
|
c=GG(c,d,a,b,M_offset_3,14,T[26]);
|
|
b=GG(b,c,d,a,M_offset_8,20,T[27]);
|
|
a=GG(a,b,c,d,M_offset_13,5,T[28]);
|
|
d=GG(d,a,b,c,M_offset_2,9,T[29]);
|
|
c=GG(c,d,a,b,M_offset_7,14,T[30]);
|
|
b=GG(b,c,d,a,M_offset_12,20,T[31]);
|
|
a=HH(a,b,c,d,M_offset_5,4,T[32]);
|
|
d=HH(d,a,b,c,M_offset_8,11,T[33]);
|
|
c=HH(c,d,a,b,M_offset_11,16,T[34]);
|
|
b=HH(b,c,d,a,M_offset_14,23,T[35]);
|
|
a=HH(a,b,c,d,M_offset_1,4,T[36]);
|
|
d=HH(d,a,b,c,M_offset_4,11,T[37]);
|
|
c=HH(c,d,a,b,M_offset_7,16,T[38]);
|
|
b=HH(b,c,d,a,M_offset_10,23,T[39]);
|
|
a=HH(a,b,c,d,M_offset_13,4,T[40]);
|
|
d=HH(d,a,b,c,M_offset_0,11,T[41]);
|
|
c=HH(c,d,a,b,M_offset_3,16,T[42]);
|
|
b=HH(b,c,d,a,M_offset_6,23,T[43]);
|
|
a=HH(a,b,c,d,M_offset_9,4,T[44]);
|
|
d=HH(d,a,b,c,M_offset_12,11,T[45]);
|
|
c=HH(c,d,a,b,M_offset_15,16,T[46]);
|
|
b=HH(b,c,d,a,M_offset_2,23,T[47]);
|
|
a=II(a,b,c,d,M_offset_0,6,T[48]);
|
|
d=II(d,a,b,c,M_offset_7,10,T[49]);
|
|
c=II(c,d,a,b,M_offset_14,15,T[50]);
|
|
b=II(b,c,d,a,M_offset_5,21,T[51]);
|
|
a=II(a,b,c,d,M_offset_12,6,T[52]);
|
|
d=II(d,a,b,c,M_offset_3,10,T[53]);
|
|
c=II(c,d,a,b,M_offset_10,15,T[54]);
|
|
b=II(b,c,d,a,M_offset_1,21,T[55]);
|
|
a=II(a,b,c,d,M_offset_8,6,T[56]);
|
|
d=II(d,a,b,c,M_offset_15,10,T[57]);
|
|
c=II(c,d,a,b,M_offset_6,15,T[58]);
|
|
b=II(b,c,d,a,M_offset_13,21,T[59]);
|
|
a=II(a,b,c,d,M_offset_4,6,T[60]);
|
|
d=II(d,a,b,c,M_offset_11,10,T[61]);
|
|
c=II(c,d,a,b,M_offset_2,15,T[62]);
|
|
b=II(b,c,d,a,M_offset_9,21,T[63]);
|
|
H[0]=(H[0]+a)|0;
|
|
H[1]=(H[1]+b)|0;
|
|
H[2]=(H[2]+c)|0;
|
|
H[3]=(H[3]+d)|0;
|
|
},
|
|
_doFinalize:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
dataWords[nBitsLeft>>>5]|=0x80<<(24-nBitsLeft%32);
|
|
var nBitsTotalH=Math.floor(nBitsTotal/0x100000000);
|
|
var nBitsTotalL=nBitsTotal;
|
|
dataWords[(((nBitsLeft+64)>>>9)<<4)+15]=((((nBitsTotalH<<8)|(nBitsTotalH>>>24))&0x00ff00ff)|(((nBitsTotalH<<24)|(nBitsTotalH>>>8))&0xff00ff00));
|
|
dataWords[(((nBitsLeft+64)>>>9)<<4)+14]=((((nBitsTotalL<<8)|(nBitsTotalL>>>24))&0x00ff00ff)|(((nBitsTotalL<<24)|(nBitsTotalL>>>8))&0xff00ff00));
|
|
data.sigBytes=(dataWords.length+1)*4;
|
|
this._process();
|
|
var hash=this._hash;
|
|
var H=hash.words;
|
|
for(var i=0;i<4;i++){
|
|
var H_i=H[i];
|
|
H[i]=(((H_i<<8)|(H_i>>>24))&0x00ff00ff)|(((H_i<<24)|(H_i>>>8))&0xff00ff00);
|
|
}
|
|
return hash;
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
clone._hash=this._hash.clone();
|
|
return clone;
|
|
}
|
|
});
|
|
function FF(a,b,c,d,x,s,t){
|
|
var n=a+((b&c)|(~b&d))+x+t;
|
|
return((n<<s)|(n>>>(32-s)))+b;
|
|
}
|
|
function GG(a,b,c,d,x,s,t){
|
|
var n=a+((b&d)|(c&~d))+x+t;
|
|
return((n<<s)|(n>>>(32-s)))+b;
|
|
}
|
|
function HH(a,b,c,d,x,s,t){
|
|
var n=a+(b^c^d)+x+t;
|
|
return((n<<s)|(n>>>(32-s)))+b;
|
|
}
|
|
function II(a,b,c,d,x,s,t){
|
|
var n=a+(c^(b|~d))+x+t;
|
|
return((n<<s)|(n>>>(32-s)))+b;
|
|
}
|
|
C.MD5=Hasher._createHelper(MD5);
|
|
C.HmacMD5=Hasher._createHmacHelper(MD5);
|
|
}(Math));
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_algo=C.algo;
|
|
var W=[];
|
|
var SHA1=C_algo.SHA1=Hasher.extend({
|
|
_doReset:function(){
|
|
this._hash=new WordArray.init([0x67452301,0xefcdab89,0x98badcfe,0x10325476,0xc3d2e1f0]);
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var H=this._hash.words;
|
|
var a=H[0];
|
|
var b=H[1];
|
|
var c=H[2];
|
|
var d=H[3];
|
|
var e=H[4];
|
|
for(var i=0;i<80;i++){
|
|
if(i<16){
|
|
W[i]=M[offset+i]|0;
|
|
}else{
|
|
var n=W[i-3]^W[i-8]^W[i-14]^W[i-16];
|
|
W[i]=(n<<1)|(n>>>31);
|
|
}
|
|
var t=((a<<5)|(a>>>27))+e+W[i];
|
|
if(i<20){
|
|
t+=((b&c)|(~b&d))+0x5a827999;
|
|
}else if(i<40){
|
|
t+=(b^c^d)+0x6ed9eba1;
|
|
}else if(i<60){
|
|
t+=((b&c)|(b&d)|(c&d))-0x70e44324;
|
|
}else
|
|
{
|
|
t+=(b^c^d)-0x359d3e2a;
|
|
}
|
|
e=d;
|
|
d=c;
|
|
c=(b<<30)|(b>>>2);
|
|
b=a;
|
|
a=t;
|
|
}
|
|
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;
|
|
},
|
|
_doFinalize:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
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;
|
|
this._process();
|
|
return this._hash;
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
clone._hash=this._hash.clone();
|
|
return clone;
|
|
}
|
|
});
|
|
C.SHA1=Hasher._createHelper(SHA1);
|
|
C.HmacSHA1=Hasher._createHmacHelper(SHA1);
|
|
}());
|
|
(function(Math){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_algo=C.algo;
|
|
var H=[];
|
|
var K=[];
|
|
(function(){
|
|
function isPrime(n){
|
|
var sqrtN=Math.sqrt(n);
|
|
for(var factor=2;factor<=sqrtN;factor++){
|
|
if(!(n%factor)){
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
function getFractionalBits(n){
|
|
return((n-(n|0))*0x100000000)|0;
|
|
}
|
|
var n=2;
|
|
var nPrime=0;
|
|
while(nPrime<64){
|
|
if(isPrime(n)){
|
|
if(nPrime<8){
|
|
H[nPrime]=getFractionalBits(Math.pow(n,1/2));
|
|
}
|
|
K[nPrime]=getFractionalBits(Math.pow(n,1/3));
|
|
nPrime++;
|
|
}
|
|
n++;
|
|
}
|
|
}());
|
|
var W=[];
|
|
var SHA256=C_algo.SHA256=Hasher.extend({
|
|
_doReset:function(){
|
|
this._hash=new WordArray.init(H.slice(0));
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var H=this._hash.words;
|
|
var a=H[0];
|
|
var b=H[1];
|
|
var c=H[2];
|
|
var d=H[3];
|
|
var e=H[4];
|
|
var f=H[5];
|
|
var g=H[6];
|
|
var h=H[7];
|
|
for(var i=0;i<64;i++){
|
|
if(i<16){
|
|
W[i]=M[offset+i]|0;
|
|
}else{
|
|
var gamma0x=W[i-15];
|
|
var gamma0=((gamma0x<<25)|(gamma0x>>>7))^((gamma0x<<14)|(gamma0x>>>18))^(gamma0x>>>3);
|
|
var gamma1x=W[i-2];
|
|
var gamma1=((gamma1x<<15)|(gamma1x>>>17))^((gamma1x<<13)|(gamma1x>>>19))^(gamma1x>>>10);
|
|
W[i]=gamma0+W[i-7]+gamma1+W[i-16];
|
|
}
|
|
var ch=(e&f)^(~e&g);
|
|
var maj=(a&b)^(a&c)^(b&c);
|
|
var sigma0=((a<<30)|(a>>>2))^((a<<19)|(a>>>13))^((a<<10)|(a>>>22));
|
|
var sigma1=((e<<26)|(e>>>6))^((e<<21)|(e>>>11))^((e<<7)|(e>>>25));
|
|
var t1=h+sigma1+ch+K[i]+W[i];
|
|
var t2=sigma0+maj;
|
|
h=g;
|
|
g=f;
|
|
f=e;
|
|
e=(d+t1)|0;
|
|
d=c;
|
|
c=b;
|
|
b=a;
|
|
a=(t1+t2)|0;
|
|
}
|
|
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:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
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;
|
|
this._process();
|
|
return this._hash;
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
clone._hash=this._hash.clone();
|
|
return clone;
|
|
}
|
|
});
|
|
C.SHA256=Hasher._createHelper(SHA256);
|
|
C.HmacSHA256=Hasher._createHmacHelper(SHA256);
|
|
}(Math));
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var C_algo=C.algo;
|
|
var SHA256=C_algo.SHA256;
|
|
var SHA224=C_algo.SHA224=SHA256.extend({
|
|
_doReset:function(){
|
|
this._hash=new WordArray.init([0xc1059ed8,0x367cd507,0x3070dd17,0xf70e5939,0xffc00b31,0x68581511,0x64f98fa7,0xbefa4fa4]);
|
|
},
|
|
_doFinalize:function(){
|
|
var hash=SHA256._doFinalize.call(this);
|
|
hash.sigBytes-=4;
|
|
return hash;
|
|
}
|
|
});
|
|
C.SHA224=SHA256._createHelper(SHA224);
|
|
C.HmacSHA224=SHA256._createHmacHelper(SHA224);
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_x64=C.x64;
|
|
var X64Word=C_x64.Word;
|
|
var X64WordArray=C_x64.WordArray;
|
|
var C_algo=C.algo;
|
|
function X64Word_create(){
|
|
return X64Word.create.apply(X64Word,arguments);
|
|
}
|
|
var K=[X64Word_create(0x428a2f98,0xd728ae22),X64Word_create(0x71374491,0x23ef65cd),X64Word_create(0xb5c0fbcf,0xec4d3b2f),X64Word_create(0xe9b5dba5,0x8189dbbc),X64Word_create(0x3956c25b,0xf348b538),X64Word_create(0x59f111f1,0xb605d019),X64Word_create(0x923f82a4,0xaf194f9b),X64Word_create(0xab1c5ed5,0xda6d8118),X64Word_create(0xd807aa98,0xa3030242),X64Word_create(0x12835b01,0x45706fbe),X64Word_create(0x243185be,0x4ee4b28c),X64Word_create(0x550c7dc3,0xd5ffb4e2),X64Word_create(0x72be5d74,0xf27b896f),X64Word_create(0x80deb1fe,0x3b1696b1),X64Word_create(0x9bdc06a7,0x25c71235),X64Word_create(0xc19bf174,0xcf692694),X64Word_create(0xe49b69c1,0x9ef14ad2),X64Word_create(0xefbe4786,0x384f25e3),X64Word_create(0x0fc19dc6,0x8b8cd5b5),X64Word_create(0x240ca1cc,0x77ac9c65),X64Word_create(0x2de92c6f,0x592b0275),X64Word_create(0x4a7484aa,0x6ea6e483),X64Word_create(0x5cb0a9dc,0xbd41fbd4),X64Word_create(0x76f988da,0x831153b5),X64Word_create(0x983e5152,0xee66dfab),X64Word_create(0xa831c66d,0x2db43210),X64Word_create(0xb00327c8,0x98fb213f),X64Word_create(0xbf597fc7,0xbeef0ee4),X64Word_create(0xc6e00bf3,0x3da88fc2),X64Word_create(0xd5a79147,0x930aa725),X64Word_create(0x06ca6351,0xe003826f),X64Word_create(0x14292967,0x0a0e6e70),X64Word_create(0x27b70a85,0x46d22ffc),X64Word_create(0x2e1b2138,0x5c26c926),X64Word_create(0x4d2c6dfc,0x5ac42aed),X64Word_create(0x53380d13,0x9d95b3df),X64Word_create(0x650a7354,0x8baf63de),X64Word_create(0x766a0abb,0x3c77b2a8),X64Word_create(0x81c2c92e,0x47edaee6),X64Word_create(0x92722c85,0x1482353b),X64Word_create(0xa2bfe8a1,0x4cf10364),X64Word_create(0xa81a664b,0xbc423001),X64Word_create(0xc24b8b70,0xd0f89791),X64Word_create(0xc76c51a3,0x0654be30),X64Word_create(0xd192e819,0xd6ef5218),X64Word_create(0xd6990624,0x5565a910),X64Word_create(0xf40e3585,0x5771202a),X64Word_create(0x106aa070,0x32bbd1b8),X64Word_create(0x19a4c116,0xb8d2d0c8),X64Word_create(0x1e376c08,0x5141ab53),X64Word_create(0x2748774c,0xdf8eeb99),X64Word_create(0x34b0bcb5,0xe19b48a8),X64Word_create(0x391c0cb3,0xc5c95a63),X64Word_create(0x4ed8aa4a,0xe3418acb),X64Word_create(0x5b9cca4f,0x7763e373),X64Word_create(0x682e6ff3,0xd6b2b8a3),X64Word_create(0x748f82ee,0x5defb2fc),X64Word_create(0x78a5636f,0x43172f60),X64Word_create(0x84c87814,0xa1f0ab72),X64Word_create(0x8cc70208,0x1a6439ec),X64Word_create(0x90befffa,0x23631e28),X64Word_create(0xa4506ceb,0xde82bde9),X64Word_create(0xbef9a3f7,0xb2c67915),X64Word_create(0xc67178f2,0xe372532b),X64Word_create(0xca273ece,0xea26619c),X64Word_create(0xd186b8c7,0x21c0c207),X64Word_create(0xeada7dd6,0xcde0eb1e),X64Word_create(0xf57d4f7f,0xee6ed178),X64Word_create(0x06f067aa,0x72176fba),X64Word_create(0x0a637dc5,0xa2c898a6),X64Word_create(0x113f9804,0xbef90dae),X64Word_create(0x1b710b35,0x131c471b),X64Word_create(0x28db77f5,0x23047d84),X64Word_create(0x32caab7b,0x40c72493),X64Word_create(0x3c9ebe0a,0x15c9bebc),X64Word_create(0x431d67c4,0x9c100d4c),X64Word_create(0x4cc5d4be,0xcb3e42b6),X64Word_create(0x597f299c,0xfc657e2a),X64Word_create(0x5fcb6fab,0x3ad6faec),X64Word_create(0x6c44198c,0x4a475817)];
|
|
var W=[];(function(){
|
|
for(var i=0;i<80;i++){
|
|
W[i]=X64Word_create();
|
|
}
|
|
}());
|
|
var SHA512=C_algo.SHA512=Hasher.extend({
|
|
_doReset:function(){
|
|
this._hash=new X64WordArray.init([new X64Word.init(0x6a09e667,0xf3bcc908),new X64Word.init(0xbb67ae85,0x84caa73b),new X64Word.init(0x3c6ef372,0xfe94f82b),new X64Word.init(0xa54ff53a,0x5f1d36f1),new X64Word.init(0x510e527f,0xade682d1),new X64Word.init(0x9b05688c,0x2b3e6c1f),new X64Word.init(0x1f83d9ab,0xfb41bd6b),new X64Word.init(0x5be0cd19,0x137e2179)]);
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var H=this._hash.words;
|
|
var H0=H[0];
|
|
var H1=H[1];
|
|
var H2=H[2];
|
|
var H3=H[3];
|
|
var H4=H[4];
|
|
var H5=H[5];
|
|
var H6=H[6];
|
|
var H7=H[7];
|
|
var H0h=H0.high;
|
|
var H0l=H0.low;
|
|
var H1h=H1.high;
|
|
var H1l=H1.low;
|
|
var H2h=H2.high;
|
|
var H2l=H2.low;
|
|
var H3h=H3.high;
|
|
var H3l=H3.low;
|
|
var H4h=H4.high;
|
|
var H4l=H4.low;
|
|
var H5h=H5.high;
|
|
var H5l=H5.low;
|
|
var H6h=H6.high;
|
|
var H6l=H6.low;
|
|
var H7h=H7.high;
|
|
var H7l=H7.low;
|
|
var ah=H0h;
|
|
var al=H0l;
|
|
var bh=H1h;
|
|
var bl=H1l;
|
|
var ch=H2h;
|
|
var cl=H2l;
|
|
var dh=H3h;
|
|
var dl=H3l;
|
|
var eh=H4h;
|
|
var el=H4l;
|
|
var fh=H5h;
|
|
var fl=H5l;
|
|
var gh=H6h;
|
|
var gl=H6l;
|
|
var hh=H7h;
|
|
var hl=H7l;
|
|
for(var i=0;i<80;i++){
|
|
var Wil;
|
|
var Wih;
|
|
var Wi=W[i];
|
|
if(i<16){
|
|
Wih=Wi.high=M[offset+i*2]|0;
|
|
Wil=Wi.low=M[offset+i*2+1]|0;
|
|
}else{
|
|
var gamma0x=W[i-15];
|
|
var gamma0xh=gamma0x.high;
|
|
var gamma0xl=gamma0x.low;
|
|
var gamma0h=((gamma0xh>>>1)|(gamma0xl<<31))^((gamma0xh>>>8)|(gamma0xl<<24))^(gamma0xh>>>7);
|
|
var gamma0l=((gamma0xl>>>1)|(gamma0xh<<31))^((gamma0xl>>>8)|(gamma0xh<<24))^((gamma0xl>>>7)|(gamma0xh<<25));
|
|
var gamma1x=W[i-2];
|
|
var gamma1xh=gamma1x.high;
|
|
var gamma1xl=gamma1x.low;
|
|
var gamma1h=((gamma1xh>>>19)|(gamma1xl<<13))^((gamma1xh<<3)|(gamma1xl>>>29))^(gamma1xh>>>6);
|
|
var gamma1l=((gamma1xl>>>19)|(gamma1xh<<13))^((gamma1xl<<3)|(gamma1xh>>>29))^((gamma1xl>>>6)|(gamma1xh<<26));
|
|
var Wi7=W[i-7];
|
|
var Wi7h=Wi7.high;
|
|
var Wi7l=Wi7.low;
|
|
var Wi16=W[i-16];
|
|
var Wi16h=Wi16.high;
|
|
var Wi16l=Wi16.low;
|
|
Wil=gamma0l+Wi7l;
|
|
Wih=gamma0h+Wi7h+((Wil>>>0)<(gamma0l>>>0)?1:0);
|
|
Wil=Wil+gamma1l;
|
|
Wih=Wih+gamma1h+((Wil>>>0)<(gamma1l>>>0)?1:0);
|
|
Wil=Wil+Wi16l;
|
|
Wih=Wih+Wi16h+((Wil>>>0)<(Wi16l>>>0)?1:0);
|
|
Wi.high=Wih;
|
|
Wi.low=Wil;
|
|
}
|
|
var chh=(eh&fh)^(~eh&gh);
|
|
var chl=(el&fl)^(~el&gl);
|
|
var majh=(ah&bh)^(ah&ch)^(bh&ch);
|
|
var majl=(al&bl)^(al&cl)^(bl&cl);
|
|
var sigma0h=((ah>>>28)|(al<<4))^((ah<<30)|(al>>>2))^((ah<<25)|(al>>>7));
|
|
var sigma0l=((al>>>28)|(ah<<4))^((al<<30)|(ah>>>2))^((al<<25)|(ah>>>7));
|
|
var sigma1h=((eh>>>14)|(el<<18))^((eh>>>18)|(el<<14))^((eh<<23)|(el>>>9));
|
|
var sigma1l=((el>>>14)|(eh<<18))^((el>>>18)|(eh<<14))^((el<<23)|(eh>>>9));
|
|
var Ki=K[i];
|
|
var Kih=Ki.high;
|
|
var Kil=Ki.low;
|
|
var t1l=hl+sigma1l;
|
|
var t1h=hh+sigma1h+((t1l>>>0)<(hl>>>0)?1:0);
|
|
var t1l=t1l+chl;
|
|
var t1h=t1h+chh+((t1l>>>0)<(chl>>>0)?1:0);
|
|
var t1l=t1l+Kil;
|
|
var t1h=t1h+Kih+((t1l>>>0)<(Kil>>>0)?1:0);
|
|
var t1l=t1l+Wil;
|
|
var t1h=t1h+Wih+((t1l>>>0)<(Wil>>>0)?1:0);
|
|
var t2l=sigma0l+majl;
|
|
var t2h=sigma0h+majh+((t2l>>>0)<(sigma0l>>>0)?1:0);
|
|
hh=gh;
|
|
hl=gl;
|
|
gh=fh;
|
|
gl=fl;
|
|
fh=eh;
|
|
fl=el;
|
|
el=(dl+t1l)|0;
|
|
eh=(dh+t1h+((el>>>0)<(dl>>>0)?1:0))|0;
|
|
dh=ch;
|
|
dl=cl;
|
|
ch=bh;
|
|
cl=bl;
|
|
bh=ah;
|
|
bl=al;
|
|
al=(t1l+t2l)|0;
|
|
ah=(t1h+t2h+((al>>>0)<(t1l>>>0)?1:0))|0;
|
|
}
|
|
H0l=H0.low=(H0l+al);
|
|
H0.high=(H0h+ah+((H0l>>>0)<(al>>>0)?1:0));
|
|
H1l=H1.low=(H1l+bl);
|
|
H1.high=(H1h+bh+((H1l>>>0)<(bl>>>0)?1:0));
|
|
H2l=H2.low=(H2l+cl);
|
|
H2.high=(H2h+ch+((H2l>>>0)<(cl>>>0)?1:0));
|
|
H3l=H3.low=(H3l+dl);
|
|
H3.high=(H3h+dh+((H3l>>>0)<(dl>>>0)?1:0));
|
|
H4l=H4.low=(H4l+el);
|
|
H4.high=(H4h+eh+((H4l>>>0)<(el>>>0)?1:0));
|
|
H5l=H5.low=(H5l+fl);
|
|
H5.high=(H5h+fh+((H5l>>>0)<(fl>>>0)?1:0));
|
|
H6l=H6.low=(H6l+gl);
|
|
H6.high=(H6h+gh+((H6l>>>0)<(gl>>>0)?1:0));
|
|
H7l=H7.low=(H7l+hl);
|
|
H7.high=(H7h+hh+((H7l>>>0)<(hl>>>0)?1:0));
|
|
},
|
|
_doFinalize:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
dataWords[nBitsLeft>>>5]|=0x80<<(24-nBitsLeft%32);
|
|
dataWords[(((nBitsLeft+128)>>>10)<<5)+30]=Math.floor(nBitsTotal/0x100000000);
|
|
dataWords[(((nBitsLeft+128)>>>10)<<5)+31]=nBitsTotal;
|
|
data.sigBytes=dataWords.length*4;
|
|
this._process();
|
|
var hash=this._hash.toX32();
|
|
return hash;
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
clone._hash=this._hash.clone();
|
|
return clone;
|
|
},
|
|
blockSize:1024/32
|
|
});
|
|
C.SHA512=Hasher._createHelper(SHA512);
|
|
C.HmacSHA512=Hasher._createHmacHelper(SHA512);
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_x64=C.x64;
|
|
var X64Word=C_x64.Word;
|
|
var X64WordArray=C_x64.WordArray;
|
|
var C_algo=C.algo;
|
|
var SHA512=C_algo.SHA512;
|
|
var SHA384=C_algo.SHA384=SHA512.extend({
|
|
_doReset:function(){
|
|
this._hash=new X64WordArray.init([new X64Word.init(0xcbbb9d5d,0xc1059ed8),new X64Word.init(0x629a292a,0x367cd507),new X64Word.init(0x9159015a,0x3070dd17),new X64Word.init(0x152fecd8,0xf70e5939),new X64Word.init(0x67332667,0xffc00b31),new X64Word.init(0x8eb44a87,0x68581511),new X64Word.init(0xdb0c2e0d,0x64f98fa7),new X64Word.init(0x47b5481d,0xbefa4fa4)]);
|
|
},
|
|
_doFinalize:function(){
|
|
var hash=SHA512._doFinalize.call(this);
|
|
hash.sigBytes-=16;
|
|
return hash;
|
|
}
|
|
});
|
|
C.SHA384=SHA512._createHelper(SHA384);
|
|
C.HmacSHA384=SHA512._createHmacHelper(SHA384);
|
|
}());
|
|
(function(Math){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_x64=C.x64;
|
|
var X64Word=C_x64.Word;
|
|
var C_algo=C.algo;
|
|
var RHO_OFFSETS=[];
|
|
var PI_INDEXES=[];
|
|
var ROUND_CONSTANTS=[];
|
|
(function(){
|
|
var x=1,
|
|
y=0;
|
|
for(var t=0;t<24;t++){
|
|
RHO_OFFSETS[x+5*y]=((t+1)*(t+2)/2)%64;
|
|
var newX=y%5;
|
|
var newY=(2*x+3*y)%5;
|
|
x=newX;
|
|
y=newY;
|
|
}
|
|
for(var x=0;x<5;x++){
|
|
for(var y=0;y<5;y++){
|
|
PI_INDEXES[x+5*y]=y+((2*x+3*y)%5)*5;
|
|
}
|
|
}
|
|
var LFSR=0x01;
|
|
for(var i=0;i<24;i++){
|
|
var roundConstantMsw=0;
|
|
var roundConstantLsw=0;
|
|
for(var j=0;j<7;j++){
|
|
if(LFSR&0x01){
|
|
var bitPosition=(1<<j)-1;
|
|
if(bitPosition<32){
|
|
roundConstantLsw^=1<<bitPosition;
|
|
}else
|
|
{
|
|
roundConstantMsw^=1<<(bitPosition-32);
|
|
}
|
|
}
|
|
if(LFSR&0x80){
|
|
LFSR=(LFSR<<1)^0x71;
|
|
}else{
|
|
LFSR<<=1;
|
|
}
|
|
}
|
|
ROUND_CONSTANTS[i]=X64Word.create(roundConstantMsw,roundConstantLsw);
|
|
}
|
|
}());
|
|
var T=[];(function(){
|
|
for(var i=0;i<25;i++){
|
|
T[i]=X64Word.create();
|
|
}
|
|
}());
|
|
var SHA3=C_algo.SHA3=Hasher.extend({
|
|
cfg:Hasher.cfg.extend({
|
|
outputLength:512
|
|
}),
|
|
_doReset:function(){
|
|
var state=this._state=[]
|
|
for(var i=0;i<25;i++){
|
|
state[i]=new X64Word.init();
|
|
}
|
|
this.blockSize=(1600-2*this.cfg.outputLength)/32;
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var state=this._state;
|
|
var nBlockSizeLanes=this.blockSize/2;
|
|
for(var i=0;i<nBlockSizeLanes;i++){
|
|
var M2i=M[offset+2*i];
|
|
var M2i1=M[offset+2*i+1];
|
|
M2i=((((M2i<<8)|(M2i>>>24))&0x00ff00ff)|(((M2i<<24)|(M2i>>>8))&0xff00ff00));
|
|
M2i1=((((M2i1<<8)|(M2i1>>>24))&0x00ff00ff)|(((M2i1<<24)|(M2i1>>>8))&0xff00ff00));
|
|
var lane=state[i];
|
|
lane.high^=M2i1;
|
|
lane.low^=M2i;
|
|
}
|
|
for(var round=0;round<24;round++){
|
|
for(var x=0;x<5;x++){
|
|
var tMsw=0,
|
|
tLsw=0;
|
|
for(var y=0;y<5;y++){
|
|
var lane=state[x+5*y];
|
|
tMsw^=lane.high;
|
|
tLsw^=lane.low;
|
|
}
|
|
var Tx=T[x];
|
|
Tx.high=tMsw;
|
|
Tx.low=tLsw;
|
|
}
|
|
for(var x=0;x<5;x++){
|
|
var Tx4=T[(x+4)%5];
|
|
var Tx1=T[(x+1)%5];
|
|
var Tx1Msw=Tx1.high;
|
|
var Tx1Lsw=Tx1.low;
|
|
var tMsw=Tx4.high^((Tx1Msw<<1)|(Tx1Lsw>>>31));
|
|
var tLsw=Tx4.low^((Tx1Lsw<<1)|(Tx1Msw>>>31));
|
|
for(var y=0;y<5;y++){
|
|
var lane=state[x+5*y];
|
|
lane.high^=tMsw;
|
|
lane.low^=tLsw;
|
|
}
|
|
}
|
|
for(var laneIndex=1;laneIndex<25;laneIndex++){
|
|
var tMsw;
|
|
var tLsw;
|
|
var lane=state[laneIndex];
|
|
var laneMsw=lane.high;
|
|
var laneLsw=lane.low;
|
|
var rhoOffset=RHO_OFFSETS[laneIndex];
|
|
if(rhoOffset<32){
|
|
tMsw=(laneMsw<<rhoOffset)|(laneLsw>>>(32-rhoOffset));
|
|
tLsw=(laneLsw<<rhoOffset)|(laneMsw>>>(32-rhoOffset));
|
|
}else
|
|
{
|
|
tMsw=(laneLsw<<(rhoOffset-32))|(laneMsw>>>(64-rhoOffset));
|
|
tLsw=(laneMsw<<(rhoOffset-32))|(laneLsw>>>(64-rhoOffset));
|
|
}
|
|
var TPiLane=T[PI_INDEXES[laneIndex]];
|
|
TPiLane.high=tMsw;
|
|
TPiLane.low=tLsw;
|
|
}
|
|
var T0=T[0];
|
|
var state0=state[0];
|
|
T0.high=state0.high;
|
|
T0.low=state0.low;
|
|
for(var x=0;x<5;x++){
|
|
for(var y=0;y<5;y++){
|
|
var laneIndex=x+5*y;
|
|
var lane=state[laneIndex];
|
|
var TLane=T[laneIndex];
|
|
var Tx1Lane=T[((x+1)%5)+5*y];
|
|
var Tx2Lane=T[((x+2)%5)+5*y];
|
|
lane.high=TLane.high^(~Tx1Lane.high&Tx2Lane.high);
|
|
lane.low=TLane.low^(~Tx1Lane.low&Tx2Lane.low);
|
|
}
|
|
}
|
|
var lane=state[0];
|
|
var roundConstant=ROUND_CONSTANTS[round];
|
|
lane.high^=roundConstant.high;
|
|
lane.low^=roundConstant.low;
|
|
}
|
|
},
|
|
_doFinalize:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
var blockSizeBits=this.blockSize*32;
|
|
dataWords[nBitsLeft>>>5]|=0x1<<(24-nBitsLeft%32);
|
|
dataWords[((Math.ceil((nBitsLeft+1)/blockSizeBits)*blockSizeBits)>>>5)-1]|=0x80;
|
|
data.sigBytes=dataWords.length*4;
|
|
this._process();
|
|
var state=this._state;
|
|
var outputLengthBytes=this.cfg.outputLength/8;
|
|
var outputLengthLanes=outputLengthBytes/8;
|
|
var hashWords=[];
|
|
for(var i=0;i<outputLengthLanes;i++){
|
|
var lane=state[i];
|
|
var laneMsw=lane.high;
|
|
var laneLsw=lane.low;
|
|
laneMsw=((((laneMsw<<8)|(laneMsw>>>24))&0x00ff00ff)|(((laneMsw<<24)|(laneMsw>>>8))&0xff00ff00));
|
|
laneLsw=((((laneLsw<<8)|(laneLsw>>>24))&0x00ff00ff)|(((laneLsw<<24)|(laneLsw>>>8))&0xff00ff00));
|
|
hashWords.push(laneLsw);
|
|
hashWords.push(laneMsw);
|
|
}
|
|
return new WordArray.init(hashWords,outputLengthBytes);
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
var state=clone._state=this._state.slice(0);
|
|
for(var i=0;i<25;i++){
|
|
state[i]=state[i].clone();
|
|
}
|
|
return clone;
|
|
}
|
|
});
|
|
C.SHA3=Hasher._createHelper(SHA3);
|
|
C.HmacSHA3=Hasher._createHmacHelper(SHA3);
|
|
}(Math));
|
|
(function(Math){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var Hasher=C_lib.Hasher;
|
|
var C_algo=C.algo;
|
|
var _zl=WordArray.create([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,7,4,13,1,10,6,15,3,12,0,9,5,2,14,11,8,3,10,14,4,9,15,8,1,2,7,0,6,13,11,5,12,1,9,11,10,0,8,12,4,13,3,7,15,14,5,6,2,4,0,5,9,7,12,2,10,14,1,3,8,11,6,15,13]);
|
|
var _zr=WordArray.create([5,14,7,0,9,2,11,4,13,6,15,8,1,10,3,12,6,11,3,7,0,13,5,10,14,15,8,12,4,9,1,2,15,5,1,3,7,14,6,9,11,8,12,2,10,0,4,13,8,6,4,1,3,11,15,0,5,12,2,13,9,7,10,14,12,15,10,4,1,5,8,7,6,2,13,14,0,3,9,11]);
|
|
var _sl=WordArray.create([11,14,15,12,5,8,7,9,11,13,14,15,6,7,9,8,7,6,8,13,11,9,7,15,7,12,15,9,11,7,13,12,11,13,6,7,14,9,13,15,14,8,13,6,5,12,7,5,11,12,14,15,14,15,9,8,9,14,5,6,8,6,5,12,9,15,5,11,6,8,13,12,5,12,13,14,11,8,5,6]);
|
|
var _sr=WordArray.create([8,9,9,11,13,15,15,5,7,7,8,11,14,14,12,6,9,13,15,7,12,8,9,11,7,7,12,7,6,15,13,11,9,7,15,11,8,6,6,14,12,13,5,14,13,13,7,5,15,5,8,11,14,14,6,14,6,9,12,9,12,5,15,8,8,5,12,9,12,5,14,6,8,13,6,5,15,13,11,11]);
|
|
var _hl=WordArray.create([0x00000000,0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xA953FD4E]);
|
|
var _hr=WordArray.create([0x50A28BE6,0x5C4DD124,0x6D703EF3,0x7A6D76E9,0x00000000]);
|
|
var RIPEMD160=C_algo.RIPEMD160=Hasher.extend({
|
|
_doReset:function(){
|
|
this._hash=WordArray.create([0x67452301,0xEFCDAB89,0x98BADCFE,0x10325476,0xC3D2E1F0]);
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
for(var i=0;i<16;i++){
|
|
var offset_i=offset+i;
|
|
var M_offset_i=M[offset_i];
|
|
M[offset_i]=((((M_offset_i<<8)|(M_offset_i>>>24))&0x00ff00ff)|(((M_offset_i<<24)|(M_offset_i>>>8))&0xff00ff00));
|
|
}
|
|
var H=this._hash.words;
|
|
var hl=_hl.words;
|
|
var hr=_hr.words;
|
|
var zl=_zl.words;
|
|
var zr=_zr.words;
|
|
var sl=_sl.words;
|
|
var sr=_sr.words;
|
|
var al,bl,cl,dl,el;
|
|
var ar,br,cr,dr,er;
|
|
ar=al=H[0];
|
|
br=bl=H[1];
|
|
cr=cl=H[2];
|
|
dr=dl=H[3];
|
|
er=el=H[4];
|
|
var t;
|
|
for(var i=0;i<80;i+=1){
|
|
t=(al+M[offset+zl[i]])|0;
|
|
if(i<16){
|
|
t+=f1(bl,cl,dl)+hl[0];
|
|
}else if(i<32){
|
|
t+=f2(bl,cl,dl)+hl[1];
|
|
}else if(i<48){
|
|
t+=f3(bl,cl,dl)+hl[2];
|
|
}else if(i<64){
|
|
t+=f4(bl,cl,dl)+hl[3];
|
|
}else{
|
|
t+=f5(bl,cl,dl)+hl[4];
|
|
}
|
|
t=t|0;
|
|
t=rotl(t,sl[i]);
|
|
t=(t+el)|0;
|
|
al=el;
|
|
el=dl;
|
|
dl=rotl(cl,10);
|
|
cl=bl;
|
|
bl=t;
|
|
t=(ar+M[offset+zr[i]])|0;
|
|
if(i<16){
|
|
t+=f5(br,cr,dr)+hr[0];
|
|
}else if(i<32){
|
|
t+=f4(br,cr,dr)+hr[1];
|
|
}else if(i<48){
|
|
t+=f3(br,cr,dr)+hr[2];
|
|
}else if(i<64){
|
|
t+=f2(br,cr,dr)+hr[3];
|
|
}else{
|
|
t+=f1(br,cr,dr)+hr[4];
|
|
}
|
|
t=t|0;
|
|
t=rotl(t,sr[i]);
|
|
t=(t+er)|0;
|
|
ar=er;
|
|
er=dr;
|
|
dr=rotl(cr,10);
|
|
cr=br;
|
|
br=t;
|
|
}
|
|
t=(H[1]+cl+dr)|0;
|
|
H[1]=(H[2]+dl+er)|0;
|
|
H[2]=(H[3]+el+ar)|0;
|
|
H[3]=(H[4]+al+br)|0;
|
|
H[4]=(H[0]+bl+cr)|0;
|
|
H[0]=t;
|
|
},
|
|
_doFinalize:function(){
|
|
var data=this._data;
|
|
var dataWords=data.words;
|
|
var nBitsTotal=this._nDataBytes*8;
|
|
var nBitsLeft=data.sigBytes*8;
|
|
dataWords[nBitsLeft>>>5]|=0x80<<(24-nBitsLeft%32);
|
|
dataWords[(((nBitsLeft+64)>>>9)<<4)+14]=((((nBitsTotal<<8)|(nBitsTotal>>>24))&0x00ff00ff)|(((nBitsTotal<<24)|(nBitsTotal>>>8))&0xff00ff00));
|
|
data.sigBytes=(dataWords.length+1)*4;
|
|
this._process();
|
|
var hash=this._hash;
|
|
var H=hash.words;
|
|
for(var i=0;i<5;i++){
|
|
var H_i=H[i];
|
|
H[i]=(((H_i<<8)|(H_i>>>24))&0x00ff00ff)|(((H_i<<24)|(H_i>>>8))&0xff00ff00);
|
|
}
|
|
return hash;
|
|
},
|
|
clone:function(){
|
|
var clone=Hasher.clone.call(this);
|
|
clone._hash=this._hash.clone();
|
|
return clone;
|
|
}
|
|
});
|
|
function f1(x,y,z){
|
|
return((x)^(y)^(z));
|
|
}
|
|
function f2(x,y,z){
|
|
return(((x)&(y))|((~x)&(z)));
|
|
}
|
|
function f3(x,y,z){
|
|
return(((x)|(~(y)))^(z));
|
|
}
|
|
function f4(x,y,z){
|
|
return(((x)&(z))|((y)&(~(z))));
|
|
}
|
|
function f5(x,y,z){
|
|
return((x)^((y)|(~(z))));
|
|
}
|
|
function rotl(x,n){
|
|
return(x<<n)|(x>>>(32-n));
|
|
}
|
|
C.RIPEMD160=Hasher._createHelper(RIPEMD160);
|
|
C.HmacRIPEMD160=Hasher._createHmacHelper(RIPEMD160);
|
|
}(Math));
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var Base=C_lib.Base;
|
|
var C_enc=C.enc;
|
|
var Utf8=C_enc.Utf8;
|
|
var C_algo=C.algo;
|
|
var HMAC=C_algo.HMAC=Base.extend({
|
|
init:function(hasher,key){
|
|
hasher=this._hasher=new hasher.init();
|
|
if(typeof key=='string'){
|
|
key=Utf8.parse(key);
|
|
}
|
|
var hasherBlockSize=hasher.blockSize;
|
|
var hasherBlockSizeBytes=hasherBlockSize*4;
|
|
if(key.sigBytes>hasherBlockSizeBytes){
|
|
key=hasher.finalize(key);
|
|
}
|
|
key.clamp();
|
|
var oKey=this._oKey=key.clone();
|
|
var iKey=this._iKey=key.clone();
|
|
var oKeyWords=oKey.words;
|
|
var iKeyWords=iKey.words;
|
|
for(var i=0;i<hasherBlockSize;i++){
|
|
oKeyWords[i]^=0x5c5c5c5c;
|
|
iKeyWords[i]^=0x36363636;
|
|
}
|
|
oKey.sigBytes=iKey.sigBytes=hasherBlockSizeBytes;
|
|
this.reset();
|
|
},
|
|
reset:function(){
|
|
var hasher=this._hasher;
|
|
hasher.reset();
|
|
hasher.update(this._iKey);
|
|
},
|
|
update:function(messageUpdate){
|
|
this._hasher.update(messageUpdate);
|
|
return this;
|
|
},
|
|
finalize:function(messageUpdate){
|
|
var hasher=this._hasher;
|
|
var innerHash=hasher.finalize(messageUpdate);
|
|
hasher.reset();
|
|
var hmac=hasher.finalize(this._oKey.clone().concat(innerHash));
|
|
return hmac;
|
|
}
|
|
});
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var Base=C_lib.Base;
|
|
var WordArray=C_lib.WordArray;
|
|
var C_algo=C.algo;
|
|
var SHA1=C_algo.SHA1;
|
|
var HMAC=C_algo.HMAC;
|
|
var PBKDF2=C_algo.PBKDF2=Base.extend({
|
|
cfg:Base.extend({
|
|
keySize:128/32,
|
|
hasher:SHA1,
|
|
iterations:1
|
|
}),
|
|
init:function(cfg){
|
|
this.cfg=this.cfg.extend(cfg);
|
|
},
|
|
compute:function(password,salt){
|
|
var cfg=this.cfg;
|
|
var hmac=HMAC.create(cfg.hasher,password);
|
|
var derivedKey=WordArray.create();
|
|
var blockIndex=WordArray.create([0x00000001]);
|
|
var derivedKeyWords=derivedKey.words;
|
|
var blockIndexWords=blockIndex.words;
|
|
var keySize=cfg.keySize;
|
|
var iterations=cfg.iterations;
|
|
while(derivedKeyWords.length<keySize){
|
|
var block=hmac.update(salt).finalize(blockIndex);
|
|
hmac.reset();
|
|
var blockWords=block.words;
|
|
var blockWordsLength=blockWords.length;
|
|
var intermediate=block;
|
|
for(var i=1;i<iterations;i++){
|
|
intermediate=hmac.finalize(intermediate);
|
|
hmac.reset();
|
|
var intermediateWords=intermediate.words;
|
|
for(var j=0;j<blockWordsLength;j++){
|
|
blockWords[j]^=intermediateWords[j];
|
|
}
|
|
}
|
|
derivedKey.concat(block);
|
|
blockIndexWords[0]++;
|
|
}
|
|
derivedKey.sigBytes=keySize*4;
|
|
return derivedKey;
|
|
}
|
|
});
|
|
C.PBKDF2=function(password,salt,cfg){
|
|
return PBKDF2.create(cfg).compute(password,salt);
|
|
};
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var Base=C_lib.Base;
|
|
var WordArray=C_lib.WordArray;
|
|
var C_algo=C.algo;
|
|
var MD5=C_algo.MD5;
|
|
var EvpKDF=C_algo.EvpKDF=Base.extend({
|
|
cfg:Base.extend({
|
|
keySize:128/32,
|
|
hasher:MD5,
|
|
iterations:1
|
|
}),
|
|
init:function(cfg){
|
|
this.cfg=this.cfg.extend(cfg);
|
|
},
|
|
compute:function(password,salt){
|
|
var block;
|
|
var cfg=this.cfg;
|
|
var hasher=cfg.hasher.create();
|
|
var derivedKey=WordArray.create();
|
|
var derivedKeyWords=derivedKey.words;
|
|
var keySize=cfg.keySize;
|
|
var iterations=cfg.iterations;
|
|
while(derivedKeyWords.length<keySize){
|
|
if(block){
|
|
hasher.update(block);
|
|
}
|
|
block=hasher.update(password).finalize(salt);
|
|
hasher.reset();
|
|
for(var i=1;i<iterations;i++){
|
|
block=hasher.finalize(block);
|
|
hasher.reset();
|
|
}
|
|
derivedKey.concat(block);
|
|
}
|
|
derivedKey.sigBytes=keySize*4;
|
|
return derivedKey;
|
|
}
|
|
});
|
|
C.EvpKDF=function(password,salt,cfg){
|
|
return EvpKDF.create(cfg).compute(password,salt);
|
|
};
|
|
}());
|
|
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){
|
|
if(!salt){
|
|
salt=WordArray.random(64/8);
|
|
}
|
|
var key=EvpKDF.create({
|
|
keySize:keySize+ivSize
|
|
}).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.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.iv=derivedParams.iv;
|
|
var plaintext=SerializableCipher.decrypt.call(this,cipher,ciphertext,derivedParams.key,cfg);
|
|
return plaintext;
|
|
}
|
|
});
|
|
}());
|
|
CryptoJS.mode.CFB=(function(){
|
|
var CFB=CryptoJS.lib.BlockCipherMode.extend();
|
|
CFB.Encryptor=CFB.extend({
|
|
processBlock:function(words,offset){
|
|
var cipher=this._cipher;
|
|
var blockSize=cipher.blockSize;
|
|
generateKeystreamAndEncrypt.call(this,words,offset,blockSize,cipher);
|
|
this._prevBlock=words.slice(offset,offset+blockSize);
|
|
}
|
|
});
|
|
CFB.Decryptor=CFB.extend({
|
|
processBlock:function(words,offset){
|
|
var cipher=this._cipher;
|
|
var blockSize=cipher.blockSize;
|
|
var thisBlock=words.slice(offset,offset+blockSize);
|
|
generateKeystreamAndEncrypt.call(this,words,offset,blockSize,cipher);
|
|
this._prevBlock=thisBlock;
|
|
}
|
|
});
|
|
function generateKeystreamAndEncrypt(words,offset,blockSize,cipher){
|
|
var keystream;
|
|
var iv=this._iv;
|
|
if(iv){
|
|
keystream=iv.slice(0);
|
|
this._iv=undefined;
|
|
}else{
|
|
keystream=this._prevBlock;
|
|
}
|
|
cipher.encryptBlock(keystream,0);
|
|
for(var i=0;i<blockSize;i++){
|
|
words[offset+i]^=keystream[i];
|
|
}
|
|
}
|
|
return CFB;
|
|
}());
|
|
CryptoJS.mode.CTR=(function(){
|
|
var CTR=CryptoJS.lib.BlockCipherMode.extend();
|
|
var Encryptor=CTR.Encryptor=CTR.extend({
|
|
processBlock:function(words,offset){
|
|
var cipher=this._cipher
|
|
var blockSize=cipher.blockSize;
|
|
var iv=this._iv;
|
|
var counter=this._counter;
|
|
if(iv){
|
|
counter=this._counter=iv.slice(0);
|
|
this._iv=undefined;
|
|
}
|
|
var keystream=counter.slice(0);
|
|
cipher.encryptBlock(keystream,0);
|
|
counter[blockSize-1]=(counter[blockSize-1]+1)|0
|
|
for(var i=0;i<blockSize;i++){
|
|
words[offset+i]^=keystream[i];
|
|
}
|
|
}
|
|
});
|
|
CTR.Decryptor=Encryptor;
|
|
return CTR;
|
|
}());
|
|
CryptoJS.mode.CTRGladman=(function(){
|
|
var CTRGladman=CryptoJS.lib.BlockCipherMode.extend();
|
|
function incWord(word){
|
|
if(((word>>24)&0xff)===0xff){
|
|
var b1=(word>>16)&0xff;
|
|
var b2=(word>>8)&0xff;
|
|
var b3=word&0xff;
|
|
if(b1===0xff)
|
|
{
|
|
b1=0;
|
|
if(b2===0xff){
|
|
b2=0;
|
|
if(b3===0xff){
|
|
b3=0;
|
|
}else{++b3;
|
|
}
|
|
}else{++b2;
|
|
}
|
|
}else{++b1;
|
|
}
|
|
word=0;
|
|
word+=(b1<<16);
|
|
word+=(b2<<8);
|
|
word+=b3;
|
|
}else{
|
|
word+=(0x01<<24);
|
|
}
|
|
return word;
|
|
}
|
|
function incCounter(counter){
|
|
if((counter[0]=incWord(counter[0]))===0){
|
|
counter[1]=incWord(counter[1]);
|
|
}
|
|
return counter;
|
|
}
|
|
var Encryptor=CTRGladman.Encryptor=CTRGladman.extend({
|
|
processBlock:function(words,offset){
|
|
var cipher=this._cipher
|
|
var blockSize=cipher.blockSize;
|
|
var iv=this._iv;
|
|
var counter=this._counter;
|
|
if(iv){
|
|
counter=this._counter=iv.slice(0);
|
|
this._iv=undefined;
|
|
}
|
|
incCounter(counter);
|
|
var keystream=counter.slice(0);
|
|
cipher.encryptBlock(keystream,0);
|
|
for(var i=0;i<blockSize;i++){
|
|
words[offset+i]^=keystream[i];
|
|
}
|
|
}
|
|
});
|
|
CTRGladman.Decryptor=Encryptor;
|
|
return CTRGladman;
|
|
}());
|
|
CryptoJS.mode.OFB=(function(){
|
|
var OFB=CryptoJS.lib.BlockCipherMode.extend();
|
|
var Encryptor=OFB.Encryptor=OFB.extend({
|
|
processBlock:function(words,offset){
|
|
var cipher=this._cipher
|
|
var blockSize=cipher.blockSize;
|
|
var iv=this._iv;
|
|
var keystream=this._keystream;
|
|
if(iv){
|
|
keystream=this._keystream=iv.slice(0);
|
|
this._iv=undefined;
|
|
}
|
|
cipher.encryptBlock(keystream,0);
|
|
for(var i=0;i<blockSize;i++){
|
|
words[offset+i]^=keystream[i];
|
|
}
|
|
}
|
|
});
|
|
OFB.Decryptor=Encryptor;
|
|
return OFB;
|
|
}());
|
|
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;
|
|
}());
|
|
CryptoJS.pad.AnsiX923={
|
|
pad:function(data,blockSize){
|
|
var dataSigBytes=data.sigBytes;
|
|
var blockSizeBytes=blockSize*4;
|
|
var nPaddingBytes=blockSizeBytes-dataSigBytes%blockSizeBytes;
|
|
var lastBytePos=dataSigBytes+nPaddingBytes-1;
|
|
data.clamp();
|
|
data.words[lastBytePos>>>2]|=nPaddingBytes<<(24-(lastBytePos%4)*8);
|
|
data.sigBytes+=nPaddingBytes;
|
|
},
|
|
unpad:function(data){
|
|
var nPaddingBytes=data.words[(data.sigBytes-1)>>>2]&0xff;
|
|
data.sigBytes-=nPaddingBytes;
|
|
}
|
|
};
|
|
CryptoJS.pad.Iso10126={
|
|
pad:function(data,blockSize){
|
|
var blockSizeBytes=blockSize*4;
|
|
var nPaddingBytes=blockSizeBytes-data.sigBytes%blockSizeBytes;
|
|
data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes-1)).concat(CryptoJS.lib.WordArray.create([nPaddingBytes<<24],1));
|
|
},
|
|
unpad:function(data){
|
|
var nPaddingBytes=data.words[(data.sigBytes-1)>>>2]&0xff;
|
|
data.sigBytes-=nPaddingBytes;
|
|
}
|
|
};
|
|
CryptoJS.pad.Iso97971={
|
|
pad:function(data,blockSize){
|
|
data.concat(CryptoJS.lib.WordArray.create([0x80000000],1));
|
|
CryptoJS.pad.ZeroPadding.pad(data,blockSize);
|
|
},
|
|
unpad:function(data){
|
|
CryptoJS.pad.ZeroPadding.unpad(data);
|
|
data.sigBytes--;
|
|
}
|
|
};
|
|
CryptoJS.pad.ZeroPadding={
|
|
pad:function(data,blockSize){
|
|
var blockSizeBytes=blockSize*4;
|
|
data.clamp();
|
|
data.sigBytes+=blockSizeBytes-((data.sigBytes%blockSizeBytes)||blockSizeBytes);
|
|
},
|
|
unpad:function(data){
|
|
var dataWords=data.words;
|
|
var i=data.sigBytes-1;
|
|
for(var i=data.sigBytes-1;i>=0;i--){
|
|
if(((dataWords[i>>>2]>>>(24-(i%4)*8))&0xff)){
|
|
data.sigBytes=i+1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
};
|
|
CryptoJS.pad.NoPadding={
|
|
pad:function(){},
|
|
unpad:function(){}
|
|
};
|
|
(function(undefined){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var CipherParams=C_lib.CipherParams;
|
|
var C_enc=C.enc;
|
|
var Hex=C_enc.Hex;
|
|
var C_format=C.format;
|
|
var HexFormatter=C_format.Hex={
|
|
stringify:function(cipherParams){
|
|
return cipherParams.ciphertext.toString(Hex);
|
|
},
|
|
parse:function(input){
|
|
var ciphertext=Hex.parse(input);
|
|
return CipherParams.create({
|
|
ciphertext:ciphertext
|
|
});
|
|
}
|
|
};
|
|
}());
|
|
(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(){
|
|
var t;
|
|
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{
|
|
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(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var WordArray=C_lib.WordArray;
|
|
var BlockCipher=C_lib.BlockCipher;
|
|
var C_algo=C.algo;
|
|
var PC1=[57,49,41,33,25,17,9,1,58,50,42,34,26,18,10,2,59,51,43,35,27,19,11,3,60,52,44,36,63,55,47,39,31,23,15,7,62,54,46,38,30,22,14,6,61,53,45,37,29,21,13,5,28,20,12,4];
|
|
var PC2=[14,17,11,24,1,5,3,28,15,6,21,10,23,19,12,4,26,8,16,7,27,20,13,2,41,52,31,37,47,55,30,40,51,45,33,48,44,49,39,56,34,53,46,42,50,36,29,32];
|
|
var BIT_SHIFTS=[1,2,4,6,8,10,12,14,15,17,19,21,23,25,27,28];
|
|
var SBOX_P=[{
|
|
0x0:0x808200,
|
|
0x10000000:0x8000,
|
|
0x20000000:0x808002,
|
|
0x30000000:0x2,
|
|
0x40000000:0x200,
|
|
0x50000000:0x808202,
|
|
0x60000000:0x800202,
|
|
0x70000000:0x800000,
|
|
0x80000000:0x202,
|
|
0x90000000:0x800200,
|
|
0xa0000000:0x8200,
|
|
0xb0000000:0x808000,
|
|
0xc0000000:0x8002,
|
|
0xd0000000:0x800002,
|
|
0xe0000000:0x0,
|
|
0xf0000000:0x8202,
|
|
0x8000000:0x0,
|
|
0x18000000:0x808202,
|
|
0x28000000:0x8202,
|
|
0x38000000:0x8000,
|
|
0x48000000:0x808200,
|
|
0x58000000:0x200,
|
|
0x68000000:0x808002,
|
|
0x78000000:0x2,
|
|
0x88000000:0x800200,
|
|
0x98000000:0x8200,
|
|
0xa8000000:0x808000,
|
|
0xb8000000:0x800202,
|
|
0xc8000000:0x800002,
|
|
0xd8000000:0x8002,
|
|
0xe8000000:0x202,
|
|
0xf8000000:0x800000,
|
|
0x1:0x8000,
|
|
0x10000001:0x2,
|
|
0x20000001:0x808200,
|
|
0x30000001:0x800000,
|
|
0x40000001:0x808002,
|
|
0x50000001:0x8200,
|
|
0x60000001:0x200,
|
|
0x70000001:0x800202,
|
|
0x80000001:0x808202,
|
|
0x90000001:0x808000,
|
|
0xa0000001:0x800002,
|
|
0xb0000001:0x8202,
|
|
0xc0000001:0x202,
|
|
0xd0000001:0x800200,
|
|
0xe0000001:0x8002,
|
|
0xf0000001:0x0,
|
|
0x8000001:0x808202,
|
|
0x18000001:0x808000,
|
|
0x28000001:0x800000,
|
|
0x38000001:0x200,
|
|
0x48000001:0x8000,
|
|
0x58000001:0x800002,
|
|
0x68000001:0x2,
|
|
0x78000001:0x8202,
|
|
0x88000001:0x8002,
|
|
0x98000001:0x800202,
|
|
0xa8000001:0x202,
|
|
0xb8000001:0x808200,
|
|
0xc8000001:0x800200,
|
|
0xd8000001:0x0,
|
|
0xe8000001:0x8200,
|
|
0xf8000001:0x808002
|
|
},
|
|
{
|
|
0x0:0x40084010,
|
|
0x1000000:0x4000,
|
|
0x2000000:0x80000,
|
|
0x3000000:0x40080010,
|
|
0x4000000:0x40000010,
|
|
0x5000000:0x40084000,
|
|
0x6000000:0x40004000,
|
|
0x7000000:0x10,
|
|
0x8000000:0x84000,
|
|
0x9000000:0x40004010,
|
|
0xa000000:0x40000000,
|
|
0xb000000:0x84010,
|
|
0xc000000:0x80010,
|
|
0xd000000:0x0,
|
|
0xe000000:0x4010,
|
|
0xf000000:0x40080000,
|
|
0x800000:0x40004000,
|
|
0x1800000:0x84010,
|
|
0x2800000:0x10,
|
|
0x3800000:0x40004010,
|
|
0x4800000:0x40084010,
|
|
0x5800000:0x40000000,
|
|
0x6800000:0x80000,
|
|
0x7800000:0x40080010,
|
|
0x8800000:0x80010,
|
|
0x9800000:0x0,
|
|
0xa800000:0x4000,
|
|
0xb800000:0x40080000,
|
|
0xc800000:0x40000010,
|
|
0xd800000:0x84000,
|
|
0xe800000:0x40084000,
|
|
0xf800000:0x4010,
|
|
0x10000000:0x0,
|
|
0x11000000:0x40080010,
|
|
0x12000000:0x40004010,
|
|
0x13000000:0x40084000,
|
|
0x14000000:0x40080000,
|
|
0x15000000:0x10,
|
|
0x16000000:0x84010,
|
|
0x17000000:0x4000,
|
|
0x18000000:0x4010,
|
|
0x19000000:0x80000,
|
|
0x1a000000:0x80010,
|
|
0x1b000000:0x40000010,
|
|
0x1c000000:0x84000,
|
|
0x1d000000:0x40004000,
|
|
0x1e000000:0x40000000,
|
|
0x1f000000:0x40084010,
|
|
0x10800000:0x84010,
|
|
0x11800000:0x80000,
|
|
0x12800000:0x40080000,
|
|
0x13800000:0x4000,
|
|
0x14800000:0x40004000,
|
|
0x15800000:0x40084010,
|
|
0x16800000:0x10,
|
|
0x17800000:0x40000000,
|
|
0x18800000:0x40084000,
|
|
0x19800000:0x40000010,
|
|
0x1a800000:0x40004010,
|
|
0x1b800000:0x80010,
|
|
0x1c800000:0x0,
|
|
0x1d800000:0x4010,
|
|
0x1e800000:0x40080010,
|
|
0x1f800000:0x84000
|
|
},
|
|
{
|
|
0x0:0x104,
|
|
0x100000:0x0,
|
|
0x200000:0x4000100,
|
|
0x300000:0x10104,
|
|
0x400000:0x10004,
|
|
0x500000:0x4000004,
|
|
0x600000:0x4010104,
|
|
0x700000:0x4010000,
|
|
0x800000:0x4000000,
|
|
0x900000:0x4010100,
|
|
0xa00000:0x10100,
|
|
0xb00000:0x4010004,
|
|
0xc00000:0x4000104,
|
|
0xd00000:0x10000,
|
|
0xe00000:0x4,
|
|
0xf00000:0x100,
|
|
0x80000:0x4010100,
|
|
0x180000:0x4010004,
|
|
0x280000:0x0,
|
|
0x380000:0x4000100,
|
|
0x480000:0x4000004,
|
|
0x580000:0x10000,
|
|
0x680000:0x10004,
|
|
0x780000:0x104,
|
|
0x880000:0x4,
|
|
0x980000:0x100,
|
|
0xa80000:0x4010000,
|
|
0xb80000:0x10104,
|
|
0xc80000:0x10100,
|
|
0xd80000:0x4000104,
|
|
0xe80000:0x4010104,
|
|
0xf80000:0x4000000,
|
|
0x1000000:0x4010100,
|
|
0x1100000:0x10004,
|
|
0x1200000:0x10000,
|
|
0x1300000:0x4000100,
|
|
0x1400000:0x100,
|
|
0x1500000:0x4010104,
|
|
0x1600000:0x4000004,
|
|
0x1700000:0x0,
|
|
0x1800000:0x4000104,
|
|
0x1900000:0x4000000,
|
|
0x1a00000:0x4,
|
|
0x1b00000:0x10100,
|
|
0x1c00000:0x4010000,
|
|
0x1d00000:0x104,
|
|
0x1e00000:0x10104,
|
|
0x1f00000:0x4010004,
|
|
0x1080000:0x4000000,
|
|
0x1180000:0x104,
|
|
0x1280000:0x4010100,
|
|
0x1380000:0x0,
|
|
0x1480000:0x10004,
|
|
0x1580000:0x4000100,
|
|
0x1680000:0x100,
|
|
0x1780000:0x4010004,
|
|
0x1880000:0x10000,
|
|
0x1980000:0x4010104,
|
|
0x1a80000:0x10104,
|
|
0x1b80000:0x4000004,
|
|
0x1c80000:0x4000104,
|
|
0x1d80000:0x4010000,
|
|
0x1e80000:0x4,
|
|
0x1f80000:0x10100
|
|
},
|
|
{
|
|
0x0:0x80401000,
|
|
0x10000:0x80001040,
|
|
0x20000:0x401040,
|
|
0x30000:0x80400000,
|
|
0x40000:0x0,
|
|
0x50000:0x401000,
|
|
0x60000:0x80000040,
|
|
0x70000:0x400040,
|
|
0x80000:0x80000000,
|
|
0x90000:0x400000,
|
|
0xa0000:0x40,
|
|
0xb0000:0x80001000,
|
|
0xc0000:0x80400040,
|
|
0xd0000:0x1040,
|
|
0xe0000:0x1000,
|
|
0xf0000:0x80401040,
|
|
0x8000:0x80001040,
|
|
0x18000:0x40,
|
|
0x28000:0x80400040,
|
|
0x38000:0x80001000,
|
|
0x48000:0x401000,
|
|
0x58000:0x80401040,
|
|
0x68000:0x0,
|
|
0x78000:0x80400000,
|
|
0x88000:0x1000,
|
|
0x98000:0x80401000,
|
|
0xa8000:0x400000,
|
|
0xb8000:0x1040,
|
|
0xc8000:0x80000000,
|
|
0xd8000:0x400040,
|
|
0xe8000:0x401040,
|
|
0xf8000:0x80000040,
|
|
0x100000:0x400040,
|
|
0x110000:0x401000,
|
|
0x120000:0x80000040,
|
|
0x130000:0x0,
|
|
0x140000:0x1040,
|
|
0x150000:0x80400040,
|
|
0x160000:0x80401000,
|
|
0x170000:0x80001040,
|
|
0x180000:0x80401040,
|
|
0x190000:0x80000000,
|
|
0x1a0000:0x80400000,
|
|
0x1b0000:0x401040,
|
|
0x1c0000:0x80001000,
|
|
0x1d0000:0x400000,
|
|
0x1e0000:0x40,
|
|
0x1f0000:0x1000,
|
|
0x108000:0x80400000,
|
|
0x118000:0x80401040,
|
|
0x128000:0x0,
|
|
0x138000:0x401000,
|
|
0x148000:0x400040,
|
|
0x158000:0x80000000,
|
|
0x168000:0x80001040,
|
|
0x178000:0x40,
|
|
0x188000:0x80000040,
|
|
0x198000:0x1000,
|
|
0x1a8000:0x80001000,
|
|
0x1b8000:0x80400040,
|
|
0x1c8000:0x1040,
|
|
0x1d8000:0x80401000,
|
|
0x1e8000:0x400000,
|
|
0x1f8000:0x401040
|
|
},
|
|
{
|
|
0x0:0x80,
|
|
0x1000:0x1040000,
|
|
0x2000:0x40000,
|
|
0x3000:0x20000000,
|
|
0x4000:0x20040080,
|
|
0x5000:0x1000080,
|
|
0x6000:0x21000080,
|
|
0x7000:0x40080,
|
|
0x8000:0x1000000,
|
|
0x9000:0x20040000,
|
|
0xa000:0x20000080,
|
|
0xb000:0x21040080,
|
|
0xc000:0x21040000,
|
|
0xd000:0x0,
|
|
0xe000:0x1040080,
|
|
0xf000:0x21000000,
|
|
0x800:0x1040080,
|
|
0x1800:0x21000080,
|
|
0x2800:0x80,
|
|
0x3800:0x1040000,
|
|
0x4800:0x40000,
|
|
0x5800:0x20040080,
|
|
0x6800:0x21040000,
|
|
0x7800:0x20000000,
|
|
0x8800:0x20040000,
|
|
0x9800:0x0,
|
|
0xa800:0x21040080,
|
|
0xb800:0x1000080,
|
|
0xc800:0x20000080,
|
|
0xd800:0x21000000,
|
|
0xe800:0x1000000,
|
|
0xf800:0x40080,
|
|
0x10000:0x40000,
|
|
0x11000:0x80,
|
|
0x12000:0x20000000,
|
|
0x13000:0x21000080,
|
|
0x14000:0x1000080,
|
|
0x15000:0x21040000,
|
|
0x16000:0x20040080,
|
|
0x17000:0x1000000,
|
|
0x18000:0x21040080,
|
|
0x19000:0x21000000,
|
|
0x1a000:0x1040000,
|
|
0x1b000:0x20040000,
|
|
0x1c000:0x40080,
|
|
0x1d000:0x20000080,
|
|
0x1e000:0x0,
|
|
0x1f000:0x1040080,
|
|
0x10800:0x21000080,
|
|
0x11800:0x1000000,
|
|
0x12800:0x1040000,
|
|
0x13800:0x20040080,
|
|
0x14800:0x20000000,
|
|
0x15800:0x1040080,
|
|
0x16800:0x80,
|
|
0x17800:0x21040000,
|
|
0x18800:0x40080,
|
|
0x19800:0x21040080,
|
|
0x1a800:0x0,
|
|
0x1b800:0x21000000,
|
|
0x1c800:0x1000080,
|
|
0x1d800:0x40000,
|
|
0x1e800:0x20040000,
|
|
0x1f800:0x20000080
|
|
},
|
|
{
|
|
0x0:0x10000008,
|
|
0x100:0x2000,
|
|
0x200:0x10200000,
|
|
0x300:0x10202008,
|
|
0x400:0x10002000,
|
|
0x500:0x200000,
|
|
0x600:0x200008,
|
|
0x700:0x10000000,
|
|
0x800:0x0,
|
|
0x900:0x10002008,
|
|
0xa00:0x202000,
|
|
0xb00:0x8,
|
|
0xc00:0x10200008,
|
|
0xd00:0x202008,
|
|
0xe00:0x2008,
|
|
0xf00:0x10202000,
|
|
0x80:0x10200000,
|
|
0x180:0x10202008,
|
|
0x280:0x8,
|
|
0x380:0x200000,
|
|
0x480:0x202008,
|
|
0x580:0x10000008,
|
|
0x680:0x10002000,
|
|
0x780:0x2008,
|
|
0x880:0x200008,
|
|
0x980:0x2000,
|
|
0xa80:0x10002008,
|
|
0xb80:0x10200008,
|
|
0xc80:0x0,
|
|
0xd80:0x10202000,
|
|
0xe80:0x202000,
|
|
0xf80:0x10000000,
|
|
0x1000:0x10002000,
|
|
0x1100:0x10200008,
|
|
0x1200:0x10202008,
|
|
0x1300:0x2008,
|
|
0x1400:0x200000,
|
|
0x1500:0x10000000,
|
|
0x1600:0x10000008,
|
|
0x1700:0x202000,
|
|
0x1800:0x202008,
|
|
0x1900:0x0,
|
|
0x1a00:0x8,
|
|
0x1b00:0x10200000,
|
|
0x1c00:0x2000,
|
|
0x1d00:0x10002008,
|
|
0x1e00:0x10202000,
|
|
0x1f00:0x200008,
|
|
0x1080:0x8,
|
|
0x1180:0x202000,
|
|
0x1280:0x200000,
|
|
0x1380:0x10000008,
|
|
0x1480:0x10002000,
|
|
0x1580:0x2008,
|
|
0x1680:0x10202008,
|
|
0x1780:0x10200000,
|
|
0x1880:0x10202000,
|
|
0x1980:0x10200008,
|
|
0x1a80:0x2000,
|
|
0x1b80:0x202008,
|
|
0x1c80:0x200008,
|
|
0x1d80:0x0,
|
|
0x1e80:0x10000000,
|
|
0x1f80:0x10002008
|
|
},
|
|
{
|
|
0x0:0x100000,
|
|
0x10:0x2000401,
|
|
0x20:0x400,
|
|
0x30:0x100401,
|
|
0x40:0x2100401,
|
|
0x50:0x0,
|
|
0x60:0x1,
|
|
0x70:0x2100001,
|
|
0x80:0x2000400,
|
|
0x90:0x100001,
|
|
0xa0:0x2000001,
|
|
0xb0:0x2100400,
|
|
0xc0:0x2100000,
|
|
0xd0:0x401,
|
|
0xe0:0x100400,
|
|
0xf0:0x2000000,
|
|
0x8:0x2100001,
|
|
0x18:0x0,
|
|
0x28:0x2000401,
|
|
0x38:0x2100400,
|
|
0x48:0x100000,
|
|
0x58:0x2000001,
|
|
0x68:0x2000000,
|
|
0x78:0x401,
|
|
0x88:0x100401,
|
|
0x98:0x2000400,
|
|
0xa8:0x2100000,
|
|
0xb8:0x100001,
|
|
0xc8:0x400,
|
|
0xd8:0x2100401,
|
|
0xe8:0x1,
|
|
0xf8:0x100400,
|
|
0x100:0x2000000,
|
|
0x110:0x100000,
|
|
0x120:0x2000401,
|
|
0x130:0x2100001,
|
|
0x140:0x100001,
|
|
0x150:0x2000400,
|
|
0x160:0x2100400,
|
|
0x170:0x100401,
|
|
0x180:0x401,
|
|
0x190:0x2100401,
|
|
0x1a0:0x100400,
|
|
0x1b0:0x1,
|
|
0x1c0:0x0,
|
|
0x1d0:0x2100000,
|
|
0x1e0:0x2000001,
|
|
0x1f0:0x400,
|
|
0x108:0x100400,
|
|
0x118:0x2000401,
|
|
0x128:0x2100001,
|
|
0x138:0x1,
|
|
0x148:0x2000000,
|
|
0x158:0x100000,
|
|
0x168:0x401,
|
|
0x178:0x2100400,
|
|
0x188:0x2000001,
|
|
0x198:0x2100000,
|
|
0x1a8:0x0,
|
|
0x1b8:0x2100401,
|
|
0x1c8:0x100401,
|
|
0x1d8:0x400,
|
|
0x1e8:0x2000400,
|
|
0x1f8:0x100001
|
|
},
|
|
{
|
|
0x0:0x8000820,
|
|
0x1:0x20000,
|
|
0x2:0x8000000,
|
|
0x3:0x20,
|
|
0x4:0x20020,
|
|
0x5:0x8020820,
|
|
0x6:0x8020800,
|
|
0x7:0x800,
|
|
0x8:0x8020000,
|
|
0x9:0x8000800,
|
|
0xa:0x20800,
|
|
0xb:0x8020020,
|
|
0xc:0x820,
|
|
0xd:0x0,
|
|
0xe:0x8000020,
|
|
0xf:0x20820,
|
|
0x80000000:0x800,
|
|
0x80000001:0x8020820,
|
|
0x80000002:0x8000820,
|
|
0x80000003:0x8000000,
|
|
0x80000004:0x8020000,
|
|
0x80000005:0x20800,
|
|
0x80000006:0x20820,
|
|
0x80000007:0x20,
|
|
0x80000008:0x8000020,
|
|
0x80000009:0x820,
|
|
0x8000000a:0x20020,
|
|
0x8000000b:0x8020800,
|
|
0x8000000c:0x0,
|
|
0x8000000d:0x8020020,
|
|
0x8000000e:0x8000800,
|
|
0x8000000f:0x20000,
|
|
0x10:0x20820,
|
|
0x11:0x8020800,
|
|
0x12:0x20,
|
|
0x13:0x800,
|
|
0x14:0x8000800,
|
|
0x15:0x8000020,
|
|
0x16:0x8020020,
|
|
0x17:0x20000,
|
|
0x18:0x0,
|
|
0x19:0x20020,
|
|
0x1a:0x8020000,
|
|
0x1b:0x8000820,
|
|
0x1c:0x8020820,
|
|
0x1d:0x20800,
|
|
0x1e:0x820,
|
|
0x1f:0x8000000,
|
|
0x80000010:0x20000,
|
|
0x80000011:0x800,
|
|
0x80000012:0x8020020,
|
|
0x80000013:0x20820,
|
|
0x80000014:0x20,
|
|
0x80000015:0x8020000,
|
|
0x80000016:0x8000000,
|
|
0x80000017:0x8000820,
|
|
0x80000018:0x8020820,
|
|
0x80000019:0x8000020,
|
|
0x8000001a:0x8000800,
|
|
0x8000001b:0x0,
|
|
0x8000001c:0x20800,
|
|
0x8000001d:0x820,
|
|
0x8000001e:0x20020,
|
|
0x8000001f:0x8020800
|
|
}];
|
|
var SBOX_MASK=[0xf8000001,0x1f800000,0x01f80000,0x001f8000,0x0001f800,0x00001f80,0x000001f8,0x8000001f];
|
|
var DES=C_algo.DES=BlockCipher.extend({
|
|
_doReset:function(){
|
|
var key=this._key;
|
|
var keyWords=key.words;
|
|
var keyBits=[];
|
|
for(var i=0;i<56;i++){
|
|
var keyBitPos=PC1[i]-1;
|
|
keyBits[i]=(keyWords[keyBitPos>>>5]>>>(31-keyBitPos%32))&1;
|
|
}
|
|
var subKeys=this._subKeys=[];
|
|
for(var nSubKey=0;nSubKey<16;nSubKey++){
|
|
var subKey=subKeys[nSubKey]=[];
|
|
var bitShift=BIT_SHIFTS[nSubKey];
|
|
for(var i=0;i<24;i++){
|
|
subKey[(i/6)|0]|=keyBits[((PC2[i]-1)+bitShift)%28]<<(31-i%6);
|
|
subKey[4+((i/6)|0)]|=keyBits[28+(((PC2[i+24]-1)+bitShift)%28)]<<(31-i%6);
|
|
}
|
|
subKey[0]=(subKey[0]<<1)|(subKey[0]>>>31);
|
|
for(var i=1;i<7;i++){
|
|
subKey[i]=subKey[i]>>>((i-1)*4+3);
|
|
}
|
|
subKey[7]=(subKey[7]<<5)|(subKey[7]>>>27);
|
|
}
|
|
var invSubKeys=this._invSubKeys=[];
|
|
for(var i=0;i<16;i++){
|
|
invSubKeys[i]=subKeys[15-i];
|
|
}
|
|
},
|
|
encryptBlock:function(M,offset){
|
|
this._doCryptBlock(M,offset,this._subKeys);
|
|
},
|
|
decryptBlock:function(M,offset){
|
|
this._doCryptBlock(M,offset,this._invSubKeys);
|
|
},
|
|
_doCryptBlock:function(M,offset,subKeys){
|
|
this._lBlock=M[offset];
|
|
this._rBlock=M[offset+1];
|
|
exchangeLR.call(this,4,0x0f0f0f0f);
|
|
exchangeLR.call(this,16,0x0000ffff);
|
|
exchangeRL.call(this,2,0x33333333);
|
|
exchangeRL.call(this,8,0x00ff00ff);
|
|
exchangeLR.call(this,1,0x55555555);
|
|
for(var round=0;round<16;round++){
|
|
var subKey=subKeys[round];
|
|
var lBlock=this._lBlock;
|
|
var rBlock=this._rBlock;
|
|
var f=0;
|
|
for(var i=0;i<8;i++){
|
|
f|=SBOX_P[i][((rBlock^subKey[i])&SBOX_MASK[i])>>>0];
|
|
}
|
|
this._lBlock=rBlock;
|
|
this._rBlock=lBlock^f;
|
|
}
|
|
var t=this._lBlock;
|
|
this._lBlock=this._rBlock;
|
|
this._rBlock=t;
|
|
exchangeLR.call(this,1,0x55555555);
|
|
exchangeRL.call(this,8,0x00ff00ff);
|
|
exchangeRL.call(this,2,0x33333333);
|
|
exchangeLR.call(this,16,0x0000ffff);
|
|
exchangeLR.call(this,4,0x0f0f0f0f);
|
|
M[offset]=this._lBlock;
|
|
M[offset+1]=this._rBlock;
|
|
},
|
|
keySize:64/32,
|
|
ivSize:64/32,
|
|
blockSize:64/32
|
|
});
|
|
function exchangeLR(offset,mask){
|
|
var t=((this._lBlock>>>offset)^this._rBlock)&mask;
|
|
this._rBlock^=t;
|
|
this._lBlock^=t<<offset;
|
|
}
|
|
function exchangeRL(offset,mask){
|
|
var t=((this._rBlock>>>offset)^this._lBlock)&mask;
|
|
this._lBlock^=t;
|
|
this._rBlock^=t<<offset;
|
|
}
|
|
C.DES=BlockCipher._createHelper(DES);
|
|
var TripleDES=C_algo.TripleDES=BlockCipher.extend({
|
|
_doReset:function(){
|
|
var key=this._key;
|
|
var keyWords=key.words;
|
|
if(keyWords.length!==2&&keyWords.length!==4&&keyWords.length<6){
|
|
throw new Error('Invalid key length - 3DES requires the key length to be 64, 128, 192 or >192.');
|
|
}
|
|
var key1=keyWords.slice(0,2);
|
|
var key2=keyWords.length<4?keyWords.slice(0,2):keyWords.slice(2,4);
|
|
var key3=keyWords.length<6?keyWords.slice(0,2):keyWords.slice(4,6);
|
|
this._des1=DES.createEncryptor(WordArray.create(key1));
|
|
this._des2=DES.createEncryptor(WordArray.create(key2));
|
|
this._des3=DES.createEncryptor(WordArray.create(key3));
|
|
},
|
|
encryptBlock:function(M,offset){
|
|
this._des1.encryptBlock(M,offset);
|
|
this._des2.decryptBlock(M,offset);
|
|
this._des3.encryptBlock(M,offset);
|
|
},
|
|
decryptBlock:function(M,offset){
|
|
this._des3.decryptBlock(M,offset);
|
|
this._des2.encryptBlock(M,offset);
|
|
this._des1.decryptBlock(M,offset);
|
|
},
|
|
keySize:192/32,
|
|
ivSize:64/32,
|
|
blockSize:64/32
|
|
});
|
|
C.TripleDES=BlockCipher._createHelper(TripleDES);
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var StreamCipher=C_lib.StreamCipher;
|
|
var C_algo=C.algo;
|
|
var RC4=C_algo.RC4=StreamCipher.extend({
|
|
_doReset:function(){
|
|
var key=this._key;
|
|
var keyWords=key.words;
|
|
var keySigBytes=key.sigBytes;
|
|
var S=this._S=[];
|
|
for(var i=0;i<256;i++){
|
|
S[i]=i;
|
|
}
|
|
for(var i=0,
|
|
j=0;i<256;i++){
|
|
var keyByteIndex=i%keySigBytes;
|
|
var keyByte=(keyWords[keyByteIndex>>>2]>>>(24-(keyByteIndex%4)*8))&0xff;
|
|
j=(j+S[i]+keyByte)%256;
|
|
var t=S[i];
|
|
S[i]=S[j];
|
|
S[j]=t;
|
|
}
|
|
this._i=this._j=0;
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
M[offset]^=generateKeystreamWord.call(this);
|
|
},
|
|
keySize:256/32,
|
|
ivSize:0
|
|
});
|
|
function generateKeystreamWord(){
|
|
var S=this._S;
|
|
var i=this._i;
|
|
var j=this._j;
|
|
var keystreamWord=0;
|
|
for(var n=0;n<4;n++){
|
|
i=(i+1)%256;
|
|
j=(j+S[i])%256;
|
|
var t=S[i];
|
|
S[i]=S[j];
|
|
S[j]=t;
|
|
keystreamWord|=S[(S[i]+S[j])%256]<<(24-n*8);
|
|
}
|
|
this._i=i;
|
|
this._j=j;
|
|
return keystreamWord;
|
|
}
|
|
C.RC4=StreamCipher._createHelper(RC4);
|
|
var RC4Drop=C_algo.RC4Drop=RC4.extend({
|
|
cfg:RC4.cfg.extend({
|
|
drop:192
|
|
}),
|
|
_doReset:function(){
|
|
RC4._doReset.call(this);
|
|
for(var i=this.cfg.drop;i>0;i--){
|
|
generateKeystreamWord.call(this);
|
|
}
|
|
}
|
|
});
|
|
C.RC4Drop=StreamCipher._createHelper(RC4Drop);
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var StreamCipher=C_lib.StreamCipher;
|
|
var C_algo=C.algo;
|
|
var S=[];
|
|
var C_=[];
|
|
var G=[];
|
|
var Rabbit=C_algo.Rabbit=StreamCipher.extend({
|
|
_doReset:function(){
|
|
var K=this._key.words;
|
|
var iv=this.cfg.iv;
|
|
for(var i=0;i<4;i++){
|
|
K[i]=(((K[i]<<8)|(K[i]>>>24))&0x00ff00ff)|(((K[i]<<24)|(K[i]>>>8))&0xff00ff00);
|
|
}
|
|
var X=this._X=[K[0],(K[3]<<16)|(K[2]>>>16),K[1],(K[0]<<16)|(K[3]>>>16),K[2],(K[1]<<16)|(K[0]>>>16),K[3],(K[2]<<16)|(K[1]>>>16)];
|
|
var C=this._C=[(K[2]<<16)|(K[2]>>>16),(K[0]&0xffff0000)|(K[1]&0x0000ffff),(K[3]<<16)|(K[3]>>>16),(K[1]&0xffff0000)|(K[2]&0x0000ffff),(K[0]<<16)|(K[0]>>>16),(K[2]&0xffff0000)|(K[3]&0x0000ffff),(K[1]<<16)|(K[1]>>>16),(K[3]&0xffff0000)|(K[0]&0x0000ffff)];
|
|
this._b=0;
|
|
for(var i=0;i<4;i++){
|
|
nextState.call(this);
|
|
}
|
|
for(var i=0;i<8;i++){
|
|
C[i]^=X[(i+4)&7];
|
|
}
|
|
if(iv){
|
|
var IV=iv.words;
|
|
var IV_0=IV[0];
|
|
var IV_1=IV[1];
|
|
var i0=(((IV_0<<8)|(IV_0>>>24))&0x00ff00ff)|(((IV_0<<24)|(IV_0>>>8))&0xff00ff00);
|
|
var i2=(((IV_1<<8)|(IV_1>>>24))&0x00ff00ff)|(((IV_1<<24)|(IV_1>>>8))&0xff00ff00);
|
|
var i1=(i0>>>16)|(i2&0xffff0000);
|
|
var i3=(i2<<16)|(i0&0x0000ffff);
|
|
C[0]^=i0;
|
|
C[1]^=i1;
|
|
C[2]^=i2;
|
|
C[3]^=i3;
|
|
C[4]^=i0;
|
|
C[5]^=i1;
|
|
C[6]^=i2;
|
|
C[7]^=i3;
|
|
for(var i=0;i<4;i++){
|
|
nextState.call(this);
|
|
}
|
|
}
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var X=this._X;
|
|
nextState.call(this);
|
|
S[0]=X[0]^(X[5]>>>16)^(X[3]<<16);
|
|
S[1]=X[2]^(X[7]>>>16)^(X[5]<<16);
|
|
S[2]=X[4]^(X[1]>>>16)^(X[7]<<16);
|
|
S[3]=X[6]^(X[3]>>>16)^(X[1]<<16);
|
|
for(var i=0;i<4;i++){
|
|
S[i]=(((S[i]<<8)|(S[i]>>>24))&0x00ff00ff)|(((S[i]<<24)|(S[i]>>>8))&0xff00ff00);
|
|
M[offset+i]^=S[i];
|
|
}
|
|
},
|
|
blockSize:128/32,
|
|
ivSize:64/32
|
|
});
|
|
function nextState(){
|
|
var X=this._X;
|
|
var C=this._C;
|
|
for(var i=0;i<8;i++){
|
|
C_[i]=C[i];
|
|
}
|
|
C[0]=(C[0]+0x4d34d34d+this._b)|0;
|
|
C[1]=(C[1]+0xd34d34d3+((C[0]>>>0)<(C_[0]>>>0)?1:0))|0;
|
|
C[2]=(C[2]+0x34d34d34+((C[1]>>>0)<(C_[1]>>>0)?1:0))|0;
|
|
C[3]=(C[3]+0x4d34d34d+((C[2]>>>0)<(C_[2]>>>0)?1:0))|0;
|
|
C[4]=(C[4]+0xd34d34d3+((C[3]>>>0)<(C_[3]>>>0)?1:0))|0;
|
|
C[5]=(C[5]+0x34d34d34+((C[4]>>>0)<(C_[4]>>>0)?1:0))|0;
|
|
C[6]=(C[6]+0x4d34d34d+((C[5]>>>0)<(C_[5]>>>0)?1:0))|0;
|
|
C[7]=(C[7]+0xd34d34d3+((C[6]>>>0)<(C_[6]>>>0)?1:0))|0;
|
|
this._b=(C[7]>>>0)<(C_[7]>>>0)?1:0;
|
|
for(var i=0;i<8;i++){
|
|
var gx=X[i]+C[i];
|
|
var ga=gx&0xffff;
|
|
var gb=gx>>>16;
|
|
var gh=((((ga*ga)>>>17)+ga*gb)>>>15)+gb*gb;
|
|
var gl=(((gx&0xffff0000)*gx)|0)+(((gx&0x0000ffff)*gx)|0);
|
|
G[i]=gh^gl;
|
|
}
|
|
X[0]=(G[0]+((G[7]<<16)|(G[7]>>>16))+((G[6]<<16)|(G[6]>>>16)))|0;
|
|
X[1]=(G[1]+((G[0]<<8)|(G[0]>>>24))+G[7])|0;
|
|
X[2]=(G[2]+((G[1]<<16)|(G[1]>>>16))+((G[0]<<16)|(G[0]>>>16)))|0;
|
|
X[3]=(G[3]+((G[2]<<8)|(G[2]>>>24))+G[1])|0;
|
|
X[4]=(G[4]+((G[3]<<16)|(G[3]>>>16))+((G[2]<<16)|(G[2]>>>16)))|0;
|
|
X[5]=(G[5]+((G[4]<<8)|(G[4]>>>24))+G[3])|0;
|
|
X[6]=(G[6]+((G[5]<<16)|(G[5]>>>16))+((G[4]<<16)|(G[4]>>>16)))|0;
|
|
X[7]=(G[7]+((G[6]<<8)|(G[6]>>>24))+G[5])|0;
|
|
}
|
|
C.Rabbit=StreamCipher._createHelper(Rabbit);
|
|
}());
|
|
(function(){
|
|
var C=CryptoJS;
|
|
var C_lib=C.lib;
|
|
var StreamCipher=C_lib.StreamCipher;
|
|
var C_algo=C.algo;
|
|
var S=[];
|
|
var C_=[];
|
|
var G=[];
|
|
var RabbitLegacy=C_algo.RabbitLegacy=StreamCipher.extend({
|
|
_doReset:function(){
|
|
var K=this._key.words;
|
|
var iv=this.cfg.iv;
|
|
var X=this._X=[K[0],(K[3]<<16)|(K[2]>>>16),K[1],(K[0]<<16)|(K[3]>>>16),K[2],(K[1]<<16)|(K[0]>>>16),K[3],(K[2]<<16)|(K[1]>>>16)];
|
|
var C=this._C=[(K[2]<<16)|(K[2]>>>16),(K[0]&0xffff0000)|(K[1]&0x0000ffff),(K[3]<<16)|(K[3]>>>16),(K[1]&0xffff0000)|(K[2]&0x0000ffff),(K[0]<<16)|(K[0]>>>16),(K[2]&0xffff0000)|(K[3]&0x0000ffff),(K[1]<<16)|(K[1]>>>16),(K[3]&0xffff0000)|(K[0]&0x0000ffff)];
|
|
this._b=0;
|
|
for(var i=0;i<4;i++){
|
|
nextState.call(this);
|
|
}
|
|
for(var i=0;i<8;i++){
|
|
C[i]^=X[(i+4)&7];
|
|
}
|
|
if(iv){
|
|
var IV=iv.words;
|
|
var IV_0=IV[0];
|
|
var IV_1=IV[1];
|
|
var i0=(((IV_0<<8)|(IV_0>>>24))&0x00ff00ff)|(((IV_0<<24)|(IV_0>>>8))&0xff00ff00);
|
|
var i2=(((IV_1<<8)|(IV_1>>>24))&0x00ff00ff)|(((IV_1<<24)|(IV_1>>>8))&0xff00ff00);
|
|
var i1=(i0>>>16)|(i2&0xffff0000);
|
|
var i3=(i2<<16)|(i0&0x0000ffff);
|
|
C[0]^=i0;
|
|
C[1]^=i1;
|
|
C[2]^=i2;
|
|
C[3]^=i3;
|
|
C[4]^=i0;
|
|
C[5]^=i1;
|
|
C[6]^=i2;
|
|
C[7]^=i3;
|
|
for(var i=0;i<4;i++){
|
|
nextState.call(this);
|
|
}
|
|
}
|
|
},
|
|
_doProcessBlock:function(M,offset){
|
|
var X=this._X;
|
|
nextState.call(this);
|
|
S[0]=X[0]^(X[5]>>>16)^(X[3]<<16);
|
|
S[1]=X[2]^(X[7]>>>16)^(X[5]<<16);
|
|
S[2]=X[4]^(X[1]>>>16)^(X[7]<<16);
|
|
S[3]=X[6]^(X[3]>>>16)^(X[1]<<16);
|
|
for(var i=0;i<4;i++){
|
|
S[i]=(((S[i]<<8)|(S[i]>>>24))&0x00ff00ff)|(((S[i]<<24)|(S[i]>>>8))&0xff00ff00);
|
|
M[offset+i]^=S[i];
|
|
}
|
|
},
|
|
blockSize:128/32,
|
|
ivSize:64/32
|
|
});
|
|
function nextState(){
|
|
var X=this._X;
|
|
var C=this._C;
|
|
for(var i=0;i<8;i++){
|
|
C_[i]=C[i];
|
|
}
|
|
C[0]=(C[0]+0x4d34d34d+this._b)|0;
|
|
C[1]=(C[1]+0xd34d34d3+((C[0]>>>0)<(C_[0]>>>0)?1:0))|0;
|
|
C[2]=(C[2]+0x34d34d34+((C[1]>>>0)<(C_[1]>>>0)?1:0))|0;
|
|
C[3]=(C[3]+0x4d34d34d+((C[2]>>>0)<(C_[2]>>>0)?1:0))|0;
|
|
C[4]=(C[4]+0xd34d34d3+((C[3]>>>0)<(C_[3]>>>0)?1:0))|0;
|
|
C[5]=(C[5]+0x34d34d34+((C[4]>>>0)<(C_[4]>>>0)?1:0))|0;
|
|
C[6]=(C[6]+0x4d34d34d+((C[5]>>>0)<(C_[5]>>>0)?1:0))|0;
|
|
C[7]=(C[7]+0xd34d34d3+((C[6]>>>0)<(C_[6]>>>0)?1:0))|0;
|
|
this._b=(C[7]>>>0)<(C_[7]>>>0)?1:0;
|
|
for(var i=0;i<8;i++){
|
|
var gx=X[i]+C[i];
|
|
var ga=gx&0xffff;
|
|
var gb=gx>>>16;
|
|
var gh=((((ga*ga)>>>17)+ga*gb)>>>15)+gb*gb;
|
|
var gl=(((gx&0xffff0000)*gx)|0)+(((gx&0x0000ffff)*gx)|0);
|
|
G[i]=gh^gl;
|
|
}
|
|
X[0]=(G[0]+((G[7]<<16)|(G[7]>>>16))+((G[6]<<16)|(G[6]>>>16)))|0;
|
|
X[1]=(G[1]+((G[0]<<8)|(G[0]>>>24))+G[7])|0;
|
|
X[2]=(G[2]+((G[1]<<16)|(G[1]>>>16))+((G[0]<<16)|(G[0]>>>16)))|0;
|
|
X[3]=(G[3]+((G[2]<<8)|(G[2]>>>24))+G[1])|0;
|
|
X[4]=(G[4]+((G[3]<<16)|(G[3]>>>16))+((G[2]<<16)|(G[2]>>>16)))|0;
|
|
X[5]=(G[5]+((G[4]<<8)|(G[4]>>>24))+G[3])|0;
|
|
X[6]=(G[6]+((G[5]<<16)|(G[5]>>>16))+((G[4]<<16)|(G[4]>>>16)))|0;
|
|
X[7]=(G[7]+((G[6]<<8)|(G[6]>>>24))+G[5])|0;
|
|
}
|
|
C.RabbitLegacy=StreamCipher._createHelper(RabbitLegacy);
|
|
}());
|
|
return CryptoJS;
|
|
})); |