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