Contents

Sécurité du Système Linux ........................................................................................................... 2

Module 1 : Introduction à la sécurité sous Linux ........................................................................ 2
Module 2 : Gestion des utilisateurs et permissions .................................................................... 2
Module 3 : Sécurisation du système et des services .................................................................. 3
Module 4 : Firewall et Sécurité Réseau ...................................................................................... 3
Module 5 : Détection d’intrusion et journalisation...................................................................... 3
Module 6 : Sécurité des applications et conteneurs ................................................................... 3
Module 7 : Chiffrement et authentification avancée................................................................... 3
Module 8 : Tests et audits de sécurité Linux ............................................................................... 3
Module 1 : Introduction à la sécurité sous Linux ............................................................................ 4
1. Principes de la sécurité informatique .................................................................................... 4
2. Menaces courantes sous Linux ............................................................................................. 4
3. Philosophie UNIX et modèle de sécurité sous Linux ............................................................... 5
Résumé du module .................................................................................................................. 6
Exercice pratique ..................................................................................................................... 6
Module 2 : Gestion des utilisateurs et permissions ....................................................................... 6
1. Gestion des utilisateurs et groupes ....................................................................................... 6
2. Permissions de fichiers et répertoires .................................................................................... 7
3. Système ACL (Access Control List) pour permissions avancées ............................................. 8
4. Sécurisation du super-utilisateur et sudo .............................................................................. 9
Exercices pratiques ................................................................................................................ 10
Résumé du module ................................................................................................................ 10
Module 3 : Sécurisation des accès et authentification ................................................................. 10
1. Gestion des mots de passe et politiques de sécurité ............................................................ 10
2. Authentification multi-facteurs (MFA) .................................................................................. 11
3. Sécurisation des connexions SSH ....................................................................................... 12
4. Limitation des tentatives de connexion avec Fail2Ban .......................................................... 13
Exercices pratiques ................................................................................................................ 13
Résumé du module ................................................................................................................ 14
Module 4 : Sécurisation du réseau sous Linux ............................................................................. 14
1. Introduction à la sécurité réseau sous Linux ........................................................................ 14
2. Configuration et gestion du pare-feu avec UFW et iptables ................................................... 14
3. Détection et prévention des intrusions avec Fail2Ban et Suricata ......................................... 15

1
 4. Analyse du trafic réseau avec Netstat et Tcpdump ............................................................... 16
Exercices pratiques ................................................................................................................ 16
Résumé du module ................................................................................................................ 17
Module 5 : Surveillance et audit de la sécurité sous Linux............................................................ 17
1. Introduction à la surveillance et à l’audit de la sécurité ........................................................ 17
2. Gestion et analyse des logs système ................................................................................... 17
3. Audit des événements de sécurité avec Auditd .................................................................... 21
4. Détection d’intrusions avec Tripwire.................................................................................... 24
5. Supervision en temps réel avec Monit ................................................................................. 24
Exercices pratiques ................................................................................................................ 25
Résumé du module ................................................................................................................ 25
Module 6 : Sécurité des applications et conteneurs sous Linux ................................................... 25
1. Introduction à la sécurité des applications et des conteneurs .............................................. 25
2. Sécurisation des applications sous Linux ............................................................................ 26
3. Sécurité des conteneurs Docker ......................................................................................... 30
4. Sécurisation des orchestrateurs de conteneurs (Kubernetes) ............................................... 34
Exercices pratiques ................................................................................................................ 42
Résumé du module ................................................................................................................ 42

Sécurité du Système Linux

Module 1 : Introduction à la sécurité sous Linux

• Principes de la sécurité informatique

• Menaces courantes (malwares, attaques réseau, exploitations de vulnérabilités)

• Philosophie UNIX et modèle de sécurité sous Linux

Module 2 : Gestion des utilisateurs et permissions

• Gestion des utilisateurs et groupes (adduser, usermod, passwd, deluser)

• Permissions de fichiers (chmod, chown, chgrp, umask)

• Système ACL (Access Control Lists) pour des permissions avancées

• Sécurisation du super-utilisateur (sudo, visudo, restriction d’accès)

2
Module 3 : Sécurisation du système et des services
• Vérification et durcissement des configurations (sysctl, limits.conf)

• Désactivation des services inutilisés

• Sécurisation des fichiers critiques (/etc/shadow, /etc/passwd, /etc/sudoers)

• Protection contre les attaques par force brute (fail2ban, DenyHosts)

Module 4 : Firewall et Sécurité Réseau

• Configuration de iptables et nftables

• Utilisation de ufw (Uncomplicated Firewall)

• Sécurisation des connexions SSH (sshd_config, fail2ban)

• VPN et chiffrement des communications (OpenVPN, WireGuard)

Module 5 : Détection d’intrusion et journalisation

• Surveillance avec auditd, psacct et acct

• Analyse des logs (journalctl, rsyslog, logwatch)

• Détection d'intrusion avec Tripwire, Aide, OSSEC

• Introduction aux systèmes de détection d’intrusion (IDS) comme Snort, Suricata

Module 6 : Sécurité des applications et conteneurs

• Sécurisation des bases de données (MySQL, PostgreSQL)

• Sécurisation des serveurs web (Apache, Nginx)

• Introduction aux politiques de sécurité SELinux et AppArmor

• Sécurisation des conteneurs Docker et Kubernetes

Module 7 : Chiffrement et authentification avancée

• Gestion des clés SSH et authentification à deux facteurs (2FA)

• Chiffrement des disques et partitions avec LUKS

• Gestion des certificats SSL/TLS avec Let’s Encrypt

• Sécurisation des mots de passe avec pam_cracklib, passwdqc

Module 8 : Tests et audits de sécurité Linux

• Audit avec Lynis, chkrootkit, rkhunter

• Pentesting d’un système Linux avec Metasploit, Nmap, Nikto

• Meilleures pratiques et plan d’intervention en cas d’incident

3
Module 1 : Introduction à la sécurité sous Linux
1. Principes de la sécurité informatique
La sécurité informatique vise à protéger les systèmes d'information contre les menaces, les intrusions et les
défaillances. Elle repose sur trois piliers fondamentaux :

1. Confidentialité : Seuls les utilisateurs autorisés doivent pouvoir accéder aux données.

o Exemple : chiffrement des fichiers avec GPG ou LUKS.

2. Intégrité : Les données ne doivent pas être modifiées de manière non autorisée.

o Exemple : vérification des fichiers avec sha256sum ou Tripwire.

3. Disponibilité : Les ressources doivent rester accessibles aux utilisateurs légitimes.

o Exemple : protection contre les attaques DDoS avec iptables et fail2ban.

Autres principes importants :

• Authentification : Vérifier l'identité des utilisateurs (ex : mots de passe, biométrie, 2FA).

• Autorisation : Définir les droits d'accès (ex : permissions UNIX, ACLs).

• Traçabilité : Suivre les actions effectuées sur un système (ex : logs avec journalctl et auditd).

2. Menaces courantes sous Linux

Même si Linux est réputé pour sa robustesse, il n'est pas à l'abri des cyberattaques. Voici les menaces les plus
courantes :

a) Malwares et rootkits

• Virus et vers : Moins courants sur Linux mais existent (ex : Linux.Rst-B).

• Rootkits : Logiciels malveillants qui masquent leur présence et fournissent un accès persistant.

o Outils de détection : chkrootkit, rkhunter.

• Cryptojacking : Utilisation illégale des ressources pour miner des cryptomonnaies.

o Outils de détection : htop, ps, netstat.

b) Attaques réseau

• Scan de ports : Détecter les services ouverts (nmap, netcat).

• Attaques par déni de service (DDoS) : Saturation du réseau ou du CPU (hping3, iptables).

• Man-in-the-Middle (MITM) : Interception des communications (ettercap, arp-scan).

• Exploitation de failles dans les services exposés : (ex : attaques sur SSH, Apache).

c) Exploitation des vulnérabilités

4
 • Escalade de privilèges : Un attaquant passe d’un utilisateur classique à root (sudo -l).

• Injection de code : XSS, SQL Injection, Buffer Overflow (sqlmap, gdb).

o XSS (Cross-Site Scripting) : Attaque qui permet d’injecter du code JavaScript malveillant dans une
page web pour voler des informations ou exécuter des actions à l'insu des utilisateurs.

o SQL Injection (SQLi) : Attaque qui consiste à injecter du code SQL malveillant dans une requête
pour manipuler ou extraire des données d’une base de données.

o Buffer Overflow : Attaque où un programme écrit plus de données que prévu dans un espace
mémoire (buffer), pouvant permettre à un attaquant d’exécuter du code arbitraire.

o sqlmap : Outil d’automatisation permettant de détecter et d’exploiter les vulnérabilités d’injection

SQL dans les applications web.

