DIV CSS 佈局教程網

JavaScript 實作 SHA-512 與 SHA-256 加密演算法完整解析
編輯:關於JavaScript     

瀏覽器端有時需要先算出一段內容的雜湊值再送出,例如表單簽章、檔案完整性校驗。以下示範以純 JavaScript 實作 FIPS 180-2 定義的 SHA-512 與 SHA-256,並附上 HMAC 變體與 64 位元運算的處理技巧。

可配置參數與對外介面

兩份實作都沿用 Paul Johnston 的經典結構,開頭兩個全域變數控制輸出樣式:hexcase 決定十六進位是小寫(0)還是大寫(1),b64pad 決定 Base64 的補位字元。對外則提供 hex、Base64、自訂編碼三種輸出,以及對應的 HMAC 版本。

/* 可配置參數:多數情況用預設值即可相容於後端 */
var hexcase = 0;  /* 0 - 小寫;1 - 大寫 */
var b64pad = "";  /* 嚴格 RFC 合規時填 "=" */

/* 一般會直接呼叫的函式,輸入字串,回傳 hex 或 base-64 */
function hex_sha512(s) { return rstr2hex(rstr_sha512(str2rstr_utf8(s))); }
function b64_sha512(s) { return rstr2b64(rstr_sha512(str2rstr_utf8(s))); }
function any_sha512(s, e) { return rstr2any(rstr_sha512(str2rstr_utf8(s)), e); }
function hex_hmac_sha512(k, d) { return rstr2hex(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d))); }
function b64_hmac_sha512(k, d) { return rstr2b64(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d))); }
function any_hmac_sha512(k, d, e) { return rstr2any(rstr_hmac_sha512(str2rstr_utf8(k), str2rstr_utf8(d)), e); }

/* 簡單自我測試,用來確認執行環境的位元運算正常 */
function sha512_vm_test() {
  return hex_sha512("abc").toLowerCase() ==
    "ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a" +
    "2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f";
}

/* 對原始字串求 SHA-512 */
function rstr_sha512(s) { return binb2rstr(binb_sha512(rstr2binb(s), s.length * 8)); }

/* 對「金鑰 + 資料」求 HMAC-SHA-512 */
function rstr_hmac_sha512(key, data) {
  var bkey = rstr2binb(key);
  if (bkey.length > 32) bkey = binb_sha512(bkey, key.length * 8);
  var ipad = Array(32), opad = Array(32);
  for (var i = 0; i < 32; i++) {
    ipad[i] = bkey[i] ^ 0x36363636;
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
  }
  var hash = binb_sha512(ipad.concat(rstr2binb(data)), 1024 + data.length * 8);
  return binb2rstr(binb_sha512(opad.concat(hash), 1024 + 512));
}

編碼轉換層

雜湊演算法只吃位元,所以還需要一層編碼轉換:把字串轉成 UTF-8、轉成大端序整數陣列,運算完再轉回十六進位或 Base64。

/* 原始字串 → 十六進位字串 */
function rstr2hex(input) {
  try { hexcase } catch (e) { hexcase = 0; }
  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
  var output = "", x;
  for (var i = 0; i < input.length; i++) {
    x = input.charCodeAt(i);
    output += hex_tab.charAt((x >>> 4) & 0x0F) + hex_tab.charAt(x & 0x0F);
  }
  return output;
}

/* 原始字串 → Base64 */
function rstr2b64(input) {
  try { b64pad } catch (e) { b64pad = ''; }
  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  var output = "", len = input.length;
  for (var i = 0; i < len; i += 3) {
    var triplet = (input.charCodeAt(i) << 16)
      | (i + 1 < len ? input.charCodeAt(i + 1) << 8 : 0)
      | (i + 2 < len ? input.charCodeAt(i + 2) : 0);
    for (var j = 0; j < 4; j++) {
      if (i * 8 + j * 6 > input.length * 8) output += b64pad;
      else output += tab.charAt((triplet >>> 6 * (3 - j)) & 0x3F);
    }
  }
  return output;
}

