Merge pull request 'Merge dev in testing: Erstellt das Projekt' (#3) from dev into testing
Unit-Tests / Unit-Tests (pull_request) Skipped
Testing Build, Publish & Preview Release / Erkenne relevante Code-Änderungen (push) Successful in 9s
Auto-PR (Testing → Main) / Erstelle automatisch PR von testing nach main (push) Successful in 13s
TruffleHog Secret Scan / TruffleHog (push) Successful in 19s
Security Scans / Trivy & OSV-Scanner (push) Successful in 35s
TruffleHog Secret Scan / TruffleHog (pull_request) Successful in 24s
Security Scans / Trivy & OSV-Scanner (pull_request) Successful in 32s
Testing Build, Publish & Preview Release / Build, Publish Packages (Testing) & Create Preview Release (push) Failing after 13m33s
Unit-Tests / Unit-Tests (pull_request) Skipped
Testing Build, Publish & Preview Release / Erkenne relevante Code-Änderungen (push) Successful in 9s
Auto-PR (Testing → Main) / Erstelle automatisch PR von testing nach main (push) Successful in 13s
TruffleHog Secret Scan / TruffleHog (push) Successful in 19s
Security Scans / Trivy & OSV-Scanner (push) Successful in 35s
TruffleHog Secret Scan / TruffleHog (pull_request) Successful in 24s
Security Scans / Trivy & OSV-Scanner (pull_request) Successful in 32s
Testing Build, Publish & Preview Release / Build, Publish Packages (Testing) & Create Preview Release (push) Failing after 13m33s
Reviewed-on: #3
This commit was merged in pull request #3.
This commit is contained in:
@@ -9,7 +9,7 @@ jobs:
|
||||
renovate:
|
||||
name: Dependency-Updates prüfen & Pull Requests erstellen
|
||||
runs-on: ubuntu-latest
|
||||
container: ghcr.io/renovatebot/renovate:44.82.0
|
||||
container: ghcr.io/renovatebot/renovate:44.83.0
|
||||
steps:
|
||||
- name: Renovate ausführen
|
||||
run: renovate
|
||||
|
||||
Generated
+6
@@ -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>
|
||||
|
||||
Generated
+1
@@ -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" />
|
||||
|
||||
@@ -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
|
||||
│ ├── testing.yaml # CI/CD: Preview-Builds, Docker-Image & Testing-Pakete
|
||||
│ ├── main.yaml # CI/CD: Stabile Builds, Multi-Arch-Paketierung, Release & Upload
|
||||
│ ├── 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),
|
||||
@@ -126,6 +152,17 @@ Alle Workflows liegen unter `.gitea/workflows/` und nutzen gecachte Abhängigkei
|
||||
- **`qodana.yaml`**: Konfiguration für JetBrains Qodana (statische Codeanalyse, Profil `qodana.starter`); wird über eine externe/IDE-seitige Qodana-CI-Integration ausgeführt, nicht über einen eigenen Gitea-Workflow in diesem Template.
|
||||
- **`renovate.yaml`** (Trigger: wöchentlich montags 04:00 UTC, `workflow_dispatch`): Führt Renovate (Container-Image, gepinnte Version) gegen die Gitea-Plattform aus und erstellt Pull Requests für veraltete Abhängigkeiten gemäß `renovate.json`.
|
||||
|
||||
### 5.2.1 Bekannte Sicherheits-Workarounds (temporär, mit Revert-Bedingung)
|
||||
|
||||
Workarounds für Schwachstellen in transitiven Abhängigkeiten, die nicht direkt
|
||||
per Versions-Bump behoben werden können (z. B. weil ein Zwischenpaket eine zu
|
||||
enge Versionsanforderung pinnt). Vor jedem Renovate-Merge/Dependency-Update
|
||||
prüfen, ob die Revert-Bedingung inzwischen erfüllt ist.
|
||||
|
||||
| Advisory | Betroffenes Paket | Workaround | Wo dokumentiert | Revert-Bedingung |
|
||||
| :--- | :--- | :--- | :--- | :--- |
|
||||
| [RUSTSEC-2026-0253](https://rustsec.org/advisories/RUSTSEC-2026-0253.html) (Use-after-free in `LruCache::pop()`) | `lru` < 0.18.2, transitiv über `turso -> turso_core -> tantivy` | `fts`-Default-Feature von `turso` deaktiviert (`Cargo.toml`) — mac2ip nutzt keine Volltextsuche, dadurch entfällt `tantivy`/`lru` komplett aus dem Dependency-Baum | Kommentar direkt über der `turso`-Zeile in `Cargo.toml` | Sobald `cargo update -p lru --precise 0.18.2` erfolgreich ist (d. h. eine stabile `turso`-Version eine `tantivy`-Version mit `lru >= 0.18.2` zulässt): `turso`-Zeile zurück auf `turso = "0.7"` (oder aktueller) ändern, `cargo update -p turso`, und `cargo tree -i lru` zur Kontrolle. |
|
||||
|
||||
### 5.3 Renovate-Konfiguration (`renovate.json`)
|
||||
- Basis-Branch für PRs: `dev`.
|
||||
- Gruppiert Updates nach `Gitea Actions`, `Cargo Dependencies` und `Docker-Images`.
|
||||
|
||||
Generated
+2843
-2
File diff suppressed because it is too large
Load Diff
+56
-23
@@ -1,15 +1,36 @@
|
||||
[package]
|
||||
name = "rust-template" # TODO: Projektnamen setzen
|
||||
version = "0.0.0" # TODO: Initiale Version setzen (z. B. 0.1.0)
|
||||
name = "mac2ip"
|
||||
version = "1.0.0"
|
||||
edition = "2024"
|
||||
authors = ['DragonSlayer_14'] # TODO: Autor(en) anpassen
|
||||
authors = ['DragonSlayer_14']
|
||||
readme = "README.md"
|
||||
license = "GPL-3.0-or-later" # TODO: Lizenz prüfen / anpassen
|
||||
repository = "https://gitea.creative-dragonslayer.de/Linuxapps/rust-template" # TODO: Repository-URL anpassen
|
||||
description = "" # TODO: Kurze Projektbeschreibung setzen
|
||||
license = "GPL-3.0-or-later"
|
||||
repository = "https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip"
|
||||
description = "Findet zuverlässig die aktuelle IP-Adresse zu einer MAC-Adresse im lokalen Netzwerk (Cache, ip neigh, nmap)"
|
||||
|
||||
[dependencies]
|
||||
# TODO: Projektabhängigkeiten hier hinzufügen
|
||||
config-ctdra = { version = "1.0.6", registry = "gitea" }
|
||||
logger-ctdra = { version = "1.0.5", registry = "gitea" }
|
||||
sudo-ctdra = { version = "1.0.1", registry = "gitea" }
|
||||
tokio = { version = "1", features = ["macros", "rt-multi-thread", "process", "time"] }
|
||||
# WORKAROUND für RUSTSEC-2026-0253 (Use-after-free in lru < 0.18.2): das
|
||||
# Default-Feature "fts" zieht tantivy 0.26.2 -> lru "^0.16.3" (verwundbar) ein,
|
||||
# obwohl mac2ip keine Volltextsuche nutzt. "fts" bleibt deaktiviert, bis eine
|
||||
# stabile turso-Version tantivy>=eine lru>=0.18.2 zulassende Version pinnt.
|
||||
#
|
||||
# Revert, sobald behoben (z. B. Renovate-PR/manuelle Prüfung):
|
||||
# 1. `cargo update -p lru --precise 0.18.2` probieren - schlägt fehl, solange
|
||||
# das o. g. Problem besteht (siehe Fehlermeldung mit dem Pfad turso ->
|
||||
# turso_core -> tantivy -> lru "^0.16.3").
|
||||
# 2. Sobald das gelingt (oder eine neue stabile turso-Version das Problem
|
||||
# upstream behebt): diese Zeile zurück zu `turso = "0.7"` (oder aktueller)
|
||||
# ändern und `cargo update -p turso` laufen lassen.
|
||||
# 3. `cargo tree -i lru` zur Kontrolle - keine Version < 0.18.2 mehr vorhanden.
|
||||
turso = { version = "0.7", default-features = false, features = ["mimalloc"] }
|
||||
clap = { version = "4", features = ["derive", "env"] }
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
thiserror = "2"
|
||||
|
||||
[profile.release]
|
||||
debug = "none"
|
||||
@@ -17,28 +38,40 @@ debug = "none"
|
||||
# --- Paketierungs-Metadaten für Linux-Distributionen ---
|
||||
|
||||
[package.metadata.deb]
|
||||
name = "" # TODO: Optional (Standard: package.name)
|
||||
maintainer = "" # TODO: Maintainer setzen (z. B. "Max Mustermann <max@example.com>")
|
||||
copyright = "" # TODO: Copyright-Hinweis setzen (z. B. "2026 Max Mustermann")
|
||||
section = "utils" # TODO: Debian-Sektion anpassen (z. B. utils, net, admin)
|
||||
priority = "optional" # TODO: Debian-Priorität anpassen (z. B. optional)
|
||||
depends = "$auto" # TODO: Abhängigkeiten definieren ($auto ermittelt via ldd automatisch)
|
||||
name = "mac2ip"
|
||||
maintainer = "DragonSlayer_14"
|
||||
copyright = "2026 DragonSlayer_14"
|
||||
section = "net"
|
||||
priority = "optional"
|
||||
depends = "$auto, sudo, iproute2, iputils-ping, nmap"
|
||||
maintainer-scripts = "packaging/deb"
|
||||
extended-description = """\
|
||||
""" # TODO: Ausführliche Paketbeschreibung setzen
|
||||
mac2ip ermittelt zuverlässig die aktuelle IP-Adresse zu einer gegebenen MAC-Adresse
|
||||
im lokalen Netzwerk. Dazu wird zunächst ein globaler, systemweiter Cache geprüft,
|
||||
danach die 'ip neigh'-Nachbartabelle (moderner Ersatz für 'arp'), und als letzter
|
||||
Schritt ein nmap-Ping-/ARP-Scan der lokal angeschlossenen Subnetze durchgeführt.\
|
||||
"""
|
||||
assets = [
|
||||
# TODO: Bei Bedarf zusätzliche Dateien / Assets definieren, z. B.:
|
||||
# ["target/release/rust-template", "usr/bin/", "755"],
|
||||
["target/release/mac2ip", "usr/bin/mac2ip", "755"],
|
||||
["README.md", "usr/share/doc/mac2ip/README.md", "644"],
|
||||
["LICENSE", "usr/share/doc/mac2ip/copyright", "644"],
|
||||
]
|
||||
|
||||
[package.metadata.generate-rpm]
|
||||
assets = [
|
||||
# TODO: Bei Bedarf zusätzliche Dateien / Assets definieren, z. B.:
|
||||
# { source = "target/release/rust-template", dest = "/usr/bin/rust-template", mode = "755" },
|
||||
{ source = "target/release/mac2ip", dest = "/usr/bin/mac2ip", mode = "755" },
|
||||
{ source = "README.md", dest = "/usr/share/doc/mac2ip/README.md", mode = "644", doc = true },
|
||||
{ source = "LICENSE", dest = "/usr/share/licenses/mac2ip/LICENSE", mode = "644", license = true },
|
||||
]
|
||||
requires = { } # TODO: RPM-Abhängigkeiten definieren, z. B. { "glibc" = "*" }
|
||||
requires = { "sudo" = "*", "iproute" = "*", "iputils" = "*", "nmap" = "*" }
|
||||
post_install_script = """
|
||||
mkdir -p /var/lib/mac2ip
|
||||
chmod 0777 /var/lib/mac2ip
|
||||
"""
|
||||
|
||||
[package.metadata.arch]
|
||||
pkgrel = "1" # TODO: Standard Release-Nummer (wird in CI durch get-build-number.py dynamisch überschrieben)
|
||||
arch = "x86_64" # TODO: Zielarchitektur (z. B. x86_64, aarch64, i686)
|
||||
depends = ["gcc-libs", "glibc"] # TODO: Arch Linux Paketabhängigkeiten definieren
|
||||
optdepends = [] # TODO: Optionale Abhängigkeiten definieren (z. B. ["curl: für Web-Downloads"])
|
||||
pkgrel = "1"
|
||||
arch = "x86_64"
|
||||
depends = ["gcc-libs", "glibc", "sudo", "iproute2", "iputils", "nmap"]
|
||||
optdepends = []
|
||||
install_script = "packaging/arch/mac2ip.install"
|
||||
|
||||
@@ -1,29 +1,134 @@
|
||||
# rust-template
|
||||
# mac2ip
|
||||
|
||||
Ein modernes Template-Projekt für Rust-basierte Linux-Anwendungen und Kommandozeilen-Tools (CLI).
|
||||
[](https://gitea.creative-dragonslayer.de/Linuxapps/Mac2Ip/actions?workflow=main.yaml)
|
||||
[](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.
|
||||
- **Multi-Architektur-Kompilierung**:
|
||||
- `x86_64-unknown-linux-gnu` (64-Bit x86)
|
||||
- `aarch64-unknown-linux-gnu` (64-Bit ARM / ARM64)
|
||||
- `i686-unknown-linux-gnu` (32-Bit x86)
|
||||
- **Linux-Paketierung out-of-the-box**:
|
||||
- **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**:
|
||||
- `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.
|
||||
- **Automatisierte Versions- & Build-Nummern**:
|
||||
- `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.
|
||||
- **Zuverlässige MAC → IP-Auflösung** über Cache, `ip neigh` und `nmap`, jeweils mit Erreichbarkeitsprüfung per Ping.
|
||||
- **Globaler, systemweiter Cache** (via [`turso`](https://turso.tech), lokal-dateibasiert) mit konfigurierbarer TTL.
|
||||
- **Maschinenlesbare Ausgabe** über `--json` (unattended-Modus) — unterdrückt dabei alle sonstigen Log-Ausgaben.
|
||||
- **Vollständig über die Kommandozeile konfigurierbar**, mit Overlay-Kette CLI > Umgebungsvariable > Konfigurationsdatei > Standardwert.
|
||||
- **Funktioniert mit und ohne `sudo`** — Root-Rechte werden nur für den nmap-Schritt benötigt.
|
||||
- **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.
|
||||
|
||||
---
|
||||
|
||||
## CLI-Nutzung
|
||||
|
||||
```bash
|
||||
mac2ip <MAC> [OPTIONEN]
|
||||
```
|
||||
|
||||
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,11 +141,24 @@ 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)
|
||||
│ ├── 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
|
||||
│ ├── 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
|
||||
@@ -49,36 +167,13 @@ Dieses Template bietet eine vorkonfigurierte Umgebung für modernes Rust (Editio
|
||||
|
||||
---
|
||||
|
||||
## 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.
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
post_install() {
|
||||
mkdir -p /var/lib/mac2ip
|
||||
chmod 0777 /var/lib/mac2ip
|
||||
}
|
||||
|
||||
post_upgrade() {
|
||||
post_install
|
||||
}
|
||||
Executable
+7
@@ -0,0 +1,7 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
|
||||
mkdir -p /var/lib/mac2ip
|
||||
chmod 0777 /var/lib/mac2ip
|
||||
|
||||
exit 0
|
||||
+14
-1
@@ -87,6 +87,7 @@ def build_package(target_triple=None, target_arch=None, pkgrel=None):
|
||||
|
||||
depends = arch_meta.get("depends", ["gcc-libs", "glibc"])
|
||||
optdepends = arch_meta.get("optdepends", [])
|
||||
install_rel_path = arch_meta.get("install_script")
|
||||
|
||||
with tempfile.TemporaryDirectory() as build_dir:
|
||||
bin_dir = os.path.join(build_dir, "usr/bin")
|
||||
@@ -102,6 +103,14 @@ 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)
|
||||
|
||||
has_install_scriptlet = False
|
||||
if install_rel_path and os.path.exists(install_rel_path):
|
||||
has_install_scriptlet = True
|
||||
subprocess.run(
|
||||
["install", "-m", "644", install_rel_path, os.path.join(build_dir, ".INSTALL")],
|
||||
check=True,
|
||||
)
|
||||
|
||||
installed_size = subprocess.check_output(["du", "-sb", build_dir]).decode().split()[0]
|
||||
builddate = str(int(time.time()))
|
||||
|
||||
@@ -128,7 +137,11 @@ 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")
|
||||
subprocess.run(["tar", "--zstd", "-cf", output_file, ".PKGINFO", "usr"], cwd=build_dir, check=True)
|
||||
tar_members = [".PKGINFO"]
|
||||
if has_install_scriptlet:
|
||||
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}")
|
||||
|
||||
|
||||
|
||||
+258
@@ -0,0 +1,258 @@
|
||||
//! Globaler, systemweiter Cache (MAC -> IP) auf Basis der `turso`-Crate (lokale Datei).
|
||||
//!
|
||||
//! Der Cache liegt absichtlich an einem einzigen, für alle Nutzer gemeinsamen Pfad
|
||||
//! (Standard: `/var/lib/mac2ip/cache.db`). Ist dieser Pfad nicht anlegbar/beschreibbar
|
||||
//! (z. B. bei einem Entwicklungslauf ohne vorherige Paketinstallation), wird der Cache
|
||||
//! für den aktuellen Lauf einfach deaktiviert (Warnung, best-effort) - es gibt bewusst
|
||||
//! KEINEN Fallback auf einen Pro-User-Pfad, da der Cache explizit global sein soll.
|
||||
|
||||
use std::net::IpAddr;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::mac::MacAddress;
|
||||
|
||||
#[cfg(unix)]
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
||||
pub struct CacheEntry {
|
||||
pub ip: IpAddr,
|
||||
#[allow(dead_code)]
|
||||
pub source: String,
|
||||
pub updated_at: i64,
|
||||
}
|
||||
|
||||
pub struct Cache {
|
||||
conn: turso::Connection,
|
||||
}
|
||||
|
||||
impl Cache {
|
||||
async fn init_schema(&self) -> turso::Result<()> {
|
||||
self.conn
|
||||
.execute(
|
||||
"CREATE TABLE IF NOT EXISTS mac_ip_cache (\
|
||||
mac TEXT PRIMARY KEY, \
|
||||
ip TEXT NOT NULL, \
|
||||
source TEXT NOT NULL, \
|
||||
updated_at INTEGER NOT NULL\
|
||||
)",
|
||||
(),
|
||||
)
|
||||
.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();
|
||||
let mut rows = match self
|
||||
.conn
|
||||
.query(
|
||||
"SELECT ip, source, updated_at FROM mac_ip_cache WHERE mac = ?1",
|
||||
(key,),
|
||||
)
|
||||
.await
|
||||
{
|
||||
Ok(rows) => rows,
|
||||
Err(e) => {
|
||||
crate::log::warn("cache", &format!("Cache-Lesefehler: {e}"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
match rows.next().await {
|
||||
Ok(Some(row)) => {
|
||||
let ip_str: String = row.get(0).ok()?;
|
||||
let source: String = row.get(1).ok()?;
|
||||
let updated_at: i64 = row.get(2).ok()?;
|
||||
ip_str.parse().ok().map(|ip| CacheEntry {
|
||||
ip,
|
||||
source,
|
||||
updated_at,
|
||||
})
|
||||
}
|
||||
Ok(None) => None,
|
||||
Err(e) => {
|
||||
crate::log::warn("cache", &format!("Cache-Lesefehler: {e}"));
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Best-effort Upsert: Fehler werden nur geloggt, niemals propagiert - ein
|
||||
/// Cache-Schreibfehler darf den 3-Stufen-Lookup nie zum Scheitern bringen.
|
||||
pub async fn upsert(&self, mac: &MacAddress, ip: IpAddr, source: &str, now: i64) {
|
||||
let key = mac.to_lower_colon();
|
||||
if let Err(e) = self
|
||||
.conn
|
||||
.execute(
|
||||
"INSERT INTO mac_ip_cache (mac, ip, source, updated_at) VALUES (?1, ?2, ?3, ?4) \
|
||||
ON CONFLICT(mac) DO UPDATE SET ip = excluded.ip, source = excluded.source, updated_at = excluded.updated_at",
|
||||
(key, ip.to_string(), source.to_string(), now),
|
||||
)
|
||||
.await
|
||||
{
|
||||
crate::log::warn("cache", &format!("Cache-Schreibfehler (ignoriert): {e}"));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Reine, injectable-Zeit-Funktion - unit-testbar ohne echte Systemzeit.
|
||||
pub fn is_expired(updated_at: i64, now: i64, ttl_seconds: u64) -> bool {
|
||||
now.saturating_sub(updated_at) as u64 > ttl_seconds
|
||||
}
|
||||
|
||||
fn ensure_cache_dir(dir: &Path) -> Result<(), String> {
|
||||
if !dir.exists() {
|
||||
std::fs::create_dir_all(dir).map_err(|e| {
|
||||
format!(
|
||||
"Verzeichnis '{}' konnte nicht angelegt werden: {e}",
|
||||
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}"))?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn chmod_cache_sidecars(db_path: &Path) {
|
||||
#[cfg(unix)]
|
||||
for suffix in ["", "-wal", "-shm", "-journal"] {
|
||||
let p = PathBuf::from(format!("{}{suffix}", db_path.display()));
|
||||
if p.exists() {
|
||||
let _ = std::fs::set_permissions(&p, std::fs::Permissions::from_mode(0o666));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Best-effort Cache-Öffnung: gibt `None` zurück (statt Fehler), wenn der Cache aus
|
||||
/// irgendeinem Grund nicht verfügbar ist - der Aufrufer führt den 3-Stufen-Algorithmus
|
||||
/// dann einfach ohne Cache aus.
|
||||
pub async fn try_open_cache(db_path: &Path) -> Option<Cache> {
|
||||
if let Some(dir) = db_path.parent()
|
||||
&& let Err(reason) = ensure_cache_dir(dir)
|
||||
{
|
||||
crate::log::warn("cache", &format!("Cache deaktiviert: {reason}"));
|
||||
return None;
|
||||
}
|
||||
|
||||
let db = match turso::Builder::new_local(db_path.to_string_lossy().as_ref())
|
||||
.build()
|
||||
.await
|
||||
{
|
||||
Ok(db) => db,
|
||||
Err(e) => {
|
||||
crate::log::warn(
|
||||
"cache",
|
||||
&format!("Cache-Datenbank konnte nicht geöffnet werden: {e}"),
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
let conn = match db.connect() {
|
||||
Ok(c) => c,
|
||||
Err(e) => {
|
||||
crate::log::warn("cache", &format!("Cache-Verbindung fehlgeschlagen: {e}"));
|
||||
return None;
|
||||
}
|
||||
};
|
||||
|
||||
let cache = Cache { conn };
|
||||
if let Err(e) = cache.init_schema().await {
|
||||
crate::log::warn(
|
||||
"cache",
|
||||
&format!("Cache-Schema konnte nicht initialisiert werden: {e}"),
|
||||
);
|
||||
return None;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
//! Kommandozeilen-Interface.
|
||||
|
||||
use std::path::PathBuf;
|
||||
|
||||
use clap::{Parser, ValueEnum};
|
||||
|
||||
use crate::mac::MacAddress;
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
#[command(
|
||||
name = "mac2ip",
|
||||
author,
|
||||
version,
|
||||
about = "Findet zuverlässig die aktuelle IP-Adresse zu einer MAC-Adresse im lokalen Netzwerk",
|
||||
long_about = None
|
||||
)]
|
||||
pub struct Cli {
|
||||
/// MAC-Adresse, deren aktuelle IP-Adresse ermittelt werden soll (z. B. aa:bb:cc:dd:ee:ff)
|
||||
pub mac: MacAddress,
|
||||
|
||||
/// Gibt das Ergebnis als einzeiliges JSON-Objekt aus; unterdrückt alle sonstigen Log-Ausgaben
|
||||
#[arg(long)]
|
||||
pub json: bool,
|
||||
|
||||
/// Benutzerdefinierter Pfad zur Konfigurationsdatei
|
||||
#[arg(long)]
|
||||
pub config: Option<PathBuf>,
|
||||
|
||||
/// Logging-Level (error, warn, info, debug)
|
||||
#[arg(long, value_enum, env = "MAC2IP_LOG_LEVEL")]
|
||||
pub log_level: Option<LogLevelArg>,
|
||||
|
||||
/// Cache-TTL in Sekunden (Standard: 1800)
|
||||
#[arg(long, env = "MAC2IP_CACHE_TTL_SECONDS")]
|
||||
pub cache_ttl_seconds: Option<u64>,
|
||||
|
||||
/// Pfad zur globalen Cache-Datenbankdatei (Standard: /var/lib/mac2ip/cache.db)
|
||||
#[arg(long, env = "MAC2IP_CACHE_DB_PATH")]
|
||||
pub cache_db_path: Option<PathBuf>,
|
||||
|
||||
/// Timeout in Sekunden für einen einzelnen nmap-Subnetz-Scan (Standard: 120)
|
||||
#[arg(long, env = "MAC2IP_NMAP_TIMEOUT_SECONDS")]
|
||||
pub nmap_timeout_seconds: Option<u64>,
|
||||
|
||||
/// 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)]
|
||||
pub enum LogLevelArg {
|
||||
Error,
|
||||
Warn,
|
||||
Info,
|
||||
Debug,
|
||||
}
|
||||
|
||||
impl LogLevelArg {
|
||||
pub fn as_str(&self) -> &'static str {
|
||||
match self {
|
||||
Self::Error => "error",
|
||||
Self::Warn => "warn",
|
||||
Self::Info => "info",
|
||||
Self::Debug => "debug",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<LogLevelArg> for logger_ctdra::LogLevel {
|
||||
fn from(value: LogLevelArg) -> Self {
|
||||
match value {
|
||||
LogLevelArg::Error => logger_ctdra::LogLevel::Error,
|
||||
LogLevelArg::Warn => logger_ctdra::LogLevel::Warn,
|
||||
LogLevelArg::Info => logger_ctdra::LogLevel::Info,
|
||||
LogLevelArg::Debug => logger_ctdra::LogLevel::Debug,
|
||||
}
|
||||
}
|
||||
}
|
||||
+116
@@ -0,0 +1,116 @@
|
||||
//! Anwendungskonfiguration: persistente Datei (via `config-ctdra`) + CLI-Overlay.
|
||||
|
||||
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
|
||||
// erreichbares Gerät vergeben wurde.
|
||||
pub const DEFAULT_CACHE_DB_PATH: &str = "/var/lib/mac2ip/cache.db";
|
||||
pub const DEFAULT_LOG_LEVEL: &str = "info";
|
||||
pub const DEFAULT_NMAP_TIMEOUT_SECONDS: u64 = 120;
|
||||
|
||||
fn default_cache_ttl_seconds() -> u64 {
|
||||
DEFAULT_CACHE_TTL_SECONDS
|
||||
}
|
||||
|
||||
fn default_cache_db_path() -> PathBuf {
|
||||
PathBuf::from(DEFAULT_CACHE_DB_PATH)
|
||||
}
|
||||
|
||||
fn default_log_level() -> String {
|
||||
DEFAULT_LOG_LEVEL.to_string()
|
||||
}
|
||||
|
||||
fn default_nmap_timeout_seconds() -> u64 {
|
||||
DEFAULT_NMAP_TIMEOUT_SECONDS
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
|
||||
pub struct AppConfig {
|
||||
#[serde(default = "default_cache_ttl_seconds")]
|
||||
pub cache_ttl_seconds: u64,
|
||||
#[serde(default = "default_cache_db_path")]
|
||||
pub cache_db_path: PathBuf,
|
||||
#[serde(default = "default_log_level")]
|
||||
pub log_level: String,
|
||||
#[serde(default = "default_nmap_timeout_seconds")]
|
||||
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 {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
cache_ttl_seconds: DEFAULT_CACHE_TTL_SECONDS,
|
||||
cache_db_path: PathBuf::from(DEFAULT_CACHE_DB_PATH),
|
||||
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>) {
|
||||
config_ctdra::set_config_name("config");
|
||||
if let Some(path) = custom_path {
|
||||
config_ctdra::set_custom_path(path.to_path_buf());
|
||||
}
|
||||
}
|
||||
|
||||
pub fn get_config_file_path() -> PathBuf {
|
||||
config_ctdra::get_config_path()
|
||||
}
|
||||
|
||||
pub fn load_config() -> AppConfig {
|
||||
config_ctdra::load_config::<AppConfig>()
|
||||
}
|
||||
|
||||
/// Reine, testbare Overlay-Funktion: überschreibt Konfigurationsfelder mit
|
||||
/// expliziten CLI-Werten (clap hat CLI>ENV bereits selbst aufgelöst; hier wird
|
||||
/// nur noch "vorhanden > Datei/Default" angewendet).
|
||||
pub fn apply_cli_overrides(config: &mut AppConfig, cli: &crate::cli::Cli) {
|
||||
if let Some(level) = &cli.log_level {
|
||||
config.log_level = level.as_str().to_string();
|
||||
}
|
||||
if let Some(ttl) = cli.cache_ttl_seconds {
|
||||
config.cache_ttl_seconds = ttl;
|
||||
}
|
||||
if let Some(path) = &cli.cache_db_path {
|
||||
config.cache_db_path = path.clone();
|
||||
}
|
||||
if let Some(timeout) = cli.nmap_timeout_seconds {
|
||||
config.nmap_timeout_seconds = timeout;
|
||||
}
|
||||
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();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
//! Fehlertypen für mac2ip.
|
||||
|
||||
use crate::mac::MacAddressError;
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
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}")]
|
||||
Io(#[from] std::io::Error),
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
//! mac2ip - findet zuverlässig die aktuelle IP-Adresse zu einer MAC-Adresse
|
||||
//! im lokalen Netzwerk (Cache -> `ip neigh` -> `nmap`).
|
||||
|
||||
pub mod cache;
|
||||
pub mod cli;
|
||||
pub mod config;
|
||||
pub mod error;
|
||||
pub mod log;
|
||||
pub mod mac;
|
||||
pub mod network;
|
||||
pub mod output;
|
||||
pub mod resolver;
|
||||
pub mod trust;
|
||||
+43
@@ -0,0 +1,43 @@
|
||||
//! JSON-Modus-bewusster Wrapper um `logger-ctdra`.
|
||||
//!
|
||||
//! Im `--json`-Modus dürfen keinerlei Log-Ausgaben (auch keine Fehler/Warnungen)
|
||||
//! auf stdout/stderr erscheinen, da nur ein einzelnes JSON-Objekt erwartet wird.
|
||||
//! Alle Module rufen ausschließlich diese Funktionen auf, niemals `logger_ctdra`
|
||||
//! direkt, damit die Unterdrückung an genau einer Stelle greift.
|
||||
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
|
||||
static JSON_MODE: AtomicBool = AtomicBool::new(false);
|
||||
|
||||
/// Muss als allererste Logger-bezogene Aktion in main() aufgerufen werden.
|
||||
pub fn set_json_mode(enabled: bool) {
|
||||
JSON_MODE.store(enabled, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
pub fn is_json_mode() -> bool {
|
||||
JSON_MODE.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
pub fn error(tag: &str, message: &str) {
|
||||
if !is_json_mode() {
|
||||
logger_ctdra::error(tag, message);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn warn(tag: &str, message: &str) {
|
||||
if !is_json_mode() {
|
||||
logger_ctdra::warn(tag, message);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn info(tag: &str, message: &str) {
|
||||
if !is_json_mode() {
|
||||
logger_ctdra::info(tag, message);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn debug(tag: &str, message: &str) {
|
||||
if !is_json_mode() {
|
||||
logger_ctdra::debug(tag, message);
|
||||
}
|
||||
}
|
||||
+77
@@ -0,0 +1,77 @@
|
||||
//! Repräsentation und Parsing von MAC-Adressen.
|
||||
|
||||
use std::fmt;
|
||||
use std::str::FromStr;
|
||||
|
||||
/// Kanonische Darstellung einer MAC-Adresse (6 Bytes).
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct MacAddress([u8; 6]);
|
||||
|
||||
#[derive(Debug, thiserror::Error, Clone, PartialEq, Eq)]
|
||||
pub enum MacAddressError {
|
||||
#[error("ungültige MAC-Adresse: '{0}'")]
|
||||
InvalidFormat(String),
|
||||
}
|
||||
|
||||
impl MacAddress {
|
||||
/// Parst eine MAC-Adresse aus ':' oder '-' getrennter Hex-Notation (case-insensitive).
|
||||
pub fn parse(input: &str) -> Result<Self, MacAddressError> {
|
||||
let err = || MacAddressError::InvalidFormat(input.to_string());
|
||||
|
||||
let normalized = input.trim();
|
||||
let separator = if normalized.contains(':') {
|
||||
':'
|
||||
} else if normalized.contains('-') {
|
||||
'-'
|
||||
} else {
|
||||
return Err(err());
|
||||
};
|
||||
|
||||
let parts: Vec<&str> = normalized.split(separator).collect();
|
||||
if parts.len() != 6 {
|
||||
return Err(err());
|
||||
}
|
||||
|
||||
let mut bytes = [0u8; 6];
|
||||
for (i, part) in parts.iter().enumerate() {
|
||||
if part.len() != 2 {
|
||||
return Err(err());
|
||||
}
|
||||
bytes[i] = u8::from_str_radix(part, 16).map_err(|_| err())?;
|
||||
}
|
||||
|
||||
Ok(Self(bytes))
|
||||
}
|
||||
|
||||
/// Kleinschreibung, Doppelpunkt-getrennt (Vergleichsform, wie `ip neigh` sie ausgibt).
|
||||
pub fn to_lower_colon(&self) -> String {
|
||||
self.0
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(":")
|
||||
}
|
||||
|
||||
/// Großschreibung, Doppelpunkt-getrennt (wie nmap sie ausgibt).
|
||||
pub fn to_upper_colon(&self) -> String {
|
||||
self.0
|
||||
.iter()
|
||||
.map(|b| format!("{b:02X}"))
|
||||
.collect::<Vec<_>>()
|
||||
.join(":")
|
||||
}
|
||||
}
|
||||
|
||||
impl FromStr for MacAddress {
|
||||
type Err = MacAddressError;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
Self::parse(s)
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for MacAddress {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", self.to_lower_colon())
|
||||
}
|
||||
}
|
||||
+40
-9
@@ -1,13 +1,44 @@
|
||||
fn main() {
|
||||
// TODO: Hauptlogik der Anwendung implementieren
|
||||
println!("Hello, World!");
|
||||
use std::process::ExitCode;
|
||||
|
||||
use clap::Parser;
|
||||
|
||||
use mac2ip::{cache, cli::Cli, config, log, output, resolver};
|
||||
|
||||
#[tokio::main]
|
||||
async fn main() -> ExitCode {
|
||||
let cli = Cli::parse();
|
||||
|
||||
// Muss vor jedem weiteren Logger-Aufruf geschehen, damit im --json-Modus
|
||||
// wirklich keine einzige Log-Zeile ausgegeben wird.
|
||||
log::set_json_mode(cli.json);
|
||||
|
||||
config::init_config_path(cli.config.as_deref());
|
||||
let mut app_config = config::load_config();
|
||||
config::apply_cli_overrides(&mut app_config, &cli);
|
||||
|
||||
match logger_ctdra::LogLevel::try_from(app_config.log_level.as_str()) {
|
||||
Ok(level) => logger_ctdra::set_log_level(level),
|
||||
Err(fallback) => logger_ctdra::set_log_level(fallback),
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
#[test]
|
||||
fn it_works() {
|
||||
// TODO: Unit-Tests für die Anwendung schreiben
|
||||
assert_eq!(2 + 2, 4);
|
||||
let cache = cache::try_open_cache(&app_config.cache_db_path).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
|
||||
}
|
||||
Err(err) => {
|
||||
output::print_failure(&cli.mac, &err, cli.json);
|
||||
ExitCode::FAILURE
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+255
@@ -0,0 +1,255 @@
|
||||
//! Netzwerk-Interaktion: Auto-Erkennung lokaler Subnetze, `ip neigh`, Ping-Erreichbarkeit
|
||||
//! und der nmap-Scan (Schritt 3). Bewusst getrennt in dünne, das System aufrufende
|
||||
//! Exec-Funktionen und reine, unit-testbare Parse-Funktionen.
|
||||
|
||||
use std::net::IpAddr;
|
||||
use std::time::Duration;
|
||||
|
||||
use crate::mac::MacAddress;
|
||||
|
||||
/// Schnelle Liveness-Probe, absichtlich kein Konfigurationsfeld (kein Nutzer-Tuning nötig).
|
||||
const PING_TIMEOUT_SECS: u32 = 1;
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Exec-Funktionen (führen echte Subprozesse aus)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
pub async fn run_ip_neigh_show() -> std::io::Result<String> {
|
||||
let out = tokio::process::Command::new("ip")
|
||||
.args(["neigh", "show"])
|
||||
.output()
|
||||
.await?;
|
||||
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
|
||||
}
|
||||
|
||||
pub async fn run_ip_route_show_scope_link() -> std::io::Result<String> {
|
||||
let out = tokio::process::Command::new("ip")
|
||||
.args(["-4", "route", "show", "scope", "link"])
|
||||
.output()
|
||||
.await?;
|
||||
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([
|
||||
"-c",
|
||||
"1",
|
||||
"-W",
|
||||
&PING_TIMEOUT_SECS.to_string(),
|
||||
&ip.to_string(),
|
||||
])
|
||||
// stdout/stderr von `ping` sind für uns irrelevant (nur der Exit-Code zählt) und
|
||||
// dürfen insbesondere im --json-Modus nicht in unseren eigenen Output durchsickern.
|
||||
.stdout(std::process::Stdio::null())
|
||||
.stderr(std::process::Stdio::null())
|
||||
.status()
|
||||
.await
|
||||
.map(|s| s.success())
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum SudoMode {
|
||||
/// Bereits root - nmap wird ohne sudo-Prefix aufgerufen.
|
||||
None,
|
||||
/// sudo darf interaktiv nach einem Passwort fragen.
|
||||
Interactive,
|
||||
/// sudo darf NICHT interaktiv nach einem Passwort fragen (`sudo -n`).
|
||||
NonInteractive,
|
||||
}
|
||||
|
||||
#[derive(Debug, thiserror::Error)]
|
||||
pub enum NmapRunError {
|
||||
#[error("sudo-Zugangsdaten nicht verfügbar (nicht-interaktiver Modus)")]
|
||||
SudoUnavailable,
|
||||
#[error("nmap-Scan hat das Zeitlimit überschritten")]
|
||||
Timeout,
|
||||
#[error("E/A-Fehler: {0}")]
|
||||
Io(#[from] std::io::Error),
|
||||
}
|
||||
|
||||
pub async fn run_nmap_scan(
|
||||
cidr: &str,
|
||||
timeout_secs: u64,
|
||||
mode: SudoMode,
|
||||
) -> Result<String, NmapRunError> {
|
||||
let mut cmd = match mode {
|
||||
SudoMode::None => {
|
||||
let mut c = tokio::process::Command::new("nmap");
|
||||
c.arg("-sn").arg("-n").arg(cidr);
|
||||
c
|
||||
}
|
||||
SudoMode::Interactive => {
|
||||
let mut c = tokio::process::Command::new("sudo");
|
||||
c.args(["nmap", "-sn", "-n", cidr]);
|
||||
c
|
||||
}
|
||||
SudoMode::NonInteractive => {
|
||||
let mut c = tokio::process::Command::new("sudo");
|
||||
c.args(["-n", "nmap", "-sn", "-n", cidr]);
|
||||
c
|
||||
}
|
||||
};
|
||||
// Erzwingt englische Fehlermeldungen, damit die "password"-Erkennung unten
|
||||
// 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 child = cmd.spawn()?;
|
||||
let pgid = child.id();
|
||||
|
||||
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);
|
||||
if stderr.to_lowercase().contains("password") {
|
||||
return Err(NmapRunError::SudoUnavailable);
|
||||
}
|
||||
return Err(NmapRunError::Io(std::io::Error::other(stderr.into_owned())));
|
||||
}
|
||||
|
||||
Ok(String::from_utf8_lossy(&out.stdout).into_owned())
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Reine Parse-Funktionen (kein Subprozess, vollständig unit-testbar)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Parst `ip neigh show`-Ausgabe, z. B. Zeilen wie
|
||||
/// "192.168.1.5 dev eth0 lladdr aa:bb:cc:dd:ee:ff REACHABLE".
|
||||
/// Gibt die IP zurück, sobald eine Zeile mit passender `lladdr`-MAC gefunden wird.
|
||||
pub fn parse_ip_neigh_output(output: &str, mac: &MacAddress) -> Option<IpAddr> {
|
||||
let target = mac.to_lower_colon();
|
||||
for line in output.lines() {
|
||||
let tokens: Vec<&str> = line.split_whitespace().collect();
|
||||
if tokens.is_empty() {
|
||||
continue;
|
||||
}
|
||||
if let Some(pos) = tokens.iter().position(|&t| t == "lladdr")
|
||||
&& let Some(&found_mac) = tokens.get(pos + 1)
|
||||
&& found_mac.eq_ignore_ascii_case(&target)
|
||||
&& let Ok(ip) = tokens[0].parse()
|
||||
{
|
||||
return Some(ip);
|
||||
}
|
||||
}
|
||||
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.
|
||||
pub fn parse_local_subnets(ip_route_output: &str) -> Vec<String> {
|
||||
ip_route_output
|
||||
.lines()
|
||||
.filter(|l| !l.trim_start().starts_with("default"))
|
||||
.filter(|l| !l.split_whitespace().any(|t| t == "lo"))
|
||||
.filter_map(|l| l.split_whitespace().next())
|
||||
.filter(|t| t.contains('/'))
|
||||
.map(|s| s.to_string())
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Parst `nmap -sn`-Ausgabe: verknüpft "Nmap scan report for IP" mit der
|
||||
/// nächstfolgenden "MAC Address: XX:XX:XX:XX:XX:XX (Vendor)"-Zeile, bevor ein neuer
|
||||
/// Host-Block beginnt.
|
||||
pub fn parse_nmap_output(output: &str, mac: &MacAddress) -> Option<IpAddr> {
|
||||
let target = mac.to_lower_colon();
|
||||
let mut current_ip: Option<IpAddr> = None;
|
||||
|
||||
for line in output.lines() {
|
||||
if let Some(rest) = line.strip_prefix("Nmap scan report for ") {
|
||||
// rest ist entweder "192.168.1.5" oder "hostname (192.168.1.5)"
|
||||
let rest = rest.trim();
|
||||
current_ip = if let Some(open) = rest.rfind('(') {
|
||||
rest[open + 1..].trim_end_matches(')').trim().parse().ok()
|
||||
} else {
|
||||
rest.parse().ok()
|
||||
};
|
||||
} else if let Some(rest) = line.trim_start().strip_prefix("MAC Address: ")
|
||||
&& let Some(mac_token) = rest.split_whitespace().next()
|
||||
&& mac_token.eq_ignore_ascii_case(&target)
|
||||
&& let Some(ip) = current_ip
|
||||
{
|
||||
return Some(ip);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
//! Human- und JSON-Ausgabe des Lookup-Ergebnisses.
|
||||
|
||||
use serde::Serialize;
|
||||
|
||||
use crate::error::Mac2IpError;
|
||||
use crate::mac::MacAddress;
|
||||
use crate::resolver::ResolveResult;
|
||||
|
||||
#[derive(Serialize, Debug, PartialEq)]
|
||||
pub struct SuccessJson {
|
||||
pub status: &'static str,
|
||||
pub mac: String,
|
||||
pub ip: String,
|
||||
pub source: &'static str,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Debug, PartialEq)]
|
||||
pub struct FailureJson {
|
||||
pub status: &'static str,
|
||||
pub mac: String,
|
||||
pub error: String,
|
||||
}
|
||||
|
||||
pub fn success_json(result: &ResolveResult) -> SuccessJson {
|
||||
SuccessJson {
|
||||
status: "ok",
|
||||
mac: result.mac.to_lower_colon(),
|
||||
ip: result.ip.to_string(),
|
||||
source: result.source.as_str(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn failure_json(mac: &MacAddress, err: &Mac2IpError) -> FailureJson {
|
||||
FailureJson {
|
||||
status: "error",
|
||||
mac: mac.to_lower_colon(),
|
||||
error: err.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn print_success(result: &ResolveResult, json: bool) {
|
||||
if json {
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&success_json(result))
|
||||
.expect("JSON-Serialisierung schlägt nicht fehl")
|
||||
);
|
||||
} else {
|
||||
println!(
|
||||
"{} -> {} (Quelle: {})",
|
||||
result.mac,
|
||||
result.ip,
|
||||
result.source.as_str()
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn print_failure(mac: &MacAddress, err: &Mac2IpError, json: bool) {
|
||||
if json {
|
||||
println!(
|
||||
"{}",
|
||||
serde_json::to_string(&failure_json(mac, err))
|
||||
.expect("JSON-Serialisierung schlägt nicht fehl")
|
||||
);
|
||||
} else {
|
||||
crate::log::error("mac2ip", &err.to_string());
|
||||
}
|
||||
}
|
||||
+156
@@ -0,0 +1,156 @@
|
||||
//! Orchestrierung des 3-Stufen-Algorithmus: Cache -> `ip neigh` -> `nmap`.
|
||||
|
||||
use std::net::IpAddr;
|
||||
use std::time::{SystemTime, UNIX_EPOCH};
|
||||
|
||||
use crate::cache::{self, Cache};
|
||||
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 {
|
||||
Cache,
|
||||
Arp,
|
||||
Nmap,
|
||||
}
|
||||
|
||||
impl MatchSource {
|
||||
pub fn as_str(&self) -> &'static str {
|
||||
match self {
|
||||
Self::Cache => "cache",
|
||||
Self::Arp => "arp",
|
||||
Self::Nmap => "nmap",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub struct ResolveResult {
|
||||
pub mac: MacAddress,
|
||||
pub ip: IpAddr,
|
||||
pub source: MatchSource,
|
||||
}
|
||||
|
||||
fn now_unix() -> i64 {
|
||||
SystemTime::now()
|
||||
.duration_since(UNIX_EPOCH)
|
||||
.map(|d| d.as_secs() as i64)
|
||||
.unwrap_or(0)
|
||||
}
|
||||
|
||||
pub async fn resolve(
|
||||
mac: &MacAddress,
|
||||
config: &AppConfig,
|
||||
cache: Option<&Cache>,
|
||||
json_mode: bool,
|
||||
auto_trust_networks: bool,
|
||||
) -> Result<ResolveResult, Mac2IpError> {
|
||||
let now = now_unix();
|
||||
|
||||
// Schritt 1: Cache
|
||||
if let Some(cache) = cache
|
||||
&& let Some(entry) = cache.get(mac).await
|
||||
&& !cache::is_expired(entry.updated_at, now, config.cache_ttl_seconds)
|
||||
&& network::ping_check(entry.ip).await
|
||||
{
|
||||
crate::log::info(
|
||||
"resolver",
|
||||
&format!("Treffer im Cache für {mac}: {}", entry.ip),
|
||||
);
|
||||
return Ok(ResolveResult {
|
||||
mac: *mac,
|
||||
ip: entry.ip,
|
||||
source: MatchSource::Cache,
|
||||
});
|
||||
}
|
||||
|
||||
// Schritt 2: ip neigh
|
||||
crate::log::debug(
|
||||
"resolver",
|
||||
"Cache-Treffer nicht verfügbar, prüfe 'ip neigh show'",
|
||||
);
|
||||
if let Ok(output) = network::run_ip_neigh_show().await
|
||||
&& let Some(ip) = network::parse_ip_neigh_output(&output, mac)
|
||||
&& network::ping_check(ip).await
|
||||
{
|
||||
crate::log::info("resolver", &format!("Treffer via ip neigh für {mac}: {ip}"));
|
||||
if let Some(cache) = cache {
|
||||
cache.upsert(mac, ip, MatchSource::Arp.as_str(), now).await;
|
||||
}
|
||||
return Ok(ResolveResult {
|
||||
mac: *mac,
|
||||
ip,
|
||||
source: MatchSource::Arp,
|
||||
});
|
||||
}
|
||||
|
||||
// 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 {
|
||||
network::run_ip_route_show_scope_link()
|
||||
.await
|
||||
.map(|o| network::parse_local_subnets(&o))
|
||||
.unwrap_or_default()
|
||||
};
|
||||
|
||||
let sudo_mode = if sudo_ctdra::is_run_as_root() {
|
||||
SudoMode::None
|
||||
} else if json_mode {
|
||||
SudoMode::NonInteractive
|
||||
} else {
|
||||
SudoMode::Interactive
|
||||
};
|
||||
|
||||
for cidr in subnets {
|
||||
match network::run_nmap_scan(&cidr, config.nmap_timeout_seconds, sudo_mode).await {
|
||||
Ok(output) => {
|
||||
if let Some(ip) = network::parse_nmap_output(&output, mac)
|
||||
&& network::ping_check(ip).await
|
||||
{
|
||||
crate::log::info("resolver", &format!("Treffer via nmap für {mac}: {ip}"));
|
||||
if let Some(cache) = cache {
|
||||
cache.upsert(mac, ip, MatchSource::Nmap.as_str(), now).await;
|
||||
}
|
||||
return Ok(ResolveResult {
|
||||
mac: *mac,
|
||||
ip,
|
||||
source: MatchSource::Nmap,
|
||||
});
|
||||
}
|
||||
}
|
||||
Err(NmapRunError::SudoUnavailable) => {
|
||||
crate::log::warn(
|
||||
"nmap",
|
||||
"sudo -n fehlgeschlagen (keine Zugangsdaten) - Schritt 3 wird abgebrochen",
|
||||
);
|
||||
break; // sudo-Session-Status ist global, ein Retry pro Subnetz bringt nichts
|
||||
}
|
||||
Err(e) => {
|
||||
crate::log::warn("nmap", &format!("nmap-Scan für {cidr} fehlgeschlagen: {e}"));
|
||||
continue; // Fehler pro Subnetz (z. B. Timeout) - nächstes Subnetz versuchen
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Err(Mac2IpError::NotFound {
|
||||
mac: mac.to_string(),
|
||||
})
|
||||
}
|
||||
+110
@@ -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)
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
@@ -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());
|
||||
}
|
||||
Reference in New Issue
Block a user