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

charm/test/adapters/abenc_adapt_hybrid_test.py

@@ -0,0 +1,29 @@
+import unittest
+
+from charm.adapters.abenc_adapt_hybrid import HybridABEnc as HybridABEnc
+from charm.schemes.abenc.abenc_bsw07 import CPabe_BSW07
+from charm.toolbox.pairinggroup import PairingGroup
+
+debug = False
+
+
+class HybridABEncTest(unittest.TestCase):
+    def testHybridABEnc(self):
+        groupObj = PairingGroup('SS512')
+        cpabe = CPabe_BSW07(groupObj)
+        hyb_abe = HybridABEnc(cpabe, groupObj)
+        access_policy = '((four or three) and (two or one))'
+        message = b"hello world this is an important message."
+        (pk, mk) = hyb_abe.setup()
+        if debug: print("pk => ", pk)
+        if debug: print("mk => ", mk)
+        sk = hyb_abe.keygen(pk, mk, ['ONE', 'TWO', 'THREE'])
+        if debug: print("sk => ", sk)
+        ct = hyb_abe.encrypt(pk, message, access_policy)
+        mdec = hyb_abe.decrypt(pk, sk, ct)
+        assert mdec == message, "Failed Decryption!!!"
+        if debug: print("Successful Decryption!!!")
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/adapters/dabenc_adapt_hybrid_test.py

@@ -0,0 +1,56 @@
+import unittest
+
+from charm.adapters.dabenc_adapt_hybrid import HybridABEncMA
+from charm.schemes.abenc.dabe_aw11 import Dabe
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class HybridABEncMATest(unittest.TestCase):
+    def testHybridABEncMA(self):
+        groupObj = PairingGroup('SS512')
+        dabe = Dabe(groupObj)
+
+        hyb_abema = HybridABEncMA(dabe, groupObj)
+
+        # Setup global parameters for all new authorities
+        gp = hyb_abema.setup()
+
+        # Instantiate a few authorities
+        # Attribute names must be globally unique.  HybridABEncMA
+        # Two authorities may not issue keys for the same attribute.
+        # Otherwise, the decryption algorithm will not know which private key to use
+        jhu_attributes = ['jhu.professor', 'jhu.staff', 'jhu.student']
+        jhmi_attributes = ['jhmi.doctor', 'jhmi.nurse', 'jhmi.staff', 'jhmi.researcher']
+        (jhuSK, jhuPK) = hyb_abema.authsetup(gp, jhu_attributes)
+        (jhmiSK, jhmiPK) = hyb_abema.authsetup(gp, jhmi_attributes)
+        allAuthPK = {};
+        allAuthPK.update(jhuPK);
+        allAuthPK.update(jhmiPK)
+
+        # Setup a user with a few keys
+        bobs_gid = "20110615 bob@gmail.com cryptokey"
+        K = {}
+        hyb_abema.keygen(gp, jhuSK, 'jhu.professor', bobs_gid, K)
+        hyb_abema.keygen(gp, jhmiSK, 'jhmi.researcher', bobs_gid, K)
+
+        msg = b'Hello World, I am a sensitive record!'
+        size = len(msg)
+        policy_str = "(jhmi.doctor or (jhmi.researcher and jhu.professor))"
+        ct = hyb_abema.encrypt(gp, allAuthPK, msg, policy_str)
+
+        if debug:
+            print("Ciphertext")
+            print("c1 =>", ct['c1'])
+            print("c2 =>", ct['c2'])
+
+        decrypted_msg = hyb_abema.decrypt(gp, K, ct)
+        if debug: print("Result =>", decrypted_msg)
+        assert decrypted_msg == msg, "Failed Decryption!!!"
+        if debug: print("Successful Decryption!!!")
+        del groupObj
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/adapters/ibenc_adapt_hybrid_test.py

