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

charm/test/conftest.py

@@ -0,0 +1,38 @@
+"""
+Pytest configuration for Charm test suite.
+
+This module provides custom pytest hooks and fixtures for version-specific
+test skipping and other test configuration.
+"""
+
+import sys
+import pytest
+
+
+def pytest_configure(config):
+    """Register custom markers."""
+    config.addinivalue_line(
+        "markers",
+        "skip_py312plus: Skip test on Python 3.12+ due to known issues"
+    )
+    config.addinivalue_line(
+        "markers",
+        "slow: Mark test as slow-running"
+    )
+
+
+def pytest_collection_modifyitems(config, items):
+    """
+    Automatically skip tests marked with skip_py312plus on Python 3.12+.
+    
+    This hook runs after test collection and modifies the test items
+    to add skip markers based on the Python version.
+    """
+    if sys.version_info >= (3, 12):
+        skip_py312plus = pytest.mark.skip(
+            reason="Test skipped on Python 3.12+ due to known hanging/compatibility issues"
+        )
+        for item in items:
+            if "skip_py312plus" in item.keywords:
+                item.add_marker(skip_py312plus)
+

charm/test/fuzz/__init__.py

@@ -0,0 +1 @@
+

charm/test/fuzz/conftest.py

@@ -0,0 +1,5 @@
+# Skip fuzzing files from pytest collection
+# These require atheris to be installed and are meant to be run directly
+
+collect_ignore = ["fuzz_policy_parser.py", "fuzz_serialization.py"]
+

charm/test/fuzz/fuzz_policy_parser.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python
+"""
+Fuzzing harness for PolicyParser in charm.toolbox.policytree
+
+This fuzzer tests the policy parser with random inputs to find crashes,
+hangs, or other unexpected behavior.
+
+Usage:
+    pip install atheris
+    python charm/test/fuzz/fuzz_policy_parser.py
+
+The fuzzer will run continuously until stopped (Ctrl+C) or a crash is found.
+
+Note: This file is not a pytest test module. It requires atheris to be installed
+and should be run directly.
+"""
+
+import sys
+
+# Defer atheris import to runtime to avoid pytest collection errors
+atheris = None
+
+
+def setup_module():
+    """Import modules after Atheris initialization for proper instrumentation."""
+    global PolicyParser
+    from charm.toolbox.policytree import PolicyParser
+
+
+def fuzz_policy_parser(data: bytes) -> None:
+    """Fuzz target for PolicyParser.
+    
+    Tests the parser with random byte strings converted to policy strings.
+    """
+    try:
+        # Convert bytes to string, handling encoding errors gracefully
+        policy_str = data.decode('utf-8', errors='replace')
+        
+        # Skip empty strings
+        if not policy_str.strip():
+            return
+            
+        # Parse the policy string
+        parser = PolicyParser()
+        parser.parse(policy_str)
+        
+    except Exception:
+        # Expected exceptions from invalid input are fine
+        # We're looking for crashes, hangs, or memory issues
+        pass
+
+
+def main():
+    """Main entry point for the fuzzer."""
+    global atheris
+
+    try:
+        import atheris as _atheris
+        atheris = _atheris
+    except ImportError:
+        print("ERROR: atheris is required for fuzzing.")
+        print("Install with: pip install atheris")
+        sys.exit(1)
+
+    # Initialize Atheris with instrumentation
+    atheris.instrument_all()
+    setup_module()
+
+    # Start fuzzing
+    atheris.Setup(sys.argv, fuzz_policy_parser)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
+

