Process Injection erkennen: Remote-Thread, Hollowing und Prozesszugriff

Process Injection erkennen gehört zu den anspruchsvolleren Aufgaben im SOC, weil der Schadcode nicht zwingend als eigener Prozess auftritt, sondern im Kontext eines bereits laufenden und oft signierten Prozesses ausgeführt werden kann. Ein Blick in die Prozessliste zeigt dann weiterhin bekannte Namen. Unsichtbar ist die Technik trotzdem nicht: Cross-Process-Zugriffe, Speicherveränderungen, Thread-Aktivität und Abweichungen zwischen Image und Speicher können charakteristische Spuren hinterlassen. Process Injection ist dabei keine einzelne Technik, sondern eine Familie verschiedener Verfahren, die sich insbesondere darin unterscheiden, wie Code in einen Zielprozess gelangt und wie die Ausführung anschließend übernommen wird.

Was Process Injection technisch bedeutet

Ein Windows-Prozess besitzt einen eigenen virtuellen Adressraum. Darin liegen unter anderem ausführbarer Programmcode, geladene DLLs, Heap- und Stack-Speicher sowie die Threads des Prozesses. Vereinfacht sieht ein normaler Prozess so aus:

explorer.exe
┌─────────────────────────────┐
│ legitimer Programmcode      │
│ Windows-DLLs                │
│ Heap / Stack                │
│ Threads                     │
└─────────────────────────────┘

Bei einer Process Injection wird dieser Zustand verändert. Zusätzlicher Code oder für seine Ausführung notwendige Daten gelangen in den Zielprozess, oder ein vorhandener Ausführungskontext wird so manipuliert, dass fremder Code ausgeführt wird.

explorer.exe
┌─────────────────────────────┐
│ legitimer Programmcode      │
│ Windows-DLLs                │
│ Heap / Stack                │
│                             │
│ fremder Code                │
│       ↑                     │
│       └── eingeschleust     │
│                             │
│ Threads                     │
└─────────────────────────────┘

Der wichtige Punkt für die Analyse: Der Prozessname kann unverändert bleiben. Im Task-Manager steht weiterhin beispielsweise explorer.exe, svchost.exe oder ein anderer legitimer Prozess. Das sagt noch nichts darüber aus, ob im Speicher ausschließlich der erwartete Code ausgeführt wird.

Write Primitive und Execution Primitive

Viele Injection-Techniken lassen sich mit zwei Fragen wesentlich leichter verstehen: Wie gelangen Code oder Daten in den Zielprozess, und wie erhält dieser Code anschließend CPU-Zeit? Diese beiden Schritte lassen sich als Write Primitive und Execution Primitive betrachten.

Write Primitive

Das Write Primitive beschreibt den Mechanismus, mit dem der Zielprozess verändert wird. Das kann beispielsweise bedeuten, neuen Speicher bereitzustellen, bestehenden Speicher zu verändern, einen DLL-Pfad zu hinterlegen, ein PE-Abbild in den Zielprozess zu übertragen oder Teile eines vorhandenen Process Images zu ersetzen.

Quellprozess
     │
     ▼
Zugriff auf Zielprozess
     │
     ├── Speicher bereitstellen
     ├── Speicher verändern
     ├── DLL / PE bereitstellen
     └── Process Image verändern

Bei klassischen Windows-Beispielen tauchen dabei API-Namen wie OpenProcess, VirtualAllocEx oder WriteProcessMemory auf. Diese APIs veranschaulichen das Prinzip gut, sind aber nicht mit Process Injection selbst gleichzusetzen. Dasselbe Verhalten kann über andere Windows- oder Native-APIs umgesetzt werden.

Execution Primitive

Das Execution Primitive beschreibt, wie die Ausführung anschließend auf den eingebrachten oder manipulierten Code gelenkt wird. Möglich sind beispielsweise ein neuer Remote Thread, ein bereits vorhandener Thread, eine APC Queue, ein veränderter Thread Context oder das Fortsetzen eines zuvor suspendierten und manipulierten Prozesses.

Code oder Daten im Zielprozess
          │
          ├── neuer Remote Thread
          ├── vorhandener Thread
          ├── APC
          ├── veränderter Thread Context
          └── Resume eines manipulierten Prozesses

Diese Trennung ist für Detection Engineering wichtig. Eine Regel, die nur nach einem neu erzeugten Remote Thread sucht, kann beispielsweise eine Variante übersehen, bei der ein bereits vorhandener Thread übernommen wird.

