threshold-elgamal 0.1.19 → 0.1.21

package/dist/constants.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GROUPS = void 0;
 /*
  The GROUPS object defines cryptographic parameters for different levels
  of finite field Diffie-Hellman (FFDHE) key exchanges.
@@ -14,7 +11,7 @@ exports.GROUPS = void 0;
 
  Reference: https://datatracker.ietf.org/doc/rfc7919/
  */
-exports.GROUPS = {
+export const GROUPS = {
     // Parameters for 2048-bit prime modulus group
     ffdhe2048: {
         primeBits: 2048, // Size of the prime in bits, default security level suitable for current applications

package/dist/elgamal.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decrypt = exports.encrypt = exports.generateParameters = void 0;
-const bigint_mod_arith_1 = require("bigint-mod-arith");
-const utils_1 = require("./utils");
+import { modPow, modInv } from 'bigint-mod-arith';
+import { getRandomBigIntegerInRange, getGroup } from './utils';
 /**
  * Generates the parameters for the ElGamal encryption, including the prime, generator,
  * and key pair (public and private keys).
@@ -10,13 +7,12 @@ const utils_1 = require("./utils");
  * @param {2048 | 3072 | 4096} primeBits - The bit length for the prime number. Supports 2048, 3072, or 4096 bits.
  * @returns {Parameters} The generated parameters including the prime, generator, publicKey, and privateKey.
  */
-const generateParameters = (primeBits = 2048) => {
-    const { prime, generator } = (0, utils_1.getGroup)(primeBits); // Use getGroup to fetch the prime and generator
-    const privateKey = (0, utils_1.getRandomBigIntegerInRange)(2n, prime - 1n);
-    const publicKey = (0, bigint_mod_arith_1.modPow)(generator, privateKey, prime);
+export const generateParameters = (primeBits = 2048) => {
+    const { prime, generator } = getGroup(primeBits); // Use getGroup to fetch the prime and generator
+    const privateKey = getRandomBigIntegerInRange(2n, prime - 1n);
+    const publicKey = modPow(generator, privateKey, prime);
     return { prime, generator, publicKey, privateKey };
 };
-exports.generateParameters = generateParameters;
 /**
  * Encrypts a secret using ElGamal encryption.
  *
@@ -26,17 +22,16 @@ exports.generateParameters = generateParameters;
  * @param {bigint} publicKey - The public key used for encryption.
  * @returns {EncryptedMessage} The encrypted secret, consisting of two BigIntegers (c1 and c2).
  */
-const encrypt = (secret, prime, generator, publicKey) => {
+export const encrypt = (secret, prime, generator, publicKey) => {
     if (secret >= Number(prime)) {
         throw new Error('Message is too large for direct encryption');
     }
-    const randomNumber = (0, utils_1.getRandomBigIntegerInRange)(1n, prime - 1n);
-    const c1 = (0, bigint_mod_arith_1.modPow)(generator, randomNumber, prime);
+    const randomNumber = getRandomBigIntegerInRange(1n, prime - 1n);
+    const c1 = modPow(generator, randomNumber, prime);
     const messageBigInt = BigInt(secret);
-    const c2 = ((0, bigint_mod_arith_1.modPow)(publicKey, randomNumber, prime) * messageBigInt) % prime;
+    const c2 = (modPow(publicKey, randomNumber, prime) * messageBigInt) % prime;
     return { c1, c2 };
 };
-exports.encrypt = encrypt;
 /**
  * Decrypts an ElGamal encrypted secret.
  *
@@ -45,9 +40,8 @@ exports.encrypt = encrypt;
  * @param {bigint} privateKey - The private key used for decryption.
  * @returns {number} The decrypted secret as an integer.
  */
-const decrypt = (encryptedMessage, prime, privateKey) => {
-    const ax = (0, bigint_mod_arith_1.modPow)(encryptedMessage.c1, privateKey, prime);
-    const plaintext = ((0, bigint_mod_arith_1.modInv)(ax, prime) * encryptedMessage.c2) % prime;
+export const decrypt = (encryptedMessage, prime, privateKey) => {
+    const ax = modPow(encryptedMessage.c1, privateKey, prime);
+    const plaintext = (modInv(ax, prime) * encryptedMessage.c2) % prime;
     return Number(plaintext);
 };
-exports.decrypt = decrypt;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export { generateParameters, encrypt, decrypt } from './elgamal';
-export { generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, } from './thresholdElgamal';
-export { getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, } from './utils';
-export type { EncryptedMessage, Parameters, KeyPair, PartyKeyPair, } from './types';
+import { generateParameters, encrypt, decrypt } from './elgamal';
+import { generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt } from './thresholdElgamal';
+import type { EncryptedMessage, Parameters, KeyPair, PartyKeyPair } from './types';
+import { getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup } from './utils';
+export { generateParameters, encrypt, decrypt, generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, };
+export type { EncryptedMessage, Parameters, KeyPair, PartyKeyPair };

package/dist/index.js

@@ -1,18 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGroup = exports.multiplyEncryptedValues = exports.getRandomBigIntegerInRange = exports.thresholdDecrypt = exports.combineDecryptionShares = exports.createDecryptionShare = exports.combinePublicKeys = exports.generateKeyShares = exports.generateSingleKeyShare = exports.decrypt = exports.encrypt = exports.generateParameters = void 0;
-var elgamal_1 = require("./elgamal");
-Object.defineProperty(exports, "generateParameters", { enumerable: true, get: function () { return elgamal_1.generateParameters; } });
-Object.defineProperty(exports, "encrypt", { enumerable: true, get: function () { return elgamal_1.encrypt; } });
-Object.defineProperty(exports, "decrypt", { enumerable: true, get: function () { return elgamal_1.decrypt; } });
-var thresholdElgamal_1 = require("./thresholdElgamal");
-Object.defineProperty(exports, "generateSingleKeyShare", { enumerable: true, get: function () { return thresholdElgamal_1.generateSingleKeyShare; } });
-Object.defineProperty(exports, "generateKeyShares", { enumerable: true, get: function () { return thresholdElgamal_1.generateKeyShares; } });
-Object.defineProperty(exports, "combinePublicKeys", { enumerable: true, get: function () { return thresholdElgamal_1.combinePublicKeys; } });
-Object.defineProperty(exports, "createDecryptionShare", { enumerable: true, get: function () { return thresholdElgamal_1.createDecryptionShare; } });
-Object.defineProperty(exports, "combineDecryptionShares", { enumerable: true, get: function () { return thresholdElgamal_1.combineDecryptionShares; } });
-Object.defineProperty(exports, "thresholdDecrypt", { enumerable: true, get: function () { return thresholdElgamal_1.thresholdDecrypt; } });
-var utils_1 = require("./utils");
-Object.defineProperty(exports, "getRandomBigIntegerInRange", { enumerable: true, get: function () { return utils_1.getRandomBigIntegerInRange; } });
-Object.defineProperty(exports, "multiplyEncryptedValues", { enumerable: true, get: function () { return utils_1.multiplyEncryptedValues; } });
-Object.defineProperty(exports, "getGroup", { enumerable: true, get: function () { return utils_1.getGroup; } });
+import { generateParameters, encrypt, decrypt } from './elgamal';
+import { generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, } from './thresholdElgamal';
+import { getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, } from './utils';
+export { generateParameters, encrypt, decrypt, generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, };

package/dist/testUtils.js

@@ -1,60 +1,52 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.votingTest = exports.homomorphicMultiplicationTest = exports.testSecureEncryptionAndDecryption = exports.thresholdSetup = exports.getRandomScore = void 0;
-const vitest_1 = require("vitest");
-const elgamal_1 = require("./elgamal");
-const thresholdElgamal_1 = require("./thresholdElgamal");
-const utils_1 = require("./utils");
-const getRandomScore = (min = 1, max = 10) => Math.floor(Math.random() * (max - min + 1)) + min;
-exports.getRandomScore = getRandomScore;
-const thresholdSetup = (partiesCount, threshold, primeBits = 2048) => {
-    const { prime, generator } = (0, utils_1.getGroup)(primeBits);
-    const keyShares = (0, thresholdElgamal_1.generateKeyShares)(partiesCount, threshold, primeBits);
+import { expect } from 'vitest';
+import { encrypt } from './elgamal';
+import { generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, } from './thresholdElgamal';
+import { multiplyEncryptedValues, getGroup } from './utils';
+export const getRandomScore = (min = 1, max = 10) => Math.floor(Math.random() * (max - min + 1)) + min;
+export const thresholdSetup = (partiesCount, threshold, primeBits = 2048) => {
+    const { prime, generator } = getGroup(primeBits);
+    const keyShares = generateKeyShares(partiesCount, threshold, primeBits);
     const publicKeys = keyShares.map((ks) => ks.partyPublicKey);
-    const combinedPublicKey = (0, thresholdElgamal_1.combinePublicKeys)(publicKeys, prime);
+    const combinedPublicKey = combinePublicKeys(publicKeys, prime);
     return { keyShares, combinedPublicKey, prime, generator };
 };
-exports.thresholdSetup = thresholdSetup;
-const testSecureEncryptionAndDecryption = (participantsCount, threshold, secret) => {
-    const { keyShares, combinedPublicKey, prime, generator } = (0, exports.thresholdSetup)(participantsCount, threshold);
-    const encryptedMessage = (0, elgamal_1.encrypt)(secret, prime, generator, combinedPublicKey);
+export const testSecureEncryptionAndDecryption = (participantsCount, threshold, secret) => {
+    const { keyShares, combinedPublicKey, prime, generator } = thresholdSetup(participantsCount, threshold);
+    const encryptedMessage = encrypt(secret, prime, generator, combinedPublicKey);
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
         .slice(0, threshold)
-        .map((keyShare) => (0, thresholdElgamal_1.createDecryptionShare)(encryptedMessage, keyShare.partyPrivateKey, prime));
-    const combinedDecryptionShares = (0, thresholdElgamal_1.combineDecryptionShares)(selectedDecryptionShares, prime);
-    const decryptedMessage = (0, thresholdElgamal_1.thresholdDecrypt)(encryptedMessage, combinedDecryptionShares, prime);
-    (0, vitest_1.expect)(decryptedMessage).toBe(secret);
+        .map((keyShare) => createDecryptionShare(encryptedMessage, keyShare.partyPrivateKey, prime));
+    const combinedDecryptionShares = combineDecryptionShares(selectedDecryptionShares, prime);
+    const decryptedMessage = thresholdDecrypt(encryptedMessage, combinedDecryptionShares, prime);
+    expect(decryptedMessage).toBe(secret);
 };
-exports.testSecureEncryptionAndDecryption = testSecureEncryptionAndDecryption;
-const homomorphicMultiplicationTest = (participantsCount, threshold, messages) => {
+export const homomorphicMultiplicationTest = (participantsCount, threshold, messages) => {
     const expectedProduct = messages.reduce((product, secret) => product * secret, 1);
-    const { keyShares, combinedPublicKey, prime, generator } = (0, exports.thresholdSetup)(participantsCount, threshold);
-    const encryptedMessages = messages.map((secret) => (0, elgamal_1.encrypt)(secret, prime, generator, combinedPublicKey));
-    const encryptedProduct = encryptedMessages.reduce((product, encryptedMessage) => (0, utils_1.multiplyEncryptedValues)(product, encryptedMessage, prime), { c1: 1n, c2: 1n });
+    const { keyShares, combinedPublicKey, prime, generator } = thresholdSetup(participantsCount, threshold);
+    const encryptedMessages = messages.map((secret) => encrypt(secret, prime, generator, combinedPublicKey));
+    const encryptedProduct = encryptedMessages.reduce((product, encryptedMessage) => multiplyEncryptedValues(product, encryptedMessage, prime), { c1: 1n, c2: 1n });
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
         .slice(0, threshold)
-        .map((keyShare) => (0, thresholdElgamal_1.createDecryptionShare)(encryptedProduct, keyShare.partyPrivateKey, prime));
-    const combinedDecryptionShares = (0, thresholdElgamal_1.combineDecryptionShares)(selectedDecryptionShares, prime);
-    const decryptedProduct = (0, thresholdElgamal_1.thresholdDecrypt)(encryptedProduct, combinedDecryptionShares, prime);
-    (0, vitest_1.expect)(decryptedProduct).toBe(expectedProduct);
+        .map((keyShare) => createDecryptionShare(encryptedProduct, keyShare.partyPrivateKey, prime));
+    const combinedDecryptionShares = combineDecryptionShares(selectedDecryptionShares, prime);
+    const decryptedProduct = thresholdDecrypt(encryptedProduct, combinedDecryptionShares, prime);
+    expect(decryptedProduct).toBe(expectedProduct);
 };
-exports.homomorphicMultiplicationTest = homomorphicMultiplicationTest;
-const votingTest = (participantsCount, threshold, candidatesCount) => {
-    const { keyShares, combinedPublicKey, prime, generator } = (0, exports.thresholdSetup)(participantsCount, threshold);
-    const votesMatrix = Array.from({ length: participantsCount }, () => Array.from({ length: candidatesCount }, () => (0, exports.getRandomScore)(1, 10)));
+export const votingTest = (participantsCount, threshold, candidatesCount) => {
+    const { keyShares, combinedPublicKey, prime, generator } = thresholdSetup(participantsCount, threshold);
+    const votesMatrix = Array.from({ length: participantsCount }, () => Array.from({ length: candidatesCount }, () => getRandomScore(1, 10)));
     const expectedProducts = Array.from({ length: candidatesCount }, (_, candidateIndex) => votesMatrix.reduce((product, votes) => product * votes[candidateIndex], 1));
-    const encryptedVotesMatrix = votesMatrix.map((votes) => votes.map((vote) => (0, elgamal_1.encrypt)(vote, prime, generator, combinedPublicKey)));
-    const encryptedProducts = Array.from({ length: candidatesCount }, (_, candidateIndex) => encryptedVotesMatrix.reduce((product, encryptedVotes) => (0, utils_1.multiplyEncryptedValues)(product, encryptedVotes[candidateIndex], prime), { c1: 1n, c2: 1n }));
+    const encryptedVotesMatrix = votesMatrix.map((votes) => votes.map((vote) => encrypt(vote, prime, generator, combinedPublicKey)));
+    const encryptedProducts = Array.from({ length: candidatesCount }, (_, candidateIndex) => encryptedVotesMatrix.reduce((product, encryptedVotes) => multiplyEncryptedValues(product, encryptedVotes[candidateIndex], prime), { c1: 1n, c2: 1n }));
     const partialDecryptionsMatrix = encryptedProducts.map((product) => keyShares
         .slice(0, threshold)
-        .map((keyShare) => (0, thresholdElgamal_1.createDecryptionShare)(product, keyShare.partyPrivateKey, prime)));
+        .map((keyShare) => createDecryptionShare(product, keyShare.partyPrivateKey, prime)));
     const decryptedProducts = partialDecryptionsMatrix.map((decryptionShares) => {
-        const combinedDecryptionShares = (0, thresholdElgamal_1.combineDecryptionShares)(decryptionShares, prime);
+        const combinedDecryptionShares = combineDecryptionShares(decryptionShares, prime);
         const encryptedProduct = encryptedProducts[partialDecryptionsMatrix.indexOf(decryptionShares)];
-        return (0, thresholdElgamal_1.thresholdDecrypt)(encryptedProduct, combinedDecryptionShares, prime);
+        return thresholdDecrypt(encryptedProduct, combinedDecryptionShares, prime);
     });
-    (0, vitest_1.expect)(decryptedProducts).toEqual(expectedProducts);
+    expect(decryptedProducts).toEqual(expectedProducts);
 };
-exports.votingTest = votingTest;

package/dist/thresholdElgamal.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.thresholdDecrypt = exports.combineDecryptionShares = exports.createDecryptionShare = exports.combinePublicKeys = exports.generateKeyShares = exports.generateSingleKeyShare = exports.evaluatePolynomial = void 0;
-const bigint_mod_arith_1 = require("bigint-mod-arith");
-const utils_1 = require("./utils");
+import { modPow, modInv } from 'bigint-mod-arith';
+import { generatePolynomial, getGroup } from './utils';
 /**
  * Evaluates a polynomial at a given point using modular arithmetic.
  *
@@ -11,14 +8,13 @@ const utils_1 = require("./utils");
  * @param {bigint} prime - The prime modulus.
  * @returns {bigint} The result of the polynomial evaluation.
  */
-const evaluatePolynomial = (polynomial, x, prime) => {
+export const evaluatePolynomial = (polynomial, x, prime) => {
     let result = 0n;
     for (let i = 0; i < polynomial.length; i++) {
         result = (result + polynomial[i] * BigInt(x) ** BigInt(i)) % prime;
     }
     return result;
 };
-exports.evaluatePolynomial = evaluatePolynomial;
 /**
  * Generates a single key share for a participant in a threshold ElGamal cryptosystem.
  *
@@ -27,20 +23,19 @@ exports.evaluatePolynomial = evaluatePolynomial;
  * @param {2048 | 3072 | 4096} primeBits - The bit length of the prime modulus (default: 2048).
  * @returns {PartyKeyPair} The key share containing a private and public key share for the participant.
  */
-const generateSingleKeyShare = (index, threshold, primeBits = 2048) => {
-    const group = (0, utils_1.getGroup)(primeBits);
+export const generateSingleKeyShare = (index, threshold, primeBits = 2048) => {
+    const group = getGroup(primeBits);
     const prime = group.prime;
     const generator = group.generator;
-    const polynomial = (0, utils_1.generatePolynomial)(threshold, prime);
-    let partyPrivateKey = (0, exports.evaluatePolynomial)(polynomial, index, prime);
+    const polynomial = generatePolynomial(threshold, prime);
+    let partyPrivateKey = evaluatePolynomial(polynomial, index, prime);
     // Ensure non-zero private key, adjusting index if necessary
     while (partyPrivateKey === 0n) {
-        partyPrivateKey = (0, exports.evaluatePolynomial)(polynomial, index + 1, prime);
+        partyPrivateKey = evaluatePolynomial(polynomial, index + 1, prime);
     }
-    const partyPublicKey = (0, bigint_mod_arith_1.modPow)(generator, partyPrivateKey, prime);
+    const partyPublicKey = modPow(generator, partyPrivateKey, prime);
     return { partyPrivateKey, partyPublicKey };
 };
-exports.generateSingleKeyShare = generateSingleKeyShare;
 /**
  * Generates key shares for a threshold ElGamal cryptosystem.
  *
@@ -49,15 +44,14 @@ exports.generateSingleKeyShare = generateSingleKeyShare;
  * @param {2048 | 3072 | 4096} primeBits - The bit length of the prime modulus (default: 2048).
  * @returns {PartyKeyPair[]} An array of key shares, each containing a private and public key share.
  */
-const generateKeyShares = (n, threshold, primeBits = 2048) => {
+export const generateKeyShares = (n, threshold, primeBits = 2048) => {
     const keyShares = [];
     for (let i = 1; i <= n; i++) {
-        const keyShare = (0, exports.generateSingleKeyShare)(i, threshold, primeBits);
+        const keyShare = generateSingleKeyShare(i, threshold, primeBits);
         keyShares.push(keyShare);
     }
     return keyShares;
 };
-exports.generateKeyShares = generateKeyShares;
 /**
  * Combines multiple public keys into a single public key.
  *
@@ -65,8 +59,7 @@ exports.generateKeyShares = generateKeyShares;
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The combined public key.
  */
-const combinePublicKeys = (publicKeys, prime) => publicKeys.reduce((acc, current) => (acc * current) % prime, 1n);
-exports.combinePublicKeys = combinePublicKeys;
+export const combinePublicKeys = (publicKeys, prime) => publicKeys.reduce((acc, current) => (acc * current) % prime, 1n);
 /**
  * Performs a partial decryption on a ciphertext using an individual's private key share.
  *
@@ -75,8 +68,7 @@ exports.combinePublicKeys = combinePublicKeys;
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The result of the partial decryption.
  */
-const createDecryptionShare = (encryptedMessage, partyPrivateKey, prime) => (0, bigint_mod_arith_1.modPow)(encryptedMessage.c1, partyPrivateKey, prime);
-exports.createDecryptionShare = createDecryptionShare;
+export const createDecryptionShare = (encryptedMessage, partyPrivateKey, prime) => modPow(encryptedMessage.c1, partyPrivateKey, prime);
 /**
  * Combines partial decryptions from multiple parties into a single decryption factor.
  *
@@ -84,14 +76,13 @@ exports.createDecryptionShare = createDecryptionShare;
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The combined decryption factor.
  */
-const combineDecryptionShares = (decryptionShares, prime) => {
+export const combineDecryptionShares = (decryptionShares, prime) => {
     let result = 1n;
     for (const partialDecryption of decryptionShares) {
         result = (result * partialDecryption) % prime;
     }
     return result;
 };
-exports.combineDecryptionShares = combineDecryptionShares;
 /**
  * Decrypts an encrypted secret using the combined partial decryptions in a threshold ElGamal scheme.
  *
@@ -100,9 +91,8 @@ exports.combineDecryptionShares = combineDecryptionShares;
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {number} The decrypted secret, assuming it was small enough to be directly encrypted.
  */
-const thresholdDecrypt = (encryptedMessage, combinedDecryptionShares, prime) => {
-    const combinedDecryptionInverse = (0, bigint_mod_arith_1.modInv)(combinedDecryptionShares, prime);
+export const thresholdDecrypt = (encryptedMessage, combinedDecryptionShares, prime) => {
+    const combinedDecryptionInverse = modInv(combinedDecryptionShares, prime);
     const plaintext = (encryptedMessage.c2 * combinedDecryptionInverse) % prime;
     return Number(plaintext);
 };
-exports.thresholdDecrypt = thresholdDecrypt;

package/dist/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/utils.js

@@ -1,48 +1,40 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generatePolynomial = exports.multiplyEncryptedValues = exports.getRandomBigIntegerInRange = exports.getGroup = void 0;
-const random_bigint_1 = __importDefault(require("random-bigint"));
-const constants_1 = require("./constants");
+import randomBigint from 'random-bigint';
+import { GROUPS } from './constants';
 /**
  * Retrieves the group parameters for a given prime bit length.
  *
  * @param {2048 | 3072 | 4096} primeBits - The bit length of the prime modulus (2048, 3072, or 4096).
  * @returns {Object} The group parameters including prime and generator.
  */
-const getGroup = (primeBits) => {
+export const getGroup = (primeBits) => {
     switch (primeBits) {
         case 2048:
-            return constants_1.GROUPS.ffdhe2048;
+            return GROUPS.ffdhe2048;
         case 3072:
-            return constants_1.GROUPS.ffdhe3072;
+            return GROUPS.ffdhe3072;
         case 4096:
-            return constants_1.GROUPS.ffdhe4096;
+            return GROUPS.ffdhe4096;
         default:
             throw new Error('Unsupported bit length');
     }
 };
-exports.getGroup = getGroup;
 /**
  * Generates a random bigint within a specified range.
  * @param {bigint} min - The minimum value (inclusive).
  * @param {bigint} max - The maximum value (exclusive).
  * @returns {bigint} A random bigint within the specified range.
  */
-const getRandomBigIntegerInRange = (min, max) => {
+export const getRandomBigIntegerInRange = (min, max) => {
     const range = max - min + 1n;
     // Determine the number of bits needed for the range
     const bitsNeeded = range.toString(2).length;
     // Generate a random bigint within the calculated bits
-    let num = (0, random_bigint_1.default)(bitsNeeded);
+    let num = randomBigint(bitsNeeded);
     // Adjust the number to our range
     num = num % range;
     // Add the minimum to align with our desired range
     return min + num;
 };
-exports.getRandomBigIntegerInRange = getRandomBigIntegerInRange;
 /**
  * Performs homomorphic multiplication on two encrypted values, allowing for encrypted arithmetic operations.
  * @param {EncryptedMessage} value1 - The first encrypted value.
@@ -50,12 +42,11 @@ exports.getRandomBigIntegerInRange = getRandomBigIntegerInRange;
  * @param {bigint} prime - The prime modulus used in the encryption system.
  * @returns {EncryptedMessage} The result of the multiplication, as a new encrypted message.
  */
-const multiplyEncryptedValues = (value1, value2, prime) => {
+export const multiplyEncryptedValues = (value1, value2, prime) => {
     const c1Multiplied = (value1.c1 * value2.c1) % prime;
     const c2Multiplied = (value1.c2 * value2.c2) % prime;
     return { c1: c1Multiplied, c2: c2Multiplied };
 };
-exports.multiplyEncryptedValues = multiplyEncryptedValues;
 /**
  * Generates a random polynomial of a specified degree, to be used in Shamir's Secret Sharing scheme.
  * The polynomial is of the form f(x) = a0 + a1*x + a2*x^2 + ... + a_{threshold-1}*x^{threshold-1},
@@ -64,11 +55,10 @@ exports.multiplyEncryptedValues = multiplyEncryptedValues;
  * @param {bigint} prime - The prime modulus used in the system, to ensure operations are performed in a finite field.
  * @returns {bigint[]} An array representing the polynomial coefficients `[a0, a1, ..., a_{threshold-1}]`.
  */
-const generatePolynomial = (threshold, prime) => {
-    const polynomial = [(0, exports.getRandomBigIntegerInRange)(2n, prime - 1n)]; // constant term is the "master" private key
+export const generatePolynomial = (threshold, prime) => {
+    const polynomial = [getRandomBigIntegerInRange(2n, prime - 1n)]; // constant term is the "master" private key
     for (let i = 1; i < threshold; i++) {
-        polynomial.push((0, exports.getRandomBigIntegerInRange)(0n, prime - 1n)); // random coefficients
+        polynomial.push(getRandomBigIntegerInRange(0n, prime - 1n)); // random coefficients
     }
     return polynomial;
 };
-exports.generatePolynomial = generatePolynomial;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "threshold-elgamal",
-    "version": "0.1.19",
+    "version": "0.1.21",
     "author": "Piotr Piech <piotr@piech.dev>",
     "license": "MIT",
     "description": "Threshold ElGamal in TypeScript",