Questions entretien ingénieur sécurité junior

Introduction

Un entretien d'ingénieur sécurité junior vérifie souvent si vous savez expliquer les bases et les appliquer à des situations concrètes : prioriser des vulnérabilités, lire des alertes SIEM, sécuriser les mots de passe, vérifier TLS et répondre calmement à un incident.

Utilisez ces questions pour préparer des réponses courtes qui relient le concept à l'action que vous mèneriez sur le terrain.

Fondamentaux de la sécurité

1. Expliquez la Triade CIA.

Réponse : La Triade CIA est le fondement de la sécurité de l'information :

Confidentialité :

Seuls les utilisateurs autorisés peuvent accéder aux données
Réalisée grâce à : chiffrement, contrôles d'accès, authentification

Intégrité :

Les données restent exactes et non modifiées
Réalisée grâce à : hachage, signatures numériques, sommes de contrôle

Disponibilité :

Les systèmes et les données sont accessibles en cas de besoin
Réalisée grâce à : redondance, sauvegardes, protection DDoS

Loading diagram...

Exemples de violations :

Confidentialité : Violation de données exposant les informations des clients
Intégrité : Attaquant modifiant les registres financiers
Disponibilité : Attaque DDoS mettant hors service un site web

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

OWASP Top 10

2. Nommez trois éléments du Top 10 de l'OWASP et expliquez-les.

Réponse : Le Top 10 de l'OWASP répertorie les risques de sécurité les plus critiques pour les applications web :

1. Injection (Injection SQL) : Un attaquant insère du code malveillant dans les requêtes.

# Code vulnérable
username = request.GET['username']
query = f"SELECT * FROM users WHERE username = '{username}'"
# Attaque : username = "admin' OR '1'='1"

# Code sécurisé (requête paramétrée)
cursor.execute("SELECT * FROM users WHERE username = %s", (username,))

2. Contrôle d'accès déficient : Les utilisateurs peuvent accéder à des ressources auxquelles ils ne devraient pas avoir accès.

# Vulnérable : Pas de vérification d'autorisation
@app.route('/admin/users/<user_id>')
def get_user(user_id):
    return User.query.get(user_id)

# Sécurisé : Vérification d'autorisation
@app.route('/admin/users/<user_id>')
@require_admin
def get_user(user_id):
    if not current_user.is_admin:
        abort(403)
    return User.query.get(user_id)

3. Cross-Site Scripting (XSS) : Un attaquant injecte des scripts malveillants dans des pages web.

<!-- Vulnérable -->
<div>Bienvenue, {{ username }}</div>

<!-- Attaque -->
username = "<script>alert('XSS')</script>"

<!-- Sécurisé (échapper la sortie) -->
<div>Bienvenue, {{ username | escape }}</div>

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

3. Comment effectuez-vous la gestion des vulnérabilités ?

Réponse : La gestion des vulnérabilités est un processus continu d'identification, d'évaluation et de correction des faiblesses de sécurité. Une bonne réponse junior mentionne l'inventaire des actifs, la sévérité, l'exploitabilité, l'exposition, l'impact métier, le responsable de correction et la vérification.

Ne vous appuyez pas uniquement sur le score CVSS. Priorisez les failles exploitées activement, exposées à internet, présentes sur des actifs critiques ou faciles à chaîner avec d'autres faiblesses.

Processus :

Loading diagram...

Analyse des vulnérabilités :

# Analyse des vulnérabilités avec Nmap
nmap --script vuln 192.168.1.100

# Analyse OpenVAS
openvas-start
# Accéder à l'interface web à https://localhost:9392

# Analyse Nessus (commercial)
# Configurer via l'interface web

Exemple Nessus :

# Automatiser l'analyse Nessus
import requests
import time

class NessusScanner:
    def __init__(self, url, access_key, secret_key):
        self.url = url
        self.headers = {
            'X-ApiKeys': f'accessKey={access_key}; secretKey={secret_key}'
        }
    
    def create_scan(self, name, targets):
        data = {
            'uuid': 'template-uuid',  # Analyse réseau de base
            'settings': {
                'name': name,
                'text_targets': targets
            }
        }
        response = requests.post(
            f'{self.url}/scans',
            headers=self.headers,
            json=data,
            verify=False
        )
        return response.json()['scan']['id']
    
    def launch_scan(self, scan_id):
        requests.post(
            f'{self.url}/scans/{scan_id}/launch',
            headers=self.headers,
            verify=False
        )
    
    def get_results(self, scan_id):
        response = requests.get(
            f'{self.url}/scans/{scan_id}',
            headers=self.headers,
            verify=False
        )
        return response.json()