Die wichtigsten Process-Injection-Techniken

Remote Thread Injection

Die klassische Remote Thread Injection eignet sich besonders gut, um das Grundprinzip zu verstehen. Ein Quellprozess erhält Zugriff auf einen bereits laufenden Zielprozess. Anschließend wird dort Speicher verwendet oder verändert, und schließlich wird ein neuer Thread innerhalb des Zielprozesses gestartet.

OpenProcess
     ↓
VirtualAllocEx
     ↓
WriteProcessMemory
     ↓
CreateRemoteThread

Diese API-Kette beschreibt eine klassische Implementierung, nicht die Definition von Process Injection. Entscheidend ist das Verhalten: Cross-Process-Zugriff, Speicherveränderung und anschließend die Ausführung innerhalb des Zielprozesses.

explorer.exe

Thread 1 ──► legitimer Explorer-Code
Thread 2 ──► legitimer Explorer-Code
Thread 3 ──► legitimer Explorer-Code

Thread 4 ──► fremder Speicherbereich
                 │
                 └── injizierter Code

Gerade dieser neue Thread ist der entscheidende Unterschied zu Techniken wie Thread Execution Hijacking oder APC Injection. Für die Detection sind hier Process Access, die Erstellung des Remote Threads und die Startadresse des Threads besonders interessant.

DLL Injection

Bei DLL Injection wird der Zielprozess dazu gebracht, zusätzlichen Code in Form einer Dynamic Link Library auszuführen. Statt direkt einen vollständigen Codeblock in den Zielprozess zu schreiben, kann beispielsweise eine Information über die zu ladende DLL im Zielprozess bereitgestellt werden. Der Zielprozess lädt die Bibliothek anschließend in seinen eigenen Adressraum.

Zielprozess
┌─────────────────────────────┐
│ legitime DLL                │
│ legitime DLL                │
│ weitere legitime Module     │
│                             │
│ zusätzliche DLL             │
│        ↑                    │
│        └── eingeschleust    │
└─────────────────────────────┘

Neben der klassischen DLL Injection existieren Varianten wie Reflective DLL Injection oder Manual Mapping. Dabei wird versucht, Teile der Arbeit des normalen Windows Loaders selbst zu übernehmen. Das kann dazu führen, dass ein Modul im Speicher nicht genauso erscheint wie eine regulär über den Windows Loader eingebundene DLL.

PE Injection

Bei PE Injection wird ausführbarer Code im Portable-Executable-Format oder ein entsprechendes Speicherabbild in den Adressraum eines anderen Prozesses eingebracht. Zum PE-Format gehören unter anderem Sektionen, Imports, Relocations und ausführbare Bereiche. Deshalb ist das Verfahren komplexer als das bloße Kopieren beliebiger Bytes.

Quellprozess
      │
      │ PE-Inhalt
      ▼
Zielprozess
┌─────────────────────────────┐
│ legitimer Code              │
│ legitime Module             │
│                             │
│ PE-Abbild                   │
│       ↑                     │
│       └── fremder Code      │
└─────────────────────────────┘

Für die Erkennung sind bei solchen Varianten insbesondere ausführbare private Speicherbereiche, PE-Strukturen außerhalb regulär geladener Module sowie Thread-Startadressen interessant, die nicht zu einem erwarteten Image gehören.

Thread Execution Hijacking

Thread Execution Hijacking zeigt besonders deutlich, warum nicht jede Process Injection einen neuen Thread erzeugt. Statt einen zusätzlichen Thread zu starten, wird ein bereits vorhandener Thread angehalten, sein Ausführungskontext verändert und der Thread anschließend fortgesetzt.

bestehender Thread
        │
        ▼
Thread anhalten
        │
        ▼
Ausführungskontext verändern
        │
        ▼
Thread fortsetzen
        │
        ▼
fremder Code wird ausgeführt

Der Thread Context enthält unter anderem Informationen darüber, an welcher Adresse die Ausführung fortgesetzt werden soll. Wird dieser Kontext verändert, kann ein bereits existierender Thread nach dem Fortsetzen auf eine andere Speicheradresse zeigen.

Für die Detection ist das entscheidend: Es muss kein neuer Remote Thread entstehen. Sysmon Event 8 kann bei dieser Variante daher fehlen.

APC Injection