o gdb (GNU Debugger) : Outil permettant d’analyser et de déboguer des programmes, notamment
pour identifier et exploiter des vulnérabilités comme le buffer overflow.

• Failles 0-day : Vulnérabilités inconnues du public et non corrigées.

Protection :

• Mises à jour régulières (apt update && apt upgrade, dnf update).

• Restriction des privilèges (principe du moindre privilège).

• Utilisation d’outils de sécurité (AppArmor, SELinux).

3. Philosophie UNIX et modèle de sécurité sous Linux

Linux hérite de la philosophie UNIX, qui repose sur plusieurs concepts fondamentaux en matière de sécurité.

a) Principe du moindre privilège

• Un utilisateur ne doit avoir que les droits strictement nécessaires pour accomplir sa tâche.

• L’utilisateur root est dangereux → utiliser sudo au lieu de se connecter directement en root.

b) Séparation des responsabilités

• Chaque tâche est réalisée par un programme distinct et spécialisé.

• Un service (ex : serveur web, base de données) tourne sous un utilisateur spécifique avec des permissions
limitées.

c) Modèle de permissions UNIX

Chaque fichier et dossier appartient à un utilisateur et un groupe, et a trois niveaux de permissions :

• Lecture (r)

• Écriture (w)

5
 • Exécution (x)

Exemple d'affichage des permissions (ls -l) :

-rw-r--r-- 1 user group 1234 Jan 01 12:00 fichier.txt

• Propriétaire : rw- → Peut lire et écrire.

• Groupe : r-- → Peut seulement lire.

• Autres : r-- → Peuvent seulement lire.

d) Outils de contrôle d'accès avancés

• ACLs (Access Control Lists) : Donnent plus de flexibilité aux permissions (setfacl, getfacl).

• SELinux & AppArmor : Systèmes de contrôle d’accès obligatoires qui limitent les actions des processus.

Résumé du module
La sécurité repose sur Confidentialité, Intégrité, Disponibilité.
Linux n'est pas invulnérable : malwares, attaques réseau et exploits existent.
Le modèle UNIX favorise la sécurité avec une gestion stricte des permissions et des processus.

Exercice pratique
1 Liste les processus en cours et identifie ceux qui sont lancés en tant que root :

ps aux | grep root

2 Vérifie les ports ouverts sur ton système :

netstat -tulnp

3 Active un firewall simple avec ufw :

sudo ufw enable

sudo ufw allow ssh

Module 2 : Gestion des utilisateurs et permissions

1. Gestion des utilisateurs et groupes
Linux utilise un système multi-utilisateurs où chaque utilisateur possède un UID (User ID) et appartient à un ou
plusieurs groupes définis par un GID (Group ID).

a) Création et gestion des utilisateurs

Créer un utilisateur :

sudo adduser nom_utilisateur

Modifier un utilisateur (ex : changer son shell par défaut) :

6
sudo usermod -s /bin/zsh nom_utilisateur

Supprimer un utilisateur :

sudo deluser nom_utilisateur

b) Gestion des groupes

Créer un groupe :

sudo groupadd nom_du_groupe

Ajouter un utilisateur à un groupe :

sudo usermod -aG nom_du_groupe nom_utilisateur

Supprimer un utilisateur d’un groupe :

sudo deluser nom_utilisateur nom_du_groupe

c) Vérification des utilisateurs et groupes

Lister les utilisateurs enregistrés :

cat /etc/passwd

Lister les groupes :

cat /etc/group

Voir les groupes d’un utilisateur :

groups nom_utilisateur

2. Permissions de fichiers et répertoires

a) Structure des permissions Linux

Chaque fichier ou dossier a trois types de permissions :

Type Lecture (r) Écriture (w) Exécution (x)

Utilisateur (owner) Peut voir le contenu Peut modifier le fichier Peut exécuter le fichier

Groupe Peut voir le contenu Peut modifier si autorisé Peut exécuter si autorisé

Autres (everyone) Peut voir le contenu Peut modifier si autorisé Peut exécuter si autorisé

Afficher les permissions d’un fichier :

ls -l fichier.txt

Exemple de sortie :

-rw-r--r-- 1 user group 1234 Jan 01 12:00 fichier.txt

7
 • Propriétaire : rw- → Peut lire et écrire.

• Groupe : r-- → Peut seulement lire.

• Autres : r-- → Peuvent seulement lire.

b) Modifier les permissions avec chmod

Utilisation des lettres (symbolique) :

• Donner les droits d'exécution à l’utilisateur propriétaire :

o chmod u+x script.sh

• Enlever le droit d’écriture pour les autres :

o chmod o-w fichier.txt

• Ajouter les permissions de lecture à tous :

o chmod a+r fichier.txt

Utilisation des chiffres (octal) :

Chaque permission a une valeur numérique :

• 4 = Lecture (r)

• 2 = Écriture (w)

• 1 = Exécution (x)

Exemple :

• chmod 755 fichier.txt donne :

o 7 (4+2+1) : Propriétaire → Lecture, Écriture, Exécution

o 5 (4+0+1) : Groupe → Lecture, Exécution

o 5 (4+0+1) : Autres → Lecture, Exécution

3. Système ACL (Access Control List) pour permissions avancées

ACL permet de donner des permissions spécifiques à des utilisateurs ou groupes sans modifier les permissions
classiques.

Activer ACL sur un système de fichiers :

sudo mount -o remount,acl /

Ajouter des permissions pour un utilisateur spécifique :

setfacl -m u:alice:rwx fichier.txt

Vérifier les ACLs :

8
 getfacl fichier.txt

Supprimer une ACL spécifique :

setfacl -x u:alice fichier.txt

4. Sécurisation du super-utilisateur et sudo

a) Pourquoi éviter d’utiliser root directement ?

• Sécurité : Un seul faux pas en root peut corrompre le système.

• Auditabilité : Les commandes exécutées avec sudo sont enregistrées dans les logs (/var/log/auth.log).

• Groupe d’utilisateurs « sudo »

o Le groupe sudo sous Linux est un groupe d’utilisateurs qui ont la permission d’exécuter des
commandes avec des privilèges root (administrateur) via la commande sudo.

o Rôle du groupe sudo :

▪ Permet à un utilisateur d’exécuter des commandes administratives sans se connecter en

tant que root.

▪ Offre un contrôle plus fin sur les permissions grâce au fichier /etc/sudoers.

▪ Améliore la sécurité en évitant l’utilisation directe du compte root.

o Vérifier si un utilisateur appartient au groupe sudo

▪ groups utilisateur

o Ajouter un utilisateur au groupe sudo

▪ sudo usermod -aG sudo utilisateur

o Lister les utilisateurs du groupe sudo

▪ getent group sudo

o Ainsi, un utilisateur du groupe sudo peut exécuter des commandes comme :

▪ sudo apt update

o et entrer son mot de passe pour obtenir des privilèges administratifs.

b) Configuration de sudo

Ajouter un utilisateur au groupe sudo :

sudo usermod -aG sudo nom_utilisateur

Fichier de configuration de sudo :

sudo visudo
9
Exemple pour donner à un utilisateur la permission d’exécuter apt sans mot de passe :

nom_utilisateur ALL=(ALL) NOPASSWD: /usr/bin/apt

Voir les droits sudo d’un utilisateur :

sudo -l -U nom_utilisateur

Exercices pratiques
Exercice 1 : Création et gestion d’un utilisateur

1 Crée un nouvel utilisateur nommé "secuser".

2 Associe cet utilisateur au groupe "security" (que tu dois créer).
3 Vérifie qu'il a bien été ajouté au groupe "security".

Exercice 2 : Manipulation des permissions

1 Crée un fichier nommé "confidentiel.txt" et empêche tous les autres utilisateurs de le lire.
2 Ajoute uniquement le droit d’exécution pour le propriétaire.
3 Donne l’accès en lecture au fichier pour l’utilisateur "secuser" via ACL.

Exercice 3 : Sécurisation de l’accès root

1 Active le fichier /etc/sudoers et ajoute une règle pour que secuser puisse exécuter ping sans mot de passe.
2 Vérifie les logs d’utilisation de sudo.
3 Désactive la connexion directe de root via SSH (PermitRootLogin no dans /etc/ssh/sshd_config).

Résumé du module
Gestion des utilisateurs et groupes avec adduser, groupadd, usermod.
Compréhension des permissions Linux (chmod, chown, ls -l).
Utilisation des ACLs pour des permissions avancées (setfacl, getfacl).
Sécurisation de l’accès root via sudo et restrictions d’accès.

Module 3 : Sécurisation des accès et authentification

1. Gestion des mots de passe et politiques de sécurité

Un mot de passe faible est une porte d’entrée facile pour les attaquants. Il est donc essentiel de mettre en place
des politiques strictes de gestion des mots de passe.

a) Configuration des exigences de mots de passe

10
 • Linux stocke les mots de passe chiffrés dans /etc/shadow.