# Utilisation
scanner = NessusScanner('https://nessus:8834', 'access_key', 'secret_key')
scan_id = scanner.create_scan('Analyse hebdomadaire', '192.168.1.0/24')
scanner.launch_scan(scan_id)

Gestion des correctifs :

# Gestion des correctifs Linux
# Ubuntu/Debian
sudo apt update
sudo apt list --upgradable
sudo apt upgrade -y

# CentOS/RHEL
sudo yum check-update
sudo yum update -y

# Application automatisée des correctifs
sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

Matrice de priorisation :

Score CVSS	Exploitation	Criticité de l'actif	Priorité
Critique (9-10)	Exploit public	Production	P1 (Immédiate)
Élevé (7-8.9)	PoC disponible	Production	P2 (1 semaine)
Moyen (4-6.9)	Pas d'exploit	Interne	P3 (1 mois)
Faible (0-3.9)	Pas d'exploit	Dev/Test	P4 (Prochain cycle)

Suivi de la correction :

# Suivi des vulnérabilités
class VulnerabilityTracker:
    def __init__(self):
        self.vulnerabilities = []
    
    def add_vulnerability(self, vuln):
        self.vulnerabilities.append({
            'id': vuln['id'],
            'severity': vuln['severity'],
            'asset': vuln['asset'],
            'status': 'open',
            'discovered': datetime.now(),
            'sla_deadline': self.calculate_sla(vuln['severity'])
        })
    
    def calculate_sla(self, severity):
        sla_days = {
            'critical': 7,
            'high': 30,
            'medium': 90,
            'low': 180
        }
        return datetime.now() + timedelta(days=sla_days[severity])
    
    def get_overdue(self):
        return [v for v in self.vulnerabilities 
                if v['status'] == 'open' and 
                datetime.now() > v['sla_deadline']]

Fréquence : Courant Difficulté : Facile-Moyenne

Bases du chiffrement

4. Quelle est la différence entre le chiffrement symétrique et asymétrique ?

Réponse :

Chiffrement symétrique :

La même clé est utilisée pour le chiffrement et le déchiffrement
Rapide
Exemples : AES, DES, 3DES

Chiffrement asymétrique :

La clé publique chiffre, la clé privée déchiffre
Plus lent
Exemples : RSA, ECC

# Chiffrement symétrique (AES)
from cryptography.fernet import Fernet

# Générer une clé
key = Fernet.generate_key()
cipher = Fernet(key)

# Chiffrer
encrypted = cipher.encrypt(b"Message secret")

# Déchiffrer
decrypted = cipher.decrypt(encrypted)

# Chiffrement asymétrique (RSA)
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography.hazmat.primitives import serialization

# Générer une paire de clés
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()

# Chiffrer avec la clé publique, déchiffrer avec la clé privée

Cas d'utilisation :

Symétrique : Chiffrer de grandes quantités de données (fichiers, bases de données)
Asymétrique : Échange de clés, signatures numériques, SSL/TLS

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

5. Comment fonctionne SSL/TLS et comment gérez-vous les certificats ?

Réponse : SSL/TLS chiffre les données en transit entre le client et le serveur.

Handshake TLS :

Loading diagram...

Comment ça marche :

Client Hello : Le client envoie les suites de chiffrement prises en charge
Server Hello : Le serveur choisit le chiffrement, envoie le certificat
Vérification du certificat : Le client valide la chaîne de certificats
Échange de clés : Établir un secret partagé
Communication chiffrée : Utiliser le chiffrement symétrique

Composants du certificat :

# Afficher les détails du certificat
openssl x509 -in certificate.crt -text -noout

# Le certificat contient :
# - Sujet (nom de domaine)
# - Émetteur (CA)
# - Période de validité
# - Clé publique
# - Signature

Gestion des certificats :

Générer une CSR (Certificate Signing Request) :

# Générer une clé privée
openssl genrsa -out private.key 2048

# Générer une CSR
openssl req -new -key private.key -out request.csr

# Afficher la CSR
openssl req -text -noout -verify -in request.csr

