Add dataset metadata, schemas, and attack-generation code

Adds CC BY 4.0 dataset-card metadata, normative frame/label schemas, a public validator, and a curated safe-default attack-generation snapshot.

LICENSE.md

@@ -0,0 +1,16 @@
+# Creative Commons Attribution 4.0 International
+
+IV-CAN-v1, including its documentation and the original supplementary code
+published in this repository, is licensed under the Creative Commons
+Attribution 4.0 International License (CC BY 4.0).
+
+License summary and legal code:
+<https://creativecommons.org/licenses/by/4.0/>
+
+You are free to share and adapt the material for any purpose, provided that
+appropriate credit is given, a link to the license is supplied, and changes
+are indicated. No additional restrictions may be applied.
+
+Third-party names, hardware drivers, libraries, and binary runtimes are not
+relicensed by this notice. In particular, PEAK-System PCAN drivers and
+`PCANBasic.dll` are not distributed in this repository.

README.md

@@ -1,58 +1,85 @@
-# IV-CAN-v1
+---
+pretty_name: IV-CAN-v1
+license: cc-by-4.0
+task_categories:
+  - tabular-classification
+tags:
+  - automotive
+  - can-bus
+  - cybersecurity
+  - intrusion-detection
+  - time-series
+size_categories:
+  - 100M<n<1B
+viewer: false
+---
 
-**IV-CAN-v1** is an in-vehicle CAN security dataset organized for attack analysis, cross-domain forwarding inspection, entropy analysis, and message-timing studies.
+# IV-CAN-v1
 
-The dataset is derived from labeled CSV DataGroups and repackaged into a public case-oriented layout. Each trial is assigned a stable open case id, such as `fuzzing_0001`, `replay_0001`, or `dos_0001`.
+**IV-CAN-v1** is an in-vehicle CAN security dataset produced entirely by the IV-CAN team. It contains 134 case-oriented captures for intrusion detection, attack analysis, cross-domain forwarding inspection, entropy analysis, and message-timing studies.
 
 ![Dataset Distribution](statistics/dataset_distribution_pies.svg)
 
 ## Highlights
 
-- **Dataset name:** IV-CAN-v1
+- **License:** [Creative Commons Attribution 4.0 International](LICENSE.md)
 - **Trials:** 134
-- **CSV payload size:** 27.45 GB
 - **CAN frames:** 225,850,423
-- **Protocol frames:** 56,015,108 classical CAN; 169,835,315 CAN FD
-- **Trials with non-driver control:** 67 (37 benign; 30 attack)
-- **Total capture duration:** 12h14min
-- **Non-benign trial duration:** 3h9min
-- **Trials with attack cross-domain forwarding:** 23
+- **CSV payload size:** 27.45 GB
+- **Protocols:** 56,015,108 classical CAN frames and 169,835,315 CAN FD frames
+- **Capture duration:** 12h14min
+- **Attack families:** DoS, fuzzing, replay, spoofing, suspension, and masquerade
 
-## Dataset Layout
+## Repository layout
 
 ```text
 IV-CAN-v1/
 ├── data/
-│   ├── Benign/<case_id>/
-│   └── Attack/<attack_type>/<case_id>/
-├── analysis/
-│   ├── Benign/<case_id>/
-│   └── Attack/<attack_type>/<case_id>/
-├── statistics/
+│   ├── Benign/<case_id>/{data.csv,label.yaml}
+│   └── Attack/<attack_type>/<case_id>/{data.csv,label.yaml}
+├── analysis/                         # case-level plots and tracing artifacts
+├── code/attack_generation/           # self-contained reproducibility snapshot
+├── schema/                            # machine-readable schemas
+├── statistics/                        # aggregate statistics and figures
+├── tools/validate_dataset.py          # lightweight public validator
 ├── dataset_manifest.csv
-├── original_csv_mapping.csv
-├── fail.csv
+├── LICENSE.md
+├── SCHEMA.md
 └── README.md
 ```
 
-Each `data/.../<case_id>/` folder contains:
+Each case has a stable public id such as `fuzzing_0001`. The manifest provides all public data and analysis paths. Large CSV files are intentionally not rendered by the Hub viewer; stream them or download selected cases instead.
 
-- `data.csv`: frame-level CAN messages and labels.
-- `label.yaml`: trial-level metadata, collection duration, and attack information.
+## Data schema
 
-Each `analysis/.../<case_id>/` folder contains:
+Every `data.csv` uses this ordered header:
+
+```text
+timestamp,can_id,is_extended_id,dlc,data,RX_or_TX,type,is_fd,domain,is_attack,traced_from,uuid,is_traced_attack
+```
+
+The normative definitions, units, enums, identifier scope, and tracing constraints are in [SCHEMA.md](SCHEMA.md). Machine-readable definitions are provided in [schema/frame.schema.yaml](schema/frame.schema.yaml) and [schema/label.schema.json](schema/label.schema.json).
+
+Important interpretation rules:
+
+- `timestamp` is Unix epoch time in seconds, expressed on the UTC time scale. The original recorder wall-clock was interpreted in the project acquisition timezone (`Asia/Shanghai`) during conversion.
+- `RX` and `TX` are relative to the recording channel: received from or transmitted by that channel.
+- PEAK frame types are `DT` (data frame without the combined flags represented below), `FB` (CAN FD with BRS), and `BI` (CAN FD with BRS and ESI). Use `is_fd`, not `DT` alone, to distinguish classical CAN from CAN FD.
+- `uuid` is unique only within one case. `traced_from` contains zero or more parent UUIDs from that same case; UUIDs must never be joined across cases.
+- `is_attack=true` identifies injected attack frames. A forwarded-only attack-related frame is selected by `is_traced_attack=true AND is_attack=false`; the flags are not declared mutually exclusive.
+
+Run a bounded structural check from the repository root:
+
+```bash
+python tools/validate_dataset.py --max-rows 1000
+```
 
-- `entropy_domain_bus/`: domain-specific bus-level payload entropy plots (`domain{n}.svg`).
-- `message_timing_domain_bus/`: domain-specific bus-level message-timing plots (`domain{n}.svg`).
-- `cross_domain_relationship_map.yaml`: cross-domain relationship data.
-- `cross_domain_relationship.html`: cross-domain visualization.
-- `tracing.html`: tracing visualization entry point.
-- Optional per-CAN-ID folders for attacked and traced attack entropy/message-timing plots.
+Use `--all` to scan every row (this is expensive for the full dataset).
 
-## Trial Categories
+## Labels and trial categories
 
 | Category | Trials |
-| --- | --- |
+| --- | ---: |
 | Benign | 60 |
 | DoS | 22 |
 | fuzzing | 28 |
@@ -61,73 +88,41 @@ Each `analysis/.../<case_id>/` folder contains:
 | suspension | 2 |
 | masquerade | 2 |
 
-![Trial Count By Attack Type](statistics/group_count_pie.svg)
+Public attack-type names are case-sensitive and normalized exactly as shown. Case ids use lowercase prefixes, for example `dos_0001` and `replay_0001`.
 
-## Collection And Attack Statistics
+## Attack-generation code
+
+[code/attack_generation](code/attack_generation/) is a curated, self-contained snapshot of the core attack construction logic used for the dataset. It excludes private builder infrastructure and third-party hardware binaries. DoS, fuzzing, replay, and spoofing include frame-generation/execution paths; suspension and masquerade are published as validated experiment plans because their execution requires a two-interface MitM bridge.
+
+The command-line tool defaults to a no-transmit preview. Hardware execution requires two explicit safety flags and an authorized, isolated CAN test bench. See the [code README](code/attack_generation/README.md) for installation, limitations, and tests.
+
+## Collection and attack statistics
 
 | Metric | Value |
-| --- | --- |
+| --- | ---: |
 | Total trials | 134 |
 | Total CAN frames | 225,850,423 |
-| Classical CAN frames | 56,015,108 (24.80%) |
-| CAN FD frames | 169,835,315 (75.20%) |
 | Trials with non-driver control | 67 (37 benign; 30 attack) |
-| Dataset size | 27.45 GB |
-| Total capture duration | 12h14min |
 | Non-benign trial duration | 3h9min |
 | Attack duration | 23min |
-| is_attack frames | 231,477 |
-| is_traced_attack frames | 42,478 |
+| `is_attack` frames | 231,477 |
+| `is_traced_attack` frames | 42,478 |
 | Trials with attack cross-domain forwarding | 23 |
 
-### Protocol Distribution By Domain
-
-| Domain | Configured name | Configured protocol | Classical CAN | CAN FD | Total |
-| --- | --- | --- | --- | --- | --- |
-| Domain 1 | 驱动CAN | can fd | 0 | 57,786,350 | 57,786,350 |
-| Domain 2 | 底盘CAN | can fd | 0 | 64,904,112 | 64,904,112 |
-| Domain 3 | 灯控CAN | classical can | 48,815,343 | 0 | 48,815,343 |
-| Domain 4 | 辅助行驶CAN | can fd | 0 | 47,144,853 | 47,144,853 |
-| Domain 5 | 方向盘CAN | classical can | 7,199,765 | 0 | 7,199,765 |
-
-### Figures
-
-![Capture Duration By Road Type](statistics/capture_duration_pie.svg)
-
-![Attack Duration By Attack Type](statistics/attack_duration_pie.svg)
-
-![Attack Frame Distribution](statistics/attack_frame_pie.svg)
-
-## Attack Effect Summary
-
-The attack effect table is available at [`statistics/attack_effect_counter.md`](statistics/attack_effect_counter.md).
-
-## Example Cases
-
-| Case ID | Attack Type | Data | Analysis |
-| --- | --- | --- | --- |
-| benign_0001 | Benign | data/Benign/benign_0001 | analysis/Benign/benign_0001 |
-| dos_0001 | DoS | data/Attack/DoS/dos_0001 | analysis/Attack/DoS/dos_0001 |
-| fuzzing_0001 | fuzzing | data/Attack/fuzzing/fuzzing_0001 | analysis/Attack/fuzzing/fuzzing_0001 |
-| replay_0001 | replay | data/Attack/replay/replay_0001 | analysis/Attack/replay/replay_0001 |
-| spoofing_0001 | spoofing | data/Attack/spoofing/spoofing_0001 | analysis/Attack/spoofing/spoofing_0001 |
-| suspension_0001 | suspension | data/Attack/suspension/suspension_0001 | analysis/Attack/suspension/suspension_0001 |
-| masquerade_0001 | masquerade | data/Attack/masquerade/masquerade_0001 | analysis/Attack/masquerade/masquerade_0001 |
-
-## File Index
+| Domain | Configured name | Protocol | Frames |
+| --- | --- | --- | ---: |
+| 1 | 驱动CAN | CAN FD | 57,786,350 |
+| 2 | 底盘CAN | CAN FD | 64,904,112 |
+| 3 | 灯控CAN | Classical CAN | 48,815,343 |
+| 4 | 辅助行驶CAN | CAN FD | 47,144,853 |
+| 5 | 方向盘CAN | Classical CAN | 7,199,765 |
 
-- [`dataset_manifest.csv`](dataset_manifest.csv): all public cases and their data/analysis paths.
-- [`original_csv_mapping.csv`](original_csv_mapping.csv): mapping from original CSV DataGroups to open case ids.
-- [`fail.csv`](fail.csv): skipped or failed inputs, if any.
-- [`statistics/count_csv_result.yaml`](statistics/count_csv_result.yaml): machine-readable dataset statistics.
+The attack-effect summary is available in [statistics/attack_effect_counter.md](statistics/attack_effect_counter.md), with additional machine-readable statistics in [statistics/count_csv_result.yaml](statistics/count_csv_result.yaml).
 
-## Naming Convention
+## Responsible use
 
-Public attack-type names are normalized as `DoS`, `fuzzing`, `replay`, `spoofing`, `suspension`, and `masquerade`.
-Case ids use lowercase prefixes, for example `dos_0001`, `fuzzing_0001`, and `replay_0001`.
+This dataset and supplementary code are intended for authorized security research, reproducibility, defensive evaluation, and education. Do not use attack-generation functionality on public roads, operational vehicles, or networks you do not own or have explicit permission to test.
 
-## Notes
+## License and attribution
 
-- `is_attack` marks injected attack frames.
-- `is_traced_attack` marks forwarded attack-related frames only when `is_traced_attack=true` and `is_attack=false`.
-- Statistics are cherry-picked from the analyzer output using an explicit public-file allowlist.
+IV-CAN-v1 data, original documentation, schemas, figures, and the original supplementary attack-generation code are released under [CC BY 4.0](LICENSE.md). Attribution is required. Third-party drivers and runtimes are not redistributed and remain subject to their vendors' licenses.

SCHEMA.md

