Process Herpaderping

Process Herpaderping est une méthode permettant de masquer les intentions d’un processus en modifiant le contenu sur disque après que l’image a été mappée. Cela entraîne un comportement curieux de la part des produits de sécurité et du système d’exploitation lui-même.

Résumé

En général, un produit de sécurité réagit à la création d’un processus en enregistrant un rappel dans le noyau Windows (PsSetCreateProcessNotifyRoutineEx). À ce stade, un produit de sécurité peut inspecter le fichier qui a servi à mapper l’exécutable et déterminer si ce processus doit être autorisé à s’exécuter. Ce rappel du noyau est invoqué lorsque le thread initial est inséré, et non lors de la création de l’objet processus.

De ce fait, un acteur peut créer et mapper un processus, modifier le contenu du fichier, puis créer le thread initial. Un produit qui inspecte au moment du rappel de création verrait le contenu modifié. De plus, certains produits utilisent une approche d’analyse à l’écriture qui consiste à surveiller les écritures de fichiers. Une optimisation courante consiste à enregistrer que le fichier a été écrit et à différer l’inspection réelle jusqu’à ce que IRP_MJ_CLEANUP se produise (par exemple, lorsque le descripteur de fichier est fermé). Ainsi, un acteur utilisant un workflow écriture -> mappage -> modification -> exécution -> fermeture contournera l’analyse à l’écriture qui repose uniquement sur l’inspection à IRP_MJ_CLEANUP.

Pour abuser de cette convention, nous écrivons d’abord un binaire dans un fichier cible sur disque. Ensuite, nous mappons une image du fichier cible et la fournissons au système d’exploitation pour qu’il l’utilise lors de la création du processus. Le système d’exploitation mappe gentiment le binaire original pour nous. En utilisant le descripteur de fichier existant, et avant de créer le thread initial, nous modifions le contenu du fichier cible pour obscurcir ou falsifier le fichier soutenant l’image. Quelque temps plus tard, nous créons le thread initial pour commencer l’exécution du binaire original. Enfin, nous fermerons le descripteur du fichier cible. Passons en revue étape par étape :

1. Écrire le binaire cible sur le disque, en gardant le descripteur ouvert. C’est ce qui s’exécutera en mémoire.
2. Mapper le fichier en tant que section d’image (NtCreateSection, SEC_IMAGE).
3. Créer l’objet processus à l’aide du descripteur de section (NtCreateProcessEx).
4. À l’aide du même descripteur de fichier cible, obscurcir le fichier sur le disque.
5. Créer le thread initial dans le processus (NtCreateThreadEx).
   • À ce stade, le rappel de création de processus dans le noyau se déclenche. Le contenu sur le disque ne correspond pas à ce qui a été mappé. L’inspection du fichier à ce moment entraînera une attribution incorrecte.
6. Fermer le descripteur. IRP_MJ_CLEANUP se produira ici.
   • Comme nous avons caché le contenu de ce qui s’exécute, l’inspection à ce stade entraînera une attribution incorrecte.

@startuml
hide empty description

[*] --> CreateFile
CreateFile --> FileHandle
FileHandle --> Write
FileHandle --> NtCreateSection
Write -[hidden]-> NtCreateSection
NtCreateSection --> SectionHandle
SectionHandle --> NtCreateProcessEx
FileHandle --> Modify
NtCreateProcessEx -[hidden]-> Modify
NtCreateProcessEx --> NtCreateThreadEx
Modify -[hidden]-> NtCreateThreadEx
NtCreateThreadEx --> [*]
FileHandle --> CloseFile
NtCreateThreadEx -[hidden]-> CloseFile
NtCreateThreadEx --> PspCallProcessNotifyRoutines
PspCallProcessNotifyRoutines -[hidden]-> [*]
CloseFile --> IRP_MJ_CLEANUP
IRP_MJ_CLEANUP -[hidden]-> [*]
PspCallProcessNotifyRoutines --> Inspect
PspCallProcessNotifyRoutines -[hidden]-> CloseFile 
IRP_MJ_CLEANUP --> Inspect
Inspect -[hidden]-> [*]

CreateFile : Créer le fichier cible, garder le descripteur ouvert.
Write : Écrire la charge utile source dans le fichier cible.
Modify : Obscurcir le fichier sur le disque.
NtCreateSection : Créer une section en utilisant le descripteur de fichier.
NtCreateProcessEx : La section d'image pour le processus est mappée et mise en cache dans l'objet fichier.
NtCreateThreadEx : La section mise en cache est utilisée.
NtCreateThreadEx : Les routines de notification de processus se déclenchent dans le noyau.
Inspect : Le contenu sur le disque ne correspond pas à ce qui a été exécuté. 
Inspect : L'inspection du fichier à ce moment entraînera une attribution incorrecte.
@enduml

Comportement

