Skip to content
KitploitKITPLOIT
ToolsBlog
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

··Feeds·Kontakt·Datenschutz·© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
c-sentinel — Semantische Beobachtbarkeit für UNIX-Systeme - Ein leichtgewichtiger, auf C basierender System-Prober mit KI-gestützter Analyse | Kitploit
Tools/GitHubGitHub/speytech/c-sentinel
SchwachstellenanalyseNetzwerksicherheitCloud-SicherheitDevSecOpsBedrohungsanalyseAuthentifizierungEinbruchserkennungIncident ResponseKI-SicherheitAnomalieerkennungLog-Analyse
7282vor 5 MonatenVon Kitploit geprüft
GitHub
speytech/c-sentinel

c-sentinel

Semantische Beobachtbarkeit für UNIX-Systeme - Ein leichtgewichtiger, auf C basierender System-Prober mit KI-gestützter Analyse

Repository anzeigenWebseite

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →
Teilen

C-Sentinel

Semantische Überwachung für UNIX-Systeme

Ein leichtgewichtiger, portabler System-Prober in C, der „System-Fingerabdrücke“ für KI-gestützte Analyse nicht offensichtlicher Risiken erfasst. Integriert auditd, erklärbare Risikobewertung und ein Live-Web-Dashboard mit unternehmensgerechter Multi-User-Authentifizierung.

License: MIT Version

Live-Demo: sentinel.speytech.com

Screenshots

Sicherheits-Dashboard

Sicherheits-Dashboard

Multi-Host-Übersicht

Hosts-Dashboard

Benutzerprofil & Sicherheitseinstellungen

Prof-Seite

Zwei-Faktor-Authentifizierung

EinrichtungAnmeldung
2FA Einrichtung2FA Anmeldung

Persönliche API-Schlüssel

API-Schlüssel

Admin-Funktionen

Sitzungsverwaltung

Sitzungen

Prüfprotokoll

Prüfprotokoll

Sichere Anmeldung

Anmeldeseite

Neuerungen in v0.6.0

  • 👥 Multi-User-Authentifizierung – Rollenbasierte Zugriffskontrolle (Admin/Operator/Viewer)
  • 🔐 Zwei-Faktor-Authentifizierung – TOTP-Unterstützung mit Google Authenticator, Authy usw.
  • 🔑 Persönliche API-Schlüssel – Benutzerspezifische API-Schlüssel für Automatisierung und CI/CD
  • 📋 Admin-Prüfprotokoll – Alle Benutzeraktionen mit Filterfunktion verfolgen
  • 💻 Sitzungsverwaltung – Aktive Sitzungen anzeigen, Zugriff widerrufen, Abmeldung erzwingen
  • 📧 E-Mail- und Slack-Benachrichtigungen – Proaktive Benachrichtigungen mit umfangreicher Formatierung
  • 🎨 Moderne Toast-Benachrichtigungen – Keine JavaScript-Alarme aus den 90ern mehr!
  • 👁️ Öffentlicher Demo-Modus – Schreibgeschützter Zugriff zum Vorzeigen Ihres Dashboards
  • 📱 Mobil Responsive – Volle Funktionalität auf Smartphones und Tablets

Frühere Versionen

v0.5.x: Sicherheitslage-Zusammenfassung, Risikotrend-Sparkline, Lernindikator, erklärbare Risikofaktoren, E-Mail-Benachrichtigungen, Ereignisverlauf

v0.4.0: Auditd-Integration, Brute-Force-Erkennung, datenschutzerhaltendes Hashing von Benutzernamen, Prozesszuordnung, Risikobewertung

v0.3.0: Web-Dashboard, SHA256-Prüfsummen, systemd-Dienst, Baseline-Lernen, Netzwerk-Probe, Überwachungsmodus

Das Problem

Moderne Observability-Tools wie Dynatrace, Datadog und Prometheus sind hervorragend für Metriksammlung und Schwellenwert-Warnungen geeignet. Aber sie beantworten nur eine enge Frage: „Liegt diese Metrik außerhalb ihres erwarteten Bereichs?“

Sie tun sich schwer mit:

  • Kausaler Schlussfolgerung: Warum ist etwas fehlgeschlagen?
  • Kontextsynthese: Eine Konfigurationsänderung letzte Woche mit dem heutigen Latenzanstieg verknüpfen
  • Nicht offensichtlicher Degradation: Dinge, die nicht „kaputt“ sind, aber in Richtung Ausfall driften
  • Sicherheitskontext: Verstehen, wer auf was zugegriffen hat und warum das wichtig ist

C-Sentinel verfolgt einen anderen Ansatz: Erfasst einen umfassenden System-Fingerabdruck – einschließlich Sicherheitsereignisse – und nutzt LLM-Schlussfolgerungen, um die „Geister in der Maschine“ zu identifizieren.

Schnellstart```bash

Clone and build

git clone https://github.com/williamofai/c-sentinel.git cd c-sentinel make

Quick analysis

./bin/sentinel --quick --network

Quick analysis with security events (requires root for audit logs)

sudo ./bin/sentinel --quick --network --audit

Learn baselines (automatic with --audit flag)

./bin/sentinel --learn --network

Continuous monitoring with full context

sudo ./bin/sentinel --watch --interval 300 --network --audit

root@kitploit:~
## Dashboard Features

Die Web-Dashboard bietet Echtzeit-Überwachung der Sicherheit in Ihrer Infrastruktur.

### Multi-User-Authentifizierung

Zugriffskontrolle auf Unternehmensniveau mit drei Rollen:

| Rolle | Berechtigungen |
|-------|----------------|
| **Admin** | Vollzugriff: Benutzer verwalten, Audit-Logs einsehen, alle Operationen |
| **Operator** | Ereignisse bestätigen, Zähler zurücksetzen, alle Daten anzeigen |
| **Viewer** | Schreibgeschützter Zugriff auf Dashboards und Daten |

### Zwei-Faktor-Authentifizierung (TOTP)

Schützen Sie Ihr Konto mit dem Industriestandard TOTP:
- Funktioniert mit Google Authenticator, Authy, Microsoft Authenticator
- QR-Code-Einrichtung für einfache Konfiguration
- Bei jedem Login erforderlich, wenn aktiviert
- E-Mail-Benachrichtigungen bei Aktivierung/Deaktivierung

### Persönliche API-Schlüssel

Jeder Benutzer kann seine eigenen API-Schlüssel für die Automatisierung erstellen:
- Benannte Schlüssel (z. B. „CI/CD Pipeline“, „Monitoring Script“)
- Optionale Ablaufdaten
- Aktivieren/Deaktivieren ohne Löschen
- Verfolgung der letzten Nutzung
- Schlüssel erben die Rollenberechtigungen des Benutzers```bash
# Use your personal API key
curl -X POST https://sentinel.example.com/api/ingest \
  -H "Content-Type: application/json" \
  -H "X-API-Key: sk_your_personal_key" \
  -d @fingerprint.json

Admin Audit-Protokoll

Verfolgt alle Benutzeraktionen für Compliance und Sicherheit:

  • Anmelde-/Abmeldeereignisse mit IP-Adressen
  • Benutzerverwaltungsaktionen (Erstellen, Aktualisieren, Löschen)
  • Passwortänderungen
  • Sitzungswiderrufe
  • Filterbar nach Benutzer, Aktionstyp und Zeitraum

Sitzungsverwaltung

Volle Transparenz über aktive Sitzungen:

  • Sehen, wer angemeldet ist und von wo
  • Geräte- und Browsererkennung
  • Einzelne Sitzungen widerrufen
  • "Alle anderen abmelden" für Sicherheitsvorfälle
  • Automatische Bereinigung abgelaufener Sitzungen

