pryvx 2.4.9__tar.gz → 2.6.0__tar.gz

{pryvx-2.4.9 → pryvx-2.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pryvx
-Version: 2.4.9
+Version: 2.6.0
 Summary: A comprehensive package for privacy-enhancing technologies
 Home-page: UNKNOWN
 Author: PryvX (Jayesh Kenaudekar)

{pryvx-2.4.9 → pryvx-2.6.0}/pryvx/__init__.py

@@ -2,4 +2,5 @@ from .psi import OPRF
 from .phe import PHE
 from .smpc import SMPC
 from .gdp import GDP
-from .ldp import LDP
+from .ldp import LDP
+from .rtphe import RTPHE

{pryvx-2.4.9 → pryvx-2.6.0}/pryvx/phe.py

@@ -1,6 +1,7 @@
 import random
 from sympy import mod_inverse, isprime, nextprime
 import math
+import hashlib
 
 def generate_prime(bits=512):
     while True:
@@ -29,6 +30,11 @@ class PHE:
     @staticmethod
     def encode(value, scale_factor=1000):
         return int(round(value * scale_factor))
+    
+    @staticmethod
+    def hash_to_bigint(data: str) -> int:
+        digest = hashlib.sha256(data.encode()).hexdigest()
+        return int(digest, 16)
 
     @staticmethod
     def decode(value, scale_factor=1000):

pryvx-2.6.0/pryvx/rtphe.py

@@ -0,0 +1,147 @@
+import random
+from sympy import mod_inverse, isprime, nextprime
+import math
+import hashlib
+import secrets
+
+def prove_dec(pub, c, m, r):
+    """
+    Non‑interactive PPK:
+        a = g^u · w^n
+        e = H(c || a)      (Fiat–Shamir)
+        z = u + e·m  (mod n)
+        w' = w · r^e (mod n)
+        π = (a, z, w')
+    """
+    n, g = pub ; n2 = n*n
+    u  = secrets.randbelow(n)
+    w  = secrets.randbelow(n)
+    a  = (pow(g, u, n2) * pow(w, n, n2)) % n2
+
+    e  = int.from_bytes(
+            hashlib.sha256(str(c).encode() + str(a).encode()).digest(),
+            'big') % n
+
+    z  = (u + e * m) % n
+    w_ = (w * pow(r, e, n)) % n
+    return a, z, w_
+
+def verify_dec(pub, c, m, proof):
+    n, g = pub ; n2 = n*n
+    a, z, w_ = proof
+    e = int.from_bytes(
+            hashlib.sha256(str(c).encode() + str(a).encode()).digest(),
+            'big') % n
+    left  = (pow(g, z, n2) * pow(w_, n, n2)) % n2
+    right = (pow(c, e, n2) * a) % n2
+    return left == right
+
+def generate_prime(bits=512):
+    while True:
+        p = nextprime(random.getrandbits(bits))
+        if isprime(p):
+            return p
+
+def lcm(a, b):
+    return abs(a * b) // math.gcd(a, b)
+
+class RTPHE:
+
+    @staticmethod
+    def keygen(bits=64):
+        p = generate_prime(bits)
+        q = generate_prime(bits)
+        n = p * q
+        lambda_n = lcm(p - 1, q - 1)
+        g = n + 1
+        mu = mod_inverse((pow(g, lambda_n, n * n) - 1) // n, n)
+        public_key = (n, g)
+        private_key = (lambda_n, mu)
+        return public_key, private_key
+
+    @staticmethod
+    def encrypt(public_key, plaintext, r=None):
+        n, g = public_key
+        if r is None:
+            r = random.randint(1, n - 1)
+            while math.gcd(r, n) != 1:
+                r = random.randint(1, n - 1)
+        n2 = n * n
+        c = (pow(g, plaintext, n2) * pow(r, n, n2)) % n2
+        return c
+
+    @staticmethod
+    def encrypt_with_randomness(public_key, plaintext):
+        r = random.randint(1, public_key[0] - 1)
+        while math.gcd(r, public_key[0]) != 1:
+            r = random.randint(1, public_key[0] - 1)
+        c = RTPHE.encrypt(public_key, plaintext, r)
+        return c, r
+
+    @staticmethod
+    def decrypt(public_key, private_key, ciphertext):
+        n, g = public_key
+        lambda_n, mu = private_key
+        n2 = n * n
+        x = pow(ciphertext, lambda_n, n2)
+        Lx = (x - 1) // n
+        plaintext = (Lx * mu) % n
+
+        if plaintext > n // 2:
+            plaintext -= n
+        return plaintext
+
+    @staticmethod
+    def homomorphic_add(c1, c2, public_key):
+        n2 = public_key[0] ** 2
+        return (c1 * c2) % n2
+
+    @staticmethod
+    def homomorphic_add_plaintext(ciphertext, plaintext, public_key):
+        n, g = public_key
+        n2 = n * n
+        c_plain = pow(g, plaintext, n2)
+        return (ciphertext * c_plain) % n2
+
+    @staticmethod
+    def homomorphic_sub(c1, c2, public_key):
+        n2 = public_key[0] ** 2
+        c2_inv = mod_inverse(c2, n2)
+        return (c1 * c2_inv) % n2
+
+    @staticmethod
+    def homomorphic_sub_plaintext(ciphertext, plaintext, public_key):
+        n, g = public_key
+        n2 = n * n
+        c_plain_neg = pow(g, -plaintext % n, n2)
+        return (ciphertext * c_plain_neg) % n2
+
+    @staticmethod
+    def homomorphic_scalar_mult(ciphertext, scalar, public_key):
+        n2 = public_key[0] ** 2
+        return pow(ciphertext, scalar, n2)
+
+    @staticmethod
+    def homomorphic_div(ciphertext, divisor, public_key):
+        n = public_key[0]
+        divisor_inv = mod_inverse(divisor, n)
+        return RTPHE.homomorphic_scalar_mult(ciphertext, divisor_inv, public_key)
+
+    # ========== 🔐 RANDOMNESS TRACKING HELPERS ==========
+
+    @staticmethod
+    def track_randomness_add(r1, r2, n):
+        return (r1 * r2) % n
+
+    @staticmethod
+    def track_randomness_sub(r1, r2, n):
+        return (r1 * mod_inverse(r2, n)) % n
+
+    @staticmethod
+    def track_randomness_scalar_mult(r, scalar, n):
+        return pow(r, scalar, n)
+
+    @staticmethod
+    def track_randomness_scalar_div(r, divisor, n):
+        divisor_inv = mod_inverse(divisor, n)
+        return pow(r, divisor_inv, n)

pryvx-2.6.0/pryvx/smpc.py

@@ -0,0 +1,34 @@
+import random
+import hashlib
+
+def getAdditiveShares(secret, N, fieldSize):
+    shares = [random.randrange(fieldSize) for _ in range(N-1)]
+    shares.append((secret - sum(shares)) % fieldSize )
+    return shares
+
+class SMPC:
+    def __init__(self) -> None:
+        self.fieldSize = 293973345475167247070445277780365744413
+
+    def encode(self, secret, scale_factor=1000):
+        return int(secret * scale_factor)
+    
+    def decode(self, upscaled, scale_factor=1000):
+        return upscaled / scale_factor
+    
+    def get_field_size(self):
+        return self.fieldSize
+    
+    def get_secret_shares(self, secret, N):
+        shares = getAdditiveShares(secret, N, self.fieldSize)
+        return shares
+    
+    def hash_to_bigint(self, data: str) -> int:
+        digest = hashlib.sha256(data.encode()).hexdigest()
+        return int(digest, 16)
+    
+    def reconstruct(self, share):
+        return share % self.fieldSize
+    
+    def additive_reconstruct(self, shares):
+        return sum(shares) % self.fieldSize

{pryvx-2.4.9 → pryvx-2.6.0}/pryvx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pryvx
-Version: 2.4.9
+Version: 2.6.0
 Summary: A comprehensive package for privacy-enhancing technologies
 Home-page: UNKNOWN
 Author: PryvX (Jayesh Kenaudekar)

{pryvx-2.4.9 → pryvx-2.6.0}/pryvx.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ pryvx/phe.py
 pryvx/pryvx_pb2.py
 pryvx/pryvx_pb2_grpc.py
 pryvx/psi.py
+pryvx/rtphe.py
 pryvx/smpc.py
 pryvx.egg-info/PKG-INFO
 pryvx.egg-info/SOURCES.txt

{pryvx-2.4.9 → pryvx-2.6.0}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '2.4.9'
+VERSION = '2.6.0'
 
 
 # Setting up

pryvx-2.4.9/pryvx/smpc.py

@@ -1,59 +0,0 @@
-import random
- 
-def getAdditiveShares(secret, N, fieldSize):
-    shares = [random.randrange(fieldSize) for i in range(N-1)]
-    shares.append((secret - sum(shares)) % fieldSize )
-    return shares
- 
-def reconstructSecret(shares, fieldSize):
-    return sum(shares) % fieldSize
-
-
-class SMPC:
-    def __init__(self) -> None:
-        self.BASE = 10
-        self.PRECISION_INTEGRAL = 8
-        self.PRECISION_FRACTIONAL = 8
-        self.fieldSize = 293973345475167247070445277780365744413
-
-        self.PRECISION = self.PRECISION_INTEGRAL + self.PRECISION_FRACTIONAL
-        assert(self.fieldSize > self.BASE**self.PRECISION)
-
-    def encode(self, rational):
-        upscaled = int(rational * self.BASE**self.PRECISION_FRACTIONAL)
-        field_element = upscaled % self.fieldSize
-        return field_element
-    
-    def decode(self, field_element):
-        upscaled = field_element if field_element <= self.fieldSize/2 else field_element - self.fieldSize
-        rational = upscaled / self.BASE**self.PRECISION_FRACTIONAL
-        return rational
-    
-    def get_secret_shares(self, m, N):
-        N = N + 1
-        shares = getAdditiveShares(self.encode(m), N, self.fieldSize)
-        return shares
-    
-    def addition(self, shares_list):
-        aggregate_shares = [sum(x) % self.fieldSize for x in shares_list]
-        return self.decode(reconstructSecret(aggregate_shares, self.fieldSize))
-
-    def multiplication(self):
-        pass
-
-    def difference(self, shares_a, shares_b):
-        difference_shares = [(a - b) % self.fieldSize for a, b in zip(shares_a, shares_b)]
-        return self.decode(reconstructSecret(difference_shares, self.fieldSize))
-    
-    def compare(self, shares_a, shares_b):
-        difference_shares = [(a - b) % self.fieldSize for a, b in zip(shares_a, shares_b)]
-        reconstructed_difference = self.decode(reconstructSecret(difference_shares, self.fieldSize))
-    
-        if reconstructed_difference == 0:
-            comparison_result = "a is equal to b"
-        elif reconstructed_difference > 0:
-            comparison_result = "a is greater than b"
-        else:
-            comparison_result = "a is less than b"
-
-        return comparison_result