pax_global_header 0000666 0000000 0000000 00000000064 13221663622 0014515 g ustar 00root root 0000000 0000000 52 comment=3516f81a545dd7ecb32f83eb31ac804115bd39ef
node-crypto-browserify-3.11.1/ 0000775 0000000 0000000 00000000000 13221663622 0016234 5 ustar 00root root 0000000 0000000 node-crypto-browserify-3.11.1/.gitignore 0000664 0000000 0000000 00000000015 13221663622 0020220 0 ustar 00root root 0000000 0000000 node_modules
node-crypto-browserify-3.11.1/.travis.yml 0000664 0000000 0000000 00000002177 13221663622 0020354 0 ustar 00root root 0000000 0000000 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="5..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=
node-crypto-browserify-3.11.1/.zuul.yml 0000664 0000000 0000000 00000000011 13221663622 0020024 0 ustar 00root root 0000000 0000000 ui: tape
node-crypto-browserify-3.11.1/LICENSE 0000664 0000000 0000000 00000002077 13221663622 0017247 0 ustar 00root root 0000000 0000000 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. node-crypto-browserify-3.11.1/README.md 0000664 0000000 0000000 00000003151 13221663622 0017513 0 ustar 00root root 0000000 0000000 # 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
node-crypto-browserify-3.11.1/example/ 0000775 0000000 0000000 00000000000 13221663622 0017667 5 ustar 00root root 0000000 0000000 node-crypto-browserify-3.11.1/example/bundle.js 0000664 0000000 0000000 00000042024 13221663622 0021500 0 ustar 00root root 0000000 0000000 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");
node-crypto-browserify-3.11.1/example/index.html 0000664 0000000 0000000 00000000475 13221663622 0021672 0 ustar 00root root 0000000 0000000
require('crypto').createHash('sha1').update('abc').digest('hex') == ''
node-crypto-browserify-3.11.1/example/test.js 0000664 0000000 0000000 00000000231 13221663622 0021200 0 ustar 00root root 0000000 0000000 var crypto = require('crypto')
var abc = crypto.createHash('sha1').update('abc').digest('hex')
console.log(abc)
// require('hello').inlineCall().call2()
node-crypto-browserify-3.11.1/index.js 0000664 0000000 0000000 00000005417 13221663622 0017710 0 ustar 00root root 0000000 0000000 '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'))
// }
// })
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
}
node-crypto-browserify-3.11.1/package.json 0000664 0000000 0000000 00000002275 13221663622 0020530 0 ustar 00root root 0000000 0000000 {
"author": "Dominic Tarr (dominictarr.com)",
"name": "crypto-browserify",
"description": "implementation of crypto for the browser",
"version": "3.11.1",
"homepage": "https://github.com/crypto-browserify/crypto-browserify",
"repository": {
"type": "git",
"url": "git://github.com/crypto-browserify/crypto-browserify.git"
},
"scripts": {
"standard": "standard",
"test": "npm run standard && npm run unit",
"unit": "node test/",
"browser": "zuul --browser-version $BROWSER_VERSION --browser-name $BROWSER_NAME -- test/index.js"
},
"engines": {
"node": "*"
},
"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"
},
"devDependencies": {
"hash-test-vectors": "~1.3.2",
"pseudorandombytes": "^2.0.0",
"standard": "^5.0.2",
"tape": "~2.3.2",
"zuul": "^3.6.0"
},
"optionalDependencies": {},
"browser": {
"crypto": false
},
"license": "MIT"
}
node-crypto-browserify-3.11.1/test/ 0000775 0000000 0000000 00000000000 13221663622 0017213 5 ustar 00root root 0000000 0000000 node-crypto-browserify-3.11.1/test/aes.js 0000664 0000000 0000000 00000003135 13221663622 0020323 0 ustar 00root root 0000000 0000000 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')
})
node-crypto-browserify-3.11.1/test/create-hash.js 0000664 0000000 0000000 00000003222 13221663622 0021734 0 ustar 00root root 0000000 0000000 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)
}
})
}
node-crypto-browserify-3.11.1/test/create-hmac.js 0000664 0000000 0000000 00000002735 13221663622 0021731 0 ustar 00root root 0000000 0000000 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)
}
})
})
}
node-crypto-browserify-3.11.1/test/dh.js 0000664 0000000 0000000 00000003125 13221663622 0020145 0 ustar 00root root 0000000 0000000 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')
})
})
})
node-crypto-browserify-3.11.1/test/ecdh.js 0000664 0000000 0000000 00000004262 13221663622 0020460 0 ustar 00root root 0000000 0000000 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')
})
})
node-crypto-browserify-3.11.1/test/index.js 0000664 0000000 0000000 00000000501 13221663622 0020654 0 ustar 00root root 0000000 0000000
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')
} catch (e) {
console.log('no secure rng avaiable')
}
require('./aes')
node-crypto-browserify-3.11.1/test/node/ 0000775 0000000 0000000 00000000000 13221663622 0020140 5 ustar 00root root 0000000 0000000 node-crypto-browserify-3.11.1/test/node/dh.js 0000664 0000000 0000000 00000003133 13221663622 0021071 0 ustar 00root root 0000000 0000000 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')
})
})
})
node-crypto-browserify-3.11.1/test/pbkdf2.js 0000664 0000000 0000000 00000000775 13221663622 0020732 0 ustar 00root root 0000000 0000000 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()
})
node-crypto-browserify-3.11.1/test/public-encrypt.js 0000664 0000000 0000000 00000014323 13221663622 0022514 0 ustar 00root root 0000000 0000000 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')
})
})
node-crypto-browserify-3.11.1/test/random-bytes.js 0000664 0000000 0000000 00000003356 13221663622 0022164 0 ustar 00root root 0000000 0000000 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()
})
}
node-crypto-browserify-3.11.1/test/sign.js 0000664 0000000 0000000 00000015121 13221663622 0020511 0 ustar 00root root 0000000 0000000 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')