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

charm/zkp_compiler/zkp_factory.py

@@ -0,0 +1,330 @@
+"""
+Factory for creating ZK proof instances without dynamic code execution.
+
+This module provides a safe alternative to the exec()-based code generation
+in zkp_generator.py, eliminating code injection vulnerabilities.
+"""
+
+import logging
+import re
+from charm.zkp_compiler.zkparser import ZKParser
+from charm.zkp_compiler.schnorr_proof import SchnorrProof, Proof
+from charm.zkp_compiler.dleq_proof import DLEQProof
+from charm.toolbox.ZKProof import ZKProofBase, ZKParseError, ZKValidationError
+
+logger = logging.getLogger(__name__)
+
+# Allowed characters in ZK statements
+_VALID_STATEMENT_PATTERN = re.compile(r'^[\w\s\^\=\(\)\*]+$')
+
+
+def validate_statement(statement):
+    """
+    Validate a ZK statement string.
+    
+    Checks for valid characters and prevents injection attacks.
+    
+    Args:
+        statement: The ZK statement string to validate
+    
+    Raises:
+        ZKValidationError: If statement is invalid or contains suspicious characters
+    """
+    if not isinstance(statement, str):
+        raise ZKValidationError("Statement must be a string")
+    
+    if not statement.strip():
+        raise ZKValidationError("Statement cannot be empty")
+    
+    if not _VALID_STATEMENT_PATTERN.match(statement):
+        raise ZKValidationError(
+            "Statement contains invalid characters. "
+            "Only alphanumeric characters, ^, =, *, (, ), and whitespace are allowed."
+        )
+    
+    # Check for suspicious patterns that might indicate injection attempts
+    suspicious_patterns = ['__', 'import', 'exec', 'eval', 'compile', 'open', 'file']
+    statement_lower = statement.lower()
+    for pattern in suspicious_patterns:
+        if pattern in statement_lower:
+            raise ZKValidationError(f"Statement contains suspicious pattern: {pattern}")
+    
+    logger.debug("Statement validated: %s", statement)
+
+
+class SchnorrProofInstance:
+    """
+    Wrapper that provides a clean API for Schnorr proofs.
+    
+    Encapsulates the generator, public value, and optionally secret,
+    providing prove() and verify() methods.
+    """
+    
+    def __init__(self, group, g, h, secret_x=None):
+        """
+        Initialize a Schnorr proof instance.
+        
+        Args:
+            group: The pairing group to use
+            g: The generator element
+            h: The public element (h = g^x)
+            secret_x: The secret exponent (required for proving, optional for verifying)
+        """
+        self.group = group
+        self.g = g
+        self.h = h
+        self._secret_x = secret_x
+    
+    def prove(self, interactive=False):
+        """
+        Generate a proof (non-interactive by default).
+        
+        Args:
+            interactive: If True, raises an error (use create_interactive_prover instead)
+        
+        Returns:
+            Proof object containing commitment, challenge, and response
+        
+        Raises:
+            ZKValidationError: If secret is not available or interactive mode requested
+        """
+        if self._secret_x is None:
+            raise ZKValidationError("Cannot prove without secret")
+        if interactive:
+            raise ZKValidationError(
+                "For interactive proofs, use create_interactive_prover() instead"
+            )
+        return SchnorrProof.prove_non_interactive(
+            self.group, self.g, self.h, self._secret_x
+        )
+    
+    def verify(self, proof):
+        """
+        Verify a proof.
+        
+        Args:
+            proof: Proof object to verify
+        
+        Returns:
+            True if proof is valid, False otherwise
+        """
+        return SchnorrProof.verify_non_interactive(
+            self.group, self.g, self.h, proof
+        )
+    
+    def create_interactive_prover(self):
+        """
+        Create an interactive prover instance.
+        
+        Returns:
+            SchnorrProof.Prover instance
+        
+        Raises:
+            ZKValidationError: If secret is not available
+        """
+        if self._secret_x is None:
+            raise ZKValidationError("Cannot create prover without secret")
+        return SchnorrProof.Prover(self._secret_x, self.group)
+    
+    def create_interactive_verifier(self):
+        """
+        Create an interactive verifier instance.
+        
+        Returns:
+            SchnorrProof.Verifier instance
+        """
+        return SchnorrProof.Verifier(self.group)
+
+
+class ZKProofFactory:
+    """
+    Factory for creating ZK proof instances without dynamic code execution.
+    
+    This factory replaces the insecure exec()-based code generation with
+    direct class instantiation, eliminating code injection vulnerabilities.
+    
+    Example:
+        >>> from charm.toolbox.pairinggroup import PairingGroup, ZR, G1
+        >>> group = PairingGroup('SS512')
+        >>> g = group.random(G1)
+        >>> x = group.random(ZR)
+        >>> h = g ** x
+        >>> 
+        >>> # Create a Schnorr proof instance
+        >>> proof_instance = ZKProofFactory.create_schnorr_proof(group, g, h, x)
+        >>> proof = proof_instance.prove()
+        >>> assert proof_instance.verify(proof)
+    """
+    
+    @staticmethod
+    def create_schnorr_proof(group, g, h, secret_x=None):
+        """
+        Create a Schnorr proof instance for proving knowledge of discrete log.
+        
+        Args:
+            group: The pairing group to use
+            g: The generator element
+            h: The public element (h = g^x)
+            secret_x: The secret exponent (required for proving, optional for verifying)
+        
+        Returns:
+            SchnorrProofInstance: An instance that can prove or verify
+        """
+        logger.debug("Creating Schnorr proof instance")
+        return SchnorrProofInstance(group, g, h, secret_x)
+    
+    @staticmethod
+    def create_from_statement(group, statement, public_params, secret_params=None):
+        """
+        Create a proof instance from a parsed ZK statement.
+        
+        This method parses the statement and determines the appropriate
+        proof type, then creates the corresponding proof instance.
+        
+        Args:
+            group: The pairing group to use
+            statement: A ZK statement string like "h = g^x"
+            public_params: Dict mapping variable names to public values
+            secret_params: Dict mapping variable names to secret values (optional)
+        
+        Returns:
+            SchnorrProofInstance: An instance of the appropriate proof type
+        
+        Raises:
+            ZKParseError: If the statement cannot be parsed
+            ZKValidationError: If required parameters are missing
+        """
+        # Validate statement first
+        validate_statement(statement)
+        
+        # Parse the statement
+        try:
+            parser = ZKParser()
+            stmt_object = parser.parse(statement)
+        except Exception as e:
+            raise ZKParseError(f"Failed to parse statement: {e}") from e
+        
+        # Extract required variables from the parsed statement
+        # For now, we support simple Schnorr-style statements: h = g^x
+        # The parser returns a tree structure that we need to analyze
+        
+        if not isinstance(public_params, dict):
+            raise ZKValidationError("public_params must be a dictionary")
+        
+        if secret_params is not None and not isinstance(secret_params, dict):
+            raise ZKValidationError("secret_params must be a dictionary")
+        
+        # Check for required public parameters
+        if 'g' not in public_params:
+            raise ZKValidationError("Missing required public parameter: 'g' (generator)")
+        if 'h' not in public_params:
+            raise ZKValidationError("Missing required public parameter: 'h' (public value)")
+        
+        g = public_params['g']
+        h = public_params['h']
+        
+        # Get secret if available
+        secret_x = None
+        if secret_params and 'x' in secret_params:
+            secret_x = secret_params['x']
+        
+        logger.debug("Created proof instance from statement: %s", statement)
+        return SchnorrProofInstance(group, g, h, secret_x)
+
+
+def prove_and_verify_schnorr(group, g, h, x):
+    """
+    Proves and immediately verifies a Schnorr proof.
+
+    Useful for testing and debugging.
+
+    Args:
+        group: The pairing group to use
+        g: The generator element
+        h: The public element (h = g^x)
+        x: The secret exponent
+
+    Returns:
+        tuple: (proof, is_valid) where proof is the Proof object and is_valid is True if verification passed
+
+    Example::
+
+        group = PairingGroup('SS512')
+        g = group.random(G1)
+        x = group.random(ZR)
+        h = g ** x
+        proof, is_valid = prove_and_verify_schnorr(group, g, h, x)
+        assert is_valid
+    """
+    proof = SchnorrProof.prove_non_interactive(group, g, h, x)
+    is_valid = SchnorrProof.verify_non_interactive(group, g, h, proof)
+    return proof, is_valid
+
+
+def prove_and_verify_dleq(group, g1, h1, g2, h2, x):
+    """
+    Proves and immediately verifies a DLEQ proof.
+
+    Useful for testing and debugging.
+
+    Args:
+        group: The pairing group to use
+        g1: The first generator element
+        h1: The first public element (h1 = g1^x)
+        g2: The second generator element
+        h2: The second public element (h2 = g2^x)
+        x: The secret exponent
+
+    Returns:
+        tuple: (proof, is_valid) where proof is the DLEQProofData object and is_valid is True if verification passed
+
+    Example::
+
+        group = PairingGroup('SS512')
+        g1 = group.random(G1)
+        g2 = group.random(G1)
+        x = group.random(ZR)
+        h1 = g1 ** x
+        h2 = g2 ** x
+        proof, is_valid = prove_and_verify_dleq(group, g1, h1, g2, h2, x)
+        assert is_valid
+    """
+    proof = DLEQProof.prove_non_interactive(group, g1, h1, g2, h2, x)
+    is_valid = DLEQProof.verify_non_interactive(group, g1, h1, g2, h2, proof)
+    return proof, is_valid
+
+
+def configure_logging(level: str = 'WARNING') -> None:
+    """
+    Configure logging for all ZKP compiler modules.
+
+    Args:
+        level: Logging level ('DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL')
+
+    Example:
+        >>> from charm.zkp_compiler import configure_logging
+        >>> configure_logging('DEBUG')  # Enable debug output
+    """
+    numeric_level = getattr(logging, level.upper(), logging.WARNING)
+
+    # Configure all ZKP module loggers
+    zkp_modules = [
+        'charm.zkp_compiler.schnorr_proof',
+        'charm.zkp_compiler.dleq_proof',
+        'charm.zkp_compiler.representation_proof',
+        'charm.zkp_compiler.and_proof',
+        'charm.zkp_compiler.or_proof',
+        'charm.zkp_compiler.range_proof',
+        'charm.zkp_compiler.batch_verify',
+    ]
+
+    for module in zkp_modules:
+        module_logger = logging.getLogger(module)
+        module_logger.setLevel(numeric_level)
+        if not module_logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(logging.Formatter(
+                '%(name)s - %(levelname)s - %(message)s'
+            ))
+            module_logger.addHandler(handler)
+

