YARA-Rules und IOC-Scanner: Shift-Left Threat Detection für DevOps

The Stoic Unix Philosophy: Calm Tools for an Uncontrollable World

The Unix philosophy tells tools how to be shaped. The Stoic Unix Philosophy tells them how to behave under adversity: calm, honest, and indifferent to everything outside their control. A field guide with a real-world case study.

Die meisten Security-Tools greifen erst nach einem Einbruch. YARA arbeitet bereits, bevor die Datei überhaupt ausgeführt wird. Es matcht Muster in Binärdateien, Memory-Dumps und Dokumenten, ähnlich wie grep Muster in Texten matcht, und ist so zum Rückgrat der Malware-Klassifizierung in der gesamten Branche geworden. VirusTotal nutzt es. CISA nutzt es. Incident-Response-Teams weltweit nutzen es.

Hier erfahren Sie, wie YARA in eine moderne DevOps-Security-Pipeline passt, zusammen mit seinem Rust-Nachfolger YARA-X, dem IOC Scanner der CISA und Sigma-Rules für die Erkennung auf Log-Ebene.

Was YARA macht

YARA ist ein Open-Source-Pattern-Matching-Tool (BSD-3-Clause-Lizenz, ~9,5k GitHub-Stars, geschrieben in C), das ursprünglich von VirusTotal entwickelt wurde. Das Konzept ist simpel: Sie schreiben Regeln, die beschreiben, wie eine bösartige Datei aussieht, und YARA scannt Dateien oder Speicherbereiche, um Übereinstimmungen zu finden.

Unter der Haube kompiliert YARA Ihre Regeln in eine interne Repräsentation und scannt die Zieldaten anschließend mit dem Aho-Corasick-String-Matching-Algorithmus. Dies ist derselbe Algorithmus, der die schnelle Multi-Pattern-Suche in Intrusion-Detection-Systemen ermöglicht. Das bedeutet, dass YARA hunderte von String-Mustern in einem einzigen Durchgang gegen eine Datei prüfen kann.

YARA befindet sich mittlerweile im Maintenance-Modus. Die gesamte Entwicklung neuer Funktionen, einschließlich neuer Module und Performance-Optimierungen, wurde auf YARA-X übertragen.

Struktur einer YARA-Regel

Jede YARA-Regel besteht aus vier Abschnitten:

• meta: beliebige Metadaten (Autor, Beschreibung, Datum, Referenz-URLs)
• strings: die zu suchenden Muster, einschließlich Hex-Byte-Sequenzen, Plaintext-Strings, regulärer Ausdrücke und Wildcards
• condition: boolesche Logik, die bestimmt, wann die Regel auslöst. Sie können die Dateigröße prüfen, die Anzahl der Mustervorkommen zählen, Offsets testen und mehrere Kriterien mit and/or kombinieren
• tags: der Regel zugewiesene Labels zur Filterung

Hier ist eine Regel, die Cobalt Strike Beacon-Payloads erkennt, indem sie den MZ-Header und charakteristische Konfigurationsmarker prüft:

rule CobaltStrike_Beacon {
    meta:
        author = "Security Team"
        description = "Detects Cobalt Strike beacon payload"
        date = "2026-03-15"
        reference = "https://attack.mitre.org/software/S0154"

    strings:
        $mz = "MZ" ascii
        $config_marker = { 00 01 00 01 00 02 00 01 }
        $beacon_ja3 = "beacon." ascii nocase
        $setting = "Setting" wide ascii

    condition:
        $mz at 0 and
        filesize < 2MB and
        any of ($config_marker, $beacon_ja3) and
        #setting > 2
}
```text

Die `at 0`-Prüfung bestätigt, dass der MZ-Header am Offset Null sitzt (eine gültige PE-Datei). Die `filesize < 2MB`-Einschränkung hält die Regel schnell, indem große Dateien, die unwahrscheinlich Beacon-Payloads sind, übersprungen werden. Das Präfix `#` zählt, wie oft ein String vorkommt.

## YARA-X: Der Rewrite in Rust