@@ -0,0 +1,36 @@
+import unittest
+
+from charm.adapters.ibenc_adapt_hybrid import HybridIBEnc
+from charm.adapters.ibenc_adapt_identityhash import HashIDAdapter
+from charm.schemes.ibenc.ibenc_bb03 import IBE_BB04
+from charm.toolbox.pairinggroup import PairingGroup
+
+debug = False
+
+
+class HybridIBEncTest(unittest.TestCase):
+    def testHybridIBEnc(self):
+        groupObj = PairingGroup('SS512')
+        ibe = IBE_BB04(groupObj)
+
+        hashID = HashIDAdapter(ibe, groupObj)
+
+        hyb_ibe = HybridIBEnc(hashID, groupObj)
+
+        (pk, mk) = hyb_ibe.setup()
+
+        kID = 'waldoayo@gmail.com'
+        sk = hyb_ibe.extract(mk, kID)
+
+        msg = b"This is a test message."
+
+        ct = hyb_ibe.encrypt(pk, kID, msg)
+        if debug:
+            print("Ciphertext")
+            print("c1 =>", ct['c1'])
+            print("c2 =>", ct['c2'])
+
+        decrypted_msg = hyb_ibe.decrypt(pk, sk, ct)
+        if debug: print("Result =>", decrypted_msg)
+        assert decrypted_msg == msg
+        del groupObj

charm/test/adapters/ibenc_adapt_identityhash_test.py

@@ -0,0 +1,32 @@
+import unittest
+
+from charm.adapters.ibenc_adapt_identityhash import HashIDAdapter
+from charm.schemes.ibenc.ibenc_bb03 import IBE_BB04
+from charm.toolbox.pairinggroup import PairingGroup, GT
+
+debug = False
+
+
+class HashIDAdapterTest(unittest.TestCase):
+    def testHashIDAdapter(self):
+        group = PairingGroup('SS512')
+
+        ibe = IBE_BB04(group)
+
+        hashID = HashIDAdapter(ibe, group)
+
+        (pk, mk) = hashID.setup()
+
+        kID = 'waldoayo@email.com'
+        sk = hashID.extract(mk, kID)
+        if debug: print("Keygen for %s" % kID)
+        if debug: print(sk)
+
+        m = group.random(GT)
+        ct = hashID.encrypt(pk, kID, m)
+
+        orig_m = hashID.decrypt(pk, sk, ct)
+
+        assert m == orig_m
+        if debug: print("Successful Decryption!!!")
+        if debug: print("Result =>", orig_m)

charm/test/adapters/kpabenc_adapt_hybrid_test.py

@@ -0,0 +1,30 @@
+import unittest
+
+from charm.adapters.kpabenc_adapt_hybrid import HybridABEnc as HybridKPABEnc
+from charm.schemes.abenc.abenc_lsw08 import KPabe
+from charm.toolbox.pairinggroup import PairingGroup
+
+debug = False
+
+
+class HybridKPABEncTest(unittest.TestCase):
+    def testHybridKPABEnc(self):
+        groupObj = PairingGroup('SS512')
+        kpabe = KPabe(groupObj)
+        hyb_abe = HybridKPABEnc(kpabe, groupObj)
+        access_key = '((ONE or TWO) and THREE)'
+        access_policy = ['ONE', 'TWO', 'THREE']
+        message = b"hello world this is an important message."
+        (pk, mk) = hyb_abe.setup()
+        if debug: print("pk => ", pk)
+        if debug: print("mk => ", mk)
+        sk = hyb_abe.keygen(pk, mk, access_key)
+        if debug: print("sk => ", sk)
+        ct = hyb_abe.encrypt(pk, message, access_policy)
+        mdec = hyb_abe.decrypt(ct, sk)
+        assert mdec == message, "Failed Decryption!!!"
+        if debug: print("Successful Decryption!!!")
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/benchmark/abenc_yllc15_bench.py

