Seminar Pulsar: Entwicklung eigener Module mit Rust und eBPF

Einordnung: Das Entwicklerseminar erweitert Pulsar um eigene Datenerfassung und Verarbeitung. Behandelt werden Architektur und Ereignisbus, Auswahl geeigneter Kernel-Hooks, eBPF-Programme, sichere Datenübergabe, Rust-basierte Userspace-Module, Ereignisschemata, Konfiguration, Tests, Fehlerbehandlung und wartbare Paketierung.

Inhaltsübersicht

1. Entwicklungsumgebung und Quellstruktur vorbereiten
2. Modularchitektur und Ereignisbus analysieren
3. Anwendungsfall und Ereignisschema entwerfen
4. Geeignete eBPF-Hooks auswählen
5. Kernelkomponente implementieren
6. Userspace-Modul in Rust entwickeln
7. Integration in Regeln und Logging
8. Tests und Qualitätssicherung
9. Performance und Stabilität bewerten
10. Paketierung und Wartung

Zielgruppe

Rust- und Systementwickler, Kernel- und eBPF-Engineers, Embedded-Linux-Entwickler, Security-Tool-Entwickler und technische Maintainer eigener Pulsar-Erweiterungen.

Lernziele

• Pulsars Modul- und Ereignisarchitektur auf Quellcodeebene nachvollziehen.
• Geeignete Kernel-Hooks und minimale Ereignisdaten für einen Anwendungsfall auswählen.
• eBPF- und Userspace-Komponenten sicher miteinander verbinden.
• Eigene Ereignistypen, Konfiguration und Fehlerbehandlung implementieren.
• Module automatisiert testen, profilieren und wartbar paketieren.

Seminarinhalte

Entwicklungsumgebung und Quellstruktur vorbereiten

1. Schritt 1: Rust-Toolchain, Compilerabhängigkeiten, Kernelheader und BTF-Informationen prüfen.
2. Schritt 2: Workspace, Crates, vorhandene Module, Beispiele und Teststruktur des Projekts erschließen.
3. Schritt 3: Einen reproduzierbaren Build für die Laborarchitektur erstellen und Basistests ausführen.

Modularchitektur und Ereignisbus analysieren

1. Schritt 1: Lebenszyklus eines Moduls von Initialisierung über Ereignisproduktion bis Shutdown nachvollziehen.
2. Schritt 2: Publisher-, Subscriber- und Konfigurationsbeziehungen im Ereignisbus identifizieren.
3. Schritt 3: Verantwortlichkeiten zwischen Kernelprobe, Userspace-Auswertung und nachgelagerten Modulen abgrenzen.

Anwendungsfall und Ereignisschema entwerfen

1. Schritt 1: Sicherheitsfrage, benötigten Kernelzeitpunkt und erforderlichen Prozesskontext präzisieren.
2. Schritt 2: Minimale Felder, Datentypen, Fehlerwerte und Versionsstrategie für das Ereignis festlegen.
3. Schritt 3: Datenschutz, Ereignisvolumen und Kompatibilität mit Regeln und Loggern berücksichtigen.

Geeignete eBPF-Hooks auswählen

1. Schritt 1: Tracepoints, Kprobes, LSM-Hooks und andere Anknüpfungspunkte nach Stabilität und Aussagekraft vergleichen.
2. Schritt 2: Kernel- und Architekturabhängigkeiten sowie mögliche Race Conditions dokumentieren.
3. Schritt 3: Einen Hook wählen, der das Ereignis mit möglichst wenig Overhead und eindeutiger Semantik liefert.

Kernelkomponente implementieren

1. Schritt 1: BPF-Datenstrukturen, Maps und sichere Feldzugriffe definieren.
2. Schritt 2: Verifier-freundliche Kontrollflüsse und begrenzte Datenmengen umsetzen.
3. Schritt 3: Fehlerpfade, verlorene Ereignisse und fehlende Kernelinformationen explizit behandeln.

Userspace-Modul in Rust entwickeln

1. Schritt 1: Kernelereignisse einlesen, validieren und in das Pulsar-Ereignisschema übersetzen.
2. Schritt 2: Konfigurationswerte, Modulstatus, Start, Stop und saubere Ressourcenfreigabe implementieren.
3. Schritt 3: Strukturierte Diagnosemeldungen für Lade-, Laufzeit- und Datenfehler bereitstellen.

Integration in Regeln und Logging

1. Schritt 1: Das neue Ereignis so veröffentlichen, dass nachgelagerte Module es zuverlässig verarbeiten können.
2. Schritt 2: Repräsentative Regeln für positive und negative Szenarien erstellen.
3. Schritt 3: Ausgabe, Feldnamen und Dokumentation auf Verständlichkeit für Regelautoren prüfen.

Tests und Qualitätssicherung

1. Schritt 1: Unit-Tests für Parser, Konfiguration und Ereignisumwandlung schreiben.
2. Schritt 2: Integrations- und Kerneltests mit kontrollierten Auslösern automatisieren.
3. Schritt 3: Fehlende BPF-Funktionen, alternative Kernelstände und Architekturunterschiede als Testfälle aufnehmen.

Performance und Stabilität bewerten

1. Schritt 1: Ereignisrate, CPU, Speicher, Map-Nutzung und Verlustquoten messen.
2. Schritt 2: Hot Paths und unnötige Datenkopien identifizieren und reduzieren.
3. Schritt 3: Lastgrenzen, Sampling oder Filterstrategien dokumentieren, ohne die Sicherheitssemantik zu verfälschen.

Paketierung und Wartung

1. Schritt 1: Buildartefakte, Konfiguration, Regeln und Dokumentation versioniert zusammenstellen.
2. Schritt 2: Kompatibilitätsangaben und Migrationshinweise für Ereignisschema und Konfiguration definieren.
3. Schritt 3: Code Review, Sicherheitsprüfung, Release und Rückfall auf eine vorherige Modulversion organisieren.

Praxisübungen

• Ein eigenes Modul wird von der Sicherheitsfrage bis zum Ereignisschema entworfen.
• Eine eBPF-Probe und das zugehörige Rust-Userspace-Modul werden implementiert und integriert.
• Regeln, Unit-Tests und Kernelintegrationstests werden für das neue Ereignis erstellt.
• Das Modul wird profiliert, optimiert und als versioniertes Paket vorbereitet.

Arbeitsweise

Quellcodeanalyse, Pair Programming, Kerneltests und Profiling führen schrittweise zu einem funktionsfähigen eigenen Modul.

Voraussetzungen

Gute Rust- und Linux-Systemprogrammierkenntnisse. Grundverständnis von eBPF, Kernelereignissen und Pulsar-Architektur wird vorausgesetzt.