Zusammenfassung der Sicherheitslage

Erklärung des Sicherheitsstatus Ihres Systems in einfachem Englisch:

"Dieses System zeigt keine Sicherheitsbedenken. Authentifizierungsmuster sind normal, keine Fehler erkannt. Keine Aktivität zur Privilegienausweitung erkannt. Gesamtzustand: GESUND."

Erklärbare Risikobewertung

Jeder Risikoscore enthält Faktoren, die erklären, warum:

FaktorGewicht
10 Authentifizierungsfehler (200% über Basislinie - hoch)+30
Brute-Force-Angriffsmuster erkannt+10
2 sensible Datei(en) zugegriffen+4
Gesamt44

Lern-/Kalibrierungsindikator

Das System lernt, was für Ihre Umgebung "normal" ist:

StichprobenStatusBedeutung
< 10🧠 LernenErste Basislinie aufbauen
10-50🧠 KalibrierenNormale Muster verfeinern
> 50(ausgeblendet)Vollständig kalibriert

Risikotrend-Sparkline

Ein Mini-Diagramm, das den Risikoscore-Verlauf der letzten 24 Stunden zeigt – sofort erkennbar, ob sich die Situation verbessert oder verschlechtert.

E-Mail- und Slack-Benachrichtigungen

Automatische Benachrichtigungen per E-Mail und/oder Slack, wenn:

  • Risikoscore ≥ 16 (hoch/kritisch)
  • Brute-Force-Angriff erkannt
  • Ausführungen von /tmp oder /dev/shm
  • Benutzeranmeldung von neuer IP
  • Passwort- oder 2FA-Änderungen

Slack-Benachrichtigungen enthalten umfangreiche Formatierung mit farbcodiertem Schweregrad, klickbaren Dashboard-Links und strukturierten Risikofaktordetails.

Auditd-Integration

C-Sentinel fasst Auditd-Protokolle für die semantische Sicherheitsanalyse zusammen.

Beispielausgabe```

C-Sentinel Quick Analysis

Hostname: axioma-validator Uptime: 14.5 days Load: 0.02 0.04 0.00 Memory: 49.2% used Processes: 120 total

Potential Issues: Zombie processes: 0 High FD processes: 1 Long-running (>7d): 95 Config permission issues: 0

Network: Listening ports: 26 Established connections: 14 Unusual ports: 12 ⚠

Security (audit): Auth failures: 6 ⚠ BRUTE FORCE PATTERN DETECTED Sudo commands: 81 Sensitive file access: 2 - /etc/passwd by touch - /etc/shadow by touch ⚠

Risk: high (score: 25)

root@kitploit:~
### JSON-Ausgabe```json
{
  "audit_summary": {
    "enabled": true,
    "period_seconds": 300,
    "authentication": {
      "failures": 6,
      "failure_users_hashed": ["user_c4c5", "user_b91b"],
      "brute_force_detected": true
    },
    "privilege_escalation": {
      "sudo_count": 81,
      "sudo_baseline_avg": 12.5,
      "sudo_deviation_pct": 548.0,
      "su_count": 5
    },
    "file_integrity": {
      "sensitive_file_access": [
        {
          "path": "/etc/shadow",
          "access": "write",
          "count": 2,
          "process": "touch",
          "process_chain": ["touch", "bash", "sshd"],
          "suspicious": true
        }
      ]
    },
    "learning": {
      "sample_count": 42,
      "confidence": "medium"
    },
    "risk_factors": [
      {"reason": "6 auth failures (200% above baseline - high)", "weight": 18},
      {"reason": "Brute force attack pattern detected", "weight": 10}
    ],
    "risk_score": 25,
    "risk_level": "high"
  }
}

Einrichtung von Audit-Regeln