/* 原始字串 → 任意字元集編碼(以長除法實作進位轉換) */
function rstr2any(input, encoding) {
  var divisor = encoding.length;
  var i, j, q, x, quotient;
  var dividend = Array(Math.ceil(input.length / 2));
  for (i = 0; i < dividend.length; i++) {
    dividend[i] = (input.charCodeAt(i * 2) << 8) | input.charCodeAt(i * 2 + 1);
  }
  var full_length = Math.ceil(input.length * 8 / (Math.log(encoding.length) / Math.log(2)));
  var remainders = Array(full_length);
  for (j = 0; j < full_length; j++) {
    quotient = Array();
    x = 0;
    for (i = 0; i < dividend.length; i++) {
      x = (x << 16) + dividend[i];
      q = Math.floor(x / divisor);
      x -= q * divisor;
      if (quotient.length > 0 || q > 0) quotient[quotient.length] = q;
    }
    remainders[j] = x;
    dividend = quotient;
  }
  var output = "";
  for (i = remainders.length - 1; i >= 0; i--) output += encoding.charAt(remainders[i]);
  return output;
}

/* 以 UTF-8 編碼,含 UTF-16 代理對處理 */
function str2rstr_utf8(input) {
  var output = "", i = -1, x, y;
  while (++i < input.length) {
    x = input.charCodeAt(i);
    y = i + 1 < input.length ? input.charCodeAt(i + 1) : 0;
    if (0xD800 <= x && x <= 0xDBFF && 0xDC00 <= y && y <= 0xDFFF) {
      x = 0x10000 + ((x & 0x03FF) << 10) + (y & 0x03FF);
      i++;
    }
    if (x <= 0x7F) output += String.fromCharCode(x);
    else if (x <= 0x7FF) output += String.fromCharCode(0xC0 | ((x >>> 6) & 0x1F), 0x80 | (x & 0x3F));
    else if (x <= 0xFFFF) output += String.fromCharCode(0xE0 | ((x >>> 12) & 0x0F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F));
    else if (x <= 0x1FFFFF) output += String.fromCharCode(0xF0 | ((x >>> 18) & 0x07), 0x80 | ((x >>> 12) & 0x3F), 0x80 | ((x >>> 6) & 0x3F), 0x80 | (x & 0x3F));
  }
  return output;
}

function str2rstr_utf16le(input) {
  var output = "";
  for (var i = 0; i < input.length; i++)
    output += String.fromCharCode(input.charCodeAt(i) & 0xFF, (input.charCodeAt(i) >>> 8) & 0xFF);
  return output;
}

function str2rstr_utf16be(input) {
  var output = "";
  for (var i = 0; i < input.length; i++)
    output += String.fromCharCode((input.charCodeAt(i) >>> 8) & 0xFF, input.charCodeAt(i) & 0xFF);
  return output;
}

/* 原始字串 → 大端序整數陣列(大於 255 的位元組會被忽略) */
function rstr2binb(input) {
  var output = Array(input.length >> 2);
  for (var i = 0; i < output.length; i++) output[i] = 0;
  for (var i = 0; i < input.length * 8; i += 8)
    output[i >> 5] |= (input.charCodeAt(i / 8) & 0xFF) << (24 - i % 32);
  return output;
}

/* 大端序整數陣列 → 原始字串 */
function binb2rstr(input) {
  var output = "";
  for (var i = 0; i < input.length * 32; i += 8)
    output += String.fromCharCode((input[i >> 5] >>> (24 - i % 32)) & 0xFF);
  return output;
}

SHA-512 主體與 64 位元運算

SHA-512 的難點在於 JavaScript 沒有原生 64 位元整數。這裡的做法是自建 int64 物件,用高、低兩個 32 位元組分別存放,並把加法拆成 16 位元一組來避免溢位。80 個輪常數 sha512_k 與 8 個初始雜湊值都以此形式定義。