Certificat auto-signé (Test) :

# Générer un certificat auto-signé
openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes

# Combiner pour l'utilisation du serveur
cat cert.pem key.pem > server.pem

Installer le certificat :

# Nginx
server {
    listen 443 ssl;
    server_name example.com;
    
    ssl_certificate /etc/nginx/ssl/cert.pem;
    ssl_certificate_key /etc/nginx/ssl/key.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
}

# Apache
<VirtualHost *:443>
    ServerName example.com
    
    SSLEngine on
    SSLCertificateFile /etc/apache2/ssl/cert.pem
    SSLCertificateKeyFile /etc/apache2/ssl/key.pem
    SSLCertificateChainFile /etc/apache2/ssl/chain.pem
    
    SSLProtocol all -SSLv3 -TLSv1 -TLSv1.1
    SSLCipherSuite HIGH:!aNULL:!MD5
</VirtualHost>

Mauvaises configurations courantes :

1. Protocoles faibles :

# Mauvais : Autorise SSLv3, TLSv1.0
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;

# Bon : Uniquement TLS moderne
ssl_protocols TLSv1.2 TLSv1.3;

2. Chiffrements faibles :

# Tester la configuration SSL
sslscan example.com
nmap --script ssl-enum-ciphers -p 443 example.com

# Ou utiliser des outils en ligne
# https://www.ssllabs.com/ssltest/

3. Certificats expirés :

# Vérifier l'expiration du certificat
openssl s_client -connect example.com:443 -servername example.com < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates

# Surveiller l'expiration
echo | openssl s_client -servername example.com -connect example.com:443 2>/dev/null | \
    openssl x509 -noout -enddate

