From 9be203eb6ce1a2070b017c549af281ec80607812 Mon Sep 17 00:00:00 2001 From: Prasanna Date: Sat, 2 May 2026 10:16:20 +0530 Subject: [PATCH] Detect bool method replay --- kernelguard.py | 106 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 105 insertions(+), 1 deletion(-) diff --git a/kernelguard.py b/kernelguard.py index f086847..8935acb 100644 --- a/kernelguard.py +++ b/kernelguard.py @@ -2462,6 +2462,104 @@ def _has_ver(expr: ast.AST | None) -> bool: return [] +def detect_bool_method_replay(code: str | SubmissionFacts) -> list[dict]: + """Pattern: object truthiness guards replay from its stored state.""" + facts = ensure_submission_facts(code) + tree = facts.ast_tree + if tree is None: + return [] + entrypoint_name = entrypoint_label(facts.entrypoint_name) + + bool_classes = { + stmt.name + for stmt in tree.body + if isinstance(stmt, ast.ClassDef) + and any( + isinstance(item, ast.FunctionDef) and item.name == "__bool__" + for item in stmt.body + ) + } + instances = { + stmt.targets[0].id: stmt.value.func.id + for stmt in tree.body + if isinstance(stmt, ast.Assign) + and len(stmt.targets) == 1 + and isinstance(stmt.targets[0], ast.Name) + and isinstance(stmt.value, ast.Call) + and isinstance(stmt.value.func, ast.Name) + and stmt.value.func.id in bool_classes + } + + def _param_names(node: ast.FunctionDef | ast.AsyncFunctionDef) -> set[str]: + params = {arg.arg for arg in node.args.args} + params.update(arg.arg for arg in node.args.posonlyargs) + params.update(arg.arg for arg in node.args.kwonlyargs) + return params + + def _instance_attr(expr: ast.AST | None) -> tuple[str, str] | None: + if isinstance(expr, ast.Subscript): + return _instance_attr(expr.value) + if not ( + isinstance(expr, ast.Attribute) + and isinstance(expr.value, ast.Name) + and expr.value.id in instances + ): + return None + return expr.value.id, expr.attr + + for node in ast.walk(tree): + if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)): + continue + if not is_entrypoint_name(node.name): + continue + + params = _param_names(node) + mutated = { + key + for expr in ast.walk(node) + if isinstance(expr, ast.Call) + and isinstance(expr.func, ast.Attribute) + and expr.func.attr in {"append", "extend", "insert", "update", "setdefault"} + and any(bool(_expr_names(arg) & params) for arg in expr.args) + for key in [_instance_attr(expr.func.value)] + if key is not None + } + if not mutated: + continue + + for child in ast.walk(node): + if not isinstance(child, ast.If): + continue + if _body_has_calls(child.body): + continue + if _expr_names(child.test) & params: + continue + tested_instances = { + expr.id + for expr in ast.walk(child.test) + if isinstance(expr, ast.Name) and expr.id in instances + } + returned = { + key + for stmt in child.body + if isinstance(stmt, ast.Return) + for key in [_instance_attr(stmt.value)] + if key is not None + } + if any(root == instance for root, _attr in returned for instance in tested_instances): + if returned & mutated: + return [{ + "pattern": "BOOL_METHOD_REPLAY", + "severity": "critical", + "evidence": ( + f"{entrypoint_name} returns state behind an object " + "__bool__ replay guard" + ), + }] + + return [] + + RE_OBJECT_ID_DATA = re.compile(r"\bdata_id\s*=\s*id\s*\(\s*data\s*\)") RE_RESULT_BANK_SET = re.compile(r"_superbatch_results\s*\[\s*(?:did|data_id)\s*\]\s*=") RE_RESULT_BANK_RETURN = re.compile(r"return\s+_superbatch_results\s*\[\s*data_id\s*\]") @@ -3479,6 +3577,10 @@ class RulePolicy: "LAST_CALL_REPLAY", "result_reuse", "hard", AUTO_FILTER, (), AMD_MANUAL_LAST_CALL_REPLAY_FIXTURES, "keep", ), + "BOOL_METHOD_REPLAY": RulePolicy( + "BOOL_METHOD_REPLAY", "result_reuse", "hard", AUTO_FILTER, (), + (), "keep", + ), "SHAPE_OUTPUT_REPLAY": RulePolicy( "SHAPE_OUTPUT_REPLAY", "result_reuse", "hard", AUTO_FILTER, (), AMD_PACKAGE_SHAPE_REPLAY_FIXTURES, "keep", @@ -3762,6 +3864,7 @@ def support_only_patterns(matched_patterns: list[dict]) -> bool: detect_decode_mm_ref, detect_result_caching, detect_last_call_replay, + detect_bool_method_replay, detect_shape_output_replay, detect_timed_input_replay, detect_cuda_graph_replay, @@ -3800,6 +3903,7 @@ def support_only_patterns(matched_patterns: list[dict]) -> bool: ("decode_mm_ref", detect_decode_mm_ref), ("result_caching", detect_result_caching), ("last_call_replay", detect_last_call_replay), + ("bool_method_replay", detect_bool_method_replay), ("shape_output_replay", detect_shape_output_replay), ("timed_input_replay", detect_timed_input_replay), ("cuda_graph_replay", detect_cuda_graph_replay), @@ -4696,7 +4800,7 @@ def _worker_parquet(args: tuple) -> dict: "EVALUATOR_EXPLOIT", "HARNESS_RUNTIME_PATCHING", "MODULE_MUTATION", "GLOBALS_MUTATION", "CODE_REPLACEMENT", "FRAME_WALK_ACCESS", "FRAME_WALK_MUTATION", "SYS_MODULES_ACCESS", "GLOBALS_ACCESS", "CODE_ACCESS", "TRUSTED_MODULE_IMPORT", - "OUTPUT_REPLAY_CACHE", "LAST_CALL_REPLAY", "SHAPE_OUTPUT_REPLAY", "TIMED_INPUT_REPLAY", "CONFIG_CACHE_EXPLOIT", "POINTER_REPLAY", "RESULT_BANK_REPLAY", "PREPROCESS_CACHE", "WORKSPACE_CACHE", + "OUTPUT_REPLAY_CACHE", "LAST_CALL_REPLAY", "BOOL_METHOD_REPLAY", "SHAPE_OUTPUT_REPLAY", "TIMED_INPUT_REPLAY", "CONFIG_CACHE_EXPLOIT", "POINTER_REPLAY", "RESULT_BANK_REPLAY", "PREPROCESS_CACHE", "WORKSPACE_CACHE", "RUNNER_PLAN_CACHE", "CUDA_GRAPH_PYTHON", "CUDA_GRAPH_REPLAY", "TIMER_MONKEYPATCH", "FAKE_BENCHMARK_EMIT", "STDIO_REDIRECT", "UNSYNC_MULTISTREAM", "CUDA_EVENT_DISABLE_TIMING", "SCALED_MM_REF", "DECODE_MM_REF", "SILENT_FALLBACK", "REFERENCE_PRECOMPUTE_REPLAY", "TORCH_COMPILE_CACHE",