Feat: JSON-Schemas um neue Workflow-Dateien aktualisiert: testing-to-main-pr.yaml, version-bump.yaml

Dokumentiert die neue Vertrauensprüfung vor dem nmap-Schritt: Konzept
(Gateway-MAC als Netzwerk-Identifikator), die neuen CLI-Optionen
--trusted-networks/--auto-trust-networks samt Config-Datei-Feld
trusted_networks, sowie das Verhalten im interaktiven vs. --json-Modus.
AGENTS.md um src/trust.rs in der Modulstruktur ergänzt.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01SnWfGGqHJGh2AhZ6uhotaD

.idea/jsonSchemas.xml

@@ -32,6 +32,12 @@
                   <Item>
                     <option name="path" value=".gitea/workflows/code-quality.yaml" />
                   </Item>
+                  <Item>
+                    <option name="path" value=".gitea/workflows/testing-to-main-pr.yaml" />
+                  </Item>
+                  <Item>
+                    <option name="path" value=".gitea/workflows/version-bump.yaml" />
+                  </Item>
                 </list>
               </option>
             </SchemaInfo>

.idea/rust-template.iml

@@ -3,6 +3,7 @@
   <component name="NewModuleRootManager">
     <content url="file://$MODULE_DIR$">
       <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/tests" isTestSource="true" />
       <excludeFolder url="file://$MODULE_DIR$/target" />
     </content>
     <orderEntry type="inheritedJdk" />

AGENTS.md

@@ -6,9 +6,21 @@ Dieses Dokument dient als technischer Leitfaden und Kontextdokument für KI-Codi
 
 ## 1. Projektübersicht & Philosophie
 
-Dieses Repository ist ein **Rust-Projekt-Template** für Linux-Anwendungen und CLI-Tools mit Fokus auf:
+**mac2ip** ist ein CLI-Tool, das zuverlässig die aktuelle IP-Adresse zu einer gegebenen MAC-Adresse im lokalen Netzwerk findet, über einen 3-stufigen Algorithmus:
+
+1. **Cache** (`src/cache.rs`): globaler, systemweiter Cache auf Basis der `turso`-Crate (lokale Datei, Standard `/var/lib/mac2ip/cache.db`). Ein Treffer wird nur verwendet, wenn er nicht abgelaufen ist (TTL, `src/config.rs`) **und** die IP per Ping erreichbar ist.
+2. **`ip neigh`** (`src/network.rs`): moderner Ersatz für `arp`. Treffer nur bei Ping-Erreichbarkeit.
+3. **`nmap -sn`** (`src/network.rs`): ARP-/Ping-Scan der lokal angeschlossenen Subnetze. MAC-Adressen erscheinen in der nmap-Ausgabe nur mit Root-Rechten (Raw-Socket/libpcap), daher läuft dieser Schritt über `sudo nmap` (bzw. `nmap` direkt, falls schon root). Kein Treffer → Fehler ("nicht gefunden").
+
+Vor Schritt 3 prüft `src/trust.rs`, ob das aktuelle Netzwerk (identifiziert über die MAC-Adresse seines Default-Gateways) für einen nmap-Scan vertrauenswürdig ist (statische Liste in `AppConfig::trusted_networks`, zuvor per interaktiver Rückfrage/`--auto-trust-networks` im Cache bestätigtes Netzwerk). Ist das Netzwerk unbekannt, wird im interaktiven Modus nachgefragt; im `--json`-Modus (keine Rückfrage möglich) wird der Scan abgelehnt.
+
+Die Orchestrierung dieser drei Schritte liegt in `src/resolver.rs`; `src/main.rs` ist nur ein dünner Entry-Point (CLI-Parsing via `src/cli.rs`, Konfiguration via `src/config.rs` + `config-ctdra`, Logging via `src/log.rs` + `logger-ctdra`).
+
+Zur Laufzeit werden folgende System-Tools benötigt: `ip` (iproute2), `ping` (iputils), `nmap`, `sudo` (nur für Schritt 3, falls nicht schon root). Diese sind in den Paketierungs-Metadaten (`Cargo.toml`, siehe §3.2) als Abhängigkeiten hinterlegt.
+
+Das Projekt basiert auf einem generischen **Rust-Projekt-Template** für Linux-Anwendungen/CLI-Tools mit Fokus auf:
 - Automatisierte Multi-Architektur-Kompilierung (`x86_64`, `aarch64`, `i686`).
-- Native Paketierung für Debian (`.deb`), Fedora/RHEL (`.rpm`) und Arch Linux (`.pkg.tar.zst`) sowie Docker-Container-Images.
+- Native Paketierung für Debian (`.deb`), Fedora/RHEL (`.rpm`) und Arch Linux (`.pkg.tar.zst`).
 - Vollständig automatisierte CI/CD-Pipelines via Gitea Actions (kompatibel mit Forgejo / GitHub Actions).
 - Automatisierte Sicherheits-Scans (Schwachstellen, Secrets) und Dependency-Updates.
 
@@ -16,7 +28,6 @@ Dieses Repository ist ein **Rust-Projekt-Template** für Linux-Anwendungen und C
 - **Sprache**: Rust (Edition 2024), Python 3 (für Hilfsskripte in `scripts/`).
 - **Rust Toolchain**: Stable.
 - **Zielplattform**: Linux (GLIBC-basiert, Cross-Kompilierung für `x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`, `i686-unknown-linux-gnu`).
-- **Container**: Docker-Images werden zusätzlich zu den nativen Paketen gebaut und in die Gitea Container Registry veröffentlicht.
 - **Sicherheits-Tooling**: Trivy, OSV-Scanner, TruffleHog (Secret-Scanning), Renovate (Dependency-Updates), Qodana (statische Codeanalyse).
 - **Lizenz**: GPL-3.0-or-later (sofern nicht im abgeleiteten Projekt anders definiert).
 
@@ -29,27 +40,41 @@ Dieses Repository ist ein **Rust-Projekt-Template** für Linux-Anwendungen und C
 │   └── config.toml             # Linker für Cross-Target-Kompilierung & Registry-Konfiguration
 ├── .gitea/
 │   └── workflows/
-│       ├── main.yaml               # CI/CD: Stabile Builds, Multi-Arch-Paketierung, Docker-Image, Release & Upload
+│       ├── main.yaml               # CI/CD: Stabile Builds, Multi-Arch-Paketierung, Release & Upload
-│       ├── testing.yaml            # CI/CD: Preview-Builds, Docker-Image & Testing-Pakete
+│       ├── testing.yaml            # CI/CD: Preview-Builds & Testing-Pakete
 │       ├── unit-tests.yaml         # CI: Unit-Tests für Pull Requests gegen 'testing'
 │       ├── security-scan.yaml      # CI: Trivy & OSV-Scanner (Schwachstellen/Misconfig/Secrets)
 │       ├── trufflehog-scan.yaml    # CI: TruffleHog Secret-Scan (inkl. Git-Historie)
 │       └── renovate.yaml           # CI: Wöchentlicher Renovate-Lauf für Dependency-Updates
+├── packaging/
+│   ├── deb/postinst             # Debian-Postinstall: legt /var/lib/mac2ip an
+│   └── arch/mac2ip.install      # Arch-Install-Skriptlet: legt /var/lib/mac2ip an
 ├── scripts/
 │   ├── get-build-number.py     # Ermittelt automatisch die nächste Revisions-/Build-Nummer
-│   ├── package-arch.py         # Erzeugt native Arch Linux .pkg.tar.zst Pakete
+│   ├── package-arch.py         # Erzeugt native Arch Linux .pkg.tar.zst Pakete (inkl. optionalem Install-Skriptlet)
 │   └── report-security-issue.py # Meldet Scan-Ergebnisse (Trivy/OSV/TruffleHog) als Gitea-Issue
 ├── src/
-│   └── main.rs                 # Einstiegspunkt der Anwendung
+│   ├── main.rs                  # Einstiegspunkt (CLI-Parsing, Wiring)
+│   ├── lib.rs                   # Modul-Wurzel (für Integrationstests)
+│   ├── cli.rs                   # clap-Kommandozeilen-Definition
+│   ├── config.rs                # AppConfig + config-ctdra-Integration + CLI-Overlay
+│   ├── log.rs                   # JSON-Modus-bewusster logger-ctdra-Wrapper
+│   ├── mac.rs                   # MacAddress-Typ (Parsing/Kanonisierung)
+│   ├── cache.rs                 # Globaler Turso-Cache (MAC -> IP)
+│   ├── network.rs               # ip neigh / ping / nmap: Exec- und Parse-Funktionen
+│   ├── trust.rs                  # Netzwerk-Vertrauensprüfung vor Schritt 3 (Gateway-MAC, Rückfrage, Cache)
+│   ├── resolver.rs               # 3-Stufen-Algorithmus (Orchestrierung)
+│   └── output.rs                 # Human- und JSON-Ausgabe
+├── tests/                       # Integrationstests (pure Parsing-/Logik-Funktionen, kein Netzwerk/root/nmap nötig)
 ├── Cargo.toml                  # Projekt-Manifest & Metadaten für deb, rpm und arch
 ├── qodana.yaml                 # Konfiguration für JetBrains Qodana (statische Analyse)
 ├── renovate.json                # Renovate-Konfiguration (Gruppierung, Versions-Pins in Workflows)
 ├── LICENSE                     # Lizenztext