@@ -0,0 +1,92 @@
+import sys
+
+from charm.core.engine.util import objectToBytes
+from charm.schemes.abenc.abenc_yllc15 import YLLC15
+from charm.toolbox.pairinggroup import PairingGroup, GT
+from charm.toolbox.policy_expression_spec import policy_expressions
+from charm.toolbox.secretutil import SecretUtil
+
+
+def run_keygen_encrypt_proxy_decrypt_decrypt_round_trip(policy_str):
+    group = PairingGroup('SS512')
+    abe = YLLC15(group)
+    (params, msk) = abe.setup()
+    pkcs, skcs = abe.ukgen(params)
+    pku, sku = abe.ukgen(params)
+
+    attrs = extract_attributes(group, policy_str)
+    random_key_elem = abe.group.random(GT)
+
+    start_bench(group)
+    proxy_key_user = abe.proxy_keygen(params, msk, pkcs, pku, attrs)
+    n = len(attrs)
+    proxy_keygen_exec_time = end_bench(group, "proxy_keygen", n)
+    proxy_key_size = len(objectToBytes(proxy_key_user, group))
+
+    start_bench(group)
+    ciphertext = abe.encrypt(params, random_key_elem, policy_str)
+    encrypt_exec_time = end_bench(group, "encrypt", n)
+    ciphertext_size = len(objectToBytes(ciphertext, group))
+
+    start_bench(group)
+    intermediate_value = abe.proxy_decrypt(skcs, proxy_key_user, ciphertext)
+    proxy_decrypt_exec_time = end_bench(group, "proxy_decrypt", n)
+
+    start_bench(group)
+    recovered_key_elem = abe.decrypt(params, sku, intermediate_value)
+    decrypt_exec_time = end_bench(group, "decrypt", n)
+
+    assert random_key_elem == recovered_key_elem
+
+    return {'policy_str': policy_str,
+            'attrs': attrs,
+            'attrs_vs_proxy_key_size': "# attributes(n) vs proxy key size(B),%d,%d" % (n, proxy_key_size),
+            'policy_leave_vs_ciphertext_size': "# Policy leaf nodes (n) vs Ciphertext size (B),%d,%d" %
+                                               (n, ciphertext_size),
+            'proxy_keygen_exec_time': proxy_keygen_exec_time,
+            'encrypt_exec_time': encrypt_exec_time,
+            'proxy_decrypt_exec_time': proxy_decrypt_exec_time,
+            'decrypt_exec_time': decrypt_exec_time
+            }
+
+
+def extract_attributes(group, policy_str):
+    util = SecretUtil(group)
+    policy = util.createPolicy(policy_str)
+    return [util.strip_index(policy_attr) for policy_attr in util.getAttributeList(policy)]
+
+
+def end_bench(group, operation, n):
+    group.EndBenchmark()
+    benchmarks = group.GetGeneralBenchmarks()
+    cpu_time = benchmarks['CpuTime']
+    real_time = benchmarks['RealTime']
+    return "%s,%d,%f,%f" % (operation, n, cpu_time, real_time)
+
+
+def start_bench(group):
+    group.InitBenchmark()
+    group.StartBenchmark(["RealTime", "CpuTime"])
+
+
+if __name__ == '__main__':
+    """
+    Performance test for YLLC15
+     
+    :arg n: the input size n. Number of attributes or leaf nodes in policy tree.
+    
+    Example invocation:
+    `$ python charm/test/benchmark/abenc_yllc15_bench.py 5`
+    
+    The technique:
+    + uses an input generator to model the expected input data.
+    + successively calls the algorithm under test with sample input data size 
+      growing up n.
+    + measures and returns performance stats.
+    + prints the results in a "grep-able" format.
+    """
+    for n in range(1, int(sys.argv[1])):
+        policy_str = policy_expressions(min_leaves=n, max_leaves=n).example()
+        result = run_keygen_encrypt_proxy_decrypt_decrypt_round_trip(policy_str)
+        print("function,n,CpuTime,RealTime")
+        [print(v) for v in result.values()]

charm/test/benchmark/benchmark_test.py

