| |
| """Run and score the public Perch method-pair benchmarks. |
| |
| Standard-library only. The command adapter is a persistent NDJSON process: it |
| receives one JSON object per line and returns one {"score": probability} per line. |
| Current scan mode uses question-pack.json exported from public Perch scan.yaml. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import hashlib |
| import json |
| import math |
| import os |
| from pathlib import Path |
| import shlex |
| import subprocess |
| import sys |
| import time |
| from urllib.error import HTTPError, URLError |
| from urllib.request import Request, urlopen |
|
|
|
|
| DATASET_URL = { |
| domain: f"https://huggingface.co/datasets/perchscan/{domain}-pairs-public/resolve/main/benchmark.jsonl" |
| for domain in ("bug", "security") |
| } |
| LEGACY_QUESTION = { |
| "bug": { |
| "type": "noul", |
| "instructions": "Does this method contain a concrete behavioral bug a caller can reach?", |
| "criteria": { |
| "true": "A reachable input makes the method violate its visible contract by returning a wrong result, leaving wrong state, or causing an unintended failure.", |
| "false": "No concrete reachable case is supported by the method and supplied context. A possible-looking pattern alone is not enough.", |
| }, |
| }, |
| "security": { |
| "type": "noul", |
| "instructions": "Does this method contain a concrete security vulnerability an attacker can reach?", |
| "criteria": { |
| "true": "A concrete path crosses a security boundary and can be exploited; name a reachable source, sensitive operation, and missing or incorrect protection.", |
| "false": "No concrete reachable case is supported by the method and supplied context. A possible-looking pattern alone is not enough.", |
| }, |
| }, |
| } |
|
|
|
|
| def load_pack(path: Path) -> dict: |
| pack = json.loads(path.read_text()) |
| body = {key: pack[key] for key in ("schema_version", "source", "source_sha256", "domains")} |
| digest = hashlib.sha256(json.dumps(body, separators=(",", ":"), ensure_ascii=False).encode()).hexdigest() |
| if (pack.get("schema_version") != 1 or pack.get("pack_sha256") != digest |
| or pack.get("protocol_id") != f"perch-scan-{digest[:12]}" |
| or pack.get("binary_protocol_id") != f"perch-scan-binary-{digest[:12]}"): |
| raise ValueError("Question pack checksum or protocol ID does not match its contents") |
| for domain in ("bug", "security"): |
| if not pack["domains"].get(domain): |
| raise ValueError(f"Question pack has no {domain} questions") |
| for question in pack["domains"][domain]: |
| if question["where"] != "**/*": |
| raise ValueError(f"Benchmark does not yet support path selector {question['where']}") |
| return pack |
|
|
|
|
| def scan_questions(pack: dict, domain: str, language: str) -> list[dict]: |
| if not language: |
| raise ValueError("Benchmark pair has no language for question selection") |
| normalized = {"csharp": "c_sharp"}.get(language, language) |
| return [q for q in pack["domains"][domain] |
| if q["language"] is None or normalized in ([q["language"]] if isinstance(q["language"], str) else q["language"])] |
|
|
|
|
| def detection_questions(questions: list[dict], domain: str) -> list[dict]: |
| issue_type = "defect" if domain == "bug" else "security" |
| return [q for q in questions if q["type"] == "noul" and q["issue"] and q["issue"]["type"] == issue_type] |
|
|
|
|
| def raised_score(question: dict, true_probability: object) -> float: |
| score = probability(true_probability) |
| return 1 - score if question["issue"].get("on") is False else score |
|
|
|
|
| def scan_result(question_scores: dict[str, float], questions: list[dict], domain: str, threshold: float) -> tuple[float, bool]: |
| relevant = detection_questions(questions, domain) |
| expected = {q["name"] for q in relevant} |
| if set(question_scores) != expected: |
| raise ValueError(f"Question scores differ from selected scan pack: {expected ^ set(question_scores)}") |
| score = max(question_scores.values(), default=0.0) |
| |
| |
| alert = any(question_scores[q["name"]] > max(threshold, (q.get("min") or 0) / 100) |
| for q in relevant) |
| return score, alert |
|
|
|
|
| def dataset_bytes(domain: str, path: Path | None) -> bytes: |
| if path is not None: |
| return (path / "benchmark.jsonl" if path.is_dir() else path).read_bytes() |
| with urlopen(DATASET_URL[domain], timeout=120) as response: |
| return response.read() |
|
|
|
|
| def load_pairs(domain: str, path: Path | None) -> tuple[list[dict], str]: |
| raw = dataset_bytes(domain, path) |
| pairs = [json.loads(line) for line in raw.splitlines() if line] |
| if not pairs: |
| raise ValueError("Benchmark contains no pairs") |
| ids = set() |
| for pair in pairs: |
| if pair["domain"] != domain or pair["pair_id"] in ids: |
| raise ValueError("Wrong domain or duplicate pair ID in benchmark") |
| ids.add(pair["pair_id"]) |
| for role in ("before", "after"): |
| if pair[role]["labels"][domain] not in (0, 1): |
| raise ValueError(f"Invalid {domain} label for {pair['pair_id']}:{role}") |
| return pairs, hashlib.sha256(raw).hexdigest() |
|
|
|
|
| def probability(value: object) -> float: |
| if isinstance(value, bool): |
| raise ValueError("Score must be a number, not a boolean") |
| score = float(value) |
| if not math.isfinite(score) or not 0 <= score <= 1: |
| raise ValueError(f"Score must be a finite probability in [0, 1]: {value!r}") |
| return score |
|
|
|
|
| def prediction_scores(path: Path, pairs: list[dict], domain: str, |
| require_complete: bool) -> dict[tuple[str, str], dict]: |
| expected = {(pair["pair_id"], role) for pair in pairs for role in ("before", "after")} |
| scores = {} |
| if not path.exists(): |
| if require_complete: |
| raise FileNotFoundError(path) |
| return scores |
| for line in path.read_text().splitlines(): |
| if not line: |
| continue |
| row = json.loads(line) |
| key = (row["pair_id"], row["role"]) |
| if key not in expected or key in scores or row.get("domain", domain) != domain: |
| raise ValueError(f"Unexpected or duplicate prediction: {key}") |
| row["score"] = probability(row["score"]) |
| scores[key] = row |
| if require_complete and scores.keys() != expected: |
| missing = expected - scores.keys() |
| raise ValueError(f"Predictions are missing {len(missing)} method sides") |
| return scores |
|
|
|
|
| def average_precision(items: list[tuple[int, float]]) -> float: |
| positives = sum(label for label, _ in items) |
| if not positives: |
| return 0.0 |
| ordered = sorted(items, key=lambda item: item[1], reverse=True) |
| found = total = 0 |
| i = 0 |
| while i < len(ordered): |
| j = i + 1 |
| while j < len(ordered) and ordered[j][1] == ordered[i][1]: |
| j += 1 |
| positives_at_score = sum(label for label, _ in ordered[i:j]) |
| found += positives_at_score |
| total += found / j * positives_at_score |
| i = j |
| return total / positives |
|
|
|
|
| def report(pairs: list[dict], scores: dict[tuple[str, str], dict], domain: str, |
| digest: str, model_revision: str, protocol_id: str, |
| threshold: float, pack: dict | None = None) -> dict: |
| items = [] |
| for pair in pairs: |
| for role in ("before", "after"): |
| row = scores[pair["pair_id"], role] |
| if pack and protocol_id in (pack["protocol_id"], pack["binary_protocol_id"]): |
| if row.get("pack_sha256") != pack["pack_sha256"]: |
| raise ValueError("Prediction was made with a different question pack") |
| questions = scan_questions(pack, domain, pair["language"]) |
| score, alert = scan_result(row.get("question_scores", {}), questions, domain, threshold) |
| if abs(score - row["score"]) > 1e-9: |
| raise ValueError("Prediction's aggregate score does not match its question scores") |
| else: |
| score, alert = row["score"], row["score"] >= threshold |
| items.append((pair[role]["labels"][domain], score, alert)) |
| tp = sum(label == 1 and alert for label, _, alert in items) |
| fp = sum(label == 0 and alert for label, _, alert in items) |
| fn = sum(label == 1 and not alert for label, _, alert in items) |
| tn = sum(label == 0 and not alert for label, _, alert in items) |
| eligible = correct = ties = 0 |
| for pair in pairs: |
| if pair["before"]["labels"][domain] == 1 and pair["after"]["labels"][domain] == 0: |
| eligible += 1 |
| before, after = scores[pair["pair_id"], "before"]["score"], scores[pair["pair_id"], "after"]["score"] |
| correct += before > after |
| ties += before == after |
| precision = tp / (tp + fp) if tp + fp else 0.0 |
| recall = tp / (tp + fn) if tp + fn else 0.0 |
| return { |
| "domain": domain, |
| "model_revision": model_revision, |
| "protocol_id": protocol_id, |
| "threshold": threshold, |
| "alert_rule": "any issue score > max(run threshold, question min)" if pack and protocol_id in (pack["protocol_id"], pack["binary_protocol_id"]) else "score >= threshold", |
| "question_pack_sha256": pack["pack_sha256"] if pack and protocol_id in (pack["protocol_id"], pack["binary_protocol_id"]) else None, |
| "benchmark_sha256": digest, |
| "benchmark_pairs": len(pairs), |
| "benchmark_methods": len(items), |
| "average_precision": average_precision([(label, score) for label, score, _ in items]), |
| "precision": precision, |
| "recall": recall, |
| "f1": 2 * tp / (2 * tp + fp + fn) if 2 * tp + fp + fn else 0.0, |
| "false_positives_per_true_positive": fp / tp if tp else None, |
| "confusion": {"tp": tp, "fp": fp, "tn": tn, "fn": fn}, |
| "vulnerable_or_buggy_before_above_fixed_after": { |
| "correct": correct, "ties": ties, "eligible": eligible, |
| }, |
| } |
|
|
|
|
| def jev_answers(state: dict, questions: dict, model: str, api_url: str) -> dict: |
| key = os.getenv("TYPESAFE_API_KEY") or os.getenv("PERCH_API_KEY") |
| if not key: |
| raise RuntimeError("Set TYPESAFE_API_KEY or PERCH_API_KEY to run Jev") |
| payload = json.dumps({"model": model, "state": state, "questions": questions}).encode() |
| for attempt in range(4): |
| request = Request(api_url, data=payload, method="POST", headers={ |
| "Authorization": f"Bearer {key}", "Content-Type": "application/json", |
| }) |
| try: |
| with urlopen(request, timeout=120) as response: |
| answer = json.load(response) |
| return answer["answers"] |
| except HTTPError as exc: |
| if exc.code not in (429, 500, 502, 503, 504) or attempt == 3: |
| raise RuntimeError(f"Jev request failed with HTTP {exc.code}") from None |
| delay = exc.headers.get("Retry-After") |
| time.sleep(float(delay) if delay and delay.isdigit() else 2 ** attempt) |
| except URLError: |
| if attempt == 3: |
| raise RuntimeError("Jev request failed after four network attempts") from None |
| time.sleep(2 ** attempt) |
| raise AssertionError("unreachable") |
|
|
|
|
| def command_score(command: subprocess.Popen, request: dict) -> float: |
| assert command.stdin and command.stdout |
| command.stdin.write(json.dumps(request, ensure_ascii=False) + "\n") |
| command.stdin.flush() |
| line = command.stdout.readline() |
| if not line: |
| raise RuntimeError("Model adapter stopped before returning a score") |
| return probability(json.loads(line)["score"]) |
|
|
|
|
| def run(args: argparse.Namespace) -> None: |
| pairs, digest = load_pairs(args.domain, args.dataset) |
| pack = load_pack(args.question_pack) |
| scan_protocols = (pack["protocol_id"], pack["binary_protocol_id"]) |
| mode = args.mode or ("broad" if args.protocol_id == "perch-broad-v1" else |
| "native" if args.protocol_id and args.protocol_id not in scan_protocols else "scan") |
| if args.scorer == "jev": |
| if mode == "native": |
| raise ValueError("Jev requires scan or broad question mode") |
| revision = args.model_revision or "jev-1.13.0" |
| protocol = pack["protocol_id"] if mode == "scan" else "perch-broad-v1" |
| if args.protocol_id and args.protocol_id != protocol: |
| raise ValueError("Jev protocol ID does not match the selected question mode") |
| else: |
| if not args.command or not args.model_revision: |
| raise ValueError("Command scorer requires --command and --model-revision") |
| revision = args.model_revision |
| protocol = args.protocol_id or (pack["binary_protocol_id"] if mode == "scan" else "perch-broad-v1") |
| if mode == "scan" and protocol != pack["binary_protocol_id"]: |
| raise ValueError("Scan protocol ID must match the question pack") |
| if mode == "native" and not args.protocol_id: |
| raise ValueError("Native scorer requires its own --protocol-id") |
| if args.predictions.exists(): |
| for line in args.predictions.read_text().splitlines(): |
| if line: |
| row = json.loads(line) |
| if row.get("model_revision") != revision or row.get("protocol_id") != protocol: |
| raise ValueError("Existing prediction file uses another model or protocol") |
| if mode == "scan" and row.get("pack_sha256") != pack["pack_sha256"]: |
| raise ValueError("Existing predictions use another scan question pack") |
| existing = prediction_scores(args.predictions, pairs, args.domain, False) |
| pending = [(pair, role) for pair in pairs for role in ("before", "after") |
| if (pair["pair_id"], role) not in existing] |
| if args.limit: |
| pending = pending[:args.limit] |
| command = None |
| if args.scorer == "command" and pending: |
| command = subprocess.Popen(shlex.split(args.command), stdin=subprocess.PIPE, |
| stdout=subprocess.PIPE, text=True, bufsize=1) |
| args.predictions.parent.mkdir(parents=True, exist_ok=True) |
| try: |
| with args.predictions.open("a") as output: |
| for index, (pair, role) in enumerate(pending, 1): |
| state = pair[role]["state"] |
| if mode == "scan": |
| selected = scan_questions(pack, args.domain, pair["language"]) |
| if args.scorer == "jev": |
| answers = jev_answers(state, {q["name"]: q["question"] for q in selected}, revision, args.api_url) |
| question_scores = {q["name"]: raised_score(q, answers[q["name"]]["noul"]) |
| for q in detection_questions(selected, args.domain)} |
| else: |
| question_scores = {} |
| for q in detection_questions(selected, args.domain): |
| request = {"domain": args.domain, "pair_id": pair["pair_id"], "role": role, |
| "language": pair["language"], "source": pair[role]["source"], |
| "state": state, "question": q["question"], "question_name": q["name"]} |
| question_scores[q["name"]] = raised_score(q, command_score(command, request)) |
| score, alert = scan_result(question_scores, selected, args.domain, args.threshold) |
| else: |
| question = LEGACY_QUESTION[args.domain] |
| if args.scorer == "jev": |
| name = "bug_any" if args.domain == "bug" else "security_any" |
| score = probability(jev_answers(state, {name: question}, revision, args.api_url)[name]["noul"]) |
| else: |
| request = {"domain": args.domain, "pair_id": pair["pair_id"], "role": role, |
| "language": pair.get("language"), "source": pair[role]["source"], |
| "state": state, "question": question} |
| score = command_score(command, request) |
| result = {"domain": args.domain, "pair_id": pair["pair_id"], "role": role, |
| "score": score, "model_revision": revision, "protocol_id": protocol} |
| if mode == "scan": |
| result.update(question_scores=question_scores, alert=alert, |
| threshold=args.threshold, |
| alert_rule="any issue score > max(run threshold, question min)", |
| pack_sha256=pack["pack_sha256"]) |
| output.write(json.dumps(result) + "\n") |
| output.flush() |
| if index % 100 == 0 or index == len(pending): |
| print(f"Scored {len(existing) + index}/{2 * len(pairs)} method sides", file=sys.stderr) |
| finally: |
| if command: |
| command.stdin.close() |
| try: |
| command.wait(timeout=30) |
| except subprocess.TimeoutExpired: |
| command.terminate() |
| command.wait(timeout=5) |
| finally: |
| command.stdout.close() |
| scores = prediction_scores(args.predictions, pairs, args.domain, False) |
| if len(scores) != 2 * len(pairs): |
| print(f"Incomplete: {len(scores)}/{2 * len(pairs)} sides; rerun to resume", file=sys.stderr) |
| return |
| result = report(pairs, scores, args.domain, digest, revision, protocol, args.threshold, pack) |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") |
| print(json.dumps(result, sort_keys=True)) |
|
|
|
|
| def score_saved(args: argparse.Namespace) -> None: |
| pairs, digest = load_pairs(args.domain, args.dataset) |
| scores = prediction_scores(args.predictions, pairs, args.domain, True) |
| first = json.loads(next(line for line in args.predictions.read_text().splitlines() if line)) |
| pack = load_pack(args.question_pack) |
| revision = args.model_revision or first.get("model_revision", "unspecified") |
| protocol = args.protocol_id or first.get("protocol_id", "unspecified") |
| if any((row.get("model_revision", revision) != revision or row.get("protocol_id", protocol) != protocol) |
| for row in scores.values()): |
| raise ValueError("Predictions mix model revisions or protocols") |
| result = report(pairs, scores, args.domain, digest, |
| revision, protocol, args.threshold, pack) |
| args.report.parent.mkdir(parents=True, exist_ok=True) |
| args.report.write_text(json.dumps(result, indent=2, sort_keys=True) + "\n") |
| print(json.dumps(result, sort_keys=True)) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__) |
| sub = parser.add_subparsers(dest="action", required=True) |
| for name in ("run", "score"): |
| command = sub.add_parser(name) |
| command.add_argument("--domain", choices=("bug", "security"), required=True) |
| command.add_argument("--dataset", type=Path, help="Local benchmark.jsonl; default downloads public pairs") |
| command.add_argument("--predictions", type=Path, required=True) |
| command.add_argument("--report", type=Path, required=True) |
| command.add_argument("--threshold", type=float, default=0.5) |
| command.add_argument("--question-pack", type=Path, default=Path(__file__).with_name("question-pack.json")) |
| command.add_argument("--model-revision") |
| command.add_argument("--protocol-id") |
| if name == "run": |
| command.add_argument("--mode", choices=("scan", "broad", "native"), |
| help="Default: scan; old broad/native protocol IDs infer their historical mode") |
| command.add_argument("--scorer", choices=("jev", "command"), required=True) |
| command.add_argument("--command", help="Persistent NDJSON scorer command") |
| command.add_argument("--api-url", default="https://api.typesafe.ai/v1/systemone") |
| command.add_argument("--limit", type=int, default=0, help="Score at most N new sides, then resume later") |
| args = parser.parse_args() |
| if not 0 <= args.threshold <= 1: |
| parser.error("--threshold must be in [0, 1]") |
| if args.action == "run": |
| if args.limit < 0: |
| parser.error("--limit must be nonnegative") |
| run(args) |
| else: |
| score_saved(args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
