pax_global_header00006660000000000000000000000064131050546450014515gustar00rootroot0000000000000052 comment=d78f61ebe25078d0020cd4b7088a9e745078db30 createHash-1.1.3/000077500000000000000000000000001310505464500135665ustar00rootroot00000000000000createHash-1.1.3/.gitignore000066400000000000000000000000151310505464500155520ustar00rootroot00000000000000node_modules createHash-1.1.3/.travis.yml000066400000000000000000000003261310505464500157000ustar00rootroot00000000000000sudo: false language: node_js before_install: - "npm install npm -g" node_js: - "0.10" - "0.12" - "4" - "5" - "6" env: - TEST_SUITE=standard - TEST_SUITE=unit script: "npm run-script $TEST_SUITE" createHash-1.1.3/browser.js000066400000000000000000000020121310505464500156020ustar00rootroot00000000000000'use strict' var inherits = require('inherits') var md5 = require('./md5') var RIPEMD160 = require('ripemd160') var sha = require('sha.js') var Base = require('cipher-base') function HashNoConstructor (hash) { Base.call(this, 'digest') this._hash = hash this.buffers = [] } inherits(HashNoConstructor, Base) HashNoConstructor.prototype._update = function (data) { this.buffers.push(data) } HashNoConstructor.prototype._final = function () { var buf = Buffer.concat(this.buffers) var r = this._hash(buf) this.buffers = null return r } function Hash (hash) { Base.call(this, 'digest') this._hash = hash } inherits(Hash, Base) Hash.prototype._update = function (data) { this._hash.update(data) } Hash.prototype._final = function () { return this._hash.digest() } module.exports = function createHash (alg) { alg = alg.toLowerCase() if (alg === 'md5') return new HashNoConstructor(md5) if (alg === 'rmd160' || alg === 'ripemd160') return new Hash(new RIPEMD160()) return new Hash(sha(alg)) } createHash-1.1.3/index.js000066400000000000000000000000561310505464500152340ustar00rootroot00000000000000module.exports = require('crypto').createHash createHash-1.1.3/make-hash.js000066400000000000000000000012521310505464500157620ustar00rootroot00000000000000'use strict' var intSize = 4 var zeroBuffer = new Buffer(intSize) zeroBuffer.fill(0) var charSize = 8 var hashSize = 16 function toArray (buf) { if ((buf.length % intSize) !== 0) { var len = buf.length + (intSize - (buf.length % intSize)) buf = Buffer.concat([buf, zeroBuffer], len) } var arr = new Array(buf.length >>> 2) for (var i = 0, j = 0; i < buf.length; i += intSize, j++) { arr[j] = buf.readInt32LE(i) } return arr } module.exports = function hash (buf, fn) { var arr = fn(toArray(buf), buf.length * charSize) buf = new Buffer(hashSize) for (var i = 0; i < arr.length; i++) { buf.writeInt32LE(arr[i], i << 2, true) } return buf } createHash-1.1.3/md5.js000066400000000000000000000124131310505464500146120ustar00rootroot00000000000000'use strict' /* * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message * Digest Algorithm, as defined in RFC 1321. * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002. * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet * Distributed under the BSD License * See http://pajhome.org.uk/crypt/md5 for more info. */ var makeHash = require('./make-hash') /* * Calculate the MD5 of an array of little-endian words, and a bit length */ function core_md5 (x, len) { /* append padding */ x[len >> 5] |= 0x80 << ((len) % 32) x[(((len + 64) >>> 9) << 4) + 14] = len var a = 1732584193 var b = -271733879 var c = -1732584194 var d = 271733878 for (var i = 0; i < x.length; i += 16) { var olda = a var oldb = b var oldc = c var oldd = d a = md5_ff(a, b, c, d, x[i + 0], 7, -680876936) d = md5_ff(d, a, b, c, x[i + 1], 12, -389564586) c = md5_ff(c, d, a, b, x[i + 2], 17, 606105819) b = md5_ff(b, c, d, a, x[i + 3], 22, -1044525330) a = md5_ff(a, b, c, d, x[i + 4], 7, -176418897) d = md5_ff(d, a, b, c, x[i + 5], 12, 1200080426) c = md5_ff(c, d, a, b, x[i + 6], 17, -1473231341) b = md5_ff(b, c, d, a, x[i + 7], 22, -45705983) a = md5_ff(a, b, c, d, x[i + 8], 7, 1770035416) d = md5_ff(d, a, b, c, x[i + 9], 12, -1958414417) c = md5_ff(c, d, a, b, x[i + 10], 17, -42063) b = md5_ff(b, c, d, a, x[i + 11], 22, -1990404162) a = md5_ff(a, b, c, d, x[i + 12], 7, 1804603682) d = md5_ff(d, a, b, c, x[i + 13], 12, -40341101) c = md5_ff(c, d, a, b, x[i + 14], 17, -1502002290) b = md5_ff(b, c, d, a, x[i + 15], 22, 1236535329) a = md5_gg(a, b, c, d, x[i + 1], 5, -165796510) d = md5_gg(d, a, b, c, x[i + 6], 9, -1069501632) c = md5_gg(c, d, a, b, x[i + 11], 14, 643717713) b = md5_gg(b, c, d, a, x[i + 0], 20, -373897302) a = md5_gg(a, b, c, d, x[i + 5], 5, -701558691) d = md5_gg(d, a, b, c, x[i + 10], 9, 38016083) c = md5_gg(c, d, a, b, x[i + 15], 14, -660478335) b = md5_gg(b, c, d, a, x[i + 4], 20, -405537848) a = md5_gg(a, b, c, d, x[i + 9], 5, 568446438) d = md5_gg(d, a, b, c, x[i + 14], 9, -1019803690) c = md5_gg(c, d, a, b, x[i + 3], 14, -187363961) b = md5_gg(b, c, d, a, x[i + 8], 20, 1163531501) a = md5_gg(a, b, c, d, x[i + 13], 5, -1444681467) d = md5_gg(d, a, b, c, x[i + 2], 9, -51403784) c = md5_gg(c, d, a, b, x[i + 7], 14, 1735328473) b = md5_gg(b, c, d, a, x[i + 12], 20, -1926607734) a = md5_hh(a, b, c, d, x[i + 5], 4, -378558) d = md5_hh(d, a, b, c, x[i + 8], 11, -2022574463) c = md5_hh(c, d, a, b, x[i + 11], 16, 1839030562) b = md5_hh(b, c, d, a, x[i + 14], 23, -35309556) a = md5_hh(a, b, c, d, x[i + 1], 4, -1530992060) d = md5_hh(d, a, b, c, x[i + 4], 11, 1272893353) c = md5_hh(c, d, a, b, x[i + 7], 16, -155497632) b = md5_hh(b, c, d, a, x[i + 10], 23, -1094730640) a = md5_hh(a, b, c, d, x[i + 13], 4, 681279174) d = md5_hh(d, a, b, c, x[i + 0], 11, -358537222) c = md5_hh(c, d, a, b, x[i + 3], 16, -722521979) b = md5_hh(b, c, d, a, x[i + 6], 23, 76029189) a = md5_hh(a, b, c, d, x[i + 9], 4, -640364487) d = md5_hh(d, a, b, c, x[i + 12], 11, -421815835) c = md5_hh(c, d, a, b, x[i + 15], 16, 530742520) b = md5_hh(b, c, d, a, x[i + 2], 23, -995338651) a = md5_ii(a, b, c, d, x[i + 0], 6, -198630844) d = md5_ii(d, a, b, c, x[i + 7], 10, 1126891415) c = md5_ii(c, d, a, b, x[i + 14], 15, -1416354905) b = md5_ii(b, c, d, a, x[i + 5], 21, -57434055) a = md5_ii(a, b, c, d, x[i + 12], 6, 1700485571) d = md5_ii(d, a, b, c, x[i + 3], 10, -1894986606) c = md5_ii(c, d, a, b, x[i + 10], 15, -1051523) b = md5_ii(b, c, d, a, x[i + 1], 21, -2054922799) a = md5_ii(a, b, c, d, x[i + 8], 6, 1873313359) d = md5_ii(d, a, b, c, x[i + 15], 10, -30611744) c = md5_ii(c, d, a, b, x[i + 6], 15, -1560198380) b = md5_ii(b, c, d, a, x[i + 13], 21, 1309151649) a = md5_ii(a, b, c, d, x[i + 4], 6, -145523070) d = md5_ii(d, a, b, c, x[i + 11], 10, -1120210379) c = md5_ii(c, d, a, b, x[i + 2], 15, 718787259) b = md5_ii(b, c, d, a, x[i + 9], 21, -343485551) a = safe_add(a, olda) b = safe_add(b, oldb) c = safe_add(c, oldc) d = safe_add(d, oldd) } return [a, b, c, d] } /* * These functions implement the four basic operations the algorithm uses. */ function md5_cmn (q, a, b, x, s, t) { return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s), b) } function md5_ff (a, b, c, d, x, s, t) { return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t) } function md5_gg (a, b, c, d, x, s, t) { return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t) } function md5_hh (a, b, c, d, x, s, t) { return md5_cmn(b ^ c ^ d, a, b, x, s, t) } function md5_ii (a, b, c, d, x, s, t) { return md5_cmn(c ^ (b | (~d)), a, b, x, s, t) } /* * Add integers, wrapping at 2^32. This uses 16-bit operations internally * to work around bugs in some JS interpreters. */ function safe_add (x, y) { var lsw = (x & 0xFFFF) + (y & 0xFFFF) var msw = (x >> 16) + (y >> 16) + (lsw >> 16) return (msw << 16) | (lsw & 0xFFFF) } /* * Bitwise rotate a 32-bit number to the left. */ function bit_rol (num, cnt) { return (num << cnt) | (num >>> (32 - cnt)) } module.exports = function md5 (buf) { return makeHash(buf, core_md5) } createHash-1.1.3/package.json000066400000000000000000000015621310505464500160600ustar00rootroot00000000000000{ "name": "create-hash", "version": "1.1.3", "description": "create hashes for browserify", "browser": "browser.js", "main": "index.js", "scripts": { "standard": "standard", "test": "npm run-script standard && npm run-script unit", "unit": "node test.js | tspec" }, "repository": { "type": "git", "url": "git@github.com:crypto-browserify/createHash.git" }, "keywords": [ "crypto" ], "author": "", "license": "MIT", "bugs": { "url": "https://github.com/crypto-browserify/createHash/issues" }, "homepage": "https://github.com/crypto-browserify/createHash", "devDependencies": { "hash-test-vectors": "^1.3.2", "standard": "^5.3.1", "tap-spec": "^2.1.2", "tape": "^3.0.3" }, "dependencies": { "cipher-base": "^1.0.1", "inherits": "^2.0.1", "ripemd160": "^2.0.0", "sha.js": "^2.4.0" } } createHash-1.1.3/readme.md000066400000000000000000000012631310505464500153470ustar00rootroot00000000000000create-hash === [![Build Status](https://travis-ci.org/crypto-browserify/createHash.svg)](https://travis-ci.org/crypto-browserify/createHash) Node style hashes for use in the browser, with native hash functions in node. Api is the same as hashes in node: ```js var createHash = require('create-hash'); var hash = createHash('sha224'); hash.update('synchronous write'); //optional encoding parameter hash.digest();// synchronously get result with optional encoding parameter hash.write('write to it as a stream'); hash.end();//remember it's a stream hash.read();//only if you ended it as a stream though ``` To get the JavaScript version even in node do `require('create-hash/browser');`createHash-1.1.3/test.js000066400000000000000000000026121310505464500151040ustar00rootroot00000000000000var test = require('tape') var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160', 'ripemd160'] var encodings = ['hex', 'base64'] // ignore binary var vectors = require('hash-test-vectors') vectors.forEach(function (vector) { vector.ripemd160 = vector.rmd160 }) var createHash = require('./browser') algorithms.forEach(function (algorithm) { test('test ' + algorithm + ' against test vectors', function (t) { vectors.forEach(function (obj, i) { var input = new Buffer(obj.input, 'base64') var node = obj[algorithm] var js = createHash(algorithm).update(input).digest('hex') t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node) }) encodings.forEach(function (encoding) { vectors.forEach(function (obj, i) { var input = new Buffer(obj.input, 'base64').toString(encoding) var node = obj[algorithm] var js = createHash(algorithm).update(input, encoding).digest('hex') t.equal(js, node, algorithm + '(testVector[' + i + '], ' + encoding + ') == ' + node) }) }) vectors.forEach(function (obj, i) { var input = new Buffer(obj.input, 'base64') var node = obj[algorithm] var hash = createHash(algorithm) hash.end(input) var js = hash.read().toString('hex') t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node) }) t.end() }) })