@@ -0,0 +1,148 @@
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+from charm.toolbox.ecgroup import ECGroup,ZR,G
+from charm.toolbox.eccurve import prime192v2
+from charm.core.math.integer import * 
+
+import unittest, sys
+
+debug = False
+
+def isSaneBenchmark(dct):
+    isSane=True
+    for val in dct.values():
+        if(type(val)==list):
+            for v in val:
+                isSane&=v>=0
+        else:
+            isSane&=val>=0
+    return isSane
+
+@unittest.skipIf(sys.platform == 'darwin', "expected issues on Mac OS X.")
+class BenchmarkTest1(unittest.TestCase):
+    def testPairing(self):    
+        trials = 10
+        trials2 = trials * 3 
+        group = PairingGroup("SS512")
+        g = group.random(G1)
+        h = group.random(G1)
+        i = group.random(G2)
+
+        self.assertTrue(group.InitBenchmark())
+        group.StartBenchmark(["RealTime", "Exp", "Pair"])
+        for a in range(trials):
+            j = g * h 
+            k = i ** group.random(ZR)
+            t = (j ** group.random(ZR)) / h 
+            n = pair(h, i)
+        group.EndBenchmark()
+       
+        msmtDict = group.GetGeneralBenchmarks()
+        self.assertTrue(isSaneBenchmark(msmtDict))        
+
+        self.assertTrue(group.InitBenchmark())
+        
+        group.StartBenchmark(["CpuTime", "Mul", "Pair"])
+        for a in range(trials2):
+            j = g * h 
+            k = i ** group.random(ZR)
+            n = pair(h, i)
+        group.EndBenchmark()
+        
+        msmtDict = group.GetGeneralBenchmarks()
+        del group
+        self.assertTrue(isSaneBenchmark(msmtDict))        
+
+@unittest.skipIf(sys.platform == 'darwin', "expected issues on Mac OS X.")
+class BenchmarkTest2(unittest.TestCase):
+    def testECGroup(self):
+        trials = 10
+        group = ECGroup(prime192v2)
+        g = group.random(G)
+        h = group.random(G)
+        i = group.random(G)
+        
+        self.assertTrue(group.InitBenchmark())
+        group.StartBenchmark(["RealTime", "Mul", "Div", "Exp", "Granular"])
+        for a in range(trials):
+            j = g * h 
+            k = h ** group.random(ZR)
+            t = (j ** group.random(ZR)) / k 
+        group.EndBenchmark()
+        
+        msmtDict = group.GetGeneralBenchmarks()
+        self.assertTrue(isSaneBenchmark(msmtDict))        
+        
+        granDict = group.GetGranularBenchmarks()
+        self.assertTrue(isSaneBenchmark(granDict))        
+        
+        self.assertTrue(group.InitBenchmark())
+        group.StartBenchmark(["RealTime", "Mul", "Div", "Exp", "Granular"])
+        for a in range(trials*2):
+            j = g * h 
+            k = h ** group.random(ZR)
+            t = (j ** group.random(ZR)) / k 
+        group.EndBenchmark()
+        
+        msmtDict = group.GetGeneralBenchmarks()
+        granDict = group.GetGranularBenchmarks()
+        del group
+        self.assertTrue(isSaneBenchmark(msmtDict))        
+        self.assertTrue(isSaneBenchmark(granDict))
+
+@unittest.skipIf(sys.platform == 'darwin', "expected issues on Mac OS X.")
+class BenchmarkTest3(unittest.TestCase):
+    def testInterleave(self):
+        trials = 10
+        trials2 = trials * 3 
+        group1 = PairingGroup("MNT224")
+        group2 = PairingGroup("MNT224")
+        
+        g = group1.random(G1)
+        h = group1.random(G1)
+        i = group1.random(G2)
+        
+        self.assertTrue(group1.InitBenchmark())
+        self.assertTrue(group2.InitBenchmark())
+        group1.StartBenchmark(["RealTime", "Exp", "Pair", "Div", "Mul"])
+        for a in range(trials):
+            j = g * h 
+            k = i ** group1.random(ZR)
+            t = (j ** group1.random(ZR)) / h 
+            n = pair(h, i)
+        group1.EndBenchmark()
+        msmtDict = group1.GetGeneralBenchmarks()
+        del group1, group2
+        self.assertTrue(isSaneBenchmark(msmtDict))
+
+@unittest.skipIf(sys.platform == 'darwin', "expected issues on Mac OS X.")
+class BenchmarkTest4(unittest.TestCase):
+    def testInteger(self):
+        count = 5
+        time_in_ms = 1000
+        
+        a = integer(10)
+        
+        self.assertTrue(InitBenchmark())
+        StartBenchmark(["RealTime", "Exp", "Mul"])
+        for k in range(count):
+            r = randomPrime(256)
+            s = r * (r ** a)
+            j = r * (r ** a)
+        EndBenchmark()
+        msmtDict = GetGeneralBenchmarks()
+        self.assertTrue(isSaneBenchmark(msmtDict))        
+        
+        self.assertTrue(InitBenchmark())
+        StartBenchmark(["RealTime", "Exp", "Mul", "Add", "Sub"])
+        for k in range(count):
+            r = randomPrime(256)
+            s = r * (r ** a)
+            j = r * (r ** a)
+            u = s + j - j 
+        EndBenchmark()
+        msmtDict = GetGeneralBenchmarks()
+        self.assertTrue(isSaneBenchmark(msmtDict)) 
+
+
+if __name__ == "__main__":
+    unittest.main()

