pax_global_header 0000666 0000000 0000000 00000000064 14705755022 0014521 g ustar 00root root 0000000 0000000 52 comment=55476aca92a99c81fcc438519a4d55817fb455fc
browserify-crypto-browserify-ab8920b/ 0000775 0000000 0000000 00000000000 14705755022 0020034 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/.eslintrc 0000664 0000000 0000000 00000000443 14705755022 0021661 0 ustar 00root root 0000000 0000000 {
"root": true,
"extends": "@ljharb",
"rules": {
"func-style": "off",
"multiline-comment-style": "off",
"sort-keys": "off",
},
"ignorePatterns": [
"example/bundle.js",
],
"overrides": [
{
"files": "example/**",
"rules": {
"no-console": "off",
},
},
],
}
browserify-crypto-browserify-ab8920b/.github/ 0000775 0000000 0000000 00000000000 14705755022 0021374 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/.github/FUNDING.yml 0000664 0000000 0000000 00000001114 14705755022 0023206 0 ustar 00root root 0000000 0000000 # These are supported funding model platforms
github: [ljharb]
patreon: # Replace with a single Patreon username
open_collective: # Replace with a single Open Collective username
ko_fi: # Replace with a single Ko-fi username
tidelift: npm/crypto-browserify
community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
liberapay: # Replace with a single Liberapay username
issuehunt: # Replace with a single IssueHunt username
otechie: # Replace with a single Otechie username
custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
browserify-crypto-browserify-ab8920b/.github/workflows/ 0000775 0000000 0000000 00000000000 14705755022 0023431 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/.github/workflows/node-aught.yml 0000664 0000000 0000000 00000000364 14705755022 0026212 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js < 10'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/node.yml@main
with:
range: '>= 0.10 < 10'
type: minors
command: npm run tests-only
skip-ls-check: true
browserify-crypto-browserify-ab8920b/.github/workflows/node-pretest.yml 0000664 0000000 0000000 00000000345 14705755022 0026567 0 ustar 00root root 0000000 0000000 name: 'Tests: pretest/posttest'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/pretest.yml@main
with:
skip-engines: true # see https://github.com/browserify/browserify-sign/pull/49
browserify-crypto-browserify-ab8920b/.github/workflows/node-tens.yml 0000664 0000000 0000000 00000000324 14705755022 0026047 0 ustar 00root root 0000000 0000000 name: 'Tests: node.js >= 10'
on: [pull_request, push]
jobs:
tests:
uses: ljharb/actions/.github/workflows/node.yml@main
with:
range: '>= 10'
type: minors
command: npm run tests-only
browserify-crypto-browserify-ab8920b/.github/workflows/rebase.yml 0000664 0000000 0000000 00000000257 14705755022 0025421 0 ustar 00root root 0000000 0000000 name: Automatic Rebase
on: [pull_request_target]
jobs:
_:
uses: ljharb/actions/.github/workflows/rebase.yml@main
secrets:
token: ${{ secrets.GITHUB_TOKEN }}
browserify-crypto-browserify-ab8920b/.github/workflows/require-allow-edits.yml 0000664 0000000 0000000 00000000303 14705755022 0030046 0 ustar 00root root 0000000 0000000 name: Require “Allow Edits”
on: [pull_request_target]
jobs:
_:
name: "Require “Allow Edits”"
runs-on: ubuntu-latest
steps:
- uses: ljharb/require-allow-edits@main
browserify-crypto-browserify-ab8920b/.gitignore 0000664 0000000 0000000 00000000205 14705755022 0022021 0 ustar 00root root 0000000 0000000 # gitignore
node_modules
# Only apps should have lockfiles
npm-shrinkwrap.json
package-lock.json
yarn.lock
coverage/
.nyc_output/
browserify-crypto-browserify-ab8920b/.npmrc 0000664 0000000 0000000 00000000050 14705755022 0021147 0 ustar 00root root 0000000 0000000 package-lock=false
audit-level=moderate
browserify-crypto-browserify-ab8920b/.nycrc 0000664 0000000 0000000 00000000121 14705755022 0021145 0 ustar 00root root 0000000 0000000 {
"exclude": [
"test/**"
],
"reporter": [
"html",
"text"
]
}
browserify-crypto-browserify-ab8920b/.travis.yml 0000664 0000000 0000000 00000001652 14705755022 0022151 0 ustar 00root root 0000000 0000000 sudo: false
language: node_js
matrix:
include:
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=
browserify-crypto-browserify-ab8920b/LICENSE 0000664 0000000 0000000 00000002077 14705755022 0021047 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. browserify-crypto-browserify-ab8920b/README.md 0000664 0000000 0000000 00000005335 14705755022 0021321 0 ustar 00root root 0000000 0000000 # crypto-browserify [![Version Badge][npm-version-svg]][package-url]
A port of node's `crypto` module to the browser.
[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]
[](https://saucelabs.com/u/crypto-browserify)
[![npm badge][npm-badge-png]][package-url]
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
[package-url]: https://npmjs.org/package/crypto-browserify
[npm-version-svg]: https://versionbadg.es/browserify/crypto-browserify.svg
[deps-svg]: https://david-dm.org/browserify/crypto-browserify.svg
[deps-url]: https://david-dm.org/browserify/crypto-browserify
[dev-deps-svg]: https://david-dm.org/browserify/crypto-browserify/dev-status.svg
[dev-deps-url]: https://david-dm.org/browserify/crypto-browserify#info=devDependencies
[npm-badge-png]: https://nodei.co/npm/crypto-browserify.png?downloads=true&stars=true
[license-image]: https://img.shields.io/npm/l/crypto-browserify.svg
[license-url]: LICENSE
[downloads-image]: https://img.shields.io/npm/dm/crypto-browserify.svg
[downloads-url]: https://npm-stat.com/charts.html?package=crypto-browserify
[codecov-image]: https://codecov.io/gh/browserify/crypto-browserify/branch/main/graphs/badge.svg
[codecov-url]: https://app.codecov.io/gh/browserify/crypto-browserify/
[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/browserify/crypto-browserify
[actions-url]: https://github.com/browserify/crypto-browserify/actions
browserify-crypto-browserify-ab8920b/example/ 0000775 0000000 0000000 00000000000 14705755022 0021467 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/example/bundle.js 0000664 0000000 0000000 00000037651 14705755022 0023312 0 ustar 00root root 0000000 0000000 'use strict';
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'); }
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;
}
// 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 = Array.prototype.slice.call(arguments).join(' ');
throw new Error(m+'\nwe accept pull requests\nhttp://github.com/browserify/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');
browserify-crypto-browserify-ab8920b/example/index.html 0000664 0000000 0000000 00000000472 14705755022 0023467 0 ustar 00root root 0000000 0000000
require('crypto').createHash('sha1').update('abc').digest('hex') == ''
browserify-crypto-browserify-ab8920b/example/test.js 0000664 0000000 0000000 00000000253 14705755022 0023004 0 ustar 00root root 0000000 0000000 'use strict';
var crypto = require('crypto');
var abc = crypto.createHash('sha1').update('abc').digest('hex');
console.log(abc);
// require('hello').inlineCall().call2()
browserify-crypto-browserify-ab8920b/index.js 0000664 0000000 0000000 00000005653 14705755022 0021512 0 ustar 00root root 0000000 0000000 'use strict';
// eslint-disable-next-line no-multi-assign
exports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes');
// eslint-disable-next-line no-multi-assign
exports.createHash = exports.Hash = require('create-hash');
// eslint-disable-next-line no-multi-assign
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\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
// };
// });
var rf = require('randomfill');
exports.randomFill = rf.randomFill;
exports.randomFillSync = rf.randomFillSync;
exports.createCredentials = function () {
throw new Error('sorry, createCredentials is not implemented yet\nwe accept pull requests\nhttps://github.com/browserify/crypto-browserify');
};
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
};
browserify-crypto-browserify-ab8920b/package.json 0000664 0000000 0000000 00000002516 14705755022 0022326 0 ustar 00root root 0000000 0000000 {
"author": "Dominic Tarr (dominictarr.com)",
"name": "crypto-browserify",
"description": "implementation of crypto for the browser",
"version": "3.12.1",
"homepage": "https://github.com/browserify/crypto-browserify",
"sideEffects": false,
"repository": {
"type": "git",
"url": "git://github.com/browserify/crypto-browserify.git"
},
"scripts": {
"lint": "eslint --ext=js,mjs .",
"pretest": "npm run lint",
"tests-only": "nyc tape 'test/**/*.js'",
"test": "npm run tests-only",
"posttest": "npx npm@'>=10.2' audit --production"
},
"funding": {
"url": "https://github.com/sponsors/ljharb"
},
"engines": {
"node": ">= 0.10"
},
"dependencies": {
"browserify-cipher": "^1.0.1",
"browserify-sign": "^4.2.3",
"create-ecdh": "^4.0.4",
"create-hash": "^1.2.0",
"create-hmac": "^1.1.7",
"diffie-hellman": "^5.0.3",
"hash-base": "~3.0.4",
"inherits": "^2.0.4",
"pbkdf2": "^3.1.2",
"public-encrypt": "^4.0.3",
"randombytes": "^2.1.0",
"randomfill": "^1.0.4"
},
"devDependencies": {
"@ljharb/eslint-config": "^21.1.1",
"eslint": "=8.8.0",
"hash-test-vectors": "^1.3.2",
"nyc": "^10.3.2",
"object.entries": "^1.1.8",
"pseudorandombytes": "^2.0.0",
"safe-buffer": "^5.2.1",
"semver": "^6.3.1",
"tape": "^5.9.0"
},
"browser": {
"crypto": false
},
"license": "MIT"
}
browserify-crypto-browserify-ab8920b/test/ 0000775 0000000 0000000 00000000000 14705755022 0021013 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/test/aes.js 0000664 0000000 0000000 00000003405 14705755022 0022123 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var bcCrypto = require('browserify-cipher/browser');
var bcCyphers = bcCrypto.getCiphers();
var randomBytes = require('pseudorandombytes');
for (var i = 0; i < 4; i += 1) {
bcCrypto.listCiphers().forEach(function (cipher) {
test('run: ' + i, function (t) {
/* eslint no-loop-func: 0 */
t.test('ciphers: ' + cipher, function (st) {
st.plan(1);
var data = randomBytes(562);
var password = randomBytes(20);
var crypter = bcCrypto.createCipher(cipher, password);
var decrypter = bcCrypto.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']());
st.equals(data.toString('hex'), Buffer.concat(out).toString('hex'));
});
});
});
}
test('getCiphers', function (t) {
t.plan(1);
t.ok(bcCyphers.length, 'get ciphers returns an array');
});
// eslint-disable-next-line global-require
test('through crypto browserify works', { skip: !require('crypto').createCipher && 'node 22+ removes createCipher' }, function (t) {
t.plan(2);
var crypto = require('../'); // eslint-disable-line global-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');
});
browserify-crypto-browserify-ab8920b/test/create-hash.js 0000664 0000000 0000000 00000003277 14705755022 0023546 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var satisfies = require('semver').satisfies;
var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
var encodings = ['hex', 'base64']; // FIXME: test binary
var vectors = require('hash-test-vectors');
function runTest(name, createHash, algorithm) {
var isUnsupported = satisfies(process.version, '^17') && (
algorithm === 'rmd160'
|| algorithm === 'hmac(rmd160)'
);
test(
name + ' test ' + algorithm + ' against test vectors',
{ skip: isUnsupported && 'this node version does not support ' + algorithm },
function (t) {
vectors.forEach(function (obj, i) {
var input = new Buffer(obj.input, 'base64');
var node = obj[algorithm];
var js = createHash(algorithm).update(input).digest('hex');
t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
encodings.forEach(function (encoding) {
var eInput = new Buffer(obj.input, 'base64').toString(encoding);
var eNode = obj[algorithm];
var eJS = createHash(algorithm).update(eInput, encoding).digest('hex');
t.equal(eJS, eNode, algorithm + '(testVector[' + i + '], ' + encoding + ') == ' + eNode);
});
input = new Buffer(obj.input, 'base64');
node = obj[algorithm];
var hash = createHash(algorithm);
hash.end(input);
js = hash.read().toString('hex');
t.equal(js, node, algorithm + '(testVector[' + i + ']) == ' + node);
});
t.end();
}
);
}
function testLib(name, createHash) {
algorithms.forEach(function (algorithm) {
runTest(name, createHash, algorithm);
});
}
testLib('createHash in crypto-browserify', require('../').createHash);
testLib('create-hash/browser', require('create-hash/browser'));
browserify-crypto-browserify-ab8920b/test/create-hmac.js 0000664 0000000 0000000 00000002714 14705755022 0023526 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var satisfies = require('semver').satisfies;
var algorithms = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'];
var vectors = require('hash-test-vectors/hmac');
function testLib(name, createHmac) {
algorithms.forEach(function (alg) {
var isUnsupported = satisfies(process.version, '^17') && (
alg === 'rmd160'
|| alg === 'hmac(rmd160)'
);
test(
name + ' hmac(' + alg + ')',
{ skip: isUnsupported && 'this node version does not support ' + alg },
function (t) {
vectors.forEach(function (input) {
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');
t.equal(output, input[alg]);
});
t.end();
}
);
test(
'hmac(' + alg + ')',
{ skip: isUnsupported && 'this node version does not support ' + alg },
function (t) {
vectors.forEach(function (input) {
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');
t.equal(output, input[alg]);
});
t.end();
}
);
});
}
testLib('createHmac in crypto-browserify', require('../').createHmac);
testLib('create-hmac/browser', require('create-hmac/browser'));
browserify-crypto-browserify-ab8920b/test/dh.js 0000664 0000000 0000000 00000003075 14705755022 0021751 0 ustar 00root root 0000000 0000000 'use strict';
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 (st) {
st.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();
st.equals(p1, p2, 'equal primes');
var pubk1 = dh1.getPublicKey();
var pubk2 = dh2.getPublicKey();
st.notEquals(pubk1, pubk2, 'diff public keys');
var pub1 = dh1.computeSecret(pubk2).toString('hex');
var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
st.equals(pub1, pub2, 'equal secrets');
});
});
});
test('diffie-hellman key lengths', function (t) {
[
64,
65,
192
].forEach(function (len) {
t.test(String(len), function (st) {
st.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();
st.equals(p1, p2, 'equal primes');
var pubk1 = dh1.getPublicKey();
var pubk2 = dh2.getPublicKey();
st.notEquals(pubk1, pubk2, 'diff public keys');
var pub1 = dh1.computeSecret(pubk2).toString('hex');
var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
st.equals(pub1, pub2, 'equal secrets');
});
});
});
browserify-crypto-browserify-ab8920b/test/ecdh.js 0000664 0000000 0000000 00000004201 14705755022 0022251 0 ustar 00root root 0000000 0000000 'use strict';
var mods = [
'secp256k1',
'secp224r1',
'prime256v1',
'prime192v1'
];
var test = require('tape');
var createECDH1 = require('../').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');
});
});
browserify-crypto-browserify-ab8920b/test/index.js 0000664 0000000 0000000 00000000623 14705755022 0022461 0 ustar 00root root 0000000 0000000 'use strict';
/* eslint-disable global-require */
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');
browserify-crypto-browserify-ab8920b/test/node/ 0000775 0000000 0000000 00000000000 14705755022 0021740 5 ustar 00root root 0000000 0000000 browserify-crypto-browserify-ab8920b/test/node/dh.js 0000664 0000000 0000000 00000003415 14705755022 0022674 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var cryptoB = require('../../');
var crypto = require('crypto');
var satisfies = require('semver').satisfies;
test('diffie-hellman mod groups', function (t) {
[
'modp1',
'modp2',
'modp5',
'modp14',
'modp15',
'modp16'
].forEach(function (mod) {
t.test(mod, function (st) {
st.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();
st.equals(p1, p2, 'equal primes');
var pubk1 = dh1.getPublicKey();
var pubk2 = dh2.getPublicKey();
st.notEquals(pubk1, pubk2, 'diff public keys');
var pub1 = dh1.computeSecret(pubk2).toString('hex');
var pub2 = dh2.computeSecret(pubk1).toString('hex');
st.equals(pub1, pub2, 'equal secrets');
});
});
});
test('diffie-hellman key lengths', function (t) {
[
64,
65,
192,
512,
1024
].forEach(function (len) {
var modulusTooSmall = satisfies(process.version, '>= 17') && len < 512;
t.test(String(len), { skip: modulusTooSmall && 'node 17+ requires a length >= 512' }, function (st) {
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();
st.equals(p1, p2, 'equal primes');
var pubk1 = dh1.getPublicKey();
var pubk2 = dh2.getPublicKey();
st.notEquals(pubk1, pubk2, 'diff public keys');
var pub1 = dh1.computeSecret(pubk2).toString('hex');
var pub2 = dh2.computeSecret(dh1.getPublicKey()).toString('hex');
st.equals(pub1, pub2, 'equal secrets');
st.end();
});
});
});
browserify-crypto-browserify-ab8920b/test/pbkdf2.js 0000664 0000000 0000000 00000001010 14705755022 0022511 0 ustar 00root root 0000000 0000000 'use strict';
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();
});
browserify-crypto-browserify-ab8920b/test/public-encrypt.js 0000664 0000000 0000000 00000014414 14705755022 0024315 0 ustar 00root root 0000000 0000000 'use strict';
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 (st) {
st.plan(2);
// note encryption is ranomized so can't test to see if they encrypt the same
st.equals(crypto1.privateDecrypt(rsa['private'], new Buffer(encrypted, 'hex')).toString(), 'hello there I am a nice message', 'decrypt it properly');
st.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 (st) {
st.plan(2);
var msg = 'this is a message';
// note encryption is ranomized so can't test to see if they encrypt the same
st.equals(crypto1.privateDecrypt(rsa['private'], crypto2.publicEncrypt(rsa['public'], new Buffer(msg))).toString(), msg, 'round trip it');
st.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 (st) {
st.plan(2);
var msg = 'this is a message';
// note encryption is ranomized so can't test to see if they encrypt the same
st.equals(crypto1.publicDecrypt(rsa['public'], crypto2.privateEncrypt(rsa['private'], new Buffer(msg))).toString(), msg, 'round trip it');
st.equals(crypto2.publicDecrypt(rsa['public'], crypto1.privateEncrypt(rsa['private'], new Buffer(msg))).toString(), msg, 'round trip it');
});
});
browserify-crypto-browserify-ab8920b/test/random-bytes.js 0000664 0000000 0000000 00000003473 14705755022 0023764 0 ustar 00root root 0000000 0000000 'use strict';
var test = require('tape');
var crypto = require('../');
var randomBytes = require('randombytes');
var entries = require('object.entries');
var randomBytesFunctions = {
randomBytes: randomBytes,
pseudoRandomBytes: crypto.pseudoRandomBytes
};
// Both randomBytes and pseudoRandomBytes should provide the same interface
entries(randomBytesFunctions).forEach(function (entry) {
var randomBytesName = entry[0];
var randomBytesFn = entry[1];
test('get error message', function (t) {
try {
var b = randomBytesFn(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(randomBytesFn(10).length, 10);
t.ok(Buffer.isBuffer(randomBytesFn(10)));
randomBytesFn(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 buffer = randomBytesFn(L);
var mean = Array.prototype.reduce.call(buffer, 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/browserify/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();
});
});
browserify-crypto-browserify-ab8920b/test/random-fill.js 0000664 0000000 0000000 00000003022 14705755022 0023552 0 ustar 00root root 0000000 0000000 'use strict';
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 buffer = crypto.randomFillSync(Buffer.alloc(L));
var mean = Array.prototype.reduce.call(buffer, 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/browserify/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();
});
browserify-crypto-browserify-ab8920b/test/sign.js 0000664 0000000 0000000 00000015122 14705755022 0022312 0 ustar 00root root 0000000 0000000 'use strict';
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 (st) {
st.plan(1);
var mySign = ourCrypto.createSign(scheme);
var mySig = mySign.update(message).sign(priv);
var myVer = ourCrypto.createVerify(scheme);
st.ok(myVer.update(message).verify(pub, mySig), 'validates');
});
t.test('node sign and verify', function (st) {
st.plan(1);
var mySign = nodeCrypto.createSign(scheme);
var mySig = mySign.update(message).sign(priv);
var myVer = nodeCrypto.createVerify(scheme);
st.ok(myVer.update(message).verify(pub, mySig), 'validates');
});
t.test('node sign and js verify', function (st) {
st.plan(1);
var mySign = nodeCrypto.createSign(scheme);
var mySig = mySign.update(message).sign(priv);
var myVer = ourCrypto.createVerify(scheme);
st.ok(myVer.update(message).verify(pub, mySig), 'validates');
});
t.test('js sign and node verify', function (st) {
st.plan(1);
var mySign = ourCrypto.createSign(scheme);
var mySig = mySign.update(message).sign(priv);
var myVer = nodeCrypto.createVerify(scheme);
st.ok(myVer.update(message).verify(pub, mySig), 'validates');
});
});
}
testit(rsa, new Buffer('rsa with sha256'), 'RSA-SHA256');
testit(ec, new Buffer('ec with sha1'), 'sha256');