包含ElGamal、Paillier、Goldweiser-Micali和DGK同态加密系统.zip

# Homomorphic Encryption [](https://github.com/AndrewQuijano/Homomorphic_Encryption/actions/workflows/build-gradle-project.yml) [](https://codecov.io/gh/AndrewQuijano/Homomorphic_Encryption) Homomorphic Encryption is a Java library that implements the following partially homomorphic encryption systems: * Paillier * El-Gamal (Additive or multiplicative) * Goldwasser-Micali * DGK As the partially homomorphic encryption systems only support addition with two ciphertexts, other protocols been appended to extend its functionality, in particular: * Secure Multiplication * Secure Division * Secure Comparison ## Installation Please retrieve the JAR file from [here](https://github.com/AndrewQuijano/Homomorphic_Encryption/tags) As this library uses Java 8, the JAR file can be imported into an Android project. If you want to review/edit the library, import the JAVA_PHE directory into a Eclipse project and edit as necessary. The Main.java folder only exists for testing and provide examples of how to use the library. ## Usage Import the packages as necessary. For basic usage please check Server.java in the test package for basic usage of these cryptography libraries. Please view Client.java and Server.java for an example how to compare encrypted numbers, secure multiplication, secure division, etc. # security.socialistmillionaire.alice **Initialize** ```java alice Niu = new alice(new Socket("192.168.1.208", 9254)); // These Public Keys are made by Bob and automatically sent to Alice. PaillierPublicKey pk = Niu.getPaillierPublicKey(); DGKPublicKey pubKey = Niu.getDGKPublicKey(); ElGamalPublicKey e_pk = Niu.getElGamalPublicKey(); ``` **Protocol1(x)** See Protocol 1 in "Improving the DGK comparison protocol" in Alice section. Compare with plaintext value y Bob has. * Parameters * plaintext (**BigInteger**) * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * If the plaintext has more bits than what the DGK public key supports. **Protocol2(x, y)** See Protocol 2 in "Improving the DGK comparison protocol" in Alice section. * Parameters * x (**BigInteger**) - a Paillier/DGK encrypted value * y (**BigInteger**) - a Paillier/DGK encrypted value * Returns * value (**boolean**) - x >= y * Raises (**HomomorphicException**) * N/A **Protocol3(x)** See Protocol 3 in "Improving the DGK comparison protocol" in Alice section. Compare with plaintext value y held by bob * Parameters * x (**BigInteger**) - plaintext * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * If the plaintext has more bits than what the DGK public key supports **Modified_Protocol3(x)** See Protocol 3 in "Correction to 'Improving the DGK comparison protocol'" in Alice section. View the sub-protocol. * Parameters * x (**BigInteger**) - plaintext * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * N/A **Protocol4(x, y)** See Protocol 3 in "Correct to 'Improving the DGK comparison protocol'" in Alice section. * Parameters * x (**BigInteger**) - Paillier or DGK encrypted value * y (**BigInteger**) - Paillier or DGK encrypted value * Returns * value (**boolean**) - x >= y * Raises (**HomomorphicException**) * ```java BigInteger x = new BigInteger("50"); BigInteger y = new BigInteger("51"); // Note: Assume bob is sharing y = new BigIntger("55"); Niu.Protocol1(x); // TRUE, X <= Y Niu.Protocol3(x);// TRUE X <= Y Niu.Modified_Protocol3(x); // TRUE X <= Y // Note: Protocol 2 only works with Paillier encrypted values! // Note: Protocol 2/4 works with Paillier/DGK encrypted values! x = PaillierCipher.encrypt(x, pk); y = PaillierCipher.encrypt(y, pk); Niu.Protocol2(x, y); // FALSE, b.c X >= Y is FALSE Niu.Protocol4(x, y); // FALSE: b.c X >= Y is FALSE ``` **division(x, y)** Please review Protocol 2 in the "Encrypted Integer Division" paper by Thjis Veugen * Parameters * x (**BigInteger**) - Paillier or DGK encrypted value * d (**BigInteger**) - plaintext value * Returns * ciphertext (**BigInteger**) - x/d * Raises (**HomomorphicException**) * Constraints: 0 <= x <= N * 2^{-sigma} and 0 <= d < N **multiplication(x, y)** * Parameters * x (**BigInteger**) - Paillier or DGK encrypted value * y (**BigInteger**) - Paillier or DGK encrypted value * Returns * ciphertext (**BigInteger**) - x * y * Raises (**HomomorphicException**) * Constraints: 0 <= x <= N * 2^{-sigma} and 0 <= d < N **bubbleSort(arr)** * Parameters * arr (**BigInteger**) - List of Paillier or DGK encrypted value * Returns * N/A - arr is list of sorted encrypted values from low to high * Raises (**HomomorphicException**) * N/A **getKMax(arr, k)** * Parameters * arr (**List<BigInteger>**) - List of Paillier or DGK encrypted value * k - get number of k largest encrypted numbers * Returns * a (**List<BigInteger>**) - new array of size k sorted from low to high * Raises (**HomomorphicException**) * N/A **getKMin(arr, k)** * Parameters * arr (**List<BigInteger>**) - List of Paillier or DGK encrypted value * k - get number of k smallest encrypted numbers * Returns * a (**List<BigInteger>**) - new array of size k sorted from low to high * Raises (**HomomorphicException**) * N/A # security.socialistmillionaire.bob **Initialize** ```java ServerSocket bob_socket = null; Socket bob_client = null; int KEY_SIZE = 1024; bob andrew = null; // Build all Key Pairs PaillierKeyPairGenerator p = new PaillierKeyPairGenerator(); p.initialize(KEY_SIZE, null); KeyPair pe = p.generateKeyPair(); DGKKeyPairGenerator d = new DGKKeyPairGenerator(); d.initialize(KEY_SIZE, null); KeyPair DGK = d.generateKeyPair(); ElGamalKeyPairGenerator pg = new ElGamalKeyPairGenerator(); pg.initialize(KEY_SIZE, new SecureRandom()); KeyPair el_gamal = pg.generateKeyPair(); bob_socket = new ServerSocket(9254); bob_client = bob_socket.accept(); // Note: Alice automatically gets the public keys! andrew = new bob(bob_client, pe, DGK, el_gamal); ``` **Protocol1(y)** See Protocol 1 in "Improving the DGK comparison protocol" in Bob section. Compare with plaintext value y Bob has. * Parameters * plaintext (**BigInteger**) * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * If the plaintext has more bits than what the DGK public key supports. **Protocol2()** See Protocol 2 in "Improving the DGK comparison protocol" in Bob section. * Parameters * N/A * Returns * value (**boolean**) - x >= y * Raises (**HomomorphicException**) * N/A **Protocol3(y)** See Protocol 3 in "Improving the DGK comparison protocol" in Bob section. Compare with plaintext value y held by bob * Parameters * y (**BigInteger**) - plaintext * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * If the plaintext has more bits than what the DGK public key supports **Modified_Protocol3(y)** See Protocol 3 in "Correction to 'Improving the DGK comparison protocol'" in Bob section. View the sub-protocol. * Parameters * y (**BigInteger**) - plaintext * Returns * value (**boolean**) - x <= y * Raises (**HomomorphicException**) * N/A **Protocol4()** See Protocol 3 in "Correct to 'Improving the DGK comparison protocol'" in Bob section. * Parameters * N/A * Returns * value (**boolean**) - x >= y * Raises (**HomomorphicException**) * ```java ``` **division(x, y)** Please review Protocol 2 in the "Encrypted Integer Division" paper by Thjis Veugen * Parameters * d (**BigInteger**) - plaintext value * Returns * N/A * Raises (**HomomorphicException**) * Constraints: 0 <= x <= N * 2^{-sigma