• La politique de mots de passe est définie dans /etc/login.defs et /etc/security/pwquality.conf.

Exemple de configuration sécurisée dans /etc/security/pwquality.conf :

minlen = 12 # Longueur minimale du mot de passe

dcredit = -1 # Au moins 1 chiffre obligatoire

ucredit = -1 # Au moins 1 majuscule obligatoire

lcredit = -1 # Au moins 1 minuscule obligatoire

ocredit = -1 # Au moins 1 caractère spécial obligatoire

b) Forcer le changement de mot de passe périodiquement

• Définir une durée de vie maximale pour les mots de passe :

sudo chage -M 90 nom_utilisateur # Expiration du mot de passe après 90 jours

• Vérifier la politique de mot de passe d’un utilisateur :

chage -l nom_utilisateur

c) Désactiver un compte après inactivité

• Bloquer un compte après 30 jours d’inactivité :

sudo usermod -L -f 30 nom_utilisateur

• Débloquer un compte :

sudo usermod -U nom_utilisateur

2. Authentification multi-facteurs (MFA)

L'authentification multi-facteurs (MFA) ajoute une couche de sécurité en exigeant un second facteur (exemple : un
code temporaire généré sur un smartphone).

a) Installation et configuration de Google Authenticator

1 Installer Google Authenticator :

sudo apt install libpam-google-authenticator

2 Lancer la configuration :

google-authenticator

3 Répondre aux questions pour générer un QR Code et un code secret.

4 Modifier /etc/pam.d/sshd pour activer MFA :

auth required pam_google_authenticator.so

5 Activer MFA dans /etc/ssh/sshd_config :

11
 ChallengeResponseAuthentication yes

6 Redémarrer le service SSH :

sudo systemctl restart sshd

3. Sécurisation des connexions SSH

a) Désactiver la connexion root via SSH

Dans /etc/ssh/sshd_config, modifier la ligne :

PermitRootLogin no

Puis redémarrer le service :

sudo systemctl restart sshd

b) Modifier le port SSH pour éviter les scans automatisés

Dans /etc/ssh/sshd_config, modifier :

Port 2222

Puis redémarrer SSH :

sudo systemctl restart sshd

c) Restreindre l’accès SSH à certains utilisateurs

Dans /etc/ssh/sshd_config, ajouter :

AllowUsers utilisateur1 utilisateur2

Ou restreindre à un groupe spécifique :

AllowGroups sshusers

d) Activer la connexion par clé SSH et désactiver les mots de passe

1 Générer une clé SSH :

ssh-keygen -t rsa -b 4096

2 Copier la clé publique sur le serveur :

ssh-copy-id utilisateur@serveur

3 Dans /etc/ssh/sshd_config, désactiver l’authentification par mot de passe :

PasswordAuthentication no

4 Redémarrer SSH :

sudo systemctl restart sshd

12
4. Limitation des tentatives de connexion avec Fail2Ban
Fail2Ban protège contre les attaques par force brute en bloquant temporairement les IP après plusieurs tentatives
échouées.

a) Installation de Fail2Ban

sudo apt install fail2ban

b) Configuration pour SSH

• Créer un fichier /etc/fail2ban/jail.local :

[sshd]

enabled = true

port = 2222

maxretry = 5

findtime = 600

bantime = 3600

• Redémarrer Fail2Ban :

sudo systemctl restart fail2ban

c) Vérification des IP bannies

• Voir les IP bloquées :

sudo fail2ban-client status sshd

• Débloquer une IP spécifique :

sudo fail2ban-client unban-ip 192.168.1.100

Exercices pratiques
Exercice 1 : Sécurisation des mots de passe

1 Configure une politique de mot de passe forte avec pwquality.conf.

2 Force un utilisateur à changer son mot de passe après 60 jours.
3 Vérifie que le changement de mot de passe est bien actif.

Exercice 2 : Authentification et SSH

1 Désactive l’accès SSH pour l’utilisateur root.

2 Change le port SSH à 2222 et redémarre le service.
3 Configure une connexion SSH uniquement via clés SSH.

13
 Exercice 3 : Sécurisation avec Fail2Ban

1 Installe et configure Fail2Ban pour bloquer après 3 tentatives SSH.

2 Teste en faisant plusieurs tentatives de connexion échouées.
3 Vérifie si ton IP a été bannie et débloque-la.

Résumé du module
Mise en place d’une politique stricte des mots de passe.
Configuration de l’authentification multi-facteurs (MFA).
Sécurisation de SSH (désactivation de root, changement de port, clés SSH).
Protection contre les attaques par force brute avec Fail2Ban.

Module 4 : Sécurisation du réseau sous Linux

1. Introduction à la sécurité réseau sous Linux
La sécurisation du réseau sous Linux repose sur plusieurs principes clés :
Contrôler l'accès au système (firewall, permissions réseau).
Surveiller l'activité réseau (logs, outils d’analyse).
Détecter et prévenir les intrusions (IDS/IPS).

2. Configuration et gestion du pare-feu avec UFW et iptables

a) Utilisation de UFW (Uncomplicated Firewall)

UFW est un outil simplifié pour gérer les règles de pare-feu basées sur iptables.

Installation et activation :

sudo apt install ufw

sudo ufw enable

Autoriser uniquement le trafic SSH sur un port spécifique :

sudo ufw allow 2222/tcp

Refuser toutes les connexions entrantes sauf les connexions SSH et HTTP/HTTPS :

sudo ufw default deny incoming

sudo ufw allow 22/tcp

sudo ufw allow 80/tcp

sudo ufw allow 443/tcp

14
 Vérifier l’état du pare-feu :

sudo ufw status verbose

b) Gestion avancée avec iptables

Bloquer tout le trafic entrant sauf SSH, HTTP et HTTPS :

sudo iptables -P INPUT DROP

sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT

sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT

sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT

Limiter le nombre de connexions SSH pour éviter les attaques brute-force :

sudo iptables -A INPUT -p tcp --dport 22 -m limit --limit 3/min --limit-burst 5 -j ACCEPT

Sauvegarder et restaurer les règles iptables :

sudo iptables-save > /etc/iptables.rules

sudo iptables-restore < /etc/iptables.rules

3. Détection et prévention des intrusions avec Fail2Ban et Suricata

a) Configuration avancée de Fail2Ban

Nous avons déjà vu comment protéger SSH avec Fail2Ban dans le module précédent.

Ajouter une protection pour Apache/Nginx :

• Créer /etc/fail2ban/jail.local et ajouter :

[nginx-http-auth]

enabled = true

port = http,https

logpath = /var/log/nginx/error.log

maxretry = 5

bantime = 600

Appliquer les modifications :

sudo systemctl restart fail2ban

b) Installation et configuration de Suricata (IDS/IPS)

15
Suricata est un système de détection et prévention d'intrusions.

Installer Suricata :

sudo apt install suricata

Activer Suricata en mode IPS (bloquer les attaques) :

Modifier /etc/suricata/suricata.yaml et activer la variable "nfqueue" pour le mode IPS.

Démarrer Suricata :

sudo systemctl start suricata

4. Analyse du trafic réseau avec Netstat et Tcpdump

a) Surveillance des connexions avec Netstat

Netstat permet de voir les connexions réseau actives.

Afficher les ports ouverts :

netstat -tulnp

Voir les connexions établies :

netstat -an | grep ESTABLISHED

b) Capture du trafic avec Tcpdump

Tcpdump permet d'analyser les paquets réseau.

Capturer les paquets sur une interface spécifique :

sudo tcpdump -i eth0

Filtrer les connexions sur un port donné (ex: SSH) :

sudo tcpdump -i eth0 port 22

Enregistrer les paquets dans un fichier pour analyse ultérieure :

sudo tcpdump -i eth0 -w capture.pcap

Exercices pratiques
Exercice 1 : Configuration d'un pare-feu avec UFW

1 Active UFW sur ta machine.

2 Bloque tout le trafic entrant sauf SSH et HTTP/HTTPS.
3 Vérifie l’état du pare-feu et teste en essayant de te connecter sur un port bloqué.

16
 Exercice 2 : Sécurisation avancée avec iptables

1 Écris une règle iptables qui limite les connexions SSH à 3 tentatives par minute.
2 Bloque toutes les connexions provenant d’une adresse IP spécifique.
3 Sauvegarde les règles iptables et restaure-les après un redémarrage.

Exercice 3 : Protection contre les attaques avec Fail2Ban

1 Installe Fail2Ban et configure-le pour bloquer les tentatives de connexion SSH après 5 échecs.
2 Simule une attaque brute-force en essayant plusieurs fois un mauvais mot de passe.
3 Vérifie si ton IP a été bannie et débloque-la.

Exercice 4 : Analyse du réseau