charm/test/fuzz/fuzz_serialization.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python
+"""
+Fuzzing harness for serialization/deserialization in Charm
+
+This fuzzer tests the deserialization functions with random byte inputs
+to find crashes, memory corruption, or other issues.
+
+Usage:
+    pip install atheris
+    python charm/test/fuzz/fuzz_serialization.py
+
+Note: This file is not a pytest test module. It requires atheris to be installed
+and should be run directly.
+"""
+
+import sys
+
+# Defer atheris import to runtime to avoid pytest collection errors
+atheris = None
+
+
+def setup_module():
+    """Import modules after Atheris initialization."""
+    global PairingGroup, objectToBytes, bytesToObject
+    from charm.toolbox.pairinggroup import PairingGroup
+    from charm.core.engine.util import objectToBytes, bytesToObject
+
+
+def fuzz_pairing_deserialization(data: bytes) -> None:
+    """Fuzz target for pairing group deserialization.
+    
+    Tests bytesToObject with random bytes to find crashes.
+    """
+    try:
+        group = PairingGroup('BN254')
+        
+        # Try to deserialize random bytes
+        bytesToObject(data, group)
+        
+    except Exception:
+        # Expected exceptions are fine
+        pass
+
+
+def fuzz_combined(data: bytes) -> None:
+    """Combined fuzz target testing multiple deserialization paths."""
+    fdp = atheris.FuzzedDataProvider(data)
+    
+    try:
+        group = PairingGroup('BN254')
+        
+        # Get random bytes of varying lengths
+        payload = fdp.ConsumeBytes(fdp.ConsumeIntInRange(0, 1024))
+        
+        # Try deserialization
+        bytesToObject(payload, group)
+        
+    except Exception:
+        pass
+
+
+def main():
+    """Main entry point."""
+    global atheris
+
+    try:
+        import atheris as _atheris
+        atheris = _atheris
+    except ImportError:
+        print("ERROR: atheris is required for fuzzing.")
+        print("Install with: pip install atheris")
+        sys.exit(1)
+
+    atheris.instrument_all()
+    setup_module()
+
+    atheris.Setup(sys.argv, fuzz_combined)
+    atheris.Fuzz()
+
+
+if __name__ == "__main__":
+    main()
+

charm/test/schemes/abenc/abenc_bsw07_test.py

@@ -0,0 +1,39 @@
+import unittest
+
+from charm.schemes.abenc.abenc_bsw07 import CPabe_BSW07
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class CPabe_BSW07Test(unittest.TestCase):
+    def testCPabe_BSW07(self):
+        groupObj = PairingGroup('SS512')
+
+        cpabe = CPabe_BSW07(groupObj)
+        attrs = ['ONE', 'TWO', 'THREE']
+        access_policy = '((four or three) and (three or one))'
+        if debug:
+            print("Attributes =>", attrs);
+            print("Policy =>", access_policy)
+
+        (pk, mk) = cpabe.setup()
+
+        sk = cpabe.keygen(pk, mk, attrs)
+
+        rand_msg = groupObj.random(GT)
+        if debug: print("msg =>", rand_msg)
+        ct = cpabe.encrypt(pk, rand_msg, access_policy)
+        if debug: print("\n\nCiphertext...\n")
+        groupObj.debug(ct)
+
+        rec_msg = cpabe.decrypt(pk, sk, ct)
+        if debug: print("\n\nDecrypt...\n")
+        if debug: print("Rec msg =>", rec_msg)
+
+        assert rand_msg == rec_msg, "FAILED Decryption: message is incorrect"
+        if debug: print("Successful Decryption!!!")
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_dacmacs_yj14_test.py

@@ -0,0 +1,16 @@
+import unittest
+
+import charm.schemes.abenc.abenc_dacmacs_yj14 as abenc_dacmacs_yj14
+
+debug = False
+
+
+# unit test for scheme contributed by artjomb
+class DacMacs_YJ14Test(unittest.TestCase):
+    def testDacmacs_YJ14(self):
+        abenc_dacmacs_yj14.basicTest()
+        abenc_dacmacs_yj14.revokedTest()
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_lsw08_test.py

