feat: encrypt & decrypt with seeds

Author: Memo Ugurbil

pyproject.toml

@@ -8,7 +8,8 @@ requires-python = ">=3.9"
 dependencies = [
     "lagrange~=3.0",
     "bcl~=2.3",
-    "pailliers~=0.1"
+    "pailliers~=0.1",
+    "pytest>=8.3.5",
 ]
 
 [project.urls]

src/nilql/nilql.py

@@ -362,7 +362,7 @@ def generate(
 
         if (
             (not isinstance(operations, dict)) or
-            (not set(operations.keys()).issubset({'store', 'match', 'sum'}))
+            (not set(operations.keys()).issubset({'store', 'seed', 'match', 'sum'}))
         ):
             raise ValueError('valid operations specification is required')
 
@@ -393,6 +393,14 @@ def generate(
                 bytes.__new__(bcl.secret, _random_bytes(32, seed))
             )
 
+        if secret_key['operations'].get('seed'):
+            # Symmetric key for encrypting the plaintext or the shares of a plaintext.
+            secret_key['material'] = (
+                bcl.symmetric.secret()
+                if seed is None else
+                bytes.__new__(bcl.secret, _random_bytes(32, seed))
+            )
+
         if secret_key['operations'].get('match'):
             # Salt for deterministic hashing of the plaintext.
             secret_key['material'] = _random_bytes(64, seed)
@@ -743,6 +751,33 @@ def encrypt(
         ))
         return list(map(_pack, shares))
 
+    # Encrypt a plaintext for storage and retrieval.
+    if key['operations'].get('seed'):
+        # For single-node clusters, the data is encrypted using a symmetric key.
+        if len(key['cluster']['nodes']) == 1:
+            return _pack(
+                bcl.symmetric.encrypt(key['material'], bcl.plain(buffer))
+            )
+
+        # For multiple-node clusters, the ciphertext is secret-shared using XOR
+        # (with each share symmetrically encrypted in the case of a secret key).
+        optional_enc = (
+            (lambda s: bcl.symmetric.encrypt(key['material'], bcl.plain(s)))
+            if 'material' in key else
+            (lambda s: s)
+        )
+        seeds = []
+        aggregate = bytes(len(buffer))
+        for _ in range(len(key['cluster']['nodes']) - 1):
+            seed = _random_bytes(64)
+            seeds.append(optional_enc(seed))
+            mask = _random_bytes(len(buffer), seed)
+            aggregate = bytes(a ^ b for (a, b) in zip(aggregate, mask))
+        share = optional_enc(
+            bytes(a ^ b for (a, b) in zip(aggregate, buffer))
+        )
+        return list(map(_pack, seeds)) + [_pack(share)]
+
     # Encrypt (i.e., hash) a plaintext for matching.
     if key['operations'].get('match'):
         # The deterministic salted hash of the encoded plaintext is the ciphertext.
@@ -949,6 +984,40 @@ def decrypt(
 
         return _decode(bytes_)
 
+    # Decrypt a value that was encrypted for storage and retrieval.
+    if key['operations'].get('seed'):
+        # For single-node clusters, the plaintext is encrypted using a symmetric key.
+        if len(key['cluster']['nodes']) == 1:
+            try:
+                return _decode(
+                    bcl.symmetric.decrypt(
+                        key['material'],
+                        bcl.cipher(_unpack(ciphertext))
+                    )
+                )
+            except Exception as exc:
+                raise error from exc
+
+        # For multiple-node clusters, the ciphertext is secret-shared using XOR
+        # (with each share symmetrically encrypted in the case of a secret key).
+        shares = [_unpack(share) for share in ciphertext]
+        if 'material' in key:
+            try:
+                shares = [
+                    bcl.symmetric.decrypt(key['material'], bcl.cipher(share))
+                    for share in shares
+                ]
+            except Exception as exc:
+                raise error from exc
+
+        bytes_ = bytes(len(shares[-1]))
+        for share_ in shares[:-1]:
+            share_ = _random_bytes(len(bytes_), share_)
+            bytes_ = bytes(a ^ b for (a, b) in zip(bytes_, share_))
+        bytes_ = bytes(a ^ b for (a, b) in zip(bytes_, shares[-1]))
+
+        return _decode(bytes_)
+
     # Decrypt a value that was encrypted in a summation-compatible way.
     if key['operations'].get('sum'):
         # For single-node clusters, the Paillier cryptosystem is used.

test/test_nilql.py

@@ -309,6 +309,21 @@ def test_encrypt_decrypt_for_store(self):
             decrypted = nilql.decrypt(sk, nilql.encrypt(sk, plaintext))
             self.assertEqual(decrypted, plaintext)
 
+    def test_encrypt_decrypt_for_seed(self):
+        """
+        Test encryption and decryption for storing.
+        """
+        for cluster in [{'nodes': [{}]}, {'nodes': [{}, {}, {}]}]:
+            sk = nilql.SecretKey.generate(cluster, {'seed': True})
+
+            plaintext = 123
+            decrypted = nilql.decrypt(sk, nilql.encrypt(sk, plaintext))
+            self.assertEqual(decrypted, plaintext)
+
+            plaintext = 'abc'
+            decrypted = nilql.decrypt(sk, nilql.encrypt(sk, plaintext))
+            self.assertEqual(decrypted, plaintext)
+
     def test_encrypt_for_match(self):
         """
         Test encryption for matching.