1 Utilise Netstat pour voir quels ports sont ouverts sur ta machine.
2 Capture le trafic réseau sur ton interface avec Tcpdump et analyse les paquets.
3 Filtre les connexions actives sur le port 22 (SSH) avec Tcpdump.

Résumé du module
Mise en place d’un pare-feu avec UFW et iptables.
Détection et prévention des attaques avec Fail2Ban et Suricata.
Analyse du réseau avec Netstat et Tcpdump.

Module 5 : Surveillance et audit de la sécurité sous Linux

1. Introduction à la surveillance et à l’audit de la sécurité
La surveillance et l’audit sont essentiels pour :
Détecter les activités suspectes.
Identifier les failles de sécurité avant qu'elles ne soient exploitées.
Garantir la conformité aux normes de sécurité.

Les outils les plus utilisés sous Linux pour la surveillance et l’audit incluent Syslog, Journald, Auditd, Logwatch, et
Rsyslog.

2. Gestion et analyse des logs système

a) Emplacement des logs sous Linux

17
Sous Linux, la majorité des logs sont stockés dans /var/log/. Voici quelques fichiers clés :

• /var/log/auth.log → Tentatives de connexion et authentifications.

• /var/log/syslog → Journal général du système.

• /var/log/kern.log → Messages du noyau Linux.

• /var/log/nginx/access.log → Logs des accès web (Nginx).

• /var/log/fail2ban.log → Logs des IP bloquées par Fail2Ban.

b) Utilisation de journalctl (pour systemd)

Voir les derniers logs système :

journalctl -n 50

Filtrer par service spécifique (ex: SSH) :

journalctl -u ssh

Voir les logs d’un utilisateur spécifique :

journalctl _UID=1001

Surveiller les logs en temps réel :

journalctl -f

complément sur journalctl et systemd

Qu’est-ce que systemd ?

systemd est le gestionnaire d'initialisation utilisé par la plupart des distributions Linux modernes
(Ubuntu, Debian, Fedora, CentOS…).
C’est le premier processus lancé au démarrage du système et il gère :
Le démarrage et l'arrêt des services.
L'initialisation des ressources système.
La gestion des logs et journaux avec journalctl.

En résumé, systemd contrôle tous les services et processus sous Linux.

Qu’est-ce que journalctl ?

journalctl est l’outil qui permet de consulter les journaux système enregistrés par systemd.
Ces journaux incluent :
Les erreurs du système.
Les logs des services (systemd units).
Les événements liés aux utilisateurs et au noyau Linux.

18
 Exemples d’utilisation de journalctl

1. Afficher tous les logs

journalctl

Affiche tous les événements système enregistrés.

2. Voir les logs en temps réel (comme tail -f)

journalctl -f

Affiche les logs en continu (utile pour voir une erreur en direct).

3. Filtrer les logs d’un service spécifique

Exemple : Voir les logs d’Apache (apache2.service sur Ubuntu/Debian) :

journalctl -u apache2

Ou pour nginx.service (serveur web) :

journalctl -u nginx

Utile pour diagnostiquer un service qui plante.

4. Voir les logs du dernier démarrage

journalctl -b

Affiche les logs depuis le dernier redémarrage du système.

Pour voir les logs d’un démarrage précédent :

journalctl -b -1

5. Filtrer les logs par utilisateur

Exemple : Voir les logs générés par l’utilisateur UID 1001

journalctl _UID=1001

Utile pour analyser les actions d’un utilisateur spécifique.

6. Filtrer par priorité des logs (erreurs seulement)

19
 journalctl -p err

Affiche uniquement les erreurs critiques (err, alert, emerg).

Liste des niveaux de logs (-p valeurs possibles) :

Niveau Signification

0 emerg Panne critique du système

1 alert Alerte nécessitant une action immédiate

2 crit Erreur critique

3 err Erreur standard

4 warning Avertissement

5 notice Notification importante

6 info Informations générales

7 debug Logs de débogage

7. Supprimer les vieux logs pour libérer de l’espace

sudo journalctl --vacuum-time=3d

Supprime les logs de plus de 3 jours pour économiser de l’espace.

Ou définir une limite de taille :

sudo journalctl --vacuum-size=500M

Garde seulement 500 Mo de logs, supprime le reste.

Résumé : journalctl et systemd

systemd : Gère les services Linux, le démarrage, et l’enregistrement des logs.

journalctl : Permet d’analyser les journaux système pour diagnostiquer les erreurs et surveiller
les services.

c) Analyse des logs avec Logwatch

Logwatch permet de générer des rapports de logs détaillés.

Installation : sudo apt install logwatch

Générer un rapport journalier :

20
 sudo logwatch --detail high --mailto [email protected] --output mail

3. Audit des événements de sécurité avec Auditd

Auditd permet de suivre en détail l’activité du système et des utilisateurs.

a) Installation et activation d’Auditd

sudo apt install auditd

sudo systemctl enable auditd

sudo systemctl start auditd

Qu’est-ce que systemctl ?

systemctl est l’outil principal pour gérer les services sous systemd.
Il permet de :
Démarrer, arrêter et redémarrer des services.
Activer ou désactiver des services au démarrage.
Vérifier l’état d’un service ou du système.

systemctl est l’équivalent moderne de commandes plus anciennes comme service et chkconfig.

Utilisation de systemctl

1. Vérifier l’état d’un service

Exemple : Vérifier si Apache (apache2.service ou httpd.service) est actif :

systemctl status apache2

Affiche :
Si le service est actif (running) ou arrêté (inactive/dead).
Les derniers logs du service.

2. Démarrer un service

sudo systemctl start apache2

Démarre Apache sans le rendre automatique au prochain redémarrage.

3. Arrêter un service

sudo systemctl stop apache2

21
 Arrête Apache immédiatement.

4. Redémarrer un service

sudo systemctl restart apache2

Redémarre Apache (utile après une modification de configuration).

5. Recharger la configuration sans redémarrer le service

sudo systemctl reload apache2

Recharge la configuration sans couper les connexions actives (si supporté).

6. Activer/Désactiver un service au démarrage

Activer au démarrage :

sudo systemctl enable apache2

Apache démarrera automatiquement à chaque reboot.

Désactiver au démarrage :

sudo systemctl disable apache2

Apache ne démarrera plus automatiquement après un reboot.

7. Vérifier tous les services actifs

systemctl list-units --type=service --state=running

Affiche tous les services actifs actuellement sur le système.

8. Voir si un service a planté

systemctl --failed

Affiche uniquement les services qui ont échoué.

9. Redémarrer le système avec systemctl

Redémarrer le système :

sudo systemctl reboot

22
 Éteindre complètement :

sudo systemctl poweroff

Passer en mode rescue (maintenance) :

sudo systemctl rescue

Différence entre systemctl et journalctl

Commande Rôle

systemctl Gère les services (démarrer, arrêter, activer au boot…)

journalctl Affiche les logs des services et du système

Exemple combiné : Vérifier et corriger un service qui plante

1 Voir l’état du service :

systemctl status nginx

2 Voir pourquoi il plante :

journalctl -u nginx --no-pager

3 Relancer le service :

sudo systemctl restart nginx

Résumé : systemctl en action

systemctl status <service> → Vérifier l’état d’un service.

systemctl start/stop/restart <service> → Contrôler un service.
systemctl enable/disable <service> → Activer/désactiver au démarrage.
systemctl list-units --type=service → Voir les services en cours.

b) Surveiller l’accès à un fichier sensible

Exemple : surveiller /etc/passwd pour toute modification.

sudo auditctl -w /etc/passwd -p wa -k surveillance-passwd

Explication :

• -w /etc/passwd → Surveille ce fichier.

• -p wa → Déclenche une alerte en cas d'écriture ou d'accès.

23
 • -k surveillance-passwd → Associe une étiquette pour identifier l’événement.

c) Voir les événements audités

sudo ausearch -k surveillance-passwd

d) Générer un rapport détaillé

sudo aureport -a

4. Détection d’intrusions avec Tripwire

Tripwire est un outil de détection d’intrusion basé sur l’intégrité des fichiers.

a) Installation et configuration

sudo apt install tripwire

• Lors de l’installation, une clé de signature est générée pour garantir l’intégrité des fichiers.
• Cette clé chiffre les rapports pour éviter qu’un attaquant ne falsifie les logs

b) Initialisation de la base de données

sudo tripwire --init

c) Vérification de l’intégrité du système

sudo tripwire --check

Si un fichier critique a été modifié, Tripwire affichera un rapport d’alerte.

5. Supervision en temps réel avec Monit

Monit surveille les services et redémarre ceux qui plantent.

a) Installation de Monit

sudo apt install monit

b) Vérifier l’état des services

monit status

c) Configurer la surveillance d’un service (ex: SSH)

• Éditer /etc/monit/monitrc et ajouter :

check process sshd with pidfile /var/run/sshd.pid

start program = "/etc/init.d/ssh start"

