Ein Leitfaden aus der Praxis zur Absicherung von KI-Rechenzentren und KI-Agenten mit NVIDIAs Cybersecurity-Portfolio und zur Überwachung all dessen über eine einzige OpenTelemetry-Pipeline, die die Werkzeuge speist, die Sicherheitsteams bereits betreiben: Elastic Security als SIEM, Dynatrace, Prometheus mit Alertmanager sowie Grafana. Er behandelt die spezifischen Bedrohungen für GPU-Umgebungen und Agenten, was jedes NVIDIA-Produkt Schicht für Schicht leistet (BlueField und DOCA, DOCA Argus, DOCA Vault, Sentry, Confidential Computing, OpenShell, Nemotron Safety, NeMo Guardrails, garak und Morpheus), welche Telemetrie jedes davon tatsächlich ausgibt, eine validierte Collector-Konfiguration, vierzehn Elastic-Erkennungsregeln, die in ein laufendes Kibana geladen und mit Testereignissen ausgelöst wurden, Prometheus-Alarmregeln mit Unit-Tests, Response-Playbooks, Compliance-Zuordnung, Aufbewahrung und Kosten, Hochverfügbarkeit und wie Workstation dies umsetzt.
otelcol-contrib validate 0.165.0 validiert und anschließend Ende-zu-Ende betrieben: Testereignisse liefen über ein echtes Gateway in Elasticsearch 9.2.0 und Prometheus 3.12.0. Ingest-Pipeline, Index-Template und Lifecycle-Policy wurden auf diesem Elasticsearch angewendet, und alle vierzehn Erkennungsregeln wurden über die Detection Engine von Kibana 9.2.0 angelegt, erfolgreich ausgeführt und lösten die erwarteten Alarme aus. Die Prometheus-Regeln bestanden promtool check rules und promtool test rules; die Alertmanager-Konfiguration bestand amtool check-config; das Kubernetes-Manifest bestand kubeconform. Dynatrace, BlueField-4, Sentry, DOCA Vault und Confidential-Computing-Hardware standen im Test nicht zur Verfügung; diese Teile sind daher anhand der öffentlichen Dokumentation von NVIDIA und Dynatrace beschrieben, und wir weisen jeweils darauf hin. Abschnitt 18 führt alle Quellen und Lücken auf.
Dieser Artikel erweitert zwei frühere Technotes, statt sie zu ersetzen. Das Referenzdesign zu UFM, DCGM und OpenTelemetry beschreibt den Collector-Agenten auf jedem Node und das Gateway-Paar, das wir für operative Telemetrie verwenden, und das Minerva-AIOps-Runbook behandelt Incident-Korrelation und änderungskontrollierte Behebung. Sicherheitstelemetrie folgt demselben Muster aus Agent und Gateway, mit einer Änderung: Sie erhält ein eigenes Gateway-Paar, das dem Sicherheitsteam gehört. Unser Standard Big Prometheus und MoSCoW gilt weiterhin: OpenTelemetry ist der Telemetrie-Vertrag, PromQL ist die Metriksprache, und jede Art von Log hat genau einen primären Speicher.
1. Management-Zusammenfassung
KI-Rechenzentren sind aus Gründen attraktive Ziele, die für gewöhnliche Serverräume nicht gelten. Die Hardware ist teuer, und es ist leicht, ihr Rechenzeit abzuzweigen. Modellgewichte und Trainingsdaten sind oft das wertvollste geistige Eigentum eines Unternehmens. Und KI-Agenten handeln inzwischen selbstständig: Sie lesen nicht vertrauenswürdige Webseiten und Dokumente, rufen Werkzeuge auf, verwenden Zugangsdaten und verändern Systeme. Eine einzige versteckte Anweisung in einem Dokument kann einen hilfreichen Agenten in einen Innentäter verwandeln.
NVIDIAs Antwort ist Defense in Depth über den gesamten Stack. Einfach ausgedrückt:
- Die DPU überwacht den Server von außerhalb. BlueField betreibt Sicherheitsdienste in einer eigenen isolierten Domäne, sodass Malware auf dem Host sie nicht abschalten kann. DOCA Argus untersucht den Hostspeicher auf Laufzeitbedrohungen; Sentry überwacht Agenten und kann sie innerhalb von Millisekunden unter Quarantäne stellen; DOCA Vault schützt sensible Daten.
- Die GPU schützt Daten während der Nutzung. Confidential Computing hält Daten und Modellgewichte verschlüsselt und isoliert innerhalb der GPU, und die Attestierung weist dies nach, bevor etwas Sensibles freigegeben wird.
- Agenten laufen in einer Sandbox mit schriftlicher Policy. OpenShell legt fest, welche Dateien, Netzwerkziele, Prozesse und Zugangsdaten ein Agent verwenden darf, setzt dies im Kernel und im Proxy durch und protokolliert jede Entscheidung in einem standardisierten Sicherheitsschema.
- Modelle werden auf dem Hin- und Rückweg geprüft. Nemotron-Safety-Modelle und NeMo Guardrails filtern unsichere Prompts und Antworten; garak greift Ihre Agenten an, bevor Angreifer es tun.
Was NVIDIAs Produkte allein nicht leisten: einem Security-Operations-Team einen zentralen Ort zu geben, an dem es all dies sehen, mit Identität, Kubernetes, dem Web-Edge und Secrets korrelieren und darauf reagieren kann. Genau darum geht es in diesem Artikel, und hier kommt Workstations Praxis für Observability und SIEM ins Spiel. Das Ergebnis für das Unternehmen:
- Jede Sicherheitskontrolle erzeugt Nachweise, die innerhalb von Sekunden in einem einheitlichen Schema in Ihrem SIEM landen;
- Erkennungen für die Angriffe, die in KI-Umgebungen zählen (Agent-Hijacking, Modelldiebstahl, GPU-Missbrauch, Missbrauch von Berechtigungen), jeweils mit einer getesteten Reaktion;
- Eindämmung, die nur dann automatisch erfolgt, wenn sie sicher und umkehrbar ist, und andernfalls eine menschliche Freigabe erfordert;
- Nachweise für Auditoren unter UK GDPR, ISO 27001 und NIS-artigen Regelwerken, zu planbaren Kosten.
Workstation ist NVIDIA-Partner. Wir liefern die Hardware und stellen Engineering, Software und Personal bereit, um dies gemeinsam mit Ihnen zu entwerfen, aufzubauen und zu betreiben, von einer ersten Bewertung bis zur laufenden Monitoring-Unterstützung (Abschnitt 17).
2. Die Bedrohungslage für KI-Rechenzentren und Agenten
Die meisten Bedrohungen für eine KI-Umgebung sind bekannte Bedrohungen mit neuen Zielen. Die Tabelle ordnet jeder zu, wo sie auftritt, welche Kontrolle sie verhindert oder begrenzt und welches Signal Ihnen zeigt, dass sie eingetreten ist. Abschnitt 11 macht aus jedem Signal eine Erkennungsregel.
| Bedrohung | Wie sie sich zeigt | Präventive Kontrollen | Signal, das wir beobachten |
|---|---|---|---|
| Direkte Prompt Injection und Jailbreaks | Nutzer formulieren Prompts so, dass ein Modell seine Anweisungen ignoriert oder schädliche Ausgaben erzeugt | Input Rails von NeMo Guardrails, Nemotron-Safety-Klassifikatoren, garak-Tests in der CI | Rail-Blockierungen pro Nutzer; garak-Angriffserfolgsrate pro Probe |
| Indirekte Prompt Injection und Goal Hijacking | In einer Webseite, E-Mail oder einem Dokument, das der Agent liest, versteckte Anweisungen lenken ihn auf ein neues Ziel um, oft Exfiltration | Netzwerk- und Datei-Policy von OpenShell (standardmäßig verweigern), Retrieval Rails, menschliche Freigabe für neue Zugriffe | OpenShell-Verweigerungen und neue Ziele; Häufungen von Verweigerungen pro Sandbox |
| Datenabfluss | Personenbezogene Daten, Secrets oder Quellcode in Prompts, Antworten, Logs oder Uploads von Agenten | Output Rails der Guardrails und Maskierung sensibler Daten, Egress-Policy von OpenShell, Credential Injection, sodass Agenten nie echte Secrets besitzen | Output-Rail-Blockierungen, Egress-Verweigerungen, Funde sensibler Daten (Morpheus oder Rails) |
| Diebstahl von Modellen und Gewichten | Große Übertragungen von Checkpoints oder Gewichten; untypische Lesezugriffe auf Modell-Registries | Confidential Computing, DOCA Vault, in wslvault verwahrte Schlüssel, Netzwerksegmentierung | Egress-Volumen von Inferenz- und Storage-Nodes; Secret-Zugriffe außerhalb der Geschäftszeiten; fehlgeschlagene Attestierungen |
| Lieferkette | Vergiftete Modelldateien, von Agenten installierte bösartige Pakete, manipulierte Container-Images | Prozess- und Paket-Policy von OpenShell, Image-Signierung und Admission Control, garak-Regressionstests | Neue Prozessausführungen (Argus, auditd), unerwartete Image-Hashes, garak-Regressionen |
| Laterale Bewegung | Ein kompromittierter Agent oder Pod erreicht die Kubernetes-API, den Cloud-Metadatendienst oder andere Mandanten | OpenShell blockiert Control-Plane-Ports und Link-Local-Adressen; Kubernetes-RBAC und Network Policy; BlueField-Isolation | Verweigerungen im SSRF-Stil, sandboxübergreifende Autorisierungsbefunde, Erstellung privilegierter Pods |
| GPU-Cryptojacking | Miner nutzen gestohlene GPU-Zeit, oft auf ungenutzten oder schlecht geplanten Nodes | GPU-Zugriff nur über den Scheduler, Ausführungs-Policy, Laufzeiterkennung mit DOCA Argus | GPU ausgelastet ohne geplanten Job (DCGM); Ausführungen aus /tmp; Argus-Alarme |
| Missbrauch durch Innentäter | Ein Administrator oder kompromittiertes Konto liest Secrets, erweitert Agentenberechtigungen oder deaktiviert das Monitoring | Single Sign-on mit Freigabeschritten, Least Privilege, Funktionstrennung für die Sicherheitspipeline | Auffällige Anmeldung, gefolgt von privilegierter Freigabe; Secret-Zugriffe außerhalb vereinbarter Zeiten; Telemetrielücken |
| Nicht vertrauenswürdige Infrastruktur | Ein Hosting-Anbieter, Mitmandant oder Betreiber mit Hostzugriff versucht, Daten oder Gewichte während der Nutzung zu lesen | Confidential Computing mit Attestierung vor der Schlüsselfreigabe | Fehlgeschlagene Attestierungen; Workloads, die ohne erfolgreiche Attestierung gestartet wurden |
3. NVIDIAs Cybersecurity-Portfolio, Schicht für Schicht
NVIDIA fasst diese Produkte auf seiner Seite zu Cybersecurity-KI-Lösungen zusammen. Wir finden es übersichtlicher, sie nach der Schicht zu ordnen, die sie schützen, denn daraus ergibt sich, woher die Telemetrie jedes Produkts stammt und was es sehen kann, was die anderen nicht sehen.
3.1 Silizium und DPU: BlueField, DOCA, DOCA Argus, DOCA Vault und Sentry
BlueField ist NVIDIAs Data Processing Unit: ein Netzwerkadapter mit eigenen Arm-Kernen, eigenem Speicher und eigenem Betriebssystem, der zwischen Server und Netzwerk sitzt. DOCA ist das Software-Framework zu seiner Programmierung. Der Sicherheitsaspekt ist die Trennung. Dienste auf der DPU laufen in einer Domäne, die das Host-Betriebssystem nicht kontrolliert; ein Angreifer mit Root-Rechten auf dem Host kann sie also weder lesen noch stoppen.
DOCA Argus nutzt diese Position, um den Host zu beobachten. Laut NVIDIAs DOCA-Argus-Serviceleitfaden läuft es als Container auf BlueField-3 oder neuer (im DPU-Modus), liest ausgewählte Kernel-Strukturen per DMA aus dem Hostspeicher und rekonstruiert daraus ein Bild von Prozessen, Binärdateien mit ihren Hashes, Kommandozeilen, Dateien, Netzwerkverbindungen, Containern und VMs sowie der GPU-Nutzung pro Prozess, ohne dass ein Agent auf dem Host installiert ist. Daraus erzeugt es Alarme für Laufzeitbedrohungen wie Reverse Shells und unerwartete Ausführungen. Für die Integration wichtig:
- Nachrichten haben einen
message_typevonEVENT,ALERToderSYSTEM_ACTIVITYund einenseverityvonINFObisCRITICAL, mit Payload-Abschnitten wieworkload_informationundactivity_data. - Der Telemetrieexport ist standardmäßig deaktiviert. Er wird mit
telemetry_address,telemetry_format(JSON oder Syslog) undtelemetry_tagkonfiguriert, und NVIDIAs Beispiele senden ihn per TCP an Fluent Bit oder Vector. - NVIDIA gibt an, dass Argus mit führenden Enterprise-XDR-Plattformen integriert ist. Wenn Sie eine solche betreiben, kann sie der primäre Empfänger bleiben; unsere Pipeline erhält dann eine Kopie zur Korrelation mit allem anderen.
Unser Gateway empfängt Argus-JSON direkt auf einem TCP-Listener (Abschnitt 6). Trennt Ihr Argus-Release Nachrichten nicht durch Zeilenumbrüche, schalten Sie Fluent Bit oder Vector dazwischen, wie es NVIDIAs Leitfaden zeigt, und leiten per OTLP an den Collector weiter; der Rest des Designs bleibt unverändert. NVIDIAs Leitfaden zeigt die Nachrichtenfelder in seinem Beispiel auf oberster Ebene, beschreibt in seiner Schematabelle aber eine message_header-Wurzel; prüfen Sie daher eine echte Nachricht aus Ihrem Release, bevor Sie sich auf die Feldpfade in unserer Regel verlassen.
DOCA Vault ist ein Sicherheits-Microservice auf BlueField, der sensible Daten mit Kontrollen im Silizium und Zero-Trust-Zugriff schützt. Wir haben ihn nicht getestet und beschreiben seine Schnittstellen hier nicht. In unseren Designs steht er neben dem Schlüsselmanagement, das Secrets an Workloads freigibt (bei uns wslvault), nicht an dessen Stelle.
NVIDIA Sentry on BlueField ist der neueste Baustein. NVIDIA beschreibt ihn als Teil seiner Open Agent Safety Platform: Er läuft in der hardwareisolierten Domäne von BlueField-4, unabhängig vom Host und von der eigenen Software des Agenten, überwacht das Verhalten von Agenten auf Policy-Abweichungen und verdächtige Aktivitäten, liefert vertrauenswürdige Telemetrie und kann einen Agenten mithilfe der Infrastrukturkontrollen der DPU innerhalb von Millisekunden unter Quarantäne stellen. Da er Out-of-Band arbeitet, funktioniert er auch dann noch, wenn der Host oder die Agenten-Runtime kompromittiert wurde, also genau dann, wenn Sie ihn brauchen. Wir behandeln die Alarme und Quarantänemaßnahmen von Sentry als vollwertige SIEM-Ereignisse; das genaue Exportformat sollte der Sentry-Dokumentation von NVIDIA für das eingesetzte Release entnommen werden.
DOCA Telemetry Service exportiert DPU-Zähler im Prometheus-Format. Er ist bereits Teil des UFM-Referenzdesigns und erfordert hier keine Änderung, außer dass Port- und Drop-Zähler auf DPUs vor Agenten-Hosts zu nützlichem Kontext bei Sicherheitsuntersuchungen werden.
3.2 Plattform: Confidential Computing und Attestierung
Confidential Computing schützt Daten und Modelle während der Nutzung. Die GPU führt die Workload in einer hardwarebasierten Trusted Execution Environment aus, sodass weder das Host-Betriebssystem noch der Hypervisor noch die Personen, die die Infrastruktur betreiben, den Speicher lesen können, und die GPU kann ihren Zustand per Attestierung nachweisen. Damit ist es die Kontrolle für zwei Bedrohungen, die nichts anderes in der Tabelle gut abdeckt: einen nicht vertrauenswürdigen Hosting-Anbieter und die gemeinsame Nutzung von Daten oder Modellen mit einer Partei, der Sie nicht vollständig vertrauen.
Die Betriebsregel ist einfach: keine erfolgreiche Attestierung, keine Schlüssel. Ein Start-Wrapper attestiert die GPU (und die Confidential VM), bevor die Workload startet, und fordert erst dann beim Schlüsseldienst den Entschlüsselungsschlüssel für Datensatz oder Modell an. NVIDIA veröffentlicht die Attestierungswerkzeuge in nvTrust; dessen README kennzeichnet das Python-Attestierungs-SDK und den lokalen GPU-Verifier als veraltet zugunsten eines C++-SDK und einer CLI; planen Sie neue Integrationen daher auf dieser Basis. Wir protokollieren jedes Attestierungsergebnis als strukturiertes Ereignis (bestanden oder fehlgeschlagen, welche GPU, welche Workload, welcher Verifier) und alarmieren bei jedem Fehlschlag.
3.3 Runtime: OpenShell
OpenShell ist NVIDIAs Open-Source-Runtime (Apache 2.0) für autonome Agenten. Jeder Agent läuft in einer Sandbox; eine Policy legt fest, welche Dateien er lesen oder schreiben darf, welche Netzwerkziele und HTTP-Methoden er verwenden darf, welche Prozesse er ausführen und welche Zugangsdaten er nutzen darf, und OpenShell setzt dies im Kernel und in einem Policy-prüfenden Proxy durch. Echte Zugangsdaten bleiben außerhalb der Sandbox: OpenShell fügt sie in ausgehende Anfragen ein, und nur dann, wenn das Ziel ein freigegebener Endpunkt ist. Bevor eine Policy-Änderung angewendet wird, markiert ein formaler Verifikationsschritt neue Zugriffe, die eine menschliche Prüfung erfordern. Unser früherer OpenShell-Artikel zeigt Schritt für Schritt, wie Agenten darunter betrieben werden.
Für ein SIEM ist OpenShell die ergiebigste Quelle im Stack, weil es jede Sicherheitsentscheidung im Open Cybersecurity Schema Framework (OCSF) in Version 1.8.0 aufzeichnet. Aus seiner Observability-Dokumentation:
- Sandbox-Supervisoren und das Gateway geben OCSF-Ereignisse für Netzwerkaktivität (Klasse 4001), HTTP-Aktivität (4002), SSH (4007), Prozessaktivität (1007), Detection Findings (2004), Authentifizierung (3002), Konfigurationsänderungen (5019), Anwendungslebenszyklus (6002) und API-Aktivität (6003) aus.
- Verweigerte Netzwerk- und HTTP-Ereignisse tragen den Grund in
status_detail, zum Beispielno matching policyoderresolves to always-blocked address(ein Link-Local- oder Loopback-Ziel wie ein Cloud-Metadaten-Endpunkt). - Ruft ein Sandbox-Credential eine Methode oder eine andere Sandbox auf, die es niemals berühren sollte, erzeugt das Gateway ein Detection Finding hoher Schwere mit
finding_info.uidsandbox-authorization-boundary: Das Credential könnte kompromittiert sein. - Wird
enabled = trueunter[openshell.gateway.otlp.ocsf]ingateway.tomlgesetzt, werden OCSF-Ereignisse als OTLP-Log-Records unter dem Instrumentation Scopeopenshell.ocsfexportiert. Der Body ist das OCSF-Ereignis als JSON; zu den Attributen gehörenocsf.class_uid,ocsf.severity_id,ocsf.metadata.uidundopenshell.sandbox.id; Supervisoren senden ihre eigenen Ereignisse an denselben Endpunkt. - Die Zustellung erfolgt mindestens einmal (at least once); deduplizieren Sie daher anhand von
ocsf.metadata.uid. Vom Gateway verworfene Records werden inopenshell_ocsf_otlp_dropped_totalgezählt, und der nächste Batch enthält einen Warn-Record namensopenshell.ocsf.gap. - Das Gateway stellt Prometheus-Metriken auf einem separaten Listener ohne Authentifizierung bereit; halten Sie ihn daher intern. Interceptor-Fehler, die eine Anfrage durchlassen, werden in
openshell_gateway_interceptor_fail_open_totalgezählt.
Die Kurzform der Logzeile für eine verweigerte Verbindung sieht so aus (aus NVIDIAs Dokumentation):
OCSF NET:OPEN [MED] DENIED /usr/bin/curl(64) -> httpbin.org:443 [policy:- engine:opa] [reason:no matching policy]
NVIDIAs OpenShell Reference Architecture baut einen vollständigen Stack um die Runtime herum: Vera-CPUs betreiben die Agenten-Harnesses und ihre Werkzeuge, Vera-Rubin-Systeme stellen die Inferenz bereit, und Sentry auf BlueField-4 ergänzt Überwachung und Durchsetzung, die nicht vom Host abhängen. NVIDIA stellt ausdrücklich klar, dass OpenShell auch auf anderen CPU-Systemen läuft und dass Vera und BlueField optional sind; sie bringen Effizienz und die Out-of-Band-Schicht, nicht die Grundfunktion. NemoClaw, NVIDIAs Sammlung offener Blueprints für spezialisierte Agenten auf Basis von Nemotron-Modellen, betreibt seine Agenten innerhalb von OpenShell; alles in diesem Artikel gilt daher unverändert für NemoClaw-Agenten. NemoClaw selbst behandeln wir in einem separaten Artikel.
3.4 Modelle und Guardrails: Nemotron Safety, NeMo Guardrails und garak
Nemotron ist NVIDIAs Familie offener Modelle; NVIDIA positioniert einige für Planung und Reasoning, einige für schnelle Tool-Aufrufe in hohem Volumen sowie eine Reihe von Nemotron-Safety-Modellen, die unsichere Inhalte in Text und Bildern klassifizieren, sodass sie auf dem Weg in eine Agentenpipeline oder aus ihr heraus gefiltert werden können. Mit NeMo spezialisiert, können Nemotron-Modelle auch die eigenen Agenten der Verteidiger für Alarm-Triage, kontinuierliches Threat Hunting und Red-Team-Simulation betreiben.
NeMo Guardrails (zum Zeitpunkt der Erstellung aktuelles Release 0.24.1) setzt programmierbare Rails zwischen eine Anwendung und ihr Modell: Input Rails (zum Beispiel Jailbreak-Prüfungen und Maskierung sensibler Daten), Dialog Rails, Retrieval Rails auf RAG-Chunks, Execution Rails auf Tool-Ein- und -Ausgaben sowie Output Rails. Hinter einer Rail kann ein Sicherheitsklassifikator wie ein Nemotron-Safety-Modell sitzen. Für das Monitoring hat seine config.yml einen Abschnitt tracing mit einem OpenTelemetry-Adapter; die Bibliothek verwendet nur die OpenTelemetry-API, und Ihre Anwendung konfiguriert SDK und Exporter. Prompt- und Antwortinhalte werden nicht erfasst, sofern Sie nicht enable_content_capture: true setzen; lassen Sie dies in der Produktion deaktiviert, denn Prompts enthalten oft personenbezogene Daten.
Spans zeigen Ihnen, welche Rails gelaufen sind und wie lange sie gedauert haben, was ideal für Dynatrace ist. Für das SIEM möchten wir zusätzlich ein Ereignis pro Blockierung, mit wer, welche Rail und was geschehen ist, aber ohne Inhalt. Dieses erzeugen wir über einen schlanken Wrapper um den Rails-Aufruf, mit unserer eigenen Feldkonvention (event.action: input_rail_blocked, rule.name auf den Rail-Flow gesetzt, user.id). Diese Konvention stammt von Workstation und ist nicht Teil von NeMo Guardrails.
garak ist NVIDIAs Schwachstellenscanner für LLMs: Er führt Probes (Prompt Injection, Jailbreaks wie die DAN-Familie, Datenabfluss, Encoding-Tricks, Wiedergabe von Trainingsdaten und mehr) gegen einen Modell- oder Agenten-Endpunkt aus und bewertet die Antworten mit Detektoren. Jeder Lauf schreibt einen JSONL-Bericht; dessen Evaluierungs-Records haben entry_type: "eval" mit probe, detector, passed, fails und total_evaluated. Wir führen garak in der CI bei jeder Änderung an einem Modell, einem Prompt oder einer Guardrail-Konfiguration aus und senden diese Records an das SIEM, sodass eine Regression eine Erkennung wie jede andere ist.
# CI step (example): scan the staging endpoint with a fixed probe set
python -m garak --config ci/garak-staging.yaml --target_type rest \
--spec probes.promptinject,probes.dan,probes.encoding,probes.leakreplay \
--report_prefix ci-${CI_PIPELINE_ID}
Hier ist ci/garak-staging.yaml eine garak-Konfigurationsdatei, die dem REST-Generator die URI und die Anfragevorlage Ihres Endpunkts übergibt (siehe garak-Dokumentation; es gibt auch Generatoren für OpenAI-kompatible Endpunkte, Hugging Face, Bedrock und andere). Aktuelle garak-Releases wählen Probes mit --spec aus; das ältere Flag --probes funktioniert noch, ist aber veraltet. Kopieren Sie die resultierende *.report.jsonl in das Verzeichnis, das der Collector des CI-Runners überwacht.
3.5 Pipelines: Morpheus
Morpheus ist NVIDIAs GPU-beschleunigtes Framework zum Aufbau von Cybersecurity-Inferenzpipelines über große Datenströme. Sein Repository enthält Beispielpipelines und vortrainierte Modelle für digitales Fingerprinting des Verhaltens von Nutzern und Maschinen, Phishing-Erkennung, Erkennung sensibler Informationen, Log-Parsing, Ransomware-Erkennung aus AppShield-Daten, Betrugserkennung mit Graph Neural Networks, Data Loss Prevention und Profilierung auffälligen Verhaltens, darunter ein Beispiel, das Kryptowährungs-Mining anhand von GPU-Telemetrie erkennt. Prüfen Sie den Status, bevor Sie damit planen: Zum Zeitpunkt der Erstellung ist das neueste getaggte Release 25.06 (Juli 2025). Wo ein Kunde bereits Morpheus-Pipelines betreibt, sind deren Ausgaben einfach eine weitere bewertete Quelle: Wir senden die Scores und markierten Records als Ereignisse in dasselbe Gateway.
4. Workstations Referenzarchitektur für Security Observability
Fünf Prinzipien bestimmen das Design:
- Eine Pipeline. Jedes Sicherheitssignal gelangt über einen OpenTelemetry Collector hinein. Backends ziehen niemals direkt von Quellen; ein Backend hinzuzufügen oder zu ersetzen ist daher eine Änderung am Gateway, nicht an der gesamten Flotte.
- Einmal normalisieren, am Gateway. Felder werden auf ECS-Namen (und, wo vorhanden, auf OTel Semantic Conventions) abgebildet, bevor sich die Daten verzweigen, sodass eine Regel in Elastic und ein Dashboard in Grafana über dasselbe
destination.domainsprechen. - Schwärzen, bevor etwas hinausgeht. Authorization-Header, Cookies, API-Tokens sowie Prompt- oder Completion-Text werden am Gateway entfernt. Kein Backend speichert sie jemals, daher muss keinem Backend damit vertraut werden.
- Jedes Backend tut, was es am besten kann. Elastic Security hält jedes Sicherheitsereignis vor und führt Korrelationsregeln und Cases aus. Dynatrace erhält die Ereignisse höherer Schwere, Metriken und Traces, damit seine KI Sicherheitsereignisse mit dem Zustand von Diensten verknüpfen kann. Prometheus erhält Zähler mit geringer Kardinalität sowie die GPU- und Netzwerkmetriken, die es bereits vorhält, für schnelle, kostengünstige Alarme. Grafana ist der gemeinsame Bildschirm.
- Die Pipeline überwacht sich selbst. Verworfene Records, fehlschlagende Exporte und verlorene Gateways sind Sicherheitsalarme, keine Betriebstickets (Abschnitt 15).
Ebenen
- Node-Agenten sind dieselben Agenten wie im UFM-Design: ein Collector pro GPU-, Storage-, Login- und Control-Plane-Node. Wir ergänzen drei Receiver (auditd, das Audit-Log des Kubernetes-API-Servers und garak-Berichte auf CI-Runnern) sowie einen zweiten Exporter, der Sicherheitslogs an die Security-Gateways statt an die Operations-Gateways sendet.
- Ein Security-Gateway-Paar (oder mehr) hinter einer virtuellen IP oder einem DNS-Namen, betrieben vom Sicherheitsteam. Es empfängt OTLP von Agenten, von OpenShell-Gateways und -Supervisoren sowie von abgesicherten Anwendungen; Argus-JSON per TCP; und Syslog über TLS von Appliances. Es scrapt die Metrik-Endpunkte des OpenShell-Gateways und von wslproxy. Backend-Zugangsdaten existieren nur hier.
- Die Operations-Gateways bleiben unverändert. DCGM-, Node- und Fabric-Metriken fließen weiterhin wie im UFM-Design an Mimir oder Prometheus; die Cryptojacking- und Exfiltrationsalarme in Abschnitt 9 laufen dort, weil die Daten bereits dort liegen.
Warum separate Security-Gateways? Funktionstrennung (das Plattformteam kann Sicherheitsereignisse nicht unbemerkt herausfiltern), unterschiedliche Aufbewahrungs- und Zugriffsregeln und ein kleinerer Schadensradius: Eine fehlerhafte Dashboard-Abfrage oder eine Betriebsänderung kann die Sicherheitspipeline nicht aushungern.
Quellen
| Quelle | Was sie uns verrät | Transport in die Pipeline | Datensatz |
|---|---|---|---|
| OpenShell-Gateway und -Supervisoren | Jede Erlaubnis und Verweigerung für Netzwerk-, HTTP-, Prozess-, SSH-, Authentifizierungs- und API-Aufrufe; Policy-Ladevorgänge; Findings | OCSF über OTLP von [openshell.gateway.otlp.ocsf]; Gateway-Metriken per Scrape | openshell.ocsf |
| DOCA Argus auf BlueField | Laufzeitalarme und Aktivitäten aus der Analyse des Hostspeichers | JSON per TCP an das Gateway | doca.argus |
| Sentry auf BlueField-4 | Verhaltensabweichungen von Agenten, Quarantänemaßnahmen | Gemäß NVIDIAs Sentry-Dokumentation; wir bilden es auf dasselbe Datensatzmuster ab | nvidia.sentry (geplant) |
| Confidential Computing | Attestierung bestanden oder fehlgeschlagen pro GPU und Workload | Start-Wrapper protokolliert ECS-JSON an Syslog | cc.attestation |
| Anwendungen mit NeMo Guardrails | Rail-Blockierungen (Ereignisse) und Rail-Laufzeiten (Spans) | OTLP von der Anwendung | nemo.guardrails |
| garak in der CI | Angriffserfolgsrate pro Probe und Detektor | Collector des Runners liest den JSONL-Bericht mit | garak.eval |
| Kubernetes-API-Server | Wer was erstellt, geändert oder per exec betreten hat | Agent auf Control-Plane-Nodes liest das Audit-Log mit | kubernetes.audit_logs |
| wslproxy-WAF | Jede WAF-Entscheidung mit Signatur, Client und Route; Prometheus-Zähler | wafsec-JSON über Syslog; Metriken per Scrape | wslproxy.waf |
| wslvault | Lese-, Schreib- und abgelehnte Zugriffe auf Secrets pro Identität | ECS-JSON über Syslog | wslvault.audit |
| OpsAPI Single Sign-on | Anmeldungen, Fehlschläge, Freigaben privilegierter Agentenzugriffe | ECS-JSON über Syslog | opsapi.sso |
| Linux-Hosts | Ausführungen, Rechteänderungen, Dateiüberwachung (auditd) | Agent liest /var/log/audit/audit.log mit | auditd.log |
| DCGM und node-exporter | GPU-Auslastung ohne Job, Egress-Volumen | Bestehende Betriebspipeline (Prometheus oder Mimir) | Metriken |
Die Feldliste von wafsec stammt aus unserem Artikel zur WAF Engine v2. Für wslvault und OpsAPI konfigurieren wir die Produkte so, dass sie JSON mit ECS-Feldnamen protokollieren (event.action, event.outcome, user.id, source.ip), was die Zuordnung am Gateway trivial hält; die in den Regeln dieses Artikels verwendeten Aktionsnamen (secret.read, login, agent.approval.granted) sind unsere Konvention, passen Sie sie also an das an, was Ihre Installation ausgibt.
5. Normalisierung: OCSF, ECS und OpenTelemetry Semantic Conventions
In dieser Pipeline treffen drei Schemata aufeinander. OpenShell spricht OCSF; die Regeln, Timelines und vorgefertigten Inhalte von Elastic Security erwarten ECS; und OpenTelemetry hat eigene Semantic Conventions für Ressourcen und Attribute. Wir lassen den ursprünglichen Record für die Forensik unverändert und fügen ECS-Felder daneben ein. Das Gateway übernimmt die Zuordnung, die jedes Backend benötigt (damit Dynatrace dieselben Namen sieht wie Elastic), und eine Elasticsearch-Ingest-Pipeline übernimmt die Elastic-spezifische Anreicherung.
| OCSF-Feld (OpenShell) | ECS-Feld | Wo es zugeordnet wird |
|---|---|---|
action (Allowed, Denied) | event.action | Gateway |
status_id (1 Erfolg, 2 Fehlschlag) | event.outcome | Gateway |
status_detail, bzw. finding_info.uid für Findings | event.reason | Ingest-Pipeline |
class_uid | event.category (network, process, authentication, api, configuration, intrusion_detection) | Ingest-Pipeline |
type_uid, severity_id, metadata.uid | event.code, event.severity, event.id | Ingest-Pipeline |
dst_endpoint.domain, .ip, .port | destination.domain, destination.ip, destination.port | Gateway (Domain, Port), Ingest-Pipeline (IP) |
src_endpoint.ip | source.ip | Ingest-Pipeline |
actor.process.name, .pid, .cmd_line | process.executable, process.pid, process.command_line | Gateway, Ingest-Pipeline |
actor.user.uid | user.id | Ingest-Pipeline |
device.container.name, .uid (die Sandbox) | container.name, container.id | Gateway, Ingest-Pipeline |
firewall_rule.name (die zutreffende Policy) | rule.name | Gateway |
metadata.product.name, .version | observer.product, observer.version | Ingest-Pipeline |
time (Epoch-Millisekunden) | @timestamp | Ingest-Pipeline |
| gesamter Record | event.original (nicht indiziert) und ocsf.* (flattened) | Ingest-Pipeline |
Die OpenShell-Dokumentation weist darauf hin, dass die Sandbox-Identität in OCSF-1.8.0-Records von einem Objekt container auf oberster Ebene nach device.container verschoben wurde, und fordert SIEM-Parser auf, dem zu folgen. Unsere Zuordnung liest nur den neuen Ort; pinnen Sie daher die OpenShell-Version in Ihren Change Records und testen Sie die Zuordnung bei einem Upgrade erneut.
6. Collector-Konfiguration
Die gesamte folgende Konfiguration verwendet Komponentennamen aus otelcol-contrib 0.165.0, das Namen in snake_case eingeführt hat (file_log, tcp_log, otlp_grpc, otlp_http, prometheus_remote_write, cumulative_to_delta, delta_to_cumulative, resource_detection). Die älteren Namen in unseren UFM- und Minerva-Artikeln funktionieren weiterhin als veraltete Aliase und protokollieren beim Start eine Warnung. Secrets sind Umgebungsplatzhalter.
Node-Agent: Sicherheits-Receiver
Diese Pipelines werden dem bestehenden Node-Agenten hinzugefügt. Auf einem Node, der weder Control Plane noch CI-Runner ist, bleiben die Receiver für nicht vorhandene Dateien einfach untätig.
# /etc/otelcol-contrib/security-agent.yaml (added to the node agent)
extensions:
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
receivers:
# Linux audit (auditd): one record per line, key=value pairs
file_log/auditd:
include: [/var/log/audit/audit.log]
start_at: end
storage: file_storage
operators:
- type: regex_parser
regex: '^type=(?P<record_type>\S+) msg=audit\((?P<epoch>[\d.]+):(?P<sequence>\d+)\): ?(?P<kv>.*)$'
parse_to: attributes["auditd.log"]
- type: key_value_parser
parse_from: attributes["auditd.log"]["kv"]
parse_to: attributes["auditd.data"]
on_error: send
- type: remove
field: attributes["auditd.log"]["kv"]
- type: add
field: attributes["data_stream.dataset"]
value: auditd.log
# Kubernetes API server audit log (control-plane nodes only)
file_log/k8s-audit:
include: [/var/log/kubernetes/audit/audit.log]
start_at: end
storage: file_storage
operators:
- type: json_parser
parse_to: attributes["kubernetes.audit"]
- type: add
field: attributes["data_stream.dataset"]
value: kubernetes.audit_logs
# garak eval records from CI runners (one report per run)
file_log/garak:
include: [/var/lib/ci/garak/*.report.jsonl]
start_at: beginning
storage: file_storage
operators:
- type: json_parser
parse_to: attributes["garak"]
- type: filter
expr: 'attributes.garak.entry_type != "eval"'
- type: add
field: attributes["data_stream.dataset"]
value: garak.eval
- type: add
field: attributes["ci.pipeline"]
value: EXPR(env("CI_PIPELINE_NAME"))
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resource_detection:
detectors: [env, system]
batch:
send_batch_size: 2048
timeout: 5s
exporters:
otlp_grpc/security-gateway:
endpoint: otel-security.sec.internal:4317
tls:
ca_file: /etc/otelcol-contrib/ca.pem
sending_queue:
enabled: true
storage: file_storage
service:
extensions: [file_storage]
pipelines:
logs/security:
receivers: [file_log/auditd, file_log/k8s-audit, file_log/garak]
processors: [memory_limiter, resource_detection, batch]
exporters: [otlp_grpc/security-gateway]
Hinweise:
- Der auditd-Parser trennt den Record-Header von seinen Schlüssel-Wert-Paaren. Hex-codierte Felder wie
proctitledekodiert er nicht; falls Sie sie benötigen, dekodieren Sie sie in der Ingest-Pipeline. Aktivieren Sie die gewünschten Audit-Regeln (zum Beispielexecveauf GPU-Nodes) in Ihrer auditd-Konfiguration; der Collector liefert nur, was auditd schreibt. - Der Kubernetes-Audit-Receiver sieht nur, was die Audit-Policy Ihres API-Servers aufzeichnet. Um privilegierte Pods zu erkennen, benötigen Sie mindestens die Stufe
RequestResponseoder die StufeRequestfür Create, Update und Patch aufpods, damit der Request-Body im Log steht. - Der garak-Receiver behält nur Evaluierungs-Records und versieht sie mit der CI-Pipeline als Label, sodass eine Regression auf die Änderung verweist, die sie verursacht hat.
Security-Gateway
# /etc/otelcol-contrib/security.yaml (security gateway pair)
extensions:
health_check:
endpoint: 0.0.0.0:13133
file_storage:
directory: /var/lib/otelcol/queue
create_directory: true
basicauth/es:
client_auth:
username: ${env:ES_USER}
password: ${env:ES_PASSWORD}
receivers:
# Agents, OpenShell gateway and supervisors (OCSF over OTLP),
# NeMo Guardrails spans and CI jobs all arrive here
otlp:
protocols:
grpc:
endpoint: 0.0.0.0:4317
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
http:
endpoint: 0.0.0.0:4318
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
# DOCA Argus telemetry (JSON lines over TCP from each BlueField)
tcp_log/argus:
listen_address: 0.0.0.0:5170
operators:
- type: json_parser
parse_to: attributes["argus"]
- type: add
field: attributes["data_stream.dataset"]
value: doca.argus
# wslproxy WAF decisions (wafsec), wslvault and OpsAPI SSO audit, appliance syslog
syslog/security:
tcp:
listen_address: 0.0.0.0:6514
tls:
cert_file: /etc/otelcol-contrib/tls/gateway.crt
key_file: /etc/otelcol-contrib/tls/gateway.key
protocol: rfc5424
# Security-relevant metrics that live off-node: OpenShell gateway, wslproxy
prometheus/security:
config:
scrape_configs:
- job_name: openshell-gateway
scrape_interval: 30s
kubernetes_sd_configs:
- role: pod
namespaces:
names: [openshell]
relabel_configs:
- source_labels: [__meta_kubernetes_pod_container_port_name]
regex: metrics
action: keep
- source_labels: [__meta_kubernetes_pod_name]
target_label: pod
- job_name: wslproxy
scrape_interval: 30s
file_sd_configs:
- files: ["/etc/otelcol-contrib/targets/wslproxy-*.yaml"]
metric_relabel_configs:
- source_labels: [__name__]
regex: "waf_(blocked|monitored|inspections|latency|errors).*"
action: keep
processors:
memory_limiter:
check_interval: 1s
limit_percentage: 75
spike_limit_percentage: 20
resource/security:
attributes:
- key: site
value: ${env:WS_SITE}
action: upsert
- key: cluster
value: ${env:WS_CLUSTER}
action: upsert
# OpenShell OCSF records: body is the OCSF event as a JSON string.
# Lift the fields every backend needs into attributes with ECS names,
# tag the dataset and ingest pipeline, and use the OCSF event id as the
# Elasticsearch document id so at-least-once retries do not duplicate.
transform/ocsf:
error_mode: ignore
log_statements:
- conditions:
- scope.name == "openshell.ocsf"
statements:
- set(log.cache["ocsf"], ParseJSON(log.body)) where IsString(log.body)
- set(log.attributes["event.action"], log.cache["ocsf"]["action"])
- set(log.attributes["event.outcome"], "failure") where log.cache["ocsf"]["status_id"] == 2
- set(log.attributes["event.outcome"], "success") where log.cache["ocsf"]["status_id"] == 1
- set(log.attributes["destination.domain"], log.cache["ocsf"]["dst_endpoint"]["domain"])
- set(log.attributes["destination.port"], Int(log.cache["ocsf"]["dst_endpoint"]["port"])) where log.cache["ocsf"]["dst_endpoint"]["port"] != nil
- set(log.attributes["process.executable"], log.cache["ocsf"]["actor"]["process"]["name"])
- set(log.attributes["container.name"], log.cache["ocsf"]["device"]["container"]["name"])
- set(log.attributes["rule.name"], log.cache["ocsf"]["firewall_rule"]["name"])
- set(log.attributes["ocsf.status_detail"], log.cache["ocsf"]["status_detail"])
- set(log.attributes["data_stream.dataset"], "openshell.ocsf")
- set(log.attributes["elasticsearch.ingest_pipeline"], "ws-ocsf-to-ecs")
- set(log.attributes["elasticsearch.document_id"], log.attributes["ocsf.metadata.uid"])
# Syslog from our own appliances: wslproxy's wafsec JSON is mapped field by
# field; wslvault, OpsAPI SSO and the attestation wrapper already log
# ECS-named JSON, so it is merged as it is and only the dataset is tagged.
transform/appliances:
error_mode: ignore
log_statements:
- conditions:
- log.attributes["appname"] == "wafsec"
statements:
- set(log.attributes["wafsec"], ParseJSON(log.attributes["message"]))
- set(log.attributes["data_stream.dataset"], "wslproxy.waf")
- set(log.attributes["event.action"], log.attributes["wafsec"]["action"])
- set(log.attributes["source.ip"], log.attributes["wafsec"]["client_ip"])
- set(log.attributes["rule.id"], log.attributes["wafsec"]["signature_id"])
- set(log.attributes["url.path"], log.attributes["wafsec"]["uri"])
- delete_key(log.attributes, "message")
- conditions:
- log.attributes["appname"] == "wslvault" or log.attributes["appname"] == "opsapi-sso" or log.attributes["appname"] == "cc-attest"
statements:
- merge_maps(log.attributes, ParseJSON(log.attributes["message"]), "upsert")
- set(log.attributes["data_stream.dataset"], "wslvault.audit") where log.attributes["appname"] == "wslvault"
- set(log.attributes["data_stream.dataset"], "opsapi.sso") where log.attributes["appname"] == "opsapi-sso"
- set(log.attributes["data_stream.dataset"], "cc.attestation") where log.attributes["appname"] == "cc-attest"
- delete_key(log.attributes, "message")
# Never let credentials or prompt text reach any backend
transform/redact:
error_mode: ignore
log_statements:
- statements:
- delete_key(log.attributes, "http.request.header.authorization")
- delete_key(log.attributes, "http.request.header.cookie")
- delete_key(log.attributes, "gen_ai.prompt")
- delete_key(log.attributes, "gen_ai.completion")
- replace_pattern(log.body, "(?i)(bearer|api-token)\\s+[A-Za-z0-9._~+/=-]{16,}", "$$1 [REDACTED]") where IsString(log.body)
trace_statements:
- statements:
- delete_key(span.attributes, "gen_ai.prompt")
- delete_key(span.attributes, "gen_ai.completion")
# Dynatrace wants delta sums; Prometheus wants cumulative ones
cumulative_to_delta:
max_staleness: 25h
delta_to_cumulative:
max_stale: 10m
batch:
send_batch_size: 4096
timeout: 2s
connectors:
# Everything goes to the SIEM; Medium and above is copied to Dynatrace
routing/severity:
default_pipelines: [logs/elastic]
table:
- condition: log.severity_number >= SEVERITY_NUMBER_WARN2
action: copy
pipelines: [logs/dynatrace]
# Turn security events into low-cardinality counters for Prometheus
count/security:
logs:
ws.security.events:
description: Security events by source, outcome and action
attributes:
- key: data_stream.dataset
default_value: unknown
- key: event.outcome
default_value: unknown
- key: event.action
default_value: unknown
exporters:
elasticsearch/siem:
endpoints:
- https://es-sec-1.sec.internal:9200
- https://es-sec-2.sec.internal:9200
mapping:
allowed_modes: [ecs]
logs_dynamic_id:
enabled: true
logs_dynamic_pipeline:
enabled: true
auth:
authenticator: basicauth/es
tls:
ca_file: /etc/otelcol-contrib/es-ca.pem
sending_queue:
enabled: true
storage: file_storage
otlp_http/dynatrace:
endpoint: https://${env:DT_ENV_ID}.live.dynatrace.com/api/v2/otlp
headers:
Authorization: "Bearer ${env:DT_PLATFORM_TOKEN}"
sending_queue:
enabled: true
storage: file_storage
prometheus_remote_write/sec:
endpoint: https://prometheus.sec.internal/api/v1/write
# only the fleet labels; never sandbox or pod ids
resource_constant_labels:
included: [site, cluster]
tls:
ca_file: /etc/otelcol-contrib/ca.pem
service:
extensions: [health_check, file_storage, basicauth/es]
pipelines:
logs/in:
receivers: [otlp, tcp_log/argus, syslog/security]
processors: [memory_limiter, resource/security, transform/ocsf, transform/appliances, transform/redact]
exporters: [routing/severity, count/security]
logs/elastic:
receivers: [routing/severity]
processors: []
exporters: [elasticsearch/siem]
logs/dynatrace:
receivers: [routing/severity]
processors: [batch]
exporters: [otlp_http/dynatrace]
metrics/scraped:
receivers: [otlp, prometheus/security]
processors: [memory_limiter, resource/security, batch]
exporters: [prometheus_remote_write/sec]
metrics/dynatrace:
receivers: [otlp, prometheus/security]
processors: [memory_limiter, resource/security, cumulative_to_delta, batch]
exporters: [otlp_http/dynatrace]
metrics/counts:
receivers: [count/security]
processors: [delta_to_cumulative, batch]
exporters: [prometheus_remote_write/sec]
metrics/counts-dt:
receivers: [count/security]
processors: [batch]
exporters: [otlp_http/dynatrace]
traces:
receivers: [otlp]
processors: [memory_limiter, resource/security, transform/redact, batch]
exporters: [otlp_http/dynatrace]
telemetry:
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
Hinweise zu den Entscheidungen:
- Dokument-ID aus der OCSF-Ereignis-ID. OpenShell liefert mindestens einmal. Wird
elasticsearch.document_idausocsf.metadata.uidgesetzt und istlogs_dynamic_idaktiviert, bleibt ein wiederholt gesendeter Record wirkungslos: In unserem Ende-zu-Ende-Test wies Elasticsearch die zweite Kopie mit einem Versionskonflikt ab, und es wurde nur ein Dokument gespeichert. - Dynamische Ingest-Pipeline. Das Attribut
elasticsearch.ingest_pipelinewählt die OCSF-Pipeline nur für OpenShell-Records aus; andere Datensätze verwenden die Standards des Data Streams. - Routing nach Schwere. Der Routing-Connector kopiert Records ab OTel-Schwere
WARN2(OpenShell bildet OCSF Medium aufWARN2und High aufERRORab) an Dynatrace, während jeder Record an Elasticsearch geht. So bleiben Volumen und Kosten bei Dynatrace verhältnismäßig. - Ereignisse zu Metriken zählen. Der Count-Connector gibt
ws.security.eventsmit nur drei Attributen aus: Datensatz, Ergebnis und Aktion. Er erzeugt Delta-Summen, die Dynatrace benötigt und Prometheus Remote Write nicht; der Prometheus-Pfad konvertiert daher mitdelta_to_cumulative. In unserem Test erhielt Prometheusws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied", event_outcome="failure"}mit den Labelssiteundcluster. - Kumulativ zu Delta für Dynatrace. Die OTLP-Ingestion von Dynatrace erfordert Delta-Temporalität für Metriken; gescrapte Metriken laufen daher nur auf dem Dynatrace-Pfad durch
cumulative_to_delta. - Konstante Labels.
resource_constant_labelsmacht nursiteundclusterzu Prometheus-Labels. Sandbox-IDs, Pod-Namen und Domains werden nie zu Labels (Abschnitt 14). - Batching. Der Elasticsearch-Exporter bildet intern Batches, daher hat seine Pipeline keinen
batch-Prozessor; andernfalls warnt der Collector vor doppeltem Batching.
Seite von OpenShell
Richten Sie auf dem OpenShell-Gateway den OCSF-Export auf die Security-Gateways. NVIDIAs Beispiel verwendet einen clusterinternen Servicenamen; unserer ist die Adresse des Security-Gateways. Supervisoren verwenden denselben Endpunkt, er muss also aus den Sandboxes erreichbar sein, und sie erhalten die Export-Header des Gateways zusammen mit ihren Start-Credentials statt über die Sandbox-Umgebung.
[openshell.gateway.otlp.ocsf]
enabled = true
endpoint = "https://otel-security.sec.internal:4317"
Halten Sie die Entscheidung über OpenShells eigene anonyme Produkttelemetrie davon getrennt: Sie hat mit diesem Export nichts zu tun und wird über OPENSHELL_TELEMETRY_ENABLED oder den Helm-Wert server.telemetryEnabled gesteuert.
7. Elastic Security als SIEM
Elastic Security hält jedes Sicherheitsereignis vor, führt die Erkennungsregeln aus und ist der Ort, an dem Analysten untersuchen (Timelines) und Arbeit verfolgen (Cases). Wir betreiben es als dedizierten Security-Cluster oder als dedizierten Space mit eigenen Rollen, getrennt von der operativen Logsuche.
Ingest-Pipeline: von OCSF zu ECS
Diese Pipeline wurde in Elasticsearch 9.2.0 geladen und sowohl mit _simulate als auch mit Records geprüft, die über das Gateway eintrafen.
PUT _ingest/pipeline/ws-ocsf-to-ecs
{
"description": "OpenShell OCSF 1.8.0 records to ECS (Workstation)",
"processors": [
{ "json": { "field": "message", "target_field": "ocsf", "if": "ctx.message instanceof String && ctx.message.startsWith('{')" } },
{ "set": { "field": "event.original", "copy_from": "message", "if": "ctx.ocsf != null" } },
{ "remove": { "field": "message", "if": "ctx.ocsf != null" } },
{ "date": { "field": "ocsf.time", "formats": ["UNIX_MS"], "target_field": "@timestamp", "if": "ctx.ocsf?.time != null" } },
{ "set": { "field": "event.module", "value": "openshell" } },
{ "set": { "field": "event.dataset", "value": "openshell.ocsf" } },
{ "set": { "field": "event.kind", "value": "event" } },
{ "set": { "field": "event.kind", "value": "alert", "if": "ctx.ocsf?.class_uid == 2004" } },
{ "set": { "field": "event.code", "value": "{{{ocsf.type_uid}}}", "if": "ctx.ocsf?.type_uid != null" } },
{ "set": { "field": "event.severity", "copy_from": "ocsf.severity_id", "if": "ctx.ocsf?.severity_id != null" } },
{ "set": { "field": "event.id", "copy_from": "ocsf.metadata.uid", "if": "ctx.ocsf?.metadata?.uid != null" } },
{ "set": { "field": "event.reason", "copy_from": "ocsf.status_detail", "if": "ctx.ocsf?.status_detail != null" } },
{ "set": { "field": "event.reason", "copy_from": "ocsf.finding_info.uid", "if": "ctx.ocsf?.finding_info?.uid != null" } },
{ "script": {
"lang": "painless",
"if": "ctx.ocsf?.class_uid != null",
"source": "def m = ['4001': 'network', '4002': 'network', '4007': 'network', '1007': 'process', '3002': 'authentication', '6003': 'api', '5019': 'configuration', '2004': 'intrusion_detection', '6002': 'process']; def c = m.get(String.valueOf(ctx.ocsf.class_uid)); if (c != null) { if (ctx.event == null) { ctx.event = [:]; } ctx.event.category = [c]; }"
} },
{ "set": { "field": "observer.product", "copy_from": "ocsf.metadata.product.name", "if": "ctx.ocsf?.metadata?.product?.name != null" } },
{ "set": { "field": "observer.version", "copy_from": "ocsf.metadata.product.version", "if": "ctx.ocsf?.metadata?.product?.version != null" } },
{ "set": { "field": "source.ip", "copy_from": "ocsf.src_endpoint.ip", "if": "ctx.ocsf?.src_endpoint?.ip != null" } },
{ "set": { "field": "destination.ip", "copy_from": "ocsf.dst_endpoint.ip", "if": "ctx.ocsf?.dst_endpoint?.ip != null" } },
{ "set": { "field": "destination.domain", "copy_from": "ocsf.dst_endpoint.domain", "override": false, "if": "ctx.ocsf?.dst_endpoint?.domain != null" } },
{ "set": { "field": "process.command_line", "copy_from": "ocsf.actor.process.cmd_line", "if": "ctx.ocsf?.actor?.process?.cmd_line != null" } },
{ "set": { "field": "process.pid", "copy_from": "ocsf.actor.process.pid", "if": "ctx.ocsf?.actor?.process?.pid != null" } },
{ "set": { "field": "user.id", "copy_from": "ocsf.actor.user.uid", "if": "ctx.ocsf?.actor?.user?.uid != null" } },
{ "set": { "field": "container.id", "copy_from": "ocsf.device.container.uid", "if": "ctx.ocsf?.device?.container?.uid != null" } },
{ "set": { "field": "container.name", "copy_from": "ocsf.device.container.name", "override": false, "if": "ctx.ocsf?.device?.container?.name != null" } },
{ "set": { "field": "url.full", "copy_from": "ocsf.http_request.url.url_string", "if": "ctx.ocsf?.http_request?.url?.url_string != null", "ignore_failure": true } },
{ "append": { "field": "related.hosts", "value": ["{{{destination.domain}}}"], "allow_duplicates": false, "if": "ctx.destination?.domain != null" } },
{ "append": { "field": "related.ip", "value": ["{{{source.ip}}}"], "allow_duplicates": false, "if": "ctx.source?.ip != null" } }
],
"on_failure": [
{ "set": { "field": "event.kind", "value": "pipeline_error" } },
{ "append": { "field": "error.message", "value": ["{{{_ingest.on_failure_message}}}"] } }
]
}
Index-Template und Aufbewahrung
Das Objekt ocsf wird als flattened gemappt, sodass die vielen optionalen Felder von OCSF keine Mapping-Explosion verursachen können, Analysten aber trotzdem danach filtern können. Der ursprüngliche Record wird gespeichert, aber nicht indiziert. Das Template setzt sich aus Elastics eingebauten logs@mappings, logs@settings und ecs@mappings zusammen.
PUT _ilm/policy/ws-security-13m
{
"policy": {
"phases": {
"hot": { "actions": { "rollover": { "max_age": "1d", "max_primary_shard_size": "50gb" } } },
"warm": { "min_age": "14d", "actions": { "forcemerge": { "max_num_segments": 1 }, "allocate": { "number_of_replicas": 1 } } },
"cold": { "min_age": "90d", "actions": { "set_priority": { "priority": 0 } } },
"delete": { "min_age": "400d", "actions": { "delete": {} } }
}
}
}
PUT _index_template/logs-openshell.ocsf
{
"index_patterns": ["logs-openshell.ocsf-*"],
"data_stream": {},
"priority": 200,
"composed_of": ["logs@mappings", "logs@settings", "ecs@mappings"],
"template": {
"settings": { "index.lifecycle.name": "ws-security-13m" },
"mappings": {
"properties": {
"ocsf": { "type": "flattened" },
"event": { "properties": { "original": { "type": "keyword", "index": false, "doc_values": false } } }
}
}
}
}
Wir erstellen pro Sicherheitsdatensatz ein Template mit derselben Struktur und einer Lifecycle-Policy, die seiner Aufbewahrungsanforderung entspricht (Abschnitt 14). Dreizehn Monate sind ein üblicher Standard für Sicherheitsereignisse, weil sie einen vollen Jahresvergleich plus die Zeit für die Untersuchung eines spät entdeckten Vorfalls abdecken; den tatsächlichen Wert legen Ihre Verantwortlichen für Recht und Compliance fest.
Erkennungsregeln
Vierzehn Regeln, angelegt über die Detection-Engine-API von Kibana (POST /api/detection_engine/rules, API-Version 2023-10-31). Jede wurde erfolgreich gegen Testdaten ausgeführt, und jede Regel außer der Vault-Regel für Zugriffe außerhalb der Geschäftszeiten (deren Testereignis innerhalb der Geschäftszeiten lag) löste ihren erwarteten Alarm aus. Die Tabelle listet alle auf; zwei werden danach vollständig gezeigt.
| Regel | Typ | Schwere |
|---|---|---|
Egress eines KI-Agenten durch OpenShell-Policy verweigertws-ai-001-agent-egress-denied | KQL-Abfrage | medium |
KI-Agent hat eine Domain erreicht, die 14 Tage lang nicht gesehen wurdews-ai-002-agent-new-egress-domain | New Terms (KQL) | low |
KI-Agent hat versucht, eine Link-Local- oder Loopback-Adresse zu erreichenws-ai-003-agent-ssrf-blocked | KQL-Abfrage | high |
OpenShell-Sandbox-Credential außerhalb seiner Grenze verwendetws-ai-004-sandbox-boundary-finding | KQL-Abfrage | critical |
Häufung von OpenShell-Policy-Verweigerungen aus einer Sandboxws-ai-005-policy-denial-spike | Threshold (KQL) | high |
Wiederholte, von NeMo Guardrails blockierte Jailbreak-Versuchews-ai-006-guardrail-jailbreak-attempts | Threshold (KQL) | medium |
garak-Angriffserfolgsrate über 5 % in der CIws-ai-007-garak-regression | ES|QL | high |
DOCA-Argus-Laufzeitalarm auf einem GPU-Hostws-ai-008-doca-argus-alert | KQL-Abfrage | critical |
Anmeldung von außerhalb Großbritanniens, gefolgt von einer Agentenfreigabews-ai-009-sso-anomaly-then-agent-approval | EQL-Sequenz | high |
wslvault-Secret außerhalb von 07:00 bis 19:00 UTC gelesenws-ai-010-vault-read-out-of-hours | ES|QL | medium |
Privilegierter Pod in Kubernetes erstellt oder geändertws-ai-011-k8s-privileged-pod | KQL-Abfrage | high |
Confidential-Computing-Attestierung fehlgeschlagenws-ai-012-attestation-failure | KQL-Abfrage | critical |
wslproxy-WAF blockiert einen Client wiederholtws-ai-013-waf-block-burst | Threshold (KQL) | medium |
Programm aus /tmp oder /dev/shm auf einem GPU-Node ausgeführtws-ai-014-exec-from-tmp | KQL-Abfrage | high |
Die Abfragen, wie geladen:
# ws-ai-001-agent-egress-denied (KQL query)
data_stream.dataset:"openshell.ocsf" and event.category:"network" and event.action:"Denied"
# ws-ai-002-agent-new-egress-domain (New terms (KQL))
# new terms: destination.domain since now-14d
data_stream.dataset:"openshell.ocsf" and event.category:"network" and event.action:"Allowed" and destination.domain:*
# ws-ai-003-agent-ssrf-blocked (KQL query)
data_stream.dataset:"openshell.ocsf" and event.reason:"resolves to always-blocked address"
# ws-ai-004-sandbox-boundary-finding (KQL query)
data_stream.dataset:"openshell.ocsf" and event.kind:"alert" and event.reason:"sandbox-authorization-boundary"
# ws-ai-005-policy-denial-spike (Threshold (KQL))
# threshold: 25 or more per container.name
data_stream.dataset:"openshell.ocsf" and event.action:"Denied"
# ws-ai-006-guardrail-jailbreak-attempts (Threshold (KQL))
# threshold: 5 or more per user.id
data_stream.dataset:"nemo.guardrails" and event.action:"input_rail_blocked" and rule.name:"check jailbreak"
# ws-ai-007-garak-regression (ES|QL)
FROM logs-garak.eval-* METADATA _id, _index, _version
| WHERE garak.entry_type == "eval" AND garak.total_evaluated > 0
| EVAL attack_success_rate = garak.fails / garak.total_evaluated
| WHERE attack_success_rate > 0.05
| KEEP _id, _index, _version, @timestamp, ci.pipeline, garak.probe, garak.detector, garak.fails, garak.total_evaluated, attack_success_rate
# ws-ai-008-doca-argus-alert (KQL query)
data_stream.dataset:"doca.argus" and argus.message_type:"ALERT" and argus.severity:("HIGH" or "CRITICAL")
# ws-ai-009-sso-anomaly-then-agent-approval (EQL sequence)
sequence by user.id with maxspan=30m
[authentication where data_stream.dataset == "opsapi.sso" and event.outcome == "success" and source.geo.country_iso_code != "GB"]
[any where data_stream.dataset == "opsapi.sso" and event.action == "agent.approval.granted"]
# ws-ai-010-vault-read-out-of-hours (ES|QL)
FROM logs-wslvault.audit-* METADATA _id, _index, _version
| WHERE event.action == "secret.read" AND event.outcome == "success"
| EVAL hour = DATE_EXTRACT("hour_of_day", @timestamp)
| WHERE hour < 7 OR hour >= 19
| KEEP _id, _index, _version, @timestamp, user.id, wslvault.path, source.ip, hour
# ws-ai-011-k8s-privileged-pod (KQL query)
data_stream.dataset:"kubernetes.audit_logs" and kubernetes.audit.objectRef.resource:"pods" and kubernetes.audit.verb:("create" or "update" or "patch") and kubernetes.audit.requestObject.spec.containers.securityContext.privileged:true
# ws-ai-012-attestation-failure (KQL query)
data_stream.dataset:"cc.attestation" and event.outcome:"failure"
# ws-ai-013-waf-block-burst (Threshold (KQL))
# threshold: 50 or more per source.ip
data_stream.dataset:"wslproxy.waf" and event.action:"block"
# ws-ai-014-exec-from-tmp (KQL query)
data_stream.dataset:"auditd.log" and auditd.log.record_type:"SYSCALL" and auditd.data.syscall:"59" and auditd.data.exe:(/tmp/* or /dev/shm/*)
Eine Abfrageregel mit Alarmunterdrückung und ATT&CK-Zuordnung. Die Unterdrückung fasst wiederholte Verweigerungen für dieselbe Sandbox und dasselbe Ziel zu einem Alarm pro Stunde zusammen; dadurch bleibt diese Regel auf einem stark ausgelasteten Cluster nutzbar:
{
"rule_id": "ws-ai-001-agent-egress-denied",
"name": "AI agent egress denied by OpenShell policy",
"description": "An agent inside an OpenShell sandbox tried to reach a destination its policy does not allow. Often the first sign of indirect prompt injection or goal hijacking: the agent has been told to send data somewhere new.",
"type": "query",
"language": "kuery",
"index": [
"logs-openshell.ocsf-*"
],
"query": "data_stream.dataset:\"openshell.ocsf\" and event.category:\"network\" and event.action:\"Denied\"",
"severity": "medium",
"risk_score": 47,
"interval": "5m",
"from": "now-6m",
"alert_suppression": {
"group_by": [
"container.name",
"destination.domain"
],
"duration": {
"value": 1,
"unit": "h"
},
"missing_fields_strategy": "suppress"
},
"tags": [
"Workstation",
"Domain: AI agents",
"Data Source: OpenShell"
],
"threat": [
{
"framework": "MITRE ATT&CK",
"tactic": {
"id": "TA0010",
"name": "Exfiltration",
"reference": "https://attack.mitre.org/tactics/TA0010/"
},
"technique": [
{
"id": "T1567",
"name": "Exfiltration Over Web Service",
"reference": "https://attack.mitre.org/techniques/T1567/"
}
]
}
]
}
Eine EQL-Sequenz, die zwei Quellen korreliert, die ein Analyst sonst von Hand zusammenführen müsste: eine Anmeldung von außerhalb Großbritanniens, auf die innerhalb von 30 Minuten die Freigabe eines privilegierten Agentenzugriffs durch denselben Nutzer folgt:
{
"rule_id": "ws-ai-009-sso-anomaly-then-agent-approval",
"name": "Sign-in from outside the UK followed by an agent approval",
"description": "An OpsAPI SSO sign-in from outside the UK, then the same user approving privileged agent access within 30 minutes.",
"type": "eql",
"language": "eql",
"index": [
"logs-opsapi.sso-*"
],
"query": "sequence by user.id with maxspan=30m\n [authentication where data_stream.dataset == \"opsapi.sso\" and event.outcome == \"success\" and source.geo.country_iso_code != \"GB\"]\n [any where data_stream.dataset == \"opsapi.sso\" and event.action == \"agent.approval.granted\"]",
"severity": "high",
"risk_score": 73,
"interval": "5m",
"from": "now-35m",
"tags": [
"Workstation",
"Domain: Identity",
"Data Source: OpsAPI"
]
}
Drei praktische Punkte zu Regeln:
- ES|QL-Regeln benötigen Metadaten zur Deduplizierung. Nicht aggregierende ES|QL-Regeln sollten
METADATA _id, _index, _versionauswählen und diese Felder behalten, wie es unsere tun, damit die Engine doppelte Alarme vermeiden kann. - Nutzen Sie auch die vorgefertigten Regeln von Elastic. Elastic liefert Hunderte vorgefertigter Regeln für Linux, Kubernetes, Cloud und Identität. Unsere schließen die KI-spezifischen Lücken. Wo eine vorgefertigte Regel dasselbe Gebiet mit einer anderen Datenquelle abdeckt (etwa Elastics eigene Kubernetes-Audit-Integration), verwenden Sie die eine oder die andere, nicht beide.
- Regeln sind Code. Wir halten sie in Git, laden sie in der CI und testen jede mit einem gezielt erstellten Ereignis, genau wie bei der Validierung für diesen Artikel. Eine Regel ohne Test ist eine Vermutung.
Timelines und Cases
Jeder Alarm öffnet sich in einer Timeline. Für Agentenvorfälle speichern wir ein Timeline-Template, gefiltert auf container.name (die Sandbox), das die OpenShell-Ereignisse der Sandbox, die Guardrail-Ereignisse und garak-Ergebnisse für dieselbe Anwendung sowie Argus-Alarme für den Host, auf dem sie lief, zusammenführt, sodass ein Analyst die letzten Aktionen des Agenten in der richtigen Reihenfolge sieht. Cases sammeln Alarme, Timelines, Notizen und Reaktionsmaßnahmen; wir verbinden sie über die Case-Connectoren von Elastic mit ServiceNow, damit Ticket und Case synchron bleiben, und der Response-Dienst (Abschnitt 12) schreibt jede automatisierte Maßnahme als Kommentar in den Case zurück.
8. Dynatrace
Viele Unternehmen setzen Dynatrace für Anwendungs- und Infrastruktur-Monitoring ein. Werden ihm die Sicherheitssignale gesendet, die für Service-Verantwortliche relevant sind, erscheint ein verweigerter Egress oder eine Guardrail-Spitze neben dem betroffenen Dienst, und Davis, die KI-Engine von Dynatrace, kann dies mit Änderungen im Verhalten dieses Dienstes in Beziehung setzen.
- Endpunkt. Laut der OTLP-API-Dokumentation von Dynatrace lautet die Basis-URL für SaaS
https://{your-environment-id}.live.dynatrace.com/api/v2/otlp(oder eine ActiveGate-Adresse), und der Exporter hängt/v1/traces,/v1/metricsund/v1/logsan. Die eigenen Metriken unseres Test-Collectors bestätigten, dass er an/api/v2/otlp/v1/logssendete. - Protokoll. OTLP über HTTP ausschließlich mit binärem Protobuf: kein gRPC und kein JSON. Daher
otlp_httpim Gateway. - Authentifizierung. Ein Dynatrace-Plattform-Token in einem
Authorization: Bearer-Header mit den Scopesopenpipeline:logs:ingest,openpipeline:metrics:ingestundopenpipeline:traces:ingest. Ältere Umgebungen mit klassischen Access Tokens sollten der Dynatrace-Dokumentation für ihren Token-Typ folgen. - Metrik-Temporalität. Nur Delta, wie oben erwähnt.
Was wir senden: OpenShell- und andere Ereignisse ab Schwere Medium, die ws.security.events-Zähler, die gescrapten OpenShell- und WAF-Metriken sowie Guardrail-Traces (mit deaktivierter Inhaltserfassung). Was wir in Dynatrace tun, gemäß dessen Dokumentation und nicht über eine hier erfundene API: Anomalieerkennung auf den Sicherheitszählern einrichten, damit Davis ihr normales Niveau pro Cluster lernt und bei einer anhaltenden Veränderung ein Problem meldet; die Sicherheitsereignisse in die Dashboards und Notebooks aufnehmen, die Service-Verantwortliche bereits nutzen; und, sofern die Dynatrace-Lizenz des Kunden dessen Sicherheitsfunktionen umfasst, die Records hoher Schwere über OpenPipeline in den Security-Event-Speicher von Dynatrace leiten, damit sie zusammen mit Schwachstellenbefunden analysiert werden können. OpenPipeline-Routing-Regeln haben wir für diesen Artikel nicht in einem echten Tenant verifiziert; daher beschreiben wir diesen Schritt ohne Konfiguration.
Dynatrace ist eine Zweitmeinung und eine Sicht für Service-Verantwortliche, kein zweites SIEM. Erkennung, Untersuchung und Cases bleiben in Elastic Security, sodass es genau einen Ort gibt, an dem ein Vorfall verantwortet wird.
9. Prometheus und Alertmanager
Prometheus ist der schnellste und günstigste Ort, um auf Zahlen zu alarmieren. Drei Sicherheitsanwendungsfälle sind von Natur aus numerisch, und die Daten für zwei davon (GPU-Auslastung aus DCGM und Netzwerk-Bytes aus node-exporter) liegen bereits aus dem UFM-Design im Speicher für Betriebsmetriken. Der dritte nutzt die Ereigniszähler, die das Security-Gateway erzeugt. Die zweite Regelgruppe überwacht die Sicherheitspipeline selbst.
# /etc/prometheus/rules/ai-security.yml
groups:
- name: ai-security-signals
rules:
# GPU busy with no Kubernetes pod and no Slurm job attached: possible cryptojacking.
# Needs dcgm-exporter's pod mapping (Kubernetes) or HPC job mapping (Slurm) switched on.
- alert: GpuBusyWithoutScheduledWork
expr: |
max by (site, cluster, Hostname, gpu) (ws:gpu_util:ratio{pod="", hpc_job=""}) > 0.3
for: 15m
labels:
severity: high
team: soc
use_case: cryptojacking
annotations:
summary: "GPU {{ $labels.gpu }} on {{ $labels.Hostname }} busy with no scheduled job"
description: "Utilisation {{ $value | humanizePercentage }} for 15 minutes with no pod or Slurm job label. Check for miners and unscheduled processes."
# Egress from inference and storage nodes far above the same hour last week:
# model weights or datasets leaving.
- alert: UnusualEgressFromModelNodes
expr: |
(
sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h]))
> 3 * sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h] offset 7d))
)
and
sum by (site, cluster, instance) (increase(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[1h])) > 50e9
for: 10m
labels:
severity: high
team: soc
use_case: exfiltration
annotations:
summary: "{{ $labels.instance }} sent {{ $value | humanize1024 }}B in the last hour, over 3x last week"
# OpenShell denials across the cluster, from the gateway's count connector
- alert: AgentPolicyDenialSurge
expr: |
sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[10m]))
> 3 * sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[1d] offset 1d))
and
sum by (site, cluster) (rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[10m])) > 0.2
for: 10m
labels:
severity: medium
team: soc
use_case: agent-misuse
annotations:
summary: "OpenShell denials in {{ $labels.cluster }} at 3x yesterday's rate"
- name: ai-security-pipeline-health
rules:
# Losing security telemetry is itself a security event
- alert: OpenShellOcsfExportDropping
expr: sum by (namespace, pod) (increase(openshell_ocsf_otlp_dropped_total[10m])) > 0
labels:
severity: high
team: soc
annotations:
summary: "OpenShell gateway {{ $labels.pod }} dropped OCSF audit records"
- alert: OpenShellInterceptorFailOpen
expr: sum by (namespace, pod) (increase(openshell_gateway_interceptor_fail_open_total[10m])) > 0
labels:
severity: high
team: soc
annotations:
summary: "OpenShell interceptor failed open on {{ $labels.pod }}"
- alert: WafFailingOpen
expr: sum by (host) (rate(waf_errors[5m])) > 0
for: 10m
labels:
severity: medium
team: platform
annotations:
summary: "wslproxy WAF on {{ $labels.host }} is erroring and therefore allowing requests"
- alert: SiemExportFailing
expr: |
sum by (instance, exporter) (rate({__name__=~"otelcol_exporter_send_failed_log_records(_total)?", exporter="elasticsearch/siem"}[5m])) > 0
for: 10m
labels:
severity: high
team: soc
annotations:
summary: "Security gateway {{ $labels.instance }} cannot write to the SIEM"
- alert: SecurityGatewayRedundancyLost
expr: count by (site) (up{job="otel-security-gateway"} == 1) < 2
for: 5m
labels:
severity: high
team: soc
annotations:
summary: "Only one security gateway left at {{ $labels.site }}"
Hinweise:
ws:gpu_util:ratioist die Recording Rule aus dem UFM-Artikel, die die alten und neuen Metriknamen von dcgm-exporter überbrückt. Die Cryptojacking-Regel setzt voraus, dass dcgm-exporter genutzten GPUspod(Kubernetes) oderhpc_job(Slurm) zuordnet. Ist die Job-Zuordnung nicht eingeschaltet, trifft die Regel auf jede ausgelastete GPU zu; prüfen Sie das also zuerst.node_roleist das Label, das der UFM-Agent ausWS_NODE_ROLEsetzt; verwenden Sie das Rollen-Label, das Ihre Flotte hat.- Die eigenen Metriknamen des Collectors haben im getesteten Build 0.165.0 ihr Suffix
_totalverloren (otelcol_exporter_send_failed_log_records);SiemExportFailingtrifft daher auf beide Schreibweisen zu. - Regeln, die mit der Vorwoche oder dem Vortag vergleichen, benötigen so viel Historie, bevor sie aussagekräftig sind. Betreiben Sie sie in den ersten zwei Wochen über eine Route ohne Paging.
Unit-Tests für die beiden Regeln, die am wahrscheinlichsten bearbeitet werden, ausgeführt mit promtool test rules:
rule_files:
- security-rules.yml
evaluation_interval: 1m
tests:
- interval: 1m
input_series:
# GPU 0 busy, no job: should fire. GPU 1 busy inside a pod: must not.
- series: 'ws:gpu_util:ratio{site="lon2",cluster="ai-prod-1",Hostname="gpu-r07-n03",gpu="0"}'
values: '0.95x30'
- series: 'ws:gpu_util:ratio{site="lon2",cluster="ai-prod-1",Hostname="gpu-r07-n03",gpu="1",pod="train-7f9",namespace="research"}'
values: '0.95x30'
alert_rule_test:
- eval_time: 20m
alertname: GpuBusyWithoutScheduledWork
exp_alerts:
- exp_labels:
severity: high
team: soc
use_case: cryptojacking
site: lon2
cluster: ai-prod-1
Hostname: gpu-r07-n03
gpu: "0"
exp_annotations:
summary: "GPU 0 on gpu-r07-n03 busy with no scheduled job"
description: "Utilisation 95% for 15 minutes with no pod or Slurm job label. Check for miners and unscheduled processes."
- interval: 1m
input_series:
- series: 'openshell_ocsf_otlp_dropped_total{namespace="openshell",pod="openshell-0",reason="queue_capacity"}'
values: '0 0 0 5 9 9 9 9 9 9 9 9'
alert_rule_test:
- eval_time: 8m
alertname: OpenShellOcsfExportDropping
exp_alerts:
- exp_labels:
severity: high
team: soc
namespace: openshell
pod: openshell-0
exp_annotations:
summary: "OpenShell gateway openshell-0 dropped OCSF audit records"
Alertmanager sendet Sicherheitsalarme der Stufen high und critical an PagerDuty und an den Response-Dienst, alles andere an Tickets. Secrets stammen aus Dateien, niemals inline:
# /etc/alertmanager/alertmanager.yml (security routes only)
route:
receiver: platform-tickets
group_by: [alertname, site, cluster]
group_wait: 30s
group_interval: 5m
repeat_interval: 4h
routes:
- matchers: ['team="soc"', 'severity=~"high|critical"']
receiver: soc-page-and-respond
continue: true
- matchers: ['team="soc"']
receiver: soc-tickets
inhibit_rules:
# If the whole security gateway tier is down, do not also page for every export failure
- source_matchers: ['alertname="SecurityGatewayRedundancyLost"']
target_matchers: ['alertname="SiemExportFailing"']
equal: [site]
receivers:
- name: soc-page-and-respond
pagerduty_configs:
- routing_key_file: /etc/alertmanager/secrets/pagerduty-soc
severity: '{{ if eq .CommonLabels.severity "critical" }}critical{{ else }}error{{ end }}'
webhook_configs:
# Workstation response service: opens the case and runs the matching playbook
- url_file: /etc/alertmanager/secrets/soar-webhook-url
send_resolved: true
- name: soc-tickets
webhook_configs:
- url_file: /etc/alertmanager/secrets/servicenow-bridge-url
send_resolved: true
- name: platform-tickets
webhook_configs:
- url_file: /etc/alertmanager/secrets/servicenow-bridge-url
Alertmanager hat keinen nativen ServiceNow-Receiver; der Webhook geht an eine kleine Bridge oder an die eigene Event-Integration von ServiceNow, je nachdem, was der Kunde betreibt.
10. Grafana-SOC-Dashboards
Grafana ist der gemeinsame Bildschirm für SOC-, Plattform- und KI-Teams, mit Prometheus und Elasticsearch als Datenquellen (und Loki nur, wenn ein Kunde eine Grafana-native Logsuche für Nicht-Sicherheitslogs wünscht; Sicherheitsereignisse bleiben in Elasticsearch). Ein Übersichts-Dashboard mit Drill-downs:
| Panel | Typ | Abfrage (Datenquelle) |
|---|---|---|
| Sicherheitsereignisse pro Minute nach Datensatz und Ergebnis | Gestapelte Zeitreihe | sum by (data_stream_dataset, event_outcome) (rate(ws_security_events_total[5m])) * 60 (Prometheus) |
| Agentenverweigerungen jetzt im Vergleich zu gestern | Zeitreihe mit Offset | sum(rate(ws_security_events_total{data_stream_dataset="openshell.ocsf", event_action="Denied"}[5m])) und dasselbe mit offset 1d |
| Häufigste verweigerte Ziele | Bar Gauge | Terms-Aggregation auf destination.domain mit event.action:Denied (Elasticsearch) |
| Sandboxes mit den meisten Verweigerungen | Tabelle | Terms auf container.name, letzte Stunde (Elasticsearch) |
| Offene Sicherheitsalarme nach Schwere | Stat | ALERTS{team="soc", alertstate="firing"} gezählt nach severity (Prometheus); Elastic-Alarmzahlen aus dem Index .alerts-security.alerts-* |
| Ausgelastete GPUs ohne Job | Tabelle | ws:gpu_util:ratio{pod="", hpc_job=""} > 0.3 (Prometheus) |
| Egress von Modell- und Storage-Nodes | Zeitreihe | sum by (instance) (rate(node_network_transmit_bytes_total{node_role=~"inference|storage", device!~"lo|ib.*"}[5m])) |
| garak-Angriffserfolgsrate nach Probe | Heatmap | garak.fails / garak.total_evaluated nach garak.probe über CI-Läufe (Elasticsearch) |
| Guardrail-Blockierungen nach Rail | Zeitreihe | Anzahl nach rule.name in nemo.guardrails (Elasticsearch) |
| WAF-Blockierungen und -Fehler | Zeitreihe | sum by (host) (rate(waf_blocked[5m])) und waf_errors |
| Pipeline-Zustand | Stat-Zeile | Gateways aktiv, Exportfehler, OpenShell-OCSF-Verluste, Queue-Füllstand |
Dashboards werden wie die Regeln aus Git bereitgestellt. Wir versehen jedes Panel mit einer Beschreibung, die angibt, wie der Normalzustand aussieht und welche Regel oder welches Runbook gilt, sodass ein neuer Analyst den Bildschirm vom ersten Tag an nutzen kann.
11. Erkennungsanwendungsfälle
Jeder Anwendungsfall verknüpft ein Signal mit einer Regel und einer geplanten Reaktion. Die Reaktionsstufen werden in Abschnitt 12 erläutert: auto bedeutet eine vorab genehmigte, umkehrbare Maßnahme; approve bedeutet einen Klick durch eine namentlich benannte freigebende Person; advise bedeutet, dass der Case eine Empfehlung gibt und Menschen handeln.
| # | Anwendungsfall | Signal | Regel | Reaktion |
|---|---|---|---|---|
| 1 | Agenten-Egress zu einer nicht freigegebenen Domain | OpenShell-Netzwerkverweigerung | ws-ai-001 (Elastic, unterdrückt pro Sandbox und Domain) | Advise: die Quelle prüfen, die der Agent gelesen hat; bei bestätigter Injection Stopp der Sandbox freigeben |
| 2 | Agent erreicht eine nie zuvor gesehene Domain | OpenShell-Netzwerkerlaubnis | ws-ai-002 (New Terms, 14-tägige Historie) | Advise: das Ziel bestätigen; eine zu weit gefasste Policy-Regel verschärfen |
| 3 | Spitze bei Policy-Verweigerungen | Verweigerungen pro Sandbox; clusterweite Rate | ws-ai-005 (Threshold); AgentPolicyDenialSurge (Prometheus) | Auto: die Sandbox stoppen, wenn zusammen mit einem Finding; andernfalls approve |
| 4 | SSRF- oder Metadaten-Zugriffsversuch | Verweigerung mit resolves to always-blocked address | ws-ai-003 | Approve: Sandbox stoppen, alle von ihr gehaltenen Zugangsdaten rotieren |
| 5 | Sandbox-Credential missbraucht | OpenShell-Finding sandbox-authorization-boundary | ws-ai-004 (critical) | Auto: Sandbox stoppen, Pod unter Quarantäne stellen, seine Secrets widerrufen |
| 6 | Jailbreak-Versuche gegen Guardrails | Input-Rail-Blockierungen pro Nutzer | ws-ai-006 | Approve: den Nutzer drosseln oder sperren; die Metadaten der Konversation prüfen |
| 7 | garak-Regression in der CI | Angriffserfolgsrate über 5 % für eine Probe | ws-ai-007 (ES|QL) | Auto: das Pipeline-Gate fehlschlagen lassen; den Modellverantwortlichen informieren |
| 8 | DOCA-Argus-Laufzeitalarm | Argus-ALERT mit HIGH oder CRITICAL | ws-ai-008 | Approve: den Host isolieren (Sentry- oder BlueField-Kontrollen, wo vorhanden; andernfalls Cordon und Network Policy) |
| 9 | GPU-Cryptojacking | GPU ausgelastet ohne Pod oder Slurm-Job; Ausführungen aus /tmp | GpuBusyWithoutScheduledWork (Prometheus); ws-ai-014 (auditd) | Approve: den Node leeren und den Prozess beenden; zuvor Beweise sichern |
| 10 | Exfiltration von Modellgewichten | Stündlicher Egress von Inferenz- oder Storage-Nodes über dem 3-Fachen der Vorwoche | UnusualEgressFromModelNodes (Prometheus) | Approve: Egress für den Node blockieren; Registry- und Vault-Zugriffe prüfen |
| 11 | Auffällige Anmeldung, dann privilegierte Agentenfreigabe | OpsAPI-SSO-Anmeldung außerhalb Großbritanniens, Freigabe innerhalb von 30 Minuten | ws-ai-009 (EQL-Sequenz) | Approve: Freigabe und Sitzungen widerrufen; mit dem Nutzer über einen anderen Kanal verifizieren |
| 12 | Secret außerhalb des vereinbarten Zeitfensters gelesen | wslvault-secret.read außerhalb von 07:00 bis 19:00 UTC | ws-ai-010 (ES|QL) | Advise: mit dem Verantwortlichen klären; bei fehlender Erklärung rotieren |
| 13 | Privilegierter Pod erstellt | Kubernetes-Audit, privilegierter Container in einer Pod-Spezifikation | ws-ai-011 | Approve: den Pod löschen; das RBAC der erstellenden Identität prüfen |
| 14 | Fehlgeschlagene Confidential-Computing-Attestierung | Attestierungsergebnis failure | ws-ai-012 (critical) | Auto: Der Schlüsseldienst hat bereits abgelehnt; alarmieren und den Node aus dem Pool heraushalten |
| 15 | Brute Force am Web-Edge | wslproxy-WAF-Blockierungen pro Client | ws-ai-013 | Auto: Die WAF blockiert bereits; nach Freigabe zur Edge-Sperrliste hinzufügen |
| 16 | Sicherheitstelemetrie verloren | OpenShell-OCSF-Verluste; SIEM-Exportfehler; nur noch ein Gateway übrig | OpenShellOcsfExportDropping, SiemExportFailing, SecurityGatewayRedundancyLost | Das SOC alarmieren: Ein blinder Fleck ist ein Vorfall |
12. Reaktion und SOAR
Erkennung ohne Reaktion ist ein Bericht. Wir verknüpfen Reaktionen mit Alarmen über einen kleinen Response-Dienst (das Webhook-Ziel in Alertmanager und ein Elastic-Connector für Erkennungsregeln), der den Case öffnet oder aktualisiert, die Reaktionsstufe für die Regel prüft und dann entweder ein Playbook ausführt, um Freigabe bittet oder nur eine Empfehlung festhält.
Eindämmungsoptionen, von der engsten zur weitesten
- Die Sandbox stoppen (OpenShell).
openshell sandbox stop <name>stoppt einen Agenten und behält die Sandbox für die Untersuchung;openshell sandbox delete <name>entfernt sie, sobald die Beweise gesichert sind. Um eine einzelne Berechtigung zu entziehen, statt den Agenten zu stoppen:openshell policy update <name> --remove-rule <rule> --wait. Sichern Sie die OCSF-Dateien des Supervisors vor dem Löschen: Unter Kubernetes liegen sie inemptyDirdes Supervisor-Pods und verschwinden mit ihm. - Den Pod unter Quarantäne stellen (Kubernetes). Eine namespaceweite NetworkPolicy isoliert jeden Pod mit einem Quarantäne-Label; das Playbook fügt nur das Label hinzu, was schnell, umkehrbar und leicht zu auditieren ist. Ihr CNI muss NetworkPolicy durchsetzen, wie es auch OpenShells eigene Kubernetes-Empfehlungen verlangen.
- Secrets widerrufen. Widerrufen Sie die Leases der Agentenidentität im Schlüsseldienst, damit alles, was sie exfiltriert hat, nicht mehr funktioniert. Mit wslvault hat der Agent von vornherein nie langlebige Schlüssel besessen, was begrenzt, was überhaupt zu widerrufen ist.
- Den Host isolieren (BlueField und Sentry). Wo Sentry auf BlueField-4 eingesetzt ist, stellt NVIDIAs Design einen Agenten innerhalb von Millisekunden an der DPU unter Quarantäne, unabhängig vom Host. Wo nicht, besteht der Rückfall darin, den Node abzusperren (Cordon) und zu leeren (Drain) und eine Netzwerksperre auf Hostebene anzuwenden. DPU-seitige Aktionen steuern wir nur über die Schnittstellen, die NVIDIA für das eingesetzte Release dokumentiert; undokumentierte skripten wir nicht.
- An die XDR-Plattform eskalieren. Wo DOCA Argus das XDR eines Kunden speist, bleiben die eigenen Reaktionsmaßnahmen dieser Plattform verfügbar, und der Case hält fest, welches Werkzeug gehandelt hat.
# Applied once per namespace; the playbook only adds the label
# kubectl -n agents label pod <pod> ws.security/quarantine=true
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: quarantine
namespace: agents
spec:
podSelector:
matchLabels:
ws.security/quarantine: "true"
policyTypes: [Ingress, Egress]
ingress:
# forensics tooling only
- from:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: soc-forensics
egress:
# DNS stays up so the pod's own logs about failures still make sense
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- protocol: UDP
port: 53
- protocol: TCP
port: 53
Freigabeschritte über OpsAPI Single Sign-on
Jede nicht vorab genehmigte Reaktion durchläuft einen Freigabeschritt in OpsAPI: Die freigebende Person meldet sich per Single Sign-on (und Multi-Faktor-Authentifizierung) an, sieht die Case-Zusammenfassung und genehmigt oder lehnt ab. Die Freigabe ist selbst ein Sicherheitsereignis (opsapi.sso, agent.approval.granted und verwandte Ereignisse); deshalb kann Anwendungsfall 11 auf eine verdächtige Anmeldung mit anschließender Freigabe achten. Wir konfigurieren es so, dass Freigebende ihre eigenen Anträge nicht genehmigen können und Änderungen an der Konfiguration der Sicherheitspipeline selbst zwei Personen erfordern. Dasselbe Muster für Agentenberechtigungen beschreibt unser Artikel zur Sicherheit agentischer KI.
ServiceNow und PagerDuty
Alarme der Stufen high und critical werden über PagerDuty gemeldet; jeder Alarm öffnet oder aktualisiert einen ServiceNow-Incident (oder Security Incident, falls der Kunde dieses Modul betreibt), verknüpft mit dem Elastic-Case. Die Auflösung fließt zurück: Wird der Case geschlossen, wird der Incident gelöst und der PagerDuty-Alarm aufgehoben. Wir vereinbaren die Automatisierungsstufe für jede Regel schriftlich mit dem Kunden, überprüfen sie vierteljährlich und stufen ein Playbook erst dann auf auto hoch, wenn es sich auf der Stufe approve fehlerfrei bewährt hat.
13. Compliance-Zuordnung
Monitoring ist der Weg, um nachzuweisen, dass Kontrollen funktionieren. Die folgende Zuordnung ist eine allgemeine Orientierung, keine Rechtsberatung; die endgültigen Entscheidungen treffen Ihr Datenschutzbeauftragter und Ihre Compliance-Verantwortlichen.
| Regelwerk | Was es allgemein erwartet | Wie dieses Design hilft |
|---|---|---|
| UK GDPR | Angemessene Sicherheit der Verarbeitung (Artikel 32), Integrität und Vertraulichkeit (Artikel 5(1)(f)), Datenschutz durch Technikgestaltung (Artikel 25), Meldung von Verletzungen des Schutzes personenbezogener Daten an das ICO unverzüglich und möglichst binnen 72 Stunden (Artikel 33) sowie Folgenabschätzungen für Verarbeitungen mit hohem Risiko (Artikel 35) | Erkennungen und Timelines liefern die Fakten, die eine Bewertung einer Datenschutzverletzung innerhalb der Frist benötigt; Schwärzung am Gateway und deaktivierte Inhaltserfassung halten personenbezogene Daten in Logs auf ein Minimum; die Aufbewahrung ist pro Datensatz festgelegt und dokumentiert. Sicherheitslogs enthalten selbst personenbezogene Daten (Nutzer-IDs, IP-Adressen); halten Sie daher die Rechtsgrundlage fest (meist berechtigte Interessen), beschränken Sie den Zugriff und beziehen Sie das SIEM in Ihre DSFA ein |
| NIS-artige Pflichten (die britischen NIS Regulations, die EU-Richtlinie NIS2 für Tätigkeiten in der EU und geplante britische Reformen) | Risikomanagementmaßnahmen, Vorfallbehandlung, Betriebskontinuität, Sicherheit der Lieferkette und fristgerechte Meldung erheblicher Vorfälle an die zuständige Behörde; Rechenzentrums- und Cloud-Dienste fallen in einigen Regelwerken in den Anwendungsbereich | Eine dokumentierte Erkennungs- und Reaktionsfähigkeit mit Betriebsnachweisen; Lieferkettensignale (garak in der CI, Image- und Paket-Policy); durch Case-Records gestützte Meldefristen. Ob eine bestimmte Organisation in den Anwendungsbereich fällt, ist eine Rechtsfrage |
| ISO/IEC 27001:2022 Anhang A | 8.15 Protokollierung, 8.16 Überwachungstätigkeiten, 8.17 Uhrensynchronisation, 5.24 bis 5.28 Vorfallmanagement einschließlich Sammlung von Beweismaterial, 8.12 Verhinderung von Datenlecks, 8.8 Handhabung technischer Schwachstellen | Zentrale, geschützte, aufbewahrte Logs (8.15); Regeln und Dashboards mit Verantwortlichen (8.16); per NTP synchronisierte Zeitstempel aus dem Quellereignis (8.17); Cases, Timelines und gesicherte Originale (5.24 bis 5.28); Egress- und Output-Rail-Kontrollen (8.12); garak- und Image-Prüfungen als Schwachstellenmanagement für KI (8.8) |
| Cyber Essentials | Fünf technische Kontrollen: Firewalls, sichere Konfiguration, Management von Sicherheitsupdates, Benutzerzugriffskontrolle und Malware-Schutz | Cyber Essentials ist eine Grundabsicherung und verlangt kein SIEM, aber dieselbe Telemetrie zeigt, dass die Kontrollen funktionieren: WAF und Egress-Policy (Firewalls), Erkennungen privilegierter Pods und Konfigurationsänderungen (sichere Konfiguration), SSO- und Freigabelogs (Zugriffskontrolle) sowie Argus- und auditd-Erkennungen (Malware-Schutz) |
14. Aufbewahrung, Kosten und Kardinalität
Sicherheitstelemetrie wächst unbemerkt, bis die Rechnung kommt. Vier Regeln halten sie planbar:
- Nach Datensatz aufbewahren, nicht global. Ein typischer Ausgangspunkt: OpenShell, SSO, Vault, Kubernetes-Audit, Attestierung und Argus 13 Monate; WAF-Entscheidungen 90 Tage in Elasticsearch, bei Bedarf mit längerer Archivierung; garak-Evaluierungs-Records für die Lebensdauer des Modells; erlaubte (nicht verweigerte) OpenShell-Netzwerkereignisse 30 bis 90 Tage, weil sie vor allem für Baselines nützlich sind. Ältere Daten können in Searchable Snapshots oder Object Storage verschoben werden, sofern die Elastic-Lizenz dies erlaubt.
- Anhand der Ereignisse pro Agent dimensionieren. Als Rechenbeispiel, nicht als Messung: 200 Agenten, die durchschnittlich 2.000 OCSF-Ereignisse pro Stunde mit je etwa 1,2 KB erzeugen, ergeben rund 11,5 GB pro Tag vor Replikaten und Kompression. Erlaubte Netzwerkereignisse dominieren; Verweigerungen und Findings sind ein kleiner Bruchteil. Messen Sie Ihre eigene Rate in einem Pilotprojekt, bevor Sie dimensionieren.
- Metriken bleiben bei geringer Kardinalität. Der Ereigniszähler hat drei Labels mit jeweils einer Handvoll Werte, plus
siteundcluster. Sandbox-IDs, Pod-Namen, Nutzer-IDs und Domains sind unbegrenzt und gehören nach Elasticsearch, niemals in Prometheus-Labels. Ein einziges falsch gewähltes Label (eine Sandbox-ID auf einem stark ausgelasteten Cluster) kann Tausende neuer Serien pro Tag hinzufügen. - Jedem Backend nur senden, was es nutzt. Jedes Ereignis geht einmal an Elasticsearch; Dynatrace erhält Medium und höher; Prometheus erhält Zählwerte. Traces bleiben in der Anwendung gesampelt. Alles in jedes Werkzeug zu duplizieren, ist der häufigste Kostenfehler, den wir sehen.
15. Hochverfügbarkeit der Sicherheitspipeline
Ein Angreifer, der das SIEM blind machen kann, hat die halbe Schlacht gewonnen; die Pipeline ist daher so gebaut, dass sie bei Ausfällen weiterarbeitet und laut wird, wenn sie das nicht kann.
- Gateways: mindestens zwei pro Standort hinter einem Load Balancer oder DNS-Namen, zustandslos abgesehen von ihren persistenten Queues auf lokaler Festplatte. Agenten und OpenShell wiederholen Sendungen an das Gateway, das antwortet; ein Gateway-Neustart verliert nichts aus der Queue.
- At-least-once Ende-zu-Ende: persistente Sende-Queues auf Agenten und Gateways, OpenShells eigene Wiederholungen und Dokument-IDs aus Ereignis-IDs, sodass Wiederholungen nie Duplikate erzeugen.
- Elasticsearch: mindestens drei master-fähige Nodes über Fehlerdomänen hinweg, ein Replikat für jeden Sicherheitsindex, Snapshots in einen separaten Speicher und eine Schreibrolle für die Gateways, die keine Daten löschen kann.
- Prometheus und Alertmanager: zwei Prometheus-Replikate (in Mimir dedupliziert, wie im UFM-Design) und ein Alertmanager-Cluster mit drei Nodes.
- Selbstüberwachung: die Pipeline-Zustandsregeln aus Abschnitt 9 plus ein Heartbeat: Eine synthetische OpenShell-Verweigerung, die alle fünf Minuten in einer Canary-Sandbox erzeugt wird, muss in Elasticsearch ankommen, sonst löst eine Regel einen Alarm aus. Lücken-Records von OpenShell (
openshell.ocsf.gap) sind ebenfalls durchsuchbare Ereignisse. - Funktionstrennung: Das Sicherheitsteam verantwortet die Gateway-Konfiguration und das SIEM; Änderungen werden von zwei Personen geprüft; das Plattformteam kann den Pipeline-Zustand sehen, aber nicht ändern, was erfasst wird.
- Uhren: Jede Quelle und jedes Gateway ist mit denselben Zeitquellen synchronisiert, und
@timestampwird aus dem Quellereignis übernommen, nicht aus dem Ingest-Zeitpunkt, damit Sequenzen über Quellen hinweg übereinstimmen.
16. Nachweis der Funktion: Übungen bei der Übergabe
Wir übergeben keine Erkennung, die wir nicht haben auslösen sehen. Im Beisein des Kundenteams führen wir durch und protokollieren:
- Ein Agent in einer Test-Sandbox liest eine Seite mit einer platzierten Anweisung und versucht, auf eine Paste-Site hochzuladen: eine OpenShell-Verweigerung, ein unterdrückter Elastic-Alarm, eine Timeline, die das Lesen und den Versuch zeigt.
- Eine Test-Sandbox ruft mit ihrem eigenen Credential die API einer anderen Sandbox auf: ein kritisches Finding, der automatische Stopp, das gesetzte Quarantäne-Label, der mit jeder Maßnahme aktualisierte Case.
- Eine bekanntermaßen schädliche Probe wird einem CI-Branch hinzugefügt: Die garak-Angriffserfolgsrate überschreitet 5 %, und das Pipeline-Gate schlägt fehl.
- Ein Benchmark-Job läuft auf einer GPU ohne zugeordneten Scheduler-Job: Der Cryptojacking-Alarm löst innerhalb seines 15-Minuten-Fensters aus.
- Ein Test-Pod mit privilegiertem Container wird erstellt: Die Kubernetes-Regel löst aus, und das Playbook bittet um Freigabe.
- Ein Security-Gateway wird gestoppt: keine verlorenen Ereignisse, ein Redundanzalarm, Wiederherstellung bei seiner Rückkehr.
- Das SIEM wird 15 Minuten lang von den Gateways abgeschnitten: Der Alarm für Exportfehler löst aus, die Queues füllen sich und leeren sich anschließend, und der Heartbeat zeigt keine Lücke.
17. Wie Workstation dies umsetzt und betreibt
- Bewertung. Bestandsaufnahme der Umgebung, der Agenten und dessen, worauf sie zugreifen können, der Daten- und Modell-Assets sowie der vorhandenen SIEM-, Monitoring- und Reaktionswerkzeuge. Ergebnis: eine Bedrohungs- und Kontrollkarte wie in Abschnitt 2, speziell für Sie.
- Architektur. Auswahl von Quellen, Schema, Backends, Aufbewahrung, HA und der Position zu UK GDPR. Ergebnis: ein unterzeichnetes Design.
- Aufbau. Collector-Agenten und Security-Gateways, OCSF-Export von OpenShell, Ingest-Pipelines, Index-Templates, Lifecycle-Policies und Dashboards, alles aus versionskontrollierter Konfiguration in Ihren Repositories.
- Detection Engineering. Regeln, Alarme und Playbooks für Ihre Anwendungsfälle, jeweils mit einem Testereignis und einem Verantwortlichen.
- Feinabstimmung. Zwei bis vier Wochen stiller Betrieb, Rauschen reduzieren, Schwellenwerte und Unterdrückung festlegen und ein Alarmbudget vereinbaren, das das Team dauerhaft bewältigen kann.
- Übergabe. Die Übungen aus Abschnitt 16, Runbooks sowie Schulungen für Analysten und Plattformingenieure.
- Managed Monitoring Support. Laufende Monitoring-Unterstützung an der Seite Ihres Teams (oder als Abdeckung außerhalb der Geschäftszeiten): Regelaktualisierungen, wenn sich NVIDIAs Produkte und die Bedrohungslage ändern, Upgrades der Pipeline, regelmäßige Threat-Hunting-Reviews und ein monatlicher Bericht zu Erkennungen, Reaktionszeiten, Rauschen und Abdeckung. Die genauen Service-Levels werden pro Kunde vereinbart.
NVIDIA-Partner: Engineering, Software und Personal
Workstation ist NVIDIA-Partner; neben der Hardware stellen wir daher Engineering, Software und Personal bereit, um KI-Rechenzentren durchgängig aufzubauen und zu betreiben, einschließlich des Sicherheitsmonitorings rund um sie. Wir spezifizieren und liefern die Plattform, installieren und konfigurieren sie, bauen die hier beschriebene Observability- und SIEM-Integration und stellen Ingenieure, die anschließend innerhalb Ihres Change-Prozesses arbeiten.
- DPUs und Netzwerk: NVIDIA-BlueField-DPUs (einschließlich der BlueField-3 B3220, der Mindestgeneration für DOCA Argus), ConnectX-8 SuperNICs und die Spectrum-X-Ethernet-Plattform.
- GPU-Systeme: DGX B300, HGX-B300-Server, DGX SuperPOD und Vera Rubin NVL72, die Systemklasse in NVIDIAs OpenShell Reference Architecture für Inferenz.
- Software: Abonnements für NVIDIA AI Enterprise sowie Einrichtung und Support für OpenShell, NeMo Guardrails, garak und die offenen Komponenten in diesem Artikel.
Um Ihre Umgebung zu besprechen, fragen Sie unseren AI Sales Engineer; er leitet Sie an den richtigen Ingenieur weiter.
18. Quellen und Hinweise zur Verifizierung
- Überblick über NVIDIAs Portfolio: die offizielle NVIDIA-Seite zu Cybersecurity-KI-Lösungen, gelesen im November 2026, zu OpenShell und seiner Referenzarchitektur, Sentry on BlueField, BlueField und DOCA, DOCA Argus, DOCA Vault, Confidential Computing, Nemotron und Nemotron Safety, NeMo, garak und NemoClaw. Alle Formulierungen hier sind unsere eigene Zusammenfassung.
- OpenShell: das README des GitHub-Repositorys und seine Dokumentationsseiten zu Sandbox-Logging, OCSF-JSON-Export, Gateway-Konfiguration (OCSF-JSONL- und OTLP-Export), Gateway-Metriken, Sandboxes und Policies. OCSF-Klassen, Grund-Strings, das Finding
sandbox-authorization-boundary, OTLP-Attribute, Metriknamen und CLI-Befehle sind aus diesen Seiten zitiert. Der Beispiel-OCSF-Record in unserem Test wurde aus dem Beispiel der Dokumentation erstellt. - DOCA Argus: NVIDIAs DOCA-Argus-Serviceleitfaden zu Anforderungen, Nachrichtentypen, Schweregraden und Telemetrieschlüsseln. Nicht auf Hardware getestet; Feldpfade sollten anhand einer echten Nachricht aus Ihrem Release geprüft werden.
- Sentry, DOCA Vault und die OpenShell Reference Architecture: ausschließlich anhand der öffentlichen NVIDIA-Seite beschrieben. Schnittstellen, Formate oder Befehle dafür werden hier nicht angegeben.
- Confidential Computing: NVIDIAs Seite und das README von nvTrust. Das Format des Attestierungsereignisses ist eine Konvention von Workstation.
- NeMo Guardrails: das README des Repositorys (Rail-Typen, Release 0.24.1) und seine Referenz zur Tracing-Konfiguration. Die Konvention für Blockierungsereignisse stammt von Workstation.
- garak: das README des Repositorys, die CLI-Optionen und der Quellcode des Evaluators für die Felder der Eval-Records. Die Probe-Auswahl im CI-Beispiel dient der Veranschaulichung.
- Morpheus: README, Beispiele und Release-Liste des Repositorys (zum Zeitpunkt der Erstellung neuester Tag 25.06, Juli 2025).
- Dynatrace: die Dokumentation von Dynatrace zur OTLP-API und zur Collector-Konfiguration für Endpunkt, Protokoll, Token-Scopes und Delta-Temporalität. Nicht gegen einen echten Tenant getestet: Der Exporter wurde validiert und lief, aber seine Anfragen gingen an eine Platzhalter-Umgebung. Davis-Anomalieerkennung und Routing von Sicherheitsereignissen sind gemäß der Dokumentation von Dynatrace allgemein beschrieben.
- OpenTelemetry Collector: beide Konfigurationen mit
otelcol-contrib validateinotel/opentelemetry-collector-contrib:0.165.0validiert und anschließend betrieben: Test-Records für OCSF, Argus, Appliances, Guardrails, auditd, Kubernetes-Audit und garak wurden über einen Agenten und das Gateway in Elasticsearch und Prometheus gesendet, und die resultierenden Dokumente und Serien wurden geprüft. Endpunkte und Hostnamen sind Platzhalter. - Elastic: Ingest-Pipeline, Index-Template und Lifecycle-Policy auf Elasticsearch 9.2.0 angewendet; alle vierzehn Regeln über die Detection-Engine-API von Kibana 9.2.0 angelegt, erfolgreich ausgeführt und mit den erwarteten Alarmen (dreizehn ausgelöst; die Regel für Zugriffe außerhalb der Geschäftszeiten korrekterweise nicht, weil ihr Testereignis innerhalb der Geschäftszeiten lag). Timeline-Templates, Case-Connectoren und Überschneidungen mit vorgefertigten Regeln wurden nicht getestet.
- Prometheus und Alertmanager: Regeln mit
promtool check rulesvalidiert und mitpromtool test rulesper Unit-Test geprüft, Prometheus 3.12.0; Alertmanager-Konfiguration mitamtool check-configvalidiert, Alertmanager 0.34.2. DCGM-Metriknamen folgen dcgm-exporter 4.9.0 über die Recording Rulesws:aus dem UFM-Artikel. - Kubernetes: die Quarantäne-NetworkPolicy mit
kubeconform0.8.0 im Strict-Modus validiert. Nicht gegen ein echtes CNI getestet. - Konventionen von Workstation: Datensatznamen, Regel-IDs, die Metrik
ws.security.events, Aktionsnamen für wslvault und OpsAPI, das Guardrail-Blockierungsereignis und das Attestierungsereignis stammen von uns. - Veranschaulichende Zahlen: Ereignisraten, Volumen, Schwellenwerte und Zeitangaben sind Rechenbeispiele, keine Messungen aus einem Kundensystem.
- Compliance: nur allgemeine Orientierung, keine Rechtsberatung.
Hinweis zu Rechten: NVIDIA, das NVIDIA-Logo, BlueField, DOCA, DOCA Argus, DOCA Vault, Sentry, OpenShell, NemoClaw, Nemotron, NeMo, NeMo Guardrails, Morpheus, Vera, Vera Rubin, Blackwell, DGX, HGX, Spectrum, Spectrum-X, ConnectX, SuperNIC, NVLink, DCGM, UFM und NVIDIA AI Enterprise sind Marken und/oder eingetragene Marken der NVIDIA Corporation in den Vereinigten Staaten und anderen Ländern. NVIDIA-Produkte und -Technologien können durch Patente und andere Rechte des geistigen Eigentums der NVIDIA Corporation geschützt sein; alle diese Rechte werden anerkannt und bleiben ihren Inhabern vorbehalten. Produktinformationen sind in unseren eigenen Worten aus öffentlichem Material von NVIDIA zusammengefasst; maßgebliche Quelle sind die Website und die Dokumentation von NVIDIA. garak ist ein von NVIDIA gepflegtes Open-Source-Projekt. Elastic, Elasticsearch, Kibana, Logstash, Elastic Security, Dynatrace, Davis, Prometheus, Alertmanager, Grafana, Loki, OpenTelemetry, Kubernetes, ServiceNow, PagerDuty, MITRE ATT&CK, Fluent Bit, Vector und Slurm sind Marken oder eingetragene Marken ihrer jeweiligen Inhaber, und andere Namen können Marken ihrer jeweiligen Inhaber sein. Eine Billigung durch eines dieser Unternehmen ist damit nicht verbunden. Die eigenen Konfigurationen, Regeln, Diagramme und Texte von Workstation sind © Workstation.