CodeGym /Cours /Docker SELF /Configuration du pare-feu, SELinux et des règles ACL de b...

Configuration du pare-feu, SELinux et des règles ACL de base

Docker SELF

Niveau 5 , Leçon 5

Disponible

1. Étape 1 : Installation et configuration du pare-feu

Salut ! Aujourd'hui, on va se lancer dans de la pratique réelle et utiliser tout ce que tu as appris sur la sécurité Linux jusqu'ici. On configure un pare-feu, on évalue le fonctionnement de SELinux et on explore la simplicité des ACL pour gérer l'accès aux fichiers. Cette conférence, c'est ton "terrain d'entraînement". Allez, mets tes "galons de sécurité admin" et on commence !

Tu sais déjà qu'un bon pare-feu, c'est comme un vigile à l'entrée. Il décide qui peut passer et qui doit entendre "Pas question !". Pour commencer, on va protéger notre système en permettant l'accès uniquement aux services SSH et HTTP.

Travailler avec UFW

Vérifie le statut d’UFW. Pas installé ? Alors, on l'installe !
```
# Vérifier UFW
sudo ufw status
```

Si la commande dit que "le pare-feu est désactivé", il faut régler ça.

Installer et démarrer UFW.

# Installation (si nécessaire)
sudo apt install ufw

# Activer le pare-feu
    sudo ufw enable

Configurer l’accès. On veut permettre uniquement SSH (port 22) et HTTP (port 80), en bloquant tout le reste. Logique simple : le serveur, c’est pas un hôtel trois étoiles pour tout le monde.
```
# Autoriser SSH
sudo ufw allow 22

# Autoriser HTTP
sudo ufw allow 80

# Vérifier la configuration
sudo ufw status
```

Vérification : Après configuration, tu devrais voir quelque chose comme ça :

Status: active
To                         Action      From
--                         ------      ----
22                         ALLOW       Anywhere
80                         ALLOW       Anywhere

Si tu utilises iptables, la configuration est un peu plus complexe, mais l'idée reste la même : on crée des règles pour SSH et HTTP, et on bloque tout le reste.

2. Étape 2 : Travailler avec SELinux

SELinux, c'est un peu comme ce prof strict qui surveille ce que font les fichiers et les utilisateurs sur ton serveur. Son slogan ? "Fais confiance, mais toujours vérifie". On va activer SELinux et voir comment il fonctionne.

Activer SELinux

Vérifier l'état actuel :
```
# Vérifions si SELinux est activé
sestatus
```
Si le mode affiche disabled, il faut l'activer via le fichier de configuration.
Activer SELinux via la config :

Le fichier de configuration SELinux se trouve ici : /etc/selinux/config. Ouvre-le avec un éditeur de texte (genre nano).
```
sudo nano /etc/selinux/config
```
Cherche cette ligne :
```
SELINUX=disabled
```
Remplace-la par :
```
SELINUX=enforcing
```
Enregistre les modifs et redémarre le système pour que ça prenne effet :
```
sudo reboot
```
Vérifier après le redémarrage.

Après le démarrage du serveur, vérifie encore une fois l'état de SELinux :
```
getenforce
```
Si le système répond Enforcing, félicitations, t'es devenu le gardien de la sécurité !

Exemple avec SELinux et un serveur web

Imaginons que t'as un serveur web qui stocke des fichiers dans le répertoire /var/www/html. Voyons comment SELinux le protège.

Regarder le contexte des fichiers : SELinux utilise des contextes pour gérer les accès. Jetons un œil au contexte du répertoire /var/www/html.
```
ls -Z /var/www/html
```
Exemple de sortie :
```
drwxr-xr-x. root root system_u:object_r:httpd_sys_content_t:s0 /var/www/html
```
Si quelque chose cloche, tu peux temporairement changer le contexte :
```
sudo chcon -t httpd_sys_content_t /var/www/html
```
Vérifier le fonctionnement du serveur web : Après avoir configuré le contexte, vérifie si ton serveur fonctionne et si y'a pas d'erreurs d'accès.

3. Étape 3 : Gestion des droits avec ACL

ACL (Access Control List) — c'est comme une "clé supplémentaire" pour gérer l'accès. Quand les permissions standards rwx limitent, ACL te permet de configurer l'accès de manière plus précise pour des utilisateurs spécifiques.

Créer un répertoire de test

Créons le répertoire project_dir et configurons-le pour qu'il soit accessible par deux utilisateurs : user1 et user2.

Créer le répertoire :
```
sudo mkdir /project_dir
```

Configurer les permissions :

On va permettre à user1 un accès complet, et à user2 seulement la lecture :

# Accès complet pour user1
sudo setfacl -m u:user1:rwx /project_dir

# Lecture seule pour user2
sudo setfacl -m u:user2:r-- /project_dir

Vérifier les ACL :

# Vérification des permissions actuelles
getfacl /project_dir

Le résultat devrait afficher vos réglages :

# fichier: /project_dir
user::rwx
user:user1:rwx
user:user2:r--

Configurer les permissions par défaut :

Pour que tous les nouveaux fichiers dans le répertoire héritent automatiquement des permissions ACL, définissons-les par défaut :
```
sudo setfacl -d -m u:user1:rwx /project_dir
sudo setfacl -d -m u:user2:r-- /project_dir
```

4. Vérification de la configuration finale

Pare-feu :
- Assure-toi que les ports SSH et HTTP sont accessibles, et que les autres sont bloqués. Essaie de te connecter au serveur via SSH et d'ouvrir le site web dans un navigateur.
SELinux :
- Vérifie les contextes des fichiers pour t'assurer que SELinux limite correctement l'accès.
ACL :
- Connecte-toi en tant qu'utilisateur user1 et user2, puis essaie de lire et d'écrire un fichier dans le répertoire /project_dir.

Exercices pratiques

Configure un pare-feu permettant uniquement l'accès via SSH et HTTP.
Active SELinux en mode enforcing et assure-toi que le serveur web fonctionne correctement.
Configure ACL pour le répertoire /project_dir : donne à user1 un accès complet et à user2 un accès en lecture seule.
Vérifie les utilisateurs actifs dans le système en utilisant la commande who.

Ces exercices t'aideront à consolider tes connaissances et à comprendre comment les appliquer en pratique. Et rappelle-toi : la sécurité sous Linux ne se limite pas à la configuration, elle demande aussi une attention constante aux détails. Bonne chance !

Précédent Leçon précédente

Suivant Leçon suivante

Commentaires

TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION