pryvx 2.4.9__py3-none-any.whl → 2.6.0__py3-none-any.whl

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/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/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/smpc.py

@@ -1,59 +1,34 @@
 import random
- 
+import hashlib
+
 def getAdditiveShares(secret, N, fieldSize):
-    shares = [random.randrange(fieldSize) for i in range(N-1)]
+    shares = [random.randrange(fieldSize) for _ 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 encode(self, secret, scale_factor=1000):
+        return int(secret * scale_factor)
+    
+    def decode(self, upscaled, scale_factor=1000):
+        return upscaled / scale_factor
     
-    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_field_size(self):
+        return self.fieldSize
     
-    def get_secret_shares(self, m, N):
-        N = N + 1
-        shares = getAdditiveShares(self.encode(m), N, self.fieldSize)
+    def get_secret_shares(self, secret, N):
+        shares = getAdditiveShares(secret, 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 hash_to_bigint(self, data: str) -> int:
+        digest = hashlib.sha256(data.encode()).hexdigest()
+        return int(digest, 16)
     
-    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))
+    def reconstruct(self, share):
+        return share % 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
+    def additive_reconstruct(self, shares):
+        return sum(shares) % self.fieldSize

{pryvx-2.4.9.dist-info → pryvx-2.6.0.dist-info}/METADATA

@@ -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.dist-info → pryvx-2.6.0.dist-info}/RECORD

@@ -1,16 +1,17 @@
-pryvx/__init__.py,sha256=QvpYISJ8MH7XnbxC5iTMTycq7Svsld0NIbMozcndYjo,111
+pryvx/__init__.py,sha256=awMTuiYTjZjhLEhLBYUA4-12DmjStBC_ChUKY7rGbUY,137
 pryvx/fl_client.py,sha256=9MFIlpdLbNemhiXvYPhJlJGZLdA2U8AzfxGuuNHlIaE,1301
 pryvx/fl_ensemble.py,sha256=lvgvd-zJDSBh-RyMAjTyJZwu0eFiUNXfCU7J2Vk7g0g,715
 pryvx/fl_server.py,sha256=LJdJkj2BJdXrMczy1qZBHN_fY-ZveH-vHvljwwgDv8k,2039
 pryvx/gdp.py,sha256=ToLtWNvBKtSs-3Na1pGe_J6dWvBxXhV2raUJkNtKMg4,925
 pryvx/ldp.py,sha256=WxBQLnZ_b2wNV1rlN7rtKXaQ5waUPPvnRus-4tUnCB8,810
-pryvx/phe.py,sha256=HN70aUNTq0w9vRPMaNGfTnNi00gMQ1B7R7Cm6r6rheE,2974
+pryvx/phe.py,sha256=q4MhHVZaRacW_-iIJD3iveogh_xiEcQiAcRVpGH-MyI,3150
 pryvx/pryvx_pb2.py,sha256=HlwY1zRVFReIaK8WZ8opJ1kd3_PQWSJEx-PZImWYlCM,1621
 pryvx/pryvx_pb2_grpc.py,sha256=yn4mThL3XY8glPvZ9b1Fmj_c8JtAs1pTNp3m0JV9d3s,3425
 pryvx/psi.py,sha256=V0BUJwYfiFWhKtEL27q45yxY7U-I7B4olKQhaGbgN50,1346
-pryvx/smpc.py,sha256=FZcE3gZo8WUVPmcBHSgP8iOkWt3AKcBLSLCtKczy8hs,2247
-pryvx-2.4.9.dist-info/LICENSE,sha256=pbIMXbaorAIVW-fDch2tvtZRkVA3mz-UnXQqeCf4LDg,1086
-pryvx-2.4.9.dist-info/METADATA,sha256=XB1r9x2GC431D0dxRbbpyOlsEJWdaeVdvh6QCLKTTB4,1066
-pryvx-2.4.9.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-pryvx-2.4.9.dist-info/top_level.txt,sha256=1iHoeevu_FoFjdPg8HyMlgvHNUm1--9QEpFMaJEa4hw,6
-pryvx-2.4.9.dist-info/RECORD,,
+pryvx/rtphe.py,sha256=e7mKCJfhtvJa-aGpJOrYDsKbEm_zi46sXR1ezrkv264,4293
+pryvx/smpc.py,sha256=MDHo53sOtz9hdRzKIlzp7qtAsLcBRyMkcaiq0t-ENMg,1051
+pryvx-2.6.0.dist-info/LICENSE,sha256=pbIMXbaorAIVW-fDch2tvtZRkVA3mz-UnXQqeCf4LDg,1086
+pryvx-2.6.0.dist-info/METADATA,sha256=wHm2cVmPRlzkz_GSelhNcfSFccCDlI1O2SdZ-ZDQLGM,1066
+pryvx-2.6.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+pryvx-2.6.0.dist-info/top_level.txt,sha256=1iHoeevu_FoFjdPg8HyMlgvHNUm1--9QEpFMaJEa4hw,6
+pryvx-2.6.0.dist-info/RECORD,,