| |
| """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): |
| |
| 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 "<<E:" + e.class.to_s + ">>"; 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)) |
| |
| |
| 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() |
|
|