stop program = "/etc/init.d/ssh stop"

if failed port 22 protocol ssh then restart

24
 • Redémarrer Monit :

sudo systemctl restart monit

Exercices pratiques
Exercice 1 : Analyse des logs système

1 Utilise journalctl pour afficher les tentatives de connexion SSH.

2 Filtre les logs pour voir uniquement les échecs d’authentification.
3 Surveille les logs en temps réel.

Exercice 2 : Audit d’un fichier sensible avec Auditd

1 Installe et active Auditd.

2 Configure Auditd pour surveiller les modifications du fichier /etc/shadow.
3 Modifie le fichier et vérifie les logs d’audit.

Exercice 3 : Détection d’intrusion avec Tripwire

1 Installe et configure Tripwire.

2 Effectue un scan d’intégrité du système.
3 Modifie un fichier du système et refais un scan pour voir si l’alerte est déclenchée.

Exercice 4 : Surveillance en temps réel avec Monit

1 Installe Monit et configure-le pour surveiller SSH.

2 Arrête le service SSH et vérifie si Monit le redémarre automatiquement.
3 Configure Monit pour envoyer une alerte par e-mail en cas de problème.

Résumé du module
Surveillance des logs système avec journalctl et Logwatch.
Audit des événements de sécurité avec Auditd.
Détection des modifications de fichiers critiques avec Tripwire.
Supervision des services en temps réel avec Monit.

Module 6 : Sécurité des applications et conteneurs sous Linux

1. Introduction à la sécurité des applications et des conteneurs
Les applications et les conteneurs peuvent être des points d’entrée pour les cyberattaques. La sécurisation repose
sur plusieurs éléments :

25
 Contrôle des permissions et gestion des utilisateurs.
Mise à jour et correction des vulnérabilités.
Isolation et confinement des applications.
Sécurité des conteneurs Docker et Kubernetes.

2. Sécurisation des applications sous Linux

a) Gestion des permissions et des accès

Éviter d’exécuter des applications avec des privilèges élevés :

• Toujours utiliser un utilisateur non root pour exécuter une application.

• Définir les permissions correctes avec chmod et chown.

Exemple : restreindre l’accès à une application web

sudo chown www-data:www-data /var/www/html/app

sudo chmod 750 /var/www/html/app

Utiliser sudo pour exécuter une application spécifique :

Limiter les commandes qu’un utilisateur peut exécuter en éditant /etc/sudoers :

alice ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart apache2

Explication de la modification dans /etc/sudoers

La ligne suivante est une règle ajoutée au fichier /etc/sudoers pour configurer des
permissions spécifiques pour l'utilisateur alice :

alice ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart apache2

Voyons en détail ce que chaque élément signifie :

Élément Signification

alice Nom de l'utilisateur à qui cette règle s'applique.

L'utilisateur alice peut exécuter cette commande depuis

ALL
n'importe quel hôte (utile en environnement multi-serveurs).

alice peut exécuter la commande en tant que n'importe

(ALL)
quel utilisateur, y compris root.

alice n'a pas besoin d'entrer son mot de passe pour

NOPASSWD
exécuter la commande.

26
Élément Signification

alice est autorisée à exécuter uniquement cette

/usr/bin/systemctl restart apache2
commande avec sudo.

Effet de cette règle

Avec cette modification, alice peut redémarrer le service Apache sans entrer son
mot de passe en exécutant :

sudo systemctl restart apache2

Sécurité :

• Cette règle ne donne pas un accès total en sudo à alice, seulement pour cette commande
précise.

• Cependant, si alice a des privilèges supplémentaires sur systemctl, elle pourrait

potentiellement manipuler d'autres services.

Comment modifier /etc/sudoers en toute sécurité ?

Ne modifiez jamais /etc/sudoers directement avec un éditeur comme nano ou vim.

Utilisez plutôt :

sudo visudo

visudo vérifie la syntaxe avant d'appliquer les changements (pour éviter de

casser les permissions sudo).

Ajoutez ensuite la ligne :

alice ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart apache2

Enregistrez et quittez (CTRL + X, puis Y et Entrée).

Cas d'usage

Cette règle est utile si alice est un administrateur web et doit redémarrer Apache
fréquemment, sans avoir à entrer son mot de passe à chaque fois.

b) Mise à jour des applications et correctifs de sécurité

Vérifier les mises à jour disponibles :

sudo apt update && sudo apt list --upgradable

27
 Mettre à jour un package spécifique :

sudo apt upgrade nginx

Automatiser les mises à jour de sécurité :

sudo apt install unattended-upgrades

sudo dpkg-reconfigure unattended-upgrades

c) Sécurisation avec AppArmor et SELinux

AppArmor et SELinux sont des modules de sécurité qui permettent de contrôler et restreindre les actions des
applications sur un système Linux.
Ils fonctionnent en définissant des politiques de sécurité qui limitent ce qu'un programme peut faire, même s'il est
compromis par un attaquant.

1 AppArmor : Sécurisation basée sur des profils

AppArmor utilise des profils pour définir les permissions d’une application (accès aux fichiers, exécution de
commandes, etc.).
Présent par défaut sur Ubuntu et Debian.

Vérifier si AppArmor est activé

Utilise la commande suivante :

sudo aa-status

Cette commande affiche :

L’état d’AppArmor (activé/désactivé).
Les profils chargés et appliqués aux applications.
Les processus qui utilisent un profil AppArmor.

Restreindre un programme avec un profil AppArmor

Un profil AppArmor permet de limiter les actions d'un programme spécifique.

Exemple : Création d'un profil pour vim

1Lancer l'outil de génération de profil :

sudo aa-genprof /usr/bin/vim

2 AppArmor passe en mode apprentissage : il enregistre les actions effectuées par vim.
3 Utiliser Vim normalement (ouvrir/modifier des fichiers).
4 Appliquer les règles observées : L’outil proposera de restreindre certaines actions et de créer un profil de sécurité.
5 Activer le profil généré :

28
sudo aa-enforce /etc/apparmor.d/usr.bin.vim

Désormais, vim ne pourra faire que ce qui est autorisé dans le profil.

2 SELinux : Sécurisation basée sur des contextes

SELinux (Security-Enhanced Linux) utilise un modèle de contrôle d'accès obligatoire (MAC) pour définir ce qu'un
utilisateur ou une application peut faire.
Présent par défaut sur Red Hat, Fedora, CentOS.

Vérifier l’état de SELinux

sestatus

Cette commande affiche :

L’état de SELinux (Enforcing, Permissive, Disabled).
Le mode de fonctionnement (Enforcing = strict, Permissive = mode apprentissage).
Le type de politique appliquée.

Changer le mode de SELinux

• Passer en mode permissif (enregistrement sans restriction) :

• sudo setenforce 0

• Passer en mode strict (appliquer les règles) :

• sudo setenforce 1

• Désactiver SELinux définitivement ( Risqué) :

Modifier le fichier /etc/selinux/config et changer la ligne :

• SELINUX=disabled

Puis redémarrer le système.

Différences entre AppArmor et SELinux

Caractéristique AppArmor SELinux

Présent par défaut sur Ubuntu, Debian RedHat, Fedora, CentOS

Fonctionnement Basé sur des profils et des chemins de fichiers Basé sur des contextes de sécurité

Configuration Plus simple Plus complexe mais plus sécurisé

29
Caractéristique AppArmor SELinux

Mode d'apprentissage Oui Oui

Résumé

AppArmor restreint les applications via des profils basés sur des chemins de fichiers.
SELinux applique un modèle de contrôle d'accès strict avec des contextes de sécurité.
Ces outils limitent l'impact des attaques, même si un programme est compromis.

3. Sécurité des conteneurs Docker

a) Utilisation de bonnes pratiques pour Docker

Introduction à la conteneurisation et à Docker

Qu’est-ce que la conteneurisation ?

La conteneurisation est une technologie de virtualisation légère qui permet d’exécuter des
applications isolées les unes des autres dans des conteneurs.

Contrairement aux machines virtuelles (VMs), les conteneurs partagent le noyau du système
hôte, ce qui les rend plus rapides et moins gourmands en ressources.

Pourquoi utiliser la conteneurisation ?

Portabilité : Un conteneur fonctionne de la même manière sur un PC, un serveur ou dans le

cloud.
Isolation : Chaque conteneur possède son propre environnement sans interférer avec
d'autres applications.
Rapidité : Démarrage quasi-instantané (contrairement aux VMs).
Facilité de déploiement : Permet d'automatiser la gestion des applications.

Qu’est-ce que Docker ?

Docker est l'outil le plus populaire pour gérer les conteneurs.

Il permet de créer, exécuter et gérer des conteneurs facilement.

Concepts clés de Docker :

30
Terme Définition

Image Modèle d'un conteneur, contenant le code et ses dépendances.

Conteneur Instance en cours d'exécution d'une image Docker.