var sha512_k;
function binb_sha512(x, len) {
  if (sha512_k == undefined) {
    // SHA-512 的 80 個輪常數,每個都是一個 int64(高, 低)
    sha512_k = new Array(
      new int64(0x428a2f98, -685199838), new int64(0x71374491, 0x23ef65cd),
      new int64(-1245643825, -330482897), new int64(-373957723, -2121671748),
      new int64(0x3956c25b, -213338824), new int64(0x59f111f1, -1241133031),
      new int64(-1841331548, -1357295717), new int64(-1424204075, -630357736),
      new int64(-670586216, -1560083902), new int64(0x12835b01, 0x45706fbe),
      new int64(0x243185be, 0x4ee4b28c), new int64(0x550c7dc3, -704662302),
      new int64(0x72be5d74, -226784913), new int64(-2132889090, 0x3b1696b1),
      new int64(-1680079193, 0x25c71235), new int64(-1046744716, -815192428),
      new int64(-459576895, -1628353838), new int64(-272742522, 0x384f25e3),
      new int64(0xfc19dc6, -1953704523), new int64(0x240ca1cc, 0x77ac9c65),
      new int64(0x2de92c6f, 0x592b0275), new int64(0x4a7484aa, 0x6ea6e483),
      new int64(0x5cb0a9dc, -1119749164), new int64(0x76f988da, -2096016459),
      new int64(-1740746414, -295247957), new int64(-1473132947, 0x2db43210),
      new int64(-1341970488, -1728372417), new int64(-1084653625, -1091629340),
      new int64(-958395405, 0x3da88fc2), new int64(-710438585, -1828018395),
      new int64(0x6ca6351, -536640913), new int64(0x14292967, 0xa0e6e70),
      new int64(0x27b70a85, 0x46d22ffc), new int64(0x2e1b2138, 0x5c26c926),
      new int64(0x4d2c6dfc, 0x5ac42aed), new int64(0x53380d13, -1651133473),
      new int64(0x650a7354, -1951439906), new int64(0x766a0abb, 0x3c77b2a8),
      new int64(-2117940946, 0x47edaee6), new int64(-1838011259, 0x1482353b),
      new int64(-1564481375, 0x4cf10364), new int64(-1474664885, -1136513023),
      new int64(-1035236496, -789014639), new int64(-949202525, 0x654be30),
      new int64(-778901479, -688958952), new int64(-694614492, 0x5565a910),
      new int64(-200395387, 0x5771202a), new int64(0x106aa070, 0x32bbd1b8),
      new int64(0x19a4c116, -1194143544), new int64(0x1e376c08, 0x5141ab53),
      new int64(0x2748774c, -544281703), new int64(0x34b0bcb5, -509917016),
      new int64(0x391c0cb3, -976659869), new int64(0x4ed8aa4a, -482243893),
      new int64(0x5b9cca4f, 0x7763e373), new int64(0x682e6ff3, -692930397),
      new int64(0x748f82ee, 0x5defb2fc), new int64(0x78a5636f, 0x43172f60),
      new int64(-2067236844, -1578062990), new int64(-1933114872, 0x1a6439ec),
      new int64(-1866530822, 0x23631e28), new int64(-1538233109, -561857047),
      new int64(-1090935817, -1295615723), new int64(-965641998, -479046869),
      new int64(-903397682, -366583396), new int64(-779700025, 0x21c0c207),
      new int64(-354779690, -840897762), new int64(-176337025, -294727304),
      new int64(0x6f067aa, 0x72176fba), new int64(0xa637dc5, -1563912026),
      new int64(0x113f9804, -1090974290), new int64(0x1b710b35, 0x131c471b),
      new int64(0x28db77f5, 0x23047d84), new int64(0x32caab7b, 0x40c72493),
      new int64(0x3c9ebe0a, 0x15c9bebc), new int64(0x431d67c4, -1676669620),
      new int64(0x4cc5d4be, -885112138), new int64(0x597f299c, -60457430),
      new int64(0x5fcb6fab, 0x3ad6faec), new int64(0x6c44198c, 0x4a475817));
  }

  // 初始雜湊值
  var H = new Array(
    new int64(0x6a09e667, -205731576), new int64(-1150833019, -2067093701),
    new int64(0x3c6ef372, -23791573), new int64(-1521486534, 0x5f1d36f1),
    new int64(0x510e527f, -1377402159), new int64(-1694144372, 0x2b3e6c1f),
    new int64(0x1f83d9ab, -79577749), new int64(0x5be0cd19, 0x137e2179));

  var T1 = new int64(0, 0), T2 = new int64(0, 0);
  var a = new int64(0, 0), b = new int64(0, 0), c = new int64(0, 0), d = new int64(0, 0);
  var e = new int64(0, 0), f = new int64(0, 0), g = new int64(0, 0), h = new int64(0, 0);
  var s0 = new int64(0, 0), s1 = new int64(0, 0);
  var Ch = new int64(0, 0), Maj = new int64(0, 0);
  var r1 = new int64(0, 0), r2 = new int64(0, 0), r3 = new int64(0, 0);
  var j, i;
  var W = new Array(80);
  for (i = 0; i < 80; i++) W[i] = new int64(0, 0);

  // 依 FIPS 規格補上 padding
  x[len >> 5] |= 0x80 << (24 - (len & 0x1f));
  x[((len + 128 >> 10) << 5) + 31] = len;

  for (i = 0; i < x.length; i += 32) {   // 32 個 dword 為一個區塊
    int64copy(a, H[0]); int64copy(b, H[1]); int64copy(c, H[2]); int64copy(d, H[3]);
    int64copy(e, H[4]); int64copy(f, H[5]); int64copy(g, H[6]); int64copy(h, H[7]);

    for (j = 0; j < 16; j++) {
      W[j].h = x[i + 2 * j];
      W[j].l = x[i + 2 * j + 1];
    }
    for (j = 16; j < 80; j++) {
      // sigma1
      int64rrot(r1, W[j - 2], 19); int64revrrot(r2, W[j - 2], 29); int64shr(r3, W[j - 2], 6);
      s1.l = r1.l ^ r2.l ^ r3.l; s1.h = r1.h ^ r2.h ^ r3.h;
      // sigma0
      int64rrot(r1, W[j - 15], 1); int64rrot(r2, W[j - 15], 8); int64shr(r3, W[j - 15], 7);
      s0.l = r1.l ^ r2.l ^ r3.l; s0.h = r1.h ^ r2.h ^ r3.h;
      int64add4(W[j], s1, W[j - 7], s0, W[j - 16]);
    }

    for (j = 0; j < 80; j++) {
      // Ch
      Ch.l = (e.l & f.l) ^ (~e.l & g.l);
      Ch.h = (e.h & f.h) ^ (~e.h & g.h);
      // Sigma1
      int64rrot(r1, e, 14); int64rrot(r2, e, 18); int64revrrot(r3, e, 9);
      s1.l = r1.l ^ r2.l ^ r3.l; s1.h = r1.h ^ r2.h ^ r3.h;
      // Sigma0
      int64rrot(r1, a, 28); int64revrrot(r2, a, 2); int64revrrot(r3, a, 7);
      s0.l = r1.l ^ r2.l ^ r3.l; s0.h = r1.h ^ r2.h ^ r3.h;
      // Maj
      Maj.l = (a.l & b.l) ^ (a.l & c.l) ^ (b.l & c.l);
      Maj.h = (a.h & b.h) ^ (a.h & c.h) ^ (b.h & c.h);

      int64add5(T1, h, s1, Ch, sha512_k[j], W[j]);
      int64add(T2, s0, Maj);

      int64copy(h, g); int64copy(g, f); int64copy(f, e);
      int64add(e, d, T1);
      int64copy(d, c); int64copy(c, b); int64copy(b, a);
      int64add(a, T1, T2);
    }

    int64add(H[0], H[0], a); int64add(H[1], H[1], b);
    int64add(H[2], H[2], c); int64add(H[3], H[3], d);
    int64add(H[4], H[4], e); int64add(H[5], H[5], f);
    int64add(H[6], H[6], g); int64add(H[7], H[7], h);
  }

  // 輸出為 16 個 32 位元的 dword
  var hash = new Array(16);
  for (i = 0; i < 8; i++) { hash[2 * i] = H[i].h; hash[2 * i + 1] = H[i].l; }
  return hash;
}

