DarCas Sandbox

Come in ogni altro ambito, crittografare le comunicazioni tra un client ed un server può rivelarsi molto importante ai fini della sicurezza e della solidità dell’applicazione.

Con JavaScript e XHR (o XMLHttpRequest) sono esplose le web application che fanno un uso massiccio di comunicazioni asincrone tra server e client. Molte di queste applicazioni gestiscono autenticazioni e scambio di dati personali in totale trasparenza.

Basta infatti un banale debugger, tipo Firebug per Mozilla Firefox, per avere sotto controllo tutte le comunicazioni che avvengo tra il nostro browser ed il server. Si posso scoprire password, modalità di accesso nonché parametri particolari che i più smaliziati potrebbero utilizzare a proprio favore.

Per ovviare a questo problema si potrebbe pensare a crittografare i dati in uscita ed in entrata. Una dritta l’ho trovata su questo post di Josh Davis, che illustra come applicare una crittografia reversibile allo scambio dei dati.

Lo script è molto complesso nel suo insieme:

/* * Advanced Encryption Standard (AES) * Full Copyright and License in http://blog.josh-davis.org/wp-content/uploads/2007/05/aes.js */ // encodes a unicode string to UTF8 (8 bit characters are critical to AES functioning properly) function encode_utf8(s) { var ret = null try { ret = unescape(encodeURIComponent(s)); } catch(e) { return s } return ret; } // decodes a UTF8 string back to unicode function decode_utf8(s) { var ret = null try { ret = decodeURIComponent(escape(s)); } catch(e) { return s } return ret; } // escape control chars which might cause problems handling ciphertext function escCtrlChars(str) { // xa0 to cater for bug in Firefox; include '-' to leave it free for use as a block marker return str.replace(/[�tnvfrxa0!-]/g, function(c) { return '!' + c.charCodeAt(0) + '!'; }); } // unescape potentially problematic control characters function unescCtrlChars(str) { return str.replace(/!dd?d?!/g, function(c) { return String.fromCharCode(c.slice(1,-1)); }); } //convert a number array to a hex string function toHex() { var ret = ""; for ( var i = 0; i < arguments.length; i++ ) ret += (arguments[i] < 16 ? '0′ : "") + arguments[i].toString(16); return ret.toUpperCase(); } //convert a hex string to a number array function toNumbers( str ) { var ret = []; str.replace(/(..)/g, function(str){ ret.push( parseInt( str, 16 ) ); }); return ret; } // get a random number in the range [min,max] function getRandom(min,max) { if(min === null) min = 0; if(max === null) max = 1; return Math.round(Math.random()*max) + min; } /* * Returns a unique hex string with the given number of hex values. * Since hex has a two character representation the actual * string length will be 2*len. */ function uniqueHex(len) { var charArray = ["0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"]; var key = ""; for(var i = 0; i < len*2; i++) key += charArray[getRandom(0,15)]; return key; } /* * START AES SECTION */ // structure of valid key sizes var keySize = { SIZE_128:16, SIZE_192:24, SIZE_256:32 }; // Rijndael S-box var sbox = [ //0 1 2 3 4 5 6 7 8 9 A B C D E F 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, //0 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, //1 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, //2 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, //3 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, //4 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, //5 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, //6 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, //7 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, //8 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, //9 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, //A 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, //B 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, //C 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, //D 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, //E 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ]; //F // Rijndael Inverted S-box var rsbox = [ 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb , 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb , 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e , 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 , 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 , 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 , 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 , 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b , 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 , 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e , 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b , 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 , 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f , 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef , 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 , 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d ]; // retrieves a given S-Box Value function getSBoxValue(num) { return sbox[num]; } // retrieves a given Inverted S-Box Value function getSBoxInvert(num) { return rsbox[num]; } /* Rijndael's key schedule rotate operation * rotate the word eight bits to the left * * rotate(1d2c3a4f) = 2c3a4f1d * * word is an char array of size 4 (32 bit) */ function rotate(word) { var c = word[0]; for (var i = 0; i < 3; i++) word[i] = word[i+1]; word[3] = c; return word; } // Rijndael Rcon var Rcon = [ 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb, 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91, 0x39, 0x72, 0xe4, 0xd3, 0xbd, 0x61, 0xc2, 0x9f, 0x25, 0x4a, 0x94, 0x33, 0x66, 0xcc, 0x83, 0x1d, 0x3a, 0x74, 0xe8, 0xcb ]; //gets a given Rcon value function getRconValue(num) { return Rcon[num]; } // Key Schedule Core function core(word, iteration) { /* rotate the 32-bit word 8 bits to the left */ word = rotate(word); /* apply S-Box substitution on all 4 parts of the 32-bit word */ for (var i = 0; i < 4; ++i) word[i] = getSBoxValue(word[i]); /* XOR the output of the rcon operation with i to the first part (leftmost) only */ word[0] = word[0]^getRconValue(iteration); return word; } /* Rijndael's key expansion * expands an 128,192,256 key into an 176,208,240 bytes key * * expandedKey is a pointer to an char array of large enough size * key is a pointer to a non-expanded key */ function expandKey(key, size, expandedKeySize) { /* current expanded keySize, in bytes */ var currentSize = 0; var rconIteration = 1; var t = []; // temporary 4-byte variable var expandedKey = []; for(var i = 0;i < expandedKeySize;i++) expandedKey[i] = 0; /* set the 16,24,32 bytes of the expanded key to the input key */ for (var j = 0; j < size; j++) expandedKey[j] = key[j]; currentSize += size; while (currentSize < expandedKeySize) { /* assign the previous 4 bytes to the temporary value t */ for (var k = 0; k < 4; k++) t[k] = expandedKey[(currentSize - 4) + k]; /* every 16,24,32 bytes we apply the core schedule to t * and increment rconIteration afterwards */ if(currentSize % size == 0) t = core(t, rconIteration++); /* For 256-bit keys, we add an extra sbox to the calculation */ if(size == keySize.SIZE_256 && ((currentSize % size) == 16)) for(var l = 0; l < 4; l++) t[l] = getSBoxValue(t[l]); /* We XOR t with the four-byte block 16,24,32 bytes before the new expanded key. * This becomes the next four bytes in the expanded key. */ for(var m = 0; m < 4; m++) { expandedKey[currentSize] = expandedKey[currentSize - size] ^ t[m]; currentSize++; } } return expandedKey; } // Adds (XORs) the round key to the state function addRoundKey(state, roundKey) { for (var i = 0; i < 16; i++) state[i] ^= roundKey[i]; return state; } // Creates a round key from the given expanded key and the // position within the expanded key. function createRoundKey(expandedKey,roundKeyPointer) { var roundKey = []; for (var i = 0; i < 4; i++) for (var j = 0; j < 4; j++) roundKey[j*4+i] = expandedKey[roundKeyPointer + i*4 + j]; return roundKey; } // galois multiplication of 8 bit characters a and b function galois_multiplication(a, b) { var p = 0; for(var counter = 0; counter < 8; counter++) { if((b & 1) == 1) p ^= a; if(p > 0×100) p ^= 0×100; var hi_bit_set = (a & 0×80); //keep p 8 bit a <<= 1; if(a > 0×100) a ^= 0×100; //keep a 8 bit if(hi_bit_set == 0×80) a ^= 0×1b; if(a > 0×100) a ^= 0×100; //keep a 8 bit b >>= 1; if(b > 0×100) b ^= 0×100; //keep b 8 bit } return p; } /* substitute all the values from the state with the value in the SBox * using the state value as index for the SBox */ function subBytes(state,isInv) { for (var i = 0; i < 16; i++) state[i] = isInv?getSBoxInvert(state[i]):getSBoxValue(state[i]); return state; } /* iterate over the 4 rows and call shiftRow() with that row */ function shiftRows(state,isInv) { for (var i = 0; i < 4; i++) state = shiftRow(state,i*4, i,isInv); return state; } /* each iteration shifts the row to the left by 1 */ function shiftRow(state,statePointer,nbr,isInv) { for (var i = 0; i < nbr; i++) { if(isInv) { var tmp = state[statePointer + 3]; for (var j = 3; j > 0; j–) state[statePointer + j] = state[statePointer + j-1]; state[statePointer] = tmp; } else { var tmp = state[statePointer]; for (var j = 0; j < 3; j++) state[statePointer + j] = state[statePointer + j+1]; state[statePointer + 3] = tmp; } } return state; } // galois multipication of the 4×4 matrix function mixColumns(state,isInv) { var column = []; /* iterate over the 4 columns */ for (var i = 0; i < 4; i++) { /* construct one column by iterating over the 4 rows */ for (var j = 0; j < 4; j++) column[j] = state[(j*4)+i]; /* apply the mixColumn on one column */ column = mixColumn(column,isInv); /* put the values back into the state */ for (var k = 0; k < 4; k++) state[(k*4)+i] = column[k]; } return state; } // galois multipication of 1 column of the 4×4 matrix function mixColumn(column,isInv) { var mult = []; if(isInv) mult = [14,9,13,11]; else mult = [2,1,1,3]; var cpy = []; for(var i = 0; i < 4; i++) cpy[i] = column[i]; column[0] = galois_multiplication(cpy[0],mult[0]) ^ galois_multiplication(cpy[3],mult[1]) ^ galois_multiplication(cpy[2],mult[2]) ^ galois_multiplication(cpy[1],mult[3]); column[1] = galois_multiplication(cpy[1],mult[0]) ^ galois_multiplication(cpy[0],mult[1]) ^ galois_multiplication(cpy[3],mult[2]) ^ galois_multiplication(cpy[2],mult[3]); column[2] = galois_multiplication(cpy[2],mult[0]) ^ galois_multiplication(cpy[1],mult[1]) ^ galois_multiplication(cpy[0],mult[2]) ^ galois_multiplication(cpy[3],mult[3]); column[3] = galois_multiplication(cpy[3],mult[0]) ^ galois_multiplication(cpy[2],mult[1]) ^ galois_multiplication(cpy[1],mult[2]) ^ galois_multiplication(cpy[0],mult[3]); return column; } // applies the 4 operations of the forward round in sequence function aes_round(state, roundKey) { state = subBytes(state,false); state = shiftRows(state,false); state = mixColumns(state,false); state = addRoundKey(state, roundKey); return state; } // applies the 4 operations of the inverse round in sequence function aes_invRound(state, roundKey) { state = shiftRows(state,true); state = subBytes(state,true); state = addRoundKey(state, roundKey); state = mixColumns(state,true); return state; } /* * Perform the initial operations, the standard round, and the final operations * of the forward aes, creating a round key for each round */ function aes_main(state, expandedKey, nbrRounds) { state = addRoundKey(state, createRoundKey(expandedKey,0)); for (var i = 1; i < nbrRounds; i++) state = aes_round(state, createRoundKey(expandedKey,16*i)); state = subBytes(state,false); state = shiftRows(state,false); state = addRoundKey(state, createRoundKey(expandedKey,16*nbrRounds)); return state; } /* * Perform the initial operations, the standard round, and the final operations * of the inverse aes, creating a round key for each round */ function aes_invMain(state, expandedKey, nbrRounds) { state = addRoundKey(state, createRoundKey(expandedKey,16*nbrRounds)); for (var i = nbrRounds-1; i > 0; i–) state = aes_invRound(state, createRoundKey(expandedKey,16*i)); state = shiftRows(state,true); state = subBytes(state,true); state = addRoundKey(state, createRoundKey(expandedKey,0)); return state; } // encrypts a 128 bit input block against the given key of size specified function aes_encrypt(input, key, size) { var output = []; var nbrRounds; /* the number of rounds */ var block = []; /* the 128 bit block to encode */ switch (size) /* set the number of rounds */ { case keySize.SIZE_128: nbrRounds = 10; break; case keySize.SIZE_192: nbrRounds = 12; break; case keySize.SIZE_256: nbrRounds = 14; break; default: alert('Invalid Key Size Specified:' + size); return null; break; } var expandedKeySize = (16*(nbrRounds+1)); /* the expanded keySize */ /* Set the block values, for the block: * a0,0 a0,1 a0,2 a0,3 * a1,0 a1,1 a1,2 a1,3 * a2,0 a2,1 a2,2 a2,3 * a3,0 a3,1 a3,2 a3,3 * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 … a2,3 a3,3 */ for (var i = 0; i < 4; i++) /* iterate over the columns */ for (var j = 0; j < 4; j++) /* iterate over the rows */ block[(i+(j*4))] = input[(i*4)+j]; /* expand the key into an 176, 208, 240 bytes key */ var expandedKey = expandKey(key, size, expandedKeySize); /* the expanded key */ /* encrypt the block using the expandedKey */ block = aes_main(block, expandedKey, nbrRounds); for (var k = 0; k < 4; k++) /* unmap the block again into the output */ for (var l = 0; l < 4; l++) /* iterate over the rows */ output[(k*4)+l] = block[(k+(l*4))]; return output; } // decrypts a 128 bit input block against the given key of size specified function aes_decrypt(input, key, size) { var output = []; var nbrRounds; /* the number of rounds */ var block = []; /* the 128 bit block to decode */ switch (size) /* set the number of rounds */ { case keySize.SIZE_128: nbrRounds = 10; break; case keySize.SIZE_192: nbrRounds = 12; break; case keySize.SIZE_256: nbrRounds = 14; break; default: alert('Invalid Key Size Specified: ' + size); return null; break; } var expandedKeySize = (16*(nbrRounds+1)); /* the expanded keySize */ /* Set the block values, for the block: * a0,0 a0,1 a0,2 a0,3 * a1,0 a1,1 a1,2 a1,3 * a2,0 a2,1 a2,2 a2,3 * a3,0 a3,1 a3,2 a3,3 * the mapping order is a0,0 a1,0 a2,0 a3,0 a0,1 a1,1 … a2,3 a3,3 */ for (var i = 0; i < 4; i++) /* iterate over the columns */ for (var j = 0; j < 4; j++) /* iterate over the rows */ block[(i+(j*4))] = input[(i*4)+j]; /* expand the key into an 176, 208, 240 bytes key */ var expandedKey = expandKey(key, size, expandedKeySize); /* decrypt the block using the expandedKey */ block = aes_invMain(block, expandedKey, nbrRounds); for (var k = 0; k < 4; k++)/* unmap the block again into the output */ for (var l = 0; l < 4; l++)/* iterate over the rows */ output[(k*4)+l] = block[(k+(l*4))]; return output; } /* * END AES SECTION */ /* * START MODE OF OPERATION SECTION */ //structure of supported modes of operation var modeOfOperation = { OFB:0, CFB:1, CBC:2 }; // converts a 16 character string into a number array; function convertString(string,start,end,mode) { if(end – start > 16) end = start + 16; if (mode == modeOfOperation.CBC) var array = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]; else var array = []; var j = 0; for(var i = start;i < end;i++) { array[j] = string.charCodeAt(i); j++; } return array; } /* * Mode of Operation Encryption * stringIn – Input String * mode – mode of type modeOfOperation * hexKey – a hex key of the bit length size * size – the bit length of the key * hexIV – the 128 bit hex Initilization Vector */ function encrypt(stringIn,mode,hexKey,size,hexIV) { input = encode_utf8(input); var key = toNumbers(hexKey); if(key.length%size) { alert('Key length does not match specified size.') return null; } var IV = toNumbers(hexIV); if(IV.length%16) { alert('IV length must be 128 bits.') return null; } // the AES input/output var plaintext = []; var input = []; var output = []; var ciphertext = []; //the output cipher string var cipherOut = ""; // char firstRound var firstRound = true; if (stringIn !== null) { for (var j = 0;j < Math.ceil(stringIn.length/16); j++) { var start = j*16; var end = j*16+16; if(j*16+16 > stringIn.length) end = stringIn.length; plaintext = convertString(stringIn,start,end,mode); if (mode == modeOfOperation.CFB) { if (firstRound) { output = aes_encrypt(IV, key, size); firstRound = false; } else output = aes_encrypt(input, key, size); for (var i = 0; i < 16; i++) ciphertext[i] = plaintext[i] ^ output[i]; for(var k = 0;k < end-start;k++) cipherOut += String.fromCharCode(ciphertext[k]); input = ciphertext; } else if (mode == modeOfOperation.OFB) { if (firstRound) { output = aes_encrypt(IV, key, size); firstRound = false; } else output = aes_encrypt(input, key, size); for (var i = 0; i < 16; i++) ciphertext[i] = plaintext[i] ^ output[i]; for(var k = 0;k < end-start;k++) cipherOut += String.fromCharCode(ciphertext[k]); input = output; } else if (mode == modeOfOperation.CBC) { for (var i = 0; i < 16; i++) input[i] = plaintext[i] ^ ((firstRound) ? IV[i] : ciphertext[i]); firstRound = false; ciphertext = aes_encrypt(input, key, size); // always 16 bytes because of the padding for CBC for(var k = 0;k < 16;k++) cipherOut += String.fromCharCode(ciphertext[k]); } } } return {mode:mode,originalsize:stringIn.length,cipher:escCtrlChars(cipherOut)}; } /* * Mode of Operation Decryption * cipherIn – Encrypted String * originalsize – The unencrypted string length – required for CBC * mode – mode of type modeOfOperation * hexKey – a hex key of the bit length size * size – the bit length of the key * hexIV – the 128 bit hex Initilization Vector */ function decrypt(cipherIn,originalsize,mode,hexKey,size,hexIV) { cipherIn = unescCtrlChars(cipherIn); var key = toNumbers(hexKey); if(key.length%size) { alert('Key length does not match specified size.') return null; } var IV = toNumbers(hexIV); if(IV.length%16) { alert('IV length must be 128 bits.') return null; } // the AES input/output var ciphertext = []; var input = []; var output = []; var plaintext = []; //the output plain text string var stringOut = ""; // char firstRound var firstRound = true; if (cipherIn !== null) { for (var j = 0;j < Math.ceil(cipherIn.length/16); j++) { var start = j*16; var end = j*16+16; if(j*16+16 > cipherIn.length) end = cipherIn.length; ciphertext = convertString(cipherIn,start,end,mode); if (mode == modeOfOperation.CFB) { if (firstRound) { output = aes_encrypt(IV, key, size); firstRound = false; } else output = aes_encrypt(input, key, size); for (i = 0; i < 16; i++) plaintext[i] = output[i] ^ ciphertext[i]; for(var k = 0;k < end-start;k++) stringOut += String.fromCharCode(plaintext[k]); input = ciphertext; } else if (mode == modeOfOperation.OFB) { if (firstRound) { output = aes_encrypt(IV, key, size); firstRound = false; } else output = aes_encrypt(input, key, size); for (i = 0; i < 16; i++) plaintext[i] = output[i] ^ ciphertext[i]; for(var k = 0;k < end-start;k++) stringOut += String.fromCharCode(plaintext[k]); input = output; } else if(mode == modeOfOperation.CBC) { output = aes_decrypt(ciphertext, key, size); for (i = 0; i < 16; i++) plaintext[i] = ((firstRound) ? IV[i] : input[i]) ^ output[i]; firstRound = false; if (originalsize < end) for(var k = 0;k < originalsize-start;k++) stringOut += String.fromCharCode(plaintext[k]); else for(var k = 0;k < end-start;k++) stringOut += String.fromCharCode(plaintext[k]); input = ciphertext; } } } return decode_utf8(stringOut); } /* * END MODE OF OPERATION SECTION */

ma se c’è la necessità di blindare la nostra applicazione, questa può essere una valida soluzione.