1/* 2 http://www.imcore.net | [email protected] 3 Developer. Kyoungbin Lee 4 2012.05.25 5 6 AES256 EnCrypt / DeCrypt 7*/ 8/** 9* @license Gibberish-AES 10* A lightweight Javascript Libray for OpenSSL compatible AES CBC encryption. 11* 12* Author: Mark Percival 13* Email: [email protected] 14* Copyright: Mark Percival - http://mpercival.com 2008 15* 16* With thanks to: 17* Josh Davis - http://www.josh-davis.org/ecmaScrypt 18* Chris Veness - http://www.movable-type.co.uk/scripts/aes.html 19* Michel I. Gallant - http://www.jensign.com/ 20* 21* License: MIT 22* 23* Usage: GibberishAES.enc("secret", "password") 24* Outputs: AES Encrypted text encoded in Base64 25*/ 26 27 28var GibberishAES = (function(){ 29 var Nr = 14, 30 /* Default to 256 Bit Encryption */ 31 Nk = 8, 32 Decrypt = false, 33 34 enc_utf8 = function(s) 35 { 36 try { 37 return unescape(encodeURIComponent(s)); 38 } 39 catch(e) { 40 throw new Error('Error on UTF-8 encode'); 41 } 42 }, 43 44 dec_utf8 = function(s) 45 { 46 try { 47 return decodeURIComponent(escape(s)); 48 } 49 catch(e) { 50 51 throw new Error('Bad Key'); 52 } 53 }, 54 55 padBlock = function(byteArr) 56 { 57 var array = [], cpad, i; 58 if (byteArr.length < 16) { 59 cpad = 16 - byteArr.length; 60 array = [cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad, cpad]; 61 } 62 for (i = 0; i < byteArr.length; i++) 63 { 64 array[i] = byteArr[i]; 65 } 66 return array; 67 }, 68 69 block2s = function(block, lastBlock) 70 { 71 var string = '', padding, i; 72 if (lastBlock) { 73 padding = block[15]; 74 if (padding > 16) { 75 throw new Error('Decryption error: Maybe bad key'); 76 } 77 if (padding === 16) { 78 return ''; 79 } 80 for (i = 0; i < 16 - padding; i++) { 81 string += String.fromCharCode(block[i]); 82 } 83 } else { 84 for (i = 0; i < 16; i++) { 85 string += String.fromCharCode(block[i]); 86 } 87 } 88 return string; 89 }, 90 91 a2h = function(numArr) 92 { 93 var string = '', i; 94 for (i = 0; i < numArr.length; i++) { 95 string += (numArr[i] < 16 ? '0': '') + numArr[i].toString(16); 96 } 97 return string; 98 }, 99 100 h2a = function(s) 101 { 102 var ret = []; 103 s.replace(/(..)/g, 104 function(s) { 105 ret.push(parseInt(s, 16)); 106 }); 107 return ret; 108 }, 109 110 s2a = function(string, binary) { 111 var array = [], i; 112 113 if (! binary) { 114 string = enc_utf8(string); 115 } 116 117 for (i = 0; i < string.length; i++) 118 { 119 array[i] = string.charCodeAt(i); 120 } 121 122 return array; 123 }, 124 125 size = function(newsize) 126 { 127 switch (newsize) 128 { 129 case 128: 130 Nr = 10; 131 Nk = 4; 132 break; 133 case 192: 134 Nr = 12; 135 Nk = 6; 136 break; 137 case 256: 138 Nr = 14; 139 Nk = 8; 140 break; 141 default: 142 throw new Error('Invalid Key Size Specified:' + newsize); 143 } 144 }, 145 146 randArr = function(num) { 147 var result = [], i; 148 for (i = 0; i < num; i++) { 149 result = result.concat(Math.floor(Math.random() * 256)); 150 } 151 return result; 152 }, 153 154 openSSLKey = function(passwordArr, saltArr) { 155 // Number of rounds depends on the size of the AES in use 156 // 3 rounds for 256 157 // 2 rounds for the key, 1 for the IV 158 // 2 rounds for 128 159 // 1 round for the key, 1 round for the IV 160 // 3 rounds for 192 since it's not evenly divided by 128 bits 161 var rounds = Nr >= 12 ? 3: 2, 162 key = [], 163 iv = [], 164 md5_hash = [], 165 result = [], 166 data00 = passwordArr.concat(saltArr), 167 i; 168 md5_hash[0] = GibberishAES.Hash.MD5(data00); 169 result = md5_hash[0]; 170 for (i = 1; i < rounds; i++) { 171 md5_hash[i] = GibberishAES.Hash.MD5(md5_hash[i - 1].concat(data00)); 172 result = result.concat(md5_hash[i]); 173 } 174 key = result.slice(0, 4 * Nk); 175 iv = result.slice(4 * Nk, 4 * Nk + 16); 176 return { 177 key: key, 178 iv: iv 179 }; 180 }, 181 182 rawEncrypt = function(plaintext, key) { 183 184 plaintext = GibberishAES.s2a(plaintext); 185 var iv = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; 186 // plaintext, key and iv as byte arrays 187 key = expandKey(GibberishAES.s2a(key)); 188 var numBlocks = Math.ceil(plaintext.length / 16), 189 blocks = [], 190 i, 191 cipherBlocks = []; 192 for (i = 0; i < numBlocks; i++) { 193 blocks[i] = padBlock(plaintext.slice(i * 16, i * 16 + 16)); 194 } 195 if (plaintext.length % 16 === 0) { 196 blocks.push([16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16]); 197 // CBC OpenSSL padding scheme 198 numBlocks++; 199 } 200 for (i = 0; i < blocks.length; i++) { 201 blocks[i] = (i === 0) ? xorBlocks(blocks[i], iv) : xorBlocks(blocks[i], cipherBlocks[i - 1]); 202 cipherBlocks[i] = encryptBlock(blocks[i], key); 203 } 204 return GibberishAES.Base64.encode(cipherBlocks); 205 }, 206 207 rawDecrypt = function(cryptArr, key) { 208 var iv = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; 209 // cryptArr, key and iv as byte arrays 210 key = expandKey(GibberishAES.s2a(key)); 211 var numBlocks = cryptArr.length / 16, 212 cipherBlocks = [], 213 i, 214 plainBlocks = [],
215 string = ''; 216 for (i = 0; i < numBlocks; i++) { 217 cipherBlocks.push(cryptArr.slice(i * 16, (i + 1) * 16)); 218 } 219 for (i = cipherBlocks.length - 1; i >= 0; i--) { 220 plainBlocks[i] = decryptBlock(cipherBlocks[i], key); 221 plainBlocks[i] = (i === 0) ? xorBlocks(plainBlocks[i], iv) : xorBlocks(plainBlocks[i], cipherBlocks[i - 1]); 222 } 223 for (i = 0; i < numBlocks - 1; i++) { 224 string += block2s(plainBlocks[i]); 225 } 226 string += block2s(plainBlocks[i], true); 227 228 return dec_utf8(string); 229 //return binary ? string : dec_utf8(string); 230 }, 231 aesEncrypt = function(plaintext, key) { 232 233 plaintext = GibberishAES.s2a(plaintext); 234 var iv = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; 235 // plaintext, key and iv as byte arrays 236 key = expandKey(GibberishAES.s2a(key)); 237 var numBlocks = Math.ceil(plaintext.length / 16), 238 blocks = [], 239 i, 240 cipherBlocks = []; 241 for (i = 0; i < numBlocks; i++) { 242 blocks[i] = padBlock(plaintext.slice(i * 16, i * 16 + 16)); 243 } 244 if (plaintext.length % 16 === 0) { 245 blocks.push([16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16]); 246 // CBC OpenSSL padding scheme 247 numBlocks++; 248 } 249 for (i = 0; i < blocks.length; i++) { 250 blocks[i] = (i === 0) ? xorBlocks(blocks[i], iv) : xorBlocks(blocks[i], cipherBlocks[i - 1]); 251 cipherBlocks[i] = encryptBlock(blocks[i], key); 252 } 253 return GibberishAES.Base64.encode(cipherBlocks); 254 }, 255 256 aesDecrypt = function(base64Text, key) { 257 258 var cryptArr = GibberishAES.Base64.decode(base64Text); 259 var iv = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; 260 // cryptArr, key and iv as byte arrays 261 key = expandKey(GibberishAES.s2a(key)); 262 var numBlocks = cryptArr.length / 16, 263 cipherBlocks = [], 264 i, 265 plainBlocks = [], 266 string = ''; 267 for (i = 0; i < numBlocks; i++) { 268 cipherBlocks.push(cryptArr.slice(i * 16, (i + 1) * 16)); 269 } 270 for (i = cipherBlocks.length - 1; i >= 0; i--) { 271 plainBlocks[i] = decryptBlock(cipherBlocks[i], key); 272 plainBlocks[i] = (i === 0) ? xorBlocks(plainBlocks[i], iv) : xorBlocks(plainBlocks[i], cipherBlocks[i - 1]); 273 } 274 for (i = 0; i < numBlocks - 1; i++) { 275 string += block2s(plainBlocks[i]); 276 } 277 string += block2s(plainBlocks[i], true); 278 279 return dec_utf8(string); 280 //return binary ? string : dec_utf8(string); 281 }, 282 encryptBlock = function(block, words) { 283 Decrypt = false; 284 var state = addRoundKey(block, words, 0), 285 round; 286 for (round = 1; round < (Nr + 1); round++) { 287 state = subBytes(state); 288 state = shiftRows(state); 289 if (round < Nr) { 290 state = mixColumns(state); 291 } 292 //last round? don't mixColumns
293 state = addRoundKey(state, words, round); 294 } 295 296 return state; 297 }, 298 299 decryptBlock = function(block, words) { 300 Decrypt = true; 301 var state = addRoundKey(block, words, Nr), 302 round; 303 for (round = Nr - 1; round > -1; round--) { 304 state = shiftRows(state); 305 state = subBytes(state); 306 state = addRoundKey(state, words, round); 307 if (round > 0) { 308 state = mixColumns(state); 309 } 310 //last round? don't mixColumns 311 } 312 313 return state; 314 }, 315 316 subBytes = function(state) { 317 var S = Decrypt ? SBoxInv: SBox, 318 temp = [], 319 i; 320 for (i = 0; i < 16; i++) { 321 temp[i] = S[state[i]]; 322 } 323 return temp; 324 }, 325 326 shiftRows = function(state) { 327 var temp = [], 328 shiftBy = Decrypt ? [0, 13, 10, 7, 4, 1, 14, 11, 8, 5, 2, 15, 12, 9, 6, 3] : [0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11], 329 i; 330 for (i = 0; i < 16; i++) { 331 temp[i] = state[shiftBy[i]]; 332 } 333 return temp; 334 }, 335 336 mixColumns = function(state) { 337 var t = [], 338 c; 339 if (!Decrypt) { 340 for (c = 0; c < 4; c++) { 341 t[c * 4] = G2X[state[c * 4]] ^ G3X[state[1 + c * 4]] ^ state[2 + c * 4] ^ state[3 + c * 4]; 342 t[1 + c * 4] = state[c * 4] ^ G2X[state[1 + c * 4]] ^ G3X[state[2 + c * 4]] ^ state[3 + c * 4]; 343 t[2 + c * 4] = state[c * 4] ^ state[1 + c * 4] ^ G2X[state[2 + c * 4]] ^ G3X[state[3 + c * 4]]; 344 t[3 + c * 4] = G3X[state[c * 4]] ^ state[1 + c * 4] ^ state[2 + c * 4] ^ G2X[state[3 + c * 4]]; 345 } 346 }else { 347 for (c = 0; c < 4; c++) { 348 t[c*4] = GEX[state[c*4]] ^ GBX[state[1+c*4]] ^ GDX[state[2+c*4]] ^ G9X[state[3+c*4]]; 349 t[1+c*4] = G9X[state[c*4]] ^ GEX[state[1+c*4]] ^ GBX[state[2+c*4]] ^ GDX[state[3+c*4]]; 350 t[2+c*4] = GDX[state[c*4]] ^ G9X[state[1+c*4]] ^ GEX[state[2+c*4]] ^ GBX[state[3+c*4]]; 351 t[3+c*4] = GBX[state[c*4]] ^ GDX[state[1+c*4]] ^ G9X[state[2+c*4]] ^ GEX[state[3+c*4]]; 352 } 353 } 354 355 return t; 356 }, 357
358 addRoundKey = function(state, words, round) { 359 var temp = [], 360 i; 361 for (i = 0; i < 16; i++) { 362 temp[i] = state[i] ^ words[round][i]; 363 } 364 return temp; 365 }, 366 367 xorBlocks = function(block1, block2) { 368 var temp = [], 369 i; 370 for (i = 0; i < 16; i++) { 371 temp[i] = block1[i] ^ block2[i]; 372 } 373 return temp; 374 }, 375 376 expandKey = function(key) { 377 // Expects a 1d number array 378 var w = [], 379 temp = [], 380 i, 381 r, 382 t, 383 flat = [], 384 j; 385 386 for (i = 0; i < Nk; i++) { 387 r = [key[4 * i], key[4 * i + 1], key[4 * i + 2], key[4 * i + 3]]; 388 w[i] = r; 389 } 390 391 for (i = Nk; i < (4 * (Nr + 1)); i++) { 392 w[i] = []; 393 for (t = 0; t < 4; t++) { 394 temp[t] = w[i - 1][t]; 395 } 396 if (i % Nk === 0) { 397 temp = subWord(rotWord(temp)); 398 temp[0] ^= Rcon[i / Nk - 1]; 399 } else if (Nk > 6 && i % Nk === 4) { 400 temp = subWord(temp); 401 } 402 for (t = 0; t < 4; t++) { 403 w[i][t] = w[i - Nk][t] ^ temp[t]; 404 } 405 } 406 for (i = 0; i < (Nr + 1); i++) { 407 flat[i] = []; 408 for (j = 0; j < 4; j++) { 409 flat[i].push(w[i * 4 + j][0], w[i * 4 + j][1], w[i * 4 + j][2], w[i * 4 + j][3]); 410 } 411 } 412 return flat; 413 }, 414 415 subWord = function(w) { 416 // apply SBox to 4-byte word w 417 for (var i = 0; i < 4; i++) { 418 w[i] = SBox[w[i]]; 419 } 420 return w; 421 }, 422 423 rotWord = function(w) { 424 // rotate 4-byte word w left by one byte 425 var tmp = w[0], 426 i; 427 for (i = 0; i < 4; i++) { 428 w[i] = w[i + 1]; 429 } 430 w[3] = tmp; 431 return w; 432 }, 433 434 435 // S-box 436 SBox = [ 437 99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 438 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 439 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 440 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 441 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 442 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 443 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 444 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 445 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 446 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 447 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 448 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 449 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 450 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 451 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 452 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 453 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 454 22], 455 456 // Precomputed lookup table for the inverse SBox 457 SBoxInv = [ 458 82, 9, 106, 213, 48, 54, 165, 56, 191, 64, 163, 158, 129, 243, 215, 459 251, 124, 227, 57, 130, 155, 47, 255, 135, 52, 142, 67, 68, 196, 222, 460 233, 203, 84, 123, 148, 50, 166, 194, 35, 61, 238, 76, 149, 11, 66, 461 250, 195, 78, 8, 46, 161, 102, 40, 217, 36, 178, 118, 91, 162, 73, 462 109, 139, 209, 37, 114, 248, 246, 100, 134, 104, 152, 22, 212, 164, 92, 463 204, 93, 101, 182, 146, 108, 112, 72, 80, 253, 237, 185, 218, 94, 21, 464 70, 87, 167, 141, 157, 132, 144, 216, 171, 0, 140, 188, 211, 10, 247, 465 228, 88, 5, 184, 179, 69, 6, 208, 44, 30, 143, 202, 63, 15, 2, 466 193, 175, 189, 3, 1, 19, 138, 107, 58, 145, 17, 65, 79, 103, 220, 467 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116, 34, 231, 173, 468 53, 133, 226, 249, 55, 232, 28, 117, 223, 110, 71, 241, 26, 113, 29, 469 41, 197, 137, 111, 183, 98, 14, 170, 24, 190, 27, 252, 86, 62, 75, 470 198, 210, 121, 32, 154, 219, 192, 254, 120, 205, 90, 244, 31, 221, 168,
471 51, 136, 7, 199, 49, 177, 18, 16, 89, 39, 128, 236, 95, 96, 81, 472 127, 169, 25, 181, 74, 13, 45, 229, 122, 159, 147, 201, 156, 239, 160, 473 224, 59, 77, 174, 42, 245, 176, 200, 235, 187, 60, 131, 83, 153, 97, 474 23, 43, 4, 126, 186, 119, 214, 38, 225, 105, 20, 99, 85, 33, 12, 475 125], 476 // Rijndael Rcon 477 Rcon = [1, 2, 4, 8, 16, 32, 64, 128, 27, 54, 108, 216, 171, 77, 154, 47, 94, 478 188, 99, 198, 151, 53, 106, 212, 179, 125, 250, 239, 197, 145], 479 480 G2X = [ 481 0x00, 0x02, 0x04, 0x06, 0x08, 0x0a, 0x0c, 0x0e, 0x10, 0x12, 0x14, 0x16, 482 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 483 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 484 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, 0x5e, 485 0x60, 0x62, 0x64, 0x66, 0x68, 0x6a, 0x6c, 0x6e, 0x70, 0x72, 0x74, 0x76, 486 0x78, 0x7a, 0x7c, 0x7e, 0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c, 0x8e, 487 0x90, 0x92, 0x94, 0x96, 0x98, 0x9a, 0x9c, 0x9e, 0xa0, 0xa2, 0xa4, 0xa6, 488 0xa8, 0xaa, 0xac, 0xae, 0xb0, 0xb2, 0xb4, 0xb6, 0xb8, 0xba, 0xbc, 0xbe, 489 0xc0, 0xc2, 0xc4, 0xc6, 0xc8, 0xca, 0xcc, 0xce, 0xd0, 0xd2, 0xd4, 0xd6, 490 0xd8, 0xda, 0xdc, 0xde, 0xe0, 0xe2, 0xe4, 0xe6, 0xe8, 0xea, 0xec, 0xee, 491 0xf0, 0xf2, 0xf4, 0xf6, 0xf8, 0xfa, 0xfc, 0xfe, 0x1b, 0x19, 0x1f, 0x1d, 492 0x13, 0x11, 0x17, 0x15, 0x0b, 0x09, 0x0f, 0x0d, 0x03, 0x01, 0x07, 0x05, 493 0x3b, 0x39, 0x3f, 0x3d, 0x33, 0x31, 0x37, 0x35, 0x2b, 0x29, 0x2f, 0x2d, 494 0x23, 0x21, 0x27, 0x25, 0x5b, 0x59, 0x5f, 0x5d, 0x53, 0x51, 0x57, 0x55, 495 0x4b, 0x49, 0x4f, 0x4d, 0x43, 0x41, 0x47, 0x45, 0x7b, 0x79, 0x7f, 0x7d, 496 0x73, 0x71, 0x77, 0x75, 0x6b, 0x69, 0x6f, 0x6d, 0x63, 0x61, 0x67, 0x65, 497 0x9b, 0x99, 0x9f, 0x9d, 0x93, 0x91, 0x97, 0x95, 0x8b, 0x89, 0x8f, 0x8d, 498 0x83, 0x81, 0x87, 0x85, 0xbb, 0xb9, 0xbf, 0xbd, 0xb3, 0xb1, 0xb7, 0xb5, 499 0xab, 0xa9, 0xaf, 0xad, 0xa3, 0xa1, 0xa7, 0xa5, 0xdb, 0xd9, 0xdf, 0xdd, 500 0xd3, 0xd1, 0xd7, 0xd5, 0xcb, 0xc9, 0xcf, 0xcd, 0xc3, 0xc1, 0xc7, 0xc5, 501 0xfb, 0xf9, 0xff, 0xfd, 0xf3, 0xf1, 0xf7, 0xf5, 0xeb, 0xe9, 0xef, 0xed, 502 0xe3, 0xe1, 0xe7, 0xe5 503 ], 504 505 G3X = [ 506 0x00, 0x03, 0x06, 0x05, 0x0c, 0x0f, 0x0a, 0x09, 0x18, 0x1b, 0x1e, 0x1d, 507 0x14, 0x17, 0x12, 0x11, 0x30, 0x33, 0x36, 0x35, 0x3c, 0x3f, 0x3a, 0x39, 508 0x28, 0x2b, 0x2e, 0x2d, 0x24, 0x27, 0x22, 0x21, 0x60, 0x63, 0x66, 0x65, 509 0x6c, 0x6f, 0x6a, 0x69, 0x78, 0x7b, 0x7e, 0x7d, 0x74, 0x77, 0x72, 0x71, 510 0x50, 0x53, 0x56, 0x55, 0x5c, 0x5f, 0x5a, 0x59, 0x48, 0x4b, 0x4e, 0x4d, 511 0x44, 0x47, 0x42, 0x41, 0xc0, 0xc3, 0xc6, 0xc5, 0xcc, 0xcf, 0xca, 0xc9, 512 0xd8, 0xdb, 0xde, 0xdd, 0xd4, 0xd7, 0xd2, 0xd1, 0xf0, 0xf3, 0xf6, 0xf5, 513 0xfc, 0xff, 0xfa, 0xf9, 0xe8, 0xeb, 0xee, 0xed, 0xe4, 0xe7, 0xe2, 0xe1, 514 0xa0, 0xa3, 0xa6, 0xa5, 0xac, 0xaf, 0xaa, 0xa9, 0xb8, 0xbb, 0xbe, 0xbd, 515 0xb4, 0xb7, 0xb2, 0xb1, 0x90, 0x93, 0x96, 0x95, 0x9c, 0x9f, 0x9a, 0x99, 516 0x88, 0x8b, 0x8e, 0x8d, 0x84, 0x87, 0x82, 0x81, 0x9b, 0x98, 0x9d, 0x9e, 517 0x97, 0x94, 0x91, 0x92, 0x83, 0x80, 0x85, 0x86, 0x8f, 0x8c, 0x89, 0x8a, 518 0xab, 0xa8, 0xad, 0xae, 0xa7, 0xa4, 0xa1, 0xa2, 0xb3, 0xb0, 0xb5, 0xb6, 519 0xbf, 0xbc, 0xb9, 0xba, 0xfb, 0xf8, 0xfd, 0xfe, 0xf7, 0xf4, 0xf1, 0xf2, 520 0xe3, 0xe0, 0xe5, 0xe6, 0xef, 0xec, 0xe9, 0xea, 0xcb, 0xc8, 0xcd, 0xce, 521 0xc7, 0xc4, 0xc1, 0xc2, 0xd3, 0xd0, 0xd5, 0xd6, 0xdf, 0xdc, 0xd9, 0xda, 522 0x5b, 0x58, 0x5d, 0x5e, 0x57, 0x54, 0x51, 0x52, 0x43, 0x40, 0x45, 0x46, 523 0x4f, 0x4c, 0x49, 0x4a, 0x6b, 0x68, 0x6d, 0x6e, 0x67, 0x64, 0x61, 0x62, 524 0x73, 0x70, 0x75, 0x76, 0x7f, 0x7c, 0x79, 0x7a, 0x3b, 0x38, 0x3d, 0x3e, 525 0x37, 0x34, 0x31, 0x32, 0x23, 0x20, 0x25, 0x26, 0x2f, 0x2c, 0x29, 0x2a, 526 0x0b, 0x08, 0x0d, 0x0e, 0x07, 0x04, 0x01, 0x02, 0x13, 0x10, 0x15, 0x16, 527 0x1f, 0x1c, 0x19, 0x1a 528 ], 529 530 G9X = [ 531 0x00, 0x09, 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x41, 0x5a, 0x53, 532 0x6c, 0x65, 0x7e, 0x77, 0x90, 0x99, 0x82, 0x8b, 0xb4, 0xbd, 0xa6, 0xaf, 533 0xd8, 0xd1, 0xca, 0xc3, 0xfc, 0xf5, 0xee, 0xe7, 0x3b, 0x32, 0x29, 0x20, 534 0x1f, 0x16, 0x0d, 0x04, 0x73, 0x7a, 0x61, 0x68, 0x57, 0x5e, 0x45, 0x4c, 535 0xab, 0xa2, 0xb9, 0xb0, 0x8f, 0x86, 0x9d, 0x94, 0xe3, 0xea, 0xf1, 0xf8, 536 0xc7, 0xce, 0xd5, 0xdc, 0x76, 0x7f, 0x64, 0x6d, 0x52, 0x5b, 0x40, 0x49, 537 0x3e, 0x37, 0x2c, 0x25, 0x1a, 0x13, 0x08, 0x01, 0xe6, 0xef, 0xf4, 0xfd, 538 0xc2, 0xcb, 0xd0, 0xd9, 0xae, 0xa7, 0xbc, 0xb5, 0x8a, 0x83, 0x98, 0x91, 539 0x4d, 0x44, 0x5f, 0x56, 0x69, 0x60, 0x7b, 0x72, 0x05, 0x0c, 0x17, 0x1e,
540 0x21, 0x28, 0x33, 0x3a, 0xdd, 0xd4, 0xcf, 0xc6, 0xf9, 0xf0, 0xeb, 0xe2, 541 0x95, 0x9c, 0x87, 0x8e, 0xb1, 0xb8, 0xa3, 0xaa, 0xec, 0xe5, 0xfe, 0xf7, 542 0xc8, 0xc1, 0xda, 0xd3, 0xa4, 0xad, 0xb6, 0xbf, 0x80, 0x89, 0x92, 0x9b, 543 0x7c, 0x75, 0x6e, 0x67, 0x58, 0x51, 0x4a, 0x43, 0x34, 0x3d, 0x26, 0x2f, 544 0x10, 0x19, 0x02, 0x0b, 0xd7, 0xde, 0xc5, 0xcc, 0xf3, 0xfa, 0xe1, 0xe8, 545 0x9f, 0x96, 0x8d, 0x84, 0xbb, 0xb2, 0xa9, 0xa0, 0x47, 0x4e, 0x55, 0x5c, 546 0x63, 0x6a, 0x71, 0x78, 0x0f, 0x06, 0x1d, 0x14, 0x2b, 0x22, 0x39, 0x30, 547 0x9a, 0x93, 0x88, 0x81, 0xbe, 0xb7, 0xac, 0xa5, 0xd2, 0xdb, 0xc0, 0xc9, 548 0xf6, 0xff, 0xe4, 0xed, 0x0a, 0x03, 0x18, 0x11, 0x2e, 0x27, 0x3c, 0x35, 549 0x42, 0x4b, 0x50, 0x59, 0x66, 0x6f, 0x74, 0x7d, 0xa1, 0xa8, 0xb3, 0xba, 550 0x85, 0x8c, 0x97, 0x9e, 0xe9, 0xe0, 0xfb, 0xf2, 0xcd, 0xc4, 0xdf, 0xd6, 551 0x31, 0x38, 0x23, 0x2a, 0x15, 0x1c, 0x07, 0x0e, 0x79, 0x70, 0x6b, 0x62, 552 0x5d, 0x54, 0x4f, 0x46 553 ], 554 555 GBX = [ 556 0x00, 0x0b, 0x16, 0x1d, 0x2c, 0x27, 0x3a, 0x31, 0x58, 0x53, 0x4e, 0x45, 557 0x74, 0x7f, 0x62, 0x69, 0xb0, 0xbb, 0xa6, 0xad, 0x9c, 0x97, 0x8a, 0x81, 558 0xe8, 0xe3, 0xfe, 0xf5, 0xc4, 0xcf, 0xd2, 0xd9, 0x7b, 0x70, 0x6d, 0x66, 559 0x57, 0x5c, 0x41, 0x4a, 0x23, 0x28, 0x35, 0x3e, 0x0f, 0x04, 0x19, 0x12, 560 0xcb, 0xc0, 0xdd, 0xd6, 0xe7, 0xec, 0xf1, 0xfa, 0x93, 0x98, 0x85, 0x8e, 561 0xbf, 0xb4, 0xa9, 0xa2, 0xf6, 0xfd, 0xe0, 0xeb, 0xda, 0xd1, 0xcc, 0xc7, 562 0xae, 0xa5, 0xb8, 0xb3, 0x82, 0x89, 0x94, 0x9f, 0x46, 0x4d, 0x50, 0x5b, 563 0x6a, 0x61, 0x7c, 0x77, 0x1e, 0x15, 0x08, 0x03, 0x32, 0x39, 0x24, 0x2f, 564 0x8d, 0x86, 0x9b, 0x90, 0xa1, 0xaa, 0xb7, 0xbc, 0xd5, 0xde, 0xc3, 0xc8, 565 0xf9, 0xf2, 0xef, 0xe4, 0x3d, 0x36, 0x2b, 0x20, 0x11, 0x1a, 0x07, 0x0c, 566 0x65, 0x6e, 0x73, 0x78, 0x49, 0x42, 0x5f, 0x54, 0xf7, 0xfc, 0xe1, 0xea, 567 0xdb, 0xd0, 0xcd, 0xc6, 0xaf, 0xa4, 0xb9, 0xb2, 0x83, 0x88, 0x95, 0x9e, 568 0x47, 0x4c, 0x51, 0x5a, 0x6b, 0x60, 0x7d, 0x76, 0x1f, 0x14, 0x09, 0x02, 569 0x33, 0x38, 0x25, 0x2e, 0x8c, 0x87, 0x9a, 0x91, 0xa0, 0xab, 0xb6, 0xbd, 570 0xd4, 0xdf, 0xc2, 0xc9, 0xf8, 0xf3, 0xee, 0xe5, 0x3c, 0x37, 0x2a, 0x21, 571 0x10, 0x1b, 0x06, 0x0d, 0x64, 0x6f, 0x72, 0x79, 0x48, 0x43, 0x5e, 0x55, 572 0x01, 0x0a, 0x17, 0x1c, 0x2d, 0x26, 0x3b, 0x30, 0x59, 0x52, 0x4f, 0x44, 573 0x75, 0x7e, 0x63, 0x68, 0xb1, 0xba, 0xa7, 0xac, 0x9d, 0x96, 0x8b, 0x80, 574 0xe9, 0xe2, 0xff, 0xf4, 0xc5, 0xce, 0xd3, 0xd8, 0x7a, 0x71, 0x6c, 0x67, 575 0x56, 0x5d, 0x40, 0x4b, 0x22, 0x29, 0x34, 0x3f, 0x0e, 0x05, 0x18, 0x13, 576 0xca, 0xc1, 0xdc, 0xd7, 0xe6, 0xed, 0xf0, 0xfb, 0x92, 0x99, 0x84, 0x8f, 577 0xbe, 0xb5, 0xa8, 0xa3 578 ], 579 580 GDX = [ 581 0x00, 0x0d, 0x1a, 0x17, 0x34, 0x39, 0x2e, 0x23, 0x68, 0x65, 0x72, 0x7f, 582 0x5c, 0x51, 0x46, 0x4b, 0xd0, 0xdd, 0xca, 0xc7, 0xe4, 0xe9, 0xfe, 0xf3, 583 0xb8, 0xb5, 0xa2, 0xaf, 0x8c, 0x81, 0x96, 0x9b, 0xbb, 0xb6, 0xa1, 0xac, 584 0x8f, 0x82, 0x95, 0x98, 0xd3, 0xde, 0xc9, 0xc4, 0xe7, 0xea, 0xfd, 0xf0, 585 0x6b, 0x66, 0x71, 0x7c, 0x5f, 0x52, 0x45, 0x48, 0x03, 0x0e, 0x19, 0x14, 586 0x37, 0x3a, 0x2d, 0x20, 0x6d, 0x60, 0x77, 0x7a, 0x59, 0x54, 0x43, 0x4e, 587 0x05, 0x08, 0x1f, 0x12, 0x31, 0x3c, 0x2b, 0x26, 0xbd, 0xb0, 0xa7, 0xaa, 588 0x89, 0x84, 0x93, 0x9e, 0xd5, 0xd8, 0xcf, 0xc2, 0xe1, 0xec, 0xfb, 0xf6, 589 0xd6, 0xdb, 0xcc, 0xc1, 0xe2, 0xef, 0xf8, 0xf5, 0xbe, 0xb3, 0xa4, 0xa9, 590 0x8a, 0x87, 0x90, 0x9d, 0x06, 0x0b, 0x1c, 0x11, 0x32, 0x3f, 0x28, 0x25, 591 0x6e, 0x63, 0x74, 0x79, 0x5a, 0x57, 0x40, 0x4d, 0xda, 0xd7, 0xc0, 0xcd, 592 0xee, 0xe3, 0xf4, 0xf9, 0xb2, 0xbf, 0xa8, 0xa5, 0x86, 0x8b, 0x9c, 0x91, 593 0x0a, 0x07, 0x10, 0x1d, 0x3e, 0x33, 0x24, 0x29, 0x62, 0x6f, 0x78, 0x75, 594 0x56, 0x5b, 0x4c, 0x41, 0x61, 0x6c, 0x7b, 0x76, 0x55, 0x58, 0x4f, 0x42, 595 0x09, 0x04, 0x13, 0x1e, 0x3d, 0x30, 0x27, 0x2a, 0xb1, 0xbc, 0xab, 0xa6, 596 0x85, 0x88, 0x9f, 0x92, 0xd9, 0xd4, 0xc3, 0xce, 0xed, 0xe0, 0xf7, 0xfa, 597 0xb7, 0xba, 0xad, 0xa0, 0x83, 0x8e, 0x99, 0x94, 0xdf, 0xd2, 0xc5, 0xc8, 598 0xeb, 0xe6, 0xf1, 0xfc, 0x67, 0x6a, 0x7d, 0x70, 0x53, 0x5e, 0x49, 0x44, 599 0x0f, 0x02, 0x15, 0x18, 0x3b, 0x36, 0x21, 0x2c, 0x0c, 0x01, 0x16, 0x1b, 600 0x38, 0x35, 0x22, 0x2f, 0x64, 0x69, 0x7e, 0x73, 0x50, 0x5d, 0x4a, 0x47, 601 0xdc, 0xd1, 0xc6, 0xcb, 0xe8, 0xe5, 0xf2, 0xff, 0xb4, 0xb9, 0xae, 0xa3, 602 0x80, 0x8d, 0x9a, 0x97 603 ], 604 605 GEX = [ 606 0x00, 0x0e, 0x1c, 0x12, 0x38, 0x36, 0x24, 0x2a, 0x70, 0x7e, 0x6c, 0x62, 607 0x48, 0x46, 0x54, 0x5a, 0xe0, 0xee, 0xfc, 0xf2, 0xd8, 0xd6, 0xc4, 0xca, 608 0x90, 0x9e, 0x8c, 0x82, 0xa8, 0xa6, 0xb4, 0xba, 0xdb, 0xd5, 0xc7, 0xc9, 609 0xe3, 0xed, 0xff, 0xf1, 0xab, 0xa5, 0xb7, 0xb9, 0x93, 0x9d, 0x8f, 0x81, 610 0x3b, 0x35, 0x27, 0x29, 0x03, 0x0d, 0x1f, 0x11, 0x4b, 0x45, 0x57, 0x59, 611 0x73, 0x7d, 0x6f, 0x61, 0xad, 0xa3, 0xb1, 0xbf, 0x95, 0x9b, 0x89, 0x87, 612 0xdd, 0xd3, 0xc1, 0xcf, 0xe5, 0xeb, 0xf9, 0xf7, 0x4d, 0x43, 0x51, 0x5f, 613 0x75, 0x7b, 0x69, 0x67, 0x3d, 0x33, 0x21, 0x2f, 0x05, 0x0b, 0x19, 0x17, 614 0x76, 0x78, 0x6a, 0x64, 0x4e, 0x40, 0x52, 0x5c, 0x06, 0x08, 0x1a, 0x14, 615 0x3e, 0x30, 0x22, 0x2c, 0x96, 0x98, 0x8a, 0x84, 0xae, 0xa0, 0xb2, 0xbc, 616 0xe6, 0xe8, 0xfa, 0xf4, 0xde, 0xd0, 0xc2, 0xcc, 0x41, 0x4f, 0x5d, 0x53, 617 0x79, 0x77, 0x65, 0x6b, 0x31, 0x3f, 0x2d, 0x23, 0x09, 0x07, 0x15, 0x1b, 618 0xa1, 0xaf, 0xbd, 0xb3, 0x99, 0x97, 0x85, 0x8b, 0xd1, 0xdf, 0xcd, 0xc3, 619 0xe9, 0xe7, 0xf5, 0xfb, 0x9a, 0x94, 0x86, 0x88, 0xa2, 0xac, 0xbe, 0xb0, 620 0xea, 0xe4, 0xf6, 0xf8, 0xd2, 0xdc, 0xce, 0xc0, 0x7a, 0x74, 0x66, 0x68, 621 0x42, 0x4c, 0x5e, 0x50, 0x0a, 0x04, 0x16, 0x18, 0x32, 0x3c, 0x2e, 0x20, 622 0xec, 0xe2, 0xf0, 0xfe, 0xd4, 0xda, 0xc8, 0xc6, 0x9c, 0x92, 0x80, 0x8e,
623 0xa4, 0xaa, 0xb8, 0xb6, 0x0c, 0x02, 0x10, 0x1e, 0x34, 0x3a, 0x28, 0x26, 624 0x7c, 0x72, 0x60, 0x6e, 0x44, 0x4a, 0x58, 0x56, 0x37, 0x39, 0x2b, 0x25, 625 0x0f, 0x01, 0x13, 0x1d, 0x47, 0x49, 0x5b, 0x55, 0x7f, 0x71, 0x63, 0x6d, 626 0xd7, 0xd9, 0xcb, 0xc5, 0xef, 0xe1, 0xf3, 0xfd, 0xa7, 0xa9, 0xbb, 0xb5, 627 0x9f, 0x91, 0x83, 0x8d 628 ], 629 630 enc = function(string, pass, binary) { 631 // string, password in plaintext 632 var salt = randArr(8), 633 pbe = openSSLKey(s2a(pass, binary), salt), 634 key = pbe.key, 635 iv = pbe.iv, 636 cipherBlocks, 637 saltBlock = [[83, 97, 108, 116, 101, 100, 95, 95].concat(salt)]; 638 string = s2a(string, binary); 639 cipherBlocks = rawEncrypt(string, key, iv); 640 // Spells out 'Salted__' 641 cipherBlocks = saltBlock.concat(cipherBlocks); 642 return Base64.encode(cipherBlocks); 643 }, 644 645 dec = function(string, pass, binary) { 646 // string, password in plaintext 647 var cryptArr = Base64.decode(string), 648 salt = cryptArr.slice(8, 16), 649 pbe = openSSLKey(s2a(pass, binary), salt), 650 key = pbe.key, 651 iv = pbe.iv; 652 cryptArr = cryptArr.slice(16, cryptArr.length); 653 // Take off the Salted__ffeeddcc 654 string = rawDecrypt(cryptArr, key, iv, binary); 655 return string; 656 }, 657 658 MD5 = function(numArr) { 659 660 function rotateLeft(lValue, iShiftBits) { 661 return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits)); 662 } 663 664 function addUnsigned(lX, lY) { 665 var lX4, 666 lY4, 667 lX8, 668 lY8, 669 lResult; 670 lX8 = (lX & 0x80000000); 671 lY8 = (lY & 0x80000000); 672 lX4 = (lX & 0x40000000); 673 lY4 = (lY & 0x40000000); 674 lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF); 675 if (lX4 & lY4) { 676 return (lResult ^ 0x80000000 ^ lX8 ^ lY8); 677 } 678 if (lX4 | lY4) { 679 if (lResult & 0x40000000) { 680 return (lResult ^ 0xC0000000 ^ lX8 ^ lY8); 681 } else { 682 return (lResult ^ 0x40000000 ^ lX8 ^ lY8); 683 } 684 } else { 685 return (lResult ^ lX8 ^ lY8); 686 } 687 } 688 689 function f(x, y, z) { 690 return (x & y) | ((~x) & z); 691 } 692 function g(x, y, z) { 693 return (x & z) | (y & (~z)); 694 } 695 function h(x, y, z) { 696 return (x ^ y ^ z); 697 } 698 function funcI(x, y, z) { 699 return (y ^ (x | (~z))); 700 } 701 702 function ff(a, b, c, d, x, s, ac) { 703 a = addUnsigned(a, addUnsigned(addUnsigned(f(b, c, d), x), ac)); 704 return addUnsigned(rotateLeft(a, s), b); 705 } 706 707 function gg(a, b, c, d, x, s, ac) { 708 a = addUnsigned(a, addUnsigned(addUnsigned(g(b, c, d), x), ac)); 709 return addUnsigned(rotateLeft(a, s), b); 710 } 711 712 function hh(a, b, c, d, x, s, ac) { 713 a = addUnsigned(a, addUnsigned(addUnsigned(h(b, c, d), x), ac)); 714 return addUnsigned(rotateLeft(a, s), b); 715 } 716 717 function ii(a, b, c, d, x, s, ac) { 718 a = addUnsigned(a, addUnsigned(addUnsigned(funcI(b, c, d), x), ac)); 719 return addUnsigned(rotateLeft(a, s), b); 720 } 721 722 function convertToWordArray(numArr) { 723 var lWordCount, 724 lMessageLength = numArr.length, 725 lNumberOfWords_temp1 = lMessageLength + 8, 726 lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64, 727 lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16, 728 lWordArray = [], 729 lBytePosition = 0, 730 lByteCount = 0; 731 while (lByteCount < lMessageLength) { 732 lWordCount = (lByteCount - (lByteCount % 4)) / 4; 733 lBytePosition = (lByteCount % 4) * 8; 734 lWordArray[lWordCount] = (lWordArray[lWordCount] | (numArr[lByteCount] << lBytePosition)); 735 lByteCount++; 736 } 737 lWordCount = (lByteCount - (lByteCount % 4)) / 4; 738 lBytePosition = (lByteCount % 4) * 8; 739 lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition); 740 lWordArray[lNumberOfWords - 2] = lMessageLength << 3; 741 lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29; 742 return lWordArray; 743 } 744 745 function wordToHex(lValue) { 746 var lByte, 747 lCount, 748 wordToHexArr = []; 749 for (lCount = 0; lCount <= 3; lCount++) { 750 lByte = (lValue >>> (lCount * 8)) & 255; 751 wordToHexArr = wordToHexArr.concat(lByte); 752 } 753 return wordToHexArr; 754 } 755 756 /*function utf8Encode(string) {
757 string = string.replace(/\r\n/g, "\n"); 758 var utftext = "", 759 n, 760 c; 761 762 for (n = 0; n < string.length; n++) { 763 764 c = string.charCodeAt(n); 765 766 if (c < 128) { 767 utftext += String.fromCharCode(c); 768 } 769 else if ((c > 127) && (c < 2048)) { 770 utftext += String.fromCharCode((c >> 6) | 192); 771 utftext += String.fromCharCode((c & 63) | 128); 772 } 773 else { 774 utftext += String.fromCharCode((c >> 12) | 224); 775 utftext += String.fromCharCode(((c >> 6) & 63) | 128); 776 utftext += String.fromCharCode((c & 63) | 128); 777 } 778 779 } 780 781 return utftext; 782 }*/ 783 784 var x = [], 785 k, 786 AA, 787 BB, 788 CC, 789 DD, 790 a, 791 b, 792 c, 793 d, 794 S11 = 7, 795 S12 = 12, 796 S13 = 17, 797 S14 = 22, 798 S21 = 5, 799 S22 = 9, 800 S23 = 14, 801 S24 = 20, 802 S31 = 4, 803 S32 = 11, 804 S33 = 16, 805 S34 = 23, 806 S41 = 6, 807 S42 = 10, 808 S43 = 15, 809 S44 = 21; 810 811 x = convertToWordArray(numArr); 812 813 a = 0x67452301; 814 b = 0xEFCDAB89; 815 c = 0x98BADCFE; 816 d = 0x10325476; 817 818 for (k = 0; k < x.length; k += 16) { 819 AA = a; 820 BB = b; 821 CC = c; 822 DD = d; 823 a = ff(a, b, c, d, x[k + 0], S11, 0xD76AA478); 824 d = ff(d, a, b, c, x[k + 1], S12, 0xE8C7B756); 825 c = ff(c, d, a, b, x[k + 2], S13, 0x242070DB); 826 b = ff(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE); 827 a = ff(a, b, c, d, x[k + 4], S11, 0xF57C0FAF); 828 d = ff(d, a, b, c, x[k + 5], S12, 0x4787C62A); 829 c = ff(c, d, a, b, x[k + 6], S13, 0xA8304613); 830 b = ff(b, c, d, a, x[k + 7], S14, 0xFD469501); 831 a = ff(a, b, c, d, x[k + 8], S11, 0x698098D8); 832 d = ff(d, a, b, c, x[k + 9], S12, 0x8B44F7AF); 833 c = ff(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1); 834 b = ff(b, c, d, a, x[k + 11], S14, 0x895CD7BE); 835 a = ff(a, b, c, d, x[k + 12], S11, 0x6B901122); 836 d = ff(d, a, b, c, x[k + 13], S12, 0xFD987193); 837 c = ff(c, d, a, b, x[k + 14], S13, 0xA679438E); 838 b = ff(b, c, d, a, x[k + 15], S14, 0x49B40821); 839 a = gg(a, b, c, d, x[k + 1], S21, 0xF61E2562); 840 d = gg(d, a, b, c, x[k + 6], S22, 0xC040B340); 841 c = gg(c, d, a, b, x[k + 11], S23, 0x265E5A51); 842 b = gg(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA); 843 a = gg(a, b, c, d, x[k + 5], S21, 0xD62F105D); 844 d = gg(d, a, b, c, x[k + 10], S22, 0x2441453); 845 c = gg(c, d, a, b, x[k + 15], S23, 0xD8A1E681); 846 b = gg(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8); 847 a = gg(a, b, c, d, x[k + 9], S21, 0x21E1CDE6); 848 d = gg(d, a, b, c, x[k + 14], S22, 0xC33707D6); 849 c = gg(c, d, a, b, x[k + 3], S23, 0xF4D50D87); 850 b = gg(b, c, d, a, x[k + 8], S24, 0x455A14ED); 851 a = gg(a, b, c, d, x[k + 13], S21, 0xA9E3E905); 852 d = gg(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8); 853 c = gg(c, d, a, b, x[k + 7], S23, 0x676F02D9); 854 b = gg(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A); 855 a = hh(a, b, c, d, x[k + 5], S31, 0xFFFA3942); 856 d = hh(d, a, b, c, x[k + 8], S32, 0x8771F681); 857 c = hh(c, d, a, b, x[k + 11], S33, 0x6D9D6122); 858 b = hh(b, c, d, a, x[k + 14], S34, 0xFDE5380C); 859 a = hh(a, b, c, d, x[k + 1], S31, 0xA4BEEA44); 860 d = hh(d, a, b, c, x[k + 4], S32, 0x4BDECFA9); 861 c = hh(c, d, a, b, x[k + 7], S33, 0xF6BB4B60); 862 b = hh(b, c, d, a, x[k + 10], S34, 0xBEBFBC70); 863 a = hh(a, b, c, d, x[k + 13], S31, 0x289B7EC6); 864 d = hh(d, a, b, c, x[k + 0], S32, 0xEAA127FA); 865 c = hh(c, d, a, b, x[k + 3], S33, 0xD4EF3085); 866 b = hh(b, c, d, a, x[k + 6], S34, 0x4881D05); 867 a = hh(a, b, c, d, x[k + 9], S31, 0xD9D4D039); 868 d = hh(d, a, b, c, x[k + 12], S32, 0xE6DB99E5); 869 c = hh(c, d, a, b, x[k + 15], S33, 0x1FA27CF8); 870 b = hh(b, c, d, a, x[k + 2], S34, 0xC4AC5665); 871 a = ii(a, b, c, d, x[k + 0], S41, 0xF4292244); 872 d = ii(d, a, b, c, x[k + 7], S42, 0x432AFF97); 873 c = ii(c, d, a, b, x[k + 14], S43, 0xAB9423A7); 874 b = ii(b, c, d, a, x[k + 5], S44, 0xFC93A039); 875 a = ii(a, b, c, d, x[k + 12], S41, 0x655B59C3); 876 d = ii(d, a, b, c, x[k + 3], S42, 0x8F0CCC92); 877 c = ii(c, d, a, b, x[k + 10], S43, 0xFFEFF47D); 878 b = ii(b, c, d, a, x[k + 1], S44, 0x85845DD1); 879 a = ii(a, b, c, d, x[k + 8], S41, 0x6FA87E4F); 880 d = ii(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0); 881 c = ii(c, d, a, b, x[k + 6], S43, 0xA3014314); 882 b = ii(b, c, d, a, x[k + 13], S44, 0x4E0811A1); 883 a = ii(a, b, c, d, x[k + 4], S41, 0xF7537E82);
884 d = ii(d, a, b, c, x[k + 11], S42, 0xBD3AF235); 885 c = ii(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB); 886 b = ii(b, c, d, a, x[k + 9], S44, 0xEB86D391); 887 a = addUnsigned(a, AA); 888 b = addUnsigned(b, BB); 889 c = addUnsigned(c, CC); 890 d = addUnsigned(d, DD); 891 } 892 893 return wordToHex(a).concat(wordToHex(b), wordToHex(c), wordToHex(d)); 894 }, 895 896 897 Base64 = (function(){ 898 // Takes a Nx16x1 byte array and converts it to Base64 899 var _chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', 900 chars = _chars.split(''), 901 902 encode = function(b, withBreaks) { 903 var flatArr = [], 904 b64 = '', 905 i, 906 broken_b64; 907 // var totalChunks = Math.floor(b.length * 16 / 3); 908 for (i = 0; i < b.length * 16; i++) { 909 flatArr.push(b[Math.floor(i / 16)][i % 16]); 910 } 911 for (i = 0; i < flatArr.length; i = i + 3) { 912 b64 += chars[flatArr[i] >> 2]; 913 b64 += chars[((flatArr[i] & 3) << 4) | (flatArr[i + 1] >> 4)]; 914 if (! (flatArr[i + 1] === undefined)) { 915 b64 += chars[((flatArr[i + 1] & 15) << 2) | (flatArr[i + 2] >> 6)]; 916 } else { 917 b64 += '='; 918 } 919 if (! (flatArr[i + 2] === undefined)) { 920 b64 += chars[flatArr[i + 2] & 63]; 921 } else { 922 b64 += '='; 923 } 924 } 925 // OpenSSL is super particular about line breaks 926 broken_b64 = b64.slice(0, 64) + '\n'; 927 for (i = 1; i < (Math.ceil(b64.length / 64)); i++) { 928 broken_b64 += b64.slice(i * 64, i * 64 + 64) + (Math.ceil(b64.length / 64) === i + 1 ? '': '\n'); 929 } 930 return broken_b64; 931 }, 932 933 decode = function(string) { 934 string = string.replace(/\n/g, ''); 935 var flatArr = [], 936 c = [], 937 b = [], 938 i; 939 for (i = 0; i < string.length; i = i + 4) { 940 c[0] = _chars.indexOf(string.charAt(i)); 941 c[1] = _chars.indexOf(string.charAt(i + 1)); 942 c[2] = _chars.indexOf(string.charAt(i + 2)); 943 c[3] = _chars.indexOf(string.charAt(i + 3)); 944 945 b[0] = (c[0] << 2) | (c[1] >> 4); 946 b[1] = ((c[1] & 15) << 4) | (c[2] >> 2); 947 b[2] = ((c[2] & 3) << 6) | c[3]; 948 flatArr.push(b[0], b[1], b[2]); 949 } 950 flatArr = flatArr.slice(0, flatArr.length - (flatArr.length % 16)); 951 return flatArr; 952 }; 953 954 //internet explorer 955 if(typeof Array.indexOf === 'function') { 956 _chars = chars; 957 } 958 959 /* 960 //other way to solve internet explorer problem 961 if(!Array.indexOf){ 962 Array.prototype.indexOf = function(obj){ 963 for(var i=0; i<this.length; i++){ 964 if(this[i]===obj){ 965 return i; 966 } 967 } 968 return -1; 969 } 970 } 971 */ 972 973 974 return { 975 'encode': encode, 976 'decode': decode 977 }; 978 })(); 979 980 return { 981 'size': size, 982 'h2a':h2a, 983 'expandKey':expandKey, 984 'encryptBlock':encryptBlock, 985 'decryptBlock':decryptBlock, 986 'Decrypt':Decrypt, 987 's2a':s2a, 988 'rawEncrypt':rawEncrypt, 989 'aesEncrypt':aesEncrypt, 990 'aesDecrypt':aesDecrypt, 991 'dec':dec, 992 'openSSLKey':openSSLKey, 993 'a2h':a2h, 994 'enc':enc, 995 'Hash':{'MD5':MD5}, 996 'Base64':Base64 997 }; 998 999})(); 1000 1001window.GibberishAES = GibberishAES
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.