@@ -0,0 +1,49 @@
+# IV-CAN-v1 data contract
+
+This document is the normative public schema for IV-CAN-v1. `schema/frame.schema.yaml` and `schema/label.schema.json` provide machine-readable companions.
+
+## Frame table (`data.csv`)
+
+| Field | Type | Definition and constraint |
+| --- | --- | --- |
+| `timestamp` | finite number | Unix epoch seconds on the UTC time scale. Sub-second precision is retained. Source recorder wall-clock values were interpreted as `Asia/Shanghai` during conversion. |
+| `can_id` | string | Uppercase hexadecimal with `0x` prefix: four digits for standard frames or eight for extended frames. Width must agree with `is_extended_id`. |
+| `is_extended_id` | boolean | `true` for a 29-bit CAN identifier; `false` for an 11-bit identifier. CSV spelling is `True`/`False`. |
+| `dlc` | integer | Actual payload byte count, not the encoded CAN DLC nibble. It must equal the number of space-separated bytes in `data`. Classical CAN permits 0–8; CAN FD permits 0–8, 12, 16, 20, 24, 32, 48, or 64. |
+| `data` | string | Zero or more uppercase hexadecimal bytes separated by one ASCII space, for example `00 F0 7F`. Empty iff `dlc=0`. |
+| `RX_or_TX` | enum | `RX`: received by the recording channel. `TX`: transmitted by the recording channel. Direction is channel-relative, not a vehicle-wide source/destination role. |
+| `type` | enum | PEAK TRC record type: `DT` = data frame without the combined flags represented below; `FB` = CAN FD data frame with bit-rate switching (BRS); `BI` = CAN FD frame with BRS and error-state indicator (ESI). A `DT` record can be classical CAN or CAN FD, so do not infer the protocol from this field alone. |
+| `is_fd` | boolean | Normative protocol discriminator: true for CAN FD and false for classical CAN. `FB` and `BI` require true; `DT` permits either value. |
+| `domain` | integer | Recording domain number, one of 1–5. Domain names and configured protocols are listed in the dataset card. |
+| `is_attack` | boolean | True when the row is an injected attack frame. |
+| `traced_from` | list of integers | Python-list serialization of zero or more direct parent UUIDs, e.g. `[]` or `[12, 19]`. Every parent must exist in the same case; cross-case references and self-references are invalid. Multiple parents are allowed. |
+| `uuid` | positive integer | Row identifier unique within one case (`data.csv`). UUID scope resets between cases and is not globally unique. |
+| `is_traced_attack` | boolean | True when tracing associates the row with attack propagation. Because an injected frame can also carry this flag, forwarded-only rows are `is_traced_attack=true AND is_attack=false`. |
+
+### Relationship constraints
+
+- The graph induced by `uuid -> traced_from` is case-local and must be acyclic.
+- Every reference must resolve to a row in the same `data.csv`.
+- A row must not reference itself; duplicates in one `traced_from` list are invalid.
+- Consumers must qualify UUIDs with `group_name` or case path before combining cases.
+- Trace edges are intended to represent causal forwarding. Consumers should retain timestamps and domains rather than assuming UUID order alone encodes causality.
+
+## Trial label (`label.yaml`)
+
+`group_name` equals the containing case directory. Benign trials use `data_attack_info: null`; attack trials provide an attack family, attacked domain, observed effect, and family-specific configuration when applicable.
+
+Enums:
+
+- `data_collection_info.road_type`: `UrbanOrdinaryRoad`, `RuralRoad`, `InternalRoad`, `UORWithLKN`, `HighwayWithLKN`, `Highway`, `UrbanExpressway`.
+- `data_attack_info.attack_type.kind`: `DoS`, `fuzzing`, `replay`, `spoofing`, `suspension`, `masquerade`.
+- `attack_effect.level`: `no effect`, `system warning`, `non-motion control compromised`, `motion control compromised`.
+- DoS config: `id_option` is `aliveId|zeroId`; `dlc_option` is `dlcChange|dlcKeep`; `ext_option` is `extendedId|standardId`; `data_option` is `FFData|randomData`.
+- fuzzing config: `id_option` is `aliveId|randomId`; `dlc_option` is `dlcChange|dlcKeep`.
+- replay config: `timing` is `delay|immediate`.
+- suspension config: positive `suspension_duration_sec` and one or more canonical `suspension_CAN_id_list` values.
+
+Attack start/end timestamps can be null when the original metadata did not record explicit bounds; `attacking_duration_sec` remains the duration field. The complete conditional structure is in `schema/label.schema.json`.
+
+## Versioning
+
+These files describe IV-CAN-v1. Schema-compatible clarifications may be added without renaming the dataset; any incompatible field or semantic change requires a new dataset version.

code/attack_generation/README.md

@@ -0,0 +1,80 @@
+# IV-CAN-v1 attack-generation snapshot
+
+This directory is the self-contained reproducibility snapshot of the attack
+construction code used by IV-CAN-v1. It preserves the dataset taxonomy and
+frame-generation logic while excluding private builder infrastructure and the
+third-party `PCANBasic.dll` binary.
+
+## Implemented scope
+
+| Attack family | Dry-run plan | Hardware execution |
+| --- | --- | --- |
+| DoS | Yes | Side-channel injection |
+| fuzzing | Yes | Side-channel injection |
+| replay | Yes | Side-channel injection |
+| spoofing | Yes | Side-channel injection |
+| suspension | Yes | Not implemented; requires a two-interface MitM bridge |
+| masquerade | Yes | Not implemented; requires a two-interface MitM bridge |
+
+The values accepted by each family match `label.yaml` and are documented in
+[`../../SCHEMA.md`](../../SCHEMA.md).
+
+## Install
+
+Dry-run mode uses only the Python standard library:
+
+```bash
+python -m pip install -e .
+```
+
+Hardware use requires the optional PCAN adapter dependency plus the official
+PEAK-System driver/runtime installed under its own license:
+
+```bash
+python -m pip install -e '.[pcan]'
+```
+
+No PEAK-System DLL is redistributed in this repository.
+
+## Safe default: preview only
+
+The CLI does not transmit unless explicitly requested:
+
+```bash
+ivcan-attack --type DoS \
+  --id-option zeroId \
+  --dlc-option dlcChange \
+  --frame-format standardId \
+  --data-option FFData \
+  --duration 10
+```
+
+Replay can consume an IV-CAN-v1 CSV or the synthetic example:
+
+```bash
+ivcan-attack --type replay \
+  --timing immediate \
+  --replay-file examples/synthetic_replay.csv
+```
+
+Hardware transmission requires both `--execute` and
+`--acknowledge-bench-only`. It must only be used on an authorized, isolated
+test bench. Never connect this tool to a vehicle operating on a public road.
+
+## Reproducibility notes
+
+- `timestamp` differences are used to reproduce replay timing.
+- `is_extended_id` and `is_fd` are consumed when present in replay CSV files.
+- The `seed` option makes generated DoS/fuzzing previews deterministic.
+- Suspension and masquerade are published as validated experiment plans, not
+  as claims of an implemented MitM bridge.
+
+## Tests
+
+```bash
+python -m unittest discover -s tests -v
+```
+
+This snapshot is distributed under CC BY 4.0 with the rest of IV-CAN-v1.
+Third-party hardware drivers and runtimes remain under their vendors' terms.
+

original_csv_mapping.csv → code/attack_generation/examples/synthetic_replay.csv

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:375a7a305c1ba344a63a3887f903b50b71e21b10edef38fdf6862fb149221025
-size 11060
+oid sha256:e5f553c4841fbfe2f35f3d2ba4decb08886b13e8d5b6c370b2582b297172284c
+size 164

code/attack_generation/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ivcan-attack-generation"
+version = "1.0.1"
+description = "Reproducibility snapshot of the IV-CAN-v1 attack generator"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "CC-BY-4.0"}
+dependencies = []
+
+[project.optional-dependencies]
+pcan = ["python-can>=4.4,<5"]
+
+[project.scripts]
+ivcan-attack = "ivcan_attacker.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+

code/attack_generation/src/ivcan_attacker/__init__.py

@@ -0,0 +1,7 @@
+"""Reproducibility snapshot of the IV-CAN-v1 attack generator."""
+
+from .attack_runtime import AttackRequest, AttackRunner
+from .attack_types import AttackBaseType, AttackType
+
+__all__ = ["AttackBaseType", "AttackRequest", "AttackRunner", "AttackType"]
+

code/attack_generation/src/ivcan_attacker/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

code/attack_generation/src/ivcan_attacker/attack_runtime.py