Dockerfile Fichier qui décrit comment construire une image.

Registry Emplacement où les images Docker sont stockées (ex : Docker Hub).

Docker Compose Outil pour gérer plusieurs conteneurs ensemble.

Premiers pas avec Docker

1 Installer Docker (Ubuntu/Debian) :

sudo apt update

sudo apt install docker.io -y

2 Vérifier l’installation :

docker --version

3 Exécuter un conteneur de test :

docker run hello-world

Docker télécharge une image de test et l’exécute dans un conteneur.

Exemple simple : Exécuter un serveur web avec Docker

1 Télécharger et exécuter un serveur web Nginx :

docker run -d -p 8080:80 nginx

Accédez au serveur sur http://localhost:8080.

2 Voir les conteneurs en cours d'exécution :

docker ps

3 Arrêter le conteneur :

docker stop <ID_du_conteneur>

Résumé

La conteneurisation permet d’exécuter des applications isolées et portables.

Docker est l'outil principal pour créer et gérer ces conteneurs.

31
 Les images sont des modèles de conteneurs, stockés sur des registries.
Un conteneur est une instance d’image en cours d’exécution.

Ne pas exécuter des conteneurs en root

docker run --user 1001 -d myapp

Explication

Ne pas exécuter des conteneurs en root : Explication

Par défaut, Docker exécute les conteneurs avec les privilèges root.
Cela signifie que si un attaquant exploite une vulnérabilité dans le conteneur, il peut potentiellement
obtenir des privilèges élevés sur l’hôte.

Problème d'exécuter un conteneur en root

1 Un processus en root dans le conteneur = root sur l’hôte (si une faille est exploitée).
2 Attaques par escalade de privilèges : Un attaquant peut échapper au conteneur et
compromettre le système.
3 Meilleure pratique en cybersécurité : Toujours exécuter les conteneurs avec un utilisateur
restreint.

Explication de la commande

docker run --user 1001 -d myapp

Option Explication

docker run Lance un nouveau conteneur.

--user 1001 Exécute le conteneur avec l'UID 1001 au lieu de root.

-d Exécute le conteneur en arrière-plan (mode détaché).

myapp Image Docker du conteneur à exécuter.

Comment savoir quel utilisateur utiliser ?

1 Lister les utilisateurs sur l’hôte Linux :

cat /etc/passwd

Cela affichera une liste des utilisateurs et leurs UID (User ID).

2 Créer un utilisateur spécifique pour Docker (si besoin) :

32
 sudo useradd -m -d /home/dockeruser -s /bin/bash dockeruser

Puis, trouver son UID avec :

id dockeruser

Exemple de sortie :

uid=1001(dockeruser) gid=1001(dockeruser) groups=1001(dockeruser)

Alors, vous pouvez exécuter le conteneur avec :

docker run --user 1001 -d myapp

Sécuriser un Dockerfile en créant un utilisateur dédié

Au lieu d’utiliser --user à chaque exécution, vous pouvez créer un utilisateur dans votre Dockerfile
:

Exemple de Dockerfile sécurisé :

FROM ubuntu:latest

# Créer un utilisateur non-root

RUN useradd -m -d /home/myuser -s /bin/bash myuser

# Passer à cet utilisateur

USER myuser

# Exécuter l'application

CMD ["/bin/bash"]

Puis construire et exécuter l’image :

docker build -t secure-app .

docker run -d secure-app

Conclusion : Sécurité Docker et utilisateur non-root

Exécuter les conteneurs avec un utilisateur restreint (--user UID).

Créer un utilisateur non-root dans le Dockerfile pour un maximum de sécurité.
Éviter d’exposer le système hôte à des attaques d’élévation de privilèges.

33
 Utiliser des images Docker officielles et vérifiées
Vérifier la provenance d’une image avant de l’utiliser :

docker image inspect nginx

Limiter les ressources allouées aux conteneurs

Exemple de limitation CPU/mémoire :

docker run --memory="512m" --cpus="1" myapp

b) Isolation des conteneurs avec AppArmor et Seccomp

Appliquer un profil AppArmor à un conteneur :

docker run --security-opt apparmor=docker-default myapp

Utiliser Seccomp pour restreindre les appels système :

docker run --security-opt seccomp=/path/to/seccomp-profile.json myapp

c) Analyse de sécurité des images Docker

Vérifier les vulnérabilités d’une image avec Trivy :

sudo apt install trivy

trivy image nginx

Scanner un conteneur en cours d’exécution :

trivy -d --scanners vuln,secret filesystem /

4. Sécurisation des orchestrateurs de conteneurs (Kubernetes)

Introduction aux orchestrateurs de conteneurs

Pourquoi orchestrer des conteneurs ?

Lorsqu’on utilise plusieurs conteneurs, il devient difficile de :

Déployer et gérer plusieurs conteneurs
Gérer le réseau et le stockage entre eux
Surveiller l'état des conteneurs et les redémarrer en cas d’échec
Répartir la charge pour éviter les surcharges

C’est ici qu’interviennent les orchestrateurs de conteneurs !

34
 Qu'est-ce qu'un orchestrateur de conteneurs ?

Un orchestrateur de conteneurs est un outil qui automatise :

Le déploiement et la mise à l’échelle des conteneurs
Le monitoring et l’auto-réparation des applications
La gestion des réseaux et du stockage

Les orchestrateurs les plus populaires

1⃣ Kubernetes (K8s) – Le standard du marché

• Développé par Google, maintenant un projet Cloud Native Computing Foundation (CNCF)

• Offre une gestion avancée des conteneurs

• Fonctionne avec Docker, containerd, et d'autres runtimes

• Supporte le scalabilité automatique et la tolérance aux pannes

• Utilisé par Amazon EKS, Google GKE, Azure AKS

Exemple de commande Kubernetes :

kubectl create deployment myapp --image=nginx

2⃣ Docker Swarm – L’orchestrateur intégré à Docker

• Plus simple que Kubernetes

• Intégré directement dans Docker (docker swarm init)

• Idéal pour petites infrastructures

Exemple d’activation du mode Swarm :

docker swarm init

docker service create --name myapp -p 8080:80 nginx

3⃣ OpenShift – Kubernetes amélioré par Red Hat

• Basé sur Kubernetes avec des outils supplémentaires

• Sécurité renforcée et intégration DevOps

• Utilisé en entreprise pour les workflows CI/CD

Quel orchestrateur choisir ?

35
Orchestrateur Points forts Cas d’usage

Kubernetes Puissant, standard du marché, haute disponibilité Grandes infrastructures et cloud

Docker Swarm Facile à configurer, natif Docker Déploiements simples

OpenShift Sécurité avancée, DevOps intégré Environnements d’entreprise

Conclusion

Les orchestrateurs permettent d’automatiser la gestion des conteneurs.

Kubernetes est la solution la plus utilisée, mais Docker Swarm est plus simple.
Ils facilitent la mise à l’échelle, la tolérance aux pannes et l’automatisation.

Introduction à Kubernetes et ses composantes

Qu'est-ce que Kubernetes ?

Kubernetes (K8s) est un orchestrateur de conteneurs open-source conçu pour automatiser :

Le déploiement de conteneurs
Leur mise à l’échelle
Leur gestion et monitoring

Développé initialement par Google, Kubernetes est aujourd’hui le standard du marché pour
gérer des infrastructures basées sur des conteneurs.

Les composantes clés de Kubernetes

1 Pod – L'unité de base

Un Pod est le plus petit élément géré par Kubernetes.

Il peut contenir un ou plusieurs conteneurs, partageant le même réseau et le même
stockage.

Exemple de Pod en YAML :

36
2 Node – Les serveurs qui exécutent les Pods

• Node (nœud) = Machine (physique ou virtuelle) qui exécute les Pods

• Un cluster Kubernetes contient plusieurs Nodes

Types de Nodes :
Master Node : Gère le cluster (Plan de contrôle)
Worker Node : Exécute les applications (Pods)

3 Deployment – Pour gérer les mises à jour

Un Deployment assure :
Le déploiement des Pods
La mise à jour sans interruption (rolling update)
La scalabilité automatique

▪ Exemple de Deployment (3 réplicas de Nginx) :

37
 ▪ Commandes associées :

kubectl apply -f deployment.yaml # Déployer

kubectl get deployments # Voir les déploiements

4 Service – Gérer l'accès aux Pods

Un Service permet d’exposer les Pods à d’autres services ou à l’extérieur.

Types de Services :

• ClusterIP (interne au cluster)

• NodePort (exposé sur un port fixe du Node)

• LoadBalancer (utilisé dans le cloud)

Exemple de Service exposant un Pod Nginx sur le port 80 :

38
5 ConfigMap et Secret – Gérer les configurations

• ConfigMap : Stocke des configurations non sensibles (ex : fichiers de config, variables
d’environnement).

