| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213 | 
							- /*
 
- CryptoJS v3.1.2
 
- code.google.com/p/crypto-js
 
- (c) 2009-2013 by Jeff Mott. All rights reserved.
 
- code.google.com/p/crypto-js/wiki/License
 
- */
 
- (function () {
 
-     // Shortcuts
 
-     var C = CryptoJS;
 
-     var C_lib = C.lib;
 
-     var BlockCipher = C_lib.BlockCipher;
 
-     var C_algo = C.algo;
 
-     // Lookup tables
 
-     var SBOX = [];
 
-     var INV_SBOX = [];
 
-     var SUB_MIX_0 = [];
 
-     var SUB_MIX_1 = [];
 
-     var SUB_MIX_2 = [];
 
-     var SUB_MIX_3 = [];
 
-     var INV_SUB_MIX_0 = [];
 
-     var INV_SUB_MIX_1 = [];
 
-     var INV_SUB_MIX_2 = [];
 
-     var INV_SUB_MIX_3 = [];
 
-     // Compute lookup tables
 
-     (function () {
 
-         // Compute double table
 
-         var d = [];
 
-         for (var i = 0; i < 256; i++) {
 
-             if (i < 128) {
 
-                 d[i] = i << 1;
 
-             } else {
 
-                 d[i] = (i << 1) ^ 0x11b;
 
-             }
 
-         }
 
-         // Walk GF(2^8)
 
-         var x = 0;
 
-         var xi = 0;
 
-         for (var i = 0; i < 256; i++) {
 
-             // Compute sbox
 
-             var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
 
-             sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
 
-             SBOX[x] = sx;
 
-             INV_SBOX[sx] = x;
 
-             // Compute multiplication
 
-             var x2 = d[x];
 
-             var x4 = d[x2];
 
-             var x8 = d[x4];
 
-             // Compute sub bytes, mix columns tables
 
-             var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
 
-             SUB_MIX_0[x] = (t << 24) | (t >>> 8);
 
-             SUB_MIX_1[x] = (t << 16) | (t >>> 16);
 
-             SUB_MIX_2[x] = (t << 8)  | (t >>> 24);
 
-             SUB_MIX_3[x] = t;
 
-             // Compute inv sub bytes, inv mix columns tables
 
-             var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
 
-             INV_SUB_MIX_0[sx] = (t << 24) | (t >>> 8);
 
-             INV_SUB_MIX_1[sx] = (t << 16) | (t >>> 16);
 
-             INV_SUB_MIX_2[sx] = (t << 8)  | (t >>> 24);
 
-             INV_SUB_MIX_3[sx] = t;
 
-             // Compute next counter
 
-             if (!x) {
 
-                 x = xi = 1;
 
-             } else {
 
-                 x = x2 ^ d[d[d[x8 ^ x2]]];
 
-                 xi ^= d[d[xi]];
 
-             }
 
-         }
 
-     }());
 
-     // Precomputed Rcon lookup
 
-     var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
 
-     /**
 
-      * AES block cipher algorithm.
 
-      */
 
-     var AES = C_algo.AES = BlockCipher.extend({
 
-         _doReset: function () {
 
-             // Shortcuts
 
-             var key = this._key;
 
-             var keyWords = key.words;
 
-             var keySize = key.sigBytes / 4;
 
-             // Compute number of rounds
 
-             var nRounds = this._nRounds = keySize + 6
 
-             // Compute number of key schedule rows
 
-             var ksRows = (nRounds + 1) * 4;
 
-             // Compute key schedule
 
-             var keySchedule = this._keySchedule = [];
 
-             for (var ksRow = 0; ksRow < ksRows; ksRow++) {
 
-                 if (ksRow < keySize) {
 
-                     keySchedule[ksRow] = keyWords[ksRow];
 
-                 } else {
 
-                     var t = keySchedule[ksRow - 1];
 
-                     if (!(ksRow % keySize)) {
 
-                         // Rot word
 
-                         t = (t << 8) | (t >>> 24);
 
-                         // Sub word
 
-                         t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
 
-                         // Mix Rcon
 
-                         t ^= RCON[(ksRow / keySize) | 0] << 24;
 
-                     } else if (keySize > 6 && ksRow % keySize == 4) {
 
-                         // Sub word
 
-                         t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
 
-                     }
 
-                     keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
 
-                 }
 
-             }
 
-             // Compute inv key schedule
 
-             var invKeySchedule = this._invKeySchedule = [];
 
-             for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
 
-                 var ksRow = ksRows - invKsRow;
 
-                 if (invKsRow % 4) {
 
-                     var t = keySchedule[ksRow];
 
-                 } else {
 
-                     var t = keySchedule[ksRow - 4];
 
-                 }
 
-                 if (invKsRow < 4 || ksRow <= 4) {
 
-                     invKeySchedule[invKsRow] = t;
 
-                 } else {
 
-                     invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[(t >>> 16) & 0xff]] ^
 
-                                                INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
 
-                 }
 
-             }
 
-         },
 
-         encryptBlock: function (M, offset) {
 
-             this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
 
-         },
 
-         decryptBlock: function (M, offset) {
 
-             // Swap 2nd and 4th rows
 
-             var t = M[offset + 1];
 
-             M[offset + 1] = M[offset + 3];
 
-             M[offset + 3] = t;
 
-             this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
 
-             // Inv swap 2nd and 4th rows
 
-             var t = M[offset + 1];
 
-             M[offset + 1] = M[offset + 3];
 
-             M[offset + 3] = t;
 
-         },
 
-         _doCryptBlock: function (M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
 
-             // Shortcut
 
-             var nRounds = this._nRounds;
 
-             // Get input, add round key
 
-             var s0 = M[offset]     ^ keySchedule[0];
 
-             var s1 = M[offset + 1] ^ keySchedule[1];
 
-             var s2 = M[offset + 2] ^ keySchedule[2];
 
-             var s3 = M[offset + 3] ^ keySchedule[3];
 
-             // Key schedule row counter
 
-             var ksRow = 4;
 
-             // Rounds
 
-             for (var round = 1; round < nRounds; round++) {
 
-                 // Shift rows, sub bytes, mix columns, add round key
 
-                 var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
 
-                 var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
 
-                 var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
 
-                 var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
 
-                 // Update state
 
-                 s0 = t0;
 
-                 s1 = t1;
 
-                 s2 = t2;
 
-                 s3 = t3;
 
-             }
 
-             // Shift rows, sub bytes, add round key
 
-             var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
 
-             var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
 
-             var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
 
-             var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
 
-             // Set output
 
-             M[offset]     = t0;
 
-             M[offset + 1] = t1;
 
-             M[offset + 2] = t2;
 
-             M[offset + 3] = t3;
 
-         },
 
-         keySize: 256/32
 
-     });
 
-     /**
 
-      * Shortcut functions to the cipher's object interface.
 
-      *
 
-      * @example
 
-      *
 
-      *     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
 
-      *     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
 
-      */
 
-     C.AES = BlockCipher._createHelper(AES);
 
- }());
 
 
  |