Víctor M. Alvarez, der ursprüngliche Autor von YARA, hat das gesamte Tool in Rust neu geschrieben. Das Ergebnis ist YARA-X (github.com/VirusTotal/yara-x), aktuell in Version v1.14.0 (März 2026) und seit Juni 2025 stabil. VirusTotal setzt es bereits produktiv ein und scannt Milliarden von Dateien mit zehntausenden von Regeln.

Die Regelkompatibilität liegt bei etwa 99 %. Die meisten bestehenden YARA-Regeln funktionieren ohne Änderungen.

Die wichtigste Verbesserung ist die Geschwindigkeit. Bei Regex-lastigen Regeln ist YARA-X 5- bis 10-mal schneller als das klassische YARA. Eine Regel zur Erkennung von Bitcoin-Adressen, die mit dem ursprünglichen YARA 20 Sekunden für eine 200-MB-Datei benötigte, wird mit YARA-X in weniger als einer Sekunde abgeschlossen.

Neben der reinen Geschwindigkeit bringt YARA-X mehrere Quality-of-Life-Verbesserungen: zeilengenaue Fehlermeldungen, die exakt angeben, welches Zeichen in einer Regel falsch ist, native JSON- und YAML-Ausgabe, WASM-Kompilierung für Sandbox-Umgebungen und eine Language Server Protocol-Implementierung, die Autovervollständigung und Validierung in Ihrer IDE bietet.

Zu den neuen Modulen gehören `dex` für Android Dalvik-Executables und `crx` für Chrome-Extensions. Das Process-Scanning (die Fähigkeit, den Speicher laufender Prozesse zu scannen) ist noch nicht implementiert, was die größte Lücke für Incident-Response-Anwendungsfälle darstellt.

| Feature | YARA (C) | YARA-X (Rust) |
| --------- | ---------- | --------------- |
| Sprache | C | Rust |
| Aktuellste Version | v4.5.x (Maintenance) | v1.14.0 (aktiv) |
| Regex-Performance | Baseline | 5-10× schneller |
| Regelkompatibilität | Vollständig | ~99% |
| JSON/YAML-Ausgabe | Teilweise (via Flags) | Nativ |
| WASM-Support | Nein | Ja |
| Language Server | Nein | Ja |
| Process-Scanning | Ja | Noch nicht |
| Fehlermeldungen | Zeilenebene | Zeichenebene |
| Neue Module | Gestoppt | Aktiv (dex, crx) |

## Integrierte Module

YARA wird mit Modulen ausgeliefert, die spezifische Dateiformate parsen und deren Struktur für Ihre Regeln zugänglich machen. Die am häufigsten verwendeten sind:

- **PE**: Windows Portable Executable. Untersucht Sektionen, Imports, Exports, Ressourcen, digitale Signaturen
- **ELF**: Linux-Executables und Shared Libraries
- **Mach-O**: macOS-Binärdateien
- **Hash**: berechnet MD5, SHA1, SHA256, CRC32 von gescannten Dateien
- **Cuckoo**: integriert Verhaltensanalysedaten aus der Cuckoo Sandbox

Hier ist ein Beispiel für das PE-Modul, das den Maschinentyp, die Anzahl der Sektionen, den Entry Point und prüft, ob die Binärdatei eine gültige Authenticode-Signatur besitzt:

```yara
import "pe"

rule Suspicious_PE_Anonymous {
    meta:
        description = "PE file with no signature and unusual structure"

    condition:
        pe.is_pe and
        pe.machine == pe.MACHINE_I386 and
        pe.number_of_sections < 3 and
        pe.entry_point < 0x1000 and
        not pe.is_signed
}
```text

## CISA IOC Scanner: Hash-basierte Erkennung in großem Maßstab

Der CISA IOC Scanner (github.com/cisagov/ioc-scanner) ist ein leichtgewichtiges Python-Skript der US-amerikanischen Cybersecurity and Infrastructure Security Agency. Veröffentlicht unter CC0-1.0 (Public Domain), ist die aktuelle Version v4.0.0 (Dezember 2025).

Die Designphilosophie ist simpel: null Abhängigkeiten. Die `ioc_scanner.py`-Datei läuft überall dort, wo Python 3 installiert ist. Kein `pip install`, keine virtuellen Umgebungen, keine Abhängigkeitskonflikte. Sie kopieren das Skript und führen es aus.