/* 64 位元數的建構子:h 為高 32 位元,l 為低 32 位元 */
function int64(h, l) { this.h = h; this.l = l; }

function int64copy(dst, src) { dst.h = src.h; dst.l = src.l; }

/* 向右循環位移,shift 需小於 32 */
function int64rrot(dst, x, shift) {
  dst.l = (x.l >>> shift) | (x.h << (32 - shift));
  dst.h = (x.h >>> shift) | (x.l << (32 - shift));
}

/* 先交換高低兩個 dword 再右旋,等效於旋轉 32 + shift */
function int64revrrot(dst, x, shift) {
  dst.l = (x.h >>> shift) | (x.l << (32 - shift));
  dst.h = (x.l >>> shift) | (x.h << (32 - shift));
}

/* 向右位移(不循環),shift 需小於 32 */
function int64shr(dst, x, shift) {
  dst.l = (x.l >>> shift) | (x.h << (32 - shift));
  dst.h = (x.h >>> shift);
}

/* 兩個 64 位元數相加,拆成 16 位元分組避免溢位 */
function int64add(dst, x, y) {
  var w0 = (x.l & 0xffff) + (y.l & 0xffff);
  var w1 = (x.l >>> 16) + (y.l >>> 16) + (w0 >>> 16);
  var w2 = (x.h & 0xffff) + (y.h & 0xffff) + (w1 >>> 16);
  var w3 = (x.h >>> 16) + (y.h >>> 16) + (w2 >>> 16);
  dst.l = (w0 & 0xffff) | (w1 << 16);
  dst.h = (w2 & 0xffff) | (w3 << 16);
}