• Secret : Stocke des informations sensibles (ex : mots de passe, clés API).

Exemple de ConfigMap :

Exemple de Secret (données encodées en base64) :

39
 Conclusion

Kubernetes gère automatiquement les conteneurs dans un cluster.

Les Pods sont les unités de base contenant des conteneurs.
Les Deployments permettent de déployer et mettre à jour les applications.
Les Services exposent les Pods et gèrent le réseau.
ConfigMap et Secret gèrent les configurations et les secrets.

a) Restreindre les permissions avec RBAC (Role-Based Access Control)

Créer un rôle Kubernetes qui permet uniquement la lecture des pods :

Associer le rôle à un utilisateur spécifique :

40
b) Scanner les vulnérabilités des déploiements Kubernetes avec kube-bench

Installer kube-bench pour vérifier la conformité avec les bonnes pratiques CIS :

kubectl apply -f https://github.com/aquasecurity/kube-bench/releases/latest/download/kube-bench.yaml

Lancer un scan de sécurité :

kubectl logs kube-bench -n kube-system

CIS (Center for Internet Security) : Définition

Le CIS (Center for Internet Security) est une organisation à but non lucratif qui définit des
standards de sécurité pour les systèmes informatiques, y compris Kubernetes.

Les bonnes pratiques CIS sont appelées CIS Benchmarks et servent de référence en
cybersécurité.

Dans Kubernetes, le CIS Kubernetes Benchmark propose des recommandations pour :

Sécuriser les configurations du cluster
Appliquer les bonnes pratiques de contrôle d'accès
Renforcer la sécurité des nœuds et des pods

kube-bench : Vérifier la conformité CIS

41
 kube-bench est un outil open-source qui scanne un cluster Kubernetes et vérifie s'il respecte les
standards de sécurité du CIS Kubernetes Benchmark.

Installation et exécution de kube-bench :

# Télécharger et exécuter kube-bench

curl -L https://github.com/aquasecurity/kube-bench/releases/latest/download/kube-
bench_$(uname -s)_$(uname -m).tar.gz | tar xz

./kube-bench

Sortie attendue :
Liste des configurations conformes
Liste des failles de sécurité détectées

Exercices pratiques
Exercice 1 : Sécurisation d'une application Linux

1 Restreindre les permissions d’un répertoire d’application web avec chown et chmod.
2 Configurer un utilisateur sudo pour redémarrer uniquement un service spécifique.
3 Activer unattended-upgrades pour automatiser les mises à jour.

Exercice 2 : Sécurisation d’un conteneur Docker

1 Exécuter un conteneur Docker avec un utilisateur non-root.

2 Scanner une image Docker avec Trivy et corriger les vulnérabilités trouvées.
3 Appliquer un profil AppArmor à un conteneur Docker.

Exercice 3 : Protection d’un cluster Kubernetes

1 Créer un rôle RBAC qui autorise uniquement la lecture des pods.

2 Associer ce rôle à un utilisateur spécifique.
3 Lancer kube-bench pour vérifier la sécurité du cluster Kubernetes.

Résumé du module
Sécurisation des applications Linux (permissions, mises à jour, AppArmor, SELinux).
Sécurisation des conteneurs Docker (permissions, isolation, analyse de vulnérabilités).
Sécurisation des orchestrateurs Kubernetes (RBAC, audits de sécurité).

Souhaites-tu approfondir une partie en particulier ?

Voici le développement détaillé du Module 7 : Chiffrement et authentification avancée sous Linux, accompagné
d’exercices pratiques.
42
Module 7 : Chiffrement et Authentification Avancée sous Linux
1. Introduction
La sécurité sous Linux repose sur deux piliers fondamentaux :
Le chiffrement : protection des données contre la lecture non autorisée.
L’authentification : vérification de l’identité d’un utilisateur avant l’accès à un système.

Dans ce module, nous allons voir les techniques avancées de chiffrement et d’authentification ainsi que des outils
utilisés sous Linux.

2. Chiffrement sous Linux

a) Chiffrement des fichiers et répertoires

Chiffrement avec GnuPG (GPG)

GnuPG permet de chiffrer et signer des fichiers avec une clé publique/privée.

Chiffrer un fichier avec une clé publique :

gpg --output fichier_chiffre.gpg --encrypt --recipient [email protected] fichier.txt

Déchiffrer un fichier :

gpg --output fichier_dechiffre.txt --decrypt fichier_chiffre.gpg

Générer une paire de clés GPG :

gpg --full-generate-key

b) Chiffrement des disques et partitions

Utilisation de LUKS (Linux Unified Key Setup)

LUKS permet de chiffrer une partition ou un disque complet.

Chiffrer une partition avec LUKS :

sudo cryptsetup luksFormat /dev/sdX

• Explication des éléments :

• sudo : Exécute la commande avec les privilèges administrateur.

• cryptsetup : Outil en ligne de commande permettant de gérer le chiffrement de partitions sous

Linux.

43
 • luksFormat : Initialise une partition pour utiliser LUKS, en la formatant avec un chiffrement
sécurisé.

• /dev/sdX : Chemin du périphérique (disque ou partition) à chiffrer. Il doit être remplacé par la bonne
lettre du disque (exemple : /dev/sdb1).

• Détails du fonctionnement

1 Efface toutes les données de la partition cible.

2 Crée un conteneur LUKS et définit le chiffrement avec un mot de passe.
3 Génère une clé de chiffrement et configure les métadonnées LUKS sur la partition.

• Vérification après chiffrement

Après l’exécution de la commande, on peut vérifier si la partition est bien chiffrée avec :

sudo cryptsetup luksDump /dev/sdX

Ouvrir et monter une partition chiffrée :

o sudo cryptsetup open /dev/sdX my_encrypted_disk

o sudo mount /dev/mapper/my_encrypted_disk /mnt
• Explication des commandes

La commande suivante est utilisée pour déverrouiller et mapper une partition chiffrée avec LUKS
afin de l'utiliser sous Linux :

sudo cryptsetup open /dev/sdX my_encrypted_disk

Explication des éléments :

• sudo : Exécute la commande avec les privilèges administrateur.

• cryptsetup : Outil permettant de gérer le chiffrement des partitions.

• open : Déverrouille la partition LUKS et crée un périphérique mappé accessible sous /dev/mapper/.

• /dev/sdX : Partition chiffrée à déverrouiller (exemple : /dev/sdb1).

• my_encrypted_disk : Nom donné au périphérique mappé, qui apparaîtra sous

/dev/mapper/my_encrypted_disk.

Comment ça fonctionne ?

1 Demande la phrase de passe associée à LUKS.

2 Déchiffre la partition temporairement sans modifier son contenu.
3 Crée un périphérique virtuel sous /dev/mapper/ pour y accéder comme un disque normal.
44
 Utilisation après ouverture

Une fois la partition déverrouillée, on peut :

• Créer un système de fichiers si la partition est vide :

sudo mkfs.ext4 /dev/mapper/my_encrypted_disk

• Monter la partition pour l’utiliser :

sudo mount /dev/mapper/my_encrypted_disk /mnt

• Vérifier si elle est bien déverrouillée : lsblk

Fermer le volume après utilisation

Pour sécuriser la partition après usage, il faut la démonter et la refermer :

sudo umount /mnt

sudo cryptsetup close my_encrypted_disk

3. Authentification Avancée
a) Authentification par clés SSH

L’authentification par clé SSH est plus sécurisée que l’authentification par mot de passe.

L'authentification par clés SSH (Secure Shell) est une méthode sécurisée pour se connecter à des serveurs
Linux sans utiliser de mot de passe. Voici comment cela fonctionne :

1. Génération des clés :

o Vous commencez par générer une paire de clés SSH sur votre machine locale. Cette paire
comprend une clé publique et une clé privée.

o Utilisez la commande suivante pour générer les clés :

ssh-keygen -t rsa -b 4096 -C "[email protected]"

• Vous serez invité à spécifier un emplacement pour enregistrer les clés (par défaut,
~/.ssh/id_rsa) et à définir une phrase de passe pour une sécurité supplémentaire.

• ssh-keygen : C'est l'outil utilisé pour générer des paires de clés SSH.

• -t rsa : Spécifie le type d'algorithme de clé à utiliser. Ici, rsa indique que l'algorithme
RSA sera utilisé pour générer la paire de clés.

45
 • -b 4096 : Définit la longueur de la clé en bits. Ici, 4096 bits est utilisé, ce qui offre un
niveau de sécurité élevé. Plus la clé est longue, plus elle est sécurisée, mais cela
peut aussi augmenter le temps de génération et de traitement.

• -C "[email protected]" : Ajoute un commentaire à la clé publique. Ce

commentaire est souvent utilisé pour identifier la clé. Ici, l'adresse email
[email protected] est utilisée comme commentaire.

• Exemple complet de la commande :