Automatisation des certificats (Let's Encrypt) :

# Installer certbot
sudo apt install certbot python3-certbot-nginx

# Obtenir un certificat
sudo certbot --nginx -d example.com -d www.example.com

# Auto-renouvellement (cron)
0 0 * * * certbot renew --quiet

Dépannage :

# Tester la connexion TLS
openssl s_client -connect example.com:443 -servername example.com

# Vérifier la chaîne de certificats
openssl verify -CAfile ca-bundle.crt certificate.crt

# Vérifier que le certificat correspond à la clé privée
openssl x509 -noout -modulus -in cert.pem | openssl md5
openssl rsa -noout -modulus -in key.pem | openssl md5
# Les hachages doivent correspondre

Fréquence : Courant Difficulté : Moyenne

Pare-feu

6. Expliquez les pare-feu avec état et sans état.

Réponse :

Pare-feu sans état :

Examine chaque paquet indépendamment
Pas de suivi de connexion
Plus rapide mais moins sécurisé
Exemple : Filtre de paquets de base

Pare-feu avec état :

Suit l'état de la connexion
Se souvient des paquets précédents
Plus sécurisé
Exemple : Pare-feu modernes

# iptables (avec état)
# Autoriser les connexions établies
iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT

# Autoriser les nouvelles connexions SSH
iptables -A INPUT -p tcp --dport 22 -m state --state NEW -j ACCEPT

# Rejeter tout le reste
iptables -A INPUT -j DROP

États de connexion :

NEW : Premier paquet de la connexion
ESTABLISHED : Fait partie d'une connexion existante
RELATED : Lié à une connexion existante
INVALID : Ne correspond à aucun état

Fréquence : Courant Difficulté : Moyenne

SIEM

7. Qu'est-ce qu'un SIEM et pourquoi est-ce important ?

Réponse : SIEM (Security Information and Event Management) centralise la collecte et l'analyse des journaux.

Fonctions principales :

Collecte des journaux : Rassembler les journaux de plusieurs sources
Normalisation : Standardiser les formats de journaux
Corrélation : Identifier les schémas et les relations
Alertes : Notifier en cas d'activité suspecte
Rapports : Conformité et analyse forensique

Loading diagram...

Cas d'utilisation :

Détecter les attaques par force brute
Identifier l'exfiltration de données
Surveiller l'accès privilégié
Rapports de conformité (PCI-DSS, HIPAA)

Outils SIEM populaires :

Splunk
ELK Stack (Elasticsearch, Logstash, Kibana)
IBM QRadar
ArcSight

Fréquence : Courant Difficulté : Moyenne

8. Quelle est la différence entre IDS et IPS ?

Réponse : IDS (Intrusion Detection System) et IPS (Intrusion Prevention System) surveillent le trafic réseau à la recherche de menaces.

Différences clés :

Caractéristique	IDS	IPS
Action	Détecte et alerte	Détecte et bloque
Placement	Hors bande (passif)	En ligne (actif)
Impact	Pas d'interruption du trafic	Peut bloquer le trafic légitime
Réponse	Manuelle	Automatique
Faux positifs	Moins critiques	Plus critiques

Déploiement IDS :

Loading diagram...

Déploiement IPS :

Loading diagram...

Configuration Snort (IDS/IPS) :

# Installer Snort
sudo apt install snort

# Configurer le réseau
sudo vi /etc/snort/snort.conf
# Définir HOME_NET
ipvar HOME_NET 192.168.1.0/24
ipvar EXTERNAL_NET !$HOME_NET

# Exécuter en mode IDS
sudo snort -A console -q -c /etc/snort/snort.conf -i eth0

# Exécuter en mode IPS (en ligne)
sudo snort -Q -c /etc/snort/snort.conf -i eth0

Règles Snort :

# Syntaxe des règles
# action protocol src_ip src_port -> dst_ip dst_port (options)

# Détecter l'injection SQL
alert tcp any any -> $HOME_NET 80 (msg:"Tentative d'injection SQL"; \
    content:"UNION SELECT"; nocase; sid:1000001; rev:1;)

# Détecter le scan de ports
alert tcp any any -> $HOME_NET any (msg:"Scan de ports détecté"; \
    flags:S; threshold:type both, track by_src, count 20, seconds 60; \
    sid:1000002; rev:1;)

# Détecter la force brute SSH
alert tcp any any -> $HOME_NET 22 (msg:"Force brute SSH"; \
    flags:S; threshold:type both, track by_src, count 5, seconds 60; \
    sid:1000003; rev:1;)

# Bloquer l'IP malveillante (mode IPS)
drop tcp 203.0.113.50 any -> $HOME_NET any (msg:"IP malveillante bloquée"; \
    sid:1000004; rev:1;)

Suricata (Alternative moderne) :

# Installer Suricata
sudo apt install suricata

# Mettre à jour les règles
sudo suricata-update

# Exécuter Suricata
sudo suricata -c /etc/suricata/suricata.yaml -i eth0

# Afficher les alertes
sudo tail -f /var/log/suricata/fast.log

Analyse des alertes :

# Analyser les alertes Snort
import re
from collections import Counter

def analyze_snort_alerts(log_file):
    alerts = []
    
    with open(log_file, 'r') as f:
        for line in f:
            # Analyser l'alerte
            match = re.search(r'\[\*\*\] \[(\d+):(\d+):(\d+)\] (.+?) \[\*\*\]', line)
            if match:
                alerts.append({
                    'sid': match.group(1),
                    'message': match.group(4),
                    'line': line
                })
    
    # Top alertes
    alert_counts = Counter([a['message'] for a in alerts])
    print("Top 10 des alertes :")
    for alert, count in alert_counts.most_common(10):
        print(f"{count:5d} - {alert}")
    
    return alerts

# Utilisation
alerts = analyze_snort_alerts('/var/log/snort/alert')

Signatures d'attaque courantes :

# Injection SQL
content:"' OR 1=1--";
content:"UNION SELECT";

# XSS
content:"<script>";
content:"javascript:";

# Injection de commande
content:";cat /etc/passwd";
content:"|whoami";

# Traversée de répertoire
content:"../../../";

# Shellshock
content:"() { :; };";

Bonnes pratiques :

Mettre à jour régulièrement les signatures
Ajuster les règles pour réduire les faux positifs
Surveiller l'IPS pour le trafic légitime bloqué
Intégrer avec SIEM pour la corrélation
Tester en mode IDS avant d'activer IPS

Fréquence : Courant Difficulté : Moyenne

Bonnes pratiques de sécurité

9. Comment sécuriser les mots de passe ?

Réponse : Sécurité des mots de passe multicouche :

1. Hachage (pas de chiffrement) :

import hashlib
import os

def hash_password(password):
    # Générer un sel
    salt = os.urandom(32)
    
    # Hacher le mot de passe avec le sel
    key = hashlib.pbkdf2_hmac(
        'sha256',
        password.encode('utf-8'),
        salt,
        100000  # itérations
    )
    
    # Stocker le sel + le hachage
    return salt + key

def verify_password(stored_password, provided_password):
    salt = stored_password[:32]
    stored_key = stored_password[32:]
    
    key = hashlib.pbkdf2_hmac(
        'sha256',
        provided_password.encode('utf-8'),
        salt,
        100000
    )
    
    return key == stored_key

2. Politique de mot de passe :

Privilégier les mots de passe ou phrases de passe longs plutôt que la complexité imposée
Autoriser les gestionnaires de mots de passe, le collage et l'autofill
Bloquer les mots de passe compromis ou trop courants
Exiger le MFA quand c'est possible
Forcer un changement en cas d'indice de compromission, pas seulement à date fixe

3. Sécurité supplémentaire :

Authentification multi-facteurs (MFA)
Verrouillage du compte après des tentatives infructueuses
Indicateur de force du mot de passe
Détection des violations (API Have I Been Pwned)

Ne jamais :

Stocker les mots de passe en texte clair
Utiliser un hachage faible (MD5, SHA1)
Hacher sans sel

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

Réponse aux incidents

10. Quelles sont les phases de la réponse aux incidents ?

Réponse : Cycle de vie de la réponse aux incidents du NIST :

1. Préparation :

Élaborer un plan de RI
Former l'équipe
Mettre en place des outils et une surveillance

2. Détection et analyse :

Identifier les incidents
Analyser la portée et l'impact
Prioriser la réponse

3. Confinement :

Court terme : Isoler les systèmes affectés
Long terme : Appliquer des correctifs, reconstruire les systèmes

4. Éradication :

Supprimer les logiciels malveillants
Fermer les vulnérabilités
Renforcer les défenses

5. Récupération :

Restaurer les systèmes
Surveiller la réinfection
Retour aux opérations normales

6. Post-incident :

Documenter les leçons apprises
Mettre à jour les procédures
Améliorer les défenses

Loading diagram...

Fréquence : Courant Difficulté : Moyenne

Conclusion

Pour un entretien d'ingénieur sécurité junior, préparez-vous à expliquer les bases et à montrer comment vous les appliqueriez dans un vrai environnement. Concentrez-vous sur :

Fondamentaux : Triade CIA, moindre privilège, authentification, autorisation
OWASP : Contrôle d'accès défaillant, erreurs cryptographiques, injection, journalisation et surveillance
Gestion des vulnérabilités : Contexte des actifs, exploitabilité, correction, vérification
Cryptographie et TLS : Chiffrement, hachage, certificats, paramètres modernes
Outils défensifs : Pare-feu, SIEM, IDS/IPS, réglage des alertes
Sécurité des mots de passe : Hachage, sels, MFA, contrôle des mots de passe compromis
Réponse aux incidents : Préparation, détection, confinement, récupération, retour d'expérience

Entraînez-vous avec des exemples concrets issus de labs, projets, stages ou environnements personnels. Les recruteurs n'attendent pas la maîtrise de tous les outils, mais un raisonnement clair, une bonne priorisation et une communication honnête.

Conseils carrière récents

Questions d'entretien ingénieur sécurité junior

Introduction

Fondamentaux de la sécurité

1. Expliquez la Triade CIA.

OWASP Top 10

2. Nommez trois éléments du Top 10 de l'OWASP et expliquez-les.

3. Comment effectuez-vous la gestion des vulnérabilités ?

Bases du chiffrement

4. Quelle est la différence entre le chiffrement symétrique et asymétrique ?

5. Comment fonctionne SSL/TLS et comment gérez-vous les certificats ?

Pare-feu

6. Expliquez les pare-feu avec état et sans état.

SIEM

7. Qu'est-ce qu'un SIEM et pourquoi est-ce important ?

8. Quelle est la différence entre IDS et IPS ?

Bonnes pratiques de sécurité

9. Comment sécuriser les mots de passe ?

Réponse aux incidents

10. Quelles sont les phases de la réponse aux incidents ?

Conclusion

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Conseils de carrière hebdomadaires qui fonctionnent vraiment

Articles Connexes

Questions d'entretien pour ingénieur réseau junior

Questions d'entretien Junior SRE avec réponses

Questions d'entretien Azure pour Ingénieur Cloud Junior

Votre Prochain Entretien n'est qu'à un CV

Partager cet article

Doublez Vos Rappels d'Entretien