#!/usr/bin/env python3 """Collect named failures after the developer patch from retained evidence. Only instances with dev_patch_fixes_root_cause false are catalogued. Independent residuals, mixed inputs and dismissed cross-CVE findings retain their classifications; inclusion does not change any verdict. Inputs are program text where retained or generated, and a report reference where the second reading did not retain its program files. Case identifiers include the case set, so counts are evidence entries rather than counts of unique program texts. No build or case is rerun by this script. Usage: python3 scripts/post_dev_failing_inputs.py [instance ...] python3 scripts/post_dev_failing_inputs.py --parquet FILE --card FILE --stage DIR """ import argparse import csv import importlib.util import json import re import shutil import subprocess from pathlib import Path FIELDS = ( "case_id", "input", "input_path", "generator", "source_status", "expected", "observed", "outcome", "classification", "evidence", ) INSTANCES = ( "mruby.cve-2022-1276", "mruby.cve-2022-0240", "mruby.cve-2022-1201", "njs.cve-2022-31306", ) def entry(case_id, source, expected, observed, outcome, classification, evidence, input_path="", generator=""): return dict(zip(FIELDS, ( case_id, source, input_path, generator, "program" if source else "report_only", expected, observed, outcome, classification, evidence, ))) def simple_results(path): return {m[1]: (m[2], m[3].strip()) for m in re.finditer( r"^(\w+)\s+(OK|WRONG|ASAN)([^\n]*)$", Path(path).read_text(), re.M)} def shell_cases(script, marker): """Expand the runner's existing case definitions without running an engine. Only the case-definition suffix is evaluated. Its run_case/crash_case/ctrl_case calls emit their arguments as NUL fields. """ text = Path(script).read_text() suffix = text[text.index(marker):] suffix = suffix.split('\necho "summary:', 1)[0] capture = """MRUBY=ruby is_ruby=1 # The image uses GNU seq, which emits nothing for `seq 1 0`. # Some host versions instead count down, changing the zero-argument input. seq() { local sep=$'\\n' first=1 last i if [[ "$1" == -s* ]]; then sep=${1:2}; shift; fi if [ "$#" = 1 ]; then last=$1; else first=$1; last=$2; fi for ((i=first; i<=last; i++)); do [ "$i" = "$first" ] || printf '%s' "$sep" printf '%s' "$i" done if ((first <= last)); then printf '\\n'; fi return 0 } run_case() { printf 'CASE\\0%s\\0%s\\0%s\\0%s\\0' "$1" "${2-}" "${3-}" "${4-}"; } crash_case() { run_case "$@"; } ctrl_case() { run_case "$@"; } """ result = subprocess.run(["bash", "-e", "-c", capture + suffix], capture_output=True, check=True, text=True) if result.stderr: raise ValueError(f"Case expansion wrote stderr: {script}: {result.stderr}") parts = result.stdout.split("\0") cases = {} while len(parts) >= 5 and parts[0] == "CASE": _, name, a, b, c = parts[:5] cases[name] = (a, b, c) parts = parts[5:] if not cases: raise ValueError(f"No case definitions expanded: {script}") return cases def kwargs_inputs(instance): script = "scripts/kwargs_aset_cases.sh" cases = shell_cases(script, "big=$(for") log = f"logs/{instance}/variants/after.cases.log" rows = [] recorder = "class R; def []=(*a); $got = a; end; def [](*a); $ref = a; R.new; end; end; o = R.new" for name, (outcome, detail) in simple_results(log).items(): if outcome == "OK": continue setup, statement, expected = cases[name] source = (f'{recorder}\n{setup}\n{statement}\nexp = {expected}\n' 'puts($got == exp ? "OK" : "WRONG got=#{$got.inspect}")\n') classification = "residual" if name.startswith("kwbig_") or name == "opasgn_kw_n1" else "root_cause" rows.append(entry(f"main/{name}", source, f"received arguments: {expected}", detail, outcome, classification, log, generator=script)) script = "scripts/kwargs_residual_cases.sh" cases = shell_cases(script, "pairs() {") log = f"logs/{instance}/variants/after.residual.log" for name, (outcome, detail) in simple_results(log).items(): if outcome != "OK": source, expected, _ = cases[name] rows.append(entry(f"residual/{name}", source + "\n", expected, detail, outcome, "residual", log, generator=script)) return rows def raw_catalog(path): runs, current, mode = {}, None, None for line in Path(path).read_text().splitlines(): if line.startswith("@@@ BEGIN "): name, status = line[len("@@@ BEGIN "):].rsplit(" rc=", 1) current = {"out": [], "err": [], "status": int(status)} runs[name] = current mode = None elif line == "@@@ STDOUT": mode = "out" elif line == "@@@ STDERR": mode = "err" elif line == "@@@ END": mode = None elif current is not None and mode: current[mode].append(line) for run in runs.values(): for key in ("out", "err"): if run[key] and run[key][-1] == "": run[key].pop() run[key] = "\n".join(run[key]) return runs def error_of(stderr): # Same error-class/message oracle as nvalhash_variants_compare.py. patterns = ( r"^\S+:\d+:in [^:]*?: (.*) \(([A-Z]\w*)\)$", r"^\S+:\d+: (.*) \(([A-Z]\w*)\)$", r"^\S+:\d+:in `[^']*': (.*) \(([A-Z]\w*)\)$", ) for line in stderr.splitlines(): for pattern in patterns: match = re.match(pattern, line) if match: return match[2], match[1] for line in stderr.splitlines(): if any(s in line for s in ("stack pointer", "syntax error", "codegen")): return "COMPILE", line.strip() return None def classify(run, reference): if "ERROR: AddressSanitizer" in run["out"] + run["err"]: return "ASAN" error, ref_error = error_of(run["err"]), error_of(reference["err"]) if run["out"] == reference["out"] and error == ref_error: return "OK" if run["out"] == reference["out"] and error and ref_error and error[0] == ref_error[0]: return "OKc" return "WRONG" def rendered(run): error = error_of(run["err"]) value = f'stdout={run["out"]!r}' if error: value += f"; error={error[0]}: {error[1]}" report = re.search(r"ERROR: (AddressSanitizer:[^\n]+)", run["err"]) if report: value += "; " + report[1] return value def nvalhash_inputs(instance): script = "scripts/nvalhash_cases.sh" cases = shell_cases(script, "# --- reaching forms:") log = f"logs/{instance}/variants/after.cases.log" rows = [] for name, (outcome, detail) in simple_results(log).items(): if outcome == "OK": continue body, expected, _ = cases[name] source = ('def t\n x = 111\n y = 222\n' + f' {body}\n [x, y]\nend\n' 'begin; print "<<" + t.inspect + ">>"; rescue => e; print "<>"; end\n') rows.append(entry(f"main/{name}", source, expected, detail, outcome, "root_cause", log, generator=script)) base = Path(f"logs/{instance}/second_reading") seen = set() for prefix in ("variants", "adjudication"): dev_path = base / f"{prefix}_dev.log" dev, ref, root = (raw_catalog(base / f"{prefix}_{build}.log") for build in ("dev", "cruby", "root")) other = raw_catalog(base / "variants_b.log") if prefix == "variants" else {} both = raw_catalog(base / "variants_ab.log") if prefix == "variants" else {} for name, run in dev.items(): if name in seen: continue seen.add(name) outcome = classify(run, ref[name]) if outcome not in ("WRONG", "ASAN"): continue if classify(root[name], ref[name]) == "OK": classification = "root_cause" elif name in other and classify(other[name], ref[name]) == "OK": classification = "residual" elif name in both and classify(both[name], ref[name]) == "OK": classification = "mixed_root_cause_and_residual" else: classification = "other_observed_failure" group, stem = name.split("/", 1) phase = "phase3" if group == "inputs_g" else "phase2" source_path = base / phase / group / (stem + ".rb") rows.append(entry(f"second_reading/{name}", source_path.read_text(), rendered(ref[name]), rendered(run), outcome, classification, str(dev_path), input_path=str(source_path))) return rows def tsv_catalog(path): return {p[0]: (p[1], p[2]) for line in Path(path).read_text().splitlines() if not line.startswith("#") and len(p := line.split("\t")) == 3} def super_inputs(instance): script = "scripts/supernull_cases.sh" cases = shell_cases(script, "# --- MRB_TT_MODULE branch:") log = f"logs/{instance}/variants/after.cases.log" rows = [] for name, (outcome, detail) in simple_results(log).items(): if outcome != "OK": source, _, _ = cases[name] rows.append(entry(f"main/{name}", source + "\n", "controlled exception; no sanitizer report", detail, outcome, "cross_cve:mruby.cve-2022-1427", log, generator=script)) base = Path(f"logs/{instance}/second_reading") dev_path = base / "catalog_dev.tsv" dev, ref = tsv_catalog(dev_path), tsv_catalog(base / "catalog_cruby.tsv") for name, (outcome, detail) in dev.items(): expected = ref[name][1] if outcome == "ASAN": classification = "cross_cve:mruby.cve-2022-1427" elif expected.startswith("value=") and detail != expected: outcome, classification = "WRONG", "residual" else: continue source_path = base / "phase3" / (name + ".rb") rows.append(entry(f"second_reading/{name}", source_path.read_text(), expected, detail, outcome, classification, str(dev_path), input_path=str(source_path))) return rows def load_generator(path): spec = importlib.util.spec_from_file_location(Path(path).stem, path) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) return module def njs_inputs(instance): rows = [] for topic, variant, case_set in (("recurdesc", "cases", "main"), ("recurdesc_big", "big", "large_array")): script = f"scripts/{topic}_cases.py" module = load_generator(script) generated = module.rc_cases() if topic == "recurdesc" else module.cases() sources = {row[0]: module.PRELUDE.lstrip("\n") + row[-1] for row in generated} expected_path = f"scripts/{topic}_expected.tsv" with open(expected_path) as stream: expected = {r["case"]: r["output"] for r in csv.DictReader( (line for line in stream if not line.startswith("#")), delimiter="\t")} log = f"logs/{instance}/variants/after.{variant}.log" text = Path(log).read_text() for name, (outcome, detail) in simple_results(log).items(): if outcome == "OK": continue match = re.search(rf"^{re.escape(name)}\s+(?:WRONG|ASAN)[^\n]*\n.*\n[^\n]*stdout=([^\n]*)", text, re.M) if match: detail += "; stdout=" + match[1] rows.append(entry(f"{case_set}/{name}", sources[name], expected[name], detail.strip("; "), outcome, "root_cause", log, generator=script)) # These five named observations are retained, but their original program # files were not copied from the second reading's sealed directory. log = f"logs/{instance}/second_reading/runs_patched.log" for line in Path(log).read_text().splitlines(): fields = [part.strip() for part in line.split("|")] if len(fields) != 4 or fields[0] not in ("c4obs", "c4big", "c5obs", "p_dup", "p_dup2"): continue name, _, observed, expected = fields rows.append(entry(f"second_reading/{name}", "", expected, observed, "ASAN" if "SAN:" in observed else "WRONG", "root_cause", log, input_path=f"logs/{instance}/second_reading.log")) return rows def collect(instance): functions = dict(zip(INSTANCES, (kwargs_inputs, nvalhash_inputs, super_inputs, njs_inputs))) if instance not in functions: raise ValueError(f"No post-developer-patch inventory defined: {instance}") rows = functions[instance](instance) names = [row["case_id"] for row in rows] if len(names) != len(set(names)): raise ValueError(f"Duplicate case identifiers: {instance}") return rows def summary(rows): from collections import Counter counts = Counter(row["classification"] for row in rows) labels = { "root_cause": "root defect", "residual": "residual", "mixed_root_cause_and_residual": "mixed root defect and residual", "cross_cve:mruby.cve-2022-1427": "counted under mruby.cve-2022-1427", "other_observed_failure": "other observed failure, scope not assigned", } return "; ".join(f"{count} {labels[kind]}" for kind, count in counts.items()) or "not catalogued" def stage_column(parquet, card_path, stage): """Add one column while preserving every existing row and column value.""" import pandas as pd stage = Path(stage) if stage.exists(): raise ValueError(f"Stage already exists: {stage}") frame = pd.read_parquet(parquet) column = "post_dev_failing_inputs" if column in frame: raise ValueError(f"Column already exists: {column}") old_columns = list(frame.columns) inventory = {row.instance_id: collect(row.instance_id) for row in frame.itertuples() if not row.dev_patch_fixes_root_cause} frame[column] = [inventory.get(instance, []) for instance in frame.instance_id] (stage / "data").mkdir(parents=True) target = stage / "data/verified-00000-of-00001.parquet" frame.to_parquet(target, index=False) reread = pd.read_parquet(target) pd.testing.assert_frame_equal(pd.read_parquet(parquet), reread[old_columns]) for instance, rows in inventory.items(): stored = reread.loc[reread.instance_id == instance, column].iloc[0] assert list(stored) == rows, instance card = Path(card_path).read_text() lines, table = [], False for line in card.splitlines(): if line.startswith("| Instance | PoC before / after |"): table = True line += " Inputs failing after developer patch |" elif table and line.startswith("|---"): line += "---|" elif table and line.startswith("| "): instance = line.split("|")[1].strip() line += " " + summary(inventory.get(instance, [])) + " |" elif table and not line.startswith("|"): table = False lines.append(line) card = "\n".join(lines) + "\n" anchor = "| `dev_patch_fixes_root_cause` | Whether the developer patch restores the violated invariant rather than guarding the crash site |\n" assert card.count(anchor) == 1 card = card.replace(anchor, anchor + "| `post_dev_failing_inputs` | Named failing inputs after the developer patch, with program text or report reference, expected and observed behavior, outcome, scope classification and evidence paths |\n") anchor = "### Files\n" assert card.count(anchor) == 1 explanation = """### Inputs failing after the developer patch `post_dev_failing_inputs` is a list of records on the four rows whose `dev_patch_fixes_root_cause` is false. The other rows contain an empty list, meaning not catalogued by this column, not a claim that they have no residual defects. The column collects every WRONG or ASAN observation from the retained main case sets, the additional large-array or residual case sets, and the second-reading validation catalogs for these four instances. For mruby.cve-2022-1201, the value oracle covers programs for which CRuby returns a value; differences in controlled exception classes are not added as wrong-result claims. An exception-message difference classified OKc by the existing oracle is also excluded. The same program may occur in more than one case set; counts are named evidence entries, not unique program texts. This inventory covers recorded cases, not all possible inputs. Each entry contains `case_id`, `input` (program text), `input_path` (a retained program or report), `generator`, `source_status`, `expected`, `observed`, `outcome` (WRONG or ASAN), `classification`, and `evidence` (the developer-build log). `source_status` is `program` when the program text is present and `report_only` when only a named observation and report reference were retained. Five njs.cve-2022-31306 second-reading entries (c4obs, c4big, c5obs, p_dup and p_dup2) have no retained program file; their `input` is empty and their report gives the available input description. `classification` preserves the reviewed distinction between `root_cause`, `residual`, and `cross_cve:mruby.cve-2022-1427`. `mixed_root_cause_and_residual` marks an input requiring both independent repairs. `other_observed_failure` records an oracle mismatch without assigning a new scope verdict when the retained evidence does not establish that classification. In particular, mruby.cve-2022-1201's remaining crash inputs are counted under mruby.cve-2022-1427, consistent with its dismissed flag. No existing verdict or reference-patch decision is changed. `scripts/post_dev_failing_inputs.py` derives the column from the published case generators and logs without rerunning a build or case. """ card = card.replace(anchor, explanation + anchor) (stage / "README.md").write_text(card) (stage / "scripts").mkdir() for name in ("post_dev_failing_inputs.py", "hf_build_verified.py"): shutil.copy2(Path("scripts", name), stage / "scripts" / name) print(f"Preserved {len(frame)} rows and {len(old_columns)} existing columns") for instance, rows in inventory.items(): print(f"{instance}: {len(rows)} entries; {summary(rows)}") def main(): parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) parser.add_argument("instances", nargs="*", default=list(INSTANCES)) parser.add_argument("--parquet") parser.add_argument("--card") parser.add_argument("--stage") args = parser.parse_args() if any((args.parquet, args.card, args.stage)): if not all((args.parquet, args.card, args.stage)): parser.error("--parquet, --card and --stage must be supplied together") stage_column(args.parquet, args.card, args.stage) return print(json.dumps({instance: collect(instance) for instance in args.instances}, ensure_ascii=True, indent=2)) if __name__ == "__main__": main()