APC steht für Asynchronous Procedure Call. Windows Threads können APCs in einer Warteschlange besitzen, die unter bestimmten Bedingungen verarbeitet werden. Eine Injection-Variante kann diesen legitimen Mechanismus missbrauchen und einen vorhandenen Thread dazu bringen, eine zusätzliche Funktion auszuführen.

Thread
  │
  ▼
APC Queue
┌──────────────────────────┐
│ legitime APC             │
│ legitime APC             │
│ fremde APC               │
│       │                  │
│       └──► fremder Code  │
└──────────────────────────┘

Auch hier wird nicht zwingend ein neuer Thread erstellt. Der vorhandene Thread wird zum Execution Primitive. Je nach APC-Typ und Thread-Zustand wird ein Eintrag nicht automatisch sofort ausgeführt, weshalb der Zustand des Zielthreads eine wichtige Rolle spielt.

Early Bird APC Injection

Bei der sogenannten Early Bird APC Injection wird ein neuer Prozess zunächst in einem angehaltenen Zustand erzeugt. Bevor die normale Ausführung vollständig begonnen hat, wird eine APC für den Thread vorbereitet. Anschließend wird der Thread fortgesetzt. Der besondere Punkt ist damit weniger die APC selbst als der sehr frühe Zeitpunkt im Lebenszyklus des Prozesses.

Prozess wird erstellt
        │
        ▼
Thread noch suspendiert
        │
        ▼
APC wird vorbereitet
        │
        ▼
Thread wird fortgesetzt
        │
        ▼
APC kann früh ausgeführt werden

Process Hollowing

Process Hollowing unterscheidet sich konzeptionell von der klassischen Injection in einen bereits laufenden Prozess. Zunächst wird ein neuer, legitimer Prozess erzeugt, dessen normale Ausführung noch angehalten ist. Danach wird das Process Image oder ein relevanter Teil des Speichers manipuliert, fremder Code eingebracht und die Ausführung auf diesen Code ausgerichtet. Erst danach wird der Prozess fortgesetzt.

1. legitimen Prozess erstellen
            │
            ▼
2. Prozess suspendiert
            │
            ▼
3. Speicher / Image verändern
            │
            ▼
4. fremden Code einbringen
            │
            ▼
5. Ausführung auf neuen Code ausrichten
            │
            ▼
6. Prozess fortsetzen

Der Begriff „Hollowing“ lässt sich sinngemäß als „Aushöhlen“ verstehen. Das Prozessobjekt und der sichtbare Dateiname können legitim wirken, während der tatsächlich ausgeführte Speicherinhalt nicht mehr vollständig dem ursprünglich gestarteten Programm entspricht. Genau deshalb ist Process Hollowing ein gutes Beispiel dafür, warum Prozessname und Dateipfad allein nicht ausreichen.

Die Techniken im Vergleich

Das gemeinsame Denkmodell bleibt damit immer gleich: Welche Veränderung findet im Zielprozess statt, und welches Execution Primitive sorgt anschließend für die Ausführung? Wer diese beiden Fragen beantwortet, kann auch unbekanntere Injection-Varianten wesentlich leichter einordnen.

Welche Logquellen die Technik zeigt

• Zugriff auf einen fremden Prozess. Sysmon Event 10 (ProcessAccess) protokolliert, wenn ein Prozess einen anderen mit bestimmten Rechten öffnet. Zugriffsrechte zum Schreiben in fremden Speicher oder zur Thread-Manipulation sind typisch für klassische Cross-Process-Injection und deshalb ein starkes Signal. Sie sind jedoch nicht bei jeder T1055-Variante in derselben Form erforderlich.
• Der Remote Thread. Sysmon Event 8 (CreateRemoteThread) zeigt, wenn ein Prozess in einem anderen einen Thread startet, samt Quell- und Zielprozess. Das ist besonders für klassische Remote Thread Injection relevant, deckt aber nicht alle Injection-Varianten ab.
• Prozess-Manipulation. Sysmon Event 25 (ProcessTampering) kann Prozessbild-Manipulationen sichtbar machen und ist deshalb insbesondere bei Process Hollowing und verwandten Verfahren interessant.
• Module Loads. Sysmon Event 7 (ImageLoad) kann bei DLL-bezogenen Verfahren zusätzliche Hinweise liefern. Interessant sind ungewöhnliche Module, Pfade, Signaturen und Module, die nicht zum normalen Verhalten des Zielprozesses passen.
• EDR und Speicheranalyse. EDR-Telemetrie kann zusätzlich Speicher- und Thread-Merkmale sichtbar machen, die in klassischen Windows-Events nicht vollständig enthalten sind. Zur Einrichtung der Sysmon-Seite siehe Sysmon einrichten.

