charm-crypto-framework 0.61.1__cp313-cp313-macosx_10_13_universal2.whl

charm/test/zkp_compiler/test_thread_safety.py

@@ -0,0 +1,169 @@
+"""
+Thread safety tests for ZKP proof implementations.
+
+Tests verify that:
+1. Non-interactive proof methods are thread-safe
+2. Thread-safe wrappers work correctly for interactive proofs
+3. Concurrent proof generation/verification works correctly
+"""
+
+import unittest
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from charm.toolbox.pairinggroup import PairingGroup, ZR, G1
+from charm.zkp_compiler.schnorr_proof import SchnorrProof
+from charm.zkp_compiler.dleq_proof import DLEQProof
+from charm.zkp_compiler.representation_proof import RepresentationProof
+from charm.zkp_compiler.thread_safe import ThreadSafeProver, ThreadSafeVerifier
+
+
+class TestNonInteractiveThreadSafety(unittest.TestCase):
+    """Test that non-interactive proof methods are thread-safe."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.group = PairingGroup('BN254')
+        self.num_threads = 10
+        self.proofs_per_thread = 5
+    
+    def test_schnorr_concurrent_prove_verify(self):
+        """Test concurrent Schnorr proof generation and verification."""
+        results = []
+        errors = []
+        
+        def prove_and_verify():
+            try:
+                g = self.group.random(G1)
+                x = self.group.random(ZR)
+                h = g ** x
+                
+                for _ in range(self.proofs_per_thread):
+                    proof = SchnorrProof.prove_non_interactive(self.group, g, h, x)
+                    valid = SchnorrProof.verify_non_interactive(self.group, g, h, proof)
+                    results.append(valid)
+            except Exception as e:
+                errors.append(str(e))
+        
+        threads = [threading.Thread(target=prove_and_verify) for _ in range(self.num_threads)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        
+        self.assertEqual(len(errors), 0, f"Errors occurred: {errors}")
+        self.assertEqual(len(results), self.num_threads * self.proofs_per_thread)
+        self.assertTrue(all(results), "All proofs should verify")
+    
+    def test_dleq_concurrent_prove_verify(self):
+        """Test concurrent DLEQ proof generation and verification."""
+        results = []
+        errors = []
+        
+        def prove_and_verify():
+            try:
+                g1 = self.group.random(G1)
+                g2 = self.group.random(G1)
+                x = self.group.random(ZR)
+                h1 = g1 ** x
+                h2 = g2 ** x
+                
+                for _ in range(self.proofs_per_thread):
+                    proof = DLEQProof.prove_non_interactive(self.group, g1, h1, g2, h2, x)
+                    valid = DLEQProof.verify_non_interactive(self.group, g1, h1, g2, h2, proof)
+                    results.append(valid)
+            except Exception as e:
+                errors.append(str(e))
+        
+        threads = [threading.Thread(target=prove_and_verify) for _ in range(self.num_threads)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        
+        self.assertEqual(len(errors), 0, f"Errors occurred: {errors}")
+        self.assertEqual(len(results), self.num_threads * self.proofs_per_thread)
+        self.assertTrue(all(results), "All proofs should verify")
+    
+    def test_representation_concurrent_prove_verify(self):
+        """Test concurrent Representation proof generation and verification."""
+        results = []
+        errors = []
+        
+        def prove_and_verify():
+            try:
+                g1 = self.group.random(G1)
+                g2 = self.group.random(G1)
+                x1 = self.group.random(ZR)
+                x2 = self.group.random(ZR)
+                h = (g1 ** x1) * (g2 ** x2)
+                
+                for _ in range(self.proofs_per_thread):
+                    proof = RepresentationProof.prove_non_interactive(
+                        self.group, [g1, g2], h, [x1, x2]
+                    )
+                    valid = RepresentationProof.verify_non_interactive(
+                        self.group, [g1, g2], h, proof
+                    )
+                    results.append(valid)
+            except Exception as e:
+                errors.append(str(e))
+        
+        threads = [threading.Thread(target=prove_and_verify) for _ in range(self.num_threads)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+        
+        self.assertEqual(len(errors), 0, f"Errors occurred: {errors}")
+        self.assertEqual(len(results), self.num_threads * self.proofs_per_thread)
+        self.assertTrue(all(results), "All proofs should verify")
+
+
+class TestThreadSafeWrappers(unittest.TestCase):
+    """Test thread-safe wrappers for interactive proofs."""
+    
+    def setUp(self):
+        """Set up test fixtures."""
+        self.group = PairingGroup('BN254')
+    
+    def test_thread_safe_prover_context_manager(self):
+        """Test ThreadSafeProver as context manager."""
+        x = self.group.random(ZR)
+        g = self.group.random(G1)
+        h = g ** x
+        
+        prover = ThreadSafeProver(SchnorrProof.Prover(x, self.group))
+        verifier = SchnorrProof.Verifier(self.group)
+        
+        with prover:
+            commitment = prover.create_commitment(g)
+            challenge = verifier.create_challenge()
+            response = prover.create_response(challenge)
+        
+        result = verifier.verify(g, h, commitment, response)
+        self.assertTrue(result)
+    
+    def test_thread_safe_verifier_context_manager(self):
+        """Test ThreadSafeVerifier as context manager."""
+        x = self.group.random(ZR)
+        g = self.group.random(G1)
+        h = g ** x
+        
+        prover = SchnorrProof.Prover(x, self.group)
+        verifier = ThreadSafeVerifier(SchnorrProof.Verifier(self.group))
+        
+        commitment = prover.create_commitment(g)
+        
+        with verifier:
+            challenge = verifier.create_challenge()
+            response = prover.create_response(challenge)
+            result = verifier.verify(g, h, commitment, response)
+        
+        self.assertTrue(result)
+
+
+if __name__ == "__main__":
+    unittest.main()
+

charm/test/zkp_compiler/test_zkp_parser.py

@@ -0,0 +1,139 @@
+"""
+Unit tests for the ZK statement parser.
+
+Tests cover parsing of ZK statements, structure extraction, and error handling.
+"""
+
+import unittest
+from charm.zkp_compiler.zkparser import ZKParser
+from charm.toolbox.zknode import BinNode
+
+
+class TestZKParser(unittest.TestCase):
+    """Tests for ZK statement parser."""
+
+    def setUp(self):
+        self.parser = ZKParser()
+
+    def test_parse_simple_statement(self):
+        """Test parsing 'h = g^x'."""
+        result = self.parser.parse("h = g^x")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.type, BinNode(4).EQ)  # EQ node
+
+    def test_parse_extracts_correct_structure(self):
+        """Test that parsed tree has correct structure."""
+        result = self.parser.parse("h = g^x")
+        # h = g^x means: EQ(h, EXP(g, x))
+        # Left side is the variable name (string)
+        self.assertEqual(result.getLeft().upper(), 'H')
+        # Right side is the exponentiation BinNode
+        right = result.getRight()
+        self.assertEqual(right.type, BinNode(3).EXP)
+
+    def test_parse_multi_exponent_and(self):
+        """Test parsing 'h = g^x AND j = g^y'.
+
+        Note: The ZKParser processes this but may return an EQ node
+        as the root depending on how AND is handled in the grammar.
+        This tests that the parse succeeds and returns a BinNode.
+        """
+        result = self.parser.parse("h = g^x AND j = g^y")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+        # The parser may return EQ (4) at the root level for this grammar
+        # We just verify it's a valid BinNode type
+        self.assertIn(result.type, [BinNode(2).AND, BinNode(4).EQ])
+
+    def test_parse_preserves_variable_names(self):
+        """Test that variable names are preserved (uppercased)."""
+        result = self.parser.parse("h = g^x")
+        # The left of EQ should be 'H'
+        self.assertEqual(result.getLeft().upper(), 'H')
+
+    def test_parse_empty_string_fails(self):
+        """Test that empty string raises exception."""
+        with self.assertRaises(Exception):
+            self.parser.parse("")
+
+    def test_parse_invalid_syntax_fails(self):
+        """Test that completely unparseable syntax raises exception.
+
+        Note: The parser is lenient and may accept partial matches.
+        We test with symbols that cannot match any grammar rules.
+        """
+        with self.assertRaises(Exception):
+            # Use symbols that cannot be parsed at all
+            self.parser.parse("@@@ ### $$$")
+
+    def test_node_structure_access(self):
+        """Test that we can access node structure correctly."""
+        result = self.parser.parse("h = g^x")
+        # Right side is a BinNode (EXP node)
+        right = result.getRight()
+        self.assertIsInstance(right, BinNode)
+        # Check that we can access the EXP node's children
+        # The EXP node has left='G' and right='X' as strings
+        self.assertIsNotNone(right.getLeft())
+        self.assertIsNotNone(right.getRight())
+
+    def test_result_is_binnode(self):
+        """Test that parser returns a BinNode."""
+        result = self.parser.parse("h = g^x")
+        self.assertIsInstance(result, BinNode)
+
+
+class TestZKParserMultiCharVariables(unittest.TestCase):
+    """Tests for multi-character variable name support (new in v0.61)."""
+
+    def setUp(self):
+        self.parser = ZKParser()
+
+    def test_parse_numbered_variables(self):
+        """Test parsing with numbered variables like x1, g1, h1."""
+        result = self.parser.parse("h1 = g1^x1")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+        self.assertEqual(result.type, BinNode(4).EQ)
+
+    def test_parse_descriptive_variable_names(self):
+        """Test parsing with descriptive variable names."""
+        result = self.parser.parse("commitment = generator^secret")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+        self.assertEqual(result.type, BinNode(4).EQ)
+
+    def test_parse_greek_letter_names(self):
+        """Test parsing with Greek letter-style names."""
+        result = self.parser.parse("gamma = alpha^beta")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+
+    def test_parse_mixed_length_variables(self):
+        """Test parsing with mixed single and multi-char variables."""
+        result = self.parser.parse("h = generator^x")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+
+    def test_parse_complex_multi_char_statement(self):
+        """Test parsing complex statement with multi-char variables."""
+        result = self.parser.parse("pk1 = g^sk1 AND pk2 = g^sk2")
+        self.assertIsNotNone(result)
+        self.assertIsInstance(result, BinNode)
+
+    def test_multi_char_preserves_variable_names(self):
+        """Test that multi-char variable names are preserved."""
+        result = self.parser.parse("commitment = generator^secret")
+        # The left of EQ should be 'COMMITMENT' (uppercased)
+        self.assertEqual(result.getLeft().upper(), 'COMMITMENT')
+
+    def test_backwards_compatible_single_char(self):
+        """Test that single-char variables still work (backwards compatibility)."""
+        result = self.parser.parse("h = g^x")
+        self.assertIsNotNone(result)
+        self.assertEqual(result.getLeft().upper(), 'H')
+
+
+if __name__ == "__main__":
+    unittest.main()
+

charm/toolbox/ABEnc.py

@@ -0,0 +1,26 @@
+''' Base class for attribute-based encryption
+ 
+ Notes: This class implements an interface for a standard attribute-based encryption scheme.
+ 
+ A public key attribute-based encryption scheme consists of four algorithms: 
+ (setup, keygen, encrypt, decrypt).
+'''
+from charm.toolbox.schemebase import *
+
+class ABEnc(SchemeBase):
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='ABEnc')  
+        self.baseSecDefs = Enum('IND_AB_CPA', 'IND_AB_CCA', 'sIND_AB_CPA', 'sIND_AB_CCA') 
+
+    def setup(self):
+        raise NotImplementedError
+
+    def keygen(self, pk, mk, object):
+        raise NotImplementedError
+
+    def encrypt(self, pk, M, object):
+        raise NotImplementedError
+
+    def decrypt(self, pk, sk, ct):
+        raise NotImplementedError

charm/toolbox/ABEncMultiAuth.py

@@ -0,0 +1,66 @@
+from charm.toolbox.schemebase import *
+
+
+class ABEncMultiAuth(SchemeBase):
+    """
+    Base class for attribute-based encryption multi-authority
+
+     Notes: This class implements an interface for a standard attribute-based encryption scheme.
+
+    A public key attribute-based encryption scheme consists of four algorithms:
+    (setup, authsetup, keygen, encrypt, decrypt).
+    """
+
+    def __init__(self):
+        SchemeBase.__init__(self)
+        SchemeBase._setProperty(self, scheme='ABEncMultiAuth')
+        self.baseSecDefs = None
+
+    def setup(self):
+        """
+        Setup this multi-authority attribute based encryption scheme.
+        :return: The result of the central setup, for example some global parameters.
+        """
+        raise NotImplementedError
+
+    def authsetup(self, gp, object):
+        """
+        Setup an authority.
+        :param gp: The global parameters of the scheme.
+        :param object: Additional required arguments, for example a list of attributes or a name.
+        :return: The result of the authority setup.
+        """
+        raise NotImplementedError
+
+    def keygen(self, gp, sk, gid, object):
+        """
+        Generate user secret keys for attributes from a single authority.
+        :param gp: The global parameters of the scheme.
+        :param sk: The secret keys of the attribute authority.
+        :param gid: Global identifier for the user.
+        :param object: An attribute, list of attributes or access structure, depending on the scheme.
+        :return: The secret keys for the user for the given attributes/access structure.
+        """
+        raise NotImplementedError
+
+    def encrypt(self, gp, pk, m, object):
+        """
+        Encrypt a message.
+        :param gp: The global parameters of the scheme.
+        :param pk: The public keys of all relevant authorities.
+        :param m: The message to encrypt.
+        :param object: An access policy or a set of attributes to use.
+        :return: The encrypted message.
+        """
+        raise NotImplementedError
+
+    def decrypt(self, gp, sk, ct):
+        """
+        Decrypt a ciphertext.
+        :param gp: The global parameters of the scheme.
+        :param sk: The secret keys of the user.
+        :param ct: The ciphertext to decrypt.
+        :return: The plaintext.
+        :raise Exception: Raised when the attributes do not satisfy the access policy.
+        """
+        raise NotImplementedError