@@ -0,0 +1,33 @@
+import unittest
+
+from charm.schemes.abenc.abenc_lsw08 import KPabe
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class KPabeTest(unittest.TestCase):
+    def testKPabe(self):
+        groupObj = PairingGroup('MNT224')
+        kpabe = KPabe(groupObj)
+
+        (pk, mk) = kpabe.setup()
+
+        policy = '(ONE or THREE) and (THREE or TWO)'
+        attributes = ['ONE', 'TWO', 'THREE', 'FOUR']
+        msg = groupObj.random(GT)
+
+        mykey = kpabe.keygen(pk, mk, policy)
+
+        if debug: print("Encrypt under these attributes: ", attributes)
+        ciphertext = kpabe.encrypt(pk, msg, attributes)
+        if debug: print(ciphertext)
+
+        rec_msg = kpabe.decrypt(ciphertext, mykey)
+
+        assert msg == rec_msg
+        if debug: print("Successful Decryption!")
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_maabe_yj14_test.py

@@ -0,0 +1,16 @@
+import unittest
+
+import charm.schemes.abenc.abenc_maabe_yj14 as abenc_maabe_yj14
+
+debug = False
+
+
+# unit test for scheme contributed by artjomb
+class MAabe_YJ14Test(unittest.TestCase):
+    def testMAabe_YJ14(self):
+        abenc_maabe_yj14.basicTest()
+        abenc_maabe_yj14.revokedTest()
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_tbpre_lww14_test.py

@@ -0,0 +1,16 @@
+import unittest
+
+import charm.schemes.abenc.abenc_tbpre_lww14 as abenc_tbpre_lww14
+
+debug = False
+
+
+# unit test for scheme contributed by artjomb
+class TBPre_LWW14Test(unittest.TestCase):
+    def testTBPre_LWW14(self):
+        abenc_tbpre_lww14.basicTest()
+        # abenc_tbpre_lww14.basicTest2() # seems to fail
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_waters09_test.py

@@ -0,0 +1,38 @@
+import unittest
+
+from charm.schemes.abenc.abenc_waters09 import CPabe09
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class CPabe09Test(unittest.TestCase):
+    def testCPabe(self):
+        # Get the eliptic curve with the bilinear mapping feature needed.
+        groupObj = PairingGroup('SS512')
+
+        cpabe = CPabe09(groupObj)
+        (msk, pk) = cpabe.setup()
+        pol = '((ONE or THREE) and (TWO or FOUR))'
+        attr_list = ['THREE', 'ONE', 'TWO']
+
+        if debug: print('Acces Policy: %s' % pol)
+        if debug: print('User credential list: %s' % attr_list)
+        m = groupObj.random(GT)
+
+        cpkey = cpabe.keygen(pk, msk, attr_list)
+        if debug: print("\nSecret key: %s" % attr_list)
+        if debug: groupObj.debug(cpkey)
+        cipher = cpabe.encrypt(pk, m, pol)
+
+        if debug: print("\nCiphertext...")
+        if debug: groupObj.debug(cipher)
+        orig_m = cpabe.decrypt(pk, cpkey, cipher)
+
+        assert m == orig_m, 'FAILED Decryption!!!'
+        if debug: print('Successful Decryption!')
+        del groupObj
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/abenc/abenc_yllc15_test.py

