Implement Circom runner

Author: Merricx

src/zkregex_fuzzer/cli.py

@@ -3,10 +3,12 @@
 """
 
 import argparse
+from pathlib import Path
 from zkregex_fuzzer.fuzzer import fuzz_with_grammar
 from zkregex_fuzzer.grammar import REGEX_GRAMMAR
 from zkregex_fuzzer.configs import TARGETS, VALID_INPUT_GENERATORS
 from zkregex_fuzzer.logger import logger
+from zkregex_fuzzer.runner.circom import CircomSubprocess, SnarkjsSubprocess, ZkRegexSubprocess
 
 def main():
     parser = argparse.ArgumentParser(
@@ -24,6 +26,12 @@ def main():
         default=10,
         help="Number of inputs to generate for each regex (default: 10)."
     )
+    parser.add_argument(
+        "--max-input-size",
+        type=int,
+        default=200,
+        help="Maximum size of the circuit input (default: 200)."
+    )
     parser.add_argument(
         "--oracle",
         choices=["valid", "invalid"],
@@ -52,10 +60,56 @@ def main():
         help="Maximum depth of recursion in the grammar (default: 5)."
     )
 
+    parser.add_argument(
+        "--circom-library",
+        nargs="*",
+        type=str,
+        help="Path to the circom library to be included"
+    )
+
+    parser.add_argument(
+        "--circom-prove",
+        action="store_true",
+        help="Run the proving and verification step with SnarkJS."
+    )
+
+    parser.add_argument(
+        "--circom-ptau",
+        type=str,
+        help="Path to the ptau (powers-of-tau) file for the proving step"
+    )
+
     args = parser.parse_args()
 
     if args.oracle == "valid" and not args.valid_input_generator:
         raise ValueError("Valid input generator is required for valid oracle.")
+    
+    if args.target == "circom":
+        circom_version = CircomSubprocess.get_installed_version()
+        snarkjs_version = SnarkjsSubprocess.get_installed_version()
+        zk_regex_version = ZkRegexSubprocess.get_installed_version()
+        print("-" * 80)
+        print(f"Circom: {circom_version}")
+        print(f"SnarkJS: {snarkjs_version}")
+        print(f"zk-regex: {zk_regex_version}")
+
+        # check if path to circom library passed as -l arg exists
+        normalized_path = []
+        for path in args.circom_library:
+            abs_path = Path(path).resolve()
+            if not abs_path.exists():
+                raise ValueError(f"Path to circom library {abs_path} does not exist.")
+            normalized_path.append(str(abs_path))
+        args.circom_library = normalized_path
+
+        # check if path to ptau used in proving step exists
+        if args.circom_prove:
+            if not args.circom_ptau:
+                raise ValueError("Path to ptau file is required for proving.")
+            
+            ptau_path = Path(args.circom_ptau).resolve()
+            if not ptau_path.exists():
+                raise ValueError(f"Path to ptau file {ptau_path} does not exist.")
 
     print("-" * 80)
     print(f"Fuzzing with {args.fuzzer} fuzzer.")
@@ -76,6 +130,7 @@ def main():
             regex_num=args.regex_num,
             inputs_num=args.inputs_num,
             max_depth=args.max_depth,
+            kwargs=vars(args)
         )
 
 

src/zkregex_fuzzer/fuzzer.py

@@ -18,6 +18,7 @@ def fuzz_with_grammar(
         regex_num: int,
         inputs_num: int,
         max_depth: int,
+        kwargs
     ):
     """
     Fuzz test with grammar.
@@ -42,7 +43,7 @@ def fuzz_with_grammar(
     primary_runner = PythonReRunner
     for regex, inputs in zip(regexes, regexes_inputs):
         print(f"Testing regex: {regex} -------- ({len(inputs)} inputs)")
-        result = harness(regex, primary_runner, target_runner, inputs, oracle)
+        result = harness(regex, primary_runner, target_runner, inputs, oracle, kwargs)
         if result.status == HarnessStatus.FAILED:
             print("-" * 80)
             print(f"Found a bug with regex: {regex}")

src/zkregex_fuzzer/harness.py

@@ -9,6 +9,7 @@
 from typing import Type, List
 from enum import Enum
 from dataclasses import dataclass
+from zkregex_fuzzer.logger import logger
 from zkregex_fuzzer.runner import Runner, RegexCompileError, RegexRunError
 
 class HarnessStatus(Enum):
@@ -28,7 +29,7 @@ class HarnessResult:
     # Status (an enum for the result of the test)
     status: HarnessStatus
 
-def harness(regex: str, primary_runner_cls: Type[Runner], secondary_runner_cls: Type[Runner], inputs: List[str], oracle: bool) -> HarnessResult:
+def harness(regex: str, primary_runner_cls: Type[Runner], secondary_runner_cls: Type[Runner], inputs: List[str], oracle: bool, kwargs) -> HarnessResult:
     """
     Harness for running regexes.
 
@@ -37,6 +38,7 @@ def harness(regex: str, primary_runner_cls: Type[Runner], secondary_runner_cls:
     secondary_runner_cls: The class of the secondary runner (either circom or noir runners).
     inputs: The inputs to use to test the regex.
     oracle: The oracle to use to test the regex. True if the inputs are valid regexes. False if the inputs are invalid regexes.
+    kwargs: The arguments to pass to the secondary runner.
 
     Returns:
         A HarnessResult object.
@@ -49,7 +51,7 @@ def harness(regex: str, primary_runner_cls: Type[Runner], secondary_runner_cls:
         return HarnessResult(regex, inp_num, oracle, [], HarnessStatus.INVALID_SEED)
 
     try:
-        secondary_runner = secondary_runner_cls(regex)
+        secondary_runner = secondary_runner_cls(regex, kwargs)
     except RegexCompileError as e:
         return HarnessResult(regex, inp_num, oracle, [], HarnessStatus.COMPILE_ERROR)
 
@@ -63,7 +65,7 @@ def harness(regex: str, primary_runner_cls: Type[Runner], secondary_runner_cls:
         try:
             if secondary_runner.match(input) != oracle:
                 failed_inputs.append(input)
-        except RegexRunError:
+        except RegexRunError as e:
             return HarnessResult(regex, inp_num, oracle, [input], HarnessStatus.RUN_ERROR)
 
     if len(failed_inputs) > 0:

src/zkregex_fuzzer/runner.py

@@ -0,0 +1,3 @@
+from .base_runner import Runner, RegexCompileError, RegexRunError
+from .python import PythonReRunner
+from .circom import CircomRunner

src/zkregex_fuzzer/runner/__init__.py

@@ -0,0 +1,64 @@
+"""
+Runners for regex implementations.
+
+Supported runners:
+- Python re module
+
+TODO:
+- Circom runner
+- Noir runner
+"""
+
+from abc import ABC, abstractmethod
+
+
+class RegexCompileError(Exception):
+    """
+    Exception raised when a regex cannot be compiled.
+    """
+    pass
+
+
+class RegexRunError(Exception):
+    """
+    Exception raised when a regex cannot be run.
+    """
+    pass
+
+
+class Runner(ABC):
+    """
+    Abstract base class for regex runners.
+    """
+
+    def __init__(self, regex: str):
+        self._regex = regex
+        self._runner = "Abstract runner"
+        self._regex_object = self.compile(regex)
+
+    @abstractmethod
+    def compile(self, regex: str) -> None:
+        """
+        Compile a regex.
+        """
+        pass
+
+    @abstractmethod
+    def match(self, input: str) -> bool:
+        """
+        Match the regex on an input.
+        """
+        pass
+
+    def clean(self) -> None:
+        """
+        Clean any produced temporary files.
+        """
+        pass
+
+    def save(self, path: str) -> None:
+        """
+        Save any produced temporary files.
+        """
+        pass
+