pax_global_header00006660000000000000000000000064126516757710014533gustar00rootroot0000000000000052 comment=6a58413e1004b48425b28fb337187db00c2d83c0 diffie-hellman-5.0.2/000077500000000000000000000000001265167577100144035ustar00rootroot00000000000000diffie-hellman-5.0.2/.gitignore000066400000000000000000000000151265167577100163670ustar00rootroot00000000000000node_modules diffie-hellman-5.0.2/.npmignore000066400000000000000000000000101265167577100163710ustar00rootroot00000000000000test.js diffie-hellman-5.0.2/.travis.yml000066400000000000000000000001501265167577100165100ustar00rootroot00000000000000language: node_js node_js: - "0.11" - "0.10" - "0.12" - "1" - "2" - "3" - "4" sudo: false diffie-hellman-5.0.2/browser.js000066400000000000000000000021551265167577100164270ustar00rootroot00000000000000var generatePrime = require('./lib/generatePrime') var primes = require('./lib/primes.json') var DH = require('./lib/dh') function getDiffieHellman (mod) { var prime = new Buffer(primes[mod].prime, 'hex') var gen = new Buffer(primes[mod].gen, 'hex') return new DH(prime, gen) } var ENCODINGS = { 'binary': true, 'hex': true, 'base64': true } function createDiffieHellman (prime, enc, generator, genc) { if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) { return createDiffieHellman(prime, 'binary', enc, generator) } enc = enc || 'binary' genc = genc || 'binary' generator = generator || new Buffer([2]) if (!Buffer.isBuffer(generator)) { generator = new Buffer(generator, genc) } if (typeof prime === 'number') { return new DH(generatePrime(prime, generator), generator, true) } if (!Buffer.isBuffer(prime)) { prime = new Buffer(prime, enc) } return new DH(prime, generator, true) } exports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman exports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman diffie-hellman-5.0.2/index.js000066400000000000000000000005371265167577100160550ustar00rootroot00000000000000var crypto = require('crypto') // getDiffieHellman exports.DiffieHellmanGroup = crypto.DiffieHellmanGroup exports.createDiffieHellmanGroup = crypto.createDiffieHellmanGroup exports.getDiffieHellman = crypto.getDiffieHellman // createDiffieHellman exports.createDiffieHellman = crypto.createDiffieHellman exports.DiffieHellman = crypto.DiffieHellman diffie-hellman-5.0.2/lib/000077500000000000000000000000001265167577100151515ustar00rootroot00000000000000diffie-hellman-5.0.2/lib/dh.js000066400000000000000000000074551265167577100161150ustar00rootroot00000000000000var BN = require('bn.js'); var MillerRabin = require('miller-rabin'); var millerRabin = new MillerRabin(); var TWENTYFOUR = new BN(24); var ELEVEN = new BN(11); var TEN = new BN(10); var THREE = new BN(3); var SEVEN = new BN(7); var primes = require('./generatePrime'); var randomBytes = require('randombytes'); module.exports = DH; function setPublicKey(pub, enc) { enc = enc || 'utf8'; if (!Buffer.isBuffer(pub)) { pub = new Buffer(pub, enc); } this._pub = new BN(pub); return this; } function setPrivateKey(priv, enc) { enc = enc || 'utf8'; if (!Buffer.isBuffer(priv)) { priv = new Buffer(priv, enc); } this._priv = new BN(priv); return this; } var primeCache = {}; function checkPrime(prime, generator) { var gen = generator.toString('hex'); var hex = [gen, prime.toString(16)].join('_'); if (hex in primeCache) { return primeCache[hex]; } var error = 0; if (prime.isEven() || !primes.simpleSieve || !primes.fermatTest(prime) || !millerRabin.test(prime)) { //not a prime so +1 error += 1; if (gen === '02' || gen === '05') { // we'd be able to check the generator // it would fail so +8 error += 8; } else { //we wouldn't be able to test the generator // so +4 error += 4; } primeCache[hex] = error; return error; } if (!millerRabin.test(prime.shrn(1))) { //not a safe prime error += 2; } var rem; switch (gen) { case '02': if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) { // unsuidable generator error += 8; } break; case '05': rem = prime.mod(TEN); if (rem.cmp(THREE) && rem.cmp(SEVEN)) { // prime mod 10 needs to equal 3 or 7 error += 8; } break; default: error += 4; } primeCache[hex] = error; return error; } function DH(prime, generator, malleable) { this.setGenerator(generator); this.__prime = new BN(prime); this._prime = BN.mont(this.__prime); this._primeLen = prime.length; this._pub = undefined; this._priv = undefined; this._primeCode = undefined; if (malleable) { this.setPublicKey = setPublicKey; this.setPrivateKey = setPrivateKey; } else { this._primeCode = 8; } } Object.defineProperty(DH.prototype, 'verifyError', { enumerable: true, get: function () { if (typeof this._primeCode !== 'number') { this._primeCode = checkPrime(this.__prime, this.__gen); } return this._primeCode; } }); DH.prototype.generateKeys = function () { if (!this._priv) { this._priv = new BN(randomBytes(this._primeLen)); } this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed(); return this.getPublicKey(); }; DH.prototype.computeSecret = function (other) { other = new BN(other); other = other.toRed(this._prime); var secret = other.redPow(this._priv).fromRed(); var out = new Buffer(secret.toArray()); var prime = this.getPrime(); if (out.length < prime.length) { var front = new Buffer(prime.length - out.length); front.fill(0); out = Buffer.concat([front, out]); } return out; }; DH.prototype.getPublicKey = function getPublicKey(enc) { return formatReturnValue(this._pub, enc); }; DH.prototype.getPrivateKey = function getPrivateKey(enc) { return formatReturnValue(this._priv, enc); }; DH.prototype.getPrime = function (enc) { return formatReturnValue(this.__prime, enc); }; DH.prototype.getGenerator = function (enc) { return formatReturnValue(this._gen, enc); }; DH.prototype.setGenerator = function (gen, enc) { enc = enc || 'utf8'; if (!Buffer.isBuffer(gen)) { gen = new Buffer(gen, enc); } this.__gen = gen; this._gen = new BN(gen); return this; }; function formatReturnValue(bn, enc) { var buf = new Buffer(bn.toArray()); if (!enc) { return buf; } else { return buf.toString(enc); } } diffie-hellman-5.0.2/lib/generatePrime.js000066400000000000000000000042751265167577100203060ustar00rootroot00000000000000var randomBytes = require('randombytes'); module.exports = findPrime; findPrime.simpleSieve = simpleSieve; findPrime.fermatTest = fermatTest; var BN = require('bn.js'); var TWENTYFOUR = new BN(24); var MillerRabin = require('miller-rabin'); var millerRabin = new MillerRabin(); var ONE = new BN(1); var TWO = new BN(2); var FIVE = new BN(5); var SIXTEEN = new BN(16); var EIGHT = new BN(8); var TEN = new BN(10); var THREE = new BN(3); var SEVEN = new BN(7); var ELEVEN = new BN(11); var FOUR = new BN(4); var TWELVE = new BN(12); var primes = null; function _getPrimes() { if (primes !== null) return primes; var limit = 0x100000; var res = []; res[0] = 2; for (var i = 1, k = 3; k < limit; k += 2) { var sqrt = Math.ceil(Math.sqrt(k)); for (var j = 0; j < i && res[j] <= sqrt; j++) if (k % res[j] === 0) break; if (i !== j && res[j] <= sqrt) continue; res[i++] = k; } primes = res; return res; } function simpleSieve(p) { var primes = _getPrimes(); for (var i = 0; i < primes.length; i++) if (p.modn(primes[i]) === 0) { if (p.cmpn(primes[i]) === 0) { return true; } else { return false; } } return true; } function fermatTest(p) { var red = BN.mont(p); return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0; } function findPrime(bits, gen) { if (bits < 16) { // this is what openssl does if (gen === 2 || gen === 5) { return new BN([0x8c, 0x7b]); } else { return new BN([0x8c, 0x27]); } } gen = new BN(gen); var num, n2; while (true) { num = new BN(randomBytes(Math.ceil(bits / 8))); while (num.bitLength() > bits) { num.ishrn(1); } if (num.isEven()) { num.iadd(ONE); } if (!num.testn(1)) { num.iadd(TWO); } if (!gen.cmp(TWO)) { while (num.mod(TWENTYFOUR).cmp(ELEVEN)) { num.iadd(FOUR); } } else if (!gen.cmp(FIVE)) { while (num.mod(TEN).cmp(THREE)) { num.iadd(FOUR); } } n2 = num.shrn(1); if (simpleSieve(n2) && simpleSieve(num) && fermatTest(n2) && fermatTest(num) && millerRabin.test(n2) && millerRabin.test(num)) { return num; } } } diffie-hellman-5.0.2/lib/primes.json000066400000000000000000000160771265167577100173560ustar00rootroot00000000000000{ "modp1": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a63a3620ffffffffffffffff" }, "modp2": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece65381ffffffffffffffff" }, "modp5": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca237327ffffffffffffffff" }, "modp14": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aacaa68ffffffffffffffff" }, "modp15": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a93ad2caffffffffffffffff" }, "modp16": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c934063199ffffffffffffffff" }, "modp17": { "gen": "02", "prime": "ffffffffffffffffc90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b139b22514a08798e3404ddef9519b3cd3a431b302b0a6df25f14374fe1356d6d51c245e485b576625e7ec6f44c42e9a637ed6b0bff5cb6f406b7edee386bfb5a899fa5ae9f24117c4b1fe649286651ece45b3dc2007cb8a163bf0598da48361c55d39a69163fa8fd24cf5f83655d23dca3ad961c62f356208552bb9ed529077096966d670c354e4abc9804f1746c08ca18217c32905e462e36ce3be39e772c180e86039b2783a2ec07a28fb5c55df06f4c52c9de2bcbf6955817183995497cea956ae515d2261898fa051015728e5a8aaac42dad33170d04507a33a85521abdf1cba64ecfb850458dbef0a8aea71575d060c7db3970f85a6e1e4c7abf5ae8cdb0933d71e8c94e04a25619dcee3d2261ad2ee6bf12ffa06d98a0864d87602733ec86a64521f2b18177b200cbbe117577a615d6c770988c0bad946e208e24fa074e5ab3143db5bfce0fd108e4b82d120a92108011a723c12a787e6d788719a10bdba5b2699c327186af4e23c1a946834b6150bda2583e9ca2ad44ce8dbbbc2db04de8ef92e8efc141fbecaa6287c59474e6bc05d99b2964fa090c3a2233ba186515be7ed1f612970cee2d7afb81bdd762170481cd0069127d5b05aa993b4ea988d8fddc186ffb7dc90a6c08f4df435c93402849236c3fab4d27c7026c1d4dcb2602646dec9751e763dba37bdf8ff9406ad9e530ee5db382f413001aeb06a53ed9027d831179727b0865a8918da3edbebcf9b14ed44ce6cbaced4bb1bdb7f1447e6cc254b332051512bd7af426fb8f401378cd2bf5983ca01c64b92ecf032ea15d1721d03f482d7ce6e74fef6d55e702f46980c82b5a84031900b1c9e59e7c97fbec7e8f323a97a7e36cc88be0f1d45b7ff585ac54bd407b22b4154aacc8f6d7ebf48e1d814cc5ed20f8037e0a79715eef29be32806a1d58bb7c5da76f550aa3d8a1fbff0eb19ccb1a313d55cda56c9ec2ef29632387fe8d76e3c0468043e8f663f4860ee12bf2d5b0b7474d6e694f91e6dcc4024ffffffffffffffff" }, "modp18": { "gen": "02", "prime": "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" } }diffie-hellman-5.0.2/package.json000066400000000000000000000014141265167577100166710ustar00rootroot00000000000000{ "name": "diffie-hellman", "version": "5.0.2", "description": "pure js diffie-hellman", "main": "index.js", "browser": "browser.js", "scripts": { "test": "node test.js | tspec" }, "repository": { "type": "git", "url": "https://github.com/crypto-browserify/diffie-hellman.git" }, "keywords": [ "diffie", "hellman", "diffiehellman", "dh" ], "author": "Calvin Metcalf", "license": "MIT", "bugs": { "url": "https://github.com/crypto-browserify/diffie-hellman/issues" }, "homepage": "https://github.com/crypto-browserify/diffie-hellman", "dependencies": { "bn.js": "^4.1.0", "miller-rabin": "^4.0.0", "randombytes": "^2.0.0" }, "devDependencies": { "tap-spec": "^1.0.1", "tape": "^3.0.1" } } diffie-hellman-5.0.2/readme.md000066400000000000000000000010061265167577100161570ustar00rootroot00000000000000diffie hellman [![Build Status](https://travis-ci.org/crypto-browserify/diffie-hellman.svg)](https://travis-ci.org/crypto-browserify/diffie-hellman) ==== pure js diffie-hellman, same api as node, most hard parts thanks to [bn.js](https://www.npmjs.org/package/bn.js) by [@indutny](https://github.com/indutny). In node just returns an object with `crypto.createDiffieHellman` and `crypto.getDiffieHellman` in the browser returns a shim. To require the pure JavaScript one in node `require('diffie-hellman/browser');`;diffie-hellman-5.0.2/test.js000066400000000000000000000115051265167577100157220ustar00rootroot00000000000000var test = require('tape'); var nodeCrypto = require('./'); var myCrypto = require('./browser'); var mods = [ 'modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16', 'modp17', 'modp18' ]; function isNode10() { if (!process.version) { return false; } var split = process.version.split('.'); if (split.length !== 3) { return false; } if (parseInt(split[1], 10) === 10 && split[0] === 'v0') { return true; } return false; } var lens = [ 2, 8, 16, 17, 18, 20, 21, 22, 64, 65, 128, 384, 512, 1024, 192, 224, 256]; var lens2 = [ 16, 17, 18, 20, 21, 22,64, 65, 128]; function run(i) { mods.forEach(function (mod) { test(mod + ' run ' + i, function (t){ t.plan(5); var dh1 = nodeCrypto.getDiffieHellman(mod); var p1 = dh1.getPrime().toString('hex'); dh1.generateKeys(); var dh2 = myCrypto.getDiffieHellman(mod); t.equals(typeof dh1.setPublicKey, typeof dh2.setPublicKey, 'same methods'); t.equals(typeof dh1.setPrivateKey, typeof dh2.setPrivateKey, 'same methods'); 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.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'); }); }); } function bylen(t, generator) { return function (len){ t.test('' + len, function (t) { t.plan(6); var dh2 = myCrypto.createDiffieHellman(len, generator); var prime2 = dh2.getPrime(); var p2 = prime2.toString('hex'); var dh1 = nodeCrypto.createDiffieHellman(prime2, generator); var p1 = dh1.getPrime().toString('hex'); t.equals(typeof dh1.setPublicKey, typeof dh2.setPublicKey, 'same methods'); t.equals(typeof dh1.setPrivateKey, typeof dh2.setPrivateKey, 'same methods'); dh1.generateKeys(); dh2.generateKeys(); t.equals(p1, p2, 'equal primes'); t.equals(dh1.getGenerator('hex'), dh2.getGenerator('hex'), 'equal generators'); 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(dh1.getPublicKey()).toString('hex'); t.equals(pub1, pub2, 'equal secrets'); }); }; } function bylen2(t) { return function (len){ t.test('' + len, function (t) { t.plan(5); var dh2 = nodeCrypto.createDiffieHellman(len); var prime2 = dh2.getPrime(); var p2 = prime2.toString('hex'); var dh1 = myCrypto.createDiffieHellman(prime2); var p1 = dh1.getPrime().toString('hex'); dh1.generateKeys(); dh2.generateKeys(); t.equals(typeof dh1.setPublicKey, typeof dh2.setPublicKey, 'same methods'); t.equals(typeof dh1.setPrivateKey, typeof dh2.setPrivateKey, 'same methods'); t.equals(p1, p2, 'equal primes'); 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(dh1.getPublicKey()).toString('hex'); t.equals(pub1, pub2, 'equal secrets'); }); }; } test('create primes gen 2', function (t) { var f = bylen(t, new Buffer([2])); lens2.forEach(f); }); if (!isNode10()) { test('create primes gen 5', function (t) { var f = bylen(t, new Buffer([5])); lens2.forEach(f); }); } test('create primes other way', function (t) { var f = bylen2(t); lens.forEach(f); }); var i = 0; while (++i < 2) { run(i); } if (!isNode10()) { test('check errors', function (t) { t.plan(5); var p1 = new Buffer('db10e7f61adcc193', 'hex'); var p2 = new Buffer('db10e7f61adcc194', 'hex'); var dh1 = myCrypto.createDiffieHellman(p1); var dh2 = nodeCrypto.createDiffieHellman(p1); t.equals(dh1.verifyError, dh2.verifyError, 'same error for good prime'); dh1 = myCrypto.createDiffieHellman(p2); dh2 = nodeCrypto.createDiffieHellman(p2); t.equals(dh1.verifyError, dh2.verifyError, 'same error for bad prime'); dh1 = myCrypto.createDiffieHellman(p2, new Buffer([7])); dh2 = nodeCrypto.createDiffieHellman(p2, new Buffer([7])); t.equals(dh1.verifyError, dh2.verifyError, 'same error for bad prime non testable generator'); dh1 = myCrypto.createDiffieHellman(p1.toString('hex'), 'hex', new Buffer([5])); dh2 = nodeCrypto.createDiffieHellman(p1.toString('hex'), 'hex', new Buffer([5])); t.equals(dh1.verifyError, dh2.verifyError, 'same error for good prime wrong generator'); dh1 = myCrypto.createDiffieHellman(p1, new Buffer([11]).toString('hex'), 'hex'); dh2 = nodeCrypto.createDiffieHellman(p1, new Buffer([11]).toString('hex'), 'hex'); t.equals(dh1.verifyError, dh2.verifyError, 'same error for good prime non testable generator'); }); }