API tools faq
paste
michels10

sha512.js

michels10
Apr 13th, 2017
36
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
JavaScript 15.95 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * A JavaScript implementation of the Secure Hash Algorithm, SHA-512, as defined
  3.  * in FIPS 180-2
  4.  * Version 2.2 Copyright Anonymous Contributor, Paul Johnston 2000 - 2009.
  5.  * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
  6.  * Distributed under the BSD License
  7.  * See http://pajhome.org.uk/crypt/md5 for details.
  8.  */
  9.  
  10. /*
  11.  * Configurable variables. You may need to tweak these to be compatible with
  12.  * the server-side, but the defaults work in most cases.
  13.  */
  14. var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
  15. var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
  16.  
  17. /*
  18.  * These are the functions you'll usually want to call
  19.  * They take string arguments and return either hex or base-64 encoded strings
  20.  */
  21. function hex_sha512(s)    { return rstr2hex(rstr_sha512(str2rstr_utf8(s))); }
  22. function b64_sha512(s)    { return rstr2b64(rstr_sha512(str2rstr_utf8(s))); }
  23. function any_sha512(s, e) { return rstr2any(rstr_sha512(str2rstr_utf8(s)), e);}
  24. function hex_hmac_sha512(k, d)
  25.   { return rstr2hex(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d))); }
  26. function b64_hmac_sha512(k, d)
  27.   { return rstr2b64(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d))); }
  28. function any_hmac_sha512(k, d, e)
  29.   { return rstr2any(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d)), e);}
  30.  
  31. /*
  32.  * Perform a simple self-test to see if the VM is working
  33.  */
  34. function sha512_vm_test()
  35. {
  36.   return hex_sha512("abc").toLowerCase() ==
  37.     "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" +
  38.     "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";
  39. }
  40.  
  41. /*
  42.  * Calculate the SHA-512 of a raw string
  43.  */
  44. function rstr_sha512(s)
  45. {
  46.   return binb2rstr(binb_sha512(rstr2binb(s), s.length * 8));
  47. }
  48.  
  49. /*
  50.  * Calculate the HMAC-SHA-512 of a key and some data (raw strings)
  51.  */
  52. function rstr_hmac_sha512(key, data)
  53. {
  54.   var bkey = rstr2binb(key);
  55.   if(bkey.length > 32) bkey = binb_sha512(bkey, key.length * 8);
  56.  
  57.   var ipad = Array(32), opad = Array(32);
  58.   for(var i = 0; i < 32; i++)
  59.   {
  60.     ipad[i] = bkey[i] ^ 0x36363636;
  61.     opad[i] = bkey[i] ^ 0x5C5C5C5C;
  62.   }
  63.  
  64.   var hash = binb_sha512(ipad.concat(rstr2binb(data)), 1024 + data.length * 8);
  65.   return binb2rstr(binb_sha512(opad.concat(hash), 1024 + 512));
  66. }
  67.  
  68. /*
  69.  * Convert a raw string to a hex string
  70.  */
  71. function rstr2hex(input)
  72. {
  73.   try { hexcase } catch(e) { hexcase=0; }
  74.   var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  75.   var output = "";
  76.   var x;
  77.   for(var i = 0; i < input.length; i++)
  78.   {
  79.     x = input.charCodeAt(i);
  80.     output += hex_tab.charAt((x >>> 4) & 0x0F)
  81.            +  hex_tab.charAt( x        & 0x0F);
  82.   }
  83.   return output;
  84. }
  85.  
  86. /*
  87.  * Convert a raw string to a base-64 string
  88.  */
  89. function rstr2b64(input)
  90. {
  91.   try { b64pad } catch(e) { b64pad=''; }
  92.   var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  93.   var output = "";
  94.   var len = input.length;
  95.   for(var i = 0; i < len; i += 3)
  96.   {
  97.     var triplet = (input.charCodeAt(i) << 16)
  98.                 | (i + 1 < len ? input.charCodeAt(i+1) << 8 : 0)
  99.                 | (i + 2 < len ? input.charCodeAt(i+2)      : 0);
  100.     for(var j = 0; j < 4; j++)
  101.     {
  102.       if(i * 8 + j * 6 > input.length * 8) output += b64pad;
  103.       else output += tab.charAt((triplet >>> 6*(3-j)) & 0x3F);
  104.     }
  105.   }
  106.   return output;
  107. }
  108.  
  109. /*
  110.  * Convert a raw string to an arbitrary string encoding
  111.  */
  112. function rstr2any(input, encoding)
  113. {
  114.   var divisor = encoding.length;
  115.   var i, j, q, x, quotient;
  116.  
  117.   /* Convert to an array of 16-bit big-endian values, forming the dividend */
  118.   var dividend = Array(Math.ceil(input.length / 2));
  119.   for(i = 0; i < dividend.length; i++)
  120.   {
  121.     dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
  122.   }
  123.  
  124.   /*
  125.    * Repeatedly perform a long division. The binary array forms the dividend,
  126.    * the length of the encoding is the divisor. Once computed, the quotient
  127.    * forms the dividend for the next step. All remainders are stored for later
  128.    * use.
  129.    */
  130.   var full_length = Math.ceil(input.length * 8 /
  131.                                     (Math.log(encoding.length) / Math.log(2)));
  132.   var remainders = Array(full_length);
  133.   for(j = 0; j < full_length; j++)
  134.   {
  135.     quotient = Array();
  136.     x = 0;
  137.     for(i = 0; i < dividend.length; i++)
  138.     {
  139.       x = (x << 16) + dividend[i];
  140.       q = Math.floor(x / divisor);
  141.       x -= q * divisor;
  142.       if(quotient.length > 0 || q > 0)
  143.         quotient[quotient.length] = q;
  144.     }
  145.     remainders[j] = x;
  146.     dividend = quotient;
  147.   }
  148.  
  149.   /* Convert the remainders to the output string */
  150.   var output = "";
  151.   for(i = remainders.length - 1; i >= 0; i--)
  152.     output += encoding.charAt(remainders[i]);
  153.  
  154.   return output;
  155. }
  156.  
  157. /*
  158.  * Encode a string as utf-8.
  159.  * For efficiency, this assumes the input is valid utf-16.
  160.  */
  161. function str2rstr_utf8(input)
  162. {
  163.   var output = "";
  164.   var i = -1;
  165.   var x, y;
  166.  
  167.   while(++i < input.length)
  168.   {
  169.     /* Decode utf-16 surrogate pairs */
  170.     x = input.charCodeAt(i);
  171.     y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
  172.     if(0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF)
  173.     {
  174.       x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
  175.       i++;
  176.     }
  177.  
  178.     /* Encode output as utf-8 */
  179.     if(x <= 0x7F)
  180.       output += String.fromCharCode(x);
  181.     else if(x <= 0x7FF)
  182.       output += String.fromCharCode(0xC0 | ((x >>> 6 ) & 0x1F),
  183.                                     0x80 | ( x         & 0x3F));
  184.     else if(x <= 0xFFFF)
  185.       output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F),
  186.                                     0x80 | ((x >>> 6 ) & 0x3F),
  187.                                     0x80 | ( x         & 0x3F));
  188.     else if(x <= 0x1FFFFF)
  189.       output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07),
  190.                                     0x80 | ((x >>> 12) & 0x3F),
  191.                                     0x80 | ((x >>> 6 ) & 0x3F),
  192.                                     0x80 | ( x         & 0x3F));
  193.   }
  194.   return output;
  195. }
  196.  
  197. /*
  198.  * Encode a string as utf-16
  199.  */
  200. function str2rstr_utf16le(input)
  201. {
  202.   var output = "";
  203.   for(var i = 0; i < input.length; i++)
  204.     output += String.fromCharCode( input.charCodeAt(i)        & 0xFF,
  205.                                   (input.charCodeAt(i) >>> 8) & 0xFF);
  206.   return output;
  207. }
  208.  
  209. function str2rstr_utf16be(input)
  210. {
  211.   var output = "";
  212.   for(var i = 0; i < input.length; i++)
  213.     output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF,
  214.                                    input.charCodeAt(i)        & 0xFF);
  215.   return output;
  216. }
  217.  
  218. /*
  219.  * Convert a raw string to an array of big-endian words
  220.  * Characters >255 have their high-byte silently ignored.
  221.  */
  222. function rstr2binb(input)
  223. {
  224.   var output = Array(input.length >> 2);
  225.   for(var i = 0; i < output.length; i++)
  226.     output[i] = 0;
  227.   for(var i = 0; i < input.length * 8; i += 8)
  228.     output[i>>5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32);
  229.   return output;
  230. }
  231.  
  232. /*
  233.  * Convert an array of big-endian words to a string
  234.  */
  235. function binb2rstr(input)
  236. {
  237.   var output = "";
  238.   for(var i = 0; i < input.length * 32; i += 8)
  239.     output += String.fromCharCode((input[i>>5] >>> (24 - i % 32)) & 0xFF);
  240.   return output;
  241. }
  242.  
  243. /*
  244.  * Calculate the SHA-512 of an array of big-endian dwords, and a bit length
  245.  */
  246. var sha512_k;
  247. function binb_sha512(x, len)
  248. {
  249.   if(sha512_k == undefined)
  250.   {
  251.     //SHA512 constants
  252.     sha512_k = new Array(
  253. new int64(0x428a2f98, -685199838), new int64(0x71374491, 0x23ef65cd),
  254. new int64(-1245643825, -330482897), new int64(-373957723, -2121671748),
  255. new int64(0x3956c25b, -213338824), new int64(0x59f111f1, -1241133031),
  256. new int64(-1841331548, -1357295717), new int64(-1424204075, -630357736),
  257. new int64(-670586216, -1560083902), new int64(0x12835b01, 0x45706fbe),
  258. new int64(0x243185be, 0x4ee4b28c), new int64(0x550c7dc3, -704662302),
  259. new int64(0x72be5d74, -226784913), new int64(-2132889090, 0x3b1696b1),
  260. new int64(-1680079193, 0x25c71235), new int64(-1046744716, -815192428),
  261. new int64(-459576895, -1628353838), new int64(-272742522, 0x384f25e3),
  262. new int64(0xfc19dc6, -1953704523), new int64(0x240ca1cc, 0x77ac9c65),
  263. new int64(0x2de92c6f, 0x592b0275), new int64(0x4a7484aa, 0x6ea6e483),
  264. new int64(0x5cb0a9dc, -1119749164), new int64(0x76f988da, -2096016459),
  265. new int64(-1740746414, -295247957), new int64(-1473132947, 0x2db43210),
  266. new int64(-1341970488, -1728372417), new int64(-1084653625, -1091629340),
  267. new int64(-958395405, 0x3da88fc2), new int64(-710438585, -1828018395),
  268. new int64(0x6ca6351, -536640913), new int64(0x14292967, 0xa0e6e70),
  269. new int64(0x27b70a85, 0x46d22ffc), new int64(0x2e1b2138, 0x5c26c926),
  270. new int64(0x4d2c6dfc, 0x5ac42aed), new int64(0x53380d13, -1651133473),
  271. new int64(0x650a7354, -1951439906), new int64(0x766a0abb, 0x3c77b2a8),
  272. new int64(-2117940946, 0x47edaee6), new int64(-1838011259, 0x1482353b),
  273. new int64(-1564481375, 0x4cf10364), new int64(-1474664885, -1136513023),
  274. new int64(-1035236496, -789014639), new int64(-949202525, 0x654be30),
  275. new int64(-778901479, -688958952), new int64(-694614492, 0x5565a910),
  276. new int64(-200395387, 0x5771202a), new int64(0x106aa070, 0x32bbd1b8),
  277. new int64(0x19a4c116, -1194143544), new int64(0x1e376c08, 0x5141ab53),
  278. new int64(0x2748774c, -544281703), new int64(0x34b0bcb5, -509917016),
  279. new int64(0x391c0cb3, -976659869), new int64(0x4ed8aa4a, -482243893),
  280. new int64(0x5b9cca4f, 0x7763e373), new int64(0x682e6ff3, -692930397),
  281. new int64(0x748f82ee, 0x5defb2fc), new int64(0x78a5636f, 0x43172f60),
  282. new int64(-2067236844, -1578062990), new int64(-1933114872, 0x1a6439ec),
  283. new int64(-1866530822, 0x23631e28), new int64(-1538233109, -561857047),
  284. new int64(-1090935817, -1295615723), new int64(-965641998, -479046869),
  285. new int64(-903397682, -366583396), new int64(-779700025, 0x21c0c207),
  286. new int64(-354779690, -840897762), new int64(-176337025, -294727304),
  287. new int64(0x6f067aa, 0x72176fba), new int64(0xa637dc5, -1563912026),
  288. new int64(0x113f9804, -1090974290), new int64(0x1b710b35, 0x131c471b),
  289. new int64(0x28db77f5, 0x23047d84), new int64(0x32caab7b, 0x40c72493),
  290. new int64(0x3c9ebe0a, 0x15c9bebc), new int64(0x431d67c4, -1676669620),
  291. new int64(0x4cc5d4be, -885112138), new int64(0x597f299c, -60457430),
  292. new int64(0x5fcb6fab, 0x3ad6faec), new int64(0x6c44198c, 0x4a475817));
  293.   }
  294.  
  295.   //Initial hash values
  296.   var H = new Array(
  297. new int64(0x6a09e667, -205731576),
  298. new int64(-1150833019, -2067093701),
  299. new int64(0x3c6ef372, -23791573),
  300. new int64(-1521486534, 0x5f1d36f1),
  301. new int64(0x510e527f, -1377402159),
  302. new int64(-1694144372, 0x2b3e6c1f),
  303. new int64(0x1f83d9ab, -79577749),
  304. new int64(0x5be0cd19, 0x137e2179));
  305.  
  306.   var T1 = new int64(0, 0),
  307.     T2 = new int64(0, 0),
  308.     a = new int64(0,0),
  309.     b = new int64(0,0),
  310.     c = new int64(0,0),
  311.     d = new int64(0,0),
  312.     e = new int64(0,0),
  313.     f = new int64(0,0),
  314.     g = new int64(0,0),
  315.     h = new int64(0,0),
  316.     //Temporary variables not specified by the document
  317.     s0 = new int64(0, 0),
  318.     s1 = new int64(0, 0),
  319.     Ch = new int64(0, 0),
  320.     Maj = new int64(0, 0),
  321.     r1 = new int64(0, 0),
  322.     r2 = new int64(0, 0),
  323.     r3 = new int64(0, 0);
  324.   var j, i;
  325.   var W = new Array(80);
  326.   for(i=0; i<80; i++)
  327.     W[i] = new int64(0, 0);
  328.  
  329.   // append padding to the source string. The format is described in the FIPS.
  330.   x[len >> 5] |= 0x80 << (24 - (len & 0x1f));
  331.   x[((len + 128 >> 10)<< 5) + 31] = len;
  332.  
  333.   for(i = 0; i<x.length; i+=32) //32 dwords is the block size
  334.   {
  335.     int64copy(a, H[0]);
  336.     int64copy(b, H[1]);
  337.     int64copy(c, H[2]);
  338.     int64copy(d, H[3]);
  339.     int64copy(e, H[4]);
  340.     int64copy(f, H[5]);
  341.     int64copy(g, H[6]);
  342.     int64copy(h, H[7]);
  343.  
  344.     for(j=0; j<16; j++)
  345.     {
  346.         W[j].h = x[i + 2*j];
  347.         W[j].l = x[i + 2*j + 1];
  348.     }
  349.  
  350.     for(j=16; j<80; j++)
  351.     {
  352.       //sigma1
  353.       int64rrot(r1, W[j-2], 19);
  354.       int64revrrot(r2, W[j-2], 29);
  355.       int64shr(r3, W[j-2], 6);
  356.       s1.l = r1.l ^ r2.l ^ r3.l;
  357.       s1.h = r1.h ^ r2.h ^ r3.h;
  358.       //sigma0
  359.       int64rrot(r1, W[j-15], 1);
  360.       int64rrot(r2, W[j-15], 8);
  361.       int64shr(r3, W[j-15], 7);
  362.       s0.l = r1.l ^ r2.l ^ r3.l;
  363.       s0.h = r1.h ^ r2.h ^ r3.h;
  364.  
  365.       int64add4(W[j], s1, W[j-7], s0, W[j-16]);
  366.     }
  367.  
  368.     for(j = 0; j < 80; j++)
  369.     {
  370.       //Ch
  371.       Ch.l = (e.l & f.l) ^ (~e.l & g.l);
  372.       Ch.h = (e.h & f.h) ^ (~e.h & g.h);
  373.  
  374.       //Sigma1
  375.       int64rrot(r1, e, 14);
  376.       int64rrot(r2, e, 18);
  377.       int64revrrot(r3, e, 9);
  378.       s1.l = r1.l ^ r2.l ^ r3.l;
  379.       s1.h = r1.h ^ r2.h ^ r3.h;
  380.  
  381.       //Sigma0
  382.       int64rrot(r1, a, 28);
  383.       int64revrrot(r2, a, 2);
  384.       int64revrrot(r3, a, 7);
  385.       s0.l = r1.l ^ r2.l ^ r3.l;
  386.       s0.h = r1.h ^ r2.h ^ r3.h;
  387.  
  388.       //Maj
  389.       Maj.l = (a.l & b.l) ^ (a.l & c.l) ^ (b.l & c.l);
  390.       Maj.h = (a.h & b.h) ^ (a.h & c.h) ^ (b.h & c.h);
  391.  
  392.       int64add5(T1, h, s1, Ch, sha512_k[j], W[j]);
  393.       int64add(T2, s0, Maj);
  394.  
  395.       int64copy(h, g);
  396.       int64copy(g, f);
  397.       int64copy(f, e);
  398.       int64add(e, d, T1);
  399.       int64copy(d, c);
  400.       int64copy(c, b);
  401.       int64copy(b, a);
  402.       int64add(a, T1, T2);
  403.     }
  404.     int64add(H[0], H[0], a);
  405.     int64add(H[1], H[1], b);
  406.     int64add(H[2], H[2], c);
  407.     int64add(H[3], H[3], d);
  408.     int64add(H[4], H[4], e);
  409.     int64add(H[5], H[5], f);
  410.     int64add(H[6], H[6], g);
  411.     int64add(H[7], H[7], h);
  412.   }
  413.  
  414.   //represent the hash as an array of 32-bit dwords
  415.   var hash = new Array(16);
  416.   for(i=0; i<8; i++)
  417.   {
  418.     hash[2*i] = H[i].h;
  419.     hash[2*i + 1] = H[i].l;
  420.   }
  421.   return hash;
  422. }
  423.  
  424. //A constructor for 64-bit numbers
  425. function int64(h, l)
  426. {
  427.   this.h = h;
  428.   this.l = l;
  429.   //this.toString = int64toString;
  430. }
  431.  
  432. //Copies src into dst, assuming both are 64-bit numbers
  433. function int64copy(dst, src)
  434. {
  435.   dst.h = src.h;
  436.   dst.l = src.l;
  437. }
  438.  
  439. //Right-rotates a 64-bit number by shift
  440. //Won't handle cases of shift>=32
  441. //The function revrrot() is for that
  442. function int64rrot(dst, x, shift)
  443. {
  444.     dst.l = (x.l >>> shift) | (x.h << (32-shift));
  445.     dst.h = (x.h >>> shift) | (x.l << (32-shift));
  446. }
  447.  
  448. //Reverses the dwords of the source and then rotates right by shift.
  449. //This is equivalent to rotation by 32+shift
  450. function int64revrrot(dst, x, shift)
  451. {
  452.     dst.l = (x.h >>> shift) | (x.l << (32-shift));
  453.     dst.h = (x.l >>> shift) | (x.h << (32-shift));
  454. }
  455.  
  456. //Bitwise-shifts right a 64-bit number by shift
  457. //Won't handle shift>=32, but it's never needed in SHA512
  458. function int64shr(dst, x, shift)
  459. {
  460.     dst.l = (x.l >>> shift) | (x.h << (32-shift));
  461.     dst.h = (x.h >>> shift);
  462. }
  463.  
  464. //Adds two 64-bit numbers
  465. //Like the original implementation, does not rely on 32-bit operations
  466. function int64add(dst, x, y)
  467. {
  468.    var w0 = (x.l & 0xffff) + (y.l & 0xffff);
  469.    var w1 = (x.l >>> 16) + (y.l >>> 16) + (w0 >>> 16);
  470.    var w2 = (x.h & 0xffff) + (y.h & 0xffff) + (w1 >>> 16);
  471.    var w3 = (x.h >>> 16) + (y.h >>> 16) + (w2 >>> 16);
  472.    dst.l = (w0 & 0xffff) | (w1 << 16);
  473.    dst.h = (w2 & 0xffff) | (w3 << 16);
  474. }
  475.  
  476. //Same, except with 4 addends. Works faster than adding them one by one.
  477. function int64add4(dst, a, b, c, d)
  478. {
  479.    var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff);
  480.    var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (w0 >>> 16);
  481.    var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (w1 >>> 16);
  482.    var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (w2 >>> 16);
  483.    dst.l = (w0 & 0xffff) | (w1 << 16);
  484.    dst.h = (w2 & 0xffff) | (w3 << 16);
  485. }
  486.  
  487. //Same, except with 5 addends
  488. function int64add5(dst, a, b, c, d, e)
  489. {
  490.    var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff) + (e.l & 0xffff);
  491.    var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (e.l >>> 16) + (w0 >>> 16);
  492.    var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (e.h & 0xffff) + (w1 >>> 16);
  493.    var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (e.h >>> 16) + (w2 >>> 16);
  494.    dst.l = (w0 & 0xffff) | (w1 << 16);
  495.    dst.h = (w2 & 0xffff) | (w3 << 16);
  496. }
Add Comment
Please, Sign In to add comment
Public Pastes
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!