@stellot/crypto/lib/commonjs/elGamal/index.js

Crypto libraries for front and backend

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.decodePrivateKey = exports.encodePrivateKey = exports.decodePublicKey = exports.encodePublicKey = exports.createEncryptionKeypair = exports.EncryptedValue = exports.DecryptedValue = exports.DecryptionElGamal = exports.EncryptionElGamal = exports.ElGamal = void 0;
const asn1_js_1 = __importDefault(require("asn1.js"));
const decryption_1 = __importDefault(require("./decryption"));
exports.DecryptionElGamal = decryption_1.default;
const encryption_1 = __importDefault(require("./encryption"));
exports.EncryptionElGamal = encryption_1.default;
const jsbn_1 = require("jsbn");
const encryptedValue_1 = __importDefault(require("./encryptedValue"));
exports.EncryptedValue = encryptedValue_1.default;
const decryptedValue_1 = __importDefault(require("./decryptedValue"));
exports.DecryptedValue = decryptedValue_1.default;
const Utils = __importStar(require("./utils"));
function createEncryptionKeypair(primeBits = 2048) {
    const { p, g, y, x } = ElGamal.generate(primeBits);
    const privateKey = encodePrivateKey(p, g, y, x);
    const publicKey = encodePublicKey(p, g, y);
    return { privateKey, publicKey };
}
exports.createEncryptionKeypair = createEncryptionKeypair;
const ElGamalPublicKey = asn1_js_1.default.define('DHPublicKeyForElGamalEncryption', function () {
    this.seq().obj(this.key('p').int(), this.key('g').int(), this.key('y').int());
});
function encodePublicKey(prime, generator, publicKey) {
    return ElGamalPublicKey.encode({
        p: new Buffer(prime.toByteArray()),
        g: new Buffer(generator.toByteArray()),
        y: new Buffer(publicKey.toByteArray()),
    }, 'der');
}
exports.encodePublicKey = encodePublicKey;
function decodePublicKey(der) {
    return ElGamalPublicKey.decode(der, 'der');
}
exports.decodePublicKey = decodePublicKey;
const ElGamalPrivateKey = asn1_js_1.default.define('DHPrivateKeyForElGamalEncryption', function () {
    this.seq().obj(this.key('p').int(), this.key('g').int(), this.key('y').int(), this.key('x').int());
});
function encodePrivateKey(prime, generator, y, x) {
    return ElGamalPrivateKey.encode({
        p: new Buffer(prime.toByteArray()),
        g: new Buffer(generator.toByteArray()),
        y: new Buffer(y.toByteArray()),
        x: new Buffer(x.toByteArray()),
    }, 'der');
}
exports.encodePrivateKey = encodePrivateKey;
function decodePrivateKey(der) {
    return ElGamalPrivateKey.decode(der, 'der');
}
exports.decodePrivateKey = decodePrivateKey;
class ElGamal {
    static generate(primeBits = 2048) {
        let q;
        let p;
        do {
            q = Utils.getBigPrime(primeBits - 1);
            p = q.shiftLeft(1).add(jsbn_1.BigInteger.ONE);
        } while (!p.isProbablePrime());
        let g;
        do {
            g = Utils.getRandomBigInt(new jsbn_1.BigInteger('3'), p);
        } while (g.modPowInt(2, p).equals(jsbn_1.BigInteger.ONE) ||
            g.modPow(q, p).equals(jsbn_1.BigInteger.ONE) ||
            p.subtract(jsbn_1.BigInteger.ONE).remainder(g).equals(jsbn_1.BigInteger.ZERO) ||
            p.subtract(jsbn_1.BigInteger.ONE).remainder(g.modInverse(p)).equals(jsbn_1.BigInteger.ZERO));
        const x = Utils.getRandomBigInt(Utils.BIG_TWO, p.subtract(jsbn_1.BigInteger.ONE));
        const y = g.modPow(x, p);
        return { p, g, y, x };
    }
    static fromPrivateKey(p, g, y, x) {
        return new decryption_1.default(p, g, y, x);
    }
    static fromPublicKey(p, g, y) {
        return new encryption_1.default(p, g, y);
    }
}
exports.default = ElGamal;
exports.ElGamal = ElGamal;