/* 四個加數版本,比逐一相加快 */
function int64add4(dst, a, b, c, d) {
  var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff);
  var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (w0 >>> 16);
  var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (w1 >>> 16);
  var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (w2 >>> 16);
  dst.l = (w0 & 0xffff) | (w1 << 16);
  dst.h = (w2 & 0xffff) | (w3 << 16);
}

/* 五個加數版本 */
function int64add5(dst, a, b, c, d, e) {
  var w0 = (a.l & 0xffff) + (b.l & 0xffff) + (c.l & 0xffff) + (d.l & 0xffff) + (e.l & 0xffff);
  var w1 = (a.l >>> 16) + (b.l >>> 16) + (c.l >>> 16) + (d.l >>> 16) + (e.l >>> 16) + (w0 >>> 16);
  var w2 = (a.h & 0xffff) + (b.h & 0xffff) + (c.h & 0xffff) + (d.h & 0xffff) + (e.h & 0xffff) + (w1 >>> 16);
  var w3 = (a.h >>> 16) + (b.h >>> 16) + (c.h >>> 16) + (d.h >>> 16) + (e.h >>> 16) + (w2 >>> 16);
  dst.l = (w0 & 0xffff) | (w1 << 16);
  dst.h = (w2 & 0xffff) | (w3 << 16);
}

SHA-256 實作

SHA-256 只處理 32 位元,因此不需要自建整數型別,程式碼短得多。它同樣有 64 個輪常數,並以 8 個初始雜湊值起算,每個區塊 16 個 word 展開成 64 個。

function hex_sha256(s) { return rstr2hex(rstr_sha256(str2rstr_utf8(s))); }
function b64_sha256(s) { return rstr2b64(rstr_sha256(str2rstr_utf8(s))); }
function any_sha256(s, e) { return rstr2any(rstr_sha256(str2rstr_utf8(s)), e); }
function hex_hmac_sha256(k, d) { return rstr2hex(rstr_hmac_sha256(str2rstr_utf8(k), str2rstr_utf8(d))); }
function b64_hmac_sha256(k, d) { return rstr2b64(rstr_hmac_sha256(str2rstr_utf8(k), str2rstr_utf8(d))); }
function any_hmac_sha256(k, d, e) { return rstr2any(rstr_hmac_sha256(str2rstr_utf8(k), str2rstr_utf8(d)), e); }

function sha256_vm_test() {
  return hex_sha256("abc").toLowerCase() ==
    "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad";
}

function rstr_sha256(s) { return binb2rstr(binb_sha256(rstr2binb(s), s.length * 8)); }

function rstr_hmac_sha256(key, data) {
  var bkey = rstr2binb(key);
  if (bkey.length > 16) bkey = binb_sha256(bkey, key.length * 8);
  var ipad = Array(16), opad = Array(16);
  for (var i = 0; i < 16; i++) {
    ipad[i] = bkey[i] ^ 0x36363636;
    opad[i] = bkey[i] ^ 0x5C5C5C5C;
  }
  var hash = binb_sha256(ipad.concat(rstr2binb(data)), 512 + data.length * 8);
  return binb2rstr(binb_sha256(opad.concat(hash), 512 + 256));
}

/*  SHA-256 的辅助函数(此处编码转换函数与 SHA-512 版本完全相同,直接复用) */