GrantedAccess richtig einordnen

Ein wichtiges Feld in Sysmon Event 10 ist GrantedAccess. Dabei handelt es sich um eine Bitmaske der Rechte, die der Quellprozess auf den Zielprozess erhalten hat. Je nach gesetzten Bits können darunter Rechte zum Lesen und Schreiben von Speicher, für Speicheroperationen, zum Erstellen von Threads oder zum Abfragen von Prozessinformationen liegen.

• PROCESS_VM_READ – Speicher lesen
• PROCESS_VM_WRITE – Speicher schreiben
• PROCESS_VM_OPERATION – Speicheroperationen durchführen
• PROCESS_CREATE_THREAD – Thread im Zielprozess erzeugen
• PROCESS_QUERY_INFORMATION – Prozessinformationen abfragen

Wichtig ist der Kontext. Eine Access Mask beweist keine Injection. Debugger, Sicherheitssoftware, Management-Agenten und andere legitime Programme können ebenfalls weitreichende Rechte benötigen. Aussagekräftig wird die Maske erst zusammen mit SourceImage, TargetImage, Pfad, Signatur, Parent Process, Benutzer und Folgeaktivität.

Was ein EDR zusätzlich sehen kann

Sysmon zeigt wichtige Prozessbeziehungen, bildet aber nicht jede Speicheroperation ab. Moderne EDR-Produkte können je nach Produkt und Sensor zusätzliche Merkmale erfassen. Dazu gehören beispielsweise ausführbarer privater Speicher, ungewöhnliche Speicherrechte, Übergänge von RW zu RX, RWX-Regionen, ausführbarer Speicher ohne zugehörige Datei, PE-Strukturen in privaten Speicherbereichen, Cross-Process Handles sowie Thread-Startadressen außerhalb regulär geladener Module.

Thread startet
      ↓
StartAddress gehört zu keinem geladenen Modul
      ↓
Speicher ist Private + Executable
      ↓
starkes Injection-Signal

Nicht jedes EDR erfasst oder bewertet all diese Merkmale gleich. Für die Analyse ist deshalb wichtig zu wissen, welche Speicher- und Thread-Telemetrie das eigene Produkt tatsächlich bereitstellt.

Das Muster im Log

Ein starkes Muster für klassische Remote Thread Injection ist die Kombination aus Process Access und anschließendem Remote Thread: Ein Prozess öffnet einen fremden Prozess mit auffälligen Speicher- oder Thread-Rechten in Event 10, und kurz darauf erzeugt dieselbe Quelle dort einen neuen Thread in Event 8. Verdächtig ist insbesondere, wenn Quelle und Ziel fachlich nicht zusammenpassen, etwa ein Office-Programm oder ein Skript-Host, der einen Systemprozess öffnet.

WINWORD.EXE
     ↓
Sysmon Event 10
     ↓
explorer.exe
     ↓
Sysmon Event 8
     ↓
neuer Remote Thread

Diese Sequenz ist jedoch kein universelles Process-Injection-Muster. Thread Execution Hijacking oder APC Injection können ohne neuen Remote Thread auskommen. Für Process Hollowing ist stattdessen die Kombination aus Prozesserstellung, früher Manipulation des neuen Prozesses und ProcessTampering-Telemetrie besonders interessant.

Process Creation
      ↓
neuer Prozess zunächst angehalten
      ↓
Process Access / Speicher-Manipulation
      ↓
ProcessTampering

Der Zugriff auf lsass ist ein Sonderfall, den der Beitrag zu Mimikatz und LSASS-Dump gesondert behandelt.

Nicht nach einer API suchen, sondern nach Verhalten

Eine zu enge Detection sucht ausschließlich nach einer bekannten API-Kette wie VirtualAllocEx, WriteProcessMemory und CreateRemoteThread. Damit lässt sich eine klassische Variante beschreiben, aber nicht die gesamte Technikfamilie. Robustere Detection abstrahiert deshalb auf das Verhalten.

Cross-Process Access
        +
Memory Manipulation
        +
Execution im Zielprozess
        +
