threshold-elgamal 0.1.28 → 0.1.30

package/README.md

@@ -54,32 +54,20 @@ First, import the whatever functions you need from the library:
 import { generateParameters, encrypt, decrypt } from "threshold-elgamal";
 ```
 
-### Generating Keys
-
-Generate a public/private key pair:
+### Generating keys, encrypting and decrypting a secret
 
 ```typescript
+// Generate a public/private key pair
+// If prime and generator aren't specified, they default to the 2048-bit group.
 const { publicKey, privateKey, prime, generator } = generateParameters();
-console.log(publicKey, privateKey, prime, generator); // ffdhe2048 group by default
-```
-
-### Encrypting a Message
 
-Encrypt a message using the public key:
+// Encrypt a message using the public key:
+const secret = 859;
+const encryptedMessage = encrypt(secret, publicKey, prime, generator);
 
-```typescript
-const secret = 42;
-const encryptedMessage = encrypt(secret, prime, generator, publicKey);
-console.log(encryptedMessage);
-```
-
-### Decrypting a Message
-
-Decrypt a message using the private key:
-
-```typescript
+// Decrypt the message using the private key:
 const decryptedMessage = decrypt(encryptedMessage, prime, privateKey);
-console.log(decryptedMessage); // 42
+// console.log(decryptedMessage); // 859
 ```
 
 ### Single secret shared with 3 participants
@@ -88,7 +76,6 @@ Threshold scheme for generating a common public key, sharing a secret to 3 parti
 
 ```typescript
 import {
-    getGroup,
     encrypt,
     generateKeys,
     combinePublicKeys,
@@ -98,7 +85,6 @@ import {
 } from "threshold-elgamal";
 
 const threshold = 3; // A scenario for 3 participants with a threshold of 3
-const { prime, generator } = getGroup(); // 2048-bit by default
 
 // Each participant generates their public key share and private key individually
 const participant1Keys = generateKeys(1, threshold);
@@ -114,28 +100,23 @@ const commonPublicKey = combinePublicKeys([
 
 // Encrypt a message using the combined public key
 const secret = 42;
-const encryptedMessage = encrypt(secret, prime, generator, commonPublicKey);
+const encryptedMessage = encrypt(secret, commonPublicKey);
 
 // Decryption shares
 const decryptionShares = [
-    createDecryptionShare(encryptedMessage, participant1Keys.privateKey, prime),
-    createDecryptionShare(encryptedMessage, participant2Keys.privateKey, prime),
-    createDecryptionShare(encryptedMessage, participant3Keys.privateKey, prime),
+    createDecryptionShare(encryptedMessage, participant1Keys.privateKey),
+    createDecryptionShare(encryptedMessage, participant2Keys.privateKey),
+    createDecryptionShare(encryptedMessage, participant3Keys.privateKey),
 ];
 // Combining the decryption shares into one, used to decrypt the message
-const combinedDecryptionShares = combineDecryptionShares(
-    decryptionShares,
-    prime,
-);
+const combinedDecryptionShares = combineDecryptionShares(decryptionShares);
 
 // Decrypting the message using the combined decryption shares
 const thresholdDecryptedMessage = thresholdDecrypt(
     encryptedMessage,
     combinedDecryptionShares,
-    prime,
 );
 console.log(thresholdDecryptedMessage); // 42
-expect(thresholdDecryptedMessage).toBe(secret);
 ```
 
 ### Voting and multiplication with threshold scheme for 3 participants
@@ -151,11 +132,9 @@ import {
     combineDecryptionShares,
     thresholdDecrypt,
     multiplyEncryptedValues,
-    getGroup,
 } from "threshold-elgamal";
 
 const threshold = 3; // A scenario for 3 participants with a threshold of 3
-const { prime, generator } = getGroup(); // 2048-bit by default
 
 // Each participant generates their public key share and private key individually
 const participant1Keys = generateKeys(1, threshold);
@@ -175,19 +154,21 @@ const voteOption2 = [10, 7, 4]; // Votes for option 2 by participants 1, 2, and
 
 // Encrypt votes for both options
 const encryptedVotesOption1 = voteOption1.map((vote) =>
-    encrypt(vote, prime, generator, commonPublicKey),
+    encrypt(vote, commonPublicKey),
 );
 const encryptedVotesOption2 = voteOption2.map((vote) =>
-    encrypt(vote, prime, generator, commonPublicKey),
+    encrypt(vote, commonPublicKey),
 );
 
 // Multiply encrypted votes together to aggregate
 const aggregatedEncryptedVoteOption1 = encryptedVotesOption1.reduce(
-    (acc, encryptedVote) => multiplyEncryptedValues(acc, encryptedVote, prime),
+    (talliedVotes, encryptedVote) =>
+        multiplyEncryptedValues(talliedVotes, encryptedVote),
     { c1: 1n, c2: 1n },
 );
 const aggregatedEncryptedVoteOption2 = encryptedVotesOption2.reduce(
-    (acc, encryptedVote) => multiplyEncryptedValues(acc, encryptedVote, prime),
+    (talliedVotes, encryptedVote) =>
+        multiplyEncryptedValues(talliedVotes, encryptedVote),
     { c1: 1n, c2: 1n },
 );
 
@@ -198,34 +179,28 @@ const decryptionSharesOption1 = [
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
         participant1Keys.privateKey,
-        prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
         participant2Keys.privateKey,
-        prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption1,
         participant3Keys.privateKey,
-        prime,
     ),
 ];
 const decryptionSharesOption2 = [
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
         participant1Keys.privateKey,
-        prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
         participant2Keys.privateKey,
-        prime,
     ),
     createDecryptionShare(
         aggregatedEncryptedVoteOption2,
         participant3Keys.privateKey,
-        prime,
     ),
 ];
 
@@ -234,22 +209,18 @@ const decryptionSharesOption2 = [
 // Only the decryption shares are shared with other participants.
 const combinedDecryptionSharesOption1 = combineDecryptionShares(
     decryptionSharesOption1,
-    prime,
 );
 const combinedDecryptionSharesOption2 = combineDecryptionShares(
     decryptionSharesOption2,
-    prime,
 );
 
 const finalTallyOption1 = thresholdDecrypt(
     aggregatedEncryptedVoteOption1,
     combinedDecryptionSharesOption1,
-    prime,
 );
 const finalTallyOption2 = thresholdDecrypt(
     aggregatedEncryptedVoteOption2,
     combinedDecryptionSharesOption2,
-    prime,
 );
 
 console.log(

package/dist/elgamal.d.ts

@@ -11,12 +11,12 @@ export declare const generateParameters: (primeBits?: 2048 | 3072 | 4096) => Par
  * Encrypts a secret using ElGamal encryption.
  *
  * @param {number} secret - The secret to be encrypted.
- * @param {bigint} prime - The prime number used in the encryption system.
- * @param {bigint} generator - The generator used in the encryption system.
  * @param {bigint} publicKey - The public key used for encryption.
+ * @param {bigint} prime - The prime number used in the encryption system. Defaults to the 2048-bit group's prime.
+ * @param {bigint} generator - The generator used in the encryption system. Defaults to the 2048-bit group's generator.
  * @returns {EncryptedMessage} The encrypted secret, consisting of two BigIntegers (c1 and c2).
  */
-export declare const encrypt: (secret: number, prime: bigint, generator: bigint, publicKey: bigint) => EncryptedMessage;
+export declare const encrypt: (secret: number, publicKey: bigint, prime?: bigint, generator?: bigint) => EncryptedMessage;
 /**
  * Decrypts an ElGamal encrypted secret.
  *

package/dist/elgamal.js

@@ -17,12 +17,12 @@ export const generateParameters = (primeBits = 2048) => {
  * Encrypts a secret using ElGamal encryption.
  *
  * @param {number} secret - The secret to be encrypted.
- * @param {bigint} prime - The prime number used in the encryption system.
- * @param {bigint} generator - The generator used in the encryption system.
  * @param {bigint} publicKey - The public key used for encryption.
+ * @param {bigint} prime - The prime number used in the encryption system. Defaults to the 2048-bit group's prime.
+ * @param {bigint} generator - The generator used in the encryption system. Defaults to the 2048-bit group's generator.
  * @returns {EncryptedMessage} The encrypted secret, consisting of two BigIntegers (c1 and c2).
  */
-export const encrypt = (secret, prime, generator, publicKey) => {
+export const encrypt = (secret, publicKey, prime = getGroup().prime, generator = getGroup().generator) => {
     if (secret >= Number(prime)) {
         throw new Error('Message is too large for direct encryption');
     }

package/dist/thresholdElgamal.d.ts

@@ -45,27 +45,27 @@ export declare const combinePublicKeys: (publicKeys: bigint[], prime?: bigint) =
  *
  * @param {EncryptedMessage} encryptedMessage - The encrypted secret.
  * @param {bigint} privateKey - The private key share of the decrypting party.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {bigint} The result of the partial decryption.
  */
-export declare const createDecryptionShare: (encryptedMessage: EncryptedMessage, privateKey: 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.
  *
  * @param {bigint[]} decryptionShares - An array of partial decryption results.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {bigint} The combined decryption factor.
  */
-export declare const combineDecryptionShares: (decryptionShares: bigint[], prime: bigint) => bigint;
+export declare const combineDecryptionShares: (decryptionShares: bigint[], prime?: bigint) => bigint;
 /**
  * Decrypts an encrypted secret using the combined partial decryptions in a threshold ElGamal scheme.
  *
  * @param {{ c1: bigint; c2: bigint }} encryptedMessage - The encrypted secret components.
  * @param {bigint} combinedDecryptionShares - The combined partial decryptions from all parties.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {number} The decrypted secret, assuming it was small enough to be directly encrypted.
  */
 export declare const thresholdDecrypt: (encryptedMessage: {
     c1: bigint;
     c2: bigint;
-}, combinedDecryptionShares: bigint, prime: bigint) => number;
+}, combinedDecryptionShares: bigint, prime?: bigint) => number;

package/dist/thresholdElgamal.js

@@ -59,24 +59,24 @@ export const generateKeyShares = (n, threshold, primeBits = 2048) => {
  * @param {bigint} prime - The prime modulus used in the ElGamal system.
  * @returns {bigint} The combined public key.
  */
-export const combinePublicKeys = (publicKeys, prime = getGroup(2048).prime) => publicKeys.reduce((acc, current) => (acc * current) % prime, 1n);
+export const combinePublicKeys = (publicKeys, prime = getGroup().prime) => publicKeys.reduce((combinedPublicKey, current) => (combinedPublicKey * current) % prime, 1n);
 /**
  * Performs a partial decryption on a ciphertext using an individual's private key share.
  *
  * @param {EncryptedMessage} encryptedMessage - The encrypted secret.
  * @param {bigint} privateKey - The private key share of the decrypting party.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {bigint} The result of the partial decryption.
  */
-export const createDecryptionShare = (encryptedMessage, privateKey, prime) => modPow(encryptedMessage.c1, privateKey, prime);
+export const createDecryptionShare = (encryptedMessage, privateKey, prime = getGroup().prime) => modPow(encryptedMessage.c1, privateKey, prime);
 /**
  * Combines partial decryptions from multiple parties into a single decryption factor.
  *
  * @param {bigint[]} decryptionShares - An array of partial decryption results.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {bigint} The combined decryption factor.
  */
-export const combineDecryptionShares = (decryptionShares, prime) => {
+export const combineDecryptionShares = (decryptionShares, prime = getGroup().prime) => {
     let result = 1n;
     for (const partialDecryption of decryptionShares) {
         result = (result * partialDecryption) % prime;
@@ -88,10 +88,10 @@ export const combineDecryptionShares = (decryptionShares, prime) => {
  *
  * @param {{ c1: bigint; c2: bigint }} encryptedMessage - The encrypted secret components.
  * @param {bigint} combinedDecryptionShares - The combined partial decryptions from all parties.
- * @param {bigint} prime - The prime modulus used in the ElGamal system.
+ * @param {bigint} prime - The prime modulus used in the ElGamal system. Defaults to the 2048-bit group prime.
  * @returns {number} The decrypted secret, assuming it was small enough to be directly encrypted.
  */
-export const thresholdDecrypt = (encryptedMessage, combinedDecryptionShares, prime) => {
+export const thresholdDecrypt = (encryptedMessage, combinedDecryptionShares, prime = getGroup().prime) => {
     const combinedDecryptionInverse = modInv(combinedDecryptionShares, prime);
     const plaintext = (encryptedMessage.c2 * combinedDecryptionInverse) % prime;
     return Number(plaintext);

package/dist/utils/testUtils.js

@@ -12,7 +12,7 @@ export const thresholdSetup = (partiesCount, threshold, primeBits = 2048) => {
 };
 export const testSecureEncryptionAndDecryption = (participantsCount, threshold, secret) => {
     const { keyShares, commonPublicKey, prime, generator } = thresholdSetup(participantsCount, threshold);
-    const encryptedMessage = encrypt(secret, prime, generator, commonPublicKey);
+    const encryptedMessage = encrypt(secret, commonPublicKey, prime, generator);
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
         .slice(0, threshold)
@@ -24,7 +24,7 @@ export const testSecureEncryptionAndDecryption = (participantsCount, threshold,
 export const homomorphicMultiplicationTest = (participantsCount, threshold, messages) => {
     const expectedProduct = messages.reduce((product, secret) => product * secret, 1);
     const { keyShares, commonPublicKey, prime, generator } = thresholdSetup(participantsCount, threshold);
-    const encryptedMessages = messages.map((secret) => encrypt(secret, prime, generator, commonPublicKey));
+    const encryptedMessages = messages.map((secret) => encrypt(secret, commonPublicKey, prime, generator));
     const encryptedProduct = encryptedMessages.reduce((product, encryptedMessage) => multiplyEncryptedValues(product, encryptedMessage, prime), { c1: 1n, c2: 1n });
     const selectedDecryptionShares = keyShares
         .sort(() => Math.random() - 0.5)
@@ -38,7 +38,7 @@ export const votingTest = (participantsCount, threshold, candidatesCount) => {
     const { keyShares, commonPublicKey, 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) => encrypt(vote, prime, generator, commonPublicKey)));
+    const encryptedVotesMatrix = votesMatrix.map((votes) => votes.map((vote) => encrypt(vote, commonPublicKey, prime, generator)));
     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)

package/dist/utils/utils.d.ts

@@ -36,10 +36,10 @@ export declare const getRandomBigIntegerInRange: (min: bigint, max: bigint) => b
  * Performs homomorphic multiplication on two encrypted values, allowing for encrypted arithmetic operations.
  * @param {EncryptedMessage} value1 - The first encrypted value.
  * @param {EncryptedMessage} value2 - The second encrypted value.
- * @param {bigint} prime - The prime modulus used in the encryption system.
+ * @param {bigint} prime - The prime modulus used in the encryption system. Defaults to the 2048-bit group prime.
  * @returns {EncryptedMessage} The result of the multiplication, as a new encrypted message.
  */
-export declare const multiplyEncryptedValues: (value1: EncryptedMessage, value2: EncryptedMessage, prime: bigint) => EncryptedMessage;
+export declare const multiplyEncryptedValues: (value1: EncryptedMessage, value2: EncryptedMessage, prime?: bigint) => EncryptedMessage;
 /**
  * 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},

package/dist/utils/utils.js

@@ -70,10 +70,10 @@ export const getRandomBigIntegerInRange = (min, max) => {
  * Performs homomorphic multiplication on two encrypted values, allowing for encrypted arithmetic operations.
  * @param {EncryptedMessage} value1 - The first encrypted value.
  * @param {EncryptedMessage} value2 - The second encrypted value.
- * @param {bigint} prime - The prime modulus used in the encryption system.
+ * @param {bigint} prime - The prime modulus used in the encryption system. Defaults to the 2048-bit group prime.
  * @returns {EncryptedMessage} The result of the multiplication, as a new encrypted message.
  */
-export const multiplyEncryptedValues = (value1, value2, prime) => {
+export const multiplyEncryptedValues = (value1, value2, prime = getGroup().prime) => {
     const c1Multiplied = (value1.c1 * value2.c1) % prime;
     const c2Multiplied = (value1.c2 * value2.c2) % prime;
     return { c1: c1Multiplied, c2: c2Multiplied };

package/package.json

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