-├── README.md                   # Benutzerdokumentation & Setup-Checkliste
+├── README.md                   # Benutzerdokumentation
 └── AGENTS.md                   # Dieses Agenten-Handbuch
 ```
 
-> **Hinweis:** `main.yaml`/`testing.yaml` bauen zusätzlich ein Docker-Image (`docker build .` mit `--build-arg TARGET_BIN=...`). Ein `Dockerfile` ist im Template noch **nicht** enthalten und muss von abgeleiteten Projekten ergänzt werden; der aktuell hartkodierte `TARGET_BIN`-Pfad (`.../release/mirror-package`) ist ein Platzhalter aus einem Referenzprojekt und muss beim Ableiten des Templates auf den tatsächlichen Binärnamen (`Cargo.toml` → `[package] name`) angepasst werden.
+> **Hinweis:** Dieses Projekt baut aktuell **kein** Docker-Image — keiner der Workflows unter `.gitea/workflows/` enthält einen Docker-Build-Schritt. Sollte das zukünftig ergänzt werden, muss ein `Dockerfile` hinzugefügt und der Binärname konsistent mit `[package] name` in `Cargo.toml` gehalten werden.
 
 ---
 
@@ -68,12 +93,13 @@ Bei Änderungen an Binärnamen, Abhängigkeiten oder Beschreibungen müssen die
 2. `[package.metadata.generate-rpm]` (für `cargo-generate-rpm`):
    - `requires`, `assets`.
 3. `[package.metadata.arch]` (für `scripts/package-arch.py`):
-   - `pkgrel`, `arch`, `depends`, `optdepends`.
+   - `pkgrel`, `arch`, `depends`, `optdepends`, optional `install_script` (Pfad zu einem pacman-Install-Skriptlet, siehe §3.3).
 
-Ändert sich der Binärname (`[package] name`), muss auch der `TARGET_BIN`-Build-Arg im Docker-Build-Step von `main.yaml`/`testing.yaml` sowie das (abzuleitende) `Dockerfile` angepasst werden.
+Alle drei Blöcke listen bei mac2ip zusätzlich `sudo`, `iproute2`/`iproute`, `iputils`/`iputils-ping` und `nmap` als Laufzeit-Abhängigkeiten (benötigt für den 3-Stufen-Algorithmus, siehe §1). `[package.metadata.deb].maintainer-scripts` sowie `[package.metadata.generate-rpm].post_install_script` legen beim Paket-Install `/var/lib/mac2ip` mit den nötigen Rechten an (siehe §1, "Caching & TTL" in README.md).
 
 ### 3.3 Skripte in `scripts/`
 - **Generizität**: Die Skripte dürfen keine hardcodierten Anwendungsnamen, spezifischen Abhängigkeiten oder projektspezifischen URLs enthalten. Alle Werte müssen dynamisch aus `Cargo.toml` (via `cargo metadata` oder Dateiparsing) oder Umgebungsvariablen (`BUILD_NUMBER`, `GITEA_URL`, `REPO`, `TOKEN`) ermittelt werden.
+- **`package-arch.py`-Install-Skriptlet**: Liest optional `[package.metadata.arch].install_script` aus `cargo metadata` und bettet die referenzierte Datei pacman-konform als `.INSTALL` in das erzeugte `.pkg.tar.zst` ein — weiterhin vollständig metadatengetrieben, kein hartkodierter Anwendungsname im Skript selbst.
 - **Python-Kompatibilität**: Verwende Standard-Python 3 ohne externe PyPI-Abhängigkeiten (nur Standardbibliothek: `json`, `subprocess`, `urllib`, `argparse`, `os`, `re`, `tempfile`, `tarfile` etc.).
 - **`get-build-number.py`**: Ermittelt die nächste Build-/Revisions-Nummer nicht mehr rein lokal, sondern dynamisch über:
   1. Gitea Releases API (Tag-/Asset-Namen),

README.md

@@ -1,29 +1,134 @@
-# rust-template
+# mac2ip
 
-Ein modernes Template-Projekt für Rust-basierte Linux-Anwendungen und Kommandozeilen-Tools (CLI).
+[![Main Release & Publish](https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip/actions/workflows/main.yaml/badge.svg?branch=main)](https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip/actions?workflow=main.yaml)
+[![Testing Build, Publish & Preview Release](https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip/actions/workflows/testing.yaml/badge.svg?branch=testing)](https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip/actions?workflow=testing.yaml)
 
-Dieses Template bietet eine vorkonfigurierte Umgebung für modernes Rust (Edition 2024), automatisierte Multi-Architektur-Kompilierung und native Paketierung für die gängigsten Linux-Distributionen (Debian/Ubuntu, Fedora/RHEL, Arch Linux) sowie vollständige CI/CD-Pipelines für Gitea Actions (kompatibel mit Forgejo und GitHub Actions).
+Ein Kommandozeilen-Tool (CLI), das zuverlässig die aktuelle IP-Adresse zu einer gegebenen MAC-Adresse im lokalen Netzwerk findet.
+
+Dazu wird ein 3-stufiger Algorithmus verwendet:
+
+1. **Cache**: Ein globaler, systemweiter Cache (für alle Nutzer dieses Rechners) wird geprüft. Ein Treffer wird nur verwendet, wenn er noch nicht abgelaufen ist (TTL) **und** die IP per Ping erreichbar ist.
+2. **`ip neigh`**: Die Linux-Nachbartabelle (`ip neigh show`, der moderne Ersatz für den veralteten `arp`-Befehl) wird nach der MAC-Adresse durchsucht. Ein Treffer wird nur verwendet, wenn die IP per Ping erreichbar ist.
+3. **`nmap`**: Als letzter Schritt wird ein Ping-/ARP-Scan (`nmap -sn`) der lokal angeschlossenen Subnetze durchgeführt. Da MAC-Adressen in der nmap-Ausgabe nur mit Root-Rechten sichtbar sind (ARP-Scans benötigen Raw-Socket-/libpcap-Zugriff), läuft dieser Schritt über `sudo nmap` (bzw. direkt `nmap`, falls das Programm bereits als root läuft). Da ein Subnetz-Scan auf fremden Netzwerken heikel sein kann, wird dieser Schritt nur in einem als vertrauenswürdig eingestuften Netzwerk ausgeführt (siehe [Netzwerk-Vertrauen](#netzwerk-vertrauen)). Wird auch hier keine erreichbare IP gefunden, bricht das Programm mit einem Fehler ("nicht gefunden") ab.
 
 ---
 
 ## Features
 
-- **Rust Edition 2024**: Moderner Rust-Sprachstandard.
+- **Zuverlässige MAC → IP-Auflösung** über Cache, `ip neigh` und `nmap`, jeweils mit Erreichbarkeitsprüfung per Ping.
-- **Multi-Architektur-Kompilierung**:
+- **Globaler, systemweiter Cache** (via [`turso`](https://turso.tech), lokal-dateibasiert) mit konfigurierbarer TTL.
-  - `x86_64-unknown-linux-gnu` (64-Bit x86)
+- **Maschinenlesbare Ausgabe** über `--json` (unattended-Modus) — unterdrückt dabei alle sonstigen Log-Ausgaben.
-  - `aarch64-unknown-linux-gnu` (64-Bit ARM / ARM64)
+- **Vollständig über die Kommandozeile konfigurierbar**, mit Overlay-Kette CLI > Umgebungsvariable > Konfigurationsdatei > Standardwert.
-  - `i686-unknown-linux-gnu` (32-Bit x86)
+- **Funktioniert mit und ohne `sudo`** — Root-Rechte werden nur für den nmap-Schritt benötigt.
-- **Linux-Paketierung out-of-the-box**:
+- **Rust Edition 2024**, Multi-Architektur-Kompilierung (`x86_64`, `aarch64`, `i686`), native Linux-Paketierung (`.deb`, `.rpm`, `.pkg.tar.zst`) und automatisierte CI/CD-Pipelines via Gitea Actions.
-  - **Debian / Ubuntu** (`.deb` via `cargo-deb`)
+
-  - **Fedora / RHEL / openSUSE** (`.rpm` via `cargo-generate-rpm`)
+---
-  - **Arch Linux** (`.pkg.tar.zst` via mitgeliefertem `scripts/package-arch.py`)
+
-- **Automatisierte CI/CD-Pipelines**:
+## CLI-Nutzung
-  - `main`-Branch: Erstellt stabile Builds, ermittelt dynamisch Build-Nummern, paketiert für alle Architekturen, lädt Pakete in die Gitea Package Registry und erstellt Gitea Releases mit Dateianhängen.
+
-  - `testing`-Branch: Erstellt Preview-Builds und Pre-Releases mit Testing-Paketen.
+```bash
-- **Automatisierte Versions- & Build-Nummern**:
+mac2ip <MAC> [OPTIONEN]
-  - `scripts/get-build-number.py` fragt Gitea Releases, die Package Registry sowie lokale Artefakte ab, um Revisions-/Release-Nummern (z. B. `1.0.0-1`, `1.0.0-2`) automatisch zu erhöhen.
+```
-- **Vorkonfigurierte Cargo-Einstellungen**:
+
-  - `.cargo/config.toml` mit vorkonfigurierten Cross-Compilation-Linkern und Unterstützung für private/öffentliche Cargo Registries.
+Beispiel:
+
+```bash
+$ mac2ip aa:bb:cc:dd:ee:ff
+aa:bb:cc:dd:ee:ff -> 192.168.1.42 (Quelle: cache)
+```
+
+Maschinenlesbare Ausgabe (unattended-Modus):
+
+```bash
+$ mac2ip aa:bb:cc:dd:ee:ff --json
+{"status":"ok","mac":"aa:bb:cc:dd:ee:ff","ip":"192.168.1.42","source":"cache"}
+```
+
+Bei Fehlern (`status: "error"`) ist `source` nicht enthalten, dafür ein `error`-Feld mit einer Beschreibung; der Exit-Code ist in beiden Fällen ungleich 0 (`1`) bei Fehlschlag.
+
+### Optionen
+
+| Option | Umgebungsvariable | Standard | Beschreibung |
+| :--- | :--- | :--- | :--- |
+| `--json` | - | aus | Gibt das Ergebnis als einzeiliges JSON-Objekt aus; unterdrückt alle sonstigen Log-Ausgaben. |
+| `--config <PATH>` | - | siehe unten | Benutzerdefinierter Pfad zur Konfigurationsdatei. |
+| `--log-level <LEVEL>` | `MAC2IP_LOG_LEVEL` | `info` | Logging-Level: `error`, `warn`, `info`, `debug`. |
+| `--cache-ttl-seconds <N>` | `MAC2IP_CACHE_TTL_SECONDS` | `1800` | Wie lange ein Cache-Eintrag als gültig angesehen wird (zusätzlich zur Ping-Prüfung). |
+| `--cache-db-path <PATH>` | `MAC2IP_CACHE_DB_PATH` | `/var/lib/mac2ip/cache.db` | Pfad zur globalen Cache-Datenbankdatei. |
+| `--nmap-timeout-seconds <N>` | `MAC2IP_NMAP_TIMEOUT_SECONDS` | `120` | Timeout für einen einzelnen nmap-Subnetz-Scan. |
+| `--networks <CIDR,CIDR,...>` | `MAC2IP_NETWORKS` | Auto-Erkennung | Kommagetrennte Liste von Subnetzen für den nmap-Scan; überschreibt die automatische Erkennung über `ip route`. |
+| `--trusted-networks <MAC,MAC,...>` | `MAC2IP_TRUSTED_NETWORKS` | leer | Kommagetrennte Liste von Gateway-MAC-Adressen, deren Netzwerke ohne Rückfrage für nmap-Scans (Schritt 3) vertraut werden; überschreibt die Konfigurationsdatei vollständig. |
+| `--auto-trust-networks` | - | aus | Beantwortet die "Netzwerk vertrauen?"-Rückfrage vor Schritt 3 automatisch mit Ja (und merkt sich das Netzwerk dauerhaft im Cache), statt interaktiv nachzufragen bzw. im `--json`-Modus abzulehnen. |
+
+Die Überschreibungs-Reihenfolge ist immer: **CLI-Flag > Umgebungsvariable > Konfigurationsdatei > Standardwert.**
+
+---
+
+## Konfigurationsdatei
+
+Die Konfiguration wird über [`config-ctdra`](https://gitea.creative-dragonslayer.de/Rust-Crates) verwaltet:
+
+- Als **root** (bzw. beim nmap-Schritt via `sudo`): `/etc/mac2ip/config.toml`
+- Als **normaler Nutzer**: `~/.config/mac2ip/config.toml`
+- Oder explizit über `--config <PATH>`
+
+Beispiel:
+
+```toml
+cache_ttl_seconds = 1800
+cache_db_path = "/var/lib/mac2ip/cache.db"
+log_level = "info"
+nmap_timeout_seconds = 120
+networks = []
+trusted_networks = []
+```
+
+Alle Felder sind optional (fehlende Felder verwenden den Standardwert) und können, wie oben beschrieben, zusätzlich per CLI-Flag oder Umgebungsvariable überschrieben werden.
+
+---
+
+## Caching & TTL
+
+Der Cache liegt standardmäßig unter `/var/lib/mac2ip/cache.db` — **global für alle Nutzer des Rechners**, nicht pro Benutzerkonto. Verzeichnis und Datei sind bewusst world-writable (`0777`/`0666`), damit auch unprivilegierte Nutzer den Cache lesen und schreiben können, ohne dass mac2ip dafür Root-Rechte bräuchte.
+
+Ein Cache-Treffer wird nur verwendet, wenn:
+1. der Eintrag noch nicht älter als `cache_ttl_seconds` ist (Standard: 30 Minuten), **und**
+2. die gespeicherte IP-Adresse aktuell per Ping erreichbar ist.
+
+Die Ping-Prüfung ist die primäre Absicherung gegen veraltete Zuordnungen; die TTL ist eine zusätzliche Absicherung für den Fall, dass eine alte IP-Adresse inzwischen an ein anderes, ebenfalls erreichbares Gerät vergeben wurde (z. B. nach einem DHCP-Lease-Wechsel).
+
+Kann das Cache-Verzeichnis beim Programmstart nicht angelegt/beschrieben werden (z. B. bei einem Entwicklungslauf ohne vorherige Paketinstallation), wird der Cache für diesen Lauf einfach deaktiviert (eine Warnung wird geloggt, im `--json`-Modus unterdrückt) — mac2ip führt den Lookup dann ohne Cache über `ip neigh`/`nmap` durch. Bei einer Installation über `.deb`/`.rpm`/`.pkg.tar.zst` wird das Verzeichnis automatisch mit den richtigen Rechten angelegt (siehe Paketierungs-Postinstall-Skripte unter `packaging/`).
+
+---
+
+## Netzwerk-Vertrauen
+
+Ein `nmap`-Subnetz-Scan (Schritt 3) ist auf Netzwerken, die man nicht selbst administriert (Firmen-/Gast-WLAN, Kundenstandort etc.), potenziell heikel — er kann IDS-Alarme auslösen oder gegen eine Nutzungsordnung verstoßen. mac2ip führt Schritt 3 deshalb nur in einem als vertrauenswürdig eingestuften Netzwerk aus.
+
+Das aktuelle Netzwerk wird über die **MAC-Adresse seines Default-Gateways** identifiziert — sie bleibt stabil, solange derselbe Router im Einsatz ist, unabhängig von SSID oder wechselndem DHCP-Subnetz. Ein Netzwerk gilt als vertrauenswürdig, wenn eine der folgenden Bedingungen zutrifft:
+
+1. Die Gateway-MAC steht in `trusted_networks` (Konfigurationsdatei oder `--trusted-networks`).
+2. Das Netzwerk wurde bereits einmal per Rückfrage bestätigt — das Ergebnis wird dauerhaft im globalen Cache gespeichert, sodass beim nächsten Besuch (auch nach Neustart) keine erneute Rückfrage nötig ist.
+3. `--auto-trust-networks` ist gesetzt: Die Rückfrage wird automatisch mit Ja beantwortet und das Ergebnis ebenfalls im Cache gemerkt.
+
+Ist keine der Bedingungen erfüllt:
+- Im **interaktiven Modus** fragt mac2ip auf stderr nach, ob der Scan in diesem Netzwerk erlaubt werden soll.
+- Im **`--json`-Modus** ist keine Rückfrage möglich (die Ausgabe darf nicht durch einen Prompt verunreinigt werden) — der Scan wird sicherheitshalber abgelehnt und ein Fehler zurückgegeben. Für unbeaufsichtigte Läufe in bekannten Netzwerken also entweder `trusted_networks` vorkonfigurieren oder einmalig interaktiv (ohne `--json`) bestätigen.
+
+Kann die Gateway-MAC nicht ermittelt werden (z. B. kein Default-Gateway vorhanden), wird der Scan ebenfalls abgelehnt, außer `--auto-trust-networks` ist gesetzt.
+
+---
+
+## Voraussetzungen
+
+Neben Rust/Cargo zur Laufzeit benötigt werden folgende System-Tools:
+
+- `ip` (Paket `iproute2`) — für Schritt 2 (`ip neigh`) und die automatische Subnetz-Erkennung.
+- `ping` (Paket `iputils`/`iputils-ping`) — für die Erreichbarkeitsprüfung.
+- `nmap` — für Schritt 3.
+- `sudo` — nur nötig, wenn Schritt 3 erreicht wird und das Programm nicht bereits als root läuft.
+
+Im `--json`-Modus wird für Schritt 3 ausschließlich `sudo -n` (nicht-interaktiv) verwendet, damit das Programm niemals interaktiv nach einem Passwort fragt und dadurch ein Skript blockiert. Ist keine gültige sudo-Sitzung/NOPASSWD-Regel vorhanden, wird Schritt 3 abgebrochen und das Ergebnis als "nicht gefunden" zurückgegeben. Im interaktiven (Nicht-JSON-)Modus darf `sudo` regulär nach einem Passwort fragen.
 
 ---
 
@@ -36,49 +141,39 @@ Dieses Template bietet eine vorkonfigurierte Umgebung für modernes Rust (Editio
 │   └── workflows/
 │       ├── main.yaml           # CI/CD-Workflow für stabile Releases (main-Branch)
 │       └── testing.yaml        # CI/CD-Workflow für Pre-Releases (testing-Branch)
+├── packaging/
+│   ├── deb/postinst            # Debian-Postinstall: legt /var/lib/mac2ip an
+│   └── arch/mac2ip.install     # Arch-Install-Skriptlet: legt /var/lib/mac2ip an
 ├── scripts/
 │   ├── get-build-number.py     # Dynamische Ermittlung der nächsten Paket-Revisionsnummer
 │   └── package-arch.py         # Erstellung von Arch Linux .pkg.tar.zst Paketen
 ├── src/
-│   └── main.rs                 # Quellcode & Einstiegspunkt der Anwendung
+│   ├── main.rs                  # Einstiegspunkt (CLI-Parsing, Wiring)
-├── Cargo.toml                  # Cargo Manifest & Paketierungsmetadaten (deb, rpm, arch)
+│   ├── lib.rs                   # Modul-Wurzel (für Integrationstests)
-├── LICENSE                     # Lizenzdatei (Standard: GPL-3.0-or-later)
+│   ├── cli.rs                   # clap-Kommandozeilen-Definition
-├── AGENTS.md                   # Richtlinien und Leitfaden für KI-Coding-Agenten
+│   ├── config.rs                # AppConfig + config-ctdra-Integration + CLI-Overlay
-└── README.md                   # Projektdokumentation
+│   ├── log.rs                   # JSON-Modus-bewusster logger-ctdra-Wrapper
+│   ├── mac.rs                   # MacAddress-Typ (Parsing/Kanonisierung)
+│   ├── cache.rs                 # Globaler Turso-Cache (MAC -> IP)
+│   ├── network.rs               # ip neigh / ping / nmap: Exec- und Parse-Funktionen
+│   ├── resolver.rs               # 3-Stufen-Algorithmus (Orchestrierung)
+│   └── output.rs                 # Human- und JSON-Ausgabe
+├── tests/                       # Integrationstests (pure Parsing-/Logik-Funktionen)
+├── Cargo.toml                   # Cargo Manifest & Paketierungsmetadaten (deb, rpm, arch)
+├── LICENSE                      # Lizenzdatei (Standard: GPL-3.0-or-later)
+├── AGENTS.md                    # Richtlinien und Leitfaden für KI-Coding-Agenten
+└── README.md                    # Projektdokumentation
 ```
 
 ---
 