Kontext und Folgeaktivität

Der Vorteil: Alternative Windows-APIs, Native APIs oder andere Execution Primitives ändern möglicherweise die Implementierung, nicht aber zwangsläufig das zugrunde liegende Verhaltensmuster.

Drei Sigma-Regeln

Die Regeln sind mit sigma-cli geprüft und nutzen die drei genannten Sysmon-Ereignisse. Sie setzen voraus, dass Event 8, 10 und 25 in der Sysmon-Konfiguration aktiviert sind. Gerade Event 8 und 10 können je nach Umgebung viele legitime Treffer erzeugen und benötigen deshalb gezieltes Tuning.

1. Remote-Thread in einen sensiblen Systemprozess (T1055). Ein Remote Thread in Prozessen wie lsass, winlogon oder csrss ist ein starkes Signal. Sicherheitssoftware, Debugger und spezielle Management-Werkzeuge können jedoch legitime Ausnahmen erzeugen. Die Regel steht deshalb auf level: high, benötigt aber eine umgebungsspezifische Allowlist.

title: Remote-Thread in einen sensiblen Systemprozess
id: 11941a12-cdc3-4c7d-87c5-f6c92fc45365
status: experimental
description: |
  Erkennt das Erstellen eines Threads in einem sensiblen Systemprozess durch
  einen anderen Prozess. Ein solcher Remote-Thread kann ein starkes Zeichen
  fuer Code-Injection in einen vertrauenswuerdigen Prozess sein.
references:
  - https://attack.mitre.org/techniques/T1055/
author: blue-team.net
tags:
  - attack.stealth
  - attack.privilege-escalation
  - attack.t1055
logsource:
  category: create_remote_thread
  product: windows
detection:
  selection:
    TargetImage|endswith:
      - '\lsass.exe'
      - '\winlogon.exe'
      - '\csrss.exe'
      - '\services.exe'
  filter_av:
    SourceImage|contains:
      - '\Windows Defender\'
      - '\Microsoft Security Client\'
  condition: selection and not filter_av
falsepositives:
  - Sicherheitsprodukte und Debugger mit legitimem Remote-Thread-Verhalten; bekannte Quellen gezielt ausnehmen
level: high

2. Prozess-Manipulation durch Image-Austausch (T1055.012). Sysmon Event 25 kann Veränderungen am Process Image sichtbar machen, die zu Process Hollowing und verwandten Manipulationstechniken passen. Die Regel steht auf level: high, sollte aber immer mit Prozesskontext und Signatur bewertet werden.

title: Prozess-Manipulation durch Image-Austausch
id: 295c4438-69cd-4692-b652-d1198210c976
status: experimental
description: |
  Erkennt eine Sysmon-Meldung ueber Prozess-Manipulation, bei der das
  Speicherabbild eines laufenden Prozesses vom erwarteten Image abweicht.
  Dieses Muster kann zu Process Hollowing und verwandten Techniken passen.
references:
  - https://attack.mitre.org/techniques/T1055/012/
author: blue-team.net
tags:
  - attack.stealth
  - attack.t1055.012
logsource:
  category: process_tampering
  product: windows
detection:
  selection:
    Type|contains: 'Image'
  condition: selection
falsepositives:
  - Packer und Schutzmechanismen legitimer Software koennen die Meldung ausloesen; nach Prozess und Signatur bewerten
level: high

3. Prozesszugriff mit Schreib- und Thread-Rechten (T1055). Eine Zugriffsmaske, die Speicheroperationen und Thread-Erstellung erlaubt, ist typisch für klassische Cross-Process-Code-Injection. Sie beweist jedoch keine Injection und deckt nicht jede T1055-Variante ab. Den Zugriff auf lsass behandelt eine eigene Detection; diese Regel steht auf level: medium.

title: Prozesszugriff mit Schreib- und Thread-Rechten auf einen fremden Prozess
id: 25f46a6f-f4c8-437c-9680-0c5279c3594d
status: experimental
description: |
  Erkennt das Oeffnen eines fremden Prozesses mit einer Zugriffsmaske, die
  Speicheroperationen und das Erstellen von Threads erlaubt. Diese
  Kombination ist typisch fuer klassische Cross-Process-Code-Injection,
  kann jedoch auch durch legitime Werkzeuge entstehen.
references:
  - https://attack.mitre.org/techniques/T1055/
