threshold-elgamal 0.1.24 → 0.1.26

package/README.md

@@ -29,9 +29,8 @@ The JavaScript/TypeScript ecosystem seems to be lacking in modern, functional El
 ## Production dependencies
 
 -   [bigint-mod-arith](https://www.npmjs.com/package/bigint-mod-arith)
--   [random-bigint](https://www.npmjs.com/package/random-bigint)
 
-It has no other production dependencies apart from these two. They could be inlined easily, if needed.
+It has no other production dependencies apart from this one. It could be inlined easily, if needed.
 
 ## TODO
 
@@ -91,41 +90,28 @@ Threshold scheme for generating a common public key, sharing a secret to 3 parti
 import {
     getGroup,
     encrypt,
-    generateSingleKeyShare,
+    generateKeys,
     combinePublicKeys,
     createDecryptionShare,
     combineDecryptionShares,
     thresholdDecrypt,
 } from "threshold-elgamal";
-import type { PartyKeyPair } from "threshold-elgamal";
 
 const primeBits = 2048; // Bit length of the prime modulus
 const threshold = 3; // A scenario for 3 participants with a threshold of 3
 const { prime, generator } = getGroup(2048);
 
 // Each participant generates their public key share and private key individually
-const participant1KeyShare: PartyKeyPair = generateSingleKeyShare(
-    1,
-    threshold,
-    primeBits,
-);
-const participant2KeyShare: PartyKeyPair = generateSingleKeyShare(
-    2,
-    threshold,
-    primeBits,
-);
-const participant3KeyShare: PartyKeyPair = generateSingleKeyShare(
-    3,
-    threshold,
-    primeBits,
-);
+const participant1Keys = generateKeys(1, threshold, primeBits);
+const participant2Keys = generateKeys(2, threshold, primeBits);
+const participant3Keys = generateKeys(3, threshold, primeBits);
 
 // Combine the public keys to form a single public key
 const combinedPublicKey = combinePublicKeys(
     [
-        participant1KeyShare.partyPublicKey,
-        participant2KeyShare.partyPublicKey,
-        participant3KeyShare.partyPublicKey,
+        participant1Keys.publicKey,
+        participant2Keys.publicKey,
+        participant3Keys.publicKey,
     ],
     prime,
 );
@@ -136,21 +122,9 @@ const encryptedMessage = encrypt(secret, prime, generator, combinedPublicKey);
 
 // Decryption shares
 const decryptionShares = [
-    createDecryptionShare(
-        encryptedMessage,
-        participant1KeyShare.partyPrivateKey,
-        prime,
-    ),
-    createDecryptionShare(
-        encryptedMessage,
-        participant2KeyShare.partyPrivateKey,
-        prime,
-    ),
-    createDecryptionShare(
-        encryptedMessage,
-        participant3KeyShare.partyPrivateKey,
-        prime,
-    ),
+    createDecryptionShare(encryptedMessage, participant1Keys.privateKey, prime),
+    createDecryptionShare(encryptedMessage, participant2Keys.privateKey, prime),
+    createDecryptionShare(encryptedMessage, participant3Keys.privateKey, prime),
 ];
 // Combining the decryption shares into one, used to decrypt the message
 const combinedDecryptionShares = combineDecryptionShares(
@@ -174,7 +148,7 @@ This example demonstrates a 1 to 10 voting scenario where 3 participants cast en
 ```typescript
 import {
     encrypt,
-    generateSingleKeyShare,
+    generateKeys,
     combinePublicKeys,
     createDecryptionShare,
     combineDecryptionShares,
@@ -182,35 +156,22 @@ import {
     multiplyEncryptedValues,
     getGroup,
 } from "threshold-elgamal";
-import type { PartyKeyPair } from "threshold-elgamal";
 
 const primeBits = 2048; // Bit length of the prime modulus
 const threshold = 3; // A scenario for 3 participants with a threshold of 3
 const { prime, generator } = getGroup(2048);
 
 // Each participant generates their public key share and private key individually
-const participant1KeyShare: PartyKeyPair = generateSingleKeyShare(
-    1,
-    threshold,
-    primeBits,
-);
-const participant2KeyShare: PartyKeyPair = generateSingleKeyShare(
-    2,
-    threshold,
-    primeBits,
-);
-const participant3KeyShare: PartyKeyPair = generateSingleKeyShare(
-    3,
-    threshold,
-    primeBits,
-);
+const participant1Keys = generateKeys(1, threshold, primeBits);
+const participant2Keys = generateKeys(2, threshold, primeBits);
+const participant3Keys = generateKeys(3, threshold, primeBits);
 
 // Combine the public keys to form a single public key
 const combinedPublicKey = combinePublicKeys(
     [
-        participant1KeyShare.partyPublicKey,
-        participant2KeyShare.partyPublicKey,
-        participant3KeyShare.partyPublicKey,
+        participant1Keys.publicKey,
+        participant2Keys.publicKey,
+        participant3Keys.publicKey,
     ],
     prime,
 );
@@ -229,11 +190,11 @@ const encryptedVotesOption2 = voteOption2.map((vote) =>
 
 // Multiply encrypted votes together to aggregate
 const aggregatedEncryptedVoteOption1 = encryptedVotesOption1.reduce(
-    (acc, current) => multiplyEncryptedValues(acc, current, prime),
+    (acc, encryptedVote) => multiplyEncryptedValues(acc, encryptedVote, prime),
     { c1: 1n, c2: 1n },
 );
 const aggregatedEncryptedVoteOption2 = encryptedVotesOption2.reduce(
-    (acc, current) => multiplyEncryptedValues(acc, current, prime),
+    (acc, encryptedVote) => multiplyEncryptedValues(acc, encryptedVote, prime),
     { c1: 1n, c2: 1n },
 );
 
@@ -243,34 +204,34 @@ const aggregatedEncryptedVoteOption2 = encryptedVotesOption2.reduce(
 const decryptionSharesOption1 = [
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
-        participant1KeyShare.partyPrivateKey,
+        participant1Keys.privateKey,
         prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
-        participant2KeyShare.partyPrivateKey,
+        participant2Keys.privateKey,
         prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
-        participant3KeyShare.partyPrivateKey,
+        participant3Keys.privateKey,
         prime,
     ),
 ];
 const decryptionSharesOption2 = [
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
-        participant1KeyShare.partyPrivateKey,
+        participant1Keys.privateKey,
         prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
-        participant2KeyShare.partyPrivateKey,
+        participant2Keys.privateKey,
         prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
-        participant3KeyShare.partyPrivateKey,
+        participant3Keys.privateKey,
         prime,
     ),
 ];

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,4 +1,4 @@
 import { generateParameters, encrypt, decrypt } from "./elgamal.js";
-import { generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, } from "./thresholdElgamal.js";
+import { generateKeys, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, } from "./thresholdElgamal.js";
 import { getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, } from "./utils/utils.js";
-export { generateParameters, encrypt, decrypt, generateSingleKeyShare, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, };
+export { generateParameters, encrypt, decrypt, generateKeys, generateKeyShares, combinePublicKeys, createDecryptionShare, combineDecryptionShares, thresholdDecrypt, getRandomBigIntegerInRange, multiplyEncryptedValues, getGroup, };

package/dist/thresholdElgamal.d.ts

@@ -1,4 +1,4 @@
-import type { EncryptedMessage, PartyKeyPair } from './types';
+import type { EncryptedMessage } from './types';
 /**
  * Evaluates a polynomial at a given point using modular arithmetic.
  *
@@ -14,18 +14,24 @@ export declare const evaluatePolynomial: (polynomial: bigint[], x: number, prime
  * @param {number} index - The unique index of the participant (starting from 1).
  * @param {number} threshold - The minimum number of key shares required for decryption.
  * @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.
+ * @returns { privateKey: bigint; publicKey: bigint} The key share containing a private and public key share for the participant.
  */
-export declare const generateSingleKeyShare: (index: number, threshold: number, primeBits?: 2048 | 3072 | 4096) => PartyKeyPair;
+export declare const generateKeys: (index: number, threshold: number, primeBits?: 2048 | 3072 | 4096) => {
+    privateKey: bigint;
+    publicKey: bigint;
+};
 /**
  * Generates key shares for a threshold ElGamal cryptosystem.
  *
  * @param {number} n - The total number of key shares.
  * @param {number} threshold - The minimum number of key shares required for decryption.
  * @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.
+ * @returns {{ privateKey: bigint; publicKey: bigint }[]} An array of key shares, each containing a private and public key share.
  */
-export declare const generateKeyShares: (n: number, threshold: number, primeBits?: 2048 | 3072 | 4096) => PartyKeyPair[];
+export declare const generateKeyShares: (n: number, threshold: number, primeBits?: 2048 | 3072 | 4096) => {
+    privateKey: bigint;
+    publicKey: bigint;
+}[];
 /**
  * Combines multiple public keys into a single public key.
  *
@@ -38,11 +44,11 @@ export declare const combinePublicKeys: (publicKeys: bigint[], prime: bigint) =>
  * Performs a partial decryption on a ciphertext using an individual's private key share.
  *
  * @param {EncryptedMessage} encryptedMessage - The encrypted secret.
- * @param {bigint} partyPrivateKey - The private key share of the decrypting party.
+ * @param {bigint} privateKey - The private key share of the decrypting party.
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The result of the partial decryption.
  */
-export declare const createDecryptionShare: (encryptedMessage: EncryptedMessage, partyPrivateKey: bigint, prime: bigint) => bigint;
+export declare const createDecryptionShare: (encryptedMessage: EncryptedMessage, privateKey: bigint, prime: bigint) => bigint;
 /**
  * Combines partial decryptions from multiple parties into a single decryption factor.
  *

package/dist/thresholdElgamal.js

@@ -21,20 +21,20 @@ export const evaluatePolynomial = (polynomial, x, prime) => {
  * @param {number} index - The unique index of the participant (starting from 1).
  * @param {number} threshold - The minimum number of key shares required for decryption.
  * @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.
+ * @returns { privateKey: bigint; publicKey: bigint} The key share containing a private and public key share for the participant.
  */
-export const generateSingleKeyShare = (index, threshold, primeBits = 2048) => {
+export const generateKeys = (index, threshold, primeBits = 2048) => {
     const group = getGroup(primeBits);
     const prime = group.prime;
     const generator = group.generator;
     const polynomial = generatePolynomial(threshold, prime);
-    let partyPrivateKey = evaluatePolynomial(polynomial, index, prime);
+    let privateKey = evaluatePolynomial(polynomial, index, prime);
     // Ensure non-zero private key, adjusting index if necessary
-    while (partyPrivateKey === 0n) {
-        partyPrivateKey = evaluatePolynomial(polynomial, index + 1, prime);
+    while (privateKey === 0n) {
+        privateKey = evaluatePolynomial(polynomial, index + 1, prime);
     }
-    const partyPublicKey = modPow(generator, partyPrivateKey, prime);
-    return { partyPrivateKey, partyPublicKey };
+    const publicKey = modPow(generator, privateKey, prime);
+    return { privateKey, publicKey };
 };
 /**
  * Generates key shares for a threshold ElGamal cryptosystem.
@@ -42,12 +42,12 @@ export const generateSingleKeyShare = (index, threshold, primeBits = 2048) => {
  * @param {number} n - The total number of key shares.
  * @param {number} threshold - The minimum number of key shares required for decryption.
  * @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.
+ * @returns {{ privateKey: bigint; publicKey: bigint }[]} An array of key shares, each containing a private and public key share.
  */
 export const generateKeyShares = (n, threshold, primeBits = 2048) => {
     const keyShares = [];
     for (let i = 1; i <= n; i++) {
-        const keyShare = generateSingleKeyShare(i, threshold, primeBits);
+        const keyShare = generateKeys(i, threshold, primeBits);
         keyShares.push(keyShare);
     }
     return keyShares;
@@ -64,11 +64,11 @@ export const combinePublicKeys = (publicKeys, prime) => publicKeys.reduce((acc,
  * Performs a partial decryption on a ciphertext using an individual's private key share.
  *
  * @param {EncryptedMessage} encryptedMessage - The encrypted secret.
- * @param {bigint} partyPrivateKey - The private key share of the decrypting party.
+ * @param {bigint} privateKey - The private key share of the decrypting party.
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The result of the partial decryption.
  */
-export const createDecryptionShare = (encryptedMessage, partyPrivateKey, prime) => modPow(encryptedMessage.c1, partyPrivateKey, prime);
+export const createDecryptionShare = (encryptedMessage, privateKey, prime) => modPow(encryptedMessage.c1, privateKey, prime);
 /**
  * Combines partial decryptions from multiple parties into a single decryption factor.
  *

package/dist/types.d.ts

@@ -8,11 +8,3 @@ export type Parameters = {
     publicKey: bigint;
     privateKey: bigint;
 };
-export type KeyPair = {
-    privateKey: bigint;
-    publicKey: bigint;
-};
-export type PartyKeyPair = {
-    partyPrivateKey: bigint;
-    partyPublicKey: bigint;
-};

package/dist/utils/testUtils.d.ts

@@ -1,7 +1,9 @@
-import type { PartyKeyPair } from '../types';
 export declare const getRandomScore: (min?: number, max?: number) => number;
 export declare const thresholdSetup: (partiesCount: number, threshold: number, primeBits?: 2048 | 3072 | 4096) => {
-    keyShares: PartyKeyPair[];
+    keyShares: {
+        privateKey: bigint;
+        publicKey: bigint;
+    }[];
     combinedPublicKey: bigint;
     prime: bigint;
     generator: bigint;

package/dist/utils/testUtils.js

@@ -6,7 +6,7 @@ export const getRandomScore = (min = 1, max = 10) => Math.floor(Math.random() *
 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 publicKeys = keyShares.map((ks) => ks.publicKey);
     const combinedPublicKey = combinePublicKeys(publicKeys, prime);
     return { keyShares, combinedPublicKey, prime, generator };
 };
@@ -16,7 +16,7 @@ export const testSecureEncryptionAndDecryption = (participantsCount, threshold,
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
         .slice(0, threshold)
-        .map((keyShare) => createDecryptionShare(encryptedMessage, keyShare.partyPrivateKey, prime));
+        .map(({ privateKey }) => createDecryptionShare(encryptedMessage, privateKey, prime));
     const combinedDecryptionShares = combineDecryptionShares(selectedDecryptionShares, prime);
     const decryptedMessage = thresholdDecrypt(encryptedMessage, combinedDecryptionShares, prime);
     expect(decryptedMessage).toBe(secret);
@@ -29,7 +29,7 @@ export const homomorphicMultiplicationTest = (participantsCount, threshold, mess
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
         .slice(0, threshold)
-        .map((keyShare) => createDecryptionShare(encryptedProduct, keyShare.partyPrivateKey, prime));
+        .map(({ privateKey }) => createDecryptionShare(encryptedProduct, privateKey, prime));
     const combinedDecryptionShares = combineDecryptionShares(selectedDecryptionShares, prime);
     const decryptedProduct = thresholdDecrypt(encryptedProduct, combinedDecryptionShares, prime);
     expect(decryptedProduct).toBe(expectedProduct);
@@ -42,7 +42,7 @@ export const votingTest = (participantsCount, threshold, candidatesCount) => {
     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) => createDecryptionShare(product, keyShare.partyPrivateKey, prime)));
+        .map((keyShare) => createDecryptionShare(product, keyShare.privateKey, prime)));
     const decryptedProducts = partialDecryptionsMatrix.map((decryptionShares) => {
         const combinedDecryptionShares = combineDecryptionShares(decryptionShares, prime);
         const encryptedProduct = encryptedProducts[partialDecryptionsMatrix.indexOf(decryptionShares)];

package/package.json

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