Für beste Ergebnisse fügen Sie Audit-Regeln für sensible Dateien hinzu:```bash

Add audit rules

sudo auditctl -w /etc/passwd -p wa -k identity sudo auditctl -w /etc/shadow -p wa -k identity sudo auditctl -w /etc/sudoers -p wa -k priv_esc sudo auditctl -w /var/log/lastlog -p wa -k auth

Make permanent (add to /etc/audit/rules.d/sentinel.rules)

root@kitploit:~
### Datenschutzfunktionen

- **Benutzername-Hashing**: Fehlgeschlagene Login-Benutzernamen werden gehasht (z. B. `user_c4c5`), wodurch die Mustererkennung erhalten bleibt, ohne Identitäten preiszugeben
- **Keine Passwörter**: Befehlsargumente und sensible Daten werden nie erfasst
- **Nur Prozessnamen**: Vollständige Pfade aus Datenschutzgründen bereinigt

## Web-Dashboard

C-Sentinel enthält ein Web-Dashboard zur Überwachung mehrerer Hosts in Echtzeit.

### Funktionen

- **Multi-Benutzer-Authentifizierung** - Rollenbasierte Zugriffskontrolle
- **Zwei-Faktor-Authentifizierung** - TOTP mit QR-Code-Einrichtung
- **Persönliche API-Schlüssel** - Automatisierungsschlüssel pro Benutzer
- **Admin-Prüfprotokoll** - Vollständige Aktionshistorie
- **Sitzungsverwaltung** - Aktive Sitzungskontrolle
- **Sicherheitslage-Zusammenfassung** - Systemstatus in einfachem Englisch
- **Risikotrend-Sparkline** - 24-Stunden-Visualisierungsverlauf
- **Erklärbare Risikofaktoren** - Wissen Sie, *warum* der Punktestand ist, was er ist
- **Lernindikator** - Basiskalibrierungsfortschritt
- **Ereignishistorie** - Zeitleiste mit Bestätigung
- **E-Mail-Benachrichtigungen** - Proaktive Benachrichtigungen
- **Echtzeit-Überwachung** - Alle Hosts auf einen Blick
- **Historische Diagramme** - Speicher und Auslastung über 24 Stunden
- **Netzwerkansicht** - Alle lauschenden Ports und Verbindungen
- **Konfigurationsverfolgung** - SHA256-Prüfsummen überwachter Dateien

### Schnelleinrichtung```bash
# Install dashboard
cd dashboard
sudo ./install-dashboard.sh

# Run database migration
sudo -u postgres psql -d sentinel -f migrate.sql

# Install 2FA dependencies (optional)
sudo /opt/sentinel-dashboard/venv/bin/pip install pyotp qrcode pillow

# Configure agent to report (with audit)
*/5 * * * * sudo /usr/local/bin/sentinel --json --network --audit | curl -s -X POST \
  -H "Content-Type: application/json" \
  -H "X-API-Key: YOUR_KEY" \
  -d @- https://your-dashboard.com/api/ingest

E-Mail-Alarmkonfiguration

Fügen Sie zu Ihrem systemd-Dienst oder Ihrer Umgebung hinzu:```bash ALERT_EMAIL_ENABLED=true ALERT_SMTP_HOST=smtp.gmail.com ALERT_SMTP_PORT=587 ALERT_SMTP_USER=[email protected] ALERT_SMTP_PASS=your-app-password ALERT_FROM=[email protected] ALERT_TO=[email protected] ALERT_COOLDOWN_MINS=60

root@kitploit:~
### Slack Webhook Konfiguration```bash
ALERT_SLACK_ENABLED=true
ALERT_SLACK_WEBHOOK=https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX
ALERT_SLACK_CHANNEL=#security-alerts    # Optional - override default webhook channel
ALERT_SLACK_USERNAME=C-Sentinel         # Optional - bot display name

