yara-ttd

# yara-ttd - _Le némésis ultime des packers_

Utilisez les règles YARA sur des traces Time Travel Debugging

1. [Démo](#démo)
2. [Motivations](#motivations)
3. [Installation](#installation)
4. [Utilisation](#utilisation)
5. [Fonctionnalités à venir](#fonctionnalités-à-venir)

## Démo

#### Un binaire packé avec UPX

Un simple binaire qui lance calc.exe, packé avec [UPX](https://upx.github.io).
_yara-ttd_ trouve la chaîne `calc.exe` dans la mémoire du module, lors de la création d'un thread.

<img src="https://assets.kitploit.com/production/public/readmes/48539/eb22ee3a9c058b24bf62918c4d75e3cfb284384e614bcf0f7941583d47475e7f.gif" alt="Démo UPX" />

#### Un simple shellcode obfusqué qui exécute `calc.exe`

Le binaire testé déchiffre un shellcode et l'exécute dans un nouveau thread.
_yara-ttd_ parvient à trouver la chaîne `calc.exe` sur le tas en hookant la fonction `ntdll!NtCreateThreadEx`.

<img src="https://assets.kitploit.com/production/public/readmes/48539/07bf1a05242597f725a3187bbf1c5edc91f8c1e2c7e97a4ef6d36b1dbb19c3ac.gif" alt="Démo shellcode" />

## Motivations

### YARA

[YARA](https://virustotal.github.io/yara/) est un puissant outil de correspondance de motifs pour les binaires.

> YARA est un outil destiné (mais pas uniquement) à aider les chercheurs en malware à identifier et à classer des échantillons de malware. Avec YARA, vous pouvez créer des descriptions de familles de malwares (ou de tout ce que vous voulez décrire) sur la base de motifs textuels ou binaires.
>
> -- <cite>[Documentation YARA](https://virustotal.github.io/yara/)</cite>

Grâce à YARA, nous pouvons gagner beaucoup de temps en classant automatiquement les échantillons de malware dans un pipeline avant de les analyser.

### Packers

Malheureusement, la plupart des échantillons de malware sont protégés par différents types de **packers**. Un schéma classique de packer à l'exécution, comme [UPX](https://upx.github.io/) ou [VMProtect](https://vmpsoft.com/), consiste à s'auto-extraire et à exécuter du code obfusqué et parfois chiffré.
Par conséquent, YARA ne peut pas traiter les binaires packés car il ne trouvera aucune correspondance dans le code packé.

### Time Travel Debugging

[Time Travel Debugging](https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/time-travel-debugging-overview) — ou TTD — est une fonctionnalité du débogueur natif Windows WinDbg.

> Time Travel Debugging est un outil qui vous permet de capturer une trace de votre processus lors de son exécution, puis de la rejouer plus tard, à la fois en avant et en arrière. Le Time Travel Debugging (TTD) peut vous aider à déboguer des problèmes plus facilement en vous permettant de « rembobiner » votre session de débogage, au lieu d'avoir à reproduire le problème jusqu'à ce que vous trouviez le bug.
>
> -- <cite>[Documentation Microsoft](https://learn.microsoft.com/en-us/windows-hardware/drivers/debugger/time-travel-debugging-overview#what-is-time-travel-debugging)</cite>

Pour l'analyse de malwares, TTD est un outil puissant car il permet d'enregistrer la trace d'un malware dans un sandbox. Ainsi, nous pouvons rejouer et partager en toute sécurité le fichier enregistré en dehors du sandbox pour analyser le malware.
De plus, TTD n'est pas un débogueur, il ne sera donc pas détecté par les techniques classiques anti-débogage telles que `PEB.BeingDebugged`.
Pour une analyse plus approfondie de TTD d'un point de vue sécurité, consultez cet article : [Deep dive into the TTD ecosystem](https://www.elastic.co/security-labs/deep-dive-into-the-ttd-ecosystem)

Bien sûr, TTD est un logiciel propriétaire, et ce travail n'aurait pas pu exister sans les [ttd-bindings développés par commial](https://github.com/commial/ttd-bindings).

### yara-ttd

L'idée derrière `yara-ttd` est d'utiliser les fichiers de trace enregistrés par TTD avec `yara` lui-même pour vaincre les packers.

Comme `yara` ne peut pas scanner le binaire packé lui-même, `yara-ttd` offre un moyen d'analyser le fichier de trace qui contient toutes les informations d'exécution, y compris le processus de dépacking.

Avec `yara-ttd`, vous pouvez sélectionner un ensemble de positions dans le fichier de trace où vous souhaitez scanner la mémoire avec vos règles yara.
Ainsi, vous pouvez hooker le binaire packé où vous voulez avec vos règles yara !

`yara-ttd` fournit plusieurs stratégies de scan mémoire, comme lors du chargement des modules, ou lors de l'allocation de mémoire virtuelle, qui sont souvent utilisées pour stocker le code du malware une fois celui-ci dépacké.

## Installation

Pour l'instant, `yara-ttd` ne prend en charge que Windows, car il doit interagir avec l'API TTD.

Commencez par compiler le projet :

```bash
mkdir build
cd build
cmake ..
cmake --build .
```

Ensuite, placez les fichiers `TTDReplay.dll` et `TTDReplayCPU.dll` dans le même répertoire que l'exécutable.
Vous trouverez ces fichiers DLL dans `%LocalAppData%\Microsoft\WindowsApps\Microsoft.WinDbg_X\TTD`

## Utilisation

Vous devez d'abord enregistrer une trace (fichier `.run`) de votre programme.
Pour une aide détaillée sur la façon d'enregistrer une trace TTD, consultez [ce tutoriel](https://github.com/airbus-cert/ttddbg/blob/main/HOWTO_TIME_TRAVEL.md).

Puis exécutez simplement :

```
.\yara-ttd path\to\rule path\to\trace\file
```

### Modes de mémoire

Il existe trois modes pour scanner la mémoire :

- Mode 0 (par défaut) : mémoire des modules chargés
- Mode 1 : mémoire virtuelle allouée + mémoire des modules chargés
- Mode 2 : mémoire complète (peut être très longue)

Vous pouvez sélectionner le mode avec `-m` :

```
.\yara-ttd -m 1 path\to\rule path\to\trace\file
```

Comme pour la CLI officielle de _yara_, vous pouvez utiliser l'option `-s` pour afficher les détails des correspondances, comme l'adresse mémoire et la sous-règle exacte qui a correspondu.

##### Remarques sur le mode mémoire virtuelle allouée :

Comme TTD ne stocke pas la structure mémoire, `yara-ttd` calcule avant le scan la structure des adresses du tas pour chaque position temporelle.
Il crée un fichier cache avec l'extension `.tmp` dans le même répertoire que le fichier de trace pour stocker la structure du tas.
Si vous souhaitez relancer yara-ttd sur une trace et charger la structure du tas depuis le fichier cache généré, il vous suffit de faire :

```bash
.\yara-ttd -m 1 --cache=path\to\cache\file path\to\rule path\to\trace\file
```

##### Remarque sur le mode mémoire complète :

Avec TTD, nous pouvons accéder à la plage mémoire complète d'un processus, ce qui correspond aux adresses min et max renvoyées par `GetSystemInfo`. Néanmoins, la plupart du temps, cette plage est trop importante pour être scannée sans optimisation.

### Modes temporels

Les positions temporelles scannées par défaut sont :

- Événements d'exception
- Événements de chargement de module
- Événements de création de thread

Avec les options `-t` et `-f`, vous pouvez sélectionner d'autres positions ou appels de fonction à scanner :

```bash
.\yara-ttd -m 1 -t 3C1:A -t 5FF:22 -f ntdll!FreeVirtualMemory -f ntdll!NtCreateThreadEx path\to\rule path\to\trace\file
```

L'option `-t` attend des positions TTD au format `major:minor` (toutes deux en hexadécimal, sans `0x`).
L'option `-f` attend une chaîne de la forme `module_name!function_name`.

Vous pouvez également ajouter toutes les fonctions que vous souhaitez hooker dans un fichier :

```bash
> cat .\functions.txt
ntdll!FreeVirtualMemory
ntdll!NtCreateThreadEx

> .\yara-ttd -m 1 -F functions.txt path\to\rule path\to\trace\file
```

### Scanner plusieurs fichiers de trace

Si vous avez plusieurs fichiers à scanner avec `yara-ttd`, vous pouvez également scanner un répertoire entier.
`yara-ttd` ignorera toutes les extensions suivantes dans le dossier :

- `.tmp` (fichiers cache générés par `yara-ttd`)
- `.idx` (fichiers d'index générés par `ttd`)
- `.err` (fichiers d'erreur générés par `ttd`)
- `.out` (fichiers journal générés par `ttd`)

Dans l'exemple suivant, `yara-ttd` ne scannera que les fichiers `trace01.run` et `trace02.run`.

```bash
> dir .\traces
trace01.run
trace01.out
trace01.idx
trace02.run
trace01.run.err
trace01.tmp

> .\yara-ttd path\to\rule .\traces
```

Alternativement, vous pouvez spécifier toutes les traces à scanner dans un fichier et utiliser l'option `--scan-list` ou `-l`. Il scannera les fichiers listés, un par ligne :

```bash
> cat .\scan_me.txt
.\traces\trace01.run
.\traces\trace02.run

> .\yara-ttd -l path\to\rule .\scan_me.txt
```

> Lors du scan de plusieurs fichiers, `yara-ttd` exécute les scans les uns après les autres, et non simultanément avec des threads comme la CLI `yara` d'origine.

## Fonctionnalités à venir

- libyarattd avec des bindings Python
- Liaison avec [ttddbg](https://github.com/airbus-cert/ttddbg) et IDA : fonctionnalité qui charge IDA à la fin du scan à la position de la correspondance dans le temps et la mémoire
- TTD : suivre l'enfant lors du fork du processus