1735 // This function packs an array of bytes into the four row form defined by

  1736 // Rijndael. It assumes the length of the array of bytes is divisible by

  1737 // four. Bytes are filled in according to the Rijndael spec (starting with

  1738 // column 0, row 0 to 3). This function returns a 2d array.

  1739 

  1740 function packBytes(octets) {

  1741   var state = new Array();

  1742   if (!octets || octets.length % 4)

  1743     return;

  1744 

  1745   state[0] = new Array();  state[1] = new Array(); 

  1746   state[2] = new Array();  state[3] = new Array();

  1747   for (var j=0; j<octets.length; j+= 4) {

  1748      state[0][j/4] = octets[j];

  1749      state[1][j/4] = octets[j+1];

  1750      state[2][j/4] = octets[j+2];

  1751      state[3][j/4] = octets[j+3];

  1752   }

  1753   return state;  

  1754 }

  1755 

  1756 // This function unpacks an array of bytes from the four row format preferred

  1757 // by Rijndael into a single 1d array of bytes. It assumes the input "packed"

  1758 // is a packed array. Bytes are filled in according to the Rijndael spec. 

  1759 // This function returns a 1d array of bytes.

  1760 

  1761 function unpackBytes(packed) {

  1762   var result = new Array();

  1763   for (var j=0; j<packed[0].length; j++) {

  1764     result[result.length] = packed[0][j];

  1765     result[result.length] = packed[1][j];

  1766     result[result.length] = packed[2][j];

  1767     result[result.length] = packed[3][j];

  1768   }

  1769   return result;

  1770 }

  1771 

  1772 // This function takes a prospective plaintext (string or array of bytes)

  1773 // and pads it with zero bytes if its length is not a multiple of the block 

  1774 // size. If plaintext is a string, it is converted to an array of bytes

  1775 // in the process. The type checking can be made much nicer using the 

  1776 // instanceof operator, but this operator is not available until IE5.0 so I 

  1777 // chose to use the heuristic below. 

  1778 

  1779 function formatPlaintext(plaintext) {

  1780   var bpb = blockSizeInBits / 8;               // bytes per block

  1781   var i;

  1782 

  1783   // if primitive string or String instance

  1784   if (typeof plaintext == "string" || plaintext.split) {

  1785     // alert('AUUGH you idiot it\'s NOT A STRING ITS A '+typeof(plaintext)+'!!!');

  1786     // return false;

  1787     plaintext = plaintext.split("");

  1788     // Unicode issues here (ignoring high byte)

  1789     for (i=0; i<plaintext.length; i++)

  1790       plaintext[i] = plaintext[i].charCodeAt(0) & 0xFF;

  1791   } 

  1792 

  1793   for (i = bpb - (plaintext.length % bpb); i > 0 && i < bpb; i--) 

  1794     plaintext[plaintext.length] = 0;

  1795   

  1796   return plaintext;

  1797 }

  1798 

  1799 // Returns an array containing "howMany" random bytes. YOU SHOULD CHANGE THIS

  1800 // TO RETURN HIGHER QUALITY RANDOM BYTES IF YOU ARE USING THIS FOR A "REAL"

  1801 // APPLICATION.

  1802 

  1803 function getRandomBytes(howMany) {

  1804   var i;

  1805   var bytes = new Array();

  1806   for (i=0; i<howMany; i++)

  1807     bytes[i] = Math.round(Math.random()*255);

  1808   return bytes;

  1809 }

  1810 

  1811 // rijndaelEncrypt(plaintext, key, mode)

  1812 // Encrypts the plaintext using the given key and in the given mode. 

  1813 // The parameter "plaintext" can either be a string or an array of bytes. 

  1814 // The parameter "key" must be an array of key bytes. If you have a hex 

  1815 // string representing the key, invoke hexToByteArray() on it to convert it 

  1816 // to an array of bytes. The third parameter "mode" is a string indicating

  1817 // the encryption mode to use, either "ECB" or "CBC". If the parameter is

  1818 // omitted, ECB is assumed.

  1819 // 

  1820 // An array of bytes representing the cihpertext is returned. To convert 

  1821 // this array to hex, invoke byteArrayToHex() on it. If you are using this 

  1822 // "for real" it is a good idea to change the function getRandomBytes() to 

  1823 // something that returns truly random bits.

  1824 

  1825 function rijndaelEncrypt(plaintext, key, mode) {

  1826   var expandedKey, i, aBlock;

  1827   var bpb = blockSizeInBits / 8;          // bytes per block

  1828   var ct;                                 // ciphertext

  1829 

  1830   if (typeof plaintext != 'object' || typeof key != 'object')

  1831   {

  1832     alert( 'Invalid params\nplaintext: '+typeof(plaintext)+'\nkey: '+typeof(key) );

  1833     return false;

  1834   }

  1835   if (key.length*8 == keySizeInBits+8)

  1836     key.length = keySizeInBits / 8;

  1837   if (key.length*8 != keySizeInBits)

  1838   {

  1839     alert( 'Key length is bad!\nLength: '+key.length+'\nExpected: '+keySizeInBits / 8 );

  1840     return false;

  1841   }

  1842   if (mode == "CBC")

  1843     ct = getRandomBytes(bpb);             // get IV

  1844   else {

  1845     mode = "ECB";

  1846     ct = new Array();

  1847   }

  1848 

  1849   // convert plaintext to byte array and pad with zeros if necessary. 

  1850   plaintext = formatPlaintext(plaintext);

  1851 

  1852   expandedKey = keyExpansion(key);

  1853   

  1854   for (var block=0; block<plaintext.length / bpb; block++) {

  1855     aBlock = plaintext.slice(block*bpb, (block+1)*bpb);

  1856     if (mode == "CBC")

  1857       for (var i=0; i<bpb; i++) 

  1858         aBlock[i] ^= ct[block*bpb + i];

  1859     ct = ct.concat(encrypt(aBlock, expandedKey));

  1860   }

  1861 

  1862   return ct;

  1863 }

  1864 

  1865 // rijndaelDecrypt(ciphertext, key, mode)

  1866 // Decrypts the using the given key and mode. The parameter "ciphertext" 

  1867 // must be an array of bytes. The parameter "key" must be an array of key 

  1868 // bytes. If you have a hex string representing the ciphertext or key, 

  1869 // invoke hexToByteArray() on it to convert it to an array of bytes. The

  1870 // parameter "mode" is a string, either "CBC" or "ECB".

  1871 // 

  1872 // An array of bytes representing the plaintext is returned. To convert 

  1873 // this array to a hex string, invoke byteArrayToHex() on it. To convert it 

  1874 // to a string of characters, you can use byteArrayToString().

  1875 

  1876 function rijndaelDecrypt(ciphertext, key, mode) {

  1877   var expandedKey;

  1878   var bpb = blockSizeInBits / 8;          // bytes per block

  1879   var pt = new Array();                   // plaintext array

  1880   var aBlock;                             // a decrypted block

  1881   var block;                              // current block number

  1882 

  1883   if (!ciphertext || !key || typeof ciphertext == "string")

  1884     return;

  1885   if (key.length*8 != keySizeInBits)

  1886     return; 

  1887   if (!mode)

  1888     mode = "ECB";                         // assume ECB if mode omitted

  1889 

  1890   expandedKey = keyExpansion(key);

  1891  

  1892   // work backwards to accomodate CBC mode 

  1893   for (block=(ciphertext.length / bpb)-1; block>0; block--) {

  1894     aBlock = 

  1895      decrypt(ciphertext.slice(block*bpb,(block+1)*bpb), expandedKey);

  1896     if (mode == "CBC") 

  1897       for (var i=0; i<bpb; i++) 

  1898         pt[(block-1)*bpb + i] = aBlock[i] ^ ciphertext[(block-1)*bpb + i];

  1899     else 

  1900       pt = aBlock.concat(pt);

  1901   }

  1902 

  1903   // do last block if ECB (skips the IV in CBC)

  1904   if (mode == "ECB")

  1905     pt = decrypt(ciphertext.slice(0, bpb), expandedKey).concat(pt);

  1906 

  1907   return pt;

  1908 }

  1909