• ssh-keygen -t rsa -b 4096 -C "[email protected]"

• Clés générées : Deux fichiers seront créés : une clé privée (id_rsa) et une clé
publique (id_rsa.pub).

2. Copie de la clé publique sur le serveur :

o La clé publique doit être copiée sur le serveur auquel vous souhaitez vous connecter.

o Utilisez la commande suivante pour copier la clé publique :

ssh-copy-id utilisateur@serveur

o Cette commande ajoute la clé publique au fichier ~/.ssh/authorized_keys de l'utilisateur

sur le serveur.

3. Connexion au serveur :

o Une fois la clé publique en place, vous pouvez vous connecter au serveur sans mot de passe
en utilisant la commande suivante :

ssh utilisateur@serveur

o Le serveur utilise la clé publique pour chiffrer un message, que votre machine locale
déchiffre avec la clé privée. Si le déchiffrement est réussi, l'authentification est validée.

4. Avantages de l'authentification par clés SSH :

• Sécurité accrue : Les clés SSH sont beaucoup plus difficiles à deviner que les mots de passe.

• Commodité : Une fois configurée, vous n'avez plus besoin de saisir votre mot de passe à chaque
connexion.

• Automatisation : Idéal pour les scripts et les tâches automatisées nécessitant des connexions
sécurisées.

b) Authentification à deux facteurs (2FA)

46
L’authentification à deux facteurs ajoute une couche de sécurité en exigeant un code temporaire en plus du mot de
passe.

Installer Google Authenticator :

sudo apt install libpam-google-authenticator

Configurer l’authentification 2FA :

google-authenticator

Activer 2FA pour SSH en modifiant /etc/pam.d/sshd :

auth required pam_google_authenticator.so

Puis, modifier /etc/ssh/sshd_config :

ChallengeResponseAuthentication yes

Redémarrer SSH :

sudo systemctl restart sshd

c) Utilisation de PAM (Pluggable Authentication Modules)

PAM est un framework permettant de gérer l’authentification des utilisateurs.

Voir les modules PAM activés :

cat /etc/pam.d/common-auth

Restreindre l’accès aux utilisateurs spécifiques en ajoutant dans /etc/security/access.conf :

-:ALL EXCEPT user1 user2:ALL

Appliquer cette règle dans PAM en ajoutant à /etc/pam.d/sshd :

account required pam_access.so

4. Exercices Pratiques
Exercice 1 : Chiffrement et déchiffrement avec GPG

1 Générer une paire de clés GPG.

2 Chiffrer un fichier texte avec GPG.
3 Déchiffrer le fichier avec la clé privée.

Exercice 2 : Mise en place d’un disque chiffré avec LUKS

1 Chiffrer une partition avec cryptsetup luksFormat.

2 Ouvrir et monter le volume chiffré.
3 Fermer le volume après utilisation.

47
 Exercice 3 : Connexion SSH sécurisée avec clés SSH

1 Générer une paire de clés SSH.

2 Ajouter la clé publique sur un serveur distant.
3 Désactiver l’authentification par mot de passe et tester la connexion.

Exercice 4 : Mise en place de l’authentification 2FA sur SSH

1 Installer Google Authenticator.

2 Configurer un utilisateur avec 2FA.
3 Tester la connexion SSH avec le mot de passe + code 2FA.

Résumé du module
Chiffrement des fichiers avec GPG et des disques avec LUKS.
Authentification sécurisée avec SSH par clés et authentification 2FA.
Gestion avancée de l’authentification avec PAM.

Module 8 : Tests et audits de sécurité Linux

Introduction
L’audit de sécurité d’un système Linux est une étape cruciale pour détecter les vulnérabilités et prévenir les
attaques. Il comprend plusieurs approches :
Audits de sécurité : analyse du système et détection de rootkits/malwares
Pentesting : test d’intrusion pour identifier les faiblesses exploitables
Réaction aux incidents : bonnes pratiques pour sécuriser un système après une attaque

1. Audit avec Lynis, chkrootkit et rkhunter

Audit de configuration avec Lynis

Lynis est un outil d’analyse de sécurité permettant d’identifier les faiblesses du système. Il vérifie :
Le noyau et les modules actifs
Les permissions et configurations
Les services actifs et leur sécurité

Installation et exécution de Lynis :

sudo apt update && sudo apt install lynis -y

sudo lynis audit system

48
 Sortie attendue : Une liste de recommandations de sécurité avec un score global.

Détection de rootkits avec chkrootkit et rkhunter

Les rootkits sont des malwares furtifs qui permettent aux attaquants de garder un accès persistant sur un
système.

Installation et exécution de chkrootkit :

sudo apt install chkrootkit -y

sudo chkrootkit

Installation et exécution de rkhunter :

sudo apt install rkhunter -y

sudo rkhunter --update

sudo rkhunter --checkall

Sortie attendue : Alertes indiquant la présence potentielle de rootkits.

Exercice 1 : Audit et correction

1⃣ Installez Lynis et effectuez un audit

2⃣ Analysez le rapport et appliquez trois recommandations
3⃣ Exécutez chkrootkit et rkhunter pour détecter des menaces
4⃣ Vérifiez si les alertes sont de faux positifs ou des menaces réelles

2. Pentesting d’un système Linux

Analyse réseau avec Nmap

Nmap est un outil de scan permettant d’identifier les ports ouverts, les services et les vulnérabilités
potentielles.

Exécuter un scan simple sur une machine cible :

nmap -sS -p- 192.168.1.10

Scanner les services et versions :

nmap -sV 192.168.1.10

Chercher des vulnérabilités connues :

nmap --script vuln 192.168.1.10

Test d’intrusion avec Metasploit

Metasploit est un framework d’exploitation permettant de tester les vulnérabilités d’un système.

Lancer Metasploit :
49
sudo msfconsole

Rechercher une vulnérabilité pour un service :

search vsftpd

Exploiter une vulnérabilité (exemple FTP) :

use exploit/unix/ftp/vsftpd_234_backdoor

set RHOSTS 192.168.1.10

run

Sortie attendue : Ouverture d’une session sur la machine cible si elle est vulnérable.

Scan de vulnérabilités web avec Nikto

Nikto permet de scanner un serveur web à la recherche de failles connues.

Lancer un scan complet :

nikto -h http://192.168.1.10

Sortie attendue : Liste des vulnérabilités détectées (ex : fichiers sensibles exposés, failles XSS, etc.).

Exercice 2 : Scanner un serveur et exploiter une faille

1⃣ Utilisez Nmap pour analyser les ports et services d’une machine Linux
2⃣ Lancez Nikto pour identifier les failles web
3⃣ Essayez d’exploiter une vulnérabilité avec Metasploit (si possible dans un environnement de test)

3. Meilleures pratiques et plan d’intervention en cas d’incident

1. Réaction en cas d’attaque

Lorsqu’une attaque est détectée, suivez ces étapes :

1⃣ Identifier la menace et analyser les logs avec journalctl et syslog
2⃣ Isoler la machine du réseau pour limiter la propagation
3⃣ Vérifier les processus suspects :

ps aux | grep suspicious_process

4⃣ Lister les connexions réseau actives :

netstat -tulnp

5⃣ Vérifier les connexions SSH suspectes :

last -i

2. Renforcement de la sécurité

50
 Mettre à jour le système :

sudo apt update && sudo apt upgrade -y

Restreindre les accès SSH (modifier /etc/ssh/sshd_config) :

PermitRootLogin no

AllowUsers admin

Activer un pare-feu avec UFW :

sudo ufw enable

sudo ufw allow 22/tcp

3. Plan d’audit régulier

Créer un script d’audit automatique :

#!/bin/bash

echo "Audit de sécurité Linux"

echo "1. Vérification des mises à jour"

sudo apt update -y

echo "2. Analyse avec Lynis"

sudo lynis audit system

echo "3. Scan des rootkits"

sudo rkhunter --check

Programmer un audit régulier avec cron :

crontab -e

Ajouter cette ligne pour exécuter l’audit chaque semaine :

0 3 * * 1 /path/to/audit_script.sh

Exercice 3 : Plan d’audit et réponse aux incidents

1⃣ Simulez une attaque en exécutant un scan Nmap sur une machine Linux
2⃣ Identifiez l’attaque en analysant les logs (journalctl)
3⃣ Mettez en place une réponse :

• Isoler la machine

• Restreindre les accès

• Mettre à jour le système

4⃣ Automatisez un audit avec cron

51
Conclusion
Lynis, chkrootkit et rkhunter permettent de détecter des failles et des rootkits.
Nmap, Nikto et Metasploit aident à identifier et tester les vulnérabilités.
Un bon plan d’intervention permet de réagir efficacement en cas d’attaque.
L’automatisation des audits améliore la surveillance et la protection du système.

Besoin d’un guide plus détaillé sur un outil spécifique ?

52