;(function(root, factory, undef) {
|
if (typeof exports === 'object') {
|
// CommonJS
|
module.exports = exports = factory(
|
require('./core'),
|
require('./enc-base64'),
|
require('./md5'),
|
require('./evpkdf'),
|
require('./cipher-core')
|
)
|
} else if (typeof define === 'function' && define.amd) {
|
// AMD
|
define([
|
'./core',
|
'./enc-base64',
|
'./md5',
|
'./evpkdf',
|
'./cipher-core'
|
], factory)
|
} else {
|
// Global (browser)
|
factory(root.CryptoJS)
|
}
|
})(this, function(CryptoJS) {
|
;(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() {
|
// Skip reset of nRounds has been set before and key did not change
|
if (this._nRounds && this._keyPriorReset === this._key) {
|
return
|
}
|
|
// Shortcuts
|
var key = (this._keyPriorReset = 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)
|
})()
|
|
return CryptoJS.AES
|
})
|