charm/zkp_compiler/zkp_generator.py

@@ -0,0 +1,370 @@
+"""
+Legacy ZKP Generator Module (DEPRECATED)
+========================================
+
+.. deprecated:: 0.60
+    This module uses insecure dynamic code generation (exec/compile) which
+    can lead to code injection vulnerabilities. It will be removed in v0.80.
+
+    For production use, please migrate to the new secure API:
+
+    - :class:`charm.zkp_compiler.schnorr_proof.SchnorrProof`
+    - :class:`charm.zkp_compiler.dleq_proof.DLEQProof`
+    - :class:`charm.zkp_compiler.representation_proof.RepresentationProof`
+    - :class:`charm.zkp_compiler.zkp_factory.ZKProofFactory`
+
+    See the migration guide in doc/zkp_proof_types_design.md
+
+Example Migration
+-----------------
+Old (deprecated)::
+
+    from charm.zkp_compiler.zkp_generator import executeIntZKProof
+    result = executeIntZKProof(public, secret, statement, party_info)
+
+New (recommended)::
+
+    from charm.zkp_compiler.schnorr_proof import SchnorrProof
+    proof = SchnorrProof.prove_non_interactive(group, g, h, x)
+    is_valid = SchnorrProof.verify_non_interactive(group, g, h, proof)
+"""
+
+import logging
+import warnings
+
+from pyparsing import *
+from charm.zkp_compiler.zkparser import *
+from charm.core.engine.protocol import *
+from charm.core.engine.util import *
+#from charm.core.math.pairing import *
+
+# Emit deprecation warning when this module is imported
+warnings.warn(
+    "The zkp_generator module is deprecated and will be removed in v0.80. "
+    "It uses insecure dynamic code execution (exec/compile). "
+    "Please migrate to charm.zkp_compiler.schnorr_proof or charm.zkp_compiler.zkp_factory. "
+    "See doc/zkp_proof_types_design.md for migration guide.",
+    DeprecationWarning,
+    stacklevel=2
+)
+
+# Set up logging instead of print statements
+logger = logging.getLogger(__name__)
+
+int_default = True
+
+def newStateFunction(func_name, args=True):
+    if args:
+        return """\
+    def %s(self, input):\n""" % func_name
+    else:
+        return """\
+    def %s(self):\n""" % func_name
+
+def addToCode(lines):
+    stmts = "        " # 8 spaces
+    for stmt in lines:
+        if type(stmt) == str:
+#            print("Adding =>", stmt)
+            stmts += stmt + "; "
+    return stmts + "\n"
+
+PROVER, VERIFIER = 1,2
+# Handle a Schnorr HVZK proof-of-knowledge of a discrete logarithm
+def KoDLFixedBase(publicDict, secretDict, baseVarKey, expVarKey, statesCode, interactive):
+    if type(publicDict) != dict or type(secretDict) != dict: 
+        print("Type Error!"); return None
+    
+    # First move of protocol: prover picks random integer "k", store k as a secret, output g^k
+    stateDef = newStateFunction("prover_state1", False)
+ #   stateDef += addToCode(["print('State PROVER 1:')"]) # DEBUG
+    stateDef += addToCode(["pk = Protocol.get(self, "+str(list(publicDict.keys()))+", dict)"])
+    prov_keys, obj_ret, ver_keys2, ver_keys4 = "","", "", []
+    rand_elems,dl_elems,store_elems,non_int_def2 = [],[],[],""
+    for i in range(len(expVarKey)):
+        k = 'k' + str(i)
+        prov_keys += expVarKey[i]+","
+        rand_elems.append(k + " = self.group.random(ZR)")
+        dl_elems.append("val_"+ k + " = pk['" + baseVarKey + "'] ** " + k)
+        store_elems.append("Protocol.store(self, ('"+k+"',"+k+"), ('"+expVarKey[i]+"',"+expVarKey[i]+") )")
+        obj_ret += "'val_"+k+"':val_"+k+", "
+        ver_keys2 += ", ('val_"+k+"', input['val_"+k+"'])"
+        four = 'val_'+k
+        ver_keys4.append('%s' % four) # used in verify_state4
+        non_int_def2 += "input['%s']," % four # used for non-interactive in state def2   
+    stateDef += addToCode(["("+prov_keys+") = Protocol.get(self, "+str(list(expVarKey))+")"])
+    stateDef += addToCode(rand_elems)
+    stateDef += addToCode(dl_elems)
+    stateDef += addToCode(store_elems)
+    stateDef += addToCode(["Protocol.setState(self, 3)","return {"+obj_ret+"'pk':pk }"])
+    statesCode += stateDef + "\n"
+
+    # Second move of protocol: verifier computes random challenge c, outputs c
+    stateDef2 = newStateFunction("verifier_state2")
+    c = 'c'
+ #   stateDef2 += addToCode(["print('State VERIFIER 2:')"]) # DEBUG
+    if interactive == True:
+       stateDef2 += addToCode(["c = self.group.random(ZR)"])
+    else:
+       stateDef2 += addToCode(["c = self.group.hash(("+str(non_int_def2)+"), ZR)"])
+    stateDef2 += addToCode(["Protocol.store(self, ('c',c), ('pk',input['pk'])"+ ver_keys2 +" )", 
+                            "Protocol.setState(self, 4)", "return {'c':c}"])
+    statesCode += stateDef2 + "\n"
+    
+    stateDef3 = newStateFunction("prover_state3")
+#    stateDef3 += addToCode(["print('State PROVER 3:')"]) # DEBUG
+    stateDef3 += addToCode(["c = input['c']"])
+    getVals, test_elems = "", ""
+    compute, ver_inputs = [],[]
+    prf_stmt = []
+    for i in range(len(expVarKey)):
+        z,k = 'z' + str(i),'k' + str(i)
+        getVals += "'"+ expVarKey[i] +"','"+k+"',"
+        compute.append(z + " = val['"+expVarKey[i]+"'] * c + val['"+k+"']")
+        test_elems += "'"+z+"':"+z+","
+        ver_inputs.append(z + " = input['"+z+"']")
+        prf_stmt.append("val['pk']['"+baseVarKey+"'] ** "+z) # used in verify_state4
+        
+    stateDef3 += addToCode(["val = Protocol.get(self, ["+getVals+"], dict)"])
+    stateDef3 += addToCode(compute)
+    stateDef3 += addToCode(["Protocol.setState(self, 5)", "return {"+test_elems+"}"])
+    statesCode += stateDef3 + "\n"
+    
+    stateDef4 = newStateFunction("verifier_state4")
+#    stateDef4 += addToCode(["print('State VERIFIER 4:')"]) # DEBUG    
+    stateDef4 += addToCode(ver_inputs)
+    pk = ['pk']
+    pk.extend(ver_keys4); pk.append('c')
+
+    stateDef4 += addToCode(["val = Protocol.get(self, "+ str(pk) +", dict)"])
+    # need to compute g^z =?= g^k (val_k) * (pubkey)^c
+    verify4_stmt = []
+    for i in range(len(expVarKey)):
+        pub_key = secretDict[ expVarKey[i] ] # get pubkey for secret
+        verify4_stmt.append("\n        if ("+ prf_stmt[i] + ") == " + "((val['pk']['"+pub_key+"'] ** val['c']) * val['"+ver_keys4[i]+"'] ): result = 'OK'\n        else: result = 'FAIL'")
+#        verify4_stmt.append("print(val['pk']['g']); result = 'OK'")    
+    stateDef4 += addToCode(verify4_stmt)
+    stateDef4 += addToCode(["Protocol.setState(self, 6)", "Protocol.setErrorCode(self, result)"] )
+    stateDef4 += addToCode(["print('Result => ',result); return result"])  
+    statesCode += stateDef4 + "\n"
+
+    stateDef5 = newStateFunction("prover_state5")
+#    stateDef5 += addToCode(["print('State PROVER 5:')"]) # DEBUG
+    stateDef5 += addToCode(["Protocol.setState(self, None)", "Protocol.setErrorCode(self, input); return None"])
+    statesCode += stateDef5 + "\n"
+    
+    stateDef6 = newStateFunction("verifier_state6")
+#    stateDef6 += addToCode(["print('State VERIFIER 6:')"]) # DEBUG    
+    stateDef6 += addToCode(["Protocol.setState(self, None)", "return None"])
+    statesCode += stateDef6 + "\n"
+    
+#    print("Finishing state 1 =>", statesCode)
+    # SECURITY: Removed filesystem write of generated code (tmpGenCode.py)
+    # The generated code is logged at DEBUG level for debugging purposes
+    logger.debug("Generated ZK proof code:\n%s", statesCode)
+
+    return statesCode
+
+
+# Return a fixed preamble for an interactive ZK proof protocol.
+def genIZKPreamble():
+    return """\
+\nfrom charm.engine.protocol import *
+from charm.engine.util import *
+from socket import *
+from charm.toolbox.pairinggroup import PairingGroup,ZR,G1,G2,GT,pair
+
+class %s(Protocol):
+    def __init__(self, groupObj, common_input=None):
+        Protocol.__init__(self, None)
+        PROVER,VERIFIER = %s,%s
+        prover_states = { 1:self.prover_state1, 3:self.prover_state3, 5:self.prover_state5 }
+        verifier_states = { 2:self.verifier_state2, 4:self.verifier_state4, 6:self.verifier_state6 }
+        prover_trans = { 1:3, 3:5 }
+        verifier_trans = { 2:4, 4:6 }
+        # describe the parties involved and the valid transitions
+        Protocol.addPartyType(self, VERIFIER, verifier_states, verifier_trans)
+        Protocol.addPartyType(self, PROVER, prover_states, prover_trans, True)
+
+        # must pass in a group object parameter (allows us to operate in any setting)
+        self.group = groupObj
+
+        if common_input == None: # generate common parameters to P and V
+           db = {}
+           self.__gen_setup = True
+        else: # can be used as a sub-protocol if common_input is specified by caller
+           db = common_input
+           self.__gen_setup = False
+        self.PROVER, self.VERIFIER = PROVER, VERIFIER
+        Protocol.setSubclassVars(self, self.group, db)\n"""
+
+# public contains a dictionary of the public group elements (keys appropriately labeled)
+# secret contains a dictionary of the secret elements (keys must be appropriately labeled)
+# statement is the statement for which we would like to prove via ZK and thus code 
+# we need to generate to prove the statement.
+def parseAndGenerateCode(public, secretDict, statement, party_ID, interactive):
+    # parse the statement such that we know the baseVar, expName (secret)
+    output = genIZKPreamble()
+    output = output % ('ZKProof', PROVER, VERIFIER)
+
+    parser = ZKParser()
+    stmt_object = parser.parse(statement)
+    pk, sk = [], []
+    gen, sec = [], {}
+    extract(stmt_object, pk, sk, sec, gen)
+    # Get the preamble (including class definition and __init__ routine
+#    print("Public params...", pk)
+#    print("Secret keys...", sk)
+#    print("Secret key =>", sec)
+
+    baseVar = gen.pop() # NOTE: we only support one generator for now (i.e. 'g'), for more advanced
+    expSecret = sk # e.g. ['x', 'y',...]
+    secret = sec # mapping of secret to public key (e.g. {'x':'h', 'y':'j'}
+    
+#    print("Input public =>", public)
+#    print("Input private =>", secret)
+
+    final_src = KoDLFixedBase(public, secret, baseVar, expSecret, output, interactive)
+    return final_src
+    
+def extract(node, pk, sk, sk_pk_map, gen):
+    if node.type == node.EXP:
+#        print("public =>", node.getLeft(), "in pk?")
+#        print("secret =>", node.getRight(), "in sk?")
+        if not node.getLeft() in pk:
+            pk.append(node.getLeft())
+        if not node.getLeft() in gen:
+            gen.append(node.getLeft())  # ONLY SUPPORT 1 generator (may need to re-arch generator to support multiple gens)    
+        sk.append(node.getRight())
+            
+    elif node.type == node.EQ:
+#        print("public =>", node.getLeft(), "in pk?")
+        extract(node.getRight(), pk, sk, sk_pk_map, gen)        
+        sec_key = sk.pop()
+        sk_pk_map[sec_key] = node.getLeft()
+        sk.append(sec_key)
+        if not node.getLeft() in pk:
+            pk.append(node.getLeft())
+    elif node.type == node.AND:
+        extract(node.getLeft(), pk, sk, sk_pk_map, gen)
+        extract(node.getRight(), pk, sk, sk_pk_map, gen)
+    else:
+        return None
+    return None
+
+# does tyep checking on the parsed statement object to determine 
+# 1) all the public keys (in stmt) appear in pk
+# 2) all the secret keys (in stmt) appear in sk
+def dict_check(node, pk, sk):
+    if node.type == node.EXP:
+       if not node.getLeft() in pk: return False
+       if not node.getRight() in sk: return False
+    elif node.type == node.EQ:
+        if not node.getLeft() in pk: return False
+        return dict_check(node.getRight(), pk, sk)
+    elif node.type == node.AND:
+        if dict_check(node.getLeft(), pk, sk) == False: return False
+        if dict_check(node.getRight(), pk, sk) == False: return False
+    elif node.type == node.OR:
+        if dict_check(node.getLeft(), pk, sk) or dict_check(node.getLeft(), pk, sk): return True
+        else: return False
+    return True
+
+def write_out(name, prefix, value):
+    """Log debug output instead of writing to filesystem.
+
+    SECURITY: This function previously wrote to the filesystem, which could
+    allow attackers to write arbitrary content. Now it logs to the debug
+    logger instead.
+    """
+    logger.debug("%s: %s => %s", name, prefix, value)
+
+
+# Generate an interactive ZK proof from a statement and variables.  The output
+# of this function is a subclass of Protocol.  To execute the proof, first
+# set it up using the Protocol API and run Execute().
+def executeIntZKProof(public, secret, statement, party_info, interactive=int_default):
+    """Execute an interactive ZK proof.
+
+    .. deprecated:: 0.60
+        This function uses insecure dynamic code execution (exec/compile).
+        Use :class:`charm.zkp_compiler.zkp_factory.ZKProofFactory` instead.
+
+        Migration example::
+
+            # Old (deprecated):
+            # result = executeIntZKProof(public, secret, statement, party_info)
+
+            # New (recommended):
+            from charm.zkp_compiler.zkp_factory import ZKProofFactory
+            proof_instance = ZKProofFactory.create_schnorr_proof(group, g, h, x)
+            proof = proof_instance.prove()
+            is_valid = proof_instance.verify(proof)
+    """
+    warnings.warn(
+        "executeIntZKProof() uses insecure dynamic code execution. "
+        "Use charm.zkp_compiler.zkp_factory.ZKProofFactory instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    logger.info("Executing Interactive ZK proof...")
+    # verify that party_info contains wellformed dictionary
+    party_keys = set(['party', 'setting', 'socket'])
+    if not party_keys.issubset(set(party_info.keys())):
+        missing_keys = party_keys.difference_update(set(party_info_keys()))
+        logger.error("Required key/values missing: '%s'", missing_keys)
+        return None
+
+    p_name, p_socket, groupObj = party_info['party'], party_info['socket'], party_info['setting']
+    if p_name.upper() == 'PROVER': partyID = PROVER
+    elif p_name.upper() == 'VERIFIER': partyID = VERIFIER
+    else: logger.error("Unrecognized party!"); return None
+
+    # Parse through the statement and insert code into each state of the prover and/or verifier
+    ZKClass = parseAndGenerateCode(public, secret, statement, partyID, interactive)
+    dummy_class = '<string>'
+    # SECURITY WARNING: compile() and exec() are used here for legacy compatibility.
+    # This is a known security vulnerability. Use ZKProofFactory for new code.
+    proof_code = compile(ZKClass, dummy_class, 'exec')
+    logger.debug("Proof code object => %s", proof_code)
+#    return proof_code
+    ns = {}
+    exec(proof_code, globals(), ns)  # nosec B102 - legacy code, deprecated
+    ZKProof = ns['ZKProof']
+
+    prov_db = None
+    if(partyID == PROVER):
+        prov_db = {}; prov_db.update(public); prov_db.update(secret)
+    zkp = ZKProof(groupObj, prov_db)
+    zkp.setup( {'name':p_name.lower(), 'type':partyID, 'socket':p_socket})
+    # is there a way to check type of socket?
+    zkp.execute(partyID)
+    return zkp.result
+
+
+def executeNonIntZKProof(public, secret, statement, party_info):
+    """Execute a non-interactive ZK proof.
+
+    .. deprecated:: 0.60
+        This function uses insecure dynamic code execution (exec/compile).
+        Use :class:`charm.zkp_compiler.schnorr_proof.SchnorrProof` instead.
+
+        Migration example::
+
+            # Old (deprecated):
+            # result = executeNonIntZKProof(public, secret, statement, party_info)
+
+            # New (recommended):
+            from charm.zkp_compiler.schnorr_proof import SchnorrProof
+            proof = SchnorrProof.prove_non_interactive(group, g, h, x)
+            is_valid = SchnorrProof.verify_non_interactive(group, g, h, proof)
+    """
+    warnings.warn(
+        "executeNonIntZKProof() uses insecure dynamic code execution. "
+        "Use charm.zkp_compiler.schnorr_proof.SchnorrProof instead.",
+        DeprecationWarning,
+        stacklevel=2
+    )
+    logger.info("Executing Non-interactive ZK proof...")
+    return executeIntZKProof(public, secret, statement, party_info, interactive=False)
+