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.

Live-Demo: sentinel.speytech.com

Screenshots

Sicherheits-Dashboard

Multi-Host-Übersicht

Benutzerprofil & Sicherheitseinstellungen

Zwei-Faktor-Authentifizierung

Einrichtung	Anmeldung

Persönliche API-Schlüssel

Admin-Funktionen

Sitzungsverwaltung

Prüfprotokoll

Sichere Anmeldung

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

## 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:

Lern-/Kalibrierungsindikator

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

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)

### 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)

### 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

### 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"

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

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

Exit-Codes (für CI/CD)

Was es erfasst

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 │ └─────────────────────────────────────────────────────────────────┘

### 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

**Fedora/RHEL/CentOS:**```bash
sudo dnf install libcmocka-devel

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

**FreeBSD:**```bash
sudo pkg install cmocka

OpenBSD:```bash doas pkg_add cmocka

### 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:

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); }

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

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."