gadget.xml

<?xml version="1.0" encoding="UTF-8"?>
<Module>
	<ModulePrefs title="Encryptarea Gadget" description="" author="Jos Shepherd" author_affiliation="" author_email="" screenshot="" thumbnail="">
		<Require feature="idi"/>
		<Require feature="locked-domain"/>
	</ModulePrefs>
	<UserPref name="_table_query_url" display_name="Data source url" required="true"/>
	<UserPref name="_table_query_refresh_interval" display_name="Data refresh interval (minutes)" default_value="300" datatype="enum" required="false">
		<EnumValue value="0" display_value="Do not refresh"/>
		<EnumValue value="60" display_value="1"/>
		<EnumValue value="300" display_value="5"/>
		<EnumValue value="1800" display_value="30"/>
	</UserPref>
	<UserPref name="hash" display_name="Password Hash" datatype="string" default_value=""/>
	<Content type="html"><![CDATA[
	    <style>
	    body,td {font-family: arial; font-size: 10px; }
		td {border: 1px solid #888;}
		th {border: 1px solid #444;}
		
	    </style>
	<!-- Load the Google common loader, that is later used to load the Visualization API. -->
	<script src="http://www.google.com/jsapi" type="text/javascript"></script>
	
	
	<div>Master password:<input type="password" id="masterpassword"/></div>

	<div><input type="text" id="plaintext"/><button onclick="encode()">encode</button></div>
	
	<div id="tablediv" style="overflow: auto;"><img src="http://www.google.com/ig/images/spinner.gif" /><span id="loadingmessage">starting up...</span></div>

	<script>
		
		/**
		*
		*  MD5 (Message-Digest Algorithm)
		*  http://www.webtoolkit.info/
		*
		**/

		var MD5 = function (string) {

			function RotateLeft(lValue, iShiftBits) {
				return (lValue<<iShiftBits) | (lValue>>>(32-iShiftBits));
			}

			function AddUnsigned(lX,lY) {
				var lX4,lY4,lX8,lY8,lResult;
				lX8 = (lX & 0x80000000);
				lY8 = (lY & 0x80000000);
				lX4 = (lX & 0x40000000);
				lY4 = (lY & 0x40000000);
				lResult = (lX & 0x3FFFFFFF)+(lY & 0x3FFFFFFF);
				if (lX4 & lY4) {
					return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
				}
				if (lX4 | lY4) {
					if (lResult & 0x40000000) {
						return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
					} else {
						return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
					}
				} else {
					return (lResult ^ lX8 ^ lY8);
				}
		 	}

		 	function F(x,y,z) { return (x & y) | ((~x) & z); }
		 	function G(x,y,z) { return (x & z) | (y & (~z)); }
		 	function H(x,y,z) { return (x ^ y ^ z); }
			function I(x,y,z) { return (y ^ (x | (~z))); }

			function FF(a,b,c,d,x,s,ac) {
				a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
				return AddUnsigned(RotateLeft(a, s), b);
			};

			function GG(a,b,c,d,x,s,ac) {
				a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
				return AddUnsigned(RotateLeft(a, s), b);
			};

			function HH(a,b,c,d,x,s,ac) {
				a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
				return AddUnsigned(RotateLeft(a, s), b);
			};

			function II(a,b,c,d,x,s,ac) {
				a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
				return AddUnsigned(RotateLeft(a, s), b);
			};

			function ConvertToWordArray(string) {
				var lWordCount;
				var lMessageLength = string.length;
				var lNumberOfWords_temp1=lMessageLength + 8;
				var lNumberOfWords_temp2=(lNumberOfWords_temp1-(lNumberOfWords_temp1 % 64))/64;
				var lNumberOfWords = (lNumberOfWords_temp2+1)*16;
				var lWordArray=Array(lNumberOfWords-1);
				var lBytePosition = 0;
				var lByteCount = 0;
				while ( lByteCount < lMessageLength ) {
					lWordCount = (lByteCount-(lByteCount % 4))/4;
					lBytePosition = (lByteCount % 4)*8;
					lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount)<<lBytePosition));
					lByteCount++;
				}
				lWordCount = (lByteCount-(lByteCount % 4))/4;
				lBytePosition = (lByteCount % 4)*8;
				lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80<<lBytePosition);
				lWordArray[lNumberOfWords-2] = lMessageLength<<3;
				lWordArray[lNumberOfWords-1] = lMessageLength>>>29;
				return lWordArray;
			};

			function WordToHex(lValue) {
				var WordToHexValue="",WordToHexValue_temp="",lByte,lCount;
				for (lCount = 0;lCount<=3;lCount++) {
					lByte = (lValue>>>(lCount*8)) & 255;
					WordToHexValue_temp = "0" + lByte.toString(16);
					WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length-2,2);
				}
				return WordToHexValue;
			};

			function Utf8Encode(string) {
				string = string.replace(/\r\n/g,"\n");
				var utftext = "";

				for (var n = 0; n < string.length; n++) {

					var c = string.charCodeAt(n);

					if (c < 128) {
						utftext += String.fromCharCode(c);
					}
					else if((c > 127) && (c < 2048)) {
						utftext += String.fromCharCode((c >> 6) | 192);
						utftext += String.fromCharCode((c & 63) | 128);
					}
					else {
						utftext += String.fromCharCode((c >> 12) | 224);
						utftext += String.fromCharCode(((c >> 6) & 63) | 128);
						utftext += String.fromCharCode((c & 63) | 128);
					}

				}

				return utftext;
			};

			var x=Array();
			var k,AA,BB,CC,DD,a,b,c,d;
			var S11=7, S12=12, S13=17, S14=22;
			var S21=5, S22=9 , S23=14, S24=20;
			var S31=4, S32=11, S33=16, S34=23;
			var S41=6, S42=10, S43=15, S44=21;

			string = Utf8Encode(string);

			x = ConvertToWordArray(string);

			a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;

			for (k=0;k<x.length;k+=16) {
				AA=a; BB=b; CC=c; DD=d;
				a=FF(a,b,c,d,x[k+0], S11,0xD76AA478);
				d=FF(d,a,b,c,x[k+1], S12,0xE8C7B756);
				c=FF(c,d,a,b,x[k+2], S13,0x242070DB);
				b=FF(b,c,d,a,x[k+3], S14,0xC1BDCEEE);
				a=FF(a,b,c,d,x[k+4], S11,0xF57C0FAF);
				d=FF(d,a,b,c,x[k+5], S12,0x4787C62A);
				c=FF(c,d,a,b,x[k+6], S13,0xA8304613);
				b=FF(b,c,d,a,x[k+7], S14,0xFD469501);
				a=FF(a,b,c,d,x[k+8], S11,0x698098D8);
				d=FF(d,a,b,c,x[k+9], S12,0x8B44F7AF);
				c=FF(c,d,a,b,x[k+10],S13,0xFFFF5BB1);
				b=FF(b,c,d,a,x[k+11],S14,0x895CD7BE);
				a=FF(a,b,c,d,x[k+12],S11,0x6B901122);
				d=FF(d,a,b,c,x[k+13],S12,0xFD987193);
				c=FF(c,d,a,b,x[k+14],S13,0xA679438E);
				b=FF(b,c,d,a,x[k+15],S14,0x49B40821);
				a=GG(a,b,c,d,x[k+1], S21,0xF61E2562);
				d=GG(d,a,b,c,x[k+6], S22,0xC040B340);
				c=GG(c,d,a,b,x[k+11],S23,0x265E5A51);
				b=GG(b,c,d,a,x[k+0], S24,0xE9B6C7AA);
				a=GG(a,b,c,d,x[k+5], S21,0xD62F105D);
				d=GG(d,a,b,c,x[k+10],S22,0x2441453);
				c=GG(c,d,a,b,x[k+15],S23,0xD8A1E681);
				b=GG(b,c,d,a,x[k+4], S24,0xE7D3FBC8);
				a=GG(a,b,c,d,x[k+9], S21,0x21E1CDE6);
				d=GG(d,a,b,c,x[k+14],S22,0xC33707D6);
				c=GG(c,d,a,b,x[k+3], S23,0xF4D50D87);
				b=GG(b,c,d,a,x[k+8], S24,0x455A14ED);
				a=GG(a,b,c,d,x[k+13],S21,0xA9E3E905);
				d=GG(d,a,b,c,x[k+2], S22,0xFCEFA3F8);
				c=GG(c,d,a,b,x[k+7], S23,0x676F02D9);
				b=GG(b,c,d,a,x[k+12],S24,0x8D2A4C8A);
				a=HH(a,b,c,d,x[k+5], S31,0xFFFA3942);
				d=HH(d,a,b,c,x[k+8], S32,0x8771F681);
				c=HH(c,d,a,b,x[k+11],S33,0x6D9D6122);
				b=HH(b,c,d,a,x[k+14],S34,0xFDE5380C);
				a=HH(a,b,c,d,x[k+1], S31,0xA4BEEA44);
				d=HH(d,a,b,c,x[k+4], S32,0x4BDECFA9);
				c=HH(c,d,a,b,x[k+7], S33,0xF6BB4B60);
				b=HH(b,c,d,a,x[k+10],S34,0xBEBFBC70);
				a=HH(a,b,c,d,x[k+13],S31,0x289B7EC6);
				d=HH(d,a,b,c,x[k+0], S32,0xEAA127FA);
				c=HH(c,d,a,b,x[k+3], S33,0xD4EF3085);
				b=HH(b,c,d,a,x[k+6], S34,0x4881D05);
				a=HH(a,b,c,d,x[k+9], S31,0xD9D4D039);
				d=HH(d,a,b,c,x[k+12],S32,0xE6DB99E5);
				c=HH(c,d,a,b,x[k+15],S33,0x1FA27CF8);
				b=HH(b,c,d,a,x[k+2], S34,0xC4AC5665);
				a=II(a,b,c,d,x[k+0], S41,0xF4292244);
				d=II(d,a,b,c,x[k+7], S42,0x432AFF97);
				c=II(c,d,a,b,x[k+14],S43,0xAB9423A7);
				b=II(b,c,d,a,x[k+5], S44,0xFC93A039);
				a=II(a,b,c,d,x[k+12],S41,0x655B59C3);
				d=II(d,a,b,c,x[k+3], S42,0x8F0CCC92);
				c=II(c,d,a,b,x[k+10],S43,0xFFEFF47D);
				b=II(b,c,d,a,x[k+1], S44,0x85845DD1);
				a=II(a,b,c,d,x[k+8], S41,0x6FA87E4F);
				d=II(d,a,b,c,x[k+15],S42,0xFE2CE6E0);
				c=II(c,d,a,b,x[k+6], S43,0xA3014314);
				b=II(b,c,d,a,x[k+13],S44,0x4E0811A1);
				a=II(a,b,c,d,x[k+4], S41,0xF7537E82);
				d=II(d,a,b,c,x[k+11],S42,0xBD3AF235);
				c=II(c,d,a,b,x[k+2], S43,0x2AD7D2BB);
				b=II(b,c,d,a,x[k+9], S44,0xEB86D391);
				a=AddUnsigned(a,AA);
				b=AddUnsigned(b,BB);
				c=AddUnsigned(c,CC);
				d=AddUnsigned(d,DD);
			}

			var temp = WordToHex(a)+WordToHex(b)+WordToHex(c)+WordToHex(d);

			return temp.toLowerCase();
		}


		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
		/*  AES implementation in JavaScript (c) Chris Veness 2005-2009                                   */
		/*   - see http://csrc.nist.gov/publications/PubsFIPS.html#197                                    */
		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

		var Aes = {};  // Aes namespace

		/**
		 * AES Cipher function: encrypt 'input' state with Rijndael algorithm
		 *   applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage
		 *
		 * @param {Number[]} input 16-byte (128-bit) input state array
		 * @param {Number[][]} w   Key schedule as 2D byte-array (Nr+1 x Nb bytes)
		 * @returns {Number[]}     Encrypted output state array
		 */
		Aes.Cipher = function(input, w) {    // main Cipher function [§5.1]
		  var Nb = 4;               // block size (in words): no of columns in state (fixed at 4 for AES)
		  var Nr = w.length/Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys

		  var state = [[],[],[],[]];  // initialise 4xNb byte-array 'state' with input [§3.4]
		  for (var i=0; i<4*Nb; i++) state[i%4][Math.floor(i/4)] = input[i];

		  state = Aes.AddRoundKey(state, w, 0, Nb);

		  for (var round=1; round<Nr; round++) {
		    state = Aes.SubBytes(state, Nb);
		    state = Aes.ShiftRows(state, Nb);
		    state = Aes.MixColumns(state, Nb);
		    state = Aes.AddRoundKey(state, w, round, Nb);
		  }

		  state = Aes.SubBytes(state, Nb);
		  state = Aes.ShiftRows(state, Nb);
		  state = Aes.AddRoundKey(state, w, Nr, Nb);

		  var output = new Array(4*Nb);  // convert state to 1-d array before returning [§3.4]
		  for (var i=0; i<4*Nb; i++) output[i] = state[i%4][Math.floor(i/4)];
		  return output;
		}

		/**
		 * Perform Key Expansion to generate a Key Schedule
		 *
		 * @param {Number[]} key Key as 16/24/32-byte array
		 * @returns {Number[][]} Expanded key schedule as 2D byte-array (Nr+1 x Nb bytes)
		 */
		Aes.KeyExpansion = function(key) {  // generate Key Schedule (byte-array Nr+1 x Nb) from Key [§5.2]
		  var Nb = 4;            // block size (in words): no of columns in state (fixed at 4 for AES)
		  var Nk = key.length/4  // key length (in words): 4/6/8 for 128/192/256-bit keys
		  var Nr = Nk + 6;       // no of rounds: 10/12/14 for 128/192/256-bit keys

		  var w = new Array(Nb*(Nr+1));
		  var temp = new Array(4);

		  for (var i=0; i<Nk; i++) {
		    var r = [key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]];
		    w[i] = r;
		  }

		  for (var i=Nk; i<(Nb*(Nr+1)); i++) {
		    w[i] = new Array(4);
		    for (var t=0; t<4; t++) temp[t] = w[i-1][t];
		    if (i % Nk == 0) {
		      temp = Aes.SubWord(Aes.RotWord(temp));
		      for (var t=0; t<4; t++) temp[t] ^= Aes.Rcon[i/Nk][t];
		    } else if (Nk > 6 && i%Nk == 4) {
		      temp = Aes.SubWord(temp);
		    }
		    for (var t=0; t<4; t++) w[i][t] = w[i-Nk][t] ^ temp[t];
		  }

		  return w;
		}

		/*
		 * ---- remaining routines are private, not called externally ----
		 */

		Aes.SubBytes = function(s, Nb) {    // apply SBox to state S [§5.1.1]
		  for (var r=0; r<4; r++) {
		    for (var c=0; c<Nb; c++) s[r][c] = Aes.Sbox[s[r][c]];
		  }
		  return s;
		}

		Aes.ShiftRows = function(s, Nb) {    // shift row r of state S left by r bytes [§5.1.2]
		  var t = new Array(4);
		  for (var r=1; r<4; r++) {
		    for (var c=0; c<4; c++) t[c] = s[r][(c+r)%Nb];  // shift into temp copy
		    for (var c=0; c<4; c++) s[r][c] = t[c];         // and copy back
		  }          // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
		  return s;  // see asmaes.sourceforge.net/rijndael/rijndaelImplementation.pdf
		}

		Aes.MixColumns = function(s, Nb) {   // combine bytes of each col of state S [§5.1.3]
		  for (var c=0; c<4; c++) {
		    var a = new Array(4);  // 'a' is a copy of the current column from 's'
		    var b = new Array(4);  // 'b' is a•{02} in GF(2^8)
		    for (var i=0; i<4; i++) {
		      a[i] = s[i][c];
		      b[i] = s[i][c]&0x80 ? s[i][c]<<1 ^ 0x011b : s[i][c]<<1;
		    }
		    // a[n] ^ b[n] is a•{03} in GF(2^8)
		    s[0][c] = b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]; // 2*a0 + 3*a1 + a2 + a3
		    s[1][c] = a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]; // a0 * 2*a1 + 3*a2 + a3
		    s[2][c] = a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]; // a0 + a1 + 2*a2 + 3*a3
		    s[3][c] = a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]; // 3*a0 + a1 + a2 + 2*a3
		  }
		  return s;
		}

		Aes.AddRoundKey = function(state, w, rnd, Nb) {  // xor Round Key into state S [§5.1.4]
		  for (var r=0; r<4; r++) {
		    for (var c=0; c<Nb; c++) state[r][c] ^= w[rnd*4+c][r];
		  }
		  return state;
		}

		Aes.SubWord = function(w) {    // apply SBox to 4-byte word w
		  for (var i=0; i<4; i++) w[i] = Aes.Sbox[w[i]];
		  return w;
		}

		Aes.RotWord = function(w) {    // rotate 4-byte word w left by one byte
		  var tmp = w[0];
		  for (var i=0; i<3; i++) w[i] = w[i+1];
		  w[3] = tmp;
		  return w;
		}

		// Sbox is pre-computed multiplicative inverse in GF(2^8) used in SubBytes and KeyExpansion [§5.1.1]
		Aes.Sbox =  [0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
		             0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
		             0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
		             0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
		             0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
		             0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
		             0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
		             0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
		             0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
		             0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
		             0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
		             0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
		             0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
		             0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
		             0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
		             0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16];

		// Rcon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
		Aes.Rcon = [ [0x00, 0x00, 0x00, 0x00],
		             [0x01, 0x00, 0x00, 0x00],
		             [0x02, 0x00, 0x00, 0x00],
		             [0x04, 0x00, 0x00, 0x00],
		             [0x08, 0x00, 0x00, 0x00],
		             [0x10, 0x00, 0x00, 0x00],
		             [0x20, 0x00, 0x00, 0x00],
		             [0x40, 0x00, 0x00, 0x00],
		             [0x80, 0x00, 0x00, 0x00],
		             [0x1b, 0x00, 0x00, 0x00],
		             [0x36, 0x00, 0x00, 0x00] ]; 


		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
		/*  AES Counter-mode implementation in JavaScript (c) Chris Veness 2005-2009                      */
		/*   - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf                       */
		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

		var AesCtr = {};  // AesCtr namespace

		/** 
		 * Encrypt a text using AES encryption in Counter mode of operation
		 *
		 * Unicode multi-byte character safe
		 *
		 * @param {String} plaintext Source text to be encrypted
		 * @param {String} password  The password to use to generate a key
		 * @param {Number} nBits     Number of bits to be used in the key (128, 192, or 256)
		 * @returns {string}         Encrypted text
		 */
		AesCtr.encrypt = function(plaintext, password, nBits) {
		  var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
		  if (!(nBits==128 || nBits==192 || nBits==256)) return '';  // standard allows 128/192/256 bit keys
		  plaintext = Utf8.encode(plaintext);
		  password = Utf8.encode(password);
		  //var t = new Date();  // timer

		  // use AES itself to encrypt password to get cipher key (using plain password as source for key 
		  // expansion) - gives us well encrypted key
		  var nBytes = nBits/8;  // no bytes in key
		  var pwBytes = new Array(nBytes);
		  for (var i=0; i<nBytes; i++) {
		    pwBytes[i] = isNaN(password.charCodeAt(i)) ? 0 : password.charCodeAt(i);
		  }
		  var key = Aes.Cipher(pwBytes, Aes.KeyExpansion(pwBytes));  // gives us 16-byte key
		  key = key.concat(key.slice(0, nBytes-16));  // expand key to 16/24/32 bytes long

		  // initialise counter block (NIST SP800-38A §B.2): millisecond time-stamp for nonce in 1st 8 bytes,
		  // block counter in 2nd 8 bytes
		  var counterBlock = new Array(blockSize);
		  var nonce = (new Date()).getTime();  // timestamp: milliseconds since 1-Jan-1970
		  var nonceSec = Math.floor(nonce/1000);
		  var nonceMs = nonce%1000;
		  // encode nonce with seconds in 1st 4 bytes, and (repeated) ms part filling 2nd 4 bytes
		  for (var i=0; i<4; i++) counterBlock[i] = (nonceSec >>> i*8) & 0xff;
		  for (var i=0; i<4; i++) counterBlock[i+4] = nonceMs & 0xff; 
		  // and convert it to a string to go on the front of the ciphertext
		  var ctrTxt = '';
		  for (var i=0; i<8; i++) ctrTxt += String.fromCharCode(counterBlock[i]);

		  // generate key schedule - an expansion of the key into distinct Key Rounds for each round
		  var keySchedule = Aes.KeyExpansion(key);

		  var blockCount = Math.ceil(plaintext.length/blockSize);
		  var ciphertxt = new Array(blockCount);  // ciphertext as array of strings

		  for (var b=0; b<blockCount; b++) {
		    // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
		    // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
		    for (var c=0; c<4; c++) counterBlock[15-c] = (b >>> c*8) & 0xff;
		    for (var c=0; c<4; c++) counterBlock[15-c-4] = (b/0x100000000 >>> c*8)

		    var cipherCntr = Aes.Cipher(counterBlock, keySchedule);  // -- encrypt counter block --

		    // block size is reduced on final block
		    var blockLength = b<blockCount-1 ? blockSize : (plaintext.length-1)%blockSize+1;
		    var cipherChar = new Array(blockLength);

		    for (var i=0; i<blockLength; i++) {  // -- xor plaintext with ciphered counter char-by-char --
		      cipherChar[i] = cipherCntr[i] ^ plaintext.charCodeAt(b*blockSize+i);
		      cipherChar[i] = String.fromCharCode(cipherChar[i]);
		    }
		    ciphertxt[b] = cipherChar.join(''); 
		  }

		  // Array.join is more efficient than repeated string concatenation in IE
		  var ciphertext = ctrTxt + ciphertxt.join('');
		  ciphertext = Base64.encode(ciphertext);  // encode in base64

		  //alert((new Date()) - t);
		  return ciphertext;
		}

		/** 
		 * Decrypt a text encrypted by AES in counter mode of operation
		 *
		 * @param {String} ciphertext Source text to be encrypted
		 * @param {String} password   The password to use to generate a key
		 * @param {Number} nBits      Number of bits to be used in the key (128, 192, or 256)
		 * @returns {String}          Decrypted text
		 */
		AesCtr.decrypt = function(ciphertext, password, nBits) {
		  var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
		  if (!(nBits==128 || nBits==192 || nBits==256)) return '';  // standard allows 128/192/256 bit keys
		  ciphertext = Base64.decode(ciphertext);
		  password = Utf8.encode(password);
		  //var t = new Date();  // timer

		  // use AES to encrypt password (mirroring encrypt routine)
		  var nBytes = nBits/8;  // no bytes in key
		  var pwBytes = new Array(nBytes);
		  for (var i=0; i<nBytes; i++) {
		    pwBytes[i] = isNaN(password.charCodeAt(i)) ? 0 : password.charCodeAt(i);
		  }
		  var key = Aes.Cipher(pwBytes, Aes.KeyExpansion(pwBytes));
		  key = key.concat(key.slice(0, nBytes-16));  // expand key to 16/24/32 bytes long

		  // recover nonce from 1st 8 bytes of ciphertext
		  var counterBlock = new Array(8);
		  ctrTxt = ciphertext.slice(0, 8);
		  for (var i=0; i<8; i++) counterBlock[i] = ctrTxt.charCodeAt(i);

		  // generate key schedule
		  var keySchedule = Aes.KeyExpansion(key);

		  // separate ciphertext into blocks (skipping past initial 8 bytes)
		  var nBlocks = Math.ceil((ciphertext.length-8) / blockSize);
		  var ct = new Array(nBlocks);
		  for (var b=0; b<nBlocks; b++) ct[b] = ciphertext.slice(8+b*blockSize, 8+b*blockSize+blockSize);
		  ciphertext = ct;  // ciphertext is now array of block-length strings

		  // plaintext will get generated block-by-block into array of block-length strings
		  var plaintxt = new Array(ciphertext.length);

		  for (var b=0; b<nBlocks; b++) {
		    // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
		    for (var c=0; c<4; c++) counterBlock[15-c] = ((b) >>> c*8) & 0xff;
		    for (var c=0; c<4; c++) counterBlock[15-c-4] = (((b+1)/0x100000000-1) >>> c*8) & 0xff;

		    var cipherCntr = Aes.Cipher(counterBlock, keySchedule);  // encrypt counter block

		    var plaintxtByte = new Array(ciphertext[b].length);
		    for (var i=0; i<ciphertext[b].length; i++) {
		      // -- xor plaintxt with ciphered counter byte-by-byte --
		      plaintxtByte[i] = cipherCntr[i] ^ ciphertext[b].charCodeAt(i);
		      plaintxtByte[i] = String.fromCharCode(plaintxtByte[i]);
		    }
		    plaintxt[b] = plaintxtByte.join('');
		  }

		  // join array of blocks into single plaintext string
		  var plaintext = plaintxt.join('');
		  plaintext = Utf8.decode(plaintext);  // decode from UTF8 back to Unicode multi-byte chars

		  //alert((new Date()) - t);
		  return plaintext;
		}


		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
		/*  Base64 class: Base 64 encoding / decoding (c) Chris Veness 2002-2009                          */
		/*    note: depends on Utf8 class                                                                 */
		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

		var Base64 = {};  // Base64 namespace

		Base64.code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";

		/**
		 * Encode string into Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648]
		 * (instance method extending String object). As per RFC 4648, no newlines are added.
		 *
		 * @param {String} str The string to be encoded as base-64
		 * @param {Boolean} [utf8encode=false] Flag to indicate whether str is Unicode string to be encoded 
		 *   to UTF8 before conversion to base64; otherwise string is assumed to be 8-bit characters
		 * @returns {String} Base64-encoded string
		 */ 
		Base64.encode = function(str, utf8encode) {  // http://tools.ietf.org/html/rfc4648
		  utf8encode =  (typeof utf8encode == 'undefined') ? false : utf8encode;
		  var o1, o2, o3, bits, h1, h2, h3, h4, e=[], pad = '', c, plain, coded;
		  var b64 = Base64.code;

		  plain = utf8encode ? str.encodeUTF8() : str;

		  c = plain.length % 3;  // pad string to length of multiple of 3
		  if (c > 0) { while (c++ < 3) { pad += '='; plain += '\0'; } }
		  // note: doing padding here saves us doing special-case packing for trailing 1 or 2 chars

		  for (c=0; c<plain.length; c+=3) {  // pack three octets into four hexets
		    o1 = plain.charCodeAt(c);
		    o2 = plain.charCodeAt(c+1);
		    o3 = plain.charCodeAt(c+2);

		    bits = o1<<16 | o2<<8 | o3;

		    h1 = bits>>18 & 0x3f;
		    h2 = bits>>12 & 0x3f;
		    h3 = bits>>6 & 0x3f;
		    h4 = bits & 0x3f;

		    // use hextets to index into code string
		    e[c/3] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
		  }
		  coded = e.join('');  // join() is far faster than repeated string concatenation in IE

		  // replace 'A's from padded nulls with '='s
		  coded = coded.slice(0, coded.length-pad.length) + pad;

		  return coded;
		}

		/**
		 * Decode string from Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648]
		 * (instance method extending String object). As per RFC 4648, newlines are not catered for.
		 *
		 * @param {String} str The string to be decoded from base-64
		 * @param {Boolean} [utf8decode=false] Flag to indicate whether str is Unicode string to be decoded 
		 *   from UTF8 after conversion from base64
		 * @returns {String} decoded string
		 */ 
		Base64.decode = function(str, utf8decode) {
		  utf8decode =  (typeof utf8decode == 'undefined') ? false : utf8decode;
		  var o1, o2, o3, h1, h2, h3, h4, bits, d=[], plain, coded;
		  var b64 = Base64.code;

		  coded = utf8decode ? str.decodeUTF8() : str;


		  for (var c=0; c<coded.length; c+=4) {  // unpack four hexets into three octets
		    h1 = b64.indexOf(coded.charAt(c));
		    h2 = b64.indexOf(coded.charAt(c+1));
		    h3 = b64.indexOf(coded.charAt(c+2));
		    h4 = b64.indexOf(coded.charAt(c+3));

		    bits = h1<<18 | h2<<12 | h3<<6 | h4;

		    o1 = bits>>>16 & 0xff;
		    o2 = bits>>>8 & 0xff;
		    o3 = bits & 0xff;

		    d[c/4] = String.fromCharCode(o1, o2, o3);
		    // check for padding
		    if (h4 == 0x40) d[c/4] = String.fromCharCode(o1, o2);
		    if (h3 == 0x40) d[c/4] = String.fromCharCode(o1);
		  }
		  plain = d.join('');  // join() is far faster than repeated string concatenation in IE

		  return utf8decode ? plain.decodeUTF8() : plain; 
		}


		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
		/*  Utf8 class: encode / decode between multi-byte Unicode characters and UTF-8 multiple          */
		/*              single-byte character encoding (c) Chris Veness 2002-2009                         */
		/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */

		var Utf8 = {};  // Utf8 namespace

		/**
		 * Encode multi-byte Unicode string into utf-8 multiple single-byte characters 
		 * (BMP / basic multilingual plane only)
		 *
		 * Chars in range U+0080 - U+07FF are encoded in 2 chars, U+0800 - U+FFFF in 3 chars
		 *
		 * @param {String} strUni Unicode string to be encoded as UTF-8
		 * @returns {String} encoded string
		 */
		Utf8.encode = function(strUni) {
		  // use regular expressions & String.replace callback function for better efficiency 
		  // than procedural approaches
		  var strUtf = strUni.replace(
		      /[\u0080-\u07ff]/g,  // U+0080 - U+07FF => 2 bytes 110yyyyy, 10zzzzzz
		      function(c) { 
		        var cc = c.charCodeAt(0);
		        return String.fromCharCode(0xc0 | cc>>6, 0x80 | cc&0x3f); }
		    );
		  strUtf = strUtf.replace(
		      /[\u0800-\uffff]/g,  // U+0800 - U+FFFF => 3 bytes 1110xxxx, 10yyyyyy, 10zzzzzz
		      function(c) { 
		        var cc = c.charCodeAt(0); 
		        return String.fromCharCode(0xe0 | cc>>12, 0x80 | cc>>6&0x3F, 0x80 | cc&0x3f); }
		    );
		  return strUtf;
		}

		/**
		 * Decode utf-8 encoded string back into multi-byte Unicode characters
		 *
		 * @param {String} strUtf UTF-8 string to be decoded back to Unicode
		 * @returns {String} decoded string
		 */
		Utf8.decode = function(strUtf) {
		  var strUni = strUtf.replace(
		      /[\u00c0-\u00df][\u0080-\u00bf]/g,                 // 2-byte chars
		      function(c) {  // (note parentheses for precence)
		        var cc = (c.charCodeAt(0)&0x1f)<<6 | c.charCodeAt(1)&0x3f;
		        return String.fromCharCode(cc); }
		    );
		  strUni = strUni.replace(
		      /[\u00e0-\u00ef][\u0080-\u00bf][\u0080-\u00bf]/g,  // 3-byte chars
		      function(c) {  // (note parentheses for precence)
		        var cc = ((c.charCodeAt(0)&0x0f)<<12) | ((c.charCodeAt(1)&0x3f)<<6) | ( c.charCodeAt(2)&0x3f); 
		        return String.fromCharCode(cc); }
		    );
		  return strUni;
		}	
		
		
	var gadgetHelper = null;
	var table = null; 

	function escapeHtml(text) {
		if (text == null) {
			return '';
		}
		return _hesc(text);
	} 
	
	var hash = false;

	function encode(){
		if(!hash){
			var prefs = new _IG_Prefs(); // User preferences
			hash = prefs.getString("hash");
		}

		var masterpassword = _gel('masterpassword').value;
		var plaintext = _gel('plaintext').value;
	
		if(hash) {
		
			if(hash != MD5(masterpassword)) {
				alert('Master password doesn\'t match hash '+MD5(masterpassword));
			} else {
				alert(':'+AesCtr.encrypt(plaintext, masterpassword, 128));
			}
		
		} else {
			alert('Please set the password hash preference');
	
		}
	}

	function decode(item){
	
		if(!hash){
			var prefs = new _IG_Prefs(); // User preferences
			hash = prefs.getString("hash");
		}

		var masterpassword = _gel('masterpassword').value;
		
		if(hash) {
			
			if(hash != MD5(masterpassword)) {
				alert('Master password doesn\'t match hash '+MD5(masterpassword));
			} else {
				alert(AesCtr.decrypt(item.title.substring(1), masterpassword, 128));
			}
			
		} else {
			alert('Please set the password hash preference');
		
		}
	}

	_IG_RegisterOnloadHandler(loadVisualizationAPI);

	/**
	* Load the Google Visualization API
	*/
	
	function loadVisualizationAPI() {
		_gel('loadingmessage').innerHTML = 'visualization started...';
		google.load("visualization", "1");
		google.setOnLoadCallback(sendQuery);
	}

	/**
	* Create a query from the user prefs, and then send it to the data source.
	* This method is called once the visualization API is fully loaded.
	* Note that in the last line, a callback function is specified to be
	* called once the response is received from the data source.
	*/
	function sendQuery() {
		var prefs = new _IG_Prefs(); // User preferences 
		gadgetHelper = new google.visualization.GadgetHelper(); 
		var query = gadgetHelper.createQueryFromPrefs(prefs);
		query.send(handleQueryResponse);
		_gel('loadingmessage').innerHTML = 'sending query...';
	}

	/**
	* Query response handler function.
	* Called by the Google Visualization API once the response is received.
	* Takes the query response and formats it as a table.
	*/
	function handleQueryResponse(response) {
		_gel('loadingmessage').innerHTML = 'handling response...';

		// Use the visualization GadgetHelper class to validate the data, and
		// for error handling.
		if (!gadgetHelper.validateResponse(response)) {
			// Default error handling was done, just leave.
			return;
		};

		_gel('loadingmessage').innerHTML = 'getting datatable...';

		var data = response.getDataTable();

		// Take the data table from the response, and format it.
		var options = {showRowNumber: true};
		_gel('loadingmessage').innerHTML = 'generating html...';

		var html = [];
		html.push('<table>');

		/**
		* Process all Rows in the specified range
		*/
		for (var row = 0; row < data.getNumberOfRows(); row++) {
			_gel('loadingmessage').innerHTML = 'generating row '+row+'...';

			/**
			* Process the Columns in each Row
			*/
			html.push('<tr>');

			for (var col = 0; col < data.getNumberOfColumns(); col++) {

				/**
				* GET A DATA VALUE FROM THE RANGE - sorry again for screaming - but this is the next key step 
				*/
				_gel('loadingmessage').innerHTML = 'getting data '+row+'x'+col+'...';

				var formattedValue = data.getFormattedValue(row, col);
				formattedValue = escapeHtml(formattedValue);

				_gel('loadingmessage').innerHTML = 'processing data '+row+'x'+col+'...';

				/**
				* Look for the 'world'... add the word to the html either way, but format it differently
				*/
				
				if(formattedValue.substring(0,5) == 'hash:'){
					hash = formattedValue.substring(5);
					html.push('<td>hash</td>');
				} else if(formattedValue.substring(0,1) == ':'){
					html.push('<th onclick="decode(this)" title="'+formattedValue+'">');
					html.push(formattedValue.substring(0,8));
					html.push('</th>');
				} else {
					html.push('<td>');
					html.push(formattedValue);
					html.push('</td>');
				}
				
				html.push('\n');
			}
			
			html.push('</tr>');
		}
		
		html.push('</table>');
		
		/**
		* Set the generated html into the container div.
		*/
		
		_gel('loadingmessage').innerHTML = 'updating display...';

		var tableDiv = _gel('tablediv');
		tableDiv.innerHTML = html.join('');
		tableDiv.style.width = document.body.clientWidth + 'px';
		tableDiv.style.height = document.body.clientHeight + 'px';
	};

	</script>

  ]]></Content>
</Module>