function sha256_S(X, n) { return (X >>> n) | (X << (32 - n)); }
function sha256_R(X, n) { return (X >>> n); }
function sha256_Ch(x, y, z) { return ((x & y) ^ ((~x) & z)); }
function sha256_Maj(x, y, z) { return ((x & y) ^ (x & z) ^ (y & z)); }
function sha256_Sigma0256(x) { return (sha256_S(x, 2) ^ sha256_S(x, 13) ^ sha256_S(x, 22)); }
function sha256_Sigma1256(x) { return (sha256_S(x, 6) ^ sha256_S(x, 11) ^ sha256_S(x, 25)); }
function sha256_Gamma0256(x) { return (sha256_S(x, 7) ^ sha256_S(x, 18) ^ sha256_R(x, 3)); }
function sha256_Gamma1256(x) { return (sha256_S(x, 17) ^ sha256_S(x, 19) ^ sha256_R(x, 10)); }
function sha256_Sigma0512(x) { return (sha256_S(x, 28) ^ sha256_S(x, 34) ^ sha256_S(x, 39)); }
function sha256_Sigma1512(x) { return (sha256_S(x, 14) ^ sha256_S(x, 18) ^ sha256_S(x, 41)); }
function sha256_Gamma0512(x) { return (sha256_S(x, 1) ^ sha256_S(x, 8) ^ sha256_R(x, 7)); }
function sha256_Gamma1512(x) { return (sha256_S(x, 19) ^ sha256_S(x, 61) ^ sha256_R(x, 6)); }

var sha256_K = new Array(
  1116352408, 1899447441, -1245643825, -373957723, 961987163, 1508970993,
  -1841331548, -1424204075, -670586216, 310598401, 607225278, 1426881987,
  1925078388, -2132889090, -1680079193, -1046744716, -459576895, -272742522,
  264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,
  -1740746414, -1473132947, -1341970488, -1084653625, -958395405, -710438585,
  113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291,
  1695183700, 1986661051, -2117940946, -1838011259, -1564481375, -1474664885,
  -1035236496, -949202525, -778901479, -694614492, -200395387, 275423344,
  430227734, 506948616, 659060556, 883997877, 958139571, 1322822218,
  1537002063, 1747873779, 1955562222, 2024104815, -2067236844, -1933114872,
  -1866530822, -1538233109, -1090935817, -965641998);

function binb_sha256(m, l) {
  var HASH = new Array(1779033703, -1150833019, 1013904242, -1521486534,
    1359893119, -1694144372, 528734635, 1541459225);
  var W = new Array(64);
  var a, b, c, d, e, f, g, h;
  var i, j, T1, T2;

  /* 補 padding */
  m[l >> 5] |= 0x80 << (24 - l % 32);
  m[((l + 64 >> 9) << 4) + 15] = l;

  for (i = 0; i < m.length; i += 16) {
    a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3];
    e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];

    for (j = 0; j < 64; j++) {
      if (j < 16) W[j] = m[j + i];
      else W[j] = safe_add(safe_add(safe_add(sha256_Gamma1256(W[j - 2]), W[j - 7]),
        sha256_Gamma0256(W[j - 15])), W[j - 16]);

      T1 = safe_add(safe_add(safe_add(safe_add(h, sha256_Sigma1256(e)),
        sha256_Ch(e, f, g)), sha256_K[j]), W[j]);
      T2 = safe_add(sha256_Sigma0256(a), sha256_Maj(a, b, c));

      h = g; g = f; f = e; e = safe_add(d, T1);
      d = c; c = b; b = a; a = safe_add(T1, T2);
    }

    HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]);
    HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);
    HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]);
    HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);
  }
  return HASH;
}

/* 32 位元安全加法,避開 JS 位元運算的溢位問題 */
function safe_add(x, y) {
  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
  return (msw << 16) | (lsw & 0xFFFF);
}

使用上的提醒

這兩份實作皆以 BSD 授權發布,出處為 https://pajhome.org.uk/crypt/md5/ 與 https://anmar.eu.org/projects/jssha2/,商用前請保留授權聲明。另外要留意兩點:一是 SHA-256 與 SHA-512 共用 hexcase、b64pad、rstr2hex 等同名函式,同一頁面只能擇一載入,否則後者會覆蓋前者;二是純 JavaScript 雜湊在效能上遠不如原生 API,若只是要計算摘要,優先考慮 crypto.subtle.digest()。SHA-1 與 MD5 已被證明存在碰撞風險,不要用於簽章或個資保護場景。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved