1. /* rijndael.js      Rijndael Reference Implementation
2.    Copyright (c) 2001 Fritz Schneider
4. This software is provided as-is, without express or implied warranty.
5. Permission to use, copy, modify, distribute or sell this software, with or
6. without fee, for any purpose and by any individual or organization, is hereby
7. granted, provided that the above copyright notice and this paragraph appear
8. in all copies. Distribution as a part of an application or binary must
9. include the above copyright notice in the documentation and/or other materials
10. provided with the application or distribution.
13.    As the above disclaimer notes, you are free to use this code however you
14.    want. However, I would request that you send me an email
15.    (fritz /at/ cs /dot/ ucsd /dot/ edu) to say hi if you find this code useful
16.    or instructional. Seeing that people are using the code acts as
17.    encouragement for me to continue development. If you *really* want to thank
18.    me you can buy the book I wrote with Thomas Powell, _JavaScript:
19.    _The_Complete_Reference_ :)
21.    This code is an UNOPTIMIZED REFERENCE implementation of Rijndael.
22.    If there is sufficient interest I can write an optimized (word-based,
23.    table-driven) version, although you might want to consider using a
24.    compiled language if speed is critical to your application. As it stands,
25.    one run of the monte carlo test (10,000 encryptions) can take up to
26.    several minutes, depending upon your processor. You shouldn’t expect more
27.    than a few kilobytes per second in throughput.
29.    Also note that there is very little error checking in these functions.
30.    Doing proper error checking is always a good idea, but the ideal
31.    implementation (using the instanceof operator and exceptions) requires
32.    IE5+/NS6+, and I’ve chosen to implement this code so that it is compatible
33.    with IE4/NS4.
35.    And finally, because JavaScript doesn’t have an explicit byte/char data
36.    type (although JavaScript 2.0 most likely will), when I refer to "byte"
37.    in this code I generally mean "32 bit integer with value in the interval
38.    [0,255]" which I treat as a byte.
40.    See http://www-cse.ucsd.edu/~fritz/rijndael.html for more documentation
41.    of the (very simple) API provided by this code.
43.                                                Fritz Schneider
44.                                                fritz at cs.ucsd.edu
46. */
49. // Rijndael parameters —  Valid values are 128, 192, or 256
51. var keySizeInBits = 128;
52. var blockSizeInBits = 128;
54. ///////  You shouldn’t have to modify anything below this line except for
55. ///////  the function getRandomBytes().
56. //
57. // Note: in the following code the two dimensional arrays are indexed as
58. //       you would probably expect, as array[row][column]. The state arrays
59. //       are 2d arrays of the form state[4][Nb].
62. // The number of rounds for the cipher, indexed by [Nk][Nb]
63. var roundsArray = [ ,,,,[,,,,10,, 12,, 14],,
64.                         [,,,,12,, 12,, 14],,
65.                         [,,,,14,, 14,, 14] ];
67. // The number of bytes to shift by in shiftRow, indexed by [Nb][row]
68. var shiftOffsets = [ ,,,,[,1, 2, 3],,[,1, 2, 3],,[,1, 3, 4] ];
70. // The round constants used in subkey expansion
71. var Rcon = [
72. 0x01, 0x02, 0x04, 0x08, 0x10, 0x20,
73. 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8,
74. 0xab, 0x4d, 0x9a, 0x2f, 0x5e, 0xbc,
75. 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4,
76. 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91 ];
78. // Precomputed lookup table for the SBox
79. var SBox = [
80.  99, 124, 119, 123, 242, 107, 111, 197,  48,   1, 103,  43, 254, 215, 171,
81. 118, 202, 130, 201, 125, 250,  89,  71, 240, 173, 212, 162, 175, 156, 164,
82. 114, 192, 183, 253, 147,  38,  54,  63, 247, 204,  52, 165, 229, 241, 113,
83. 216,  49,  21,   4, 199,  35, 195,  24, 150,   5, 154,   7,  18, 128, 226,
84. 235,  39, 178, 117,   9, 131,  44,  26,  27, 110,  90, 160,  82,  59, 214,
85. 179,  41, 227,  47, 132,  83, 209,   0, 237,  32, 252, 177,  91, 106, 203,
86. 190,  57,  74,  76,  88, 207, 208, 239, 170, 251,  67,  77,  51, 133,  69,
87. 249,   2, 127,  80,  60, 159, 168,  81, 163,  64, 143, 146, 157,  56, 245,
88. 188, 182, 218,  33,  16, 255, 243, 210, 205,  12,  19, 236,  95, 151,  68,
89. 23,  196, 167, 126,  61, 100,  93,  25, 115,  96, 129,  79, 220,  34,  42,
90. 144, 136,  70, 238, 184,  20, 222,  94,  11, 219, 224,  50,  58,  10,  73,
91.   6,  36,  92, 194, 211, 172,  98, 145, 149, 228, 121, 231, 200,  55, 109,
92. 141, 213,  78, 169, 108,  86, 244, 234, 101, 122, 174,   8, 186, 120,  37,
93.  46,  28, 166, 180, 198, 232, 221, 116,  31,  75, 189, 139, 138, 112,  62,
94. 181, 102,  72,   3, 246,  14,  97,  53,  87, 185, 134, 193,  29, 158, 225,
95. 248, 152,  17, 105, 217, 142, 148, 155,  30, 135, 233, 206,  85,  40, 223,
96. 140, 161, 137,  13, 191, 230,  66, 104,  65, 153,  45,  15, 176,  84, 187,
97.  22 ];
99. // Precomputed lookup table for the inverse SBox
100. var SBoxInverse = [
101.  82,   9, 106, 213,  48,  54, 165,  56, 191,  64, 163, 158, 129, 243, 215,
102. 251, 124, 227,  57, 130, 155,  47, 255, 135,  52, 142,  67,  68, 196, 222,
103. 233, 203,  84, 123, 148,  50, 166, 194,  35,  61, 238,  76, 149,  11,  66,
104. 250, 195,  78,   8,  46, 161, 102,  40, 217,  36, 178, 118,  91, 162,  73,
105. 109, 139, 209,  37, 114, 248, 246, 100, 134, 104, 152,  22, 212, 164,  92,
106. 204,  93, 101, 182, 146, 108, 112,  72,  80, 253, 237, 185, 218,  94,  21,
107.  70,  87, 167, 141, 157, 132, 144, 216, 171,   0, 140, 188, 211,  10, 247,
108. 228,  88,   5, 184, 179,  69,   6, 208,  44,  30, 143, 202,  63,  15,   2,
109. 193, 175, 189,   3,   1,  19, 138, 107,  58, 145,  17,  65,  79, 103, 220,
110. 234, 151, 242, 207, 206, 240, 180, 230, 115, 150, 172, 116,  34, 231, 173,
111.  53, 133, 226, 249,  55, 232,  28, 117, 223, 110,  71, 241,  26, 113,  29,
112.  41, 197, 137, 111, 183,  98,  14, 170,  24, 190,  27, 252,  86,  62,  75,
113. 198, 210, 121,  32, 154, 219, 192, 254, 120, 205,  90, 244,  31, 221, 168,
114.  51, 136,   7, 199,  49, 177,  18,  16,  89,  39, 128, 236,  95,  96,  81,
115. 127, 169,  25, 181,  74,  13,  45, 229, 122, 159, 147, 201, 156, 239, 160,
116. 224,  59,  77, 174,  42, 245, 176, 200, 235, 187,  60, 131,  83, 153,  97,
117.  23,  43,   4, 126, 186, 119, 214,  38, 225, 105,  20,  99,  85,  33,  12,
118. 125 ];
120. // This method circularly shifts the array left by the number of elements
121. // given in its parameter. It returns the resulting array and is used for
122. // the ShiftRow step. Note that shift() and push() could be used for a more
123. // elegant solution, but they require IE5.5+, so I chose to do it manually.
125. function cyclicShiftLeft(theArray, positions) {
126.   var temp = theArray.slice(0, positions);
127.   theArray = theArray.slice(positions).concat(temp);
128.   return theArray;
129. }
131. // Cipher parameters … do not change these
132. var Nk = keySizeInBits / 32;
133. var Nb = blockSizeInBits / 32;
134. var Nr = roundsArray[Nk][Nb];
136. // Multiplies the element "poly" of GF(2^8) by x. See the Rijndael spec.
138. function xtime(poly) {
139.   poly <<= 1;
140.   return ((poly & 0x100) ? (poly ^ 0x11B) : (poly));
141. }
143. // Multiplies the two elements of GF(2^8) together and returns the result.
144. // See the Rijndael spec, but should be straightforward: for each power of
145. // the indeterminant that has a 1 coefficient in x, add y times that power
146. // to the result. x and y should be bytes representing elements of GF(2^8)
148. function mult_GF256(x, y) {
149.   var bit, result = 0;
151.   for (bit = 1; bit < 256; bit *= 2, y = xtime(y)) {
152.     if (x & bit)
153.       result ^= y;
154.   }
155.   return result;
156. }
158. // Performs the substitution step of the cipher. State is the 2d array of
159. // state information (see spec) and direction is string indicating whether
160. // we are performing the forward substitution ("encrypt") or inverse
161. // substitution (anything else)
163. function byteSub(state, direction) {
164.   var S;
165.   if (direction == "encrypt")           // Point S to the SBox we’re using
166.     S = SBox;
167.   else
168.     S = SBoxInverse;
169.   for (var i = 0; i < 4; i++)           // Substitute for every byte in state
170.     for (var j = 0; j < Nb; j++)
171.        state[i][j] = S[state[i][j]];
172. }
174. // Performs the row shifting step of the cipher.
176. function shiftRow(state, direction) {
177.   for (var i=1; i<4; i++)               // Row 0 never shifts
178.     if (direction == "encrypt")
179.        state[i] = cyclicShiftLeft(state[i], shiftOffsets[Nb][i]);
180.     else
181.        state[i] = cyclicShiftLeft(state[i], Nb – shiftOffsets[Nb][i]);
183. }
185. // Performs the column mixing step of the cipher. Most of these steps can
186. // be combined into table lookups on 32bit values (at least for encryption)
187. // to greatly increase the speed.
189. function mixColumn(state, direction) {
190.   var b = [];                            // Result of matrix multiplications
191.   for (var j = 0; j < Nb; j++) {         // Go through each column…
192.     for (var i = 0; i < 4; i++) {        // and for each row in the column…
193.       if (direction == "encrypt")
194.         b[i] = mult_GF256(state[i][j], 2) ^          // perform mixing
195.                mult_GF256(state[(i+1)%4][j], 3) ^
196.                state[(i+2)%4][j] ^
197.                state[(i+3)%4][j];
198.       else
199.         b[i] = mult_GF256(state[i][j], 0xE) ^
200.                mult_GF256(state[(i+1)%4][j], 0xB) ^
201.                mult_GF256(state[(i+2)%4][j], 0xD) ^
202.                mult_GF256(state[(i+3)%4][j], 9);
203.     }
204.     for (var i = 0; i < 4; i++)          // Place result back into column
205.       state[i][j] = b[i];
206.   }
207. }
209. // Adds the current round key to the state information. Straightforward.
211. function addRoundKey(state, roundKey) {
212.   for (var j = 0; j < Nb; j++) {                 // Step through columns…
213.     state[0][j] ^= (roundKey[j] & 0xFF);         // and XOR
214.     state[1][j] ^= ((roundKey[j]>>8) & 0xFF);
215.     state[2][j] ^= ((roundKey[j]>>16) & 0xFF);
216.     state[3][j] ^= ((roundKey[j]>>24) & 0xFF);
217.   }
218. }
220. // This function creates the expanded key from the input (128/192/256-bit)
221. // key. The parameter key is an array of bytes holding the value of the key.
222. // The returned value is an array whose elements are the 32-bit words that
223. // make up the expanded key.
225. function keyExpansion(key) {
226.   var expandedKey = new Array();
227.   var temp;
229.   // in case the key size or parameters were changed…
230.   Nk = keySizeInBits / 32;
231.   Nb = blockSizeInBits / 32;
232.   Nr = roundsArray[Nk][Nb];
234.   for (var j=0; j < Nk; j++)     // Fill in input key first
235.     expandedKey[j] =
236.       (key[4*j]) | (key[4*j+1]<<8) | (key[4*j+2]<<16) | (key[4*j+3]<<24);
238.   // Now walk down the rest of the array filling in expanded key bytes as
239.   // per Rijndael’s spec
240.   for (j = Nk; j < Nb * (Nr + 1); j++) {    // For each word of expanded key
241.     temp = expandedKey[j – 1];
242.     if (j % Nk == 0)
243.       temp = ( (SBox[(temp>>8) & 0xFF]) |
244.                (SBox[(temp>>16) & 0xFF]<<8) |
245.                (SBox[(temp>>24) & 0xFF]<<16) |
246.                (SBox[temp & 0xFF]<<24) ) ^ Rcon[Math.floor(j / Nk) – 1];
247.     else if (Nk > 6 && j % Nk == 4)
248.       temp = (SBox[(temp>>24) & 0xFF]<<24) |
249.              (SBox[(temp>>16) & 0xFF]<<16) |
250.              (SBox[(temp>>8) & 0xFF]<<8) |
251.              (SBox[temp & 0xFF]);
252.     expandedKey[j] = expandedKey[j-Nk] ^ temp;
253.   }
254.   return expandedKey;
255. }
257. // Rijndael’s round functions…
259. function Round(state, roundKey) {
260.   byteSub(state, "encrypt");
261.   shiftRow(state, "encrypt");
262.   mixColumn(state, "encrypt");
263.   addRoundKey(state, roundKey);
264. }
266. function InverseRound(state, roundKey) {
267.   addRoundKey(state, roundKey);
268.   mixColumn(state, "decrypt");
269.   shiftRow(state, "decrypt");
270.   byteSub(state, "decrypt");
271. }
273. function FinalRound(state, roundKey) {
274.   byteSub(state, "encrypt");
275.   shiftRow(state, "encrypt");
276.   addRoundKey(state, roundKey);
277. }
279. function InverseFinalRound(state, roundKey){
280.   addRoundKey(state, roundKey);
281.   shiftRow(state, "decrypt");
282.   byteSub(state, "decrypt");
283. }
285. // encrypt is the basic encryption function. It takes parameters
286. // block, an array of bytes representing a plaintext block, and expandedKey,
287. // an array of words representing the expanded key previously returned by
288. // keyExpansion(). The ciphertext block is returned as an array of bytes.
290. function encrypt(block, expandedKey) {
291.   var i;
292.   if (!block || block.length*8 != blockSizeInBits)
293.      return;
294.   if (!expandedKey)
295.      return;
297.   block = packBytes(block);
298.   addRoundKey(block, expandedKey);
299.   for (i=1; i<Nr; i++)
300.     Round(block, expandedKey.slice(Nb*i, Nb*(i+1)));
301.   FinalRound(block, expandedKey.slice(Nb*Nr));
302.   return unpackBytes(block);
303. }
305. // decrypt is the basic decryption function. It takes parameters
306. // block, an array of bytes representing a ciphertext block, and expandedKey,
307. // an array of words representing the expanded key previously returned by
308. // keyExpansion(). The decrypted block is returned as an array of bytes.
310. function decrypt(block, expandedKey) {
311.   var i;
312.   if (!block || block.length*8 != blockSizeInBits)
313.      return;
314.   if (!expandedKey)
315.      return;
317.   block = packBytes(block);
318.   InverseFinalRound(block, expandedKey.slice(Nb*Nr));
319.   for (i = Nr – 1; i>0; i--)
320.     InverseRound(block, expandedKey.slice(Nb*i, Nb*(i+1)));
321.   addRoundKey(block, expandedKey);
322.   return unpackBytes(block);
323. }
325. // This method takes a byte array (byteArray) and converts it to a string by
326. // applying String.fromCharCode() to each value and concatenating the result.
327. // The resulting string is returned. Note that this function SKIPS zero bytes
328. // under the assumption that they are padding added in formatPlaintext().
329. // Obviously, do not invoke this method on raw data that can contain zero
330. // bytes. It is really only appropriate for printable ASCII/Latin-1
331. // values. Roll your own function for more robust functionality :)
333. function byteArrayToString(byteArray) {
334.   var result = "";
335.   for(var i=0; i<byteArray.length; i++)
336.     if (byteArray[i] != 0)
337.       result += String.fromCharCode(byteArray[i]);
338.   return result;
339. }
341. // This function takes an array of bytes (byteArray) and converts them
342. // to a hexadecimal string. Array element 0 is found at the beginning of
343. // the resulting string, high nibble first. Consecutive elements follow
344. // similarly, for example [16, 255] --> "10ff". The function returns a
345. // string.
347. function byteArrayToHex(byteArray) {
348.   var result = "";
349.   if (!byteArray)
350.     return;
351.   for (var i=0; i<byteArray.length; i++)
352.     result += ((byteArray[i]<16) ? "0" : "") + byteArray[i].toString(16);
354.   return result;
355. }
357. // This function converts a string containing hexadecimal digits to an
358. // array of bytes. The resulting byte array is filled in the order the
359. // values occur in the string, for example "10FF" --> [16, 255]. This
360. // function returns an array.
362. function hexToByteArray(hexString) {
363.   var byteArray = [];
364.   if (hexString.length % 2)             // must have even length
365.     return;
366.   if (hexString.indexOf("0x") == 0 || hexString.indexOf("0X") == 0)
367.     hexString = hexString.substring(2);
368.   for (var i = 0; i<hexString.length; i += 2)
369.     byteArray[Math.floor(i/2)] = parseInt(hexString.slice(i, i+2), 16);
370.   return byteArray;
371. }
373. // This function packs an array of bytes into the four row form defined by
374. // Rijndael. It assumes the length of the array of bytes is divisible by
375. // four. Bytes are filled in according to the Rijndael spec (starting with
376. // column 0, row 0 to 3). This function returns a 2d array.
378. function packBytes(octets) {
379.   var state = new Array();
380.   if (!octets || octets.length % 4)
381.     return;
383.   state[0] = new Array();  state[1] = new Array();
384.   state[2] = new Array();  state[3] = new Array();
385.   for (var j=0; j<octets.length; j+= 4) {
386.      state[0][j/4] = octets[j];
387.      state[1][j/4] = octets[j+1];
388.      state[2][j/4] = octets[j+2];
389.      state[3][j/4] = octets[j+3];
390.   }
391.   return state;
392. }
394. // This function unpacks an array of bytes from the four row format preferred
395. // by Rijndael into a single 1d array of bytes. It assumes the input "packed"
396. // is a packed array. Bytes are filled in according to the Rijndael spec.
397. // This function returns a 1d array of bytes.
399. function unpackBytes(packed) {
400.   var result = new Array();
401.   for (var j=0; j<packed[0].length; j++) {
402.     result[result.length] = packed[0][j];
403.     result[result.length] = packed[1][j];
404.     result[result.length] = packed[2][j];
405.     result[result.length] = packed[3][j];
406.   }
407.   return result;
408. }
410. // This function takes a prospective plaintext (string or array of bytes)
411. // and pads it with zero bytes if its length is not a multiple of the block
412. // size. If plaintext is a string, it is converted to an array of bytes
413. // in the process. The type checking can be made much nicer using the
414. // instanceof operator, but this operator is not available until IE5.0 so I
415. // chose to use the heuristic below.
417. function formatPlaintext(plaintext) {
418.   var bpb = blockSizeInBits / 8;               // bytes per block
419.   var i;
421.   // if primitive string or String instance
422.   if (typeof plaintext == "string" || plaintext.indexOf) {
423.     plaintext = plaintext.split("");
424.     // Unicode issues here (ignoring high byte)
425.     for (i=0; i<plaintext.length; i++)
426.       plaintext[i] = plaintext[i].charCodeAt(0) & 0xFF;
427.   }
429.   for (i = bpb – (plaintext.length % bpb); i > 0 && i < bpb; i--)
430.     plaintext[plaintext.length] = 0;
432.   return plaintext;
433. }
435. // Returns an array containing "howMany" random bytes. YOU SHOULD CHANGE THIS
436. // TO RETURN HIGHER QUALITY RANDOM BYTES IF YOU ARE USING THIS FOR A "REAL"
437. // APPLICATION.
439. function getRandomBytes(howMany) {
440.   var i;
441.   var bytes = new Array();
442.   for (i=0; i<howMany; i++)
443.     bytes[i] = Math.round(Math.random()*255);
444.   return bytes;
445. }
447. // rijndaelEncrypt(plaintext, key, mode)
448. // Encrypts the plaintext using the given key and in the given mode.
449. // The parameter "plaintext" can either be a string or an array of bytes.
450. // The parameter "key" must be an array of key bytes. If you have a hex
451. // string representing the key, invoke hexToByteArray() on it to convert it
452. // to an array of bytes. The third parameter "mode" is a string indicating
453. // the encryption mode to use, either "ECB" or "CBC". If the parameter is
454. // omitted, ECB is assumed.
455. //
456. // An array of bytes representing the cihpertext is returned. To convert
457. // this array to hex, invoke byteArrayToHex() on it. If you are using this
458. // "for real" it is a good idea to change the function getRandomBytes() to
459. // something that returns truly random bits.
461. function rijndaelEncrypt(plaintext, key, mode) {
462.   var expandedKey, i, aBlock;
463.   var bpb = blockSizeInBits / 8;          // bytes per block
464.   var ct;                                 // ciphertext
466.   if (!plaintext || !key)
467.     return;
468.   if (key.length*8 != keySizeInBits)
469.     return;
470.   if (mode == "CBC")
471.     ct = getRandomBytes(bpb);             // get IV
472.   else {
473.     mode = "ECB";
474.     ct = new Array();
475.   }
477.   // convert plaintext to byte array and pad with zeros if necessary.
478.   plaintext = formatPlaintext(plaintext);
480.   expandedKey = keyExpansion(key);
482.   for (var block=0; block<plaintext.length / bpb; block++) {
483.     aBlock = plaintext.slice(block*bpb, (block+1)*bpb);
484.     if (mode == "CBC")
485.       for (var i=0; i<bpb; i++)
486.         aBlock[i] ^= ct[block*bpb + i];
487.     ct = ct.concat(encrypt(aBlock, expandedKey));
488.   }
490.   return ct;
491. }
493. // rijndaelDecrypt(ciphertext, key, mode)
494. // Decrypts the using the given key and mode. The parameter "ciphertext"
495. // must be an array of bytes. The parameter "key" must be an array of key
496. // bytes. If you have a hex string representing the ciphertext or key,
497. // invoke hexToByteArray() on it to convert it to an array of bytes. The
498. // parameter "mode" is a string, either "CBC" or "ECB".
499. //
500. // An array of bytes representing the plaintext is returned. To convert
501. // this array to a hex string, invoke byteArrayToHex() on it. To convert it
502. // to a string of characters, you can use byteArrayToString().
504. function rijndaelDecrypt(ciphertext, key, mode) {
505.   var expandedKey;
506.   var bpb = blockSizeInBits / 8;          // bytes per block
507.   var pt = new Array();                   // plaintext array
508.   var aBlock;                             // a decrypted block
509.   var block;                              // current block number
511.   if (!ciphertext || !key || typeof ciphertext == "string")
512.     return;
513.   if (key.length*8 != keySizeInBits)
514.     return;
515.   if (!mode)
516.     mode = "ECB";                         // assume ECB if mode omitted
518.   expandedKey = keyExpansion(key);
520.   // work backwards to accomodate CBC mode
521.   for (block=(ciphertext.length / bpb)-1; block>0; block--) {
522.     aBlock =
523.      decrypt(ciphertext.slice(block*bpb,(block+1)*bpb), expandedKey);
524.     if (mode == "CBC")
525.       for (var i=0; i<bpb; i++)
526.         pt[(block-1)*bpb + i] = aBlock[i] ^ ciphertext[(block-1)*bpb + i];
527.     else
528.       pt = aBlock.concat(pt);
529.   }
531.   // do last block if ECB (skips the IV in CBC)
532.   if (mode == "ECB")
533.     pt = decrypt(ciphertext.slice(0, bpb), expandedKey).concat(pt);
535.   return pt;
536. }

from:http://www.coolcode.org/?action=show&id=94