@@ -0,0 +1,74 @@
+import sys
+import unittest
+
+import pytest
+
+from charm.toolbox.secretutil import SecretUtil
+
+settings = pytest.importorskip("hypothesis").settings
+given = pytest.importorskip("hypothesis").given
+from hypothesis.strategies import lists
+
+from charm.schemes.abenc.abenc_yllc15 import YLLC15
+from charm.toolbox.pairinggroup import PairingGroup, GT
+from charm.toolbox.policy_expression_spec import attributes, policy_expressions
+
+
+class YLLC15Test(unittest.TestCase):
+
+    def setUp(self):
+        group = PairingGroup('SS512')
+        self.abe = YLLC15(group)
+        (self.params, self.msk) = self.abe.setup()
+
+    def test_ukgen(self, user_id='bob@example.com'):
+        (public_key, secret_key) = self.abe.ukgen(self.params)
+
+    @pytest.mark.skipif(sys.version_info < (3, 4),
+                        reason="requires python3.4 or higher")
+    @given(attrs=lists(attributes(), min_size=1))
+    @settings(deadline=300, max_examples=50)
+    def test_proxy_key_gen_deduplicates_and_uppercases_attributes(self, attrs):
+        pkcs, skcs = self.abe.ukgen(self.params)
+        pku, sku = self.abe.ukgen(self.params)
+        proxy_key_user = self.abe.proxy_keygen(self.params, self.msk, pkcs, pku, attrs)
+        self.assertEqual({ attr.upper() for attr in set(attrs) }, proxy_key_user['k_attrs'].keys())
+
+    @settings(deadline=1000, max_examples=50)  # Increased deadline for CI variability
+    @given(policy_str=policy_expressions())
+    def test_encrypt_proxy_decrypt_decrypt_round_trip(self, policy_str):
+        pkcs, skcs = self.abe.ukgen(self.params)
+        pku, sku = self.abe.ukgen(self.params)
+        attrs = self.extract_attributes(policy_str)
+        random_key_elem = self.abe.group.random(GT)
+
+        proxy_key_user = self.abe.proxy_keygen(self.params, self.msk, pkcs, pku, attrs)
+        ciphertext = self.abe.encrypt(self.params, random_key_elem, policy_str)
+        intermediate_value = self.abe.proxy_decrypt(skcs, proxy_key_user, ciphertext)
+        recovered_key_elem = self.abe.decrypt(None, sku, intermediate_value)
+        self.assertEqual(random_key_elem, recovered_key_elem)
+
+    def extract_attributes(self, policy_str):
+        util = SecretUtil(self.abe.group)
+        policy = util.createPolicy(policy_str)
+        return [util.strip_index(policy_attr) for policy_attr in util.getAttributeList(policy)]
+
+    @pytest.mark.skipif(sys.version_info < (3, 4),
+                        reason="requires python3.4 or higher")
+    @settings(deadline=400, max_examples=50)
+    @given(policy=policy_expressions())
+    def test_policy_not_satisfied(self, policy):
+        pkcs, skcs = self.abe.ukgen(self.params)
+        pku, sku = self.abe.ukgen(self.params)
+        attribute_list = ["UNLIKELY_ATTRIBUTE_NAME"]
+        proxy_key_user = self.abe.proxy_keygen(self.params, self.msk, pkcs, pku, attribute_list)
+
+        random_key_elem = self.abe.group.random(GT)
+        ciphertext = self.abe.encrypt(self.params, random_key_elem, policy)
+
+        result = self.abe.proxy_decrypt(skcs, proxy_key_user, ciphertext)
+        self.assertIsNone(result)
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/chamhash_adm05_test.py

@@ -0,0 +1,31 @@
+import unittest
+
+import pytest
+
+from charm.schemes.chamhash_adm05 import ChamHash_Adm05
+from charm.toolbox.integergroup import integer
+
+debug = False
+
+
+class ChamHash_Adm05Test(unittest.TestCase):
+    @pytest.mark.skip(reason="Fails on Linux CI - investigating platform-specific issue with IntegerGroupQ.hash")
+    def testChamHash_Adm05(self):
+        # fixed params for unit tests
+        p = integer(141660875619984104245410764464185421040193281776686085728248762539241852738181649330509191671665849071206347515263344232662465937366909502530516774705282764748558934610432918614104329009095808618770549804432868118610669336907161081169097403439689930233383598055540343198389409225338204714777812724565461351567)
+        q = integer(70830437809992052122705382232092710520096640888343042864124381269620926369090824665254595835832924535603173757631672116331232968683454751265258387352641382374279467305216459307052164504547904309385274902216434059305334668453580540584548701719844965116691799027770171599194704612669102357388906362282730675783)
+        chamHash = ChamHash_Adm05(p, q)
+        (pk, sk) = chamHash.paramgen()
+        if debug: print("pk => ", pk)
+        if debug: print("sk => ", sk)
+
+        msg = "Hello world this is the message!"
+        (h, r, s) = chamHash.hash(pk, msg)
+        if debug: print("Hash...")
+        if debug: print("sig =>", h)
+
+        (h1, r1, s1) = chamHash.hash(pk, msg, r, s)
+        if debug: print("sig 2 =>", h1)
+
+        assert h == h1, "Signature failed!!!"
+        if debug: print("Signature generated correctly!!!")