Um eine Webhook-URL zu erhalten:

  1. Gehe zu api.slack.com/apps
  2. Erstelle eine neue App → "From scratch"
  3. Aktiviere "Incoming Webhooks"
  4. Klicke auf "Add New Webhook to Workspace"
  5. Wähle einen Kanal aus und kopiere die Webhook-URL

Siehe dashboard/README.md für vollständige Einrichtungsanweisungen.

Öffentlicher Demo-Modus

Aktiviere schreibgeschützten öffentlichen Zugriff, um dein Dashboard zu präsentieren:```bash Environment="DEMO_MODE=true"

root@kitploit:~
Im Demo-Modus:
- Kein Login erforderlich - Besucher gelangen direkt zum Dashboard
- Schreibgeschützter Zugriff (Betrachter-Rolle)
- Admin-Funktionen sind ausgeblendet
- Profil/Logout-Links durch GitHub-Link ersetzt
- Gelbes Banner kennzeichnet den Demo-Modus

Ideal für LinkedIn-Beiträge, Blogartikel oder um Interessenten vor der Bereitstellung zu erkunden.

## Systemd Service

Für die Produktionsbereitstellung:```bash
# Install
sudo ./install.sh

# Enable and start
sudo systemctl enable sentinel
sudo systemctl start sentinel

# Check status
sudo journalctl -u sentinel -f

Alle Funktionen

FunktionBefehlBeschreibung
Schnellanalyse--quickMenschlich lesbare Zusammenfassung
Netzwerkprüfung--networkLauschende Ports und Verbindungen
Audit-Prüfung--auditSicherheitsereignisse (erfordert Root-Rechte)
Überwachungsmodus--watch --interval 60Kontinuierliche Überwachung
Basislinie lernen--learnAktuellen Zustand als „normal“ speichern
Audit-Basislinie--audit-learnNormale Sicherheitsmuster lernen
Basislinienvergleich--baselineAbweichungen erkennen
JSON-Ausgabe--jsonVollständiger Fingerabdruck für LLM/Dashboard
Farbausgabe--colorFarbige Terminalausgabe
Konfiguration--configAktuelle Einstellungen anzeigen

Die Farbausgabe wird automatisch erkannt (TTY) und respektiert den NO_COLOR-Standard.

Exit-Codes (für CI/CD)

CodeBedeutung
0Keine Probleme erkannt
1Warnungen (kleinere Probleme)
2Kritisch (Zombies, Berechtigungsprobleme, ungewöhnliche Ports, hochriskante Sicherheitsereignisse)
3Fehler (Prüfung fehlgeschlagen)

Was es erfasst

KategorieDatenZweck
SystemHostname, Kernel, Betriebszeit, Last, SpeicherGrundlegender Gesundheitskontext
ProzesseAuffällige Prozesse mit MetadatenErkennung von Zombies, Lecks und hängenden Prozessen
KonfigurationenDateimetadaten + SHA256-PrüfsummenErkennung kryptografischer Abweichungen
NetzwerkListener, Verbindungen, PortsDienstüberwachung
SicherheitAuthentifizierungsfehler, sudo-Nutzung, DateizugriffBedrohungserkennung

Was es markiert

Systemprobleme

  • 🧟 Zombie-Prozesse: Immer ein Problem
  • 📂 Hohe FD-Anzahl: Mögliche Deskriptorlecks (>100 offen)
  • ⏰ Langlaufende Prozesse: >7 Tage ohne Neustart
  • 🔓 Berechtigungsprobleme: Weltweit beschreibbare Konfigurationen

Netzwerkprobleme

  • 🌐 Ungewöhnliche Ports: Dienste nicht in der Liste der üblichen Ports
  • 📡 Neue Listener: Ports, die nicht in der Basislinie waren
  • ❌ Fehlende Dienste: Erwartete Ports, die nicht mehr lauschen