author: blue-team.net
tags:
  - attack.stealth
  - attack.t1055
logsource:
  category: process_access
  product: windows
detection:
  selection:
    GrantedAccess:
      - '0x1F3FFF'
      - '0x1FFFFF'
      - '0x143A'
      - '0x1438'
  filter_lsass:
    TargetImage|endswith: '\lsass.exe'
  filter_av:
    SourceImage|contains:
      - '\Windows Defender\'
      - '\Microsoft Security Client\'
  condition: selection and not filter_lsass and not filter_av
falsepositives:
  - Debugger, Diagnosewerkzeuge und Sicherheitsprodukte mit legitimem Vollzugriff; bekannte Quellen gezielt ausnehmen
level: medium

Korrelation statt Einzelereignis

Eine einzelne ProcessAccess-Meldung ist häufig zu unspezifisch. Stärker wird die Detection, wenn mehrere Ereignisse in einem kurzen Zeitfenster zusammengeführt werden. Ein typisches Beispiel ist Event 10 gefolgt von Event 8 mit derselben Source- und Target-Beziehung. Für Hollowing kann dagegen eine Folge aus Prozesserstellung, frühem Zugriff auf den neuen Prozess und Event 25 relevant sein.

Korrelation reduziert False Positives, weil nicht nur ein einzelner Zugriff bewertet wird, sondern der Ablauf. Zusätzlich sollten Parent-Child-Beziehung, Signatur, Pfad, Integrity Level, Benutzer und Folgeaktivität einbezogen werden.

Härtung: der Angriff, der ins Leere läuft

• Credential Guard und geschützte Prozesse. Protected Process Light (PPL) und Credential Guard erschweren den Zugriff auf sensible Prozesse wie lsass erheblich und reduzieren damit die Angriffsfläche für bestimmte Injection- und Credential-Access-Szenarien.
• ASR-Regeln aktivieren. Die Regeln zur Verringerung der Angriffsfläche von Microsoft Defender können unter anderem verdächtige Code-Injection-Pfade aus Office-Anwendungen und anderen häufig missbrauchten Quellen einschränken.
• EDR-Prävention nutzen. Wenn das eingesetzte EDR verdächtige Speicher- oder Thread-Manipulationen blockieren kann, sollte geprüft werden, welche Präventionsrichtlinien für die eigene Umgebung sinnvoll aktiviert werden können.
• Angriffsfläche verkleinern. Makros einschränken, Skript-Hosts kontrollieren und unnötige Software reduzieren. Je weniger missbrauchbare Startpunkte existieren, desto weniger Quellen stehen für eine Injection zur Verfügung.

Der Test

Die Erkennung lässt sich im Lab auf einem isolierten System mit aktivem Sysmon prüfen. Dabei sollte nicht nur die Frage beantwortet werden, ob ein Alert ausgelöst wird. Ebenso wichtig ist, welche Telemetrie die einzelnen Varianten tatsächlich erzeugen.

• Atomic Red Team bietet für T1055 und verschiedene Unterverfahren Tests, mit denen sich Injection-Verhalten kontrolliert nachstellen lässt.
• Vergleiche Remote Thread Injection, Thread Hijacking und Process Hollowing getrennt. Eine Detection für Remote Threads erkennt nicht automatisch Thread Hijacking oder APC-basierte Varianten.
• Prüfe, welche Events entstehen, welche Felder gefüllt sind, welche Ereignisse fehlen und in welcher zeitlichen Reihenfolge sie auftreten.
• Für eine Process-Hollowing-Simulation ist besonders interessant, ob und wie Event 25 sowie ergänzende EDR-Telemetrie erscheinen.
• Verwende ausschließlich freigegebene Testwerkzeuge in einer isolierten Umgebung und spiele anschließend einen Snapshot zurück. Mehr zum Vorgehen unter Atomic Red Team.

Fehlalarme und Tuning