charm/test/schemes/chamhash_rsa_hw09_test.py

@@ -0,0 +1,29 @@
+import unittest
+
+from charm.schemes.chamhash_rsa_hw09 import ChamHash_HW09
+from charm.toolbox.integergroup import integer
+
+debug = False
+
+
+class ChamHash_HW09Test(unittest.TestCase):
+    def testChamHash_HW09(self):
+        # Test p and q primes for unit tests only
+        # These primes are mathematically suitable - phi_N = (p-1)*(q-1) is coprime with 65537
+        # This ensures the deterministic coprime algorithm finds a solution quickly
+        p = integer(95969491500266197744623842643163713790605329484264579952704690252128663957034885038057265490969414900858594119440280815406458877960454430736966405387849574204717896425412057524927419980472986383200765875162149934175300724788379539851438576829444747397186724447127392785957485487971933719848100802790176324337)
+        q = integer(165685596906806363133681673469906489437474476163789251744214878002662496954723502283532073376723817149461444040314419947626958411649072129703545884779008062578922350877123596086401947242893563534827734633284461244941306661332124200807263458137608535445118169374047964965396160553232687802551488935469282118877)
+
+        chamHash = ChamHash_HW09()
+        (pk, sk) = chamHash.paramgen(1024, p, q)
+
+        msg = "Hello world this is the message!"
+        (h, r) = chamHash.hash(pk, msg)
+        if debug: print("Hash...")
+        if debug: print("sig =>", h)
+
+        (h1, r1) = chamHash.hash(pk, msg, r)
+        if debug: print("sig 2 =>", h1)
+
+        assert h == h1, "Signature failed!!!"
+        if debug: print("Signature generated correctly!!!")

charm/test/schemes/commit/commit_gs08_test.py

@@ -0,0 +1,24 @@
+import unittest
+
+from charm.schemes.commit.commit_gs08 import Commitment_GS08
+from charm.toolbox.pairinggroup import PairingGroup, G1
+
+debug = False
+
+
+class Commitment_GS08Test(unittest.TestCase):
+    def testCommitment_GS08(self):
+        groupObj = PairingGroup('SS512')
+        cm = Commitment_GS08(groupObj)
+
+        pk = cm.setup()
+        if debug:
+            print("Public parameters...")
+            print("pk =>", pk)
+
+        m = groupObj.random(G1)
+        if debug: print("Committing to =>", m)
+        (c, d) = cm.commit(pk, m)
+
+        assert cm.decommit(pk, c, d, m), "FAILED to decommit"
+        if debug: print("Successful and Verified decommitment!!!")

charm/test/schemes/commit/commit_pedersen92_test.py

@@ -0,0 +1,26 @@
+import unittest
+
+from charm.schemes.commit.commit_pedersen92 import CM_Ped92
+from charm.toolbox.ecgroup import ECGroup
+from charm.toolbox.pairinggroup import ZR
+
+debug = False
+
+
+class CM_Ped92Test(unittest.TestCase):
+    def testCM_Ped92(self):
+        groupObj = ECGroup(410)
+        cm = CM_Ped92(groupObj)
+
+        pk = cm.setup()
+        if debug:
+            print("Public parameters...")
+            print("pk =>", pk)
+
+        m = groupObj.random(ZR)
+        if debug: print("Commiting to =>", m)
+        (c, d) = cm.commit(pk, m)
+
+        assert cm.decommit(pk, c, d, m), "FAILED to decommit"
+        if debug: print("Successful and Verified decommitment!!!")
+        del groupObj

