inpguard 0.1.0__tar.gz

inpguard-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Onur Cetinkaya
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inpguard-0.1.0/PKG-INFO

@@ -0,0 +1,196 @@
+Metadata-Version: 2.4
+Name: inpguard
+Version: 0.1.0
+Summary: Defensive linting for EPANET .inp water-network model files
+Author: Onur Çetinkaya
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/onurcetinkaya-ce/inpguard
+Project-URL: Source, https://github.com/onurcetinkaya-ce/inpguard
+Project-URL: Issues, https://github.com/onurcetinkaya-ce/inpguard/issues
+Project-URL: Security, https://github.com/onurcetinkaya-ce/inpguard/security/policy
+Keywords: epanet,water,scada,ics,security,lint
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Hydrology
+Classifier: Topic :: Security
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# inpguard
+
+Defensive linting for EPANET `.inp` water-network model files.
+
+`inpguard` is a dependency-free Python library and CLI that inspects an EPANET
+input file **before** it reaches a hydraulic solver. It reports malformed
+structure, dangling cross-references, numeric values that overflow single
+precision, embedded control bytes that desynchronise C string handling, and
+other input hazards.
+
+It is a *linter*, not a fuzzer and not an exploit. It never executes the file.
+
+## Why this exists
+
+Water utilities exchange `.inp` files constantly — with consultants, with
+contractors, between distribution-system teams, and increasingly through
+automated pipelines. The format is plain text, section-delimited, and widely
+reimplemented in memory-unsafe languages. Most parsers assume the file is
+benign because historically it always was.
+
+That assumption is aging badly. Water systems are now an explicit target class,
+and the people who steward these models — civil and environmental engineers —
+are trained in hydraulics, not in adversarial input handling. The realistic
+failure mode isn't a nation-state exploit; it's a subtle malformed file that
+silently corrupts a hydraulic model, or a parser that crashes and takes a
+modelling session with it.
+
+`inpguard` gives the engineering side a two-second sanity check that speaks in
+byte offsets and line numbers rather than stack traces.
+
+## Install
+
+```bash
+pip install inpguard
+```
+
+For development, install from a clone:
+
+```bash
+git clone https://github.com/onurcetinkaya-ce/inpguard.git
+cd inpguard
+pip install -e .
+```
+
+No runtime dependencies. Python 3.9+.
+
+## Use
+
+```bash
+inpguard check network.inp
+inpguard check models/*.inp --json
+```
+
+```
+network.inp: 412 bytes, 34 lines, 6 sections
+  ERROR INP032      line 14: link endpoint 'J9' is not a defined node
+  WARN  INP022      line 12: value 1e39 in column 4 exceeds float32 range and will overflow to inf on a single-precision parser
+  1 error(s), 1 warning(s)
+```
+
+Exit codes: `0` clean, `1` error findings, `2` I/O or usage failure.
+
+As a library:
+
+```python
+from inpguard import lint_text
+
+report = lint_text(open("network.inp").read())
+for finding in report.sorted_findings():
+    print(finding)
+print(report.ok())
+```
+
+## Rule reference
+
+| Code | Severity | Meaning |
+|------|----------|---------|
+| INP001 | ERROR | File exceeds the 64 MiB ceiling (checked before parsing) |
+| INP002 | ERROR | Physical line exceeds 8 KiB |
+| INP003 | ERROR | Forbidden control byte (NUL, vertical tab, form feed, etc.) |
+| INP004 | ERROR | Line is not valid UTF-8 |
+| INP005 | ERROR | Empty or malformed section header |
+| INP006 | ERROR | Data before the first section header |
+| INP007 | ERROR | Section exceeds its row ceiling |
+| INP008 | ERROR | Too many sections |
+| INP010 | WARN | Unknown section name |
+| INP011 | WARN | Section appears more than once |
+| INP012 | WARN | Token exceeds 256 bytes (fixed-buffer hazard) |
+| INP013 | WARN | No `[END]` section |
+| INP014 | WARN | Cross-reference limit reached; reference findings are a lower bound |
+| INP020 | ERROR | Duplicate node/link identifier |
+| INP021 | ERROR | Non-finite numeric literal (`nan`, `inf`) |
+| INP022 | WARN | Value overflows IEEE-754 single precision |
+| INP023 | WARN | Numeric literal uses digit separators (`1_000`) |
+| INP030 | WARN | Reference to an undefined pattern |
+| INP031 | WARN | Reference to an undefined curve |
+| INP032 | ERROR | Link endpoint is not a defined node |
+
+## Design notes
+
+**Line splitting is deliberately narrow.** The file is split on LF and CRLF
+only. It does *not* split on `\v`, `\f`, `\x1c`–`\x1e`, `\u2028`, or `\u0085`,
+which `str.splitlines()` does honour. If the linter and the target parser
+disagree about where a record ends, an attacker can craft a file that reads one
+way to the linter and another way to the parser. The corpus contains an
+explicit `unicode_line_sep` case asserting this.
+
+**The UTF-8 BOM is stripped, not rejected.** Windows and spreadsheet tooling
+emits BOMs routinely. A linter that rejects every such file gets switched off
+in production within a week, and a linter that is switched off protects nobody.
+
+**Limits are checked before the work they bound.** An oversized file is
+reported and abandoned without walking its body.
+
+**Findings carry byte offsets.** A finding you cannot locate is a finding
+nobody acts on.
+
+## Corpus
+
+`inpguard/corpus.py` ships eleven cases: a clean model, a truncated transfer, a
+Windows CRLF+BOM export, and adversarial inputs for dangling references,
+duplicate identifiers, float32 overflow, NaN/Inf literals, embedded NULs,
+Unicode line-separator smuggling, unknown sections, and oversized tokens.
+
+These are not exploits. They are malformed or hostile *inputs* that a parser
+should reject or survive. The corpus exists so that the check has something to
+fail against, and so that a parser author can reproduce a report.
+
+## Validation
+
+Validated against 17 `.inp` files it did not author, ~37,400 lines in total,
+from two independent publishing bodies.
+
+**Nine benchmark distribution networks** — C-Town, d-town, Modena, Jilin, Zhi
+Jiang, KL, ky1, ky8, RuralNetwork — sourced from the DiTEC-WDN corpus
+(Truong et al., *Scientific Data* 2025): **zero errors, zero warnings**. Sizes
+range from 234 to 7,731 lines.
+
+**Eight files from the USEPA/WNTR reference suite**, including the 847 KB
+`Net6_plus.inp` benchmark: five lint completely clean; the three that do not are
+malformed on purpose and produce exactly one finding each, the one they were
+built to contain.
+
+The first run against those files produced 66 false positives and exposed three
+real bugs (inline `;` comments, `[PUMPS]`/`[VALVES]` column indexing, repeated
+sections). Each is fixed and carries a regression test. Adversarial self-testing
+separately found and fixed a resource-amplification bug in this tool.
+
+See `VALIDATION.md` for the full tables, method, and a candid statement of what
+a clean result does and does not demonstrate.
+
+## Status
+
+`0.1.0` — alpha. The rule set is deliberately conservative: it flags only what
+is unambiguous in the format specification. Rules that would warn on a
+legitimate file exported from a common modelling tool are bugs, not features.
+
+Output and memory are bounded: findings are capped per rule code (with the number
+of elided occurrences reported, never silently dropped), and cross-reference
+checking is capped with an explicit `INP014` rather than growing without limit.
+A 3.2 MB adversarial file that once produced 400,002 findings and 287.9 MB peak
+RSS now produces 106 findings and 38.7 MB. See `VALIDATION.md`.
+
+## License
+
+MIT.