-## Checkliste zur Verwendung als Template
-
-Wenn du ein neues Projekt aus diesem Template erstellst, gehe folgende Schritte durch:
-
-1. **`Cargo.toml` anpassen**:
-   - `name`: Den Namen deiner Anwendung setzen.
-   - `version`: Initiale Version festlegen (z. B. `0.1.0`).
-   - `authors`, `repository`, `description`, `license`: Projektdaten eintragen.
-   - Paketierungsabschnitte prüfen:
-     - `[package.metadata.deb]`: `maintainer`, `copyright`, `section`, `extended-description` setzen.
-     - `[package.metadata.generate-rpm]`: `requires` anpassen.
-     - `[package.metadata.arch]`: `depends` und `optdepends` anpassen.
-2. **`src/` implementieren**:
-   - Eigene Anwendungslogik in `src/main.rs` (bzw. Modulen / `src/lib.rs`) implementieren.
-   - Tests in `src/` oder `tests/` ergänzen.
-3. **`.cargo/config.toml` prüfen**:
-   - Falls crates.io statt einer privaten Registry genutzt werden soll, den Standard-Registry-Eintrag anpassen oder auskommentieren.
-4. **CI/CD Secrets konfigurieren**:
-   - In den Repository-Einstellungen von Gitea/Forgejo ein Secret `PACKAGE_TOKEN` (bzw. `GITEA_TOKEN`) mit Rechten für Pakete und Releases hinterlegen.
-5. **Dokumentation aktualisieren**:
-   - `README.md` an die konkrete Funktionsweise deiner Anwendung anpassen.
-
----
-
 ## Lokale Entwicklung
 
 ### Voraussetzungen
 
 - **Rust & Cargo** (aktuelle Stable-Version, Edition 2024 unterstützt)
 - **Python 3** (für Hilfsskripte in `scripts/`)
