feat: strongly typed ciphertext, public and private keys

Author: 10d9e

README.md

@@ -1,15 +1,19 @@
 # Paillier Solidity Smart Contract
+
 This Solidity smart contract provides functionalities for performing homomorphic encryption using the Paillier cryptosystem on the Ethereum blockchain. Homomorphic encryption allows computations to be performed on encrypted data without decrypting it first, providing privacy and security benefits.
 
 # Features
+
 - Addition of two encrypted values.
 - Multiplication of an encrypted value by a plaintext constant.
 - Encryption of zero.
 
 # Installation
+
 To use this smart contract, you need to deploy it on the Ethereum blockchain. You'll also need to import the BigNumbers.sol library for handling large numbers.
 
 # Usage
+
 1. Deploy the PaillierSolidity contract on the Ethereum blockchain.
 2. Import the contract into your Solidity code.
 3. Use the provided functions to perform homomorphic encryption operations.
@@ -19,6 +23,7 @@ To use this smart contract, you need to deploy it on the Ethereum blockchain. Yo
 The Paillier cryptosystem, which is homomorphic with respect to addition and multiplication, can be applied in various blockchain-based applications that require privacy-preserving computation. Here are five possible applications with corresponding example Solidity code snippets:
 
 ## Private Voting System
+
 In a voting system, votes can be encrypted using the Paillier cryptosystem. Each encrypted vote is a ciphertext representing either 0 or 1 (abstention or cast vote). The final tally can be computed without decrypting the individual votes.
 
 ```solidity
@@ -52,6 +57,7 @@ contract PrivateVoting {
 ```
 
 ## Privacy-Preserving Payroll:
+
 Payroll can be computed on-chain while preserving employees' salary privacy. Each employee's encrypted salary can be stored, and payroll totals can be computed without revealing individual salaries.
 
 ```solidity
@@ -86,6 +92,7 @@ contract PrivatePayroll {
 ```
 
 ## Anonymous Donations:
+
 In a charitable donation system, donors' contributions can be kept private. The total amount donated can be computed and verified without revealing individual contributions.
 
 ```solidity
@@ -119,6 +126,7 @@ contract AnonymousDonations {
 ```
 
 ## Private Auction:
+
 In a private auction, bids can be encrypted, and the winner can be determined without revealing other bidders' bid amounts.
 
 ```solidity
@@ -158,6 +166,7 @@ contract PrivateAuction {
 ```
 
 ## Private Tax Calculation:
+
 Tax calculations can be carried out on-chain while keeping individual taxpayers' incomes private. The total tax owed can be computed without revealing individual incomes.
 
 ```solidity
@@ -192,4 +201,8 @@ contract PrivateTaxCalculation {
         return total;
     }
 }
-```
+```
+
+# References
+
+https://github.com/jahali6128/paillier-solidity

contracts/Paillier.sol

@@ -3,6 +3,27 @@ pragma solidity ^0.8.24;
 
 import "./BigNum.sol";
 
+/// @title CipherText Struct
+/// @notice A struct to represent an encrypted value
+/// @dev The encrypted value is stored as a byte array
+struct Ciphertext {
+    bytes value;
+}
+
+/// @title PublicKey Struct
+/// @notice A struct to represent a public key
+/// @dev The public key is stored as a byte array
+struct PublicKey {
+    bytes value;
+}
+
+/// @title PrivateKey Struct
+/// @notice A struct to represent a private key
+/// @dev The private key is stored as a byte array
+struct PrivateKey {
+    bytes value;
+}
+
 /// @title Paillier Cryptosystem Implementation
 /// @author The developer
 /// @notice This contract provides basic operations for the Paillier cryptosystem
@@ -17,17 +38,25 @@ contract Paillier {
     /// @param publicKey The public key in bytes
     /// @return enc_sum The encrypted sum as a BigNumber
     function add(
-        bytes calldata a,
-        bytes calldata b,
-        bytes calldata publicKey
+        Ciphertext calldata a,
+        Ciphertext calldata b,
+        PublicKey calldata publicKey
     ) public view returns (BigNumber memory) {
         // Create BigNumber representations for the encrypted values and the public key
-        BigNumber memory enc_a = BigNumber(a, false, BigNum.bitLength(a));
-        BigNumber memory enc_b = BigNumber(b, false, BigNum.bitLength(b));
+        BigNumber memory enc_a = BigNumber(
+            a.value,
+            false,
+            BigNum.bitLength(a.value)
+        );
+        BigNumber memory enc_b = BigNumber(
+            b.value,
+            false,
+            BigNum.bitLength(b.value)
+        );
         BigNumber memory pub_n = BigNumber(
-            publicKey,
+            publicKey.value,
             false,
-            BigNum.bitLength(publicKey)
+            BigNum.bitLength(publicKey.value)
         );
 
         // Calculate the encrypted sum as enc_a * enc_b % pub_n^2
@@ -46,16 +75,20 @@ contract Paillier {
     /// @param publicKey The public key in bytes
     /// @return enc_result The encrypted result as a BigNumber
     function mul(
-        bytes calldata a,
+        Ciphertext calldata a,
         uint256 b,
-        bytes calldata publicKey
+        PublicKey calldata publicKey
     ) public view returns (BigNumber memory) {
         // Create BigNumber representations for the encrypted value and the public key
-        BigNumber memory enc_value = BigNumber(a, false, BigNum.bitLength(a));
+        BigNumber memory enc_value = BigNumber(
+            a.value,
+            false,
+            BigNum.bitLength(a.value)
+        );
         BigNumber memory pub_n = BigNumber(
-            publicKey,
+            publicKey.value,
             false,
-            BigNum.bitLength(publicKey)
+            BigNum.bitLength(publicKey.value)
         );
 
         // Calculate the encrypted result as enc_value^b % pub_n^2
@@ -74,14 +107,14 @@ contract Paillier {
     /// @return enc_zero The encrypted zero as a BigNumber
     function encryptZero(
         bytes calldata rnd,
-        bytes calldata publicKey
+        PublicKey calldata publicKey
     ) public view returns (BigNumber memory) {
         // Create BigNumber representations for the random value and the public key
         BigNumber memory rand = BigNumber(rnd, false, BigNum.bitLength(rnd));
         BigNumber memory pub_n = BigNumber(
-            publicKey,
+            publicKey.value,
             false,
-            BigNum.bitLength(publicKey)
+            BigNum.bitLength(publicKey.value)
         );
 
         // Calculate the encrypted zero as r^n % n^2
@@ -100,25 +133,25 @@ contract Paillier {
     /// @param publicKey The public key in bytes
     /// @return decryptedValue The decrypted value as a BigNumber
     function decrypt(
-        bytes calldata encValue,
-        bytes calldata privateKey,
-        bytes calldata publicKey
+        Ciphertext calldata encValue,
+        PrivateKey calldata privateKey,
+        PublicKey calldata publicKey
     ) public view returns (BigNumber memory) {
         // Create BigNumber representations for the encrypted value, private key, and public key
         BigNumber memory enc_value = BigNumber(
-            encValue,
+            encValue.value,
             false,
-            BigNum.bitLength(encValue)
+            BigNum.bitLength(encValue.value)
         );
         BigNumber memory lambda = BigNumber(
-            privateKey,
+            privateKey.value,
             false,
-            BigNum.bitLength(privateKey)
+            BigNum.bitLength(privateKey.value)
         );
         BigNumber memory n = BigNumber(
-            publicKey,
+            publicKey.value,
             false,
-            BigNum.bitLength(publicKey)
+            BigNum.bitLength(publicKey.value)
         );
 
         // Decrypt the value using private key lambda

hardhat.config.ts

@@ -2,7 +2,8 @@ import { HardhatUserConfig } from "hardhat/config";
 import "@nomicfoundation/hardhat-toolbox";
 require("@nomicfoundation/hardhat-chai-matchers");
 
-const mnemonic: string = "adapt mosquito move limb mobile illegal tree voyage juice mosquito burger raise father hope layer"
+const mnemonic: string =
+  "adapt mosquito move limb mobile illegal tree voyage juice mosquito burger raise father hope layer";
 const config: HardhatUserConfig = {
   solidity: "0.8.25",
   defaultNetwork: "hardhat",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "paillier-contracts",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Paillier homomorphic encryption contract",
   "license": "The Unlicense",
   "author": {

test/Paillier.ts

@@ -1,27 +1,42 @@
-import * as paillierBigint from 'paillier-bigint';
-import * as bigIntConversion from 'bigint-conversion';
+import * as paillierBigint from "paillier-bigint";
+import * as bigIntConversion from "bigint-conversion";
 import { ethers } from "hardhat";
 import { expect } from "chai";
 
-describe("Paillier", function () {
+// Public key
+interface PublicKey {
+    value: string;
+}
+
+// Ciphertext
+interface Ciphertext {
+    value: string;
+}
 
+describe("Paillier", function () {
     it("should add 2 ciphertexts", async function () {
-        const { publicKey, privateKey } = await paillierBigint.generateRandomKeys(256);
+        const Paillier = await ethers.deployContract("Paillier");
+
+        const { publicKey, privateKey } =
+            await paillierBigint.generateRandomKeys(256);
         const a: bigint = BigInt(1);
         const b: bigint = BigInt(2);
-        const enc_a = ethers.toBeHex(publicKey.encrypt(a));
-        const enc_b = ethers.toBeHex(publicKey.encrypt(b));
+        const enc_a: Ciphertext = {
+            value: ethers.toBeHex(publicKey.encrypt(a)),
+        };
+        const enc_b: Ciphertext = {
+            value: ethers.toBeHex(publicKey.encrypt(b)),
+        };
 
         // Public key
-        const pub_n = ethers.toBeHex(publicKey.n);
+        const pub_n: PublicKey = {
+            value: ethers.toBeHex(publicKey.n),
+        };
 
         // bit length will differ to what has been stated in this script.
-        // if using 256-bit key, bit_length will be 264 as "0x" prefix may have been factored in  
-
-        // Now lets deploy the contract
-        const [owner] = await ethers.getSigners();
-        const paillierSolidity = await ethers.deployContract("Paillier");
-        const enc_sum = await paillierSolidity.add(enc_a, enc_b, pub_n);
+        // if using 256-bit key, bit_length will be 264 as "0x" prefix may have been factored in
+        // Now lets deploy the contract and test the addition
+        const enc_sum = await Paillier.add(enc_a, enc_b, pub_n);
         const enc_sum_int = bigIntConversion.hexToBigint(enc_sum[0]);
 
         // Conversion to int for convenience
@@ -30,44 +45,41 @@ describe("Paillier", function () {
 
         // We want dec_sum to equal 3
         expect(dec_sum).to.equal(3);
-
     });
 
     it("should encrypt zero", async function () {
-        const { publicKey, privateKey } = await paillierBigint.generateRandomKeys(256);
-        const [owner] = await ethers.getSigners();
-        const paillierSolidity = await ethers.deployContract("Paillier");
-        // Arbitary random number - 10000
-        const rand = ethers.toBeHex(Math.floor(Math.random() * 10000));
+        const { publicKey, privateKey } =
+            await paillierBigint.generateRandomKeys(256);
+        const Paillier = await ethers.deployContract("Paillier");
+        // Arbitary random number - 1000000
+        const rand = ethers.toBeHex(Math.floor(Math.random() * 1000000));
 
         // Public key
-        const pub_n = ethers.toBeHex(publicKey.n);
-        const enc_zero = await paillierSolidity.encryptZero(rand, pub_n);
+        const pub_n = { value: ethers.toBeHex(publicKey.n) };
+        const enc_zero = await Paillier.encryptZero(rand, pub_n);
         const enc_zero_int = bigIntConversion.hexToBigint(enc_zero[0]);
         const dec_zero = Number(privateKey.decrypt(enc_zero_int));
         expect(dec_zero).to.equal(0);
-
     });
 
     it("should multiply encrypted value by a scalar", async function () {
-        const { publicKey, privateKey } = await paillierBigint.generateRandomKeys(256);
+        const { publicKey, privateKey } =
+            await paillierBigint.generateRandomKeys(256);
         const [owner] = await ethers.getSigners();
-        const paillierSolidity = await ethers.deployContract("Paillier");
+        const Paillier = await ethers.deployContract("Paillier");
         const a: bigint = BigInt(2);
         const b: bigint = BigInt(5);
-        const enc_a = ethers.toBeHex(publicKey.encrypt(a));
+        const enc_a = { value: ethers.toBeHex(publicKey.encrypt(a)) };
 
         // Public key
-        const pub_n = ethers.toBeHex(publicKey.n);
-        const enc_scalar = await paillierSolidity.mul(enc_a, b, pub_n);
+        const pub_n = { value: ethers.toBeHex(publicKey.n) };
+        const enc_scalar = await Paillier.mul(enc_a, b, pub_n);
 
         // returns tuple so get first index
         const enc_scalar_int = bigIntConversion.hexToBigint(enc_scalar[0]);
 
         const dec_scalar = Number(privateKey.decrypt(enc_scalar_int));
         console.log("Decrypted Scalar:", dec_scalar);
         expect(dec_scalar).to.equal(10);
-
     });
-
-});
+});