Vous verrez dans la démo ci-dessous que CMD.exe est utilisé comme cible d’exécution. La première exécution remplace les octets sur le disque par un motif. La deuxième exécution remplace CMD.exe par ProcessHacker.exe. L’outil Herpaderping corrige le binaire pour qu’il ressemble le plus possible à ProcessHacker.exe, en conservant même la signature originale. Notez les exécutions multiples du même binaire et l’apparence du processus pour l’utilisateur par rapport à ce qui se trouve dans le fichier sur le disque.

Approfondir

Nous avons observé le comportement et certains aspects peuvent surprendre. Essayons d’expliquer ce comportement.

Plongée technique approfondie

Contexte et motivation

Lors de la conception de produits de sécurisation des plateformes Windows, de nombreux ingénieurs de ce domaine (dont moi-même) sont tombés dans des idées préconçues concernant la façon dont le système d’exploitation gère les données. Dans ce scénario, certains pourraient s’attendre à ce que le fichier sur disque reste « verrouillé » lorsque le processus est créé. Vous ne pouvez pas supprimer le fichier. Vous ne pouvez pas y écrire. Mais vous pouvez le renommer. Comme on le voit ici, sous certaines conditions, vous pouvez en fait y écrire. Restez vigilant sur vos hypothèses, remettez-les toujours en question et faites vos recherches.

La motivation de cette recherche est venue en découvrant comment effectuer une analyse lorsqu’un fichier est écrit. Avec des recherches antérieures sur le Process Hollowing et le Doppelganging, j’avais théorisé que cela pourrait être possible. L’objectif est d’offrir une meilleure sécurité. On ne peut pas créer une meilleure serrure sans d’abord comprendre comment briser l’ancienne.

Techniques similaires

Herpaderping est similaire au Hollowing et au Doppelganging, mais il existe quelques différences clés :

Process Hollowing

Le Process Hollowing consiste à modifier la section mappée avant le début de l’exécution, ce qui, de manière abstraite, ressemble à : mapper -> modifier la section -> exécuter. Ce workflow entraîne une divergence du flux d’exécution prévu du processus creusé vers un code non prévu. Le Doppelganging peut être considéré comme une forme de Hollowing. Cependant, le Hollowing, à mon avis, est plus proche de l’injection dans la mesure où il implique généralement une écriture explicite dans le code déjà mappé. Cela diffère d’Herpaderping, où il n’y a pas de sections modifiées.

Process Doppelganging

Le Process Doppelganging est plus proche d’Herpaderping. Le Doppelganging abuse des opérations de fichier transactionnelles et implique généralement ces étapes : transaction -> écriture -> mappage -> annulation -> exécution. Dans ce workflow, le système d’exploitation crée la section d’image et tient compte des transactions, de sorte que la section d’image mise en cache finit par être ce que vous avez écrit dans la transaction. Le système d’exploitation a corrigé cette technique. Enfin, ils ont corrigé le crash qu’elle provoquait. Peut-être considèrent-ils cela comme une utilisation « légale » d’une transaction. Heureusement, Windows Defender détecte la technique Doppelganging. Doppelganging diffère d’Herpaderping en ce sens qu’Herpaderping ne repose pas sur des opérations de fichier transactionnelles. Et Defender ne détecte pas Herpaderping.

Comparaison

Pour référence, les techniques généralisées :

On voit ici les différences. Bien qu’Herpaderping soit sans doute plus bruyant que Doppelganging, dans la mesure où les bits malveillants touchent effectivement le disque, nous avons constaté que les produits de sécurité sont encore incapables de détecter Herpaderping.

Solution possible

Il n’y a pas de correctif clair ici. Il semble raisonnable qu’empêcher le mappage/la mise en cache d’une section d’image lorsqu’il y a un accès en écriture au fichier devrait colmater la brèche. Cependant, cela peut ou non être une solution pratique.

Une autre option pourrait consister à vider les modifications apportées au fichier dans la section d’image mise en cache si elle n’a pas encore été mappée dans un processus. Cependant, comme le mappage dans le nouveau processus se produit lors de NtCreateProcess, ce n’est probablement pas une solution viable.

D’un point de vue détection, il n’existe pas de bon moyen d’identifier les bits réels qui ont été mappés ; l’inspection à IRP_MJ_CLEANUP ou via un rappel enregistré avec PsSetCreateProcessNotifyRoutineEx entraîne une attribution incorrecte car les bits sur le disque ont été modifiés ; il faudrait reconstruire le fichier à partir de la section qui a été créée. Il convient de noter ici qu’il existe un nouveau rappel dans Windows 10 que vous pouvez enregistrer avec PsSetCreateProcessNotifyRoutineEx2, mais il souffre du même problème que le rappel précédent : il est appelé lorsque le thread initial est exécuté, et non lorsque l’objet processus est créé. Microsoft a ajouté PsSetCreateThreadNotifyRoutineEx qui est appelé lorsque le thread initial est inséré s’il est enregistré avec PsCreateThreadNotifyNonSystem, contrairement à quand il est sur le point de commencer son exécution (comme le faisait l’ancien rappel). Étendre PSCREATEPROCESSNOTIFYTYPE pour qu’il soit appelé lors de la création de l’objet processus ne servirait pas non plus à grand-chose ; nous avons vu dans la section Approfondir que l’objet section d’image est mis en cache lors de l’appel à NtCreateSection et non de NtCreateProcess.