charm/test/schemes/dabe_aw11_test.py

@@ -0,0 +1,45 @@
+import unittest
+
+from charm.schemes.abenc.dabe_aw11 import Dabe
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class DabeTest(unittest.TestCase):
+    def testDabe(self):
+        groupObj = PairingGroup('SS512')
+
+        dabe = Dabe(groupObj)
+        GP = dabe.setup()
+
+        # Setup an authority
+        auth_attrs = ['ONE', 'TWO', 'THREE', 'FOUR']
+        (SK, PK) = dabe.authsetup(GP, auth_attrs)
+        if debug: print("Authority SK")
+        if debug: print(SK)
+
+        # Setup a user and give him some keys
+        gid, K = "bob", {}
+        usr_attrs = ['THREE', 'ONE', 'TWO']
+        for i in usr_attrs: dabe.keygen(GP, SK, i, gid, K)
+        if debug: print('User credential list: %s' % usr_attrs)
+        if debug: print("\nSecret key:")
+        if debug: groupObj.debug(K)
+
+        # Encrypt a random element in GT
+        m = groupObj.random(GT)
+        policy = '((one or three) and (TWO or FOUR))'
+        if debug: print('Acces Policy: %s' % policy)
+        CT = dabe.encrypt(GP, PK, m, policy)
+        if debug: print("\nCiphertext...")
+        if debug: groupObj.debug(CT)
+
+        orig_m = dabe.decrypt(GP, K, CT)
+
+        assert m == orig_m, 'FAILED Decryption!!!'
+        if debug: print('Successful Decryption!')
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/encap_bchk05_test.py

@@ -0,0 +1,21 @@
+from charm.schemes.encap_bchk05 import EncapBCHK
+import unittest
+
+debug = False
+class EncapBCHKTest(unittest.TestCase):
+    def testEncapBCHK(self):
+        encap = EncapBCHK()
+
+        hout = encap.setup()
+
+        (r, com, dec) = encap.S(hout)
+
+        rout = encap.R(hout, com, dec)
+        
+        if debug: print("recovered m =>", rout)
+
+        assert r == rout, "Failed Decryption"
+        if debug: print("Successful Decryption!!!")
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/schemes/grpsig/groupsig_bgls04_test.py

@@ -0,0 +1,35 @@
+import unittest
+
+from charm.schemes.grpsig.groupsig_bgls04 import ShortSig as BGLS04
+from charm.toolbox.pairinggroup import PairingGroup
+
+debug = False
+
+
+class BGLS04Test(unittest.TestCase):
+    def testBGLS04(self):
+        groupObj = PairingGroup('MNT224')
+        n = 3    # how manu users in the group
+        user = 1 # which user's key to sign a message with
+
+        sigTest = BGLS04(groupObj)
+
+        (gpk, gmsk, gsk) = sigTest.keygen(n)
+
+        message = 'Hello World this is a message!'
+        if debug: print("\n\nSign the following M: '%s'" % (message))
+
+        signature = sigTest.sign(gpk, gsk[user], message)
+
+        result = sigTest.verify(gpk, message, signature)
+        #if result:
+        #    print("Verify signers identity...")
+        #    index = sigTest.open(gpk, gmsk, message, signature)
+        #    i = 0
+        #    while i < n:
+        #        if gsk[i][0] == index:
+        #            print('Found index of signer: %d' % i)
+        #            print('A = %s' % index)
+        #        i += 1
+        assert result, "Signature Failed"
+        if debug: print('Complete!')