diff options
Diffstat (limited to 'node_modules/crypto-browserify')
21 files changed, 1488 insertions, 0 deletions
diff --git a/node_modules/crypto-browserify/.travis.yml b/node_modules/crypto-browserify/.travis.yml new file mode 100644 index 0000000..5ad8439 --- /dev/null +++ b/node_modules/crypto-browserify/.travis.yml @@ -0,0 +1,27 @@ +sudo: false +language: node_js +matrix: + include: + - node_js: '0.11' + env: TEST_SUITE=unit + - node_js: '0.12' + env: TEST_SUITE=unit + - node_js: '4' + env: TEST_SUITE=unit + - node_js: '4' + env: TEST_SUITE=standard + - node_js: '4' + env: TEST_SUITE=browser BROWSER_NAME=ie BROWSER_VERSION="10..latest" + - node_js: '4' + env: TEST_SUITE=browser BROWSER_NAME=chrome BROWSER_VERSION="-2..beta" + - node_js: '4' + env: TEST_SUITE=browser BROWSER_NAME=firefox BROWSER_VERSION="-2..latest" + - node_js: '4' + env: TEST_SUITE=browser BROWSER_NAME=safari BROWSER_VERSION="7..latest" + - node_js: '4' + env: TEST_SUITE=browser BROWSER_NAME=android BROWSER_VERSION="5.0..latest" +script: "npm run-script $TEST_SUITE" +env: + global: + - secure: YHNUDQmx/WiW3gmDcRCfb6KLDeio7Mr5tqPY2kHPdZlBSytsQjNk75ytM4U6Cu8Uk8iEIoj/aFlxiVMpJNA8J4QSUyW/YkbVaIz0+1oywoV0Ht8aRBfZ1jvXfX6789+1Q9c4xaMkYYbJpXSh9JcirsiwmqWd4+IDd7hcESodsDQ= + - secure: Nhj5yejKZxUbtHGZta+GjYWqXGaOZB7ainTkOuGcpXM+OwwjeDpYlTBrwS90Q7hqens7KXVzQM09aDbadpsDCsOo1nyaEigMtomAorZ1UC1CpEoVz1ZuikF9bEhb+/7M9pzuL1fX+Ke9Dx4mPPeb8sf/2SrAu1RqXkSwZV/duAc= diff --git a/node_modules/crypto-browserify/.zuul.yml b/node_modules/crypto-browserify/.zuul.yml new file mode 100644 index 0000000..96d9cfb --- /dev/null +++ b/node_modules/crypto-browserify/.zuul.yml @@ -0,0 +1 @@ +ui: tape diff --git a/node_modules/crypto-browserify/LICENSE b/node_modules/crypto-browserify/LICENSE new file mode 100644 index 0000000..8abb57d --- /dev/null +++ b/node_modules/crypto-browserify/LICENSE @@ -0,0 +1,24 @@ +The MIT License + +Copyright (c) 2013 Dominic Tarr + +Permission is hereby granted, free of charge, +to any person obtaining a copy of this software and +associated documentation files (the "Software"), to +deal in the Software without restriction, including +without limitation the rights to use, copy, modify, +merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom +the Software is furnished to do so, +subject to the following conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR +ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file diff --git a/node_modules/crypto-browserify/README.md b/node_modules/crypto-browserify/README.md new file mode 100644 index 0000000..1b9cf3b --- /dev/null +++ b/node_modules/crypto-browserify/README.md @@ -0,0 +1,50 @@ +# crypto-browserify + +A port of node's `crypto` module to the browser. + +[](https://travis-ci.org/crypto-browserify/crypto-browserify) +[](https://github.com/feross/standard) +[](https://saucelabs.com/u/crypto-browserify) + +The goal of this module is to reimplement node's crypto module, +in pure javascript so that it can run in the browser. + +Here is the subset that is currently implemented: + +* createHash (sha1, sha224, sha256, sha384, sha512, md5, rmd160) +* createHmac (sha1, sha224, sha256, sha384, sha512, md5, rmd160) +* pbkdf2 +* pbkdf2Sync +* randomBytes +* pseudoRandomBytes +* createCipher (aes) +* createDecipher (aes) +* createDiffieHellman +* createSign (rsa, ecdsa) +* createVerify (rsa, ecdsa) +* createECDH (secp256k1) +* publicEncrypt/privateDecrypt (rsa) +* privateEncrypt/publicDecrypt (rsa) + +## todo + +these features from node's `crypto` are still unimplemented. + +* createCredentials + +## contributions + +If you are interested in writing a feature, please implement as a new module, +which will be incorporated into crypto-browserify as a dependency. + +All deps must be compatible with node's crypto +(generate example inputs and outputs with node, +and save base64 strings inside JSON, so that tests can run in the browser. +see [sha.js](https://github.com/dominictarr/sha.js) + +Crypto is _extra serious_ so please do not hesitate to review the code, +and post comments if you do. + +## License + +MIT diff --git a/node_modules/crypto-browserify/example/bundle.js b/node_modules/crypto-browserify/example/bundle.js new file mode 100644 index 0000000..02698cc --- /dev/null +++ b/node_modules/crypto-browserify/example/bundle.js @@ -0,0 +1,637 @@ +var require = function (file, cwd) { + var resolved = require.resolve(file, cwd || '/'); + var mod = require.modules[resolved]; + if (!mod) throw new Error( + 'Failed to resolve module ' + file + ', tried ' + resolved + ); + var res = mod._cached ? mod._cached : mod(); + return res; +} + +require.paths = []; +require.modules = {}; +require.extensions = [".js",".coffee"]; + +require._core = { + 'assert': true, + 'events': true, + 'fs': true, + 'path': true, + 'vm': true +}; + +require.resolve = (function () { + return function (x, cwd) { + if (!cwd) cwd = '/'; + + if (require._core[x]) return x; + var path = require.modules.path(); + cwd = path.resolve('/', cwd); + var y = cwd || '/'; + + if (x.match(/^(?:\.\.?\/|\/)/)) { + var m = loadAsFileSync(path.resolve(y, x)) + || loadAsDirectorySync(path.resolve(y, x)); + if (m) return m; + } + + var n = loadNodeModulesSync(x, y); + if (n) return n; + + throw new Error("Cannot find module '" + x + "'"); + + function loadAsFileSync (x) { + if (require.modules[x]) { + return x; + } + + for (var i = 0; i < require.extensions.length; i++) { + var ext = require.extensions[i]; + if (require.modules[x + ext]) return x + ext; + } + } + + function loadAsDirectorySync (x) { + x = x.replace(/\/+$/, ''); + var pkgfile = x + '/package.json'; + if (require.modules[pkgfile]) { + var pkg = require.modules[pkgfile](); + var b = pkg.browserify; + if (typeof b === 'object' && b.main) { + var m = loadAsFileSync(path.resolve(x, b.main)); + if (m) return m; + } + else if (typeof b === 'string') { + var m = loadAsFileSync(path.resolve(x, b)); + if (m) return m; + } + else if (pkg.main) { + var m = loadAsFileSync(path.resolve(x, pkg.main)); + if (m) return m; + } + } + + return loadAsFileSync(x + '/index'); + } + + function loadNodeModulesSync (x, start) { + var dirs = nodeModulesPathsSync(start); + for (var i = 0; i < dirs.length; i++) { + var dir = dirs[i]; + var m = loadAsFileSync(dir + '/' + x); + if (m) return m; + var n = loadAsDirectorySync(dir + '/' + x); + if (n) return n; + } + + var m = loadAsFileSync(x); + if (m) return m; + } + + function nodeModulesPathsSync (start) { + var parts; + if (start === '/') parts = [ '' ]; + else parts = path.normalize(start).split('/'); + + var dirs = []; + for (var i = parts.length - 1; i >= 0; i--) { + if (parts[i] === 'node_modules') continue; + var dir = parts.slice(0, i + 1).join('/') + '/node_modules'; + dirs.push(dir); + } + + return dirs; + } + }; +})(); + +require.alias = function (from, to) { + var path = require.modules.path(); + var res = null; + try { + res = require.resolve(from + '/package.json', '/'); + } + catch (err) { + res = require.resolve(from, '/'); + } + var basedir = path.dirname(res); + + var keys = (Object.keys || function (obj) { + var res = []; + for (var key in obj) res.push(key) + return res; + })(require.modules); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (key.slice(0, basedir.length + 1) === basedir + '/') { + var f = key.slice(basedir.length); + require.modules[to + f] = require.modules[basedir + f]; + } + else if (key === basedir) { + require.modules[to] = require.modules[basedir]; + } + } +}; + +require.define = function (filename, fn) { + var dirname = require._core[filename] + ? '' + : require.modules.path().dirname(filename) + ; + + var require_ = function (file) { + return require(file, dirname) + }; + require_.resolve = function (name) { + return require.resolve(name, dirname); + }; + require_.modules = require.modules; + require_.define = require.define; + var module_ = { exports : {} }; + + require.modules[filename] = function () { + require.modules[filename]._cached = module_.exports; + fn.call( + module_.exports, + require_, + module_, + module_.exports, + dirname, + filename + ); + require.modules[filename]._cached = module_.exports; + return module_.exports; + }; +}; + +if (typeof process === 'undefined') process = {}; + +if (!process.nextTick) process.nextTick = (function () { + var queue = []; + var canPost = typeof window !== 'undefined' + && window.postMessage && window.addEventListener + ; + + if (canPost) { + window.addEventListener('message', function (ev) { + if (ev.source === window && ev.data === 'browserify-tick') { + ev.stopPropagation(); + if (queue.length > 0) { + var fn = queue.shift(); + fn(); + } + } + }, true); + } + + return function (fn) { + if (canPost) { + queue.push(fn); + window.postMessage('browserify-tick', '*'); + } + else setTimeout(fn, 0); + }; +})(); + +if (!process.title) process.title = 'browser'; + +if (!process.binding) process.binding = function (name) { + if (name === 'evals') return require('vm') + else throw new Error('No such module') +}; + +if (!process.cwd) process.cwd = function () { return '.' }; + +if (!process.env) process.env = {}; +if (!process.argv) process.argv = []; + +require.define("path", function (require, module, exports, __dirname, __filename) { +function filter (xs, fn) { + var res = []; + for (var i = 0; i < xs.length; i++) { + if (fn(xs[i], i, xs)) res.push(xs[i]); + } + return res; +} + +// resolves . and .. elements in a path array with directory names there +// must be no slashes, empty elements, or device names (c:\) in the array +// (so also no leading and trailing slashes - it does not distinguish +// relative and absolute paths) +function normalizeArray(parts, allowAboveRoot) { + // if the path tries to go above the root, `up` ends up > 0 + var up = 0; + for (var i = parts.length; i >= 0; i--) { + var last = parts[i]; + if (last == '.') { + parts.splice(i, 1); + } else if (last === '..') { + parts.splice(i, 1); + up++; + } else if (up) { + parts.splice(i, 1); + up--; + } + } + + // if the path is allowed to go above the root, restore leading ..s + if (allowAboveRoot) { + for (; up--; up) { + parts.unshift('..'); + } + } + + return parts; +} + +// Regex to split a filename into [*, dir, basename, ext] +// posix version +var splitPathRe = /^(.+\/(?!$)|\/)?((?:.+?)?(\.[^.]*)?)$/; + +// path.resolve([from ...], to) +// posix version +exports.resolve = function() { +var resolvedPath = '', + resolvedAbsolute = false; + +for (var i = arguments.length; i >= -1 && !resolvedAbsolute; i--) { + var path = (i >= 0) + ? arguments[i] + : process.cwd(); + + // Skip empty and invalid entries + if (typeof path !== 'string' || !path) { + continue; + } + + resolvedPath = path + '/' + resolvedPath; + resolvedAbsolute = path.charAt(0) === '/'; +} + +// At this point the path should be resolved to a full absolute path, but +// handle relative paths to be safe (might happen when process.cwd() fails) + +// Normalize the path +resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) { + return !!p; + }), !resolvedAbsolute).join('/'); + + return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.'; +}; + +// path.normalize(path) +// posix version +exports.normalize = function(path) { +var isAbsolute = path.charAt(0) === '/', + trailingSlash = path.slice(-1) === '/'; + +// Normalize the path +path = normalizeArray(filter(path.split('/'), function(p) { + return !!p; + }), !isAbsolute).join('/'); + + if (!path && !isAbsolute) { + path = '.'; + } + if (path && trailingSlash) { + path += '/'; + } + + return (isAbsolute ? '/' : '') + path; +}; + + +// posix version +exports.join = function() { + var paths = Array.prototype.slice.call(arguments, 0); + return exports.normalize(filter(paths, function(p, index) { + return p && typeof p === 'string'; + }).join('/')); +}; + + +exports.dirname = function(path) { + var dir = splitPathRe.exec(path)[1] || ''; + var isWindows = false; + if (!dir) { + // No dirname + return '.'; + } else if (dir.length === 1 || + (isWindows && dir.length <= 3 && dir.charAt(1) === ':')) { + // It is just a slash or a drive letter with a slash + return dir; + } else { + // It is a full dirname, strip trailing slash + return dir.substring(0, dir.length - 1); + } +}; + + +exports.basename = function(path, ext) { + var f = splitPathRe.exec(path)[2] || ''; + // TODO: make this comparison case-insensitive on windows? + if (ext && f.substr(-1 * ext.length) === ext) { + f = f.substr(0, f.length - ext.length); + } + return f; +}; + + +exports.extname = function(path) { + return splitPathRe.exec(path)[3] || ''; +}; + +}); + +require.define("crypto", function (require, module, exports, __dirname, __filename) { +module.exports = require("crypto-browserify") +}); + +require.define("/node_modules/crypto-browserify/package.json", function (require, module, exports, __dirname, __filename) { +module.exports = {} +}); + +require.define("/node_modules/crypto-browserify/index.js", function (require, module, exports, __dirname, __filename) { +var sha = require('./sha') + +var algorithms = { + sha1: { + hex: sha.hex_sha1, + binary: sha.b64_sha1, + ascii: sha.str_sha1 + } +} + +function error () { + var m = [].slice.call(arguments).join(' ') + throw new Error([ + m, + 'we accept pull requests', + 'http://github.com/dominictarr/crypto-browserify' + ].join('\n')) +} + +exports.createHash = function (alg) { + alg = alg || 'sha1' + if(!algorithms[alg]) + error('algorithm:', alg, 'is not yet supported') + var s = '' + _alg = algorithms[alg] + return { + update: function (data) { + s += data + return this + }, + digest: function (enc) { + enc = enc || 'binary' + var fn + if(!(fn = _alg[enc])) + error('encoding:', enc , 'is not yet supported for algorithm', alg) + var r = fn(s) + s = null //not meant to use the hash after you've called digest. + return r + } + } +} +// the least I can do is make error messages for the rest of the node.js/crypto api. +;['createCredentials' +, 'createHmac' +, 'createCypher' +, 'createCypheriv' +, 'createDecipher' +, 'createDecipheriv' +, 'createSign' +, 'createVerify' +, 'createDeffieHellman', +, 'pbkdf2', +, 'randomBytes' ].forEach(function (name) { + exports[name] = function () { + error('sorry,', name, 'is not implemented yet') + } +}) + +}); + +require.define("/node_modules/crypto-browserify/sha.js", function (require, module, exports, __dirname, __filename) { +/* + * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined + * in FIPS PUB 180-1 + * Version 2.1a Copyright Paul Johnston 2000 - 2002. + * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet + * Distributed under the BSD License + * See http://pajhome.org.uk/crypt/md5 for details. + */ + +exports.hex_sha1 = hex_sha1; +exports.b64_sha1 = b64_sha1; +exports.str_sha1 = str_sha1; +exports.hex_hmac_sha1 = hex_hmac_sha1; +exports.b64_hmac_sha1 = b64_hmac_sha1; +exports.str_hmac_sha1 = str_hmac_sha1; + +/* + * Configurable variables. You may need to tweak these to be compatible with + * the server-side, but the defaults work in most cases. + */ +var hexcase = 0; /* hex output format. 0 - lowercase; 1 - uppercase */ +var b64pad = ""; /* base-64 pad character. "=" for strict RFC compliance */ +var chrsz = 8; /* bits per input character. 8 - ASCII; 16 - Unicode */ + +/* + * These are the functions you'll usually want to call + * They take string arguments and return either hex or base-64 encoded strings + */ +function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));} +function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));} +function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));} +function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));} +function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));} +function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));} + +/* + * Perform a simple self-test to see if the VM is working + */ +function sha1_vm_test() +{ + return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d"; +} + +/* + * Calculate the SHA-1 of an array of big-endian words, and a bit length + */ +function core_sha1(x, len) +{ + /* append padding */ + x[len >> 5] |= 0x80 << (24 - len % 32); + x[((len + 64 >> 9) << 4) + 15] = len; + + var w = Array(80); + var a = 1732584193; + var b = -271733879; + var c = -1732584194; + var d = 271733878; + var e = -1009589776; + + for(var i = 0; i < x.length; i += 16) + { + var olda = a; + var oldb = b; + var oldc = c; + var oldd = d; + var olde = e; + + for(var j = 0; j < 80; j++) + { + if(j < 16) w[j] = x[i + j]; + else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1); + var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)), + safe_add(safe_add(e, w[j]), sha1_kt(j))); + e = d; + d = c; + c = rol(b, 30); + b = a; + a = t; + } + + a = safe_add(a, olda); + b = safe_add(b, oldb); + c = safe_add(c, oldc); + d = safe_add(d, oldd); + e = safe_add(e, olde); + } + return Array(a, b, c, d, e); + +} + +/* + * Perform the appropriate triplet combination function for the current + * iteration + */ +function sha1_ft(t, b, c, d) +{ + if(t < 20) return (b & c) | ((~b) & d); + if(t < 40) return b ^ c ^ d; + if(t < 60) return (b & c) | (b & d) | (c & d); + return b ^ c ^ d; +} + +/* + * Determine the appropriate additive constant for the current iteration + */ +function sha1_kt(t) +{ + return (t < 20) ? 1518500249 : (t < 40) ? 1859775393 : + (t < 60) ? -1894007588 : -899497514; +} + +/* + * Calculate the HMAC-SHA1 of a key and some data + */ +function core_hmac_sha1(key, data) +{ + var bkey = str2binb(key); + if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz); + + 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 = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz); + return core_sha1(opad.concat(hash), 512 + 160); +} + +/* + * 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 rol(num, cnt) +{ + return (num << cnt) | (num >>> (32 - cnt)); +} + +/* + * Convert an 8-bit or 16-bit string to an array of big-endian words + * In 8-bit function, characters >255 have their hi-byte silently ignored. + */ +function str2binb(str) +{ + var bin = Array(); + var mask = (1 << chrsz) - 1; + for(var i = 0; i < str.length * chrsz; i += chrsz) + bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32); + return bin; +} + +/* + * Convert an array of big-endian words to a string + */ +function binb2str(bin) +{ + var str = ""; + var mask = (1 << chrsz) - 1; + for(var i = 0; i < bin.length * 32; i += chrsz) + str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask); + return str; +} + +/* + * Convert an array of big-endian words to a hex string. + */ +function binb2hex(binarray) +{ + var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef"; + var str = ""; + for(var i = 0; i < binarray.length * 4; i++) + { + str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) + + hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8 )) & 0xF); + } + return str; +} + +/* + * Convert an array of big-endian words to a base-64 string + */ +function binb2b64(binarray) +{ + var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + var str = ""; + for(var i = 0; i < binarray.length * 4; i += 3) + { + var triplet = (((binarray[i >> 2] >> 8 * (3 - i %4)) & 0xFF) << 16) + | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 ) + | ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF); + for(var j = 0; j < 4; j++) + { + if(i * 8 + j * 6 > binarray.length * 32) str += b64pad; + else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F); + } + } + return str; +} + + +}); + +require.define("/test.js", function (require, module, exports, __dirname, __filename) { + var crypto = require('crypto') +var abc = crypto.createHash('sha1').update('abc').digest('hex') +console.log(abc) +//require('hello').inlineCall().call2() + +}); +require("/test.js"); diff --git a/node_modules/crypto-browserify/example/index.html b/node_modules/crypto-browserify/example/index.html new file mode 100644 index 0000000..9d55c6d --- /dev/null +++ b/node_modules/crypto-browserify/example/index.html @@ -0,0 +1,12 @@ +<!doctype html> +<html> +<script src=bundle.js></script> +<body> + <pre> + require('crypto').createHash('sha1').update('abc').digest('hex') == '<span id=ans></span>' + </pre> +</body> +<script> + document.getElementById('ans').innerHTML = require('crypto').createHash('sha1').update('abc').digest('hex') +</script> +</html> diff --git a/node_modules/crypto-browserify/example/test.js b/node_modules/crypto-browserify/example/test.js new file mode 100644 index 0000000..0b76c01 --- /dev/null +++ b/node_modules/crypto-browserify/example/test.js @@ -0,0 +1,4 @@ +var crypto = require('crypto') +var abc = crypto.createHash('sha1').update('abc').digest('hex') +console.log(abc) +// require('hello').inlineCall().call2() diff --git a/node_modules/crypto-browserify/index.js b/node_modules/crypto-browserify/index.js new file mode 100644 index 0000000..b6d4d24 --- /dev/null +++ b/node_modules/crypto-browserify/index.js @@ -0,0 +1,97 @@ +'use strict' + +exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes') +exports.createHash = exports.Hash = require('create-hash') +exports.createHmac = exports.Hmac = require('create-hmac') + +var algos = require('browserify-sign/algos') +var algoKeys = Object.keys(algos) +var hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys) +exports.getHashes = function () { + return hashes +} + +var p = require('pbkdf2') +exports.pbkdf2 = p.pbkdf2 +exports.pbkdf2Sync = p.pbkdf2Sync + +var aes = require('browserify-cipher') + +exports.Cipher = aes.Cipher +exports.createCipher = aes.createCipher +exports.Cipheriv = aes.Cipheriv +exports.createCipheriv = aes.createCipheriv +exports.Decipher = aes.Decipher +exports.createDecipher = aes.createDecipher +exports.Decipheriv = aes.Decipheriv +exports.createDecipheriv = aes.createDecipheriv +exports.getCiphers = aes.getCiphers +exports.listCiphers = aes.listCiphers + +var dh = require('diffie-hellman') + +exports.DiffieHellmanGroup = dh.DiffieHellmanGroup +exports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup +exports.getDiffieHellman = dh.getDiffieHellman +exports.createDiffieHellman = dh.createDiffieHellman +exports.DiffieHellman = dh.DiffieHellman + +var sign = require('browserify-sign') + +exports.createSign = sign.createSign +exports.Sign = sign.Sign +exports.createVerify = sign.createVerify +exports.Verify = sign.Verify + +exports.createECDH = require('create-ecdh') + +var publicEncrypt = require('public-encrypt') + +exports.publicEncrypt = publicEncrypt.publicEncrypt +exports.privateEncrypt = publicEncrypt.privateEncrypt +exports.publicDecrypt = publicEncrypt.publicDecrypt +exports.privateDecrypt = publicEncrypt.privateDecrypt + +// the least I can do is make error messages for the rest of the node.js/crypto api. +// ;[ +// 'createCredentials' +// ].forEach(function (name) { +// exports[name] = function () { +// throw new Error([ +// 'sorry, ' + name + ' is not implemented yet', +// 'we accept pull requests', +// 'https://github.com/crypto-browserify/crypto-browserify' +// ].join('\n')) +// } +// }) + +var rf = require('randomfill') + +exports.randomFill = rf.randomFill +exports.randomFillSync = rf.randomFillSync + +exports.createCredentials = function () { + throw new Error([ + 'sorry, createCredentials is not implemented yet', + 'we accept pull requests', + 'https://github.com/crypto-browserify/crypto-browserify' + ].join('\n')) +} + +exports.constants = { + 'DH_CHECK_P_NOT_SAFE_PRIME': 2, + 'DH_CHECK_P_NOT_PRIME': 1, + 'DH_UNABLE_TO_CHECK_GENERATOR': 4, + 'DH_NOT_SUITABLE_GENERATOR': 8, + 'NPN_ENABLED': 1, + 'ALPN_ENABLED': 1, + 'RSA_PKCS1_PADDING': 1, + 'RSA_SSLV23_PADDING': 2, + 'RSA_NO_PADDING': 3, + 'RSA_PKCS1_OAEP_PADDING': 4, + 'RSA_X931_PADDING': 5, + 'RSA_PKCS1_PSS_PADDING': 6, + 'POINT_CONVERSION_COMPRESSED': 2, + 'POINT_CONVERSION_UNCOMPRESSED': 4, + 'POINT_CONVERSION_HYBRID': 6 +} diff --git a/node_modules/crypto-browserify/package.json b/node_modules/crypto-browserify/package.json new file mode 100644 index 0000000..d2d054d --- /dev/null +++ b/node_modules/crypto-browserify/package.json @@ -0,0 +1,78 @@ +{ + "_from": "crypto-browserify@^3.11.0", + "_id": "crypto-browserify@3.12.0", + "_inBundle": false, + "_integrity": "sha512-fz4spIh+znjO2VjL+IdhEpRJ3YN6sMzITSBijk6FK2UvTqruSQW+/cCZTSNsMiZNvUeq0CqurF+dAbyiGOY6Wg==", + "_location": "/crypto-browserify", + "_phantomChildren": {}, + "_requested": { + "type": "range", + "registry": true, + "raw": "crypto-browserify@^3.11.0", + "name": "crypto-browserify", + "escapedName": "crypto-browserify", + "rawSpec": "^3.11.0", + "saveSpec": null, + "fetchSpec": "^3.11.0" + }, + "_requiredBy": [ + "/node-libs-browser" + ], + "_resolved": "https://registry.npmjs.org/crypto-browserify/-/crypto-browserify-3.12.0.tgz", + "_shasum": "396cf9f3137f03e4b8e532c58f698254e00f80ec", + "_spec": "crypto-browserify@^3.11.0", + "_where": "/home/pruss/Dev/3-minute-website/node_modules/node-libs-browser", + "author": { + "name": "Dominic Tarr", + "email": "dominic.tarr@gmail.com", + "url": "dominictarr.com" + }, + "browser": { + "crypto": false + }, + "bugs": { + "url": "https://github.com/crypto-browserify/crypto-browserify/issues" + }, + "bundleDependencies": false, + "dependencies": { + "browserify-cipher": "^1.0.0", + "browserify-sign": "^4.0.0", + "create-ecdh": "^4.0.0", + "create-hash": "^1.1.0", + "create-hmac": "^1.1.0", + "diffie-hellman": "^5.0.0", + "inherits": "^2.0.1", + "pbkdf2": "^3.0.3", + "public-encrypt": "^4.0.0", + "randombytes": "^2.0.0", + "randomfill": "^1.0.3" + }, + "deprecated": false, + "description": "implementation of crypto for the browser", + "devDependencies": { + "hash-test-vectors": "~1.3.2", + "pseudorandombytes": "^2.0.0", + "safe-buffer": "^5.1.1", + "standard": "^5.0.2", + "tape": "~2.3.2", + "zuul": "^3.6.0" + }, + "engines": { + "node": "*" + }, + "homepage": "https://github.com/crypto-browserify/crypto-browserify", + "license": "MIT", + "name": "crypto-browserify", + "optionalDependencies": {}, + "repository": { + "type": "git", + "url": "git://github.com/crypto-browserify/crypto-browserify.git" + }, + "scripts": { + "browser": "zuul --browser-version $BROWSER_VERSION --browser-name $BROWSER_NAME -- test/index.js", + "standard": "standard", + "test": "npm run standard && npm run unit", + "unit": "node test/" + }, + "version": "3.12.0" +} diff --git a/node_modules/crypto-browserify/test/aes.js b/node_modules/crypto-browserify/test/aes.js new file mode 100644 index 0000000..916a019 --- /dev/null +++ b/node_modules/crypto-browserify/test/aes.js @@ -0,0 +1,49 @@ +var test = require('tape') +var crypto = require('browserify-cipher/browser') +var randomBytes = require('pseudorandombytes') + +function runIt (i) { + crypto.listCiphers().forEach(function (cipher) { + test('run: ' + i, function (t) { + t.test('ciphers: ' + cipher, function (t) { + t.plan(1) + var data = randomBytes(562) + var password = randomBytes(20) + var crypter = crypto.createCipher(cipher, password) + var decrypter = crypto.createDecipher(cipher, password) + var out = [] + out.push(decrypter.update(crypter.update(data))) + out.push(decrypter.update(crypter.final())) + if (cipher.indexOf('gcm') > -1) { + decrypter.setAuthTag(crypter.getAuthTag()) + } + out.push(decrypter.final()) + t.equals(data.toString('hex'), Buffer.concat(out).toString('hex')) + }) + }) + }) + if (i < 4) { + setTimeout(runIt, 0, i + 1) + } +} +runIt(1) +test('getCiphers', function (t) { + t.plan(1) + t.ok(crypto.getCiphers().length, 'get ciphers returns an array') +}) + +test('through crypto browserify works', function (t) { + t.plan(2) + var crypto = require('../') + var cipher = 'aes-128-ctr' + var data = randomBytes(562) + var password = randomBytes(20) + var crypter = crypto.createCipher(cipher, password) + var decrypter = crypto.createDecipher(cipher, password) + var out = [] + out.push(decrypter.update(crypter.update(data))) + out.push(decrypter.update(crypter.final())) + out.push(decrypter.final()) + t.equals(data.toString('hex'), Buffer.concat(out).toString('hex')) + t.ok(crypto.getCiphers().length, 'get ciphers returns an array') +}) diff --git a/node_modules/crypto-browserify/test/create-hash.js b/node_modules/crypto-browserify/test/create-hash.js new file mode 100644 index 0000000..33532fd --- /dev/null +++ b/node_modules/crypto-browserify/test/create-hash.js @@ -0,0 +1,50 @@ +var test = require('tape') + +var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'] +var encodings = ['hex', 'base64'] // FIXME: test binary +var vectors = require('hash-test-vectors') + +testLib('createHash in crypto-browserify', require('../').createHash) +testLib('create-hash/browser', require('create-hash/browser')) + +function testLib (name, createHash) { + algorithms.forEach(function (algorithm) { + runTest(name, createHash, algorithm) + }) +} +function runTest (name, createHash, algorithm) { + test(name + ' test ' + algorithm + ' against test vectors', function (t) { + run(0) + function run (i) { + if (i >= vectors.length) { + return t.end() + } + var obj = vectors[i] + + var input = new Buffer(obj.input, 'base64') + var node = obj[algorithm] + var js = createHash(algorithm).update(input).digest('hex') + if (js !== node) { + t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node) + } + + encodings.forEach(function (encoding) { + var input = new Buffer(obj.input, 'base64').toString(encoding) + var node = obj[algorithm] + var js = createHash(algorithm).update(input, encoding).digest('hex') + if (js !== node) { + t.equal(js, node, algorithm + '(testVector[' + i + '], ' + encoding + ') == ' + node) + } + }) + input = new Buffer(obj.input, 'base64') + node = obj[algorithm] + var hash = createHash(algorithm) + hash.end(input) + js = hash.read().toString('hex') + if (js !== node) { + t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node) + } + setTimeout(run, 0, i + 1) + } + }) +} diff --git a/node_modules/crypto-browserify/test/create-hmac.js b/node_modules/crypto-browserify/test/create-hmac.js new file mode 100644 index 0000000..08488ab --- /dev/null +++ b/node_modules/crypto-browserify/test/create-hmac.js @@ -0,0 +1,50 @@ +var test = require('tape') + +var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'] +var vectors = require('hash-test-vectors/hmac') +testLib('createHmac in crypto-browserify', require('../').createHmac) +testLib('create-hmac/browser', require('create-hmac/browser')) + +function testLib (name, createHmac) { + algorithms.forEach(function (alg) { + test(name + ' hmac(' + alg + ')', function (t) { + run(0) + function run (i) { + if (i >= vectors.length) { + return t.end() + } + var input = vectors[i] + var output = createHmac(alg, new Buffer(input.key, 'hex')) + .update(input.data, 'hex').digest() + + output = input.truncate ? output.slice(0, input.truncate) : output + output = output.toString('hex') + if (output !== input[alg]) { + t.equal(output, input[alg]) + } + setTimeout(run, 0, i + 1) + } + }) + + test('hmac(' + alg + ')', function (t) { + run(0) + function run (i) { + if (i >= vectors.length) { + return t.end() + } + var input = vectors[i] + var hmac = createHmac(alg, new Buffer(input.key, 'hex')) + + hmac.end(input.data, 'hex') + var output = hmac.read() + + output = input.truncate ? output.slice(0, input.truncate) : output + output = output.toString('hex') + if (output !== input[alg]) { + t.equal(output, input[alg]) + } + setTimeout(run, 0, i + 1) + } + }) + }) +} diff --git a/node_modules/crypto-browserify/test/dh.js b/node_modules/crypto-browserify/test/dh.js new file mode 100644 index 0000000..61fd074 --- /dev/null +++ b/node_modules/crypto-browserify/test/dh.js @@ -0,0 +1,49 @@ +var test = require('tape') +var crypto = require('diffie-hellman/browser') + +test('diffie-hellman mod groups', function (t) { + [ + 'modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16' + ].forEach(function (mod) { + t.test(mod, function (t) { + t.plan(3) + var dh1 = crypto.getDiffieHellman(mod) + var p1 = dh1.getPrime().toString('hex') + dh1.generateKeys() + var dh2 = crypto.getDiffieHellman(mod) + var p2 = dh2.getPrime().toString('hex') + dh2.generateKeys() + t.equals(p1, p2, 'equal primes') + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.notEquals(pubk1, pubk2, 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + }) +}) + +test('diffie-hellman key lengths', function (t) { + [ + 64, 65, 192 + ].forEach(function (len) { + t.test('' + len, function (t) { + t.plan(3) + var dh2 = crypto.createDiffieHellman(len) + var prime2 = dh2.getPrime() + var p2 = prime2.toString('hex') + var dh1 = crypto.createDiffieHellman(prime2) + var p1 = dh1.getPrime().toString('hex') + dh1.generateKeys() + dh2.generateKeys() + t.equals(p1, p2, 'equal primes') + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.notEquals(pubk1, pubk2, 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + }) +}) diff --git a/node_modules/crypto-browserify/test/ecdh.js b/node_modules/crypto-browserify/test/ecdh.js new file mode 100644 index 0000000..86b5aed --- /dev/null +++ b/node_modules/crypto-browserify/test/ecdh.js @@ -0,0 +1,61 @@ +var mods = [ + 'secp256k1', + 'secp224r1', + 'prime256v1', + 'prime192v1' +] +var test = require('tape') +var _crypto = require('../') +var createECDH1 = _crypto.createECDH +var createECDH2 = require('create-ecdh/browser') + +mods.forEach(function (mod) { + test('createECDH: ' + mod + ' uncompressed', function (t) { + t.plan(2) + var dh1 = createECDH1(mod) + dh1.generateKeys() + var dh2 = createECDH2(mod) + dh2.generateKeys() + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(pubk1).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + + test('createECDH: ' + mod + ' compressed', function (t) { + t.plan(2) + var dh1 = createECDH1(mod) + dh1.generateKeys() + var dh2 = createECDH2(mod) + dh2.generateKeys() + var pubk1 = dh1.getPublicKey(null, 'compressed') + var pubk2 = dh2.getPublicKey(null, 'compressed') + t.notEquals(pubk1.toString('hex'), pubk2.toString('hex'), 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(pubk1).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + + test('createECDH: ' + mod + ' set stuff', function (t) { + t.plan(5) + var dh1 = createECDH1(mod) + var dh2 = createECDH2(mod) + dh1.generateKeys() + dh2.generateKeys() + dh1.setPrivateKey(dh2.getPrivateKey()) + dh1.setPublicKey(dh2.getPublicKey()) + var priv1 = dh1.getPrivateKey('hex') + var priv2 = dh2.getPrivateKey('hex') + t.equals(priv1, priv2, 'same private key') + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.equals(pubk1.toString('hex'), pubk2.toString('hex'), 'same public keys, uncompressed') + t.equals(dh1.getPublicKey('hex', 'compressed'), dh2.getPublicKey('hex', 'compressed'), 'same public keys compressed') + t.equals(dh1.getPublicKey('hex', 'hybrid'), dh2.getPublicKey('hex', 'hybrid'), 'same public keys hybrid') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(pubk1).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) +}) diff --git a/node_modules/crypto-browserify/test/index.js b/node_modules/crypto-browserify/test/index.js new file mode 100644 index 0000000..2ac7094 --- /dev/null +++ b/node_modules/crypto-browserify/test/index.js @@ -0,0 +1,19 @@ + +require('./create-hash') +require('./create-hmac') +if (!process.browser) { + require('./dh') +} + +require('./pbkdf2') +try { + require('randombytes')(8) + require('./ecdh') + require('./public-encrypt') + require('./random-bytes') + require('./sign') + require('./random-fill') +} catch (e) { + console.log('no secure rng avaiable') +} +require('./aes') diff --git a/node_modules/crypto-browserify/test/node/dh.js b/node_modules/crypto-browserify/test/node/dh.js new file mode 100644 index 0000000..0b3aa71 --- /dev/null +++ b/node_modules/crypto-browserify/test/node/dh.js @@ -0,0 +1,51 @@ +var test = require('tape') +var cryptoB = require('../../') +var crypto = require('crypto') + +test('diffie-hellman mod groups', function (t) { + [ + 'modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16' + ].forEach(function (mod) { + t.test(mod, function (t) { + t.plan(3) + var dh1 = cryptoB.getDiffieHellman(mod) + var p1 = dh1.getPrime().toString('hex') + dh1.generateKeys() + + var dh2 = crypto.getDiffieHellman(mod) + var p2 = dh2.getPrime().toString('hex') + dh2.generateKeys() + t.equals(p1, p2, 'equal primes') + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.notEquals(pubk1, pubk2, 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(pubk1).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + }) +}) + +test('diffie-hellman key lengths', function (t) { + [ + 64, 65, 192 + ].forEach(function (len) { + t.test('' + len, function (t) { + t.plan(3) + var dh2 = cryptoB.createDiffieHellman(len) + var prime2 = dh2.getPrime() + var p2 = prime2.toString('hex') + var dh1 = crypto.createDiffieHellman(prime2) + var p1 = dh1.getPrime().toString('hex') + dh1.generateKeys() + dh2.generateKeys() + t.equals(p1, p2, 'equal primes') + var pubk1 = dh1.getPublicKey() + var pubk2 = dh2.getPublicKey() + t.notEquals(pubk1, pubk2, 'diff public keys') + var pub1 = dh1.computeSecret(pubk2).toString('hex') + var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex') + t.equals(pub1, pub2, 'equal secrets') + }) + }) +}) diff --git a/node_modules/crypto-browserify/test/pbkdf2.js b/node_modules/crypto-browserify/test/pbkdf2.js new file mode 100644 index 0000000..084014e --- /dev/null +++ b/node_modules/crypto-browserify/test/pbkdf2.js @@ -0,0 +1,21 @@ +var tape = require('tape') +var crypto = require('pbkdf2/browser') + +var vectors = require('hash-test-vectors/pbkdf2') + +tape('pbkdf2', function (t) { + vectors.forEach(function (input) { + // skip inputs that will take way too long + if (input.iterations > 10000) return + + var key = crypto.pbkdf2Sync(input.password, input.salt, input.iterations, input.length) + + if (key.toString('hex') !== input.sha1) { + console.log(input) + } + + t.equal(key.toString('hex'), input.sha1) + }) + + t.end() +}) diff --git a/node_modules/crypto-browserify/test/public-encrypt.js b/node_modules/crypto-browserify/test/public-encrypt.js new file mode 100644 index 0000000..edb435c --- /dev/null +++ b/node_modules/crypto-browserify/test/public-encrypt.js @@ -0,0 +1,36 @@ +var test = require('tape') +var crypto1 = require('../') +var rsa = { + 'private': '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', + 'public': '2d2d2d2d2d424547494e20525341205055424c4943204b45592d2d2d2d2d0a4d49494242674b422f6779376d6a615767506546645659445a5752434139424e69763370506230657332372b464b593068737a4c614f773437457843744157700a4473483438545841667948425977424c67756179666b344c4749757078622b43474d62526f337845703043626659314a62793236543976476a524331666f48440a44554a4738347561526279487161663469367a74346756522b786c4145496a6b614641414b38634f6f58415431435671474c4c6c6a554363684c38506a61486a0a2f7972695a2f53377264776c49334c6e41427877776d4c726d522f7637315774706d4f2f614e47384e2b31706f2b5177616768546b79513539452f5a7641754f0a6b4657486f6b32712f523650594161326a645a397a696d3046714f502b6e6b5161454452624246426d4271547635664647666b32577341664b662f5247302f560a46642b5a654d353235315465547658483639356e6c53476175566c3941674d424141453d0a2d2d2d2d2d454e4420525341205055424c4943204b45592d2d2d2d2d0a' +} +var crypto2 = require('public-encrypt/browser') +rsa.private = new Buffer(rsa.private, 'hex') +rsa.public = new Buffer(rsa.public, 'hex') +var encrypted = '0bcd6462ad7a563be2d42b0b73e0b0a163886304e7723b025f97605144fe1781e84acdc4031327d6bccd67fe13183e8fbdc8c5fe947b49d011ce3ebb08b11e83b87a77328ca57ee77cfdc78743b0749366643d7a21b2abcd4aa32dee9832938445540ee3007b7a70191c8dc9ff2ad76fe8dfaa5362d9d2c4b31a67b816d7b7970a293cb95bf3437a301bedb9f431b7075aa2f9df77b4385bea2a37982beda467260b384a58258b5eb4e36a0e0bf7dff83589636f5f97bf542084f0f76868c9f3f989a27fee5b8cd2bfee0bae1eae958df7c3184e5a40fda101196214f371606feca4330b221f30577804bbd4f61578a84e85dcd298849f509e630d275280' + +test('publicEncrypt/privateDecrypt', function (t) { + t.test('can decrypt', function (t) { + t.plan(2) + // note encryption is ranomized so can't test to see if they encrypt the same + t.equals(crypto1.privateDecrypt(rsa.private, new Buffer(encrypted, 'hex')).toString(), 'hello there I am a nice message', 'decrypt it properly') + t.equals(crypto2.privateDecrypt(rsa.private, new Buffer(encrypted, 'hex')).toString(), 'hello there I am a nice message', 'decrypt it properly') + }) + t.test('can round trip', function (t) { + t.plan(2) + var msg = 'this is a message' + // note encryption is ranomized so can't test to see if they encrypt the same + t.equals(crypto1.privateDecrypt(rsa.private, crypto2.publicEncrypt(rsa.public, new Buffer(msg))).toString(), msg, 'round trip it') + t.equals(crypto2.privateDecrypt(rsa.private, crypto1.publicEncrypt(rsa.public, new Buffer(msg))).toString(), msg, 'round trip it') + }) +}) + +test('privateEncrypt/publicDecrypt', function (t) { + t.test('can round trip', function (t) { + t.plan(2) + var msg = 'this is a message' + // note encryption is ranomized so can't test to see if they encrypt the same + t.equals(crypto1.publicDecrypt(rsa.public, crypto2.privateEncrypt(rsa.private, new Buffer(msg))).toString(), msg, 'round trip it') + t.equals(crypto2.publicDecrypt(rsa.public, crypto1.privateEncrypt(rsa.private, new Buffer(msg))).toString(), msg, 'round trip it') + }) +}) diff --git a/node_modules/crypto-browserify/test/random-bytes.js b/node_modules/crypto-browserify/test/random-bytes.js new file mode 100644 index 0000000..398af24 --- /dev/null +++ b/node_modules/crypto-browserify/test/random-bytes.js @@ -0,0 +1,60 @@ +var test = require('tape') +var crypto = require('../') + +var randomBytesFunctions = { + randomBytes: require('randombytes'), + pseudoRandomBytes: crypto.pseudoRandomBytes +} + +for (var randomBytesName in randomBytesFunctions) { + // Both randomBytes and pseudoRandomBytes should provide the same interface + var randomBytes = randomBytesFunctions[randomBytesName] + + test('get error message', function (t) { + try { + var b = randomBytes(10) + t.ok(Buffer.isBuffer(b)) + t.end() + } catch (err) { + t.ok(/not supported/.test(err.message), '"not supported" is in error message') + t.end() + } + }) + + test(randomBytesName, function (t) { + t.plan(5) + t.equal(randomBytes(10).length, 10) + t.ok(Buffer.isBuffer(randomBytes(10))) + randomBytes(10, function (ex, bytes) { + t.error(ex) + t.equal(bytes.length, 10) + t.ok(Buffer.isBuffer(bytes)) + t.end() + }) + }) + + test(randomBytesName + ' seem random', function (t) { + var L = 1000 + var b = randomBytes(L) + + var mean = [].reduce.call(b, function (a, b) { return a + b }, 0) / L + + // test that the random numbers are plausably random. + // Math.random() will pass this, but this will catch + // terrible mistakes such as this blunder: + // https://github.com/dominictarr/crypto-browserify/commit/3267955e1df7edd1680e52aeede9a89506ed2464#commitcomment-7916835 + + // this doesn't check that the bytes are in a random *order* + // but it's better than nothing. + + var expected = 256 / 2 + var smean = Math.sqrt(mean) + + // console.log doesn't work right on testling, *grumble grumble* + console.log(JSON.stringify([expected - smean, mean, expected + smean])) + t.ok(mean < expected + smean) + t.ok(mean > expected - smean) + + t.end() + }) +} diff --git a/node_modules/crypto-browserify/test/random-fill.js b/node_modules/crypto-browserify/test/random-fill.js new file mode 100644 index 0000000..63c885a --- /dev/null +++ b/node_modules/crypto-browserify/test/random-fill.js @@ -0,0 +1,53 @@ +var test = require('tape') +var crypto = require('../') +var Buffer = require('safe-buffer').Buffer + +test('get error message', function (t) { + try { + var b = crypto.randomFillSync(Buffer.alloc(10)) + t.ok(Buffer.isBuffer(b)) + t.end() + } catch (err) { + t.ok(/not supported/.test(err.message), '"not supported" is in error message') + t.end() + } +}) + +test('randomfill', function (t) { + t.plan(5) + t.equal(crypto.randomFillSync(Buffer.alloc(10)).length, 10) + t.ok(Buffer.isBuffer(crypto.randomFillSync(Buffer.alloc(10)))) + crypto.randomFill(Buffer.alloc(10), function (ex, bytes) { + t.error(ex) + t.equal(bytes.length, 10) + t.ok(Buffer.isBuffer(bytes)) + t.end() + }) +}) + +test('seems random', function (t) { + var L = 1000 + var b = crypto.randomFillSync(Buffer.alloc(L)) + + var mean = [].reduce.call(b, function (a, b) { + return a + b + }, 0) / L + + // test that the random numbers are plausably random. + // Math.random() will pass this, but this will catch + // terrible mistakes such as this blunder: + // https://github.com/dominictarr/crypto-browserify/commit/3267955e1df7edd1680e52aeede9a89506ed2464#commitcomment-7916835 + + // this doesn't check that the bytes are in a random *order* + // but it's better than nothing. + + var expected = 256 / 2 + var smean = Math.sqrt(mean) + + // console.log doesn't work right on testling, *grumble grumble* + console.log(JSON.stringify([expected - smean, mean, expected + smean])) + t.ok(mean < expected + smean) + t.ok(mean > expected - smean) + + t.end() +}) diff --git a/node_modules/crypto-browserify/test/sign.js b/node_modules/crypto-browserify/test/sign.js new file mode 100644 index 0000000..7d67685 --- /dev/null +++ b/node_modules/crypto-browserify/test/sign.js @@ -0,0 +1,59 @@ +var test = require('tape') +var nodeCrypto = require('../') +var ourCrypto = require('browserify-sign/browser') + +var rsa = { + 'private': '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', + 'public': '2d2d2d2d2d424547494e20525341205055424c4943204b45592d2d2d2d2d0a4d49494242674b422f6779376d6a615767506546645659445a5752434139424e69763370506230657332372b464b593068737a4c614f773437457843744157700a4473483438545841667948425977424c67756179666b344c4749757078622b43474d62526f337845703043626659314a62793236543976476a524331666f48440a44554a4738347561526279487161663469367a74346756522b786c4145496a6b614641414b38634f6f58415431435671474c4c6c6a554363684c38506a61486a0a2f7972695a2f53377264776c49334c6e41427877776d4c726d522f7637315774706d4f2f614e47384e2b31706f2b5177616768546b79513539452f5a7641754f0a6b4657486f6b32712f523650594161326a645a397a696d3046714f502b6e6b5161454452624246426d4271547635664647666b32577341664b662f5247302f560a46642b5a654d353235315465547658483639356e6c53476175566c3941674d424141453d0a2d2d2d2d2d454e4420525341205055424c4943204b45592d2d2d2d2d0a' +} + +var ec = { + 'private': '2d2d2d2d2d424547494e2045432050524956415445204b45592d2d2d2d2d0a4d485143415145454944463658763853762f2f77475557442b6337383070704772553051645a5743417a78415150515838722f756f416347425375424241414b0a6f55514451674145495a656f7744796c6c73344b2f7766426a4f313862596f37674778386e595152696a6134652f71454d696b4f484a616937676565557265550a7235586b792f4178377332644774656773504e7350674765354d705176673d3d0a2d2d2d2d2d454e442045432050524956415445204b45592d2d2d2d2d0a', + 'public': '2d2d2d2d2d424547494e205055424c4943204b45592d2d2d2d2d0a4d465977454159484b6f5a497a6a3043415159464b34454541416f4451674145495a656f7744796c6c73344b2f7766426a4f313862596f37674778386e5951520a696a6134652f71454d696b4f484a616937676565557265557235586b792f4178377332644774656773504e7350674765354d705176673d3d0a2d2d2d2d2d454e44205055424c4943204b45592d2d2d2d2d0a' +} + +rsa.private = new Buffer(rsa.private, 'hex') +rsa.public = new Buffer(rsa.public, 'hex') +ec.private = new Buffer(ec.private, 'hex') +ec.public = new Buffer(ec.public, 'hex') + +function testit (keys, message, scheme) { + var pub = keys.public + var priv = keys.private + test(message.toString(), function (t) { + t.test('js sign and verify', function (t) { + t.plan(t) + var mySign = ourCrypto.createSign(scheme) + var mySig = mySign.update(message).sign(priv) + var myVer = ourCrypto.createVerify(scheme) + t.ok(myVer.update(message).verify(pub, mySig), 'validates') + }) + + t.test('node sign and verify', function (t) { + t.plan(t) + var mySign = nodeCrypto.createSign(scheme) + var mySig = mySign.update(message).sign(priv) + var myVer = nodeCrypto.createVerify(scheme) + t.ok(myVer.update(message).verify(pub, mySig), 'validates') + }) + + t.test('node sign and js verify', function (t) { + t.plan(t) + var mySign = nodeCrypto.createSign(scheme) + var mySig = mySign.update(message).sign(priv) + var myVer = ourCrypto.createVerify(scheme) + t.ok(myVer.update(message).verify(pub, mySig), 'validates') + }) + + t.test('js sign and node verify', function (t) { + t.plan(t) + var mySign = ourCrypto.createSign(scheme) + var mySig = mySign.update(message).sign(priv) + var myVer = nodeCrypto.createVerify(scheme) + t.ok(myVer.update(message).verify(pub, mySig), 'validates') + }) + }) +} + +testit(rsa, new Buffer('rsa with sha256'), 'RSA-SHA256') +testit(ec, new Buffer('ec with sha1'), 'ecdsa-with-SHA1') |