charm/test/benchmark_threshold.py

@@ -0,0 +1,260 @@
+"""
+Benchmark suite for DKLS23 Threshold ECDSA implementation.
+
+Run with: python charm/test/benchmark_threshold.py
+
+This module benchmarks:
+- DKG (Distributed Key Generation)
+- Presigning (Round 1 and Round 2 only - full protocol WIP)
+- Signing (simulated with pre-computed values)
+- Full threshold signing flow (DKG only - other phases WIP)
+
+Note: Some benchmarks are limited as the full protocol implementation
+is still in development.
+"""
+
+import time
+import tracemalloc
+from charm.toolbox.ecgroup import ECGroup, ZR, G
+from charm.toolbox.eccurve import secp256k1
+
+
+def run_dkg(group, t, n, g):
+    """
+    Run DKG protocol and return key_shares, public_key.
+
+    This function handles the tuple return from keygen_round3.
+    """
+    from charm.schemes.threshold.dkls23_dkg import DKLS23_DKG
+
+    dkg = DKLS23_DKG(group, threshold=t, num_parties=n)
+
+    # Round 1
+    party_states = [dkg.keygen_round1(i + 1, g) for i in range(n)]
+    round1_msgs = [s[0] for s in party_states]
+    priv_states = [s[1] for s in party_states]
+
+    # Round 2
+    round2_results = [
+        dkg.keygen_round2(i + 1, priv_states[i], round1_msgs) for i in range(n)
+    ]
+    shares_for_others = [r[0] for r in round2_results]
+    states_r2 = [r[1] for r in round2_results]
+
+    # Round 3 - keygen_round3 returns (KeyShare, complaint) tuple
+    key_shares = {}
+    for party_id in range(1, n + 1):
+        received = {
+            sender + 1: shares_for_others[sender][party_id] for sender in range(n)
+        }
+        ks, complaint = dkg.keygen_round3(
+            party_id, states_r2[party_id - 1], received, round1_msgs
+        )
+        if complaint is not None:
+            raise RuntimeError(f"DKG failed: {complaint}")
+        key_shares[party_id] = ks
+
+    public_key = key_shares[1].X
+    return key_shares, public_key
+
+
+def benchmark_dkg(t, n, iterations=10):
+    """
+    Benchmark Distributed Key Generation.
+
+    Parameters
+    ----------
+    t : int
+        Threshold value
+    n : int
+        Number of parties
+    iterations : int
+        Number of iterations to average over
+
+    Returns
+    -------
+    float
+        Average time in milliseconds
+    """
+    group = ECGroup(secp256k1)
+    g = group.random(G)
+
+    times = []
+    for _ in range(iterations):
+        start = time.perf_counter()
+        key_shares, public_key = run_dkg(group, t, n, g)
+        end = time.perf_counter()
+        times.append((end - start) * 1000)  # Convert to ms
+
+    return sum(times) / len(times)
+
+
+def benchmark_presign(t, n, iterations=10):
+    """
+    Benchmark presigning rounds 1 and 2.
+
+    Note: Round 3 is not included as the MtA integration is still in development.
+
+    Parameters
+    ----------
+    t : int
+        Threshold value
+    n : int
+        Number of parties
+    iterations : int
+        Number of iterations to average over
+
+    Returns
+    -------
+    float
+        Average time in milliseconds for rounds 1-2
+    """
+    from charm.schemes.threshold.dkls23_presign import DKLS23_Presign
+
+    group = ECGroup(secp256k1)
+    g = group.random(G)
+
+    # Setup: generate key shares first
+    key_shares, _ = run_dkg(group, t, n, g)
+    participants = list(range(1, t + 1))
+
+    times = []
+    for _ in range(iterations):
+        presign = DKLS23_Presign(group)
+
+        start = time.perf_counter()
+
+        # Round 1
+        r1 = {}
+        st = {}
+        for pid in participants:
+            msg, s = presign.presign_round1(pid, key_shares[pid].x_i, participants, g)
+            r1[pid], st[pid] = msg, s
+
+        # Round 2
+        for pid in participants:
+            b, m, s = presign.presign_round2(pid, st[pid], r1)
+
+        end = time.perf_counter()
+        times.append((end - start) * 1000)
+
+    return sum(times) / len(times)
+
+
+def benchmark_sign(t, n, iterations=10):
+    """
+    Benchmark signing operation (simulated).
+
+    This benchmarks the signing computation with pre-computed values,
+    as the full presigning flow is still in development.
+
+    Parameters
+    ----------
+    t : int
+        Threshold value
+    n : int
+        Number of parties
+    iterations : int
+        Number of iterations to average over
+
+    Returns
+    -------
+    float
+        Average time in milliseconds
+    """
+    from charm.schemes.threshold.dkls23_sign import DKLS23_Sign
+
+    group = ECGroup(secp256k1)
+    g = group.random(G)
+    signer = DKLS23_Sign(group)
+
+    # Simulate signature computation timing
+    # (actual full flow requires working presigning)
+    message = b"Benchmark signing message"
+
+    times = []
+    for _ in range(iterations):
+        # Generate simulated values
+        k = group.random(ZR)
+        x = group.random(ZR)
+        R = g**k
+        r = group.zr(R)
+
+        start = time.perf_counter()
+        # Simulate signature computation
+        e = signer._hash_message(message)
+        s = (e + r * x) * (k ** (-1))
+        end = time.perf_counter()
+        times.append((end - start) * 1000)
+
+    return sum(times) / len(times)
+
+
+def benchmark_full_flow(t, n, num_signatures=5):
+    """
+    Benchmark complete DKG flow with memory usage tracking.
+
+    Note: Only DKG is fully benchmarked; presigning/signing are placeholders
+    until the full protocol is integrated.
+
+    Parameters
+    ----------
+    t : int
+        Threshold value
+    n : int
+        Number of parties
+    num_signatures : int
+        Number of DKG runs to measure
+
+    Returns
+    -------
+    tuple
+        (total_time_ms, peak_memory_kb, avg_per_dkg_ms)
+    """
+    group = ECGroup(secp256k1)
+    g = group.random(G)
+
+    tracemalloc.start()
+    start = time.perf_counter()
+
+    # Run DKG multiple times to measure memory and performance
+    for i in range(num_signatures):
+        key_shares, public_key = run_dkg(group, t, n, g)
+
+    end = time.perf_counter()
+    current, peak = tracemalloc.get_traced_memory()
+    tracemalloc.stop()
+
+    total_ms = (end - start) * 1000
+    peak_kb = peak / 1024
+    avg_per_run = total_ms / num_signatures
+
+    return total_ms, peak_kb, avg_per_run
+
+
+def run_benchmarks(t=2, n=3):
+    """Run all benchmarks and print formatted results."""
+    print(f"\nDKLS23 Threshold ECDSA Benchmarks ({t}-of-{n})")
+    print("=" * 50)
+
+    # Run individual benchmarks
+    dkg_time = benchmark_dkg(t, n, iterations=10)
+    print(f"DKG:      {dkg_time:6.1f} ms (avg over 10 runs)")
+
+    presign_time = benchmark_presign(t, n, iterations=10)
+    print(f"Presign:  {presign_time:6.1f} ms (avg over 10 runs, rounds 1-2)")
+
+    sign_time = benchmark_sign(t, n, iterations=10)
+    print(f"Sign:     {sign_time:6.1f} ms (avg over 10 runs, simulated)")
+
+    # Full flow benchmark
+    total_time, peak_mem, avg_per_run = benchmark_full_flow(t, n, num_signatures=5)
+    print(f"Full flow: {total_time:6.1f} ms total (5 DKG runs)")
+    print(f"Peak memory: {peak_mem:6.1f} KB")
+    print(f"Avg per DKG: {avg_per_run:6.1f} ms")
+    print("=" * 50)
+
+
+if __name__ == "__main__":
+    run_benchmarks(t=2, n=3)
+