Der Scanner durchsucht Dateisysteme nach Dateien, die mit bekannten bösartigen Hashes (MD5, SHA-1, SHA-256) aus CISA-Warnmeldungen übereinstimmen. Er parst Hash-Werte aus Plaintext, CSV oder jedem Blob, der Strings enthält, die Hash-Mustern entsprechen.

```bash
python3 ioc_scanner.py --file hashes.txt --target /var/www

# Scan a specific directory tree
python3 ioc_scanner.py --file cisa_advisory_hashes.txt --target /home/deploy/releases/
```text

Für den flächendeckenden Einsatz in der gesamten Flotte lässt sich der Scanner in Ansible-Playbooks oder den AWS Systems Manager (SSM) integrieren, um Scans von einem zentralen Ort aus auf hunderten von Maschinen zu pushen. Die Ausgabe ist unkompliziert: jeder Hash, gefolgt von der Anzahl der übereinstimmenden Dateien (Null ist das gewünschte Ergebnis).

## Sigma Rules: Erkennung für Logs
Was YARA für Dateien ist, ist Sigma für Logs. Sigma ist ein offenes, herstellerunabhängiges Signaturformat, das von SigmaHQ (sigmahq.io) gepflegt wird und über 3.000 Community-Regeln umfasst. Anstatt die Erkennungslogik separat für Splunk, Elastic, Microsoft Sentinel und QRadar zu schreiben, schreiben Sie diese einmal in Sigma YAML und konvertieren sie mithilfe von `sigma-cli` in jede unterstützte Plattform.

Eine Sigma-Regel spezifiziert eine Log-Quelle, die Erkennungslogik und kontextuelle Metadaten, einschließlich MITRE ATT&CK-Tags:

```yaml
title: Windows Defender Threat Protection Disabled
id: a3b10c5e-4f8a-4c25-9c6b-6d5a96f9c8d7
status: experimental
description: Detects attempts to disable Windows Defender real-time protection
author: Security Team
date: 2026/03/15
tags:
    - attack.defense_evasion
    - attack.t1562.001
logsource:
    category: registry_event
    product: windows
detection:
    selection:
        TargetObject|contains:
            - '\Real-Time Protection'
            - '\DisableAntiSpyware'
        Details|contains:
            - 'DWORD (0x00000001)'
    condition: selection
falsepositives:
    - Legitimate admin reconfiguration
level: high
```text

Die Konvertierung dieser Regel für Ihr SIEM erfolgt mit einem einzigen Befehl:

```bash
# Install the converter
pip3 install sigma-cli
sigma plugin install splunk

# Convert to Splunk SPL
sigma convert --target splunk --pipeline splunk_windows ./rules/
```text

## Das Ökosystem: Ebenen der Erkennung

Diese Tools bilden einen Stack, wobei jedes eine andere Ebene abdeckt:

1. **YARA** erkennt bösartige Muster in Dateien und Binärdateien.
2. **Sigma** erkennt verdächtiges Verhalten in Logs und Events.
3. **STIX/TAXII** bietet ein Standardprotokoll für den Austausch von Threat Intelligence.
4. **MISP** dient als Threat Intelligence Plattform, die Indikatoren aggregiert und korreliert.

Mehrere Tools schlagen die Brücke zwischen diesen Ebenen. YARA-CI (betrieben von VirusTotal) testet Ihre Regeln kontinuierlich gegen einen Korpus von Millionen von Dateien, um False Positives und fehlerhafte Regeln abzufangen, bevor sie in die Produktion gelangen. YaraHunter von Deepfence (~1,3k GitHub-Stars) kapselt YARA in einen container-nativen Scanner, wodurch das Scannen von Docker-Images während des Build-Prozesses unkompliziert wird.

## DevOps-Integration

Der eigentliche Wert dieser Tools zeigt sich, wenn Sie sie in CI/CD-Pipelines einbetten. Hier ist ein GitHub Actions Workflow, der bei jedem Push einen YARA-Scan ausführt:

```yaml
name: YARA Security Scan

on:
    push:
        branches: [main]
    pull_request:
        branches: [main]

jobs:
    yara-scan:
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v4

            - name: Install YARA
              run: sudo apt-get update && sudo apt-get install -y yara

            - name: Clone detection rules
              run: |
                  git clone --depth 1 https://github.com/Yara-Rules/rules.git /tmp/yara-rules

            - name: Scan repository artefacts
              run: |
                  yara --recursive --print-tags \
                    /tmp/yara-rules/malware/ ./artefacts/ \
> yara-results.txt 2>&1 |  | true

            - name: Check for matches
              run: |
                  if [ -s yara-results.txt ]; then
                    echo "::error::YARA detected malicious patterns"
                    cat yara-results.txt
                    exit 1
                  fi
```text

Für eine Python-basierte Integration ermöglicht die `yara-python` Bibliothek das programmatische Kompilieren von Regeln sowie das Scannen von Dateien oder Memory-Buffern:

```python
import yara

# Compile rules from file
rules = yara.compile(filepath="rules/malware.yar")

# Scan a file
matches = rules.match("suspicious_binary.exe")
for match in matches:
    print(f"Rule: {match.rule}, Tags: {match.tags}")

# Scan a memory buffer
with open("upload.bin", "rb") as f:
    matches = rules.match(data=f.read())
```text

Um Community-Regeln von VirusTotal zu beziehen, können Sie die VirusTotal API nutzen, um kuratierte Regelsätze herunterzuladen. In Kombination mit dem CISA IOC Scanner für hashbasierte Prüfungen und Sigma-Regeln für das Log-Monitoring erhalten Sie eine umfassende Abdeckung über Dateien, Hashes und Logs hinweg.

## Aufbau einer Detection Pipeline

Zusammengefasst sieht eine praxisnahe Shift-Left Detection Pipeline wie folgt aus:

1. **Pre-commit**: Git-Hooks führen YARA-Regeln gegen gestagte Dateien aus. Leichtgewichtig, schnell und fängt offensichtliche Probleme ab, bevor sie ins Repository gelangen.

2. **CI/CD**: GitHub Actions oder GitLab CI führen YARA-X-Scans auf Build-Artefakten aus, YaraHunter scannt Docker-Images und der CISA IOC Scanner prüft Release-Binaries gegen bekannte bösartige Hashes.
3. **Registry-Scanning**: Bevor ein Container-Image von Staging nach Production befördert wird, scannt YaraHunter oder ein ähnliches Tool die Image-Layer auf bekannte Malware-Muster.

4. **Runtime-Monitoring**: Sigma-Regeln, die in das native Format Ihres SIEM konvertiert wurden, erkennen verdächtiges Verhalten in den Production-Logs. Beispiele hierfür sind das Deaktivieren von Windows Defender, unerwartete PowerShell-Downloads oder ungewöhnliche Netzwerkverbindungen.

5. **Fleet-Auditing**: Der CISA IOC Scanner wird planmäßig (via Ansible, AWS SSM oder cron) über Ihre gesamte Infrastruktur ausgeführt und prüft Dateisysteme gegen die neuesten Hashes aus CISA-Warnmeldungen.

6. **Kontinuierliches Testen**: YARA-CI testet Ihre Detection-Regeln bei jeder Änderung gegen ein großes Korpus, um False Positives abzufangen und sicherzustellen, dass die Regeln angesichts der sich entwickelnden Bedrohungslage effektiv bleiben.

Das Tooling ist Open Source, gut gepflegt und auf Interoperabilität ausgelegt. YARA übernimmt das Pattern Matching auf Dateiebene. Sigma kümmert sich um die Erkennung auf Log-Ebene. Der CISA IOC Scanner schließt die Lücke mit einfachen, hashbasierten Prüfungen, die keine Konfiguration erfordern. Zusammen ermöglichen sie es Ihnen, die Bedrohungserkennung nach links zu verschieben („shift left“), sodass bösartige Dateien und verdächtige Aktivitäten abgefangen werden, bevor sie die Production erreichen, anstatt sie erst während der Incident Response zu entdecken.