inpguard-0.1.0/README.md

@@ -0,0 +1,166 @@
+# inpguard
+
+Defensive linting for EPANET `.inp` water-network model files.
+
+`inpguard` is a dependency-free Python library and CLI that inspects an EPANET
+input file **before** it reaches a hydraulic solver. It reports malformed
+structure, dangling cross-references, numeric values that overflow single
+precision, embedded control bytes that desynchronise C string handling, and
+other input hazards.
+
+It is a *linter*, not a fuzzer and not an exploit. It never executes the file.
+
+## Why this exists
+
+Water utilities exchange `.inp` files constantly — with consultants, with
+contractors, between distribution-system teams, and increasingly through
+automated pipelines. The format is plain text, section-delimited, and widely
+reimplemented in memory-unsafe languages. Most parsers assume the file is
+benign because historically it always was.
+
+That assumption is aging badly. Water systems are now an explicit target class,
+and the people who steward these models — civil and environmental engineers —
+are trained in hydraulics, not in adversarial input handling. The realistic
+failure mode isn't a nation-state exploit; it's a subtle malformed file that
+silently corrupts a hydraulic model, or a parser that crashes and takes a
+modelling session with it.
+
+`inpguard` gives the engineering side a two-second sanity check that speaks in
+byte offsets and line numbers rather than stack traces.
+
+## Install
+
+```bash
+pip install inpguard
+```
+
+For development, install from a clone:
+
+```bash
+git clone https://github.com/onurcetinkaya-ce/inpguard.git
+cd inpguard
+pip install -e .
+```
+
+No runtime dependencies. Python 3.9+.
+
+## Use
+
+```bash
+inpguard check network.inp
+inpguard check models/*.inp --json
+```
+
+```
+network.inp: 412 bytes, 34 lines, 6 sections
+  ERROR INP032      line 14: link endpoint 'J9' is not a defined node
+  WARN  INP022      line 12: value 1e39 in column 4 exceeds float32 range and will overflow to inf on a single-precision parser
+  1 error(s), 1 warning(s)
+```
+
+Exit codes: `0` clean, `1` error findings, `2` I/O or usage failure.
+
+As a library:
+
+```python
+from inpguard import lint_text
+
+report = lint_text(open("network.inp").read())
+for finding in report.sorted_findings():
+    print(finding)
+print(report.ok())
+```
+
+## Rule reference
+
+| Code | Severity | Meaning |
+|------|----------|---------|
+| INP001 | ERROR | File exceeds the 64 MiB ceiling (checked before parsing) |
+| INP002 | ERROR | Physical line exceeds 8 KiB |
+| INP003 | ERROR | Forbidden control byte (NUL, vertical tab, form feed, etc.) |
+| INP004 | ERROR | Line is not valid UTF-8 |
+| INP005 | ERROR | Empty or malformed section header |
+| INP006 | ERROR | Data before the first section header |
+| INP007 | ERROR | Section exceeds its row ceiling |
+| INP008 | ERROR | Too many sections |
+| INP010 | WARN | Unknown section name |
+| INP011 | WARN | Section appears more than once |
+| INP012 | WARN | Token exceeds 256 bytes (fixed-buffer hazard) |
+| INP013 | WARN | No `[END]` section |
+| INP014 | WARN | Cross-reference limit reached; reference findings are a lower bound |
+| INP020 | ERROR | Duplicate node/link identifier |
+| INP021 | ERROR | Non-finite numeric literal (`nan`, `inf`) |
+| INP022 | WARN | Value overflows IEEE-754 single precision |
+| INP023 | WARN | Numeric literal uses digit separators (`1_000`) |
+| INP030 | WARN | Reference to an undefined pattern |
+| INP031 | WARN | Reference to an undefined curve |
+| INP032 | ERROR | Link endpoint is not a defined node |
+
+## Design notes
+
+**Line splitting is deliberately narrow.** The file is split on LF and CRLF
+only. It does *not* split on `\v`, `\f`, `\x1c`–`\x1e`, `\u2028`, or `\u0085`,
+which `str.splitlines()` does honour. If the linter and the target parser
+disagree about where a record ends, an attacker can craft a file that reads one
+way to the linter and another way to the parser. The corpus contains an
+explicit `unicode_line_sep` case asserting this.
+
+**The UTF-8 BOM is stripped, not rejected.** Windows and spreadsheet tooling
+emits BOMs routinely. A linter that rejects every such file gets switched off
+in production within a week, and a linter that is switched off protects nobody.
+
+**Limits are checked before the work they bound.** An oversized file is
+reported and abandoned without walking its body.
+
+**Findings carry byte offsets.** A finding you cannot locate is a finding
+nobody acts on.
+
+## Corpus
+
+`inpguard/corpus.py` ships eleven cases: a clean model, a truncated transfer, a
+Windows CRLF+BOM export, and adversarial inputs for dangling references,
+duplicate identifiers, float32 overflow, NaN/Inf literals, embedded NULs,
+Unicode line-separator smuggling, unknown sections, and oversized tokens.
+
+These are not exploits. They are malformed or hostile *inputs* that a parser
+should reject or survive. The corpus exists so that the check has something to
+fail against, and so that a parser author can reproduce a report.
+
+## Validation
+
+Validated against 17 `.inp` files it did not author, ~37,400 lines in total,
+from two independent publishing bodies.
+
+**Nine benchmark distribution networks** — C-Town, d-town, Modena, Jilin, Zhi
+Jiang, KL, ky1, ky8, RuralNetwork — sourced from the DiTEC-WDN corpus
+(Truong et al., *Scientific Data* 2025): **zero errors, zero warnings**. Sizes
+range from 234 to 7,731 lines.
+
+**Eight files from the USEPA/WNTR reference suite**, including the 847 KB
+`Net6_plus.inp` benchmark: five lint completely clean; the three that do not are
+malformed on purpose and produce exactly one finding each, the one they were
+built to contain.
+
+The first run against those files produced 66 false positives and exposed three
+real bugs (inline `;` comments, `[PUMPS]`/`[VALVES]` column indexing, repeated
+sections). Each is fixed and carries a regression test. Adversarial self-testing
+separately found and fixed a resource-amplification bug in this tool.
+
+See `VALIDATION.md` for the full tables, method, and a candid statement of what
+a clean result does and does not demonstrate.
+
+## Status
+
+`0.1.0` — alpha. The rule set is deliberately conservative: it flags only what
+is unambiguous in the format specification. Rules that would warn on a
+legitimate file exported from a common modelling tool are bugs, not features.
+
+Output and memory are bounded: findings are capped per rule code (with the number
+of elided occurrences reported, never silently dropped), and cross-reference
+checking is capped with an explicit `INP014` rather than growing without limit.
+A 3.2 MB adversarial file that once produced 400,002 findings and 287.9 MB peak
+RSS now produces 106 findings and 38.7 MB. See `VALIDATION.md`.
+
+## License
+
+MIT.