@@ -0,0 +1,459 @@
+"""Readable attack strategies built on the vendor-neutral ``can_base`` API.
+
+The module separates three concerns:
+
+1. :class:`AttackType` describes the paper-level attack configuration.
+2. :class:`AttackRequest` contains runtime values supplied by the CLI.
+3. Strategy classes turn a request into CAN frames or a MitM execution plan.
+
+Side-channel injection attacks can already use the common execution loop.
+Suspension and masquerade deliberately expose explicit extension points because
+they need a two-interface MitM bridge, which ``can_base`` does not yet provide.
+"""
+
+from __future__ import annotations
+
+import csv
+import random
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterator
+
+from .can_base import CANFrame, CANInterfaceBase
+from .attack_types import (
+    AttackBaseType,
+    AttackType,
+    DoSConfig,
+    DoSOptionDLC,
+    DoSOptionData,
+    DoSOptionExt,
+    DoSOptionId,
+    FuzzConfig,
+    FuzzOptionDLC,
+    FuzzOptionId,
+    ReplayConfig,
+    ReplayOption,
+    SuspensionConfig,
+)
+
+
+_CLASSIC_DLC_VALUES = tuple(range(0, 9))
+_CAN_FD_DLC_VALUES = (*_CLASSIC_DLC_VALUES, 12, 16, 20, 24, 32, 48, 64)
+
+
+def parse_can_id(value: str) -> int:
+    """Parse a decimal or ``0x``-prefixed CAN identifier."""
+
+    try:
+        parsed = int(value, 0)
+    except ValueError as exc:
+        raise ValueError(f"invalid CAN ID: {value!r}") from exc
+    if parsed < 0:
+        raise ValueError("CAN ID cannot be negative")
+    return parsed
+
+
+def parse_payload(value: str) -> bytes:
+    """Parse payload text such as ``11 22 FF`` or ``1122FF``."""
+
+    compact = value.replace("0x", "").replace(" ", "").replace(":", "")
+    if not compact:
+        return b""
+    if len(compact) % 2:
+        raise ValueError("payload must contain complete hexadecimal bytes")
+    try:
+        return bytes.fromhex(compact)
+    except ValueError as exc:
+        raise ValueError(f"invalid hexadecimal payload: {value!r}") from exc
+
+
+@dataclass(frozen=True, slots=True)
+class AttackRequest:
+    """One fully parsed CLI request.
+
+    ``duration`` controls generated injection attacks. Replay sends one input
+    sequence, while suspension uses the duration stored in its paper-level
+    :class:`SuspensionConfig`.
+    """
+
+    attack_type: AttackType
+    duration: float = 10.0
+    interval: float = 0.01
+    can_id: int | None = None
+    dlc: int | None = None
+    payload: bytes | None = None
+    is_extended_id: bool = False
+    is_fd: bool = False
+    replay_file: Path | None = None
+    replay_delay: float = 0.0
+    seed: int | None = None
+
+    def __post_init__(self) -> None:
+        if self.duration <= 0:
+            raise ValueError("duration must be positive")
+        if self.interval < 0:
+            raise ValueError("interval cannot be negative")
+        if self.replay_delay < 0:
+            raise ValueError("replay delay cannot be negative")
+        if self.dlc is not None:
+            allowed = _CAN_FD_DLC_VALUES if self.is_fd else _CLASSIC_DLC_VALUES
+            if self.dlc not in allowed:
+                protocol = "CAN FD" if self.is_fd else "classical CAN"
+                raise ValueError(f"DLC {self.dlc} is invalid for {protocol}")
+        if self.payload is not None:
+            maximum = 64 if self.is_fd else 8
+            if len(self.payload) > maximum:
+                raise ValueError(f"payload exceeds the {maximum}-byte protocol limit")
+
+    def to_dict(self) -> dict:
+        return {
+            "attack_type": self.attack_type.to_dict(),
+            "runtime": {
+                "duration": self.duration,
+                "interval": self.interval,
+                "can_id": None if self.can_id is None else f"0x{self.can_id:X}",
+                "dlc": self.dlc,
+                "payload": None if self.payload is None else self.payload.hex(" ").upper(),
+                "is_extended_id": self.is_extended_id,
+                "is_fd": self.is_fd,
+                "replay_file": None if self.replay_file is None else str(self.replay_file),
+                "replay_delay": self.replay_delay,
+                "seed": self.seed,
+            },
+        }
+
+
+class AttackStrategy(ABC):
+    """Base class for one attack vector."""
+
+    @abstractmethod
+    def validate(self, request: AttackRequest) -> None:
+        """Validate attack-specific runtime values."""
+
+    @abstractmethod
+    def describe(self, request: AttackRequest) -> str:
+        """Return a concise human-readable execution plan."""
+
+    def preview(self, request: AttackRequest, count: int = 3) -> list[CANFrame]:
+        """Return representative frames without opening CAN hardware."""
+
+        return []
+
+    @abstractmethod
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        """Execute the request and return the number of transmitted frames."""
+
+
+class GeneratedFrameStrategy(AttackStrategy):
+    """Common timed loop for attacks that generate side-channel frames."""
+
+    @abstractmethod
+    def frames(self, request: AttackRequest) -> Iterator[CANFrame]:
+        """Yield an unbounded stream of attack frames."""
+
+    def preview(self, request: AttackRequest, count: int = 3) -> list[CANFrame]:
+        self.validate(request)
+        stream = self.frames(request)
+        return [next(stream) for _ in range(count)]
+
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        self.validate(request)
+        deadline = time.monotonic() + request.duration
+        transmitted = 0
+        for frame in self.frames(request):
+            if time.monotonic() >= deadline:
+                break
+            interface.send(frame)
+            transmitted += 1
+            if request.interval:
+                time.sleep(request.interval)
+        return transmitted
+
+
+def _random_dlc(rng: random.Random, request: AttackRequest) -> int:
+    values = _CAN_FD_DLC_VALUES if request.is_fd else _CLASSIC_DLC_VALUES
+    candidates = tuple(value for value in values if value != request.dlc)
+    return rng.choice(candidates or values)
+
+
+def _validate_explicit_can_id(request: AttackRequest, *, extended: bool) -> int:
+    if request.can_id is None:
+        raise ValueError("this configuration requires --can-id")
+    maximum = 0x1FFFFFFF if extended else 0x7FF
+    if request.can_id > maximum:
+        width = "29-bit" if extended else "11-bit"
+        raise ValueError(f"CAN ID 0x{request.can_id:X} does not fit {width} format")
+    return request.can_id
+
+
+class DoSStrategy(GeneratedFrameStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        config = request.attack_type.config
+        if not isinstance(config, DoSConfig):
+            raise ValueError("DoSStrategy requires DoSConfig")
+        extended = config.ext_option is DoSOptionExt.EXTENDED_ID
+        if config.id_option is DoSOptionId.ALIVE_ID:
+            _validate_explicit_can_id(request, extended=extended)
+        if config.dlc_option is DoSOptionDLC.DLC_KEEP and request.dlc is None:
+            raise ValueError("dlcKeep requires --dlc from the active frame")
+
+    def describe(self, request: AttackRequest) -> str:
+        config = request.attack_type.config
+        assert isinstance(config, DoSConfig)
+        identifier = (
+            "0x000"
+            if config.id_option is DoSOptionId.ZERO_ID
+            else f"0x{request.can_id:X}"
+        )
+        return (
+            f"DoS injection: id={identifier}, {config.dlc_option.value}, "
+            f"{config.ext_option.value}, {config.data_option.value}"
+        )
+
+    def frames(self, request: AttackRequest) -> Iterator[CANFrame]:
+        config = request.attack_type.config
+        assert isinstance(config, DoSConfig)
+        rng = random.Random(request.seed)
+        extended = config.ext_option is DoSOptionExt.EXTENDED_ID
+        arbitration_id = (
+            0
+            if config.id_option is DoSOptionId.ZERO_ID
+            else _validate_explicit_can_id(request, extended=extended)
+        )
+        while True:
+            dlc = (
+                request.dlc
+                if config.dlc_option is DoSOptionDLC.DLC_KEEP
+                else _random_dlc(rng, request)
+            )
+            assert dlc is not None
+            payload = (
+                bytes([0xFF]) * dlc
+                if config.data_option is DoSOptionData.FF_DATA
+                else bytes(rng.randrange(256) for _ in range(dlc))
+            )
+            yield CANFrame(
+                arbitration_id=arbitration_id,
+                data=payload,
+                is_extended_id=extended,
+                is_fd=request.is_fd,
+                bitrate_switch=request.is_fd,
+            )
+
+
+class FuzzStrategy(GeneratedFrameStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        config = request.attack_type.config
+        if not isinstance(config, FuzzConfig):
+            raise ValueError("FuzzStrategy requires FuzzConfig")
+        if config.id_option is FuzzOptionId.ALIVE_ID:
+            _validate_explicit_can_id(request, extended=request.is_extended_id)
+        if config.dlc_option is FuzzOptionDLC.DLC_KEEP and request.dlc is None:
+            raise ValueError("dlcKeep requires --dlc from the active frame")
+
+    def describe(self, request: AttackRequest) -> str:
+        config = request.attack_type.config
+        assert isinstance(config, FuzzConfig)
+        identifier = (
+            "random"
+            if config.id_option is FuzzOptionId.RANDOM_ID
+            else f"0x{request.can_id:X}"
+        )
+        return f"fuzzing injection: id={identifier}, {config.dlc_option.value}"
+
+    def frames(self, request: AttackRequest) -> Iterator[CANFrame]:
+        config = request.attack_type.config
+        assert isinstance(config, FuzzConfig)
+        rng = random.Random(request.seed)
+        maximum_id = 0x1FFFFFFF if request.is_extended_id else 0x7FF
+        while True:
+            arbitration_id = (
+                rng.randint(0, maximum_id)
+                if config.id_option is FuzzOptionId.RANDOM_ID
+                else _validate_explicit_can_id(request, extended=request.is_extended_id)
+            )
+            dlc = (
+                request.dlc
+                if config.dlc_option is FuzzOptionDLC.DLC_KEEP
+                else _random_dlc(rng, request)
+            )
+            assert dlc is not None
+            yield CANFrame(
+                arbitration_id=arbitration_id,
+                data=bytes(rng.randrange(256) for _ in range(dlc)),
+                is_extended_id=request.is_extended_id,
+                is_fd=request.is_fd,
+                bitrate_switch=request.is_fd,
+            )
+
+
+class SpoofingStrategy(GeneratedFrameStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        _validate_explicit_can_id(request, extended=request.is_extended_id)
+        if request.payload is None:
+            raise ValueError("Spoofing requires --data")
+
+    def describe(self, request: AttackRequest) -> str:
+        payload = request.payload.hex(" ").upper()
+        return f"spoofing injection: id=0x{request.can_id:X}, payload={payload}"
+
+    def frames(self, request: AttackRequest) -> Iterator[CANFrame]:
+        assert request.can_id is not None and request.payload is not None
+        frame = CANFrame(
+            arbitration_id=request.can_id,
+            data=request.payload,
+            is_extended_id=request.is_extended_id,
+            is_fd=request.is_fd,
+            bitrate_switch=request.is_fd,
+        )
+        while True:
+            yield frame
+
+
+def _parse_bool(value: str) -> bool:
+    normalized = value.strip().lower()
+    if normalized in {"1", "true", "yes", "y"}:
+        return True
+    if normalized in {"0", "false", "no", "n", ""}:
+        return False
+    raise ValueError(f"invalid boolean value: {value!r}")
+
+
+def _load_replay_csv(path: Path) -> list[CANFrame]:
+    """Load frames from an IV-CAN-style CSV file."""
+
+    if not path.is_file():
+        raise ValueError(f"replay file does not exist: {path}")
+    frames: list[CANFrame] = []
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        for line_number, row in enumerate(csv.DictReader(handle), start=2):
+            try:
+                frames.append(
+                    CANFrame(
+                        arbitration_id=parse_can_id(row["can_id"]),
+                        data=parse_payload(row.get("data", "")),
+                        timestamp=float(row["timestamp"]) if row.get("timestamp") else None,
+                        is_extended_id=_parse_bool(row.get("is_extended_id", "false")),
+                        is_fd=_parse_bool(row.get("is_fd", "false")),
+                    )
+                )
+            except (KeyError, ValueError) as exc:
+                raise ValueError(f"invalid replay CSV row {line_number}: {exc}") from exc
+    if not frames:
+        raise ValueError("replay file contains no frames")
+    return frames
+
+
+class ReplayStrategy(AttackStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        config = request.attack_type.config
+        if not isinstance(config, ReplayConfig):
+            raise ValueError("ReplayStrategy requires ReplayConfig")
+        if request.replay_file is None:
+            raise ValueError("Replay requires --replay-file")
+        if config.timing is ReplayOption.DELAY and request.replay_delay <= 0:
+            raise ValueError("delayed replay requires a positive --replay-delay")
+
+    def describe(self, request: AttackRequest) -> str:
+        config = request.attack_type.config
+        assert isinstance(config, ReplayConfig)
+        suffix = f" by {request.replay_delay:g} s" if config.timing is ReplayOption.DELAY else ""
+        return f"replay {request.replay_file}: {config.timing.value}{suffix}"
+
+    def preview(self, request: AttackRequest, count: int = 3) -> list[CANFrame]:
+        self.validate(request)
+        assert request.replay_file is not None
+        return _load_replay_csv(request.replay_file)[:count]
+
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        self.validate(request)
+        config = request.attack_type.config
+        assert isinstance(config, ReplayConfig) and request.replay_file is not None
+        frames = _load_replay_csv(request.replay_file)
+        if config.timing is ReplayOption.DELAY:
+            time.sleep(request.replay_delay)
+
+        first_timestamp = frames[0].timestamp
+        started_at = time.monotonic()
+        transmitted = 0
+        for frame in frames:
+            if first_timestamp is not None and frame.timestamp is not None:
+                due = started_at + max(0.0, frame.timestamp - first_timestamp)
+                time.sleep(max(0.0, due - time.monotonic()))
+            elif transmitted and request.interval:
+                time.sleep(request.interval)
+            interface.send(frame)
+            transmitted += 1
+        return transmitted
+
+
+class SuspensionStrategy(AttackStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        if not isinstance(request.attack_type.config, SuspensionConfig):
+            raise ValueError("SuspensionStrategy requires SuspensionConfig")
+
+    def describe(self, request: AttackRequest) -> str:
+        config = request.attack_type.config
+        assert isinstance(config, SuspensionConfig)
+        return (
+            f"MitM suspension: drop {', '.join(config.suspension_CAN_id_list)} "
+            f"for {config.suspension_duration_sec} s"
+        )
+
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        self.validate(request)
+        raise NotImplementedError(
+            "Suspension needs a two-interface MitM bridge; the strategy contract is ready, "
+            "but can_base currently exposes individual interfaces only."
+        )
+
+
+class MasqueradeStrategy(AttackStrategy):
+    def validate(self, request: AttackRequest) -> None:
+        _validate_explicit_can_id(request, extended=request.is_extended_id)
+        if request.payload is None:
+            raise ValueError("Masquerade requires --data for the forged replacement frame")
+
+    def describe(self, request: AttackRequest) -> str:
+        return f"MitM masquerade: replace id=0x{request.can_id:X} with forged payload"
+
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        self.validate(request)
+        raise NotImplementedError(
+            "Masquerade needs a two-interface MitM bridge that suppresses legitimate frames "
+            "before forwarding forged replacements."
+        )
+
+
+_STRATEGIES: dict[AttackBaseType, type[AttackStrategy]] = {
+    AttackBaseType.DOS: DoSStrategy,
+    AttackBaseType.FUZZ: FuzzStrategy,
+    AttackBaseType.REPLAY: ReplayStrategy,
+    AttackBaseType.SPOOFING: SpoofingStrategy,
+    AttackBaseType.SUSPENSION: SuspensionStrategy,
+    AttackBaseType.MASQUERADE: MasqueradeStrategy,
+}
+
+
+class AttackRunner:
+    """Resolve and run the strategy associated with an :class:`AttackRequest`."""
+
+    def strategy_for(self, request: AttackRequest) -> AttackStrategy:
+        try:
+            strategy_class = _STRATEGIES[request.attack_type.kind]
+        except KeyError as exc:
+            raise ValueError(f"unsupported attack type: {request.attack_type.kind.value}") from exc
+        strategy = strategy_class()
+        strategy.validate(request)
+        return strategy
+
+    def describe(self, request: AttackRequest) -> str:
+        return self.strategy_for(request).describe(request)
+
+    def preview(self, request: AttackRequest, count: int = 3) -> list[CANFrame]:
+        return self.strategy_for(request).preview(request, count=count)
+
+    def execute(self, request: AttackRequest, interface: CANInterfaceBase) -> int:
+        return self.strategy_for(request).execute(request, interface)

code/attack_generation/src/ivcan_attacker/attack_types.py

@@ -0,0 +1,133 @@
+"""Attack taxonomy used to construct the IV-CAN-v1 attack trials."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class AttackBaseType(str, Enum):
+    DOS = "DoS"
+    FUZZ = "fuzzing"
+    REPLAY = "replay"
+    SPOOFING = "spoofing"
+    SUSPENSION = "suspension"
+    MASQUERADE = "masquerade"
+
+
+class DoSOptionId(str, Enum):
+    ALIVE_ID = "aliveId"
+    ZERO_ID = "zeroId"
+
+
+class DoSOptionDLC(str, Enum):
+    DLC_CHANGE = "dlcChange"
+    DLC_KEEP = "dlcKeep"
+
+
+class DoSOptionExt(str, Enum):
+    EXTENDED_ID = "extendedId"
+    STANDARD_ID = "standardId"
+
+
+class DoSOptionData(str, Enum):
+    RANDOM_DATA = "randomData"
+    FF_DATA = "FFData"
+
+
+@dataclass(frozen=True, slots=True)
+class DoSConfig:
+    id_option: DoSOptionId
+    dlc_option: DoSOptionDLC
+    ext_option: DoSOptionExt
+    data_option: DoSOptionData
+
+    def to_dict(self) -> dict:
+        return {
+            "id_option": self.id_option.value,
+            "dlc_option": self.dlc_option.value,
+            "ext_option": self.ext_option.value,
+            "data_option": self.data_option.value,
+        }
+
+
+class FuzzOptionId(str, Enum):
+    ALIVE_ID = "aliveId"
+    RANDOM_ID = "randomId"
+
+
+class FuzzOptionDLC(str, Enum):
+    DLC_CHANGE = "dlcChange"
+    DLC_KEEP = "dlcKeep"
+
+
+@dataclass(frozen=True, slots=True)
+class FuzzConfig:
+    id_option: FuzzOptionId
+    dlc_option: FuzzOptionDLC
+
+    def to_dict(self) -> dict:
+        return {
+            "id_option": self.id_option.value,
+            "dlc_option": self.dlc_option.value,
+        }
+
+
+class ReplayOption(str, Enum):
+    DELAY = "delay"
+    IMMEDIATE = "immediate"
+
+
+@dataclass(frozen=True, slots=True)
+class ReplayConfig:
+    timing: ReplayOption
+
+    def to_dict(self) -> dict:
+        return {"timing": self.timing.value}
+
+
+@dataclass(frozen=True, slots=True)
+class SuspensionConfig:
+    suspension_duration_sec: int
+    suspension_CAN_id_list: list[str]
+
+    def __post_init__(self) -> None:
+        if self.suspension_duration_sec <= 0:
+            raise ValueError("suspension_duration_sec must be positive")
+        if not self.suspension_CAN_id_list:
+            raise ValueError("suspension_CAN_id_list cannot be empty")
+
+    def to_dict(self) -> dict:
+        return {
+            "suspension_duration_sec": self.suspension_duration_sec,
+            "suspension_CAN_id_list": self.suspension_CAN_id_list,
+        }
+
+
+AttackConfig = DoSConfig | FuzzConfig | ReplayConfig | SuspensionConfig
+
+
+@dataclass(frozen=True, slots=True)
+class AttackType:
+    kind: AttackBaseType
+    config: AttackConfig | None = None
+
+    def __post_init__(self) -> None:
+        expected = {
+            AttackBaseType.DOS: DoSConfig,
+            AttackBaseType.FUZZ: FuzzConfig,
+            AttackBaseType.REPLAY: ReplayConfig,
+            AttackBaseType.SUSPENSION: SuspensionConfig,
+        }.get(self.kind)
+        if expected is None:
+            if self.config is not None:
+                raise ValueError(f"{self.kind.value} does not accept a config object")
+        elif not isinstance(self.config, expected):
+            raise ValueError(f"{self.kind.value} requires {expected.__name__}")
+
+    def to_dict(self) -> dict:
+        return {
+            "kind": self.kind.value,
+            "config": None if self.config is None else self.config.to_dict(),
+        }
+

code/attack_generation/src/ivcan_attacker/can_base/__init__.py

@@ -0,0 +1,44 @@
+"""Stable public API for CAN hardware access."""
+
+from .can_interface_base import CANInterfaceBase
+from .exceptions import (
+    CANBaseError,
+    CANConfigurationError,
+    CANConnectionError,
+    CANDependencyError,
+    CANDisconnectionError,
+    CANQueueFullError,
+    CANReceiveError,
+    CANStateError,
+    CANTimeoutError,
+    CANTransmissionError,
+)
+from .pcan_interface import PCANInterface, PCANInterfaceConfig
+from .types import (
+    CANFrame,
+    CANInterfaceConfig,
+    CANStatistics,
+    ConnectionState,
+    OverflowPolicy,
+)
+
+__all__ = [
+    "CANBaseError",
+    "CANConfigurationError",
+    "CANConnectionError",
+    "CANDependencyError",
+    "CANDisconnectionError",
+    "CANFrame",
+    "CANInterfaceBase",
+    "CANInterfaceConfig",
+    "CANQueueFullError",
+    "CANReceiveError",
+    "CANStateError",
+    "CANStatistics",
+    "CANTimeoutError",
+    "CANTransmissionError",
+    "ConnectionState",
+    "OverflowPolicy",
+    "PCANInterface",
+    "PCANInterfaceConfig",
+]

code/attack_generation/src/ivcan_attacker/can_base/can_interface_base.py

@@ -0,0 +1,594 @@
+"""Thread-safe lifecycle and queueing foundation for CAN adapters."""
+
+from __future__ import annotations
+
+import logging
+import queue
+import threading
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Iterable
+
+from .exceptions import (
+    CANBaseError,
+    CANConnectionError,
+    CANDisconnectionError,
+    CANQueueFullError,
+    CANReceiveError,
+    CANStateError,
+    CANTimeoutError,
+    CANTransmissionError,
+)
+from .types import (
+    CANFrame,
+    CANInterfaceConfig,
+    CANStatistics,
+    ConnectionState,
+    OverflowPolicy,
+)
+
+
+@dataclass(slots=True)
+class _TxRequest:
+    frame: CANFrame
+    completion: threading.Event = field(default_factory=threading.Event)
+    error: BaseException | None = None
+
+
+class CANInterfaceBase(ABC):
+    """Base class for a full-duplex CAN hardware interface.
+
+    Subclasses only implement the four synchronous hardware hooks.  This class
+    owns connection state, bounded queues, one receive worker, and one ordered
+    transmit worker.  A worker is created per direction, never per frame.
+    """
+
+    def __init__(
+        self,
+        config: CANInterfaceConfig,
+        *,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        self.config = config
+        self._logger = logger or logging.getLogger(
+            f"{self.__class__.__module__}.{self.__class__.__qualname__}"
+        )
+
+        self._state = ConnectionState.DISCONNECTED
+        self._state_lock = threading.RLock()
+        self._lifecycle_lock = threading.Lock()
+        self._statistics_lock = threading.Lock()
+        self._last_error: BaseException | None = None
+
+        self._rx_queue: queue.Queue[CANFrame] = queue.Queue(
+            maxsize=config.rx_queue_size
+        )
+        self._tx_queue: queue.Queue[_TxRequest] = queue.Queue(
+            maxsize=config.tx_queue_size
+        )
+        self._stop_event = threading.Event()
+        self._drain_tx_on_stop = False
+        self._rx_thread: threading.Thread | None = None
+        self._tx_thread: threading.Thread | None = None
+
+        self._rx_received = 0
+        self._rx_delivered = 0
+        self._rx_dropped = 0
+        self._tx_queued = 0
+        self._tx_sent = 0
+        self._tx_failed = 0
+        self._tx_dropped = 0
+
+    @property
+    def state(self) -> ConnectionState:
+        """Return the current lifecycle state."""
+
+        with self._state_lock:
+            return self._state
+
+    @property
+    def connected(self) -> bool:
+        """Whether the interface currently accepts receive/send operations."""
+
+        return self.state is ConnectionState.CONNECTED
+
+    @property
+    def last_error(self) -> BaseException | None:
+        """Return the fatal worker or connection error, if one occurred."""
+
+        with self._state_lock:
+            return self._last_error
+
+    @property
+    def statistics(self) -> CANStatistics:
+        """Return a consistent snapshot of runtime counters."""
+
+        with self._statistics_lock:
+            return CANStatistics(
+                rx_received=self._rx_received,
+                rx_delivered=self._rx_delivered,
+                rx_dropped=self._rx_dropped,
+                tx_queued=self._tx_queued,
+                tx_sent=self._tx_sent,
+                tx_failed=self._tx_failed,
+                tx_dropped=self._tx_dropped,
+            )
+
+    def connect(self) -> None:
+        """Open the hardware and start the independent RX/TX workers.
+
+        Calling this method while already connected is harmless.  After a
+        failed connection or fatal worker error, call :meth:`disconnect` before
+        attempting to reconnect.
+        """
+
+        with self._lifecycle_lock:
+            current = self.state
+            if current is ConnectionState.CONNECTED:
+                return
+            if current is not ConnectionState.DISCONNECTED:
+                raise CANStateError(f"cannot connect while interface is {current.value}")
+
+            self._set_state(ConnectionState.CONNECTING)
+            with self._state_lock:
+                self._last_error = None
+            self._stop_event.clear()
+            self._drain_tx_on_stop = False
+            self._rx_queue = queue.Queue(maxsize=self.config.rx_queue_size)
+            self._tx_queue = queue.Queue(maxsize=self.config.tx_queue_size)
+
+            try:
+                self._open_hardware()
+                self._set_state(ConnectionState.CONNECTED)
+                self._rx_thread = threading.Thread(
+                    target=self._rx_worker,
+                    name=f"{self.config.thread_name_prefix}-rx",
+                    daemon=True,
+                )
+                self._tx_thread = threading.Thread(
+                    target=self._tx_worker,
+                    name=f"{self.config.thread_name_prefix}-tx",
+                    daemon=True,
+                )
+                self._rx_thread.start()
+                self._tx_thread.start()
+            except Exception as exc:
+                self._stop_event.set()
+                try:
+                    self._close_hardware()
+                except Exception as close_exc:  # pragma: no cover - defensive path
+                    self._logger.warning(
+                        "hardware cleanup after failed connect also failed: %s",
+                        close_exc,
+                    )
+                error = (
+                    exc
+                    if isinstance(exc, CANBaseError)
+                    else CANConnectionError(f"failed to connect CAN hardware: {exc}")
+                )
+                with self._state_lock:
+                    self._last_error = error
+                self._set_state(ConnectionState.ERROR)
+                raise error from exc
+
+    def disconnect(
+        self,
+        *,
+        drain_tx: bool = False,
+        timeout: float | None = None,
+    ) -> None:
+        """Stop workers and close the hardware connection.
+
+        Args:
+            drain_tx: Send frames already queued before closing.  The default
+                fails pending requests immediately, which is safer for HIL use.
+            timeout: Overall worker join timeout.  Defaults to the configured
+                ``worker_join_timeout``.
+        """
+
+        if timeout is not None and timeout < 0:
+            raise ValueError("timeout cannot be negative")
+
+        with self._lifecycle_lock:
+            current = self.state
+            if current is ConnectionState.DISCONNECTED:
+                return
+            if current in (ConnectionState.CONNECTING, ConnectionState.DISCONNECTING):
+                raise CANStateError(
+                    f"cannot disconnect while interface is {current.value}"
+                )
+
+            self._set_state(ConnectionState.DISCONNECTING)
+            self._drain_tx_on_stop = drain_tx
+            self._stop_event.set()
+            if not drain_tx:
+                self._fail_pending_tx(
+                    CANStateError("transmission cancelled by disconnect"),
+                    dropped=True,
+                )
+
+            join_budget = self.config.worker_join_timeout if timeout is None else timeout
+            deadline = time.monotonic() + join_budget
+            live_threads: list[str] = []
+            for worker in (self._rx_thread, self._tx_thread):
+                if worker is None or worker is threading.current_thread():
+                    continue
+                worker.join(max(0.0, deadline - time.monotonic()))
+                if worker.is_alive():
+                    live_threads.append(worker.name)
+
+            close_error: BaseException | None = None
+            try:
+                self._close_hardware()
+            except Exception as exc:
+                close_error = exc
+            finally:
+                self._fail_pending_tx(
+                    CANStateError("interface disconnected before transmission"),
+                    dropped=True,
+                )
+                self._rx_thread = None
+                self._tx_thread = None
+                self._drain_tx_on_stop = False
+                self._set_state(ConnectionState.DISCONNECTED)
+
+            problems: list[str] = []
+            if live_threads:
+                problems.append(f"workers did not stop: {', '.join(live_threads)}")
+            if close_error is not None:
+                problems.append(f"hardware close failed: {close_error}")
+            if problems:
+                error = CANDisconnectionError("; ".join(problems))
+                with self._state_lock:
+                    self._last_error = error
+                raise error from close_error
+
+    def capture(
+        self,
+        *,
+        max_frames: int = 1,
+        timeout: float | None = None,
+    ) -> list[CANFrame]:
+        """Return up to ``max_frames`` received frames from the RX queue.
+
+        With a finite timeout the method returns a partial batch when the
+        deadline expires.  ``timeout=0`` performs a non-blocking queue drain;
+        ``timeout=None`` waits until the requested batch is complete.
+        """
+
+        if max_frames <= 0:
+            raise ValueError("max_frames must be positive")
+        if timeout is not None and timeout < 0:
+            raise ValueError("timeout cannot be negative")
+        self._require_connected("capture")
+
+        deadline = None if timeout is None else time.monotonic() + timeout
+        frames: list[CANFrame] = []
+        while len(frames) < max_frames:
+            try:
+                if timeout == 0:
+                    frame = self._rx_queue.get_nowait()
+                else:
+                    frame = self._wait_for_rx_frame(deadline)
+            except queue.Empty:
+                break
+            frames.append(frame)
+            self._rx_queue.task_done()
+
+        if frames:
+            self._increment_stat("_rx_delivered", len(frames))
+        return frames
+
+    def send(
+        self,
+        frames: CANFrame | Iterable[CANFrame],
+        *,
+        block: bool = False,
+        timeout: float | None = None,
+    ) -> int:
+        """Queue one frame or an iterable of frames for ordered transmission.
+
+        ``block=True`` waits for the hardware write result of every frame.
+        The timeout is an overall deadline covering queue admission and, when
+        blocking, transmission completion.
+        """
+
+        if timeout is not None and timeout < 0:
+            raise ValueError("timeout cannot be negative")
+        self._require_connected("send")
+
+        if isinstance(frames, CANFrame):
+            frame_batch = (frames,)
+        else:
+            frame_batch = tuple(frames)
+            if not all(isinstance(frame, CANFrame) for frame in frame_batch):
+                raise TypeError("send expects CANFrame objects")
+        if not frame_batch:
+            return 0
+
+        deadline = None if timeout is None else time.monotonic() + timeout
+        requests: list[_TxRequest] = []
+        for frame in frame_batch:
+            request = _TxRequest(frame=frame)
+            self._enqueue_tx(request, deadline)
+            requests.append(request)
+            self._increment_stat("_tx_queued")
+
+        if block:
+            for request in requests:
+                self._wait_for_tx_request(request, deadline)
+        return len(requests)
+
+    def __enter__(self) -> "CANInterfaceBase":
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc, traceback) -> None:
+        self.disconnect()
+
+    def _wait_for_rx_frame(self, deadline: float | None) -> CANFrame:
+        while True:
+            current = self.state
+            if current is ConnectionState.ERROR:
+                error = self.last_error
+                raise CANReceiveError(f"receive worker stopped: {error}") from error
+            if current is not ConnectionState.CONNECTED:
+                raise CANStateError(f"capture requires connected state, got {current.value}")
+
+            if deadline is None:
+                wait_time = min(self.config.receive_timeout, 0.05)
+            else:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise queue.Empty
+                wait_time = min(remaining, self.config.receive_timeout, 0.05)
+            try:
+                return self._rx_queue.get(timeout=wait_time)
+            except queue.Empty:
+                if deadline is not None and time.monotonic() >= deadline:
+                    raise
+
+    def _enqueue_tx(self, request: _TxRequest, deadline: float | None) -> None:
+        policy = self.config.tx_overflow_policy
+        if policy is OverflowPolicy.RAISE:
+            try:
+                self._tx_queue.put_nowait(request)
+            except queue.Full as exc:
+                raise CANQueueFullError("transmit queue is full") from exc
+            return
+
+        if policy is OverflowPolicy.DROP_OLDEST:
+            while True:
+                try:
+                    self._tx_queue.put_nowait(request)
+                    return
+                except queue.Full:
+                    try:
+                        dropped = self._tx_queue.get_nowait()
+                    except queue.Empty:
+                        continue
+                    self._complete_tx(
+                        dropped,
+                        CANQueueFullError("transmit request dropped by overflow policy"),
+                        dropped=True,
+                    )
+                    self._tx_queue.task_done()
+
+        while True:
+            self._require_connected("send")
+            if deadline is None:
+                wait_time = 0.05
+            else:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise CANQueueFullError("timed out waiting for transmit queue space")
+                wait_time = min(remaining, 0.05)
+            try:
+                self._tx_queue.put(request, timeout=wait_time)
+                return
+            except queue.Full:
+                if deadline is not None and time.monotonic() >= deadline:
+                    raise CANQueueFullError(
+                        "timed out waiting for transmit queue space"
+                    )
+
+    def _wait_for_tx_request(
+        self, request: _TxRequest, deadline: float | None
+    ) -> None:
+        while not request.completion.is_set():
+            if deadline is None:
+                wait_time = 0.05
+            else:
+                remaining = deadline - time.monotonic()
+                if remaining <= 0:
+                    raise CANTimeoutError("timed out waiting for CAN transmission")
+                wait_time = min(remaining, 0.05)
+            request.completion.wait(wait_time)
+        if request.error is not None:
+            if isinstance(request.error, CANBaseError):
+                raise request.error
+            raise CANTransmissionError(str(request.error)) from request.error
+
+    def _rx_worker(self) -> None:
+        try:
+            while not self._stop_event.is_set():
+                frames = self._receive_batch_from_hardware(
+                    timeout=self.config.receive_timeout,
+                    max_frames=self.config.rx_batch_size,
+                )
+                for frame in frames:
+                    if not isinstance(frame, CANFrame):
+                        raise CANReceiveError(
+                            "hardware adapter returned a non-CANFrame value"
+                        )
+                    self._increment_stat("_rx_received")
+                    self._enqueue_rx(frame)
+                    if self._stop_event.is_set():
+                        break
+        except Exception as exc:
+            if not self._stop_event.is_set():
+                error = (
+                    exc
+                    if isinstance(exc, CANReceiveError)
+                    else CANReceiveError(f"receive worker failed: {exc}")
+                )
+                self._record_fatal_error(error)
+
+    def _enqueue_rx(self, frame: CANFrame) -> None:
+        policy = self.config.rx_overflow_policy
+        if policy is OverflowPolicy.BLOCK:
+            while not self._stop_event.is_set():
+                try:
+                    self._rx_queue.put(frame, timeout=0.05)
+                    return
+                except queue.Full:
+                    continue
+            self._increment_stat("_rx_dropped")
+            return
+
+        if policy is OverflowPolicy.RAISE:
+            try:
+                self._rx_queue.put_nowait(frame)
+            except queue.Full as exc:
+                self._increment_stat("_rx_dropped")
+                raise CANQueueFullError("receive queue is full") from exc
+            return
+
+        while True:
+            try:
+                self._rx_queue.put_nowait(frame)
+                return
+            except queue.Full:
+                try:
+                    self._rx_queue.get_nowait()
+                except queue.Empty:
+                    continue
+                self._rx_queue.task_done()
+                self._increment_stat("_rx_dropped")
+
+    def _tx_worker(self) -> None:
+        fatal_error: BaseException | None = None
+        while True:
+            if self._stop_event.is_set() and (
+                not self._drain_tx_on_stop or self._tx_queue.empty()
+            ):
+                break
+            try:
+                first = self._tx_queue.get(timeout=0.05)
+            except queue.Empty:
+                continue
+
+            batch = [first]
+            for _ in range(self.config.tx_batch_size - 1):
+                try:
+                    batch.append(self._tx_queue.get_nowait())
+                except queue.Empty:
+                    break
+
+            for request in batch:
+                if fatal_error is not None:
+                    self._complete_tx(request, fatal_error, dropped=True)
+                    self._tx_queue.task_done()
+                    continue
+                if self._stop_event.is_set() and not self._drain_tx_on_stop:
+                    self._complete_tx(
+                        request,
+                        CANStateError("transmission cancelled by disconnect"),
+                        dropped=True,
+                    )
+                    self._tx_queue.task_done()
+                    continue
+                try:
+                    self._write_frame_to_hardware(request.frame)
+                except CANTransmissionError as exc:
+                    self._complete_tx(request, exc)
+                except Exception as exc:
+                    fatal_error = CANTransmissionError(
+                        f"transmit worker failed: {exc}"
+                    )
+                    self._complete_tx(request, fatal_error)
+                else:
+                    self._complete_tx(request)
+                finally:
+                    self._tx_queue.task_done()
+
+            if fatal_error is not None:
+                self._record_fatal_error(fatal_error)
+                break
+
+        self._fail_pending_tx(
+            fatal_error or CANStateError("transmit worker stopped"),
+            dropped=True,
+        )
+
+    def _complete_tx(
+        self,
+        request: _TxRequest,
+        error: BaseException | None = None,
+        *,
+        dropped: bool = False,
+    ) -> None:
+        if request.completion.is_set():
+            return
+        request.error = error
+        request.completion.set()
+        if error is None:
+            self._increment_stat("_tx_sent")
+        else:
+            self._increment_stat("_tx_failed")
+            if dropped:
+                self._increment_stat("_tx_dropped")
+
+    def _fail_pending_tx(self, error: BaseException, *, dropped: bool) -> None:
+        while True:
+            try:
+                request = self._tx_queue.get_nowait()
+            except queue.Empty:
+                return
+            self._complete_tx(request, error, dropped=dropped)
+            self._tx_queue.task_done()
+
+    def _record_fatal_error(self, error: BaseException) -> None:
+        with self._state_lock:
+            self._last_error = error
+            if self._state not in (
+                ConnectionState.DISCONNECTING,
+                ConnectionState.DISCONNECTED,
+            ):
+                self._state = ConnectionState.ERROR
+        self._stop_event.set()
+        self._logger.error("CAN worker stopped: %s", error)
+
+    def _require_connected(self, operation: str) -> None:
+        current = self.state
+        if current is not ConnectionState.CONNECTED:
+            raise CANStateError(
+                f"{operation} requires connected state, got {current.value}"
+            )
+
+    def _set_state(self, state: ConnectionState) -> None:
+        with self._state_lock:
+            self._state = state
+
+    def _increment_stat(self, attribute: str, value: int = 1) -> None:
+        with self._statistics_lock:
+            setattr(self, attribute, getattr(self, attribute) + value)
+
+    @abstractmethod
+    def _open_hardware(self) -> None:
+        """Initialize the concrete CAN hardware connection."""
+
+    @abstractmethod
+    def _close_hardware(self) -> None:
+        """Release concrete CAN hardware resources; must be idempotent."""
+
+    @abstractmethod
+    def _receive_batch_from_hardware(
+        self, *, timeout: float, max_frames: int
+    ) -> list[CANFrame]:
+        """Block for the first frame, then return up to ``max_frames``."""
+
+    @abstractmethod
+    def _write_frame_to_hardware(self, frame: CANFrame) -> None:
+        """Synchronously submit one frame to the hardware driver."""

code/attack_generation/src/ivcan_attacker/can_base/exceptions.py

@@ -0,0 +1,43 @@
+"""Exceptions raised by the CAN base layer."""
+
+from __future__ import annotations
+
+
+class CANBaseError(Exception):
+    """Base class for all errors exposed by :mod:`can_base`."""
+
+
+class CANConfigurationError(CANBaseError, ValueError):
+    """The interface configuration is invalid."""
+
+
+class CANDependencyError(CANBaseError, ImportError):
+    """A required driver or Python package is unavailable."""
+
+
+class CANStateError(CANBaseError, RuntimeError):
+    """An operation is not valid in the current connection state."""
+
+
+class CANConnectionError(CANBaseError, ConnectionError):
+    """Opening or maintaining the hardware connection failed."""
+
+
+class CANDisconnectionError(CANBaseError, ConnectionError):
+    """The hardware connection could not be closed cleanly."""
+
+
+class CANReceiveError(CANBaseError, OSError):
+    """Receiving a CAN frame failed."""
+
+
+class CANTransmissionError(CANBaseError, OSError):
+    """Transmitting a CAN frame failed."""
+
+
+class CANQueueFullError(CANBaseError):
+    """A bounded receive or transmit queue has no free capacity."""
+
+
+class CANTimeoutError(CANBaseError, TimeoutError):
+    """An operation did not complete before its deadline."""

code/attack_generation/src/ivcan_attacker/can_base/pcan_interface.py

@@ -0,0 +1,292 @@
+"""PEAK PCAN adapter implemented through python-can's PCAN backend."""
+
+from __future__ import annotations
+
+import importlib
+import os
+import struct
+from dataclasses import dataclass
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+from .can_interface_base import CANInterfaceBase
+from .exceptions import (
+    CANConfigurationError,
+    CANConnectionError,
+    CANDependencyError,
+    CANDisconnectionError,
+    CANReceiveError,
+    CANStateError,
+    CANTransmissionError,
+)
+from .types import CANFrame, CANInterfaceConfig, ConnectionState
+
+
+@dataclass(frozen=True, slots=True)
+class PCANInterfaceConfig(CANInterfaceConfig):
+    """PCAN-specific connection and CAN FD timing parameters.
+
+    The default FD timing reproduces the 500 kbit/s nominal and 2 Mbit/s data
+    settings found in the legacy repository.
+    """
+
+    device_id: int | None = None
+    listen_only: bool = False
+    receive_own_messages: bool = False
+    auto_reset: bool = False
+    dll_path: str | Path | None = None
+    use_bundled_dll: bool = False
+
+    data_bitrate: int = 2_000_000
+    fd_clock_mhz: int = 80
+    nom_brp: int = 2
+    nom_tseg1: int = 63
+    nom_tseg2: int = 16
+    nom_sjw: int = 16
+    data_brp: int = 2
+    data_tseg1: int = 15
+    data_tseg2: int = 4
+    data_sjw: int = 4
+
+    def __post_init__(self) -> None:
+        CANInterfaceConfig.__post_init__(self)
+        if self.device_id is not None and self.device_id < 0:
+            raise CANConfigurationError("device_id cannot be negative")
+        if self.dll_path is not None:
+            object.__setattr__(self, "dll_path", Path(self.dll_path).expanduser())
+        if self.data_bitrate <= 0:
+            raise CANConfigurationError("data_bitrate must be positive")
+
+        ranges = {
+            "fd_clock_mhz": (1, None),
+            "nom_brp": (1, 1024),
+            "nom_tseg1": (1, 256),
+            "nom_tseg2": (1, 128),
+            "nom_sjw": (1, 128),
+            "data_brp": (1, 1024),
+            "data_tseg1": (1, 32),
+            "data_tseg2": (1, 16),
+            "data_sjw": (1, 16),
+        }
+        for field_name, (minimum, maximum) in ranges.items():
+            value = getattr(self, field_name)
+            if value < minimum or (maximum is not None and value > maximum):
+                upper = f"..{maximum}" if maximum is not None else " or greater"
+                raise CANConfigurationError(
+                    f"{field_name} must be in range {minimum}{upper}"
+                )
+        if self.nom_sjw > self.nom_tseg2:
+            raise CANConfigurationError("nom_sjw cannot exceed nom_tseg2")
+        if self.data_sjw > self.data_tseg2:
+            raise CANConfigurationError("data_sjw cannot exceed data_tseg2")
+
+        if self.fd:
+            clock_hz = self.fd_clock_mhz * 1_000_000
+            nominal = clock_hz / (
+                self.nom_brp * (1 + self.nom_tseg1 + self.nom_tseg2)
+            )
+            data = clock_hz / (
+                self.data_brp * (1 + self.data_tseg1 + self.data_tseg2)
+            )
+            if nominal != self.bitrate:
+                raise CANConfigurationError(
+                    "FD nominal timing resolves to "
+                    f"{nominal:g} bit/s, not configured bitrate {self.bitrate}"
+                )
+            if data != self.data_bitrate:
+                raise CANConfigurationError(
+                    "FD data timing resolves to "
+                    f"{data:g} bit/s, not configured data_bitrate {self.data_bitrate}"
+                )
+
+
+class PCANInterface(CANInterfaceBase):
+    """Full-duplex interface for PEAK PCAN hardware."""
+
+    config: PCANInterfaceConfig
+
+    def __init__(self, config: PCANInterfaceConfig, **kwargs: Any) -> None:
+        super().__init__(config, **kwargs)
+        self._can_module: ModuleType | None = None
+        self._bus: Any | None = None
+        self._dll_directory_handle: Any | None = None
+
+    @property
+    def bundled_dll_path(self) -> Path:
+        """Return the optional DLL path expected by legacy deployments.
+
+        The public reproducibility package intentionally does not redistribute
+        PEAK-System's third-party binary.
+        """
+
+        return Path(__file__).resolve().parent / "native" / "x64" / "PCANBasic.dll"
+
+    def status(self) -> int:
+        """Return the raw PCAN bus status code."""
+
+        self._require_connected("status")
+        status_method = getattr(self._bus, "status", None)
+        if status_method is None:
+            raise CANStateError("the active backend does not expose PCAN status")
+        return int(status_method())
+
+    def status_string(self) -> str | None:
+        """Return the PCAN status description when available."""
+
+        self._require_connected("status_string")
+        method = getattr(self._bus, "status_string", None)
+        return None if method is None else method()
+
+    def flash(self, enabled: bool) -> None:
+        """Enable or disable the identification LED on the PCAN adapter."""
+
+        self._require_connected("flash")
+        method = getattr(self._bus, "flash", None)
+        if method is None:
+            raise CANStateError("the active backend does not support device flashing")
+        method(enabled)
+
+    def _open_hardware(self) -> None:
+        self._prepare_windows_dll_search()
+        try:
+            can_module = importlib.import_module("can")
+        except ImportError as exc:
+            self._release_dll_directory()
+            raise CANDependencyError(
+                "python-can is not installed; run `python -m pip install -e .`"
+            ) from exc
+
+        kwargs: dict[str, Any] = {
+            "interface": "pcan",
+            "channel": self.config.channel,
+            "state": (
+                can_module.BusState.PASSIVE
+                if self.config.listen_only
+                else can_module.BusState.ACTIVE
+            ),
+            "receive_own_messages": self.config.receive_own_messages,
+            "auto_reset": self.config.auto_reset,
+        }
+        if self.config.device_id is not None:
+            kwargs["device_id"] = self.config.device_id
+
+        if self.config.fd:
+            kwargs.update(
+                fd=True,
+                f_clock_mhz=self.config.fd_clock_mhz,
+                nom_brp=self.config.nom_brp,
+                nom_tseg1=self.config.nom_tseg1,
+                nom_tseg2=self.config.nom_tseg2,
+                nom_sjw=self.config.nom_sjw,
+                data_brp=self.config.data_brp,
+                data_tseg1=self.config.data_tseg1,
+                data_tseg2=self.config.data_tseg2,
+                data_sjw=self.config.data_sjw,
+            )
+        else:
+            kwargs.update(fd=False, bitrate=self.config.bitrate)
+
+        try:
+            bus = can_module.Bus(**kwargs)
+        except Exception as exc:
+            self._release_dll_directory()
+            raise CANConnectionError(f"PCAN initialization failed: {exc}") from exc
+        self._can_module = can_module
+        self._bus = bus
+
+    def _close_hardware(self) -> None:
+        bus, self._bus = self._bus, None
+        self._can_module = None
+        try:
+            if bus is not None:
+                bus.shutdown()
+        except Exception as exc:
+            raise CANDisconnectionError(f"PCAN shutdown failed: {exc}") from exc
+        finally:
+            self._release_dll_directory()
+
+    def _receive_batch_from_hardware(
+        self, *, timeout: float, max_frames: int
+    ) -> list[CANFrame]:
+        bus = self._bus
+        if bus is None:
+            raise CANReceiveError("PCAN bus is not initialized")
+        try:
+            first = bus.recv(timeout)
+            if first is None:
+                return []
+            messages = [first]
+            for _ in range(max_frames - 1):
+                message = bus.recv(0.0)
+                if message is None:
+                    break
+                messages.append(message)
+        except Exception as exc:
+            raise CANReceiveError(f"PCAN receive failed: {exc}") from exc
+        return [self._from_python_can(message) for message in messages]
+
+    def _write_frame_to_hardware(self, frame: CANFrame) -> None:
+        bus = self._bus
+        can_module = self._can_module
+        if bus is None or can_module is None:
+            raise CANTransmissionError("PCAN bus is not initialized")
+        try:
+            message = can_module.Message(
+                arbitration_id=frame.arbitration_id,
+                data=frame.data,
+                is_extended_id=frame.is_extended_id,
+                is_fd=frame.is_fd,
+                bitrate_switch=frame.bitrate_switch,
+                error_state_indicator=frame.error_state_indicator,
+                is_remote_frame=frame.is_remote_frame,
+                is_error_frame=frame.is_error_frame,
+                check=True,
+            )
+            bus.send(message, timeout=self.config.send_timeout)
+        except Exception as exc:
+            raise CANTransmissionError(
+                f"PCAN send failed for 0x{frame.arbitration_id:X}: {exc}"
+            ) from exc
+
+    @staticmethod
+    def _from_python_can(message: Any) -> CANFrame:
+        return CANFrame(
+            arbitration_id=int(message.arbitration_id),
+            data=bytes(message.data),
+            timestamp=float(message.timestamp),
+            is_extended_id=bool(message.is_extended_id),
+            is_fd=bool(message.is_fd),
+            bitrate_switch=bool(message.bitrate_switch),
+            error_state_indicator=bool(message.error_state_indicator),
+            is_remote_frame=bool(message.is_remote_frame),
+            is_error_frame=bool(message.is_error_frame),
+        )
+
+    def _prepare_windows_dll_search(self) -> None:
+        if os.name != "nt":
+            return
+        dll_path = self.config.dll_path
+        if dll_path is None and self.config.use_bundled_dll:
+            dll_path = self.bundled_dll_path
+        if dll_path is None:
+            return
+
+        dll_path = Path(dll_path).resolve()
+        if not dll_path.is_file():
+            raise CANDependencyError(f"PCANBasic.dll not found: {dll_path}")
+        if struct.calcsize("P") != 8 and dll_path.parent.name.lower() == "x64":
+            raise CANDependencyError(
+                "the bundled PCANBasic.dll is x64 but the Python process is 32-bit"
+            )
+        try:
+            self._dll_directory_handle = os.add_dll_directory(str(dll_path.parent))
+        except OSError as exc:
+            raise CANDependencyError(
+                f"could not add PCAN DLL directory {dll_path.parent}: {exc}"
+            ) from exc
+
+    def _release_dll_directory(self) -> None:
+        handle, self._dll_directory_handle = self._dll_directory_handle, None
+        if handle is not None:
+            handle.close()

code/attack_generation/src/ivcan_attacker/can_base/types.py

@@ -0,0 +1,153 @@
+"""Vendor-neutral value objects used by CAN interfaces."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from enum import Enum
+
+from .exceptions import CANConfigurationError
+
+
+class ConnectionState(str, Enum):
+    """Lifecycle states shared by all CAN interface implementations."""
+
+    DISCONNECTED = "disconnected"
+    CONNECTING = "connecting"
+    CONNECTED = "connected"
+    DISCONNECTING = "disconnecting"
+    ERROR = "error"
+
+
+class OverflowPolicy(str, Enum):
+    """Behaviour when one of the bounded in-memory queues is full."""
+
+    BLOCK = "block"
+    DROP_OLDEST = "drop_oldest"
+    RAISE = "raise"
+
+
+@dataclass(frozen=True, slots=True)
+class CANFrame:
+    """An immutable Classic CAN or CAN FD frame.
+
+    ``timestamp`` is receive metadata expressed in seconds.  It is not used to
+    schedule transmission; scheduling belongs in a higher-level component.
+    """
+
+    arbitration_id: int
+    data: bytes = b""
+    timestamp: float | None = None
+    is_extended_id: bool = False
+    is_fd: bool = False
+    bitrate_switch: bool = False
+    error_state_indicator: bool = False
+    is_remote_frame: bool = False
+    is_error_frame: bool = False
+
+    def __post_init__(self) -> None:
+        if isinstance(self.data, int):
+            raise CANConfigurationError("frame data must be bytes or an iterable of bytes")
+        try:
+            payload = bytes(self.data)
+        except (TypeError, ValueError) as exc:
+            raise CANConfigurationError("frame data contains an invalid byte") from exc
+        object.__setattr__(self, "data", payload)
+
+        maximum_id = 0x1FFFFFFF if self.is_extended_id else 0x7FF
+        if not 0 <= self.arbitration_id <= maximum_id:
+            id_kind = "29-bit" if self.is_extended_id else "11-bit"
+            raise CANConfigurationError(
+                f"arbitration_id must fit in a {id_kind} CAN identifier"
+            )
+
+        maximum_length = 64 if self.is_fd else 8
+        if len(payload) > maximum_length:
+            frame_kind = "CAN FD" if self.is_fd else "Classic CAN"
+            raise CANConfigurationError(
+                f"{frame_kind} payload cannot exceed {maximum_length} bytes"
+            )
+        if self.is_remote_frame and payload:
+            raise CANConfigurationError("remote frames cannot carry payload bytes")
+        if self.is_fd and self.is_remote_frame:
+            raise CANConfigurationError("CAN FD does not support remote frames")
+        if not self.is_fd and (self.bitrate_switch or self.error_state_indicator):
+            raise CANConfigurationError("BRS and ESI flags require a CAN FD frame")
+        if self.timestamp is not None and (
+            not math.isfinite(self.timestamp) or self.timestamp < 0
+        ):
+            raise CANConfigurationError("timestamp must be a finite non-negative value")
+
+    @property
+    def dlc(self) -> int:
+        """Return the payload length represented by this value object."""
+
+        return len(self.data)
+
+
+@dataclass(frozen=True, slots=True)
+class CANInterfaceConfig:
+    """Concurrency and bus settings understood by the base class."""
+
+    channel: str | int = "PCAN_USBBUS1"
+    bitrate: int = 500_000
+    fd: bool = False
+    rx_queue_size: int = 8192
+    tx_queue_size: int = 2048
+    rx_batch_size: int = 256
+    tx_batch_size: int = 64
+    receive_timeout: float = 0.05
+    send_timeout: float | None = 0.1
+    worker_join_timeout: float = 2.0
+    rx_overflow_policy: OverflowPolicy = OverflowPolicy.DROP_OLDEST
+    tx_overflow_policy: OverflowPolicy = OverflowPolicy.BLOCK
+    thread_name_prefix: str = "can-interface"
+
+    def __post_init__(self) -> None:
+        if isinstance(self.channel, str):
+            if not self.channel.strip():
+                raise CANConfigurationError("channel cannot be empty")
+        elif not isinstance(self.channel, int) or self.channel < 0:
+            raise CANConfigurationError("channel must be a non-empty string or integer")
+        if self.bitrate <= 0:
+            raise CANConfigurationError("bitrate must be positive")
+
+        for field_name in (
+            "rx_queue_size",
+            "tx_queue_size",
+            "rx_batch_size",
+            "tx_batch_size",
+        ):
+            if getattr(self, field_name) <= 0:
+                raise CANConfigurationError(f"{field_name} must be positive")
+        if self.receive_timeout <= 0:
+            raise CANConfigurationError("receive_timeout must be positive")
+        if self.send_timeout is not None and self.send_timeout <= 0:
+            raise CANConfigurationError("send_timeout must be positive or None")
+        if self.worker_join_timeout <= 0:
+            raise CANConfigurationError("worker_join_timeout must be positive")
+        if not self.thread_name_prefix.strip():
+            raise CANConfigurationError("thread_name_prefix cannot be empty")
+
+        for field_name in ("rx_overflow_policy", "tx_overflow_policy"):
+            value = getattr(self, field_name)
+            if not isinstance(value, OverflowPolicy):
+                try:
+                    object.__setattr__(self, field_name, OverflowPolicy(value))
+                except ValueError as exc:
+                    raise CANConfigurationError(
+                        f"unsupported {field_name}: {value!r}"
+                    ) from exc
+
+
+@dataclass(frozen=True, slots=True)
+class CANStatistics:
+    """Atomic snapshot of interface counters."""
+
+    rx_received: int = 0
+    rx_delivered: int = 0
+    rx_dropped: int = 0
+    tx_queued: int = 0
+    tx_sent: int = 0
+    tx_failed: int = 0
+    tx_dropped: int = 0

code/attack_generation/src/ivcan_attacker/cli.py

@@ -0,0 +1,285 @@
+#!/usr/bin/env python3
+"""Safety-oriented CLI for reproducing IV-CAN attack configurations.
+
+Example:
+    ivcan-attack --type DoS --id-option zeroId \
+        --dlc-option dlcChange --frame-format standardId \
+        --data-option FFData --duration 10
+
+The default mode only validates and previews a request. Hardware transmission
+requires both ``--execute`` and ``--acknowledge-bench-only``.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+from pathlib import Path
+
+from .attack_runtime import (
+    AttackRequest,
+    AttackRunner,
+    parse_can_id,
+    parse_payload,
+)
+from .can_base import PCANInterface, PCANInterfaceConfig
+from .attack_types import (
+    AttackBaseType,
+    AttackType,
+    DoSConfig,
+    DoSOptionDLC,
+    DoSOptionData,
+    DoSOptionExt,
+    DoSOptionId,
+    FuzzConfig,
+    FuzzOptionDLC,
+    FuzzOptionId,
+    ReplayConfig,
+    ReplayOption,
+    SuspensionConfig,
+)
+
+
+def _attack_kind(value: str) -> AttackBaseType:
+    aliases = {
+        "dos": AttackBaseType.DOS,
+        "fuzz": AttackBaseType.FUZZ,
+        "fuzzing": AttackBaseType.FUZZ,
+        "replay": AttackBaseType.REPLAY,
+        "spoofing": AttackBaseType.SPOOFING,
+        "suspension": AttackBaseType.SUSPENSION,
+        "masquerade": AttackBaseType.MASQUERADE,
+    }
+    try:
+        return aliases[value.strip().lower()]
+    except KeyError as exc:
+        options = ", ".join(kind.value for kind in AttackBaseType)
+        raise argparse.ArgumentTypeError(
+            f"unknown attack type {value!r}; choose from {options}"
+        ) from exc
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description=(
+            "Validate and preview IV-CAN attack configurations. Hardware execution "
+            "is restricted to explicitly acknowledged isolated test benches."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("--type", required=True, type=_attack_kind, dest="attack_kind")
+
+    runtime = parser.add_argument_group("runtime")
+    runtime.add_argument(
+        "--duration",
+        type=float,
+        default=10.0,
+        help="generated attack duration in seconds",
+    )
+    runtime.add_argument(
+        "--interval",
+        type=float,
+        default=0.01,
+        help="interval between generated frames",
+    )
+    runtime.add_argument("--seed", type=int, help="deterministic random seed")
+    runtime.add_argument(
+        "--execute",
+        action="store_true",
+        help="transmit on CAN hardware instead of the default dry-run preview",
+    )
+    runtime.add_argument(
+        "--acknowledge-bench-only",
+        action="store_true",
+        help="confirm execution is limited to an authorized isolated test bench",
+    )
+    runtime.add_argument(
+        "--preview-count",
+        type=int,
+        default=3,
+        help="sample frames shown in dry-run mode",
+    )
+
+    hardware = parser.add_argument_group("CAN hardware")
+    hardware.add_argument("--channel", default="PCAN_USBBUS1")
+    hardware.add_argument("--bitrate", type=int, default=500_000)
+    hardware.add_argument("--fd", action="store_true", help="use CAN FD")
+    hardware.add_argument("--data-bitrate", type=int, default=2_000_000)
+    hardware.add_argument(
+        "--extended-id",
+        action="store_true",
+        help="use a 29-bit ID where the attack type does not define frame format",
+    )
+
+    frame = parser.add_argument_group("frame values")
+    frame.add_argument(
+        "--can-id",
+        type=parse_can_id,
+        help="active/target CAN ID, decimal or 0x-prefixed",
+    )
+    frame.add_argument("--dlc", type=int, help="original or fixed payload length")
+    frame.add_argument("--data", type=parse_payload, help="hexadecimal payload, e.g. '11 22 FF'")
+
+    dos = parser.add_argument_group("DoS options (Table II)")
+    id_option_choices = sorted(
+        {item.value for item in DoSOptionId} | {item.value for item in FuzzOptionId}
+    )
+    dos.add_argument("--id-option", choices=id_option_choices)
+    dos.add_argument("--dlc-option", choices=[item.value for item in DoSOptionDLC])
+    dos.add_argument("--frame-format", choices=[item.value for item in DoSOptionExt])
+    dos.add_argument("--data-option", choices=[item.value for item in DoSOptionData])
+
+    replay = parser.add_argument_group("replay options")
+    replay.add_argument("--timing", choices=[item.value for item in ReplayOption])
+    replay.add_argument("--replay-file", type=Path, help="IV-CAN-style CSV file")
+    replay.add_argument(
+        "--replay-delay",
+        type=float,
+        default=0.0,
+        help="start delay for delayed replay",
+    )
+
+    suspension = parser.add_argument_group("suspension options")
+    suspension.add_argument(
+        "--target-ids",
+        nargs="+",
+        type=parse_can_id,
+        help="active CAN IDs suppressed by the MitM bridge",
+    )
+    suspension.add_argument(
+        "--suspension-duration",
+        type=int,
+        help="suppression interval in seconds",
+    )
+    return parser
+
+
+def _required(parser: argparse.ArgumentParser, value, flag: str, attack: str):
+    if value is None:
+        parser.error(f"{attack} requires {flag}")
+    return value
+
+
+def _build_attack_type(args: argparse.Namespace, parser: argparse.ArgumentParser) -> AttackType:
+    kind = args.attack_kind
+    if kind is AttackBaseType.DOS:
+        return AttackType(
+            kind=kind,
+            config=DoSConfig(
+                id_option=DoSOptionId(_required(parser, args.id_option, "--id-option", "DoS")),
+                dlc_option=DoSOptionDLC(_required(parser, args.dlc_option, "--dlc-option", "DoS")),
+                ext_option=DoSOptionExt(
+                    _required(parser, args.frame_format, "--frame-format", "DoS")
+                ),
+                data_option=DoSOptionData(
+                    _required(parser, args.data_option, "--data-option", "DoS")
+                ),
+            ),
+        )
+    if kind is AttackBaseType.FUZZ:
+        return AttackType(
+            kind=kind,
+            config=FuzzConfig(
+                id_option=FuzzOptionId(
+                    _required(parser, args.id_option, "--id-option", "fuzzing")
+                ),
+                dlc_option=FuzzOptionDLC(
+                    _required(parser, args.dlc_option, "--dlc-option", "fuzzing")
+                ),
+            ),
+        )
+    if kind is AttackBaseType.REPLAY:
+        return AttackType(
+            kind=kind,
+            config=ReplayConfig(
+                timing=ReplayOption(_required(parser, args.timing, "--timing", "replay")),
+            ),
+        )
+    if kind is AttackBaseType.SUSPENSION:
+        target_ids = _required(parser, args.target_ids, "--target-ids", "suspension")
+        duration = _required(
+            parser,
+            args.suspension_duration,
+            "--suspension-duration",
+            "suspension",
+        )
+        return AttackType(
+            kind=kind,
+            config=SuspensionConfig(
+                suspension_duration_sec=duration,
+                suspension_CAN_id_list=[f"0x{value:X}" for value in target_ids],
+            ),
+        )
+    return AttackType(kind=kind)
+
+
+def _build_request(args: argparse.Namespace, parser: argparse.ArgumentParser) -> AttackRequest:
+    try:
+        attack_type = _build_attack_type(args, parser)
+        return AttackRequest(
+            attack_type=attack_type,
+            duration=args.duration,
+            interval=args.interval,
+            can_id=args.can_id,
+            dlc=args.dlc,
+            payload=args.data,
+            is_extended_id=args.extended_id,
+            is_fd=args.fd,
+            replay_file=args.replay_file,
+            replay_delay=args.replay_delay,
+            seed=args.seed,
+        )
+    except ValueError as exc:
+        parser.error(str(exc))
+
+
+def _frame_dict(frame) -> dict:
+    return {
+        "can_id": f"0x{frame.arbitration_id:X}",
+        "dlc": frame.dlc,
+        "data": frame.data.hex(" ").upper(),
+        "is_extended_id": frame.is_extended_id,
+        "is_fd": frame.is_fd,
+    }
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    request = _build_request(args, parser)
+    runner = AttackRunner()
+
+    try:
+        plan = runner.describe(request)
+        if not args.execute:
+            preview = runner.preview(request, count=args.preview_count)
+            output = {
+                "request": request.to_dict(),
+                "plan": plan,
+                "preview": [_frame_dict(frame) for frame in preview],
+            }
+            print(json.dumps(output, indent=2))
+            return 0
+
+        if not args.acknowledge_bench_only:
+            parser.error("--execute requires --acknowledge-bench-only")
+
+        logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+        logging.info("attack plan: %s", plan)
+        config = PCANInterfaceConfig(
+            channel=args.channel,
+            bitrate=args.bitrate,
+            fd=args.fd,
+            data_bitrate=args.data_bitrate,
+        )
+        with PCANInterface(config) as interface:
+            transmitted = runner.execute(request, interface)
+        logging.info("attack completed: transmitted=%d", transmitted)
+        return 0
+    except (ValueError, NotImplementedError) as exc:
+        parser.error(str(exc))
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

code/attack_generation/tests/test_cli.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import contextlib
+import io
+import json
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parents[1] / "src"))
+
+from ivcan_attacker.cli import main
+
+
+class CLITests(unittest.TestCase):
+    def test_dos_defaults_to_preview(self) -> None:
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            result = main(
+                [
+                    "--type",
+                    "DoS",
+                    "--id-option",
+                    "zeroId",
+                    "--dlc-option",
+                    "dlcChange",
+                    "--frame-format",
+                    "standardId",
+                    "--data-option",
+                    "FFData",
+                    "--seed",
+                    "7",
+                ]
+            )
+        self.assertEqual(result, 0)
+        payload = json.loads(output.getvalue())
+        self.assertEqual(payload["request"]["attack_type"]["kind"], "DoS")
+        self.assertEqual(len(payload["preview"]), 3)
+
+    def test_synthetic_replay_preview(self) -> None:
+        replay = Path(__file__).parents[1] / "examples" / "synthetic_replay.csv"
+        output = io.StringIO()
+        with contextlib.redirect_stdout(output):
+            result = main(
+                [
+                    "--type",
+                    "replay",
+                    "--timing",
+                    "immediate",
+                    "--replay-file",
+                    str(replay),
+                ]
+            )
+        self.assertEqual(result, 0)
+        self.assertEqual(len(json.loads(output.getvalue())["preview"]), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

schema/frame.schema.yaml

@@ -0,0 +1,46 @@
+$schema: "https://json-schema.org/draft/2020-12/schema"
+$id: "https://huggingface.co/datasets/IV-CAN/IV-CAN-v1/raw/main/schema/frame.schema.yaml"
+title: IV-CAN-v1 frame row
+description: Logical row schema after parsing the CSV representation.
+type: object
+additionalProperties: false
+required: [timestamp, can_id, is_extended_id, dlc, data, RX_or_TX, type, is_fd, domain, is_attack, traced_from, uuid, is_traced_attack]
+properties:
+  timestamp:
+    type: number
+    minimum: 0
+    description: Unix epoch seconds on the UTC time scale; source timezone Asia/Shanghai.
+  can_id:
+    type: string
+    pattern: '^0x(?:[0-9A-F]{4}|[0-9A-F]{8})$'
+  is_extended_id: {type: boolean}
+  dlc:
+    type: integer
+    enum: [0, 1, 2, 3, 4, 5, 6, 7, 8, 12, 16, 20, 24, 32, 48, 64]
+    description: Actual payload byte count, not an encoded DLC nibble.
+  data:
+    type: string
+    pattern: '^(?:[0-9A-F]{2}(?: [0-9A-F]{2})*)?$'
+  RX_or_TX:
+    enum: [RX, TX]
+    description: Direction relative to the recording channel.
+  type:
+    enum: [DT, FB, BI]
+    description: PEAK TRC frame type (data; FD+BRS; FD+BRS+ESI). DT may be classic or FD; use is_fd.
+  is_fd: {type: boolean}
+  domain: {type: integer, minimum: 1, maximum: 5}
+  is_attack: {type: boolean}
+  traced_from:
+    type: array
+    uniqueItems: true
+    items: {type: integer, minimum: 1}
+    description: Direct parent UUIDs in the same case only.
+  uuid: {type: integer, minimum: 1}
+  is_traced_attack: {type: boolean}
+x-cross-field-constraints:
+  - can_id width agrees with is_extended_id
+  - dlc equals the number of bytes in data
+  - FB or BI implies is_fd=true; DT permits either protocol
+  - classic CAN payload length is at most 8
+  - uuid is unique within the containing data.csv only
+  - traced_from references existing, non-self UUIDs in the same data.csv and forms an acyclic graph

schema/label.schema.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://huggingface.co/datasets/IV-CAN/IV-CAN-v1/raw/main/schema/label.schema.json",
+  "title": "IV-CAN-v1 trial label",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["group_name", "collection_duration_sec", "attacking_duration_sec", "attack_start_timestamp", "attack_end_timestamp", "data_collection_info", "data_attack_info"],
+  "properties": {
+    "group_name": {"type": "string", "pattern": "^(?:benign|dos|fuzzing|replay|spoofing|suspension|masquerade)_[0-9]{4}$"},
+    "collection_duration_sec": {"type": "number", "minimum": 0},
+    "attacking_duration_sec": {"type": "number", "minimum": 0},
+    "attack_start_timestamp": {"type": ["number", "null"], "minimum": 0},
+    "attack_end_timestamp": {"type": ["number", "null"], "minimum": 0},
+    "data_collection_info": {"$ref": "#/$defs/collection"},
+    "data_attack_info": {"oneOf": [{"type": "null"}, {"$ref": "#/$defs/attack"}]}
+  },
+  "$defs": {
+    "collection": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["avg_speed", "description", "end_place", "intelligent_driving", "road_type", "start_place"],
+      "properties": {
+        "avg_speed": {"type": "number", "minimum": 0},
+        "description": {"type": "string"},
+        "end_place": {"type": "string"},
+        "intelligent_driving": {"type": "boolean"},
+        "road_type": {"enum": ["UrbanOrdinaryRoad", "RuralRoad", "InternalRoad", "UORWithLKN", "HighwayWithLKN", "Highway", "UrbanExpressway"]},
+        "start_place": {"type": "string"}
+      }
+    },
+    "attack": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["attack_effect", "attack_type", "attacked_domain"],
+      "properties": {
+        "attacked_domain": {"type": "integer", "minimum": 1, "maximum": 5},
+        "attack_effect": {
+          "type": "object", "additionalProperties": false, "required": ["description", "level"],
+          "properties": {"description": {"type": "string"}, "level": {"enum": ["no effect", "system warning", "non-motion control compromised", "motion control compromised"]}}
+        },
+        "attack_type": {"$ref": "#/$defs/attack_type"}
+      }
+    },
+    "attack_type": {
+      "oneOf": [
+        {"type": "object", "additionalProperties": false, "required": ["kind", "config"], "properties": {"kind": {"const": "DoS"}, "config": {"$ref": "#/$defs/dos_config"}}},
+        {"type": "object", "additionalProperties": false, "required": ["kind", "config"], "properties": {"kind": {"const": "fuzzing"}, "config": {"$ref": "#/$defs/fuzz_config"}}},
+        {"type": "object", "additionalProperties": false, "required": ["kind", "config"], "properties": {"kind": {"const": "replay"}, "config": {"$ref": "#/$defs/replay_config"}}},
+        {"type": "object", "additionalProperties": false, "required": ["kind", "config"], "properties": {"kind": {"const": "suspension"}, "config": {"$ref": "#/$defs/suspension_config"}}},
+        {"type": "object", "additionalProperties": false, "required": ["kind", "config"], "properties": {"kind": {"enum": ["spoofing", "masquerade"]}, "config": {"type": "null"}}}
+      ]
+    },
+    "dos_config": {
+      "type": "object", "additionalProperties": false, "required": ["id_option", "dlc_option", "ext_option", "data_option"],
+      "properties": {"id_option": {"enum": ["aliveId", "zeroId"]}, "dlc_option": {"enum": ["dlcChange", "dlcKeep"]}, "ext_option": {"enum": ["extendedId", "standardId"]}, "data_option": {"enum": ["FFData", "randomData"]}}
+    },
+    "fuzz_config": {
+      "type": "object", "additionalProperties": false, "required": ["id_option", "dlc_option"],
+      "properties": {"id_option": {"enum": ["aliveId", "randomId"]}, "dlc_option": {"enum": ["dlcChange", "dlcKeep"]}}
+    },
+    "replay_config": {
+      "type": "object", "additionalProperties": false, "required": ["timing"],
+      "properties": {"timing": {"enum": ["delay", "immediate"]}}
+    },
+    "suspension_config": {
+      "type": "object", "additionalProperties": false, "required": ["suspension_CAN_id_list", "suspension_duration_sec"],
+      "properties": {"suspension_duration_sec": {"type": "number", "exclusiveMinimum": 0}, "suspension_CAN_id_list": {"type": "array", "minItems": 1, "uniqueItems": true, "items": {"type": "string", "pattern": "^0x(?:[0-9A-F]{4}|[0-9A-F]{8})$"}}}
+    }
+  }
+}

tools/validate_dataset.py

@@ -0,0 +1,301 @@
+#!/usr/bin/env python3
+"""Validate IV-CAN-v1 labels and frame CSVs without loading tables into memory."""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import csv
+import json
+import math
+import re
+import sys
+from pathlib import Path
+from typing import Any, Iterable
+
+try:
+    import yaml
+except ImportError as exc:  # pragma: no cover
+    raise SystemExit("PyYAML is required: python -m pip install PyYAML") from exc
+
+
+COLUMNS = [
+    "timestamp", "can_id", "is_extended_id", "dlc", "data", "RX_or_TX",
+    "type", "is_fd", "domain", "is_attack", "traced_from", "uuid",
+    "is_traced_attack",
+]
+BOOL = {"True": True, "False": False}
+CAN_ID = re.compile(r"^0x(?:[0-9A-F]{4}|[0-9A-F]{8})$")
+BYTE_STRING = re.compile(r"^(?:[0-9A-F]{2}(?: [0-9A-F]{2})*)?$")
+CLASSIC_LENGTHS = set(range(9))
+FD_LENGTHS = CLASSIC_LENGTHS | {12, 16, 20, 24, 32, 48, 64}
+ROAD_TYPES = {
+    "UrbanOrdinaryRoad", "RuralRoad", "InternalRoad", "UORWithLKN",
+    "HighwayWithLKN", "Highway", "UrbanExpressway",
+}
+ATTACK_TYPES = {"DoS", "fuzzing", "replay", "spoofing", "suspension", "masquerade"}
+EFFECT_LEVELS = {
+    "no effect", "system warning", "non-motion control compromised",
+    "motion control compromised",
+}
+
+
+class Problems:
+    def __init__(self) -> None:
+        self.items: list[str] = []
+
+    def add(self, path: Path, message: str, row: int | None = None) -> None:
+        where = f"{path}:{row}" if row is not None else str(path)
+        self.items.append(f"{where}: {message}")
+
+
+def require_keys(value: Any, keys: set[str], path: Path, problems: Problems, context: str) -> bool:
+    if not isinstance(value, dict):
+        problems.add(path, f"{context} must be a mapping")
+        return False
+    missing = keys - value.keys()
+    extra = value.keys() - keys
+    if missing:
+        problems.add(path, f"{context} missing keys: {sorted(missing)}")
+    if extra:
+        problems.add(path, f"{context} has unknown keys: {sorted(extra)}")
+    return not missing
+
+
+def validate_label(path: Path, problems: Problems) -> None:
+    try:
+        value = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except Exception as exc:
+        problems.add(path, f"cannot parse YAML: {exc}")
+        return
+
+    top = {
+        "attack_end_timestamp", "attack_start_timestamp", "attacking_duration_sec",
+        "collection_duration_sec", "data_attack_info", "data_collection_info", "group_name",
+    }
+    if not require_keys(value, top, path, problems, "label"):
+        return
+    if value["group_name"] != path.parent.name:
+        problems.add(path, "group_name must equal the containing case directory")
+    for key in ("collection_duration_sec", "attacking_duration_sec"):
+        number = value[key]
+        if not isinstance(number, (int, float)) or isinstance(number, bool) or number < 0:
+            problems.add(path, f"{key} must be a non-negative number")
+    for key in ("attack_start_timestamp", "attack_end_timestamp"):
+        number = value[key]
+        if number is not None and (not isinstance(number, (int, float)) or isinstance(number, bool) or number < 0):
+            problems.add(path, f"{key} must be null or a non-negative number")
+
+    collection = value["data_collection_info"]
+    collection_keys = {"avg_speed", "description", "end_place", "intelligent_driving", "road_type", "start_place"}
+    if require_keys(collection, collection_keys, path, problems, "data_collection_info"):
+        if collection["road_type"] not in ROAD_TYPES:
+            problems.add(path, f"unknown road_type: {collection['road_type']!r}")
+        if not isinstance(collection["intelligent_driving"], bool):
+            problems.add(path, "intelligent_driving must be boolean")
+
+    attack = value["data_attack_info"]
+    if attack is None:
+        if not str(value["group_name"]).startswith("benign_"):
+            problems.add(path, "only benign cases may have data_attack_info: null")
+        return
+    if not require_keys(attack, {"attack_effect", "attack_type", "attacked_domain"}, path, problems, "data_attack_info"):
+        return
+    domain = attack["attacked_domain"]
+    if not isinstance(domain, int) or isinstance(domain, bool) or not 1 <= domain <= 5:
+        problems.add(path, "attacked_domain must be an integer from 1 through 5")
+    effect = attack["attack_effect"]
+    if require_keys(effect, {"description", "level"}, path, problems, "attack_effect") and effect["level"] not in EFFECT_LEVELS:
+        problems.add(path, f"unknown attack effect level: {effect['level']!r}")
+    attack_type = attack["attack_type"]
+    if not require_keys(attack_type, {"kind", "config"}, path, problems, "attack_type"):
+        return
+    kind, config = attack_type["kind"], attack_type["config"]
+    if kind not in ATTACK_TYPES:
+        problems.add(path, f"unknown attack kind: {kind!r}")
+        return
+    expected_prefix = "dos" if kind == "DoS" else kind
+    if not str(value["group_name"]).startswith(expected_prefix + "_"):
+        problems.add(path, "attack kind does not agree with group_name")
+    validate_attack_config(kind, config, path, problems)
+
+
+def validate_attack_config(kind: str, config: Any, path: Path, problems: Problems) -> None:
+    if kind in {"spoofing", "masquerade"}:
+        if config is not None:
+            problems.add(path, f"{kind} config must be null")
+        return
+    if not isinstance(config, dict):
+        problems.add(path, f"{kind} config must be a mapping")
+        return
+    enums: dict[str, dict[str, set[str]]] = {
+        "DoS": {"id_option": {"aliveId", "zeroId"}, "dlc_option": {"dlcChange", "dlcKeep"}, "ext_option": {"extendedId", "standardId"}, "data_option": {"FFData", "randomData"}},
+        "fuzzing": {"id_option": {"aliveId", "randomId"}, "dlc_option": {"dlcChange", "dlcKeep"}},
+        "replay": {"timing": {"delay", "immediate"}},
+    }
+    if kind in enums:
+        if not require_keys(config, set(enums[kind]), path, problems, f"{kind} config"):
+            return
+        for key, allowed in enums[kind].items():
+            if config[key] not in allowed:
+                problems.add(path, f"invalid {kind} {key}: {config[key]!r}")
+        return
+    if kind == "suspension":
+        if not require_keys(config, {"suspension_CAN_id_list", "suspension_duration_sec"}, path, problems, "suspension config"):
+            return
+        ids = config["suspension_CAN_id_list"]
+        if not isinstance(ids, list) or not ids or any(not isinstance(item, str) or not CAN_ID.fullmatch(item) for item in ids):
+            problems.add(path, "suspension_CAN_id_list must contain canonical CAN IDs")
+        duration = config["suspension_duration_sec"]
+        if not isinstance(duration, (int, float)) or isinstance(duration, bool) or duration <= 0:
+            problems.add(path, "suspension_duration_sec must be positive")
+
+
+def parse_bool(raw: str) -> bool:
+    if raw not in BOOL:
+        raise ValueError("expected True or False")
+    return BOOL[raw]
+
+
+def grow_bitset(bitset: bytearray, index: int) -> None:
+    if index >= len(bitset):
+        bitset.extend(b"\0" * (index + 1 - len(bitset)))
+
+
+def validate_frame(row: dict[str, str], path: Path, line: int, seen: bytearray, graph: dict[int, list[int]], problems: Problems) -> None:
+    try:
+        timestamp = float(row["timestamp"])
+        if not math.isfinite(timestamp) or timestamp < 0:
+            raise ValueError("timestamp must be finite and non-negative")
+        can_id = row["can_id"]
+        if not CAN_ID.fullmatch(can_id):
+            raise ValueError("can_id is not canonical uppercase hexadecimal")
+        extended = parse_bool(row["is_extended_id"])
+        if (len(can_id) == 10) != extended:
+            raise ValueError("can_id width disagrees with is_extended_id")
+        dlc = int(row["dlc"])
+        payload = row["data"]
+        if not BYTE_STRING.fullmatch(payload):
+            raise ValueError("data is not canonical space-separated uppercase hex")
+        if len(payload.split()) != dlc:
+            raise ValueError("dlc does not equal payload byte count")
+        if row["RX_or_TX"] not in {"RX", "TX"}:
+            raise ValueError("RX_or_TX must be RX or TX")
+        frame_type = row["type"]
+        if frame_type not in {"DT", "FB", "BI"}:
+            raise ValueError("type must be DT, FB, or BI")
+        is_fd = parse_bool(row["is_fd"])
+        if frame_type in {"FB", "BI"} and not is_fd:
+            raise ValueError("FB or BI requires is_fd=True")
+        if dlc not in (FD_LENGTHS if is_fd else CLASSIC_LENGTHS):
+            raise ValueError("dlc is invalid for the frame protocol")
+        domain = int(row["domain"])
+        if not 1 <= domain <= 5:
+            raise ValueError("domain must be 1 through 5")
+        parse_bool(row["is_attack"])
+        parse_bool(row["is_traced_attack"])
+        uuid = int(row["uuid"])
+        if uuid <= 0:
+            raise ValueError("uuid must be positive")
+        grow_bitset(seen, uuid)
+        if seen[uuid]:
+            raise ValueError("duplicate case-local uuid")
+        seen[uuid] = 1
+        parents = ast.literal_eval(row["traced_from"])
+        if not isinstance(parents, list) or any(type(parent) is not int or parent <= 0 for parent in parents):
+            raise ValueError("traced_from must be a list of positive integers")
+        if len(parents) != len(set(parents)):
+            raise ValueError("traced_from contains duplicates")
+        if uuid in parents:
+            raise ValueError("traced_from contains a self-reference")
+        if parents:
+            graph[uuid] = parents
+    except (ValueError, SyntaxError, KeyError) as exc:
+        problems.add(path, str(exc), line)
+
+
+def validate_graph(path: Path, graph: dict[int, list[int]], seen: bytearray, problems: Problems) -> None:
+    for child, parents in graph.items():
+        for parent in parents:
+            if parent >= len(seen) or not seen[parent]:
+                problems.add(path, f"uuid {child} traces from missing case-local uuid {parent}")
+    state: dict[int, int] = {}
+
+    def visit(node: int) -> bool:
+        if state.get(node) == 1:
+            return False
+        if state.get(node) == 2:
+            return True
+        state[node] = 1
+        for parent in graph.get(node, []):
+            if parent in graph and not visit(parent):
+                return False
+        state[node] = 2
+        return True
+
+    for node in graph:
+        if not visit(node):
+            problems.add(path, "traced_from graph contains a cycle")
+            break
+
+
+def validate_csv(path: Path, max_rows: int | None, problems: Problems) -> int:
+    seen = bytearray(1)
+    graph: dict[int, list[int]] = {}
+    rows = 0
+    with path.open("r", encoding="utf-8", newline="") as handle:
+        reader = csv.DictReader(handle)
+        if reader.fieldnames != COLUMNS:
+            problems.add(path, f"unexpected header: {reader.fieldnames!r}", 1)
+            return 0
+        for line, row in enumerate(reader, 2):
+            if max_rows is not None and rows >= max_rows:
+                break
+            validate_frame(row, path, line, seen, graph, problems)
+            rows += 1
+    if max_rows is None:
+        validate_graph(path, graph, seen, problems)
+    return rows
+
+
+def iter_cases(root: Path) -> Iterable[tuple[Path, Path]]:
+    for label in sorted((root / "data").glob("**/label.yaml")):
+        yield label, label.with_name("data.csv")
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path(__file__).resolve().parents[1])
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument("--max-rows", type=int, default=1000, help="rows checked per case (default: 1000)")
+    group.add_argument("--all", action="store_true", help="scan every row and validate trace references/cycles")
+    args = parser.parse_args(argv)
+    root = args.root.resolve()
+    max_rows = None if args.all else args.max_rows
+    if max_rows is not None and max_rows <= 0:
+        parser.error("--max-rows must be positive")
+
+    problems = Problems()
+    cases = rows = 0
+    for label, data in iter_cases(root):
+        cases += 1
+        validate_label(label, problems)
+        if not data.is_file():
+            problems.add(data, "missing data.csv")
+        else:
+            rows += validate_csv(data, max_rows, problems)
+    if not cases:
+        problems.add(root / "data", "no cases found")
+    if problems.items:
+        for item in problems.items[:100]:
+            print(f"ERROR: {item}", file=sys.stderr)
+        if len(problems.items) > 100:
+            print(f"ERROR: {len(problems.items) - 100} additional errors omitted", file=sys.stderr)
+        return 1
+    mode = "all rows" if max_rows is None else f"up to {max_rows} rows/case"
+    print(f"OK: validated {cases} cases and {rows:,} frame rows ({mode})")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())