• Event 8 und 10 brauchen Kontext. Viele legitime Programme öffnen fremde Prozesse oder erzeugen ungewöhnliche Thread-Aktivität. Filtere nicht blind alles weg, sondern berücksichtige SourceImage, TargetImage, Signatur, Pfad und Zugriffsrechte.
• Sicherheits- und Diagnosewerkzeuge. Virenschutz, EDR, Debugger, Backup-Agenten, APM-Lösungen, Accessibility-Software, Overlay-Software und Entwicklerwerkzeuge können legitime Cross-Process-Aktivität erzeugen.
• Quelle und Ziel bewerten. Ein Entwicklungswerkzeug, das auf seinen eigenen Kindprozess zugreift, ist anders zu bewerten als ein Office-Prozess oder Skript-Host, der einen privilegierten Systemprozess öffnet.
• Allowlisting spezifisch halten. Gute Ausnahmen kombinieren mehrere Merkmale wie Signer, SourceImage, TargetImage, Pfad, GrantedAccess und Parent Process. Eine breite Ausnahme nur nach Prozessname blendet zu viel aus.
• Priorität. Hochprior sind insbesondere ungewöhnliche Remote Threads in sensiblen Systemprozessen, ProcessTampering-Ereignisse mit unplausiblem Kontext und Cross-Process-Zugriffe mit anschließender verdächtiger Folgeaktivität.

Analysten-Checkliste

Quellprozess

• Welcher Prozess führt den Zugriff durch?
• Ist die Datei bekannt und digital signiert?
• Wo liegt die Datei?
• Wie lautet der Hash?
• Wer hat den Prozess gestartet?
• Wie sieht die Parent-Process-Kette aus?
• Ist die Command Line plausibel?

Zielprozess

• Welcher Prozess wird geöffnet oder manipuliert?
• Ist diese Source-Target-Beziehung in der Umgebung zu erwarten?
• Läuft der Zielprozess mit höheren Privilegien?
• Ist der Zielprozess sicherheitskritisch?

Access und Threads

• Welche GrantedAccess-Rechte wurden vergeben?
• Gibt es Speicher-Schreibrechte oder Thread-Rechte?
• Wurde ein Remote Thread erzeugt?
• Wie lauten StartAddress und StartModule?
• Gehört die Startadresse zu einem erwarteten Modul?

Speicher und Folgeaktivität

• Gibt es Private Executable Memory, RWX oder auffällige RW-zu-RX-Übergänge?
• Existiert ein Image-/Memory-Mismatch?
• Folgen Netzwerkverbindungen, Credential Access, Persistence, Discovery oder weitere Prozessstarts?

Beispiel einer Untersuchung

Angenommen, Sysmon Event 10 zeigt einen Zugriff von C:\Users\User\AppData\Local\Temp\update.exe auf C:\Windows\explorer.exe. Kurz darauf folgt Event 8 mit derselben Source- und Target-Beziehung.

Die Untersuchung sollte dann nicht bei Event 8 enden. Prüfe zunächst Hash, Signatur, Erstellungszeit, Dateipfad, Parent Process und mögliche Download-Herkunft von update.exe. Anschließend untersuchst du beim Zielprozess die Thread-Startadresse, das StartModule und – sofern das EDR diese Informationen liefert – die Eigenschaften der zugehörigen Speicherregion.

Danach folgt die Frage, was explorer.exe nach dem Ereignis getan hat. Neue Netzwerkverbindungen, Credential Access, Dateiaktivität, Persistence oder weitere Prozessstarts können zeigen, ob der Injection-Alert Teil einer größeren Angriffskette ist.

Fazit

Process Injection ist keine einzelne Technik, sondern eine Familie unterschiedlicher Verfahren. Remote Thread Injection, DLL Injection, PE Injection, Thread Execution Hijacking, APC Injection und Process Hollowing unterscheiden sich darin, wie der Zielprozess verändert und wie die Ausführung übernommen wird.

Für die Detection bedeutet das: Kein einzelnes Event deckt die gesamte Technikfamilie ab. Sysmon Event 10 kann Cross-Process-Zugriffe zeigen, Event 8 ist besonders für Remote Threads relevant, Event 25 kann Process Tampering sichtbar machen und Event 7 kann bei DLL-bezogenen Verfahren ergänzen. Moderne EDR-Telemetrie liefert zusätzlich Speicher- und Thread-Merkmale.

Process Access
      +
Memory Manipulation
      +
Thread- / Execution-Aktivität
      +
Prozesskontext
      +
Folgeaktivität

Wer diese Signale korreliert und die konkrete Injection-Variante versteht, erkennt Process Injection wesentlich zuverlässiger als mit einer Detection, die nur auf einzelne API-Namen oder einen einzelnen Sysmon-Eventtyp schaut. Weitere Verfahren, mit denen Angreifer unentdeckt bleiben, sammelt das Lexikon nach Taktik unter Stealth.