+- Zur Laufzeit: `ip`, `ping`, `nmap`, `sudo` (siehe "Voraussetzungen" oben)
 - Für Cross-Compilation (optional):
   - `rustup target add x86_64-unknown-linux-gnu aarch64-unknown-linux-gnu i686-unknown-linux-gnu`
   - Cross-Toolchains: `gcc-aarch64-linux-gnu`, `gcc-i686-linux-gnu`
@@ -126,6 +221,7 @@ Erstellt native Arch Linux-Pakete (`.pkg.tar.zst`), ohne dass `makepkg` oder ein
 - Liest Konfiguration aus `[package.metadata.arch]` in `Cargo.toml`.
 - Installiert die Binary nach `/usr/bin/`, sowie `LICENSE` und `README.md` nach `/usr/share/`.
 - Erzeugt eine standardkonforme `.PKGINFO`-Datei und komprimiert das Paket mit `zstandard`.
+- Unterstützt optional ein Install-Skriptlet (`[package.metadata.arch].install_script`), das pacman-konform als `<name>.install` mit `post_install()`/`post_upgrade()` eingebettet wird (bei mac2ip: legt `/var/lib/mac2ip` an).
 - Parameter:
   - `--target`: Rust Target-Triple (z. B. `x86_64-unknown-linux-gnu`)
   - `--arch`: Zielarchitektur (z. B. `x86_64`, `aarch64`, `i686`)
@@ -144,5 +240,4 @@ Erstellt native Arch Linux-Pakete (`.pkg.tar.zst`), ohne dass `makepkg` oder ein
 
 ## Lizenz
 
-Dieses Template steht standardmäßig unter der [GPL-3.0-or-later](LICENSE)-Lizenz. Die Lizenz kann bei Bedarf in `LICENSE` und `Cargo.toml` angepasst werden.
+mac2ip steht unter der [GPL-3.0-or-later](LICENSE)-Lizenz.
-

scripts/package-arch.py

@@ -103,11 +103,11 @@ def build_package(target_triple=None, target_arch=None, pkgrel=None):
         if os.path.exists("README.md"):
             subprocess.run(["install", "-m", "644", "README.md", f"{doc_dir}/README.md"], check=True)
 
-        install_scriptlet_name = None
+        has_install_scriptlet = False
         if install_rel_path and os.path.exists(install_rel_path):
-            install_scriptlet_name = f"{name}.install"
+            has_install_scriptlet = True
             subprocess.run(
-                ["install", "-m", "644", install_rel_path, os.path.join(build_dir, install_scriptlet_name)],
+                ["install", "-m", "644", install_rel_path, os.path.join(build_dir, ".INSTALL")],
                 check=True,
             )
 
@@ -126,8 +126,6 @@ def build_package(target_triple=None, target_arch=None, pkgrel=None):
             f"arch = {arch}",
             f"license = {license_name}",
         ]
-        if install_scriptlet_name:
-            pkginfo_lines.append(f"install = {install_scriptlet_name}")
         for dep in depends:
             pkginfo_lines.append(f"depend = {dep}")
         for optdep in optdepends:
@@ -140,8 +138,8 @@ def build_package(target_triple=None, target_arch=None, pkgrel=None):
         os.makedirs("target/arch", exist_ok=True)
         output_file = os.path.abspath(f"target/arch/{name}-{version}-{pkgrel}-{arch}.pkg.tar.zst")
         tar_members = [".PKGINFO"]
-        if install_scriptlet_name:
+        if has_install_scriptlet:
-            tar_members.append(install_scriptlet_name)
+            tar_members.append(".INSTALL")
         tar_members.append("usr")
         subprocess.run(["tar", "--zstd", "-cf", output_file, *tar_members], cwd=build_dir, check=True)
         print(f"Arch-Paket erfolgreich erstellt: {output_file}")

src/cache.rs

@@ -38,9 +38,63 @@ impl Cache {
                 (),
             )
             .await?;
+        self.conn
+            .execute(
+                "CREATE TABLE IF NOT EXISTS trusted_networks (\
+                    gateway_mac TEXT PRIMARY KEY, \
+                    trusted_at INTEGER NOT NULL\
+                )",
+                (),
+            )
+            .await?;
         Ok(())
     }
 
+    /// Best-effort: gibt bei jedem Fehler `false` zurück (nur eine Warnung wird geloggt) -
+    /// ein Cache-Lesefehler darf ein zuvor bereits bestätigtes Netzwerk nicht plötzlich
+    /// als unbekannt erscheinen lassen, aber sicherheitshalber auch nicht automatisch
+    /// als vertrauenswürdig gelten lassen; der Aufrufer fragt in diesem Fall erneut nach.
+    pub async fn is_trusted_network(&self, gateway_mac: &MacAddress) -> bool {
+        let key = gateway_mac.to_lower_colon();
+        match self
+            .conn
+            .query(
+                "SELECT 1 FROM trusted_networks WHERE gateway_mac = ?1",
+                (key,),
+            )
+            .await
+        {
+            Ok(mut rows) => matches!(rows.next().await, Ok(Some(_))),
+            Err(e) => {
+                crate::log::warn(
+                    "cache",
+                    &format!("Cache-Lesefehler (trusted_networks): {e}"),
+                );
+                false
+            }
+        }
+    }
+
+    /// Best-effort Upsert: merkt sich ein Netzwerk (identifiziert über die Gateway-MAC)
+    /// dauerhaft als vertrauenswürdig für zukünftige nmap-Scans.
+    pub async fn trust_network(&self, gateway_mac: &MacAddress, now: i64) {
+        let key = gateway_mac.to_lower_colon();
+        if let Err(e) = self
+            .conn
+            .execute(
+                "INSERT INTO trusted_networks (gateway_mac, trusted_at) VALUES (?1, ?2) \
+                 ON CONFLICT(gateway_mac) DO UPDATE SET trusted_at = excluded.trusted_at",
+                (key, now),
+            )
+            .await
+        {
+            crate::log::warn(
+                "cache",
+                &format!("Cache-Schreibfehler (trusted_networks, ignoriert): {e}"),
+            );
+        }
+    }
+
     /// Best-effort: gibt bei jedem Fehler `None` zurück (nur eine Warnung wird geloggt).
     pub async fn get(&self, mac: &MacAddress) -> Option<CacheEntry> {
         let key = mac.to_lower_colon();
@@ -109,12 +163,14 @@ fn ensure_cache_dir(dir: &Path) -> Result<(), String> {
                 dir.display()
             )
         })?;
