Created
November 3, 2009 15:58
-
-
Save jos3000/225143 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
<?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> |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment