[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

ciphers/paillier_cryptosystem.py

@@ -1,5 +1,5 @@
 """
-Paillier cryptosystem was introduced in 1999 by Pascal Paillier. It is 
+Paillier cryptosystem was introduced in 1999 by Pascal Paillier. It is
 an asymmetric algorithm for public key cryptography.
     ----Public-Key Cryptosystems Based on Composite Degree Residuosity Classes
     ----https://link.springer.com/content/pdf/10.1007/3-540-48910-X_16.pdf
@@ -52,18 +52,17 @@
 #         homomorphicADD()  ++
 #         homomorphicMUL()  ++
 
-
-
 import sympy
 import random
 
+
 class Utils:
     def primeGenerator(bit_size):
         """
         Uses sympy.randprime() for genearing a prime number
         of a particular bit-size
         """
-        low = 2**(bit_size -1)
+        low = 2 ** (bit_size - 1)
         high = (2**bit_size) - 1
         return sympy.randprime(low, high)
 
@@ -103,31 +102,33 @@ class Zn:
         """
         Model of set of Whole numbers less than n.
         """
+
         def __init__(self, n):
             # n :: n = p*q -> p,q are prime
             self.n = n
 
         def sample(self):
-            return random.randint(0, self.n-1)
+            return random.randint(0, self.n - 1)
 
-        def __contains__(self, item): # in operator
+        def __contains__(self, item):  # in operator
             return (0 <= item) and (item < self.n)
 
     class Zn_star:
         """
         Model of set of Natural numbers less than n
         which are invertible in (mod n) system.
         """
+
         def __init__(self, n):
             self.n = n
 
         def sample(self):
             while True:
-                temp = random.randint(1, self.n-1)
+                temp = random.randint(1, self.n - 1)
                 if Utils.GCD(temp, self.n) == 1:
                     return temp
 
-        def __contains__(self, item): # in operator
+        def __contains__(self, item):  # in operator
             if (1 <= item) and (item < self.n):
                 if Utils.GCD(item, self.n) == 1:
                     return True
@@ -138,6 +139,7 @@ class Zn2_star:
         Model of set of Natural numbers less than n^2
         which are invertible in (mod n^2) system.
         """
+
         def __init__(self, n):
             # n :: n = p*q -> p,q are prime
             self.n2 = n**2
@@ -146,16 +148,17 @@ def __init__(self, n):
 
         def sample(self):
             while True:
-                temp = random.randint(1, self.n2-1)
+                temp = random.randint(1, self.n2 - 1)
                 if Utils.GCD(temp, self.n2) == 1:
                     return temp
 
-        def __contains__(self, item): # in operator
+        def __contains__(self, item):  # in operator
             if (1 <= item) and (item < self.n2):
                 if Utils.GCD(item, self.n2) == 1:
                     return True
             return False
 
+
 class PaillierCryptosystem:
     def __init__(self, bit_size=256):
         self.bitSize = bit_size
@@ -186,25 +189,27 @@ def keyGen(self):
                 break
         self.p = p
         self.q = q
-        self.n = p*q
+        self.n = p * q
         self.n2 = self.n**2
-        self.g = self.n+1
-        self.l = (p-1)*(q-1)
-        self.lcm = Utils.LCM( (p-1), (q-1) )
+        self.g = self.n + 1
+        self.l = (p - 1) * (q - 1)
+        self.lcm = Utils.LCM((p - 1), (q - 1))
 
-        self.mu = Utils.getInverse( self.lcm, self.n) # mu = lambda^(-1) (mod n) -->> TRAPDOOR
+        self.mu = Utils.getInverse(
+            self.lcm, self.n
+        )  # mu = lambda^(-1) (mod n) -->> TRAPDOOR
 
         self.publicKey = {
-            "n": self.n,            # Main PUBLIC KEY
-            "n2": self.n2,          # Defining System - Computational Ease
-            "g": self.g,            # Main PUBLIC KEY
+            "n": self.n,  # Main PUBLIC KEY
+            "n2": self.n2,  # Defining System - Computational Ease
+            "g": self.g,  # Main PUBLIC KEY
         }
-        
+
         self.privateKey = {
-            'n': self.n,            # Defining System - Computational Ease - Available from PUBLIC KEY
-            'n2': self.n2,          # Defining System - Computational Ease - Available from PUBLIC KEY
-            "mu": self.mu,          # Main PRIVATE KEY
-            'lambda': self.lcm      # Main PRIVATE KEY
+            "n": self.n,  # Defining System - Computational Ease - Available from PUBLIC KEY
+            "n2": self.n2,  # Defining System - Computational Ease - Available from PUBLIC KEY
+            "mu": self.mu,  # Main PRIVATE KEY
+            "lambda": self.lcm,  # Main PRIVATE KEY
         }
 
     def getPublicKey(self):
@@ -219,7 +224,7 @@ def getPrivateKey(self):
         """
         return self.privateKey
 
-    def encrypt(pubKey : dict, msg : int):
+    def encrypt(pubKey: dict, msg: int):
         """
         Function to encrypt message using PRIVATE KEY.
 
@@ -232,8 +237,8 @@ def encrypt(pubKey : dict, msg : int):
         n2 = pubKey["n2"]
         g = pubKey["g"]
 
-        zn = Utils.Zn( n )
-        zn_star = Utils.Zn_star( n )
+        zn = Utils.Zn(n)
+        zn_star = Utils.Zn_star(n)
 
         # c = (g**x)(r**n) (mod n^2)
         assert msg in zn
@@ -242,9 +247,9 @@ def encrypt(pubKey : dict, msg : int):
 
         a = pow(g, msg, n2)
         b = pow(r, n, n2)
-        return (a*b) % n2
+        return (a * b) % n2
 
-    def decrypt(prvKey : dict, cypher : int):
+    def decrypt(prvKey: dict, cypher: int):
         """
         Function to decrypt cypher using PRIVATE KEY.
 
@@ -254,73 +259,76 @@ def decrypt(prvKey : dict, cypher : int):
         cypher belongs to Z(n^2) (all Naturals which are
         invertible in (mod n^2) system)
         """
-        n = prvKey['n']
-        n2 = prvKey['n2']
-        mu = prvKey['mu']
-        lmbda = prvKey['lambda']
-        
+        n = prvKey["n"]
+        n2 = prvKey["n2"]
+        mu = prvKey["mu"]
+        lmbda = prvKey["lambda"]
+
         t = pow(cypher, lmbda, n2)
-        t = ( Utils.L(t, n) )         # L(cypher ^ lambda) == lambda * message (mod n)
+        t = Utils.L(t, n)  # L(cypher ^ lambda) == lambda * message (mod n)
 
-        msg = (t * mu) % n                # (lambda * message) * mu == (lambda * message) * (lambda^-1) == msg (mod n)
+        msg = (
+            (t * mu) % n
+        )  # (lambda * message) * mu == (lambda * message) * (lambda^-1) == msg (mod n)
         return msg
 
-    def homomorphicADD(pubKey : dict, cypher1 : int, cypher2 : int):
+    def homomorphicADD(pubKey: dict, cypher1: int, cypher2: int):
         """
         cypher1 * cypher2 -->>  Encryption( msg1 + msg2 )
         Both the messages are encrypted and do not
         require decryption to perform Binary Operation (ADD)
-        
+
         E(m1) = (g^m1)*(r1^n) (mod n^2)
         E(m2) = (g*m2)*(r2^n) (mod n^2)
-        
+
         E(m1+m2) = E(m1)*E(m2) = (g^(m1+m2))*((r1*r2)^n) (mod n^2)
         """
-        n2 = pubKey['n2']
-        return (cypher1*cypher2) % n2
+        n2 = pubKey["n2"]
+        return (cypher1 * cypher2) % n2
 
-    def homomorphicMUL(pubKey : dict, cypher1 : int, msg2 : int):
+    def homomorphicMUL(pubKey: dict, cypher1: int, msg2: int):
         """
         cypher1 ** msg2 -->>  Encryption( msg1 * msg2 )
         It requires 2nd msg to be decrypted to perfrom
         Binary Operation (MUL).
-        
+
         E(m1) = (g^m1)*(r1^n) (mod n^2)
         m2 in Zn
-        
+
         E(m1*m2) = E(m1)^m2 (mod n^2)
         """
-        n2 = pubKey['n2']
+        n2 = pubKey["n2"]
         return pow(cypher1, msg2, n2)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     # base = 256
     for i in range(5, 9):
         base = 2**i
         print(f"TESTING BITSIZE : {base}")
         crypto = PaillierCryptosystem(base)
         crypto.keyGen()
-        
+
         pub = crypto.getPublicKey()
         msg = 233
         print(f"Msg       : {msg}")
         c = PaillierCryptosystem.encrypt(pub, msg)
-        print(f'Cypher    : {c}')
+        print(f"Cypher    : {c}")
 
         prv = crypto.getPrivateKey()
         d = PaillierCryptosystem.decrypt(prv, c)
-        print(f'Decryption: {d}')
+        print(f"Decryption: {d}")
         assert msg == d
-        
+
         msg2 = 232
         c2 = PaillierCryptosystem.encrypt(pub, msg2)
         c3 = PaillierCryptosystem.homomorphicADD(pub, c, c2)
         d3 = PaillierCryptosystem.decrypt(prv, c3)
-        assert d3 == (msg+msg2)
+        assert d3 == (msg + msg2)
         print("Homomorphic Add SUCCESSFUL")
 
         c4 = PaillierCryptosystem.homomorphicMUL(pub, c, msg2)
         d4 = PaillierCryptosystem.decrypt(prv, c4)
-        assert d4 == (msg*msg2)
+        assert d4 == (msg * msg2)
         print("Homomorphic Mul SUCCESSFUL")
-        print()
+        print()