+        // create_dir_all() unterliegt dem Prozess-Umask; explizites chmod ist nötig, um
+        // wirklich 0777 zu erreichen (Verzeichnis-Rechte steuern nicht die Umask neuer Dateien).
+        // Wird nur beim Neuanlegen ausgeführt; bei existierenden Verzeichnissen würde ein
+        // unprivilegierter Aufruf auf root-eigenen Pfaden mit EPERM fehlschlagen.
+        #[cfg(unix)]
+        std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o777))
+            .map_err(|e| format!("Verzeichnis-Rechte konnten nicht gesetzt werden: {e}"))?;
     }
-    // create_dir_all() unterliegt dem Prozess-Umask; explizites chmod ist nötig, um
-    // wirklich 0777 zu erreichen (Verzeichnis-Rechte steuern nicht die Umask neuer Dateien).
-    #[cfg(unix)]
-    std::fs::set_permissions(dir, std::fs::Permissions::from_mode(0o777))
-        .map_err(|e| format!("Verzeichnis-Rechte konnten nicht gesetzt werden: {e}"))?;
     Ok(())
 }
 
@@ -173,3 +229,30 @@ pub async fn try_open_cache(db_path: &Path) -> Option<Cache> {
     chmod_cache_sidecars(db_path);
     Some(cache)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ensure_cache_dir_existing_directory_does_not_fail() {
+        // Bestehende Systemverzeichnisse (die einem unprivilegierten Nutzer nicht gehören)
+        // dürfen beim Überprüfen keinen EPERM-Fehler werfen.
+        assert!(ensure_cache_dir(Path::new("/tmp")).is_ok());
+    }
+
+    #[test]
+    fn test_ensure_cache_dir_creates_new_directory() {
+        let temp_dir = std::env::temp_dir().join(format!(
+            "mac2ip_test_{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        assert!(!temp_dir.exists());
+        assert!(ensure_cache_dir(&temp_dir).is_ok());
+        assert!(temp_dir.exists());
+        let _ = std::fs::remove_dir(&temp_dir);
+    }
+}

src/cli.rs

@@ -45,6 +45,17 @@ pub struct Cli {
     /// Kommagetrennte Liste von CIDR-Subnetzen für den nmap-Scan (überschreibt Auto-Erkennung)
     #[arg(long, env = "MAC2IP_NETWORKS", value_delimiter = ',')]
     pub networks: Option<Vec<String>>,
+
+    /// Kommagetrennte Liste von Gateway-MAC-Adressen, deren Netzwerke ohne Rückfrage für
+    /// nmap-Scans (Schritt 3) vertraut werden (überschreibt die Konfigurationsdatei vollständig)
+    #[arg(long, env = "MAC2IP_TRUSTED_NETWORKS", value_delimiter = ',')]
+    pub trusted_networks: Option<Vec<MacAddress>>,
+
+    /// Beantwortet die "nmap-Scan in diesem Netzwerk erlauben?"-Rückfrage vor Schritt 3
+    /// automatisch mit Ja (und merkt sich das Netzwerk dauerhaft im Cache), statt
+    /// interaktiv nachzufragen bzw. im --json-Modus den Scan abzulehnen
+    #[arg(long)]
+    pub auto_trust_networks: bool,
 }
 
 #[derive(ValueEnum, Clone, Copy, Debug, PartialEq, Eq)]

src/config.rs

@@ -4,6 +4,8 @@ use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
+use crate::mac::MacAddress;
+
 pub const DEFAULT_CACHE_TTL_SECONDS: u64 = 1800; // 30 Min: Ping-Check ist die primäre
 // Absicherung gegen veraltete Einträge, die TTL ist nur eine zusätzliche Absicherung
 // gegen den Fall, dass eine alte IP inzwischen an ein anderes, ebenfalls
@@ -40,6 +42,11 @@ pub struct AppConfig {
     pub nmap_timeout_seconds: u64,
     #[serde(default)]
     pub networks: Vec<String>,
+    /// Gateway-MAC-Adressen von Netzwerken, in denen ein nmap-Scan (Schritt 3) ohne
+    /// interaktive Rückfrage erlaubt ist. Wird um per Rückfrage/`--auto-trust-networks`
+    /// bestätigte Netzwerke ergänzt, die im Cache gespeichert werden (siehe `src/trust.rs`).
+    #[serde(default)]
+    pub trusted_networks: Vec<String>,
 }
 
 impl Default for AppConfig {
@@ -50,10 +57,23 @@ impl Default for AppConfig {
             log_level: DEFAULT_LOG_LEVEL.to_string(),
             nmap_timeout_seconds: DEFAULT_NMAP_TIMEOUT_SECONDS,
             networks: Vec::new(),
+            trusted_networks: Vec::new(),
         }
     }
 }
 
+impl AppConfig {
+    /// Reine, testbare Funktion: validiert die konfigurierten vertrauten Netzwerke.
+    /// Nicht als MAC-Adresse parsbare Einträge werden übersprungen (kein harter Fehler,
+    /// da eine fehlerhafte Config-Zeile den Lookup nicht insgesamt scheitern lassen soll).
+    pub fn trusted_network_macs(&self) -> Vec<MacAddress> {
+        self.trusted_networks
+            .iter()
+            .filter_map(|s| MacAddress::parse(s).ok())
+            .collect()
+    }
+}
+
 /// Initialisiert den Konfigurationspfad bei `config-ctdra` (Standardname "config",
 /// optionaler expliziter Pfad via `--config`).
 pub fn init_config_path(custom_path: Option<&Path>) {
@@ -90,4 +110,7 @@ pub fn apply_cli_overrides(config: &mut AppConfig, cli: &crate::cli::Cli) {
     if let Some(networks) = &cli.networks {
         config.networks = networks.clone();
     }
+    if let Some(trusted) = &cli.trusted_networks {
+        config.trusted_networks = trusted.iter().map(MacAddress::to_lower_colon).collect();
+    }
 }

src/error.rs

@@ -6,6 +6,11 @@ use crate::mac::MacAddressError;
 pub enum Mac2IpError {
     #[error("keine IP-Adresse für MAC '{mac}' gefunden")]
     NotFound { mac: String },
+    #[error(
+        "nmap-Scan abgelehnt: Netzwerk nicht vertrauenswürdig{}",
+        .gateway_mac.as_ref().map(|m| format!(" (Gateway-MAC {m})")).unwrap_or_default()
+    )]
+    UntrustedNetwork { gateway_mac: Option<String> },
     #[error("MAC-Adresse ungültig: {0}")]
     InvalidMac(#[from] MacAddressError),
     #[error("E/A-Fehler: {0}")]

src/lib.rs

@@ -10,3 +10,4 @@ pub mod mac;
 pub mod network;
 pub mod output;
 pub mod resolver;
+pub mod trust;

src/main.rs

@@ -23,7 +23,15 @@ async fn main() -> ExitCode {
 
     let cache = cache::try_open_cache(&app_config.cache_db_path).await;
 
-    match resolver::resolve(&cli.mac, &app_config, cache.as_ref(), cli.json).await {
+    match resolver::resolve(
+        &cli.mac,
+        &app_config,
+        cache.as_ref(),
+        cli.json,
+        cli.auto_trust_networks,
+    )
+    .await
+    {
         Ok(result) => {
             output::print_success(&result, cli.json);
             ExitCode::SUCCESS

src/network.rs

@@ -30,6 +30,31 @@ pub async fn run_ip_route_show_scope_link() -> std::io::Result<String> {
     Ok(String::from_utf8_lossy(&out.stdout).into_owned())
 }
 
+pub async fn run_ip_route_show_default() -> std::io::Result<String> {
+    let out = tokio::process::Command::new("ip")
+        .args(["-4", "route", "show", "default"])
+        .output()
+        .await?;
+    Ok(String::from_utf8_lossy(&out.stdout).into_owned())
+}
+
+/// Ermittelt die MAC-Adresse des aktuellen Default-Gateways - dient als stabiler
+/// Identifikator für "dieses Netzwerk" (bleibt bei DHCP-Subnetzwechsel gleich,
+/// solange derselbe Router im Einsatz ist), unabhängig von SSID/CIDR.
+/// Gibt `None` zurück, wenn kein Default-Gateway existiert oder dessen MAC nicht
+/// ermittelt werden kann (z. B. kein Nachbar-Eintrag trotz Ping).
+pub async fn detect_default_gateway_mac() -> Option<MacAddress> {
+    let route_output = run_ip_route_show_default().await.ok()?;
+    let gateway_ip = parse_default_gateway_ip(&route_output)?;
+
+    // Erzwingt best-effort einen frischen Nachbar-Tabelleneintrag; Ergebnis wird
+    // ignoriert, da `ip neigh` auch von einem veralteten/STALE-Eintrag profitiert.
+    let _ = ping_check(gateway_ip).await;
+
+    let neigh_output = run_ip_neigh_show().await.ok()?;
+    parse_ip_neigh_mac_for_ip(&neigh_output, gateway_ip)
+}
+
 pub async fn ping_check(ip: IpAddr) -> bool {
     tokio::process::Command::new("ping")
         .args([
@@ -95,10 +120,34 @@ pub async fn run_nmap_scan(
     // unabhängig von der System-Locale funktioniert (z. B. "Passwort ist notwendig"
     // auf einem deutschen System würde sonst nicht erkannt werden).
     cmd.env("LC_ALL", "C").env("LANG", "C");
+    cmd.kill_on_drop(true);
+    // Eigene Prozessgruppe: `kill_on_drop`/Child::kill() signalisiert bei einem
+    // Timeout nur den direkten Kind-Prozess. Im Sudo-Fall ist das `sudo` selbst,
+    // nicht das von `sudo` geforkte (als root laufende) `nmap`. Ohne eigene
+    // Prozessgruppe würde `sudo` beim SIGKILL sterben, während `nmap` als
+    // root-Waise weiterläuft und den Scan fortsetzt.
+    cmd.process_group(0);
 
-    let out = tokio::time::timeout(Duration::from_secs(timeout_secs), cmd.output())
+    let child = cmd.spawn()?;
-        .await
+    let pgid = child.id();
-        .map_err(|_| NmapRunError::Timeout)??;
+
+    let out =
+        match tokio::time::timeout(Duration::from_secs(timeout_secs), child.wait_with_output())
+            .await
+        {
+            Ok(out) => out?,
+            Err(_) => {
+                if let Some(pgid) = pgid {
+                    // Negative PID = Signal an die gesamte Prozessgruppe (sudo + nmap).
+                    let _ = tokio::process::Command::new("kill")
+                        .arg("-KILL")
+                        .arg(format!("-{pgid}"))
+                        .output()
+                        .await;
+                }
+                return Err(NmapRunError::Timeout);
+            }
+        };
 
     if !out.status.success() {
         let stderr = String::from_utf8_lossy(&out.stderr);
@@ -136,6 +185,34 @@ pub fn parse_ip_neigh_output(output: &str, mac: &MacAddress) -> Option<IpAddr> {
     None
 }
 
+/// Parst `ip -4 route show default`, z. B. "default via 192.168.1.1 dev eth0 proto dhcp
+/// metric 100". Gibt die Gateway-IP zurück (Token direkt nach "via").
+pub fn parse_default_gateway_ip(output: &str) -> Option<IpAddr> {
+    output.lines().find_map(|line| {
+        let tokens: Vec<&str> = line.split_whitespace().collect();
+        let pos = tokens.iter().position(|&t| t == "via")?;
+        tokens.get(pos + 1)?.parse().ok()
+    })
+}
+
+/// Parst `ip neigh show`-Ausgabe und gibt die `lladdr`-MAC des Eintrags zurück, dessen
+/// erste Spalte (IP) mit `target_ip` übereinstimmt. Kehrbild zu [`parse_ip_neigh_output`].
+pub fn parse_ip_neigh_mac_for_ip(output: &str, target_ip: IpAddr) -> Option<MacAddress> {
+    for line in output.lines() {
+        let tokens: Vec<&str> = line.split_whitespace().collect();
+        if tokens.first().and_then(|t| t.parse::<IpAddr>().ok()) != Some(target_ip) {
+            continue;
+        }
+        if let Some(pos) = tokens.iter().position(|&t| t == "lladdr")
+            && let Some(&mac_str) = tokens.get(pos + 1)
+            && let Ok(mac) = mac_str.parse()
+        {
+            return Some(mac);
+        }
+    }
+    None
+}
+
 /// Extrahiert lokale CIDR-Subnetze aus `ip -4 route show scope link`.
 /// Die CIDR ist bereits das erste whitespace-getrennte Token pro passender Zeile.
 /// Überspringt `default`-Zeilen und das Loopback-Interface.

src/resolver.rs

@@ -8,6 +8,7 @@ use crate::config::AppConfig;
 use crate::error::Mac2IpError;
 use crate::mac::MacAddress;
 use crate::network::{self, NmapRunError, SudoMode};
+use crate::trust::{self, TrustDecision};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum MatchSource {
@@ -44,6 +45,7 @@ pub async fn resolve(
     config: &AppConfig,
     cache: Option<&Cache>,
     json_mode: bool,
+    auto_trust_networks: bool,
 ) -> Result<ResolveResult, Mac2IpError> {
     let now = now_unix();
 
@@ -86,6 +88,20 @@ pub async fn resolve(
 
     // Schritt 3: nmap
     crate::log::debug("resolver", "Kein Treffer via ip neigh, starte nmap-Scan");
+
+    match trust::ensure_network_trusted(config, cache, auto_trust_networks, json_mode, now).await {
+        TrustDecision::Allowed => {}
+        TrustDecision::Denied { gateway_mac } => {
+            crate::log::warn(
+                "resolver",
+                "nmap-Scan übersprungen: Netzwerk nicht als vertrauenswürdig bestätigt",
+            );
+            return Err(Mac2IpError::UntrustedNetwork {
+                gateway_mac: gateway_mac.map(|m| m.to_string()),
+            });
+        }
+    }
+
     let subnets = if !config.networks.is_empty() {
         config.networks.clone()
     } else {

src/trust.rs

@@ -0,0 +1,110 @@
+//! Netzwerk-Vertrauensprüfung vor dem nmap-Scan (Schritt 3).
+//!
+//! Ein ARP-/Ping-Scan ganzer Subnetze ist auf Netzwerken, die man nicht selbst
+//! administriert (Firmen-/Gast-WLAN etc.), potenziell heikel (IDS-Alarm, Verstoß gegen
+//! Nutzungsordnungen). Das aktuelle Netzwerk wird daher über die MAC-Adresse seines
+//! Default-Gateways identifiziert (stabil über IP-/Subnetzwechsel hinweg) und nmap darf
+//! nur laufen, wenn dieses Netzwerk explizit vertraut ist:
+//! - statisch über `AppConfig::trusted_networks` (Config-Datei/CLI/ENV), oder
+//! - dynamisch über eine frühere Bestätigung, die im Cache gespeichert wurde, oder
+//! - automatisch, wenn `--auto-trust-networks` gesetzt ist (merkt sich das Netzwerk
+//!   danach ebenfalls im Cache).
+//!
+//! Ist keins davon der Fall, wird im interaktiven Modus nachgefragt; im --json-Modus
+//! ist keine Rückfrage möglich, daher wird sicherheitshalber abgelehnt.
+
+use std::io::Write;
+
+use crate::cache::Cache;
+use crate::config::AppConfig;
+use crate::mac::MacAddress;
+use crate::network;
+
+pub enum TrustDecision {
+    Allowed,
+    Denied { gateway_mac: Option<MacAddress> },
+}
+
+pub async fn ensure_network_trusted(
+    config: &AppConfig,
+    cache: Option<&Cache>,
+    auto_trust: bool,
+    json_mode: bool,
+    now: i64,
+) -> TrustDecision {
+    let Some(gateway_mac) = network::detect_default_gateway_mac().await else {
+        crate::log::warn(
+            "trust",
+            "Gateway-MAC konnte nicht ermittelt werden, Netzwerk kann nicht identifiziert werden",
+        );
+        if auto_trust {
+            crate::log::warn(
+                "trust",
+                "--auto-trust-networks gesetzt: nmap-Scan wird trotz unbekannter Gateway-MAC ausgeführt",
+            );
+            return TrustDecision::Allowed;
+        }
+        return TrustDecision::Denied { gateway_mac: None };
+    };
+
+    if config.trusted_network_macs().contains(&gateway_mac) {
+        return TrustDecision::Allowed;
+    }
+
+    if let Some(cache) = cache
+        && cache.is_trusted_network(&gateway_mac).await
+    {
+        return TrustDecision::Allowed;
+    }
+
+    if auto_trust {
+        crate::log::info(
+            "trust",
+            &format!(
+                "Netzwerk (Gateway-MAC {gateway_mac}) automatisch als vertrauenswürdig markiert"
+            ),
+        );
+        if let Some(cache) = cache {
+            cache.trust_network(&gateway_mac, now).await;
+        }
+        return TrustDecision::Allowed;
+    }
+
+    if json_mode {
+        // Keine Rückfrage im --json-Modus möglich (stdin ggf. nicht an ein Terminal
+        // gebunden, Ausgabe darf nicht durch einen Prompt verunreinigt werden).
+        return TrustDecision::Denied {
+            gateway_mac: Some(gateway_mac),
+        };
+    }
+
+    if prompt_trust_confirmation(gateway_mac).await {
+        if let Some(cache) = cache {
+            cache.trust_network(&gateway_mac, now).await;
+        }
+        TrustDecision::Allowed
+    } else {
+        TrustDecision::Denied {
+            gateway_mac: Some(gateway_mac),
+        }
+    }
+}
+
+/// Blockierende stdin-Abfrage, daher in `spawn_blocking` ausgelagert, damit der
+/// Tokio-Runtime-Thread währenddessen nicht blockiert.
+async fn prompt_trust_confirmation(gateway_mac: MacAddress) -> bool {
+    tokio::task::spawn_blocking(move || {
+        eprint!(
+            "Unbekanntes Netzwerk (Gateway-MAC {gateway_mac}). nmap-Scan in diesem Netzwerk erlauben und dauerhaft merken? [y/N]: "
+        );
+        let _ = std::io::stderr().flush();
+
+        let mut input = String::new();
+        if std::io::stdin().read_line(&mut input).is_err() {
+            return false;
+        }
+        matches!(input.trim().to_lowercase().as_str(), "y" | "yes" | "j" | "ja")
+    })
+    .await
+    .unwrap_or(false)
+}

tests/cache_ttl.rs

@@ -0,0 +1,28 @@
+use mac2ip::cache::is_expired;
+
+#[test]
+fn fresh_entry_is_not_expired() {
+    assert!(!is_expired(1000, 1000, 1800));
+}
+
+#[test]
+fn entry_exactly_at_ttl_boundary_is_not_expired() {
+    // now - updated_at == ttl_seconds -> nicht abgelaufen (strikt größer nötig)
+    assert!(!is_expired(1000, 1000 + 1800, 1800));
+}
+
+#[test]
+fn entry_one_second_past_ttl_is_expired() {
+    assert!(is_expired(1000, 1000 + 1801, 1800));
+}
+
+#[test]
+fn zero_ttl_expires_immediately_after_any_elapsed_time() {
+    assert!(is_expired(1000, 1001, 0));
+    assert!(!is_expired(1000, 1000, 0));
+}
+
+#[test]
+fn large_gap_is_expired() {
+    assert!(is_expired(0, 1_000_000, 1800));
+}

tests/config_overrides.rs

@@ -0,0 +1,95 @@
+use std::path::PathBuf;
+
+use mac2ip::cli::Cli;
+use mac2ip::config::{AppConfig, apply_cli_overrides};
+use mac2ip::mac::MacAddress;
+
+fn base_cli() -> Cli {
+    Cli {
+        mac: MacAddress::parse("aa:bb:cc:dd:ee:ff").unwrap(),
+        json: false,
+        config: None,
+        log_level: None,
+        cache_ttl_seconds: None,
+        cache_db_path: None,
+        nmap_timeout_seconds: None,
+        networks: None,
+        trusted_networks: None,
+        auto_trust_networks: false,
+    }
+}
+
+#[test]
+fn no_overrides_leaves_config_untouched() {
+    let default_config = AppConfig::default();
+    let mut config = default_config.clone();
+    apply_cli_overrides(&mut config, &base_cli());
+    assert_eq!(config, default_config);
+}
+
+#[test]
+fn overrides_cache_ttl_seconds() {
+    let mut config = AppConfig::default();
+    let mut cli = base_cli();
+    cli.cache_ttl_seconds = Some(60);
+    apply_cli_overrides(&mut config, &cli);
+    assert_eq!(config.cache_ttl_seconds, 60);
+}
+
+#[test]
+fn overrides_cache_db_path() {
+    let mut config = AppConfig::default();
+    let mut cli = base_cli();
+    cli.cache_db_path = Some(PathBuf::from("/tmp/custom-cache.db"));
+    apply_cli_overrides(&mut config, &cli);
+    assert_eq!(config.cache_db_path, PathBuf::from("/tmp/custom-cache.db"));
+}
+
+#[test]
+fn overrides_nmap_timeout_seconds() {
+    let mut config = AppConfig::default();
+    let mut cli = base_cli();
+    cli.nmap_timeout_seconds = Some(30);
+    apply_cli_overrides(&mut config, &cli);
+    assert_eq!(config.nmap_timeout_seconds, 30);
+}
+
+#[test]
+fn overrides_networks() {
+    let mut config = AppConfig::default();
+    let mut cli = base_cli();
+    cli.networks = Some(vec!["10.0.0.0/24".to_string()]);
+    apply_cli_overrides(&mut config, &cli);
+    assert_eq!(config.networks, vec!["10.0.0.0/24".to_string()]);
+}
+
+#[test]
+fn overrides_trusted_networks() {
+    let mut config = AppConfig::default();
+    let mut cli = base_cli();
+    cli.trusted_networks = Some(vec![MacAddress::parse("aa:bb:cc:dd:ee:ff").unwrap()]);
+    apply_cli_overrides(&mut config, &cli);
+    assert_eq!(
+        config.trusted_networks,
+        vec!["aa:bb:cc:dd:ee:ff".to_string()]
+    );
+}
+
+#[test]
+fn partial_overrides_only_touch_provided_fields() {
+    let default_config = AppConfig::default();
+    let mut config = default_config.clone();
+    let mut cli = base_cli();
+    cli.cache_ttl_seconds = Some(999);
+    apply_cli_overrides(&mut config, &cli);
+
+    assert_eq!(config.cache_ttl_seconds, 999);
+    assert_eq!(config.cache_db_path, default_config.cache_db_path);
+    assert_eq!(config.log_level, default_config.log_level);
+    assert_eq!(
+        config.nmap_timeout_seconds,
+        default_config.nmap_timeout_seconds
+    );
+    assert_eq!(config.networks, default_config.networks);
+    assert_eq!(config.trusted_networks, default_config.trusted_networks);
+}

tests/gateway_trust.rs

@@ -0,0 +1,94 @@
+use std::net::IpAddr;
+
+use mac2ip::config::AppConfig;
+use mac2ip::mac::MacAddress;
+use mac2ip::network::{parse_default_gateway_ip, parse_ip_neigh_mac_for_ip};
+
+fn mac(s: &str) -> MacAddress {
+    MacAddress::parse(s).unwrap()
+}
+
+fn ip(s: &str) -> IpAddr {
+    s.parse().unwrap()
+}
+
+// --- parse_default_gateway_ip ---
+
+#[test]
+fn parses_gateway_ip_from_default_route() {
+    let output = "default via 192.168.1.1 dev eth0 proto dhcp metric 100\n";
+    assert_eq!(parse_default_gateway_ip(output), Some(ip("192.168.1.1")));
+}
+
+#[test]
+fn parses_gateway_ip_ignoring_extra_trailing_fields() {
+    let output = "default via 10.0.0.254 dev wlan0 proto static metric 600 onlink\n";
+    assert_eq!(parse_default_gateway_ip(output), Some(ip("10.0.0.254")));
+}
+
+#[test]
+fn no_default_route_returns_none() {
+    assert!(parse_default_gateway_ip("").is_none());
+}
+
+#[test]
+fn missing_via_token_returns_none() {
+    let output = "default dev eth0 proto dhcp metric 100\n";
+    assert!(parse_default_gateway_ip(output).is_none());
+}
+
+// --- parse_ip_neigh_mac_for_ip ---
+
+#[test]
+fn finds_mac_for_matching_ip() {
+    let output = "192.168.1.1 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE\n";
+    let result = parse_ip_neigh_mac_for_ip(output, ip("192.168.1.1"));
+    assert_eq!(result, Some(mac("aa:bb:cc:dd:ee:ff")));
+}
+
+#[test]
+fn ignores_entries_for_other_ips() {
+    let output = "\
+192.168.1.2 dev eth0 lladdr 11:22:33:44:55:66 STALE
+192.168.1.1 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE
+";
+    let result = parse_ip_neigh_mac_for_ip(output, ip("192.168.1.1"));
+    assert_eq!(result, Some(mac("aa:bb:cc:dd:ee:ff")));
+}
+
+#[test]
+fn returns_none_when_ip_not_present() {
+    let output = "192.168.1.2 dev eth0 lladdr 11:22:33:44:55:66 STALE\n";
+    assert!(parse_ip_neigh_mac_for_ip(output, ip("192.168.1.1")).is_none());
+}
+
+// --- AppConfig::trusted_network_macs ---
+
+#[test]
+fn trusted_network_macs_parses_valid_entries() {
+    let config = AppConfig {
+        trusted_networks: vec!["aa:bb:cc:dd:ee:ff".to_string()],
+        ..Default::default()
+    };
+    assert_eq!(
+        config.trusted_network_macs(),
+        vec![mac("aa:bb:cc:dd:ee:ff")]
+    );
+}
+
+#[test]
+fn trusted_network_macs_skips_invalid_entries() {
+    let config = AppConfig {
+        trusted_networks: vec!["not-a-mac".to_string(), "aa:bb:cc:dd:ee:ff".to_string()],
+        ..Default::default()
+    };
+    assert_eq!(
+        config.trusted_network_macs(),
+        vec![mac("aa:bb:cc:dd:ee:ff")]
+    );
+}
+
+#[test]
+fn trusted_network_macs_empty_by_default() {
+    assert!(AppConfig::default().trusted_network_macs().is_empty());
+}

tests/ip_neigh_parsing.rs

@@ -0,0 +1,52 @@
+use mac2ip::mac::MacAddress;
+use mac2ip::network::parse_ip_neigh_output;
+
+fn mac(s: &str) -> MacAddress {
+    MacAddress::parse(s).unwrap()
+}
+
+#[test]
+fn finds_matching_entry() {
+    let output = "192.168.1.5 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE\n";
+    let ip = parse_ip_neigh_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn picks_correct_entry_among_multiple() {
+    let output = "\
+192.168.1.4 dev eth0 lladdr 11:22:33:44:55:66 STALE
+192.168.1.5 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE
+192.168.1.6 dev eth0 lladdr 77:88:99:aa:bb:cc STALE
+";
+    let ip = parse_ip_neigh_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn skips_entries_without_lladdr() {
+    let output = "\
+192.168.1.7 dev eth0  FAILED
+192.168.1.5 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE
+";
+    let ip = parse_ip_neigh_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn returns_none_when_no_match() {
+    let output = "192.168.1.4 dev eth0 lladdr 11:22:33:44:55:66 STALE\n";
+    assert!(parse_ip_neigh_output(output, &mac("aa:bb:cc:dd:ee:ff")).is_none());
+}
+
+#[test]
+fn tolerates_blank_lines_and_extra_whitespace() {
+    let output = "\n   \n192.168.1.5   dev   eth0   lladdr   aa:bb:cc:dd:ee:ff   REACHABLE\n\n";
+    let ip = parse_ip_neigh_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn empty_output_returns_none() {
+    assert!(parse_ip_neigh_output("", &mac("aa:bb:cc:dd:ee:ff")).is_none());
+}

tests/json_output.rs

@@ -0,0 +1,90 @@
+use std::net::IpAddr;
+use std::str::FromStr;
+
+use mac2ip::error::Mac2IpError;
+use mac2ip::mac::MacAddress;
+use mac2ip::output::{SuccessJson, failure_json, success_json};
+use mac2ip::resolver::{MatchSource, ResolveResult};
+
+fn mac() -> MacAddress {
+    MacAddress::parse("aa:bb:cc:dd:ee:ff").unwrap()
+}
+
+fn ip() -> IpAddr {
+    IpAddr::from_str("192.168.1.5").unwrap()
+}
+
+#[test]
+fn success_json_has_expected_shape_for_cache_source() {
+    let result = ResolveResult {
+        mac: mac(),
+        ip: ip(),
+        source: MatchSource::Cache,
+    };
+    let json = success_json(&result);
+    assert_eq!(
+        json,
+        SuccessJson {
+            status: "ok",
+            mac: "aa:bb:cc:dd:ee:ff".to_string(),
+            ip: "192.168.1.5".to_string(),
+            source: "cache",
+        }
+    );
+}
+
+#[test]
+fn success_json_has_expected_shape_for_arp_source() {
+    let result = ResolveResult {
+        mac: mac(),
+        ip: ip(),
+        source: MatchSource::Arp,
+    };
+    assert_eq!(success_json(&result).source, "arp");
+}
+
+#[test]
+fn success_json_has_expected_shape_for_nmap_source() {
+    let result = ResolveResult {
+        mac: mac(),
+        ip: ip(),
+        source: MatchSource::Nmap,
+    };
+    assert_eq!(success_json(&result).source, "nmap");
+}
+
+#[test]
+fn failure_json_has_expected_shape() {
+    let err = Mac2IpError::NotFound {
+        mac: mac().to_string(),
+    };
+    let json = failure_json(&mac(), &err);
+    assert_eq!(json.status, "error");
+    assert_eq!(json.mac, "aa:bb:cc:dd:ee:ff");
+    assert_eq!(json.error, err.to_string());
+}
+
+#[test]
+fn success_json_serializes_with_stable_field_names() {
+    let result = ResolveResult {
+        mac: mac(),
+        ip: ip(),
+        source: MatchSource::Arp,
+    };
+    let value = serde_json::to_value(success_json(&result)).unwrap();
+    assert_eq!(value["status"], "ok");
+    assert_eq!(value["mac"], "aa:bb:cc:dd:ee:ff");
+    assert_eq!(value["ip"], "192.168.1.5");
+    assert_eq!(value["source"], "arp");
+}
+
+#[test]
+fn failure_json_serializes_with_stable_field_names() {
+    let err = Mac2IpError::NotFound {
+        mac: mac().to_string(),
+    };
+    let value = serde_json::to_value(failure_json(&mac(), &err)).unwrap();
+    assert_eq!(value["status"], "error");
+    assert_eq!(value["mac"], "aa:bb:cc:dd:ee:ff");
+    assert!(value["error"].is_string());
+}

tests/mac_address.rs

@@ -0,0 +1,65 @@
+use mac2ip::mac::MacAddress;
+
+#[test]
+fn parses_lowercase_colon_separated() {
+    let mac = MacAddress::parse("aa:bb:cc:dd:ee:ff").unwrap();
+    assert_eq!(mac.to_lower_colon(), "aa:bb:cc:dd:ee:ff");
+}
+
+#[test]
+fn parses_uppercase_colon_separated() {
+    let mac = MacAddress::parse("AA:BB:CC:DD:EE:FF").unwrap();
+    assert_eq!(mac.to_lower_colon(), "aa:bb:cc:dd:ee:ff");
+    assert_eq!(mac.to_upper_colon(), "AA:BB:CC:DD:EE:FF");
+}
+
+#[test]
+fn parses_hyphen_separated() {
+    let mac = MacAddress::parse("aa-bb-cc-dd-ee-ff").unwrap();
+    assert_eq!(mac.to_lower_colon(), "aa:bb:cc:dd:ee:ff");
+}
+
+#[test]
+fn parses_mixed_case() {
+    let mac = MacAddress::parse("Aa:bB:Cc:dD:eE:fF").unwrap();
+    assert_eq!(mac.to_lower_colon(), "aa:bb:cc:dd:ee:ff");
+}
+
+#[test]
+fn different_notations_are_equal_after_canonicalization() {
+    let a = MacAddress::parse("AA:BB:CC:DD:EE:FF").unwrap();
+    let b = MacAddress::parse("aa-bb-cc-dd-ee-ff").unwrap();
+    assert_eq!(a, b);
+}
+
+#[test]
+fn from_str_matches_parse() {
+    use std::str::FromStr;
+    let mac: MacAddress = "aa:bb:cc:dd:ee:ff".parse().unwrap();
+    assert_eq!(mac, MacAddress::from_str("aa:bb:cc:dd:ee:ff").unwrap());
+}
+
+#[test]
+fn rejects_too_short() {
+    assert!(MacAddress::parse("aa:bb:cc:dd:ee").is_err());
+}
+
+#[test]
+fn rejects_too_long() {
+    assert!(MacAddress::parse("aa:bb:cc:dd:ee:ff:00").is_err());
+}
+
+#[test]
+fn rejects_non_hex_characters() {
+    assert!(MacAddress::parse("gg:bb:cc:dd:ee:ff").is_err());
+}
+
+#[test]
+fn rejects_wrong_separator_count() {
+    assert!(MacAddress::parse("aabbccddeeff").is_err());
+}
+
+#[test]
+fn rejects_empty_string() {
+    assert!(MacAddress::parse("").is_err());
+}

tests/nmap_parsing.rs

@@ -0,0 +1,74 @@
+use mac2ip::mac::MacAddress;
+use mac2ip::network::parse_nmap_output;
+
+fn mac(s: &str) -> MacAddress {
+    MacAddress::parse(s).unwrap()
+}
+
+#[test]
+fn finds_matching_host_among_multiple_blocks() {
+    let output = "\
+Nmap scan report for 192.168.1.4
+Host is up (0.0010s latency).
+MAC Address: 11:22:33:44:55:66 (Some Vendor)
+Nmap scan report for 192.168.1.5
+Host is up (0.0020s latency).
+MAC Address: AA:BB:CC:DD:EE:FF (Other Vendor)
+Nmap scan report for 192.168.1.6
+Host is up (0.0030s latency).
+MAC Address: 77:88:99:AA:BB:CC (Third Vendor)
+";
+    let ip = parse_nmap_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn host_without_mac_line_does_not_leak_into_next_block() {
+    let output = "\
+Nmap scan report for 192.168.1.4
+Host is up (0.0010s latency).
+Nmap scan report for 192.168.1.5
+Host is up (0.0020s latency).
+MAC Address: AA:BB:CC:DD:EE:FF (Vendor)
+";
+    // Even if we searched for a MAC that never appears, the missing MAC line for
+    // 192.168.1.4 must not accidentally get associated with 192.168.1.5's MAC.
+    assert!(parse_nmap_output(output, &mac("11:22:33:44:55:66")).is_none());
+    let ip = parse_nmap_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn parses_hostname_plus_ip_form() {
+    let output = "\
+Nmap scan report for myhost.lan (192.168.1.5)
+Host is up (0.0020s latency).
+MAC Address: AA:BB:CC:DD:EE:FF (Vendor)
+";
+    let ip = parse_nmap_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn is_case_insensitive_against_uppercase_nmap_output() {
+    let output = "\
+Nmap scan report for 192.168.1.5
+MAC Address: AA:BB:CC:DD:EE:FF (Vendor)
+";
+    let ip = parse_nmap_output(output, &mac("aa:bb:cc:dd:ee:ff")).unwrap();
+    assert_eq!(ip.to_string(), "192.168.1.5");
+}
+
+#[test]
+fn returns_none_when_no_match() {
+    let output = "\
+Nmap scan report for 192.168.1.4
+MAC Address: 11:22:33:44:55:66 (Vendor)
+";
+    assert!(parse_nmap_output(output, &mac("aa:bb:cc:dd:ee:ff")).is_none());
+}
+
+#[test]
+fn empty_output_returns_none() {
+    assert!(parse_nmap_output("", &mac("aa:bb:cc:dd:ee:ff")).is_none());
+}

tests/subnet_parsing.rs

@@ -0,0 +1,40 @@
+use mac2ip::network::parse_local_subnets;
+
+#[test]
+fn extracts_cidrs_from_multiple_interfaces() {
+    let output = "\
+192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.23
+10.0.0.0/8 dev wlan0 proto kernel scope link src 10.0.0.5
+";
+    let subnets = parse_local_subnets(output);
+    assert_eq!(
+        subnets,
+        vec!["192.168.1.0/24".to_string(), "10.0.0.0/8".to_string()]
+    );
+}
+
+#[test]
+fn excludes_default_route() {
+    let output = "\
+default via 192.168.1.1 dev eth0
+192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.23
+";
+    let subnets = parse_local_subnets(output);
+    assert_eq!(subnets, vec!["192.168.1.0/24".to_string()]);
+}
+
+#[test]
+fn excludes_loopback_interface() {
+    let output = "\
+127.0.0.0/8 dev lo proto kernel scope link src 127.0.0.1
+192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.23
+";
+    let subnets = parse_local_subnets(output);
+    assert_eq!(subnets, vec!["192.168.1.0/24".to_string()]);
+}
+
+#[test]
+fn empty_input_returns_empty_vec() {
+    let subnets = parse_local_subnets("");
+    assert!(subnets.is_empty());
+}