- add crypto-js library(for new hash access method).

[feedblog/feedblog.git] / js / crypto-js / components / sha256.js

diff --git a/js/crypto-js/components/sha256.js b/js/crypto-js/components/sha256.js
new file mode 100644 (file)
index 0000000..16cee0c
--- /dev/null
+++ b/js/crypto-js/components/sha256.js
@@ -0,0 +1,185 @@
+/*
+CryptoJS v3.1.2
+code.google.com/p/crypto-js
+(c) 2009-2013 by Jeff Mott. All rights reserved.
+code.google.com/p/crypto-js/wiki/License
+*/
+(function (Math) {\r
+    // Shortcuts\r
+    var C = CryptoJS;\r
+    var C_lib = C.lib;\r
+    var WordArray = C_lib.WordArray;\r
+    var Hasher = C_lib.Hasher;\r
+    var C_algo = C.algo;\r
+\r
+    // Initialization and round constants tables\r
+    var H = [];\r
+    var K = [];\r
+\r
+    // Compute constants\r
+    (function () {\r
+        function isPrime(n) {\r
+            var sqrtN = Math.sqrt(n);\r
+            for (var factor = 2; factor <= sqrtN; factor++) {\r
+                if (!(n % factor)) {\r
+                    return false;\r
+                }\r
+            }\r
+\r
+            return true;\r
+        }\r
+\r
+        function getFractionalBits(n) {\r
+            return ((n - (n | 0)) * 0x100000000) | 0;\r
+        }\r
+\r
+        var n = 2;\r
+        var nPrime = 0;\r
+        while (nPrime < 64) {\r
+            if (isPrime(n)) {\r
+                if (nPrime < 8) {\r
+                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));\r
+                }\r
+                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));\r
+\r
+                nPrime++;\r
+            }\r
+\r
+            n++;\r
+        }\r
+    }());\r
+\r
+    // Reusable object\r
+    var W = [];\r
+\r
+    /**\r
+     * SHA-256 hash algorithm.\r
+     */\r
+    var SHA256 = C_algo.SHA256 = Hasher.extend({\r
+        _doReset: function () {\r
+            this._hash = new WordArray.init(H.slice(0));\r
+        },\r
+\r
+        _doProcessBlock: function (M, offset) {\r
+            // Shortcut\r
+            var H = this._hash.words;\r
+\r
+            // Working variables\r
+            var a = H[0];\r
+            var b = H[1];\r
+            var c = H[2];\r
+            var d = H[3];\r
+            var e = H[4];\r
+            var f = H[5];\r
+            var g = H[6];\r
+            var h = H[7];\r
+\r
+            // Computation\r
+            for (var i = 0; i < 64; i++) {\r
+                if (i < 16) {\r
+                    W[i] = M[offset + i] | 0;\r
+                } else {\r
+                    var gamma0x = W[i - 15];\r
+                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^\r
+                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^\r
+                                   (gamma0x >>> 3);\r
+\r
+                    var gamma1x = W[i - 2];\r
+                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^\r
+                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^\r
+                                   (gamma1x >>> 10);\r
+\r
+                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\r
+                }\r
+\r
+                var ch  = (e & f) ^ (~e & g);\r
+                var maj = (a & b) ^ (a & c) ^ (b & c);\r
+\r
+                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));\r
+                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));\r
+\r
+                var t1 = h + sigma1 + ch + K[i] + W[i];\r
+                var t2 = sigma0 + maj;\r
+\r
+                h = g;\r
+                g = f;\r
+                f = e;\r
+                e = (d + t1) | 0;\r
+                d = c;\r
+                c = b;\r
+                b = a;\r
+                a = (t1 + t2) | 0;\r
+            }\r
+\r
+            // Intermediate hash value\r
+            H[0] = (H[0] + a) | 0;\r
+            H[1] = (H[1] + b) | 0;\r
+            H[2] = (H[2] + c) | 0;\r
+            H[3] = (H[3] + d) | 0;\r
+            H[4] = (H[4] + e) | 0;\r
+            H[5] = (H[5] + f) | 0;\r
+            H[6] = (H[6] + g) | 0;\r
+            H[7] = (H[7] + h) | 0;\r
+        },\r
+\r
+        _doFinalize: function () {\r
+            // Shortcuts\r
+            var data = this._data;\r
+            var dataWords = data.words;\r
+\r
+            var nBitsTotal = this._nDataBytes * 8;\r
+            var nBitsLeft = data.sigBytes * 8;\r
+\r
+            // Add padding\r
+            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);\r
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\r
+            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;\r
+            data.sigBytes = dataWords.length * 4;\r
+\r
+            // Hash final blocks\r
+            this._process();\r
+\r
+            // Return final computed hash\r
+            return this._hash;\r
+        },\r
+\r
+        clone: function () {\r
+            var clone = Hasher.clone.call(this);\r
+            clone._hash = this._hash.clone();\r
+\r
+            return clone;\r
+        }\r
+    });\r
+\r
+    /**\r
+     * Shortcut function to the hasher's object interface.\r
+     *\r
+     * @param {WordArray|string} message The message to hash.\r
+     *\r
+     * @return {WordArray} The hash.\r
+     *\r
+     * @static\r
+     *\r
+     * @example\r
+     *\r
+     *     var hash = CryptoJS.SHA256('message');\r
+     *     var hash = CryptoJS.SHA256(wordArray);\r
+     */\r
+    C.SHA256 = Hasher._createHelper(SHA256);\r
+\r
+    /**\r
+     * Shortcut function to the HMAC's object interface.\r
+     *\r
+     * @param {WordArray|string} message The message to hash.\r
+     * @param {WordArray|string} key The secret key.\r
+     *\r
+     * @return {WordArray} The HMAC.\r
+     *\r
+     * @static\r
+     *\r
+     * @example\r
+     *\r
+     *     var hmac = CryptoJS.HmacSHA256(message, key);\r
+     */\r
+    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);\r
+}(Math));\r