Sicherheitsprobleme (mit --audit)

  • 🔐 Brute-Force: Spitzen bei Authentifizierungsfehlern (>5 im Fenster)
  • 📊 Basislinienabweichung: Aktivität deutlich über dem Normalwert
  • 📝 Zugriff auf sensible Dateien: Änderungen an /etc/shadow, /etc/sudoers
  • ⚠️ Verdächtige Prozesse: Ungewöhnlicher Prozess mit Zugriff auf sensible Dateien
  • 💀 Malware-Indikatoren: Ausführungen aus /tmp oder /dev/shm

Architektur```

┌─────────────────────────────────────────────────────────────────┐ │ Web Dashboard │ │ • Multi-user auth (RBAC) • Two-factor authentication │ │ • Personal API keys • Session management │ │ • Admin audit log • Email & Slack alerts │ │ • Security posture summary • Risk trend sparkline │ │ • Explainable risk factors • Event history timeline │ │ • Multi-host view • Historical charts │ └─────────────────────────────────────────────────────────────────┘ ▲ │ JSON via HTTP POST │ ┌─────────────────────────────────────────────────────────────────┐ │ C Foundation (99KB) │ │ • /proc parsing • SHA256 checksums │ │ • Process analysis • Drift detection │ │ • Network probing • Baseline learning │ │ • Auditd parsing • Risk scoring │ │ • Process chains • Anomaly detection │ └─────────────────────────────────────────────────────────────────┘

root@kitploit:~
### Warum C?

| Bedenken | Python | C |
|---------|--------|---|
| **Abhängigkeiten** | Erfordert Python-Laufzeitumgebung (~100MB) | Statische Binärdatei (~99KB) |
| **Startzeit** | ~500ms Interpreter-Start | ~1ms |
| **Speicher** | ~30MB Grundlast | <2MB |
| **Portabilität** | Benötigt passende Python-Version | Läuft auf jedem POSIX-System |

## Erstellung```bash
make              # Release build
make DEBUG=1      # Debug build with symbols
make test         # Run all tests (unit + integration)
make install      # Install to /usr/local/bin

Testen

C-Sentinel enthält eine umfassende Testsammlung mit 128+ Unit-Tests unter Verwendung des cmocka-Testframeworks.

Installation von cmocka

Debian/Ubuntu:```bash sudo apt-get install libcmocka-dev

root@kitploit:~
**Fedora/RHEL/CentOS:**```bash
sudo dnf install libcmocka-devel

macOS (Homebrew):```bash brew install cmocka

root@kitploit:~
**FreeBSD:**```bash
sudo pkg install cmocka

OpenBSD:```bash doas pkg_add cmocka

root@kitploit:~
### Tests ausführen```bash
make test              # Run all tests (unit + integration)
make unit-test         # Run unit tests only (requires cmocka)
make integration-test  # Run integration/smoke tests only
make coverage          # Run tests with gcov coverage report
make check-cmocka      # Verify cmocka is installed correctly

Testabdeckung

Die Unit-Tests decken ab:

ModulTestsAbdeckung
SHA25610NIST-Testvektoren, Randfälle
Sanitize30Eingabevalidierung, Injection-Prävention
Policy36Befehls-/Pfad-Zulassungs-/Ablehnungsregeln
JSON Serialize11Ausgabeformatierung, Escaping
Baseline11Lernmodus, Abweichungserkennung
Config9Konfigurationsparsen
Audit21Risikobewertung, Ereignisanalyse

Neue Tests schreiben

