API tools faq
paste
Advertisement
InfectedPacket

AES Encryption/Decryption Javascript

InfectedPacket
Aug 21st, 2015
473
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 19.88 KB | None | 0 0
raw download clone embed print report
  1. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  2. /*  AES implementation in JavaScript (c) Chris Veness 2005-2011                                   */
  3. /*   - see http://csrc.nist.gov/publications/PubsFIPS.html#197                                    */
  4. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  5.  
  6. var Aes = {};  // Aes namespace
  7.  
  8. /**
  9.  * AES Cipher function: encrypt 'input' state with Rijndael algorithm
  10.  *   applies Nr rounds (10/12/14) using key schedule w for 'add round key' stage
  11.  *
  12.  * @param {Number[]} input 16-byte (128-bit) input state array
  13.  * @param {Number[][]} w   Key schedule as 2D byte-array (Nr+1 x Nb bytes)
  14.  * @returns {Number[]}     Encrypted output state array
  15.  */
  16. Aes.cipher = function(input, w) {    // main Cipher function [§5.1]
  17.   var Nb = 4;               // block size (in words): no of columns in state (fixed at 4 for AES)
  18.   var Nr = w.length/Nb - 1; // no of rounds: 10/12/14 for 128/192/256-bit keys
  19.  
  20.   var state = [[],[],[],[]];  // initialise 4xNb byte-array 'state' with input [§3.4]
  21.   for (var i=0; i<4*Nb; i++) state[i%4][Math.floor(i/4)] = input[i];
  22.  
  23.   state = Aes.addRoundKey(state, w, 0, Nb);
  24.  
  25.   for (var round=1; round<Nr; round++) {
  26.     state = Aes.subBytes(state, Nb);
  27.     state = Aes.shiftRows(state, Nb);
  28.     state = Aes.mixColumns(state, Nb);
  29.     state = Aes.addRoundKey(state, w, round, Nb);
  30.   }
  31.  
  32.   state = Aes.subBytes(state, Nb);
  33.   state = Aes.shiftRows(state, Nb);
  34.   state = Aes.addRoundKey(state, w, Nr, Nb);
  35.  
  36.   var output = new Array(4*Nb);  // convert state to 1-d array before returning [§3.4]
  37.   for (var i=0; i<4*Nb; i++) output[i] = state[i%4][Math.floor(i/4)];
  38.   return output;
  39. }
  40.  
  41. /**
  42.  * Perform Key Expansion to generate a Key Schedule
  43.  *
  44.  * @param {Number[]} key Key as 16/24/32-byte array
  45.  * @returns {Number[][]} Expanded key schedule as 2D byte-array (Nr+1 x Nb bytes)
  46.  */
  47. Aes.keyExpansion = function(key) {  // generate Key Schedule (byte-array Nr+1 x Nb) from Key [§5.2]
  48.   var Nb = 4;            // block size (in words): no of columns in state (fixed at 4 for AES)
  49.   var Nk = key.length/4  // key length (in words): 4/6/8 for 128/192/256-bit keys
  50.   var Nr = Nk + 6;       // no of rounds: 10/12/14 for 128/192/256-bit keys
  51.  
  52.   var w = new Array(Nb*(Nr+1));
  53.   var temp = new Array(4);
  54.  
  55.   for (var i=0; i<Nk; i++) {
  56.     var r = [key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]];
  57.     w[i] = r;
  58.   }
  59.  
  60.   for (var i=Nk; i<(Nb*(Nr+1)); i++) {
  61.     w[i] = new Array(4);
  62.     for (var t=0; t<4; t++) temp[t] = w[i-1][t];
  63.     if (i % Nk == 0) {
  64.       temp = Aes.subWord(Aes.rotWord(temp));
  65.       for (var t=0; t<4; t++) temp[t] ^= Aes.rCon[i/Nk][t];
  66.     } else if (Nk > 6 && i%Nk == 4) {
  67.       temp = Aes.subWord(temp);
  68.     }
  69.     for (var t=0; t<4; t++) w[i][t] = w[i-Nk][t] ^ temp[t];
  70.   }
  71.  
  72.   return w;
  73. }
  74.  
  75. /*
  76.  * ---- remaining routines are private, not called externally ----
  77.  */
  78.  
  79. Aes.subBytes = function(s, Nb) {    // apply SBox to state S [§5.1.1]
  80.   for (var r=0; r<4; r++) {
  81.     for (var c=0; c<Nb; c++) s[r][c] = Aes.sBox[s[r][c]];
  82.   }
  83.   return s;
  84. }
  85.  
  86. Aes.shiftRows = function(s, Nb) {    // shift row r of state S left by r bytes [§5.1.2]
  87.   var t = new Array(4);
  88.   for (var r=1; r<4; r++) {
  89.     for (var c=0; c<4; c++) t[c] = s[r][(c+r)%Nb];  // shift into temp copy
  90.     for (var c=0; c<4; c++) s[r][c] = t[c];         // and copy back
  91.   }          // note that this will work for Nb=4,5,6, but not 7,8 (always 4 for AES):
  92.   return s;  // see asmaes.sourceforge.net/rijndael/rijndaelImplementation.pdf
  93. }
  94.  
  95. Aes.mixColumns = function(s, Nb) {   // combine bytes of each col of state S [§5.1.3]
  96.   for (var c=0; c<4; c++) {
  97.     var a = new Array(4);  // 'a' is a copy of the current column from 's'
  98.     var b = new Array(4);  // 'b' is a•{02} in GF(2^8)
  99.     for (var i=0; i<4; i++) {
  100.       a[i] = s[i][c];
  101.       b[i] = s[i][c]&0x80 ? s[i][c]<<1 ^ 0x011b : s[i][c]<<1;
  102.  
  103.     }
  104.     // a[n] ^ b[n] is a•{03} in GF(2^8)
  105.     s[0][c] = b[0] ^ a[1] ^ b[1] ^ a[2] ^ a[3]; // 2*a0 + 3*a1 + a2 + a3
  106.     s[1][c] = a[0] ^ b[1] ^ a[2] ^ b[2] ^ a[3]; // a0 * 2*a1 + 3*a2 + a3
  107.     s[2][c] = a[0] ^ a[1] ^ b[2] ^ a[3] ^ b[3]; // a0 + a1 + 2*a2 + 3*a3
  108.     s[3][c] = a[0] ^ b[0] ^ a[1] ^ a[2] ^ b[3]; // 3*a0 + a1 + a2 + 2*a3
  109.   }
  110.   return s;
  111. }
  112.  
  113. Aes.addRoundKey = function(state, w, rnd, Nb) {  // xor Round Key into state S [§5.1.4]
  114.   for (var r=0; r<4; r++) {
  115.     for (var c=0; c<Nb; c++) state[r][c] ^= w[rnd*4+c][r];
  116.   }
  117.   return state;
  118. }
  119.  
  120. Aes.subWord = function(w) {    // apply SBox to 4-byte word w
  121.   for (var i=0; i<4; i++) w[i] = Aes.sBox[w[i]];
  122.   return w;
  123. }
  124.  
  125. Aes.rotWord = function(w) {    // rotate 4-byte word w left by one byte
  126.   var tmp = w[0];
  127.   for (var i=0; i<3; i++) w[i] = w[i+1];
  128.   w[3] = tmp;
  129.   return w;
  130. }
  131.  
  132. // sBox is pre-computed multiplicative inverse in GF(2^8) used in subBytes and keyExpansion [§5.1.1]
  133. Aes.sBox =  [0x63,0x7c,0x77,0x7b,0xf2,0x6b,0x6f,0xc5,0x30,0x01,0x67,0x2b,0xfe,0xd7,0xab,0x76,
  134.              0xca,0x82,0xc9,0x7d,0xfa,0x59,0x47,0xf0,0xad,0xd4,0xa2,0xaf,0x9c,0xa4,0x72,0xc0,
  135.              0xb7,0xfd,0x93,0x26,0x36,0x3f,0xf7,0xcc,0x34,0xa5,0xe5,0xf1,0x71,0xd8,0x31,0x15,
  136.              0x04,0xc7,0x23,0xc3,0x18,0x96,0x05,0x9a,0x07,0x12,0x80,0xe2,0xeb,0x27,0xb2,0x75,
  137.              0x09,0x83,0x2c,0x1a,0x1b,0x6e,0x5a,0xa0,0x52,0x3b,0xd6,0xb3,0x29,0xe3,0x2f,0x84,
  138.              0x53,0xd1,0x00,0xed,0x20,0xfc,0xb1,0x5b,0x6a,0xcb,0xbe,0x39,0x4a,0x4c,0x58,0xcf,
  139.              0xd0,0xef,0xaa,0xfb,0x43,0x4d,0x33,0x85,0x45,0xf9,0x02,0x7f,0x50,0x3c,0x9f,0xa8,
  140.              0x51,0xa3,0x40,0x8f,0x92,0x9d,0x38,0xf5,0xbc,0xb6,0xda,0x21,0x10,0xff,0xf3,0xd2,
  141.              0xcd,0x0c,0x13,0xec,0x5f,0x97,0x44,0x17,0xc4,0xa7,0x7e,0x3d,0x64,0x5d,0x19,0x73,
  142.              0x60,0x81,0x4f,0xdc,0x22,0x2a,0x90,0x88,0x46,0xee,0xb8,0x14,0xde,0x5e,0x0b,0xdb,
  143.              0xe0,0x32,0x3a,0x0a,0x49,0x06,0x24,0x5c,0xc2,0xd3,0xac,0x62,0x91,0x95,0xe4,0x79,
  144.              0xe7,0xc8,0x37,0x6d,0x8d,0xd5,0x4e,0xa9,0x6c,0x56,0xf4,0xea,0x65,0x7a,0xae,0x08,
  145.              0xba,0x78,0x25,0x2e,0x1c,0xa6,0xb4,0xc6,0xe8,0xdd,0x74,0x1f,0x4b,0xbd,0x8b,0x8a,
  146.              0x70,0x3e,0xb5,0x66,0x48,0x03,0xf6,0x0e,0x61,0x35,0x57,0xb9,0x86,0xc1,0x1d,0x9e,
  147.              0xe1,0xf8,0x98,0x11,0x69,0xd9,0x8e,0x94,0x9b,0x1e,0x87,0xe9,0xce,0x55,0x28,0xdf,
  148.              0x8c,0xa1,0x89,0x0d,0xbf,0xe6,0x42,0x68,0x41,0x99,0x2d,0x0f,0xb0,0x54,0xbb,0x16];
  149.  
  150. // rCon is Round Constant used for the Key Expansion [1st col is 2^(r-1) in GF(2^8)] [§5.2]
  151. Aes.rCon = [ [0x00, 0x00, 0x00, 0x00],
  152.              [0x01, 0x00, 0x00, 0x00],
  153.              [0x02, 0x00, 0x00, 0x00],
  154.              [0x04, 0x00, 0x00, 0x00],
  155.              [0x08, 0x00, 0x00, 0x00],
  156.              [0x10, 0x00, 0x00, 0x00],
  157.              [0x20, 0x00, 0x00, 0x00],
  158.              [0x40, 0x00, 0x00, 0x00],
  159.              [0x80, 0x00, 0x00, 0x00],
  160.              [0x1b, 0x00, 0x00, 0x00],
  161.              [0x36, 0x00, 0x00, 0x00] ];
  162.  
  163.  
  164. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  165. /*  AES Counter-mode implementation in JavaScript (c) Chris Veness 2005-2011                      */
  166. /*   - see http://csrc.nist.gov/publications/nistpubs/800-38a/sp800-38a.pdf                       */
  167. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  168.  
  169. Aes.Ctr = {};  // Aes.Ctr namespace: a subclass or extension of Aes
  170.  
  171. /**
  172.  * Encrypt a text using AES encryption in Counter mode of operation
  173.  *
  174.  * Unicode multi-byte character safe
  175.  *
  176.  * @param {String} plaintext Source text to be encrypted
  177.  * @param {String} password  The password to use to generate a key
  178.  * @param {Number} nBits     Number of bits to be used in the key (128, 192, or 256)
  179.  * @returns {string}         Encrypted text
  180.  */
  181. Aes.Ctr.encrypt = function(plaintext, password, nBits) {
  182.   var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  183.   if (!(nBits==128 || nBits==192 || nBits==256)) return '';  // standard allows 128/192/256 bit keys
  184.   plaintext = Utf8.encode(plaintext);
  185.   password = Utf8.encode(password);
  186.   //var t = new Date();  // timer
  187.        
  188.   // use AES itself to encrypt password to get cipher key (using plain password as source for key
  189.   // expansion) - gives us well encrypted key (though hashed key might be preferred for prod'n use)
  190.   var nBytes = nBits/8;  // no bytes in key (16/24/32)
  191.   var pwBytes = new Array(nBytes);
  192.   for (var i=0; i<nBytes; i++) {  // use 1st 16/24/32 chars of password for key
  193.     pwBytes[i] = isNaN(password.charCodeAt(i)) ? 0 : password.charCodeAt(i);
  194.   }
  195.   var key = Aes.cipher(pwBytes, Aes.keyExpansion(pwBytes));  // gives us 16-byte key
  196.   key = key.concat(key.slice(0, nBytes-16));  // expand key to 16/24/32 bytes long
  197.  
  198.   // initialise 1st 8 bytes of counter block with nonce (NIST SP800-38A §B.2): [0-1] = millisec,
  199.   // [2-3] = random, [4-7] = seconds, together giving full sub-millisec uniqueness up to Feb 2106
  200.   var counterBlock = new Array(blockSize);
  201.  
  202.   var nonce = (new Date()).getTime();  // timestamp: milliseconds since 1-Jan-1970
  203.   var nonceMs = nonce%1000;
  204.   var nonceSec = Math.floor(nonce/1000);
  205.   var nonceRnd = Math.floor(Math.random()*0xffff);
  206.  
  207.   for (var i=0; i<2; i++) counterBlock[i]   = (nonceMs  >>> i*8) & 0xff;
  208.   for (var i=0; i<2; i++) counterBlock[i+2] = (nonceRnd >>> i*8) & 0xff;
  209.   for (var i=0; i<4; i++) counterBlock[i+4] = (nonceSec >>> i*8) & 0xff;
  210.  
  211.   // and convert it to a string to go on the front of the ciphertext
  212.   var ctrTxt = '';
  213.   for (var i=0; i<8; i++) ctrTxt += String.fromCharCode(counterBlock[i]);
  214.  
  215.   // generate key schedule - an expansion of the key into distinct Key Rounds for each round
  216.   var keySchedule = Aes.keyExpansion(key);
  217.  
  218.   var blockCount = Math.ceil(plaintext.length/blockSize);
  219.   var ciphertxt = new Array(blockCount);  // ciphertext as array of strings
  220.  
  221.   for (var b=0; b<blockCount; b++) {
  222.     // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  223.     // done in two stages for 32-bit ops: using two words allows us to go past 2^32 blocks (68GB)
  224.     for (var c=0; c<4; c++) counterBlock[15-c] = (b >>> c*8) & 0xff;
  225.     for (var c=0; c<4; c++) counterBlock[15-c-4] = (b/0x100000000 >>> c*8)
  226.  
  227.     var cipherCntr = Aes.cipher(counterBlock, keySchedule);  // -- encrypt counter block --
  228.    
  229.     // block size is reduced on final block
  230.     var blockLength = b<blockCount-1 ? blockSize : (plaintext.length-1)%blockSize+1;
  231.     var cipherChar = new Array(blockLength);
  232.    
  233.     for (var i=0; i<blockLength; i++) {  // -- xor plaintext with ciphered counter char-by-char --
  234.       cipherChar[i] = cipherCntr[i] ^ plaintext.charCodeAt(b*blockSize+i);
  235.       cipherChar[i] = String.fromCharCode(cipherChar[i]);
  236.     }
  237.     ciphertxt[b] = cipherChar.join('');
  238.   }
  239.  
  240.   // Array.join is more efficient than repeated string concatenation in IE
  241.   var ciphertext = ctrTxt + ciphertxt.join('');
  242.   ciphertext = Base64.encode(ciphertext);  // encode in base64
  243.  
  244.   //alert((new Date()) - t);
  245.   return ciphertext;
  246. }
  247.  
  248. /**
  249.  * Decrypt a text encrypted by AES in counter mode of operation
  250.  *
  251.  * @param {String} ciphertext Source text to be encrypted
  252.  * @param {String} password   The password to use to generate a key
  253.  * @param {Number} nBits      Number of bits to be used in the key (128, 192, or 256)
  254.  * @returns {String}          Decrypted text
  255.  */
  256. Aes.Ctr.decrypt = function(ciphertext, password, nBits) {
  257.   var blockSize = 16;  // block size fixed at 16 bytes / 128 bits (Nb=4) for AES
  258.   if (!(nBits==128 || nBits==192 || nBits==256)) return '';  // standard allows 128/192/256 bit keys
  259.   ciphertext = Base64.decode(ciphertext);
  260.   password = Utf8.encode(password);
  261.   //var t = new Date();  // timer
  262.  
  263.   // use AES to encrypt password (mirroring encrypt routine)
  264.   var nBytes = nBits/8;  // no bytes in key
  265.   var pwBytes = new Array(nBytes);
  266.   for (var i=0; i<nBytes; i++) {
  267.     pwBytes[i] = isNaN(password.charCodeAt(i)) ? 0 : password.charCodeAt(i);
  268.   }
  269.   var key = Aes.cipher(pwBytes, Aes.keyExpansion(pwBytes));
  270.   key = key.concat(key.slice(0, nBytes-16));  // expand key to 16/24/32 bytes long
  271.  
  272.   // recover nonce from 1st 8 bytes of ciphertext
  273.   var counterBlock = new Array(8);
  274.   ctrTxt = ciphertext.slice(0, 8);
  275.   for (var i=0; i<8; i++) counterBlock[i] = ctrTxt.charCodeAt(i);
  276.  
  277.   // generate key schedule
  278.   var keySchedule = Aes.keyExpansion(key);
  279.  
  280.   // separate ciphertext into blocks (skipping past initial 8 bytes)
  281.   var nBlocks = Math.ceil((ciphertext.length-8) / blockSize);
  282.   var ct = new Array(nBlocks);
  283.   for (var b=0; b<nBlocks; b++) ct[b] = ciphertext.slice(8+b*blockSize, 8+b*blockSize+blockSize);
  284.   ciphertext = ct;  // ciphertext is now array of block-length strings
  285.  
  286.   // plaintext will get generated block-by-block into array of block-length strings
  287.   var plaintxt = new Array(ciphertext.length);
  288.  
  289.   for (var b=0; b<nBlocks; b++) {
  290.     // set counter (block #) in last 8 bytes of counter block (leaving nonce in 1st 8 bytes)
  291.     for (var c=0; c<4; c++) counterBlock[15-c] = ((b) >>> c*8) & 0xff;
  292.     for (var c=0; c<4; c++) counterBlock[15-c-4] = (((b+1)/0x100000000-1) >>> c*8) & 0xff;
  293.  
  294.     var cipherCntr = Aes.cipher(counterBlock, keySchedule);  // encrypt counter block
  295.  
  296.     var plaintxtByte = new Array(ciphertext[b].length);
  297.     for (var i=0; i<ciphertext[b].length; i++) {
  298.       // -- xor plaintxt with ciphered counter byte-by-byte --
  299.       plaintxtByte[i] = cipherCntr[i] ^ ciphertext[b].charCodeAt(i);
  300.       plaintxtByte[i] = String.fromCharCode(plaintxtByte[i]);
  301.     }
  302.     plaintxt[b] = plaintxtByte.join('');
  303.   }
  304.  
  305.   // join array of blocks into single plaintext string
  306.   var plaintext = plaintxt.join('');
  307.   plaintext = Utf8.decode(plaintext);  // decode from UTF8 back to Unicode multi-byte chars
  308.  
  309.   //alert((new Date()) - t);
  310.   return plaintext;
  311. }
  312.  
  313.  
  314. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  315. /*  Base64 class: Base 64 encoding / decoding (c) Chris Veness 2002-2011                          */
  316. /*    note: depends on Utf8 class                                                                 */
  317. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  318.  
  319. var Base64 = {};  // Base64 namespace
  320.  
  321. Base64.code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
  322.  
  323. /**
  324.  * Encode string into Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648]
  325.  * (instance method extending String object). As per RFC 4648, no newlines are added.
  326.  *
  327.  * @param {String} str The string to be encoded as base-64
  328.  * @param {Boolean} [utf8encode=false] Flag to indicate whether str is Unicode string to be encoded
  329.  *   to UTF8 before conversion to base64; otherwise string is assumed to be 8-bit characters
  330.  * @returns {String} Base64-encoded string
  331.  */
  332. Base64.encode = function(str, utf8encode) {  // http://tools.ietf.org/html/rfc4648
  333.   utf8encode =  (typeof utf8encode == 'undefined') ? false : utf8encode;
  334.   var o1, o2, o3, bits, h1, h2, h3, h4, e=[], pad = '', c, plain, coded;
  335.   var b64 = Base64.code;
  336.    
  337.   plain = utf8encode ? str.encodeUTF8() : str;
  338.  
  339.   c = plain.length % 3;  // pad string to length of multiple of 3
  340.   if (c > 0) { while (c++ < 3) { pad += '='; plain += '\0'; } }
  341.   // note: doing padding here saves us doing special-case packing for trailing 1 or 2 chars
  342.    
  343.   for (c=0; c<plain.length; c+=3) {  // pack three octets into four hexets
  344.     o1 = plain.charCodeAt(c);
  345.     o2 = plain.charCodeAt(c+1);
  346.     o3 = plain.charCodeAt(c+2);
  347.      
  348.     bits = o1<<16 | o2<<8 | o3;
  349.      
  350.     h1 = bits>>18 & 0x3f;
  351.     h2 = bits>>12 & 0x3f;
  352.     h3 = bits>>6 & 0x3f;
  353.     h4 = bits & 0x3f;
  354.  
  355.     // use hextets to index into code string
  356.     e[c/3] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
  357.   }
  358.   coded = e.join('');  // join() is far faster than repeated string concatenation in IE
  359.  
  360.   // replace 'A's from padded nulls with '='s
  361.   coded = coded.slice(0, coded.length-pad.length) + pad;
  362.    
  363.   return coded;
  364. }
  365.  
  366. /**
  367.  * Decode string from Base64, as defined by RFC 4648 [http://tools.ietf.org/html/rfc4648]
  368.  * (instance method extending String object). As per RFC 4648, newlines are not catered for.
  369.  *
  370.  * @param {String} str The string to be decoded from base-64
  371.  * @param {Boolean} [utf8decode=false] Flag to indicate whether str is Unicode string to be decoded
  372.  *   from UTF8 after conversion from base64
  373.  * @returns {String} decoded string
  374.  */
  375. Base64.decode = function(str, utf8decode) {
  376.   utf8decode =  (typeof utf8decode == 'undefined') ? false : utf8decode;
  377.   var o1, o2, o3, h1, h2, h3, h4, bits, d=[], plain, coded;
  378.   var b64 = Base64.code;
  379.  
  380.   coded = utf8decode ? str.decodeUTF8() : str;
  381.  
  382.  
  383.   for (var c=0; c<coded.length; c+=4) {  // unpack four hexets into three octets
  384.     h1 = b64.indexOf(coded.charAt(c));
  385.     h2 = b64.indexOf(coded.charAt(c+1));
  386.     h3 = b64.indexOf(coded.charAt(c+2));
  387.     h4 = b64.indexOf(coded.charAt(c+3));
  388.      
  389.     bits = h1<<18 | h2<<12 | h3<<6 | h4;
  390.      
  391.     o1 = bits>>>16 & 0xff;
  392.     o2 = bits>>>8 & 0xff;
  393.     o3 = bits & 0xff;
  394.    
  395.     d[c/4] = String.fromCharCode(o1, o2, o3);
  396.     // check for padding
  397.     if (h4 == 0x40) d[c/4] = String.fromCharCode(o1, o2);
  398.     if (h3 == 0x40) d[c/4] = String.fromCharCode(o1);
  399.   }
  400.   plain = d.join('');  // join() is far faster than repeated string concatenation in IE
  401.    
  402.   return utf8decode ? plain.decodeUTF8() : plain;
  403. }
  404.  
  405.  
  406. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  407. /*  Utf8 class: encode / decode between multi-byte Unicode characters and UTF-8 multiple          */
  408. /*              single-byte character encoding (c) Chris Veness 2002-2011                         */
  409. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
  410.  
  411. var Utf8 = {};  // Utf8 namespace
  412.  
  413. /**
  414.  * Encode multi-byte Unicode string into utf-8 multiple single-byte characters
  415.  * (BMP / basic multilingual plane only)
  416.  *
  417.  * Chars in range U+0080 - U+07FF are encoded in 2 chars, U+0800 - U+FFFF in 3 chars
  418.  *
  419.  * @param {String} strUni Unicode string to be encoded as UTF-8
  420.  * @returns {String} encoded string
  421.  */
  422. Utf8.encode = function(strUni) {
  423.   // use regular expressions & String.replace callback function for better efficiency
  424.   // than procedural approaches
  425.   var strUtf = strUni.replace(
  426.       /[\u0080-\u07ff]/g,  // U+0080 - U+07FF => 2 bytes 110yyyyy, 10zzzzzz
  427.       function(c) {
  428.         var cc = c.charCodeAt(0);
  429.         return String.fromCharCode(0xc0 | cc>>6, 0x80 | cc&0x3f); }
  430.     );
  431.   strUtf = strUtf.replace(
  432.       /[\u0800-\uffff]/g,  // U+0800 - U+FFFF => 3 bytes 1110xxxx, 10yyyyyy, 10zzzzzz
  433.       function(c) {
  434.         var cc = c.charCodeAt(0);
  435.         return String.fromCharCode(0xe0 | cc>>12, 0x80 | cc>>6&0x3F, 0x80 | cc&0x3f); }
  436.     );
  437.   return strUtf;
  438. }
  439.  
  440. /**
  441.  * Decode utf-8 encoded string back into multi-byte Unicode characters
  442.  *
  443.  * @param {String} strUtf UTF-8 string to be decoded back to Unicode
  444.  * @returns {String} decoded string
  445.  */
  446. Utf8.decode = function(strUtf) {
  447.   // note: decode 3-byte chars first as decoded 2-byte strings could appear to be 3-byte char!
  448.   var strUni = strUtf.replace(
  449.       /[\u00e0-\u00ef][\u0080-\u00bf][\u0080-\u00bf]/g,  // 3-byte chars
  450.       function(c) {  // (note parentheses for precence)
  451.         var cc = ((c.charCodeAt(0)&0x0f)<<12) | ((c.charCodeAt(1)&0x3f)<<6) | ( c.charCodeAt(2)&0x3f);
  452.         return String.fromCharCode(cc); }
  453.     );
  454.   strUni = strUni.replace(
  455.       /[\u00c0-\u00df][\u0080-\u00bf]/g,                 // 2-byte chars
  456.       function(c) {  // (note parentheses for precence)
  457.         var cc = (c.charCodeAt(0)&0x1f)<<6 | c.charCodeAt(1)&0x3f;
  458.         return String.fromCharCode(cc); }
  459.     );
  460.   return strUni;
  461. }
  462.  
  463. /* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  */
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!