inpguard-0.1.0/inpguard/__init__.py

@@ -0,0 +1,30 @@
+"""inpguard — defensive linting for EPANET .inp water-network model files.
+
+Water utilities exchange .inp files constantly: between utilities, with
+consultants, with contractors, and increasingly through automated pipelines.
+Most parsers handle that input with the assumption that it is benign. This
+package makes the malicious and the merely-malformed cases visible *before* the
+file reaches a parser.
+
+    >>> from inpguard import lint_text
+    >>> report = lint_text(open("network.inp").read())
+    >>> print(report.ok())
+"""
+
+from .lint import ERROR, INFO, WARN, Finding, Report, lint_bytes, lint_text
+from .spec import KNOWN_SECTIONS, LIMITS
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "ERROR",
+    "INFO",
+    "WARN",
+    "Finding",
+    "Report",
+    "KNOWN_SECTIONS",
+    "LIMITS",
+    "lint_bytes",
+    "lint_text",
+    "__version__",
+]

inpguard-0.1.0/inpguard/cli.py

@@ -0,0 +1,113 @@
+"""CLI entry point: `inpguard check network.inp`.
+
+Exit codes are the contract for CI:
+  0  clean (no ERROR findings)
+  1  at least one ERROR finding
+  2  usage or I/O failure
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__, lint_bytes
+from .lint import Report
+
+
+def _render_text(report: Report, path: str) -> str:
+    lines = [f"{path}: {report.bytes_read} bytes, {report.lines_read} lines, "
+             f"{len(report.sections)} sections"]
+    findings = report.sorted_findings()
+    if not findings:
+        lines.append("  clean")
+        return "\n".join(lines)
+    for finding in findings:
+        lines.append(f"  {finding}")
+    for code, count in sorted(report.suppressed.items()):
+        lines.append(
+            f"  NOTE  {code:12s} {count} further finding(s) of this code suppressed"
+        )
+    errors = len(report.errors)
+    warns = len(report.warnings)
+    lines.append(f"  {errors} error(s), {warns} warning(s)")
+    return "\n".join(lines)
+
+
+def _render_json(report: Report, path: str) -> str:
+    payload = {
+        "path": path,
+        "bytes": report.bytes_read,
+        "lines": report.lines_read,
+        "ok": report.ok(),
+        "sections": [s.name for s in report.sections],
+        "findings": [
+            {
+                "severity": f.severity,
+                "code": f.code,
+                "message": f.message,
+                "offset": f.offset,
+                "line": f.line,
+                "section": f.section,
+            }
+            for f in report.sorted_findings()
+        ],
+        "suppressed": dict(sorted(report.suppressed.items())),
+    }
+    return json.dumps(payload, indent=2)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="inpguard",
+        description="Defensive linting for EPANET .inp water-network model files.",
+    )
+    parser.add_argument("--version", action="version", version=f"inpguard {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    check = sub.add_parser("check", help="lint one or more .inp files")
+    check.add_argument("files", nargs="+", type=Path)
+    check.add_argument("--json", action="store_true", help="machine-readable output")
+    check.add_argument(
+        "--allow-references",
+        action="store_true",
+        help="skip cross-section reference checks (partial files)",
+    )
+    check.add_argument(
+        "--max-float",
+        type=float,
+        default=None,
+        help="override the single-precision ceiling",
+    )
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+
+    worst = 0
+    for path in args.files:
+        try:
+            raw = path.read_bytes()
+        except OSError as exc:
+            print(f"{path}: cannot read: {exc}", file=sys.stderr)
+            worst = max(worst, 2)
+            continue
+
+        report = lint_bytes(
+            raw,
+            strict_references=not args.allow_references,
+            float_ceiling=args.max_float,
+        )
+        out = _render_json(report, str(path)) if args.json else _render_text(report, str(path))
+        print(out)
+        if not report.ok():
+            worst = max(worst, 1)
+
+    return worst
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

inpguard-0.1.0/inpguard/corpus.py

@@ -0,0 +1,155 @@
+"""CORPUS — a regression corpus of hand-built EPANET .inp inputs.
+
+Every case here is a file a real water utility could plausibly receive: a clean
+export from a modelling tool, a truncated transfer, a legacy file with CRLF
+endings, and a set of adversarial files exercising specific parser assumptions.
+
+The adversarial cases are NOT exploits. They are malformed or hostile *inputs*
+that a parser should reject or survive. Publishing them is the point: the
+defender needs a test suite, and the vendor needs a reproducible report.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+CLEAN = """\
+[TITLE]
+METU campus distribution model - synthetic
+
+[JUNCTIONS]
+;ID       Elev    Dem     Pattern
+ J1       10.0    5.0     P1
+ J2       12.5    3.5     P1
+
+[RESERVOIRS]
+;ID       Head
+ R1       55.0
+
+[PIPES]
+;ID   Node1  Node2  Length  Diam  Rough  Mloss  Status
+ P1    R1     J1     120.0   300   130    0       Open
+ P2    J1     J2     240.0   200   130    0       Open
+
+[PATTERNS]
+;ID   Factor
+ P1   1.0
+ P1   1.2
+
+[OPTIONS]
+ Units LPS
+ Headloss H-W
+
+[END]
+"""
+
+# Truncated download / interrupted transfer: valid prefix, no terminator.
+TRUNCATED = CLEAN.split("[OPTIONS]")[0]
+
+# Legacy export with CRLF and a BOM.
+CRLF_BOM = "\ufeff" + CLEAN.replace("\n", "\r\n")
+
+# Dangling reference: pipe names a node that does not exist.
+DANGLING_NODE = """\
+[JUNCTIONS]
+ J1 10.0 5.0
+
+[RESERVOIRS]
+ R1 55.0
+
+[PIPES]
+ P1 R1 J9 120.0 300 130 0 Open
+
+[END]
+"""
+
+# Duplicate identifiers: depends on whether the parser overwrites or appends.
+DUPLICATE_ID = """\
+[JUNCTIONS]
+ J1 10.0 5.0
+ J1 12.0 4.0
+
+[END]
+"""
+
+# Numeric bombs: values that overflow single precision.
+NUMERIC_BOMB = """\
+[JUNCTIONS]
+ J1 10.0 5.0
+
+[PIPES]
+ P1 J1 J1 1e39 300 130 0 Open
+
+[END]
+"""
+
+# NaN/Inf literals: strtod accepts these; many downstream models do not.
+NONFINITE = """\
+[JUNCTIONS]
+ J1 10.0 nan
+ J2 inf 5.0
+
+[END]
+"""
+
+# Embedded NUL: truncates C string handling, classic parser desync.
+EMBEDDED_NUL = "[JUNCTIONS]\n J1\x0010.0 5.0\n\n[END]\n"
+
+# Line-separator smuggling: the linter must NOT split these as newlines,
+# otherwise an attacker can make the linter and the parser disagree.
+UNICODE_LINE_SEP = "[JUNCTIONS]\n J1 10.0 5.0\u2028 J2 99.0 99.0\n\n[END]\n"
+
+# Unknown section: an extension the parser may or may not understand.
+UNKNOWN_SECTION = """\
+[JUNCTIONS]
+ J1 10.0 5.0
+
+[MYSTERY_EXTENSION]
+ whatever 1 2 3
+
+[END]
+"""
+
+# Long token: fixed-buffer parsers may truncate or overflow.
+LONG_TOKEN = "[JUNCTIONS]\n " + ("A" * 5000) + " 10.0 5.0\n\n[END]\n"
+
+
+@dataclass(frozen=True)
+class Case:
+    name: str
+    data: str
+    expect_codes: frozenset[str]
+    expect_ok: bool
+    note: str
+
+
+CASES: tuple[Case, ...] = (
+    Case("clean", CLEAN, frozenset(), True, "well-formed file; must lint clean"),
+    Case("truncated", TRUNCATED, frozenset({"INP013"}), True,
+         "interrupted transfer; no [END]"),
+    Case("crlf_bom", CRLF_BOM, frozenset(), True,
+         "Windows export with BOM; must not false-positive"),
+    Case("dangling_node", DANGLING_NODE, frozenset({"INP032"}), False,
+         "referential integrity failure"),
+    Case("duplicate_id", DUPLICATE_ID, frozenset({"INP020"}), False,
+         "identifier collision"),
+    Case("numeric_bomb", NUMERIC_BOMB, frozenset({"INP022"}), True,
+         "float32 overflow"),
+    Case("nonfinite", NONFINITE, frozenset({"INP021"}), False,
+         "NaN/Inf literals"),
+    Case("embedded_nul", EMBEDDED_NUL, frozenset({"INP003"}), False,
+         "NUL truncates C strings"),
+    Case("unicode_line_sep", UNICODE_LINE_SEP, frozenset(), True,
+         "U+2028 must not split lines"),
+    Case("unknown_section", UNKNOWN_SECTION, frozenset({"INP010"}), True,
+         "undocumented extension"),
+    Case("long_token", LONG_TOKEN, frozenset({"INP012"}), True,
+         "fixed-buffer truncation hazard"),
+)
+
+
+def get(name: str) -> Case:
+    for case in CASES:
+        if case.name == name:
+            return case
+    raise KeyError(name)