Die Tests befinden sich in tests/src/ und folgen den cmocka-Konventionen:```c #include <stdarg.h> #include <stddef.h> #include <setjmp.h> #include <cmocka.h> #include "test_helpers.h"

static void test_example(void **state) { (void)state; assert_int_equal(1 + 1, 2); }

int main(void) { const struct CMUnitTest tests[] = { cmocka_unit_test(test_example), }; return cmocka_run_group_tests(tests, NULL, NULL); }

root@kitploit:~
Fügen Sie neue Testdateien zur Variable `TEST_SOURCES` der Makefile hinzu.

## Plattformunterstützung

| Plattform | Build | Prozess-Sonde | Netzwerk-Sonde | Audit |
|-----------|-------|---------------|----------------|-------|
| Linux | ✅ | ✅ /proc | ✅ /proc/net | ✅ auditd |
| macOS | ✅ | ✅ libproc | ✅ netstat | ❌ N/A |
| FreeBSD | ✅ | ✅ libkvm | ✅ netstat | ❌ N/A |
| OpenBSD | ✅ | ✅ libkvm | ✅ netstat | ❌ N/A |
| NetBSD | ✅ | ✅ libkvm | ✅ netstat | ❌ N/A |
| DragonFlyBSD | ✅ | ✅ libkvm | ✅ netstat | ❌ N/A |

### Anforderungen

- GCC oder Clang mit C99-Unterstützung
- GNU Make (gmake auf BSD)
- Unterstützte Plattformen:
  - Linux (Kernel 3.x+)
  - macOS (10.12+)
  - FreeBSD (12+)
  - OpenBSD (7.x)
  - NetBSD (9.x)
  - DragonFlyBSD (6.x)
- auditd (optional, nur Linux für die `--audit`-Flagge)

## Projektstruktur```
c-sentinel/
├── include/
│   ├── sentinel.h        # Core data structures
│   └── audit.h           # Audit integration types
├── src/
│   ├── main.c            # CLI entry point
│   ├── prober.c          # System probing (/proc)
│   ├── net_probe.c       # Network probing
│   ├── audit.c           # Auditd log parsing
│   ├── audit_json.c      # Audit JSON serialisation
│   ├── process_chain.c   # Process ancestry walking
│   ├── baseline.c        # Baseline learning
│   ├── sha256.c          # Pure C SHA256
│   └── ...
├── dashboard/            # Flask web dashboard
├── deploy/               # Systemd service files
└── docs/
    ├── AUDIT_SPEC.md     # Audit integration design
    └── DESIGN_DECISIONS.md

Roadmap

Abgeschlossen ✅

  • Kernsystem-Prober
  • JSON-Serialisierung
  • Netzwerk-Probing
  • Überwachungsmodus und Basislinienlernen
  • SHA256-Prüfsummen
  • Systemd-Dienst
  • Web-Dashboard
  • Auditd-Integration
  • Risikobewertung mit Abweichungsanalyse
  • Prozesszuordnung
  • Dashboard-Authentifizierung
  • Ereignisverlaufs-Zeitleiste
  • Erklärbare Risikofaktoren
  • Sicherheitslage-Zusammenfassung
  • Risikotrend-Sparkline
  • Lern-/Kalibrierungsindikator
  • E-Mail-Benachrichtigungen
  • macOS-Unterstützung
  • FreeBSD-Unterstützung (FreeBSD, OpenBSD, NetBSD, DragonFlyBSD)
  • Mehrbenutzer-Dashboard mit Rollen
  • Zwei-Faktor-Authentifizierung (TOTP)
  • Persönliche API-Schlüssel
  • Admin-Protokoll
  • Sitzungsverwaltung
  • Slack-Webhook-Benachrichtigungen
  • Öffentlicher Demomodus
  • Farbige Terminalausgabe

Geplant 📋

  • Microsoft Teams-Webhook-Benachrichtigungen
  • Benutzerdefinierte Warnregeln
  • PDF-Sicherheitsberichte
  • Berechtigungen auf Hostebene

Lizenz

MIT-Lizenz – siehe LICENSE für Details.

Autor

William Murray – 30 Jahre UNIX-Systemtechnik

  • GitHub: @williamofai
  • LinkedIn: William Murray
  • Website: speytech.com

"Das Ziel ist nicht, Überwachungswerkzeuge zu ersetzen – es geht darum, ihren Daten Weisheit hinzuzufügen."

Tool herunterladen