Nous ne pouvons pas facilement identifier ce qui a été exécuté. Il ne nous reste plus qu’à essayer de détecter le comportement d’exploitation de l’acteur ; je laisse la découverte des indicateurs de comportement comme exercice pour le lecteur.

Plateformes connues affectées

Voici une liste de produits et de systèmes d’exploitation Windows qui ont été testés au (31/08/2020). Les tests ont été effectués avec un binaire malveillant connu.

Divulgation responsable

Cette vulnérabilité a été divulguée au Microsoft Security Response Center (MSRC) le 17/07/2020 et un dossier a été ouvert par MSRC le 22/07/2020. MSRC a conclu son enquête le 25/08/2020 et a déterminé que les conclusions étaient valides mais ne répondaient pas à leurs critères de maintenance immédiate. À ce jour, leur dossier est clos, sans résolution, et marqué pour un examen futur, sans calendrier.

Nous ne sommes pas d’accord sur la gravité de ce bogue ; cela a été communiqué à MSRC le 27/08/2020.

1. Il existe des vulnérabilités similaires dans cette classe (Hollowing et Doppelganging).
2. La vulnérabilité s’avère capable de contourner les fonctionnalités de sécurité inhérentes au système d’exploitation (Windows Defender).
3. La vulnérabilité permet à un acteur d’obtenir l’exécution de code arbitraire.
4. L’utilisateur n’est pas averti de l’exécution de code non prévu.
5. Les informations sur le processus présentées à l’utilisateur ne reflètent pas précisément ce qui est exécuté.
6. Les moyens d’identifier précisément le processus ne sont pas intuitifs ou sont incorrects, même depuis le noyau.

Source

Ce dépôt contient un outil pour exercer la méthode Herpaderping d’obscurcissement de processus. L’utilisation est la suivante :

Process Herpaderping Tool - Copyright (c) Johnny Shaw
ProcessHerpaderping.exe SourceFile TargetFile [ReplacedWith] [Options...]
Usage:
  SourceFile               Fichier source à exécuter.
  TargetFile               Fichier cible à partir duquel exécuter la source.
  ReplacedWith             Fichier pour remplacer la cible. Optionnel,
                           par défaut remplace le binaire par un motif.
  -h,--help                Affiche l'utilisation de l'outil.
  -d,--do-not-wait         N'attend pas la fin du processus créé,
                           par défaut attend.
  -l,--logging-mask number Spécifie le masque de journalisation, par défaut
                           journalisation complète.
                               0x1   Succès
                               0x2   Informations
                               0x4   Avertissements
                               0x8   Erreurs
                               0x10  Contextuel
  -q,--quiet               Fonctionne silencieusement, remplace le masque de journalisation, pas de titre.
  -r,--random-obfuscation  Utilise des octets aléatoires plutôt qu'un motif pour
                           l'obscurcissement du fichier.
  -e,--exclusive           Le fichier cible est créé avec un accès exclusif et
                           le descripteur est maintenu ouvert le plus longtemps possible.
                           Sans cette option, le descripteur a un accès complet en partage
                           et est fermé dès que possible.
  -u,--do-not-flush-file   Ne vide pas le fichier après la réécriture.
  -c,--close-file-early    Ferme le fichier avant la création du thread (avant que
                           le rappel de notification de processus ne se déclenche dans le noyau).
                           Non valide avec l'option "--exclusive".
  -k,--kill                Termine le processus créé quel que soit le
                           succès ou l'échec, utile dans certains environnements
                           d'automatisation. Force l'option "--do-not-wait".

Clonage et compilation

Le dépôt utilise des sous-modules ; après avoir cloné, assurez-vous d’initialiser et de mettre à jour les sous-modules. Les fichiers de projet ciblent Visual Studio 2019.

git clone https://github.com/jxy-s/herpaderping.git
cd .\herpaderping\
git submodule update --init --recursive
MSBuild .\herpaderping.sln

Crédits

Les éléments suivants sont utilisés sans modification. Crédits à leurs auteurs.

• Windows Implementation Libraries (WIL)
  Une bibliothèque C++ uniquement en-tête créée pour faciliter la vie des développeurs sur Windows grâce à des interfaces C++ typées et sûres pour les modèles de codage Windows courants.
• Process Hacker Native API Headers
  Collection de fichiers d’en-tête d’API Native. Rassemblés à partir des fichiers d’en-tête Microsoft et des fichiers de symboles, ainsi que d’une grande quantité de rétro-ingénierie et de suppositions.