1. Concepts fondamentaux

Sous Linux, chaque fichier et repertoire appartient a un utilisateur (owner) et a un groupe (group). Le systeme s'appuie sur des identifiants numeriques (UID/GID) pour gerer les acces. Comprendre ces mecanismes est essentiel pour securiser un serveur ou un poste de travail.

1.1 UID et GID

Chaque utilisateur possede un UID (User ID) et chaque groupe un GID (Group ID). Le systeme utilise ces nombres en interne, pas les noms textuels.

# Afficher l'UID et les GID de l'utilisateur courant
id

# Exemple de sortie :
# uid=1000(jean) gid=1000(jean) groupes=1000(jean),27(sudo),33(www-data)

# Afficher uniquement l'UID
id -u

# Afficher uniquement le GID primaire
id -g

# Afficher tous les GID
id -G

# Afficher les informations d'un autre utilisateur
id www-data

1.2 Le fichier /etc/passwd

Ce fichier contient la liste de tous les utilisateurs du systeme. Chaque ligne suit le format :

# Format : nom:mot_de_passe:UID:GID:commentaire:repertoire_home:shell
# Le champ mot_de_passe contient 'x' (le hash reel est dans /etc/shadow)

cat /etc/passwd

# Exemples de lignes :
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
jean:x:1000:1000:Jean Dupont,,,:/home/jean:/bin/bash

# Lister uniquement les utilisateurs avec un shell de connexion
grep -v '/nologin\|/false' /etc/passwd

# Compter le nombre d'utilisateurs
wc -l /etc/passwd

# Extraire uniquement les noms d'utilisateurs
cut -d: -f1 /etc/passwd

# Chercher un utilisateur specifique
getent passwd jean

1.3 Le fichier /etc/shadow

Ce fichier contient les mots de passe hashes et les informations d'expiration. Il n'est lisible que par root.

# Format : nom:hash:dernier_changement:min:max:warn:inactive:expire:reserve

sudo cat /etc/shadow

# Exemple de ligne :
# jean:$y$j9T$abc...xyz:19500:0:99999:7:::

# Les champs :
# - nom : nom de l'utilisateur
# - hash : mot de passe hashe ($y$ = yescrypt, $6$ = SHA-512, $5$ = SHA-256)
# - dernier_changement : jours depuis le 1er janvier 1970
# - min : nombre minimum de jours entre deux changements
# - max : nombre maximum de jours de validite
# - warn : jours d'avertissement avant expiration
# - inactive : jours apres expiration avant desactivation
# - expire : date d'expiration du compte (jours depuis epoch)

# Verifier les informations d'expiration d'un compte
sudo chage -l jean

1.4 Le fichier /etc/group

Ce fichier contient la liste de tous les groupes et leurs membres.

# Format : nom_groupe:mot_de_passe:GID:liste_membres

cat /etc/group

# Exemples :
root:x:0:
sudo:x:27:jean,admin
www-data:x:33:jean
docker:x:998:jean,deploy

# Lister les groupes d'un utilisateur
groups jean

# Chercher un groupe specifique
getent group sudo

# Lister tous les membres d'un groupe
getent group docker | cut -d: -f4

1.5 Le fichier /etc/login.defs

Ce fichier definit les valeurs par defaut pour la creation d'utilisateurs et la politique de mots de passe.

# Parametres importants dans /etc/login.defs

# Plage d'UID pour les utilisateurs normaux
UID_MIN                  1000
UID_MAX                 60000

# Plage de GID pour les groupes normaux
GID_MIN                  1000
GID_MAX                 60000

# Politique de mots de passe par defaut
PASS_MAX_DAYS           99999
PASS_MIN_DAYS           0
PASS_WARN_AGE           7

# Creer automatiquement le repertoire home
CREATE_HOME             yes

# Umask par defaut
UMASK                   022

# Methode de chiffrement des mots de passe
ENCRYPT_METHOD          YESCRYPT

2. Permissions de base

Chaque fichier et repertoire possede trois ensembles de permissions : pour le proprietaire (u), le groupe (g) et les autres (o). Les permissions sont : lecture (r=4), ecriture (w=2), execution (x=1).

2.1 Comprendre la notation rwx

# Afficher les permissions detaillees
ls -la /home/jean/

# Exemple de sortie :
# drwxr-xr-x  5 jean jean  4096 mars  12 10:00 .
# drwxr-xr-x  3 root root  4096 mars  10 08:00 ..
# -rw-r--r--  1 jean jean   220 mars  10 08:00 .bashrc
# -rwxr-x---  1 jean dev   8192 mars  12 09:30 script.sh
# drwxrwx---  2 jean www    4096 mars  11 14:00 web

# Decomposition : -rwxr-x---
# - : type (- = fichier, d = repertoire, l = lien symbolique)
# rwx : proprietaire peut lire, ecrire, executer
# r-x : groupe peut lire et executer
# --- : autres n'ont aucun acces

# Pour un repertoire :
# r = lister le contenu (ls)
# w = creer/supprimer des fichiers dans le repertoire
# x = traverser le repertoire (cd)

2.2 Notation octale

# Correspondance symbolique / octale :
# rwx = 4+2+1 = 7
# rw- = 4+2+0 = 6
# r-x = 4+0+1 = 5
# r-- = 4+0+0 = 4
# --- = 0+0+0 = 0

# Exemples courants :
# 755 = rwxr-xr-x  (repertoires, scripts)
# 644 = rw-r--r--  (fichiers de configuration)
# 600 = rw-------  (fichiers sensibles, cles SSH)
# 700 = rwx------  (repertoires prives)
# 775 = rwxrwxr-x  (repertoires partages avec le groupe)
# 664 = rw-rw-r--  (fichiers partages avec le groupe)
# 750 = rwxr-x---  (repertoires accessibles au groupe seulement)
# 440 = r--r-----  (fichiers en lecture seule, ex: sudoers)

2.3 chmod - Modifier les permissions

# Syntaxe octale
chmod 755 script.sh
chmod 644 config.conf
chmod 600 ~/.ssh/id_rsa
chmod 700 ~/.ssh

# Syntaxe symbolique
# u = user (proprietaire), g = group, o = others, a = all
chmod u+x script.sh          # Ajouter execution au proprietaire
chmod g+rw fichier.txt        # Ajouter lecture+ecriture au groupe
chmod o-rwx secret.txt        # Retirer tous les droits aux autres
chmod a+r readme.txt          # Ajouter lecture pour tout le monde
chmod ug+rw,o-rw partage.txt  # Combinaison

# Modifier recursivement (tout un repertoire)
chmod -R 755 /var/www/html/
chmod -R g+rw /srv/partage/

# Modifier uniquement les repertoires (pas les fichiers)
find /var/www/html -type d -exec chmod 755 {} \;

# Modifier uniquement les fichiers (pas les repertoires)
find /var/www/html -type f -exec chmod 644 {} \;

# Utiliser --reference pour copier les permissions d'un autre fichier
chmod --reference=fichier_modele.txt nouveau_fichier.txt

# Mode verbose pour voir les changements
chmod -v 644 *.conf

2.4 chown - Modifier le proprietaire

# Changer le proprietaire
sudo chown jean fichier.txt

# Changer le proprietaire et le groupe
sudo chown jean:www-data fichier.txt

# Changer uniquement le groupe (equivalent de chgrp)
sudo chown :www-data fichier.txt

# Recursivement
sudo chown -R www-data:www-data /var/www/html/

# Suivre les liens symboliques
sudo chown -L jean:jean /chemin/lien_symbolique

# Ne pas suivre les liens symboliques (defaut)
sudo chown -h jean:jean /chemin/lien_symbolique

# Mode verbose
sudo chown -Rv jean:jean /home/jean/

2.5 chgrp - Modifier le groupe

# Changer le groupe d'un fichier
sudo chgrp www-data /var/www/html/index.php

# Recursivement
sudo chgrp -R developers /srv/projet/

# Avec reference
sudo chgrp --reference=fichier_ref.txt autre_fichier.txt

2.6 umask - Masque de creation par defaut

Le umask definit les permissions retirees lors de la creation de nouveaux fichiers et repertoires. Par defaut, les fichiers sont crees en 666 et les repertoires en 777, moins le umask.

# Afficher le umask actuel
umask
# 0022 (notation octale)

umask -S
# u=rwx,g=rx,o=rx (notation symbolique)

# Avec umask 022 :
# Fichiers : 666 - 022 = 644 (rw-r--r--)
# Repertoires : 777 - 022 = 755 (rwxr-xr-x)

# Avec umask 027 :
# Fichiers : 666 - 027 = 640 (rw-r-----)
# Repertoires : 777 - 027 = 750 (rwxr-x---)

# Modifier temporairement le umask (session courante)
umask 027

# Modifier definitivement pour un utilisateur
# Ajouter dans ~/.bashrc ou ~/.profile :
echo "umask 027" >> ~/.bashrc

# Modifier definitivement pour tous les utilisateurs
# Editer /etc/profile ou /etc/login.defs (variable UMASK)

# Tester : creer un fichier et verifier les permissions
umask 077
touch test_umask.txt
ls -la test_umask.txt
# -rw------- 1 jean jean 0 mars 12 10:00 test_umask.txt

3. Permissions speciales

En plus des permissions classiques rwx, Linux dispose de trois permissions speciales : SUID, SGID et Sticky Bit. Elles sont representees par un chiffre supplementaire devant la notation octale (ex: 4755).

3.1 SUID (Set User ID) - Bit 4

Lorsqu'un fichier executable a le bit SUID, il s'execute avec les privileges de son proprietaire (et non de l'utilisateur qui le lance). Visible comme s a la place du x du proprietaire.

# Exemple classique : la commande passwd
ls -la /usr/bin/passwd
# -rwsr-xr-x 1 root root 68208 mars 10 /usr/bin/passwd
#    ^-- le 's' indique SUID

# Sans SUID, un utilisateur normal ne pourrait pas modifier /etc/shadow
# car ce fichier appartient a root

# Appliquer le bit SUID
sudo chmod u+s /usr/local/bin/mon_programme
sudo chmod 4755 /usr/local/bin/mon_programme

# Retirer le bit SUID
sudo chmod u-s /usr/local/bin/mon_programme

# Trouver tous les fichiers SUID sur le systeme
sudo find / -perm -4000 -type f 2>/dev/null

# Si le 's' est en majuscule 'S', le fichier n'a pas le bit x
# (SUID sans permission d'execution = inutile et suspect)
ls -la fichier_suspect
# -rwSr--r-- = SUID mais pas d'execution = probleme

3.2 SGID (Set Group ID) - Bit 2

Sur un fichier, SGID fait s'executer le programme avec les privileges du groupe proprietaire. Sur un repertoire, SGID force les nouveaux fichiers crees a heriter du groupe du repertoire parent (tres utile pour les repertoires partages).

# SGID sur un repertoire partage (cas le plus courant)
sudo mkdir /srv/projet-equipe
sudo chown root:developers /srv/projet-equipe
sudo chmod 2775 /srv/projet-equipe

ls -ld /srv/projet-equipe
# drwxrwsr-x 2 root developers 4096 mars 12 /srv/projet-equipe
#         ^-- le 's' indique SGID

# Maintenant, tout fichier cree dans ce repertoire
# appartiendra au groupe 'developers', quel que soit
# l'utilisateur qui le cree
touch /srv/projet-equipe/nouveau_fichier.txt
ls -la /srv/projet-equipe/nouveau_fichier.txt
# -rw-rw-r-- 1 jean developers ...

# Appliquer SGID
sudo chmod g+s /srv/projet-equipe/
sudo chmod 2775 /srv/projet-equipe/

# Retirer SGID
sudo chmod g-s /srv/projet-equipe/

# Trouver tous les fichiers/repertoires SGID
sudo find / -perm -2000 -type f 2>/dev/null
sudo find / -perm -2000 -type d 2>/dev/null

3.3 Sticky Bit - Bit 1

Sur un repertoire, le Sticky Bit empeche les utilisateurs de supprimer ou renommer les fichiers des autres, meme s'ils ont les droits d'ecriture sur le repertoire. Seul le proprietaire du fichier, le proprietaire du repertoire ou root peut supprimer.

# Exemple classique : /tmp
ls -ld /tmp
# drwxrwxrwt 15 root root 4096 mars 12 10:00 /tmp
#          ^-- le 't' indique le Sticky Bit

# Tout le monde peut creer dans /tmp, mais chacun
# ne peut supprimer que ses propres fichiers

# Appliquer le Sticky Bit
sudo chmod +t /srv/partage/
sudo chmod 1777 /srv/partage/

# Retirer le Sticky Bit
sudo chmod -t /srv/partage/

# Exemple pratique : repertoire de depot commun
sudo mkdir /srv/depot
sudo chmod 1777 /srv/depot
# Tout le monde peut deposer, personne ne peut supprimer les fichiers des autres

3.4 Resume des permissions speciales

# Notation octale complete : XYYY
# X = permissions speciales (SUID=4, SGID=2, Sticky=1)
# Y = permissions classiques (rwx pour user, group, others)

# Exemples :
# 4755 = SUID + rwxr-xr-x
# 2775 = SGID + rwxrwxr-x
# 1777 = Sticky + rwxrwxrwx
# 6755 = SUID+SGID + rwxr-xr-x

# Trouver TOUS les fichiers avec permissions speciales
sudo find / -perm /7000 -type f 2>/dev/null

4. ACL (Access Control Lists)

Les ACL permettent de definir des permissions plus granulaires que le modele classique user/group/others. Elles permettent d'accorder des droits specifiques a plusieurs utilisateurs ou groupes differents sur un meme fichier.

4.1 Installation et prerequis

# Debian / Ubuntu
sudo apt install acl

# Rocky Linux / AlmaLinux
sudo dnf install acl

# Verifier que le systeme de fichiers supporte les ACL
# (active par defaut sur ext4, xfs, btrfs)
mount | grep acl
# ou
tune2fs -l /dev/sda1 | grep "Default mount options"

# Si les ACL ne sont pas actives, les activer dans /etc/fstab :
# /dev/sda1  /  ext4  defaults,acl  0  1
# Puis remonter : sudo mount -o remount /

4.2 getfacl - Afficher les ACL

# Afficher les ACL d'un fichier
getfacl /srv/projet/document.txt

# Sortie typique :
# # file: srv/projet/document.txt
# # owner: jean
# # group: developers
# user::rw-
# user:marie:rw-          # ACL specifique pour marie
# user:admin:r--           # ACL specifique pour admin
# group::r--
# group:managers:r--       # ACL specifique pour le groupe managers
# mask::rw-
# other::---

# Afficher les ACL recursivement
getfacl -R /srv/projet/

# Afficher de maniere compacte
getfacl -c /srv/projet/document.txt

# Un '+' dans la sortie de ls indique la presence d'ACL
ls -la /srv/projet/document.txt
# -rw-rw----+ 1 jean developers 1024 mars 12 document.txt
#           ^-- le '+' indique des ACL

4.3 setfacl - Definir les ACL

# Ajouter une ACL pour un utilisateur
setfacl -m u:marie:rw /srv/projet/document.txt

# Ajouter une ACL pour un groupe
setfacl -m g:managers:r /srv/projet/document.txt

# Ajouter plusieurs ACL en une seule commande
setfacl -m u:marie:rw,u:admin:r,g:managers:rx /srv/projet/

# Supprimer l'ACL d'un utilisateur specifique
setfacl -x u:marie /srv/projet/document.txt

# Supprimer l'ACL d'un groupe specifique
setfacl -x g:managers /srv/projet/document.txt

# Supprimer TOUTES les ACL (revenir aux permissions classiques)
setfacl -b /srv/projet/document.txt

# Appliquer recursivement
setfacl -R -m u:marie:rwx /srv/projet/

# Copier les ACL d'un fichier vers un autre
getfacl source.txt | setfacl --set-file=- destination.txt

4.4 ACL par defaut (heritage)

Les ACL par defaut s'appliquent automatiquement aux nouveaux fichiers et sous-repertoires crees dans un repertoire.

# Definir des ACL par defaut sur un repertoire
setfacl -d -m u:marie:rwx /srv/projet/
setfacl -d -m g:developers:rwx /srv/projet/
setfacl -d -m o::--- /srv/projet/

# Verifier les ACL par defaut
getfacl /srv/projet/
# default:user::rwx
# default:user:marie:rwx
# default:group::r-x
# default:group:developers:rwx
# default:mask::rwx
# default:other::---

# Tout nouveau fichier dans /srv/projet/ heritera de ces ACL
touch /srv/projet/nouveau.txt
getfacl /srv/projet/nouveau.txt
# user:marie:rwx    (herite des ACL par defaut)

# Supprimer les ACL par defaut
setfacl -k /srv/projet/

# Exemple complet : repertoire de projet collaboratif
sudo mkdir -p /srv/projets/webapp
sudo chown root:developers /srv/projets/webapp
sudo chmod 2770 /srv/projets/webapp
setfacl -d -m g:developers:rwx /srv/projets/webapp
setfacl -d -m g:designers:rx /srv/projets/webapp
setfacl -m g:developers:rwx /srv/projets/webapp
setfacl -m g:designers:rx /srv/projets/webapp

4.5 Le masque ACL

Le masque definit les permissions maximales effectives pour les utilisateurs et groupes nommes dans les ACL. C'est une limite superieure.

# Definir le masque
setfacl -m m::rx /srv/projet/document.txt

# Avec ce masque, meme si marie a 'rwx' dans l'ACL,
# ses permissions effectives seront limitees a 'r-x'

# getfacl affiche les permissions effectives
getfacl /srv/projet/document.txt
# user:marie:rwx    #effective:r-x
# group:dev:rw-     #effective:r--

# Attention : chmod modifie le masque ACL !
# Apres un chmod g=rx, le masque ACL sera aussi r-x

4.6 Sauvegarde et restauration des ACL

# Sauvegarder les ACL d'une arborescence
getfacl -R /srv/projet/ > acl_backup.txt

# Restaurer les ACL depuis la sauvegarde
setfacl --restore=acl_backup.txt

# Utile avant une migration ou une restauration de backup
# car rsync et tar ne preservent pas toujours les ACL

# rsync avec preservation des ACL
rsync -avA /srv/projet/ /backup/projet/

# tar avec preservation des ACL
tar --acls -czf backup.tar.gz /srv/projet/
tar --acls -xzf backup.tar.gz

5. Gestion des utilisateurs

5.1 useradd - Creer un utilisateur

# Creer un utilisateur avec les options par defaut
sudo useradd jean

# Creer un utilisateur avec toutes les options courantes
sudo useradd -m -d /home/jean -s /bin/bash -c "Jean Dupont" -G sudo,www-data jean

# Options detaillees :
# -m            : creer le repertoire home
# -d /home/jean : specifier le chemin du home
# -s /bin/bash  : shell de connexion
# -c "..."      : commentaire (nom complet, GECOS)
# -G sudo,www   : groupes supplementaires
# -g developers : groupe primaire (par defaut = groupe du meme nom)
# -u 1500       : forcer un UID specifique
# -e 2026-12-31 : date d'expiration du compte
# -f 30         : jours d'inactivite apres expiration du mot de passe

# Creer un compte systeme (UID < 1000, sans home, sans shell)
sudo useradd -r -s /usr/sbin/nologin service-app

# Definir le mot de passe
sudo passwd jean

# Version non-interactive (utile dans les scripts)
echo "jean:MonMotDePasse" | sudo chpasswd

# Creer un utilisateur et definir le mot de passe en une seule etape
sudo useradd -m -s /bin/bash jean && echo "jean:TempPass123!" | sudo chpasswd

# Forcer le changement de mot de passe a la premiere connexion
sudo chage -d 0 jean

# adduser (interactif, Debian/Ubuntu uniquement)
sudo adduser jean
# Pose les questions : mot de passe, nom complet, telephone, etc.

# adduser avec groupe supplementaire
sudo adduser jean sudo
sudo adduser jean www-data

5.2 usermod - Modifier un utilisateur

# Changer le shell
sudo usermod -s /bin/zsh jean

# Changer le repertoire home (et deplacer les fichiers)
sudo usermod -d /home/nouveau_jean -m jean

# Ajouter a des groupes supplementaires (ATTENTION : -a est crucial !)
sudo usermod -aG docker jean
sudo usermod -aG sudo,www-data jean

# SANS -a, les groupes supplementaires sont REMPLACES (dangereux !)
# sudo usermod -G docker jean  # Retire jean de TOUS ses anciens groupes !

# Changer le nom de connexion
sudo usermod -l nouveau_nom ancien_nom

# Changer l'UID
sudo usermod -u 2000 jean

# Verrouiller un compte (desactiver la connexion)
sudo usermod -L jean

# Deverrouiller un compte
sudo usermod -U jean

# Definir une date d'expiration
sudo usermod -e 2026-12-31 jean

# Supprimer la date d'expiration
sudo usermod -e "" jean

# Changer le commentaire (nom complet)
sudo usermod -c "Jean Dupont - DevOps" jean

5.3 userdel - Supprimer un utilisateur

# Supprimer l'utilisateur (conserve le home et les fichiers)
sudo userdel jean

# Supprimer l'utilisateur ET son repertoire home
sudo userdel -r jean

# Forcer la suppression meme si l'utilisateur est connecte
sudo userdel -f jean

# Avant de supprimer, verifier les processus en cours
ps aux | grep jean

# Trouver tous les fichiers appartenant a un utilisateur
sudo find / -user jean 2>/dev/null

# Trouver les fichiers orphelins (UID sans utilisateur correspondant)
sudo find / -nouser 2>/dev/null

5.4 passwd - Gestion des mots de passe

# Changer son propre mot de passe
passwd

# Changer le mot de passe d'un autre utilisateur (root)
sudo passwd jean

# Verrouiller un mot de passe (ajoute ! devant le hash)
sudo passwd -l jean

# Deverrouiller un mot de passe
sudo passwd -u jean

# Supprimer le mot de passe (connexion sans mot de passe - dangereux)
sudo passwd -d jean

# Afficher le statut du mot de passe
sudo passwd -S jean
# jean P 03/12/2026 0 99999 7 -1
# P = mot de passe actif, L = verrouille, NP = pas de mot de passe

# Forcer l'expiration du mot de passe (changement au prochain login)
sudo passwd -e jean

5.5 chage - Politique d'expiration

# Afficher les informations d'expiration
sudo chage -l jean

# Sortie :
# Dernier changement de mot de passe          : mars 12, 2026
# Le mot de passe expire                       : jamais
# Mot de passe inactif                         : jamais
# Le compte expire                             : jamais
# Nb min de jours entre changements            : 0
# Nb max de jours entre changements            : 99999
# Nombre de jours d'avertissement              : 7

# Definir la duree maximale du mot de passe (90 jours)
sudo chage -M 90 jean

# Definir le delai minimum entre deux changements (1 jour)
sudo chage -m 1 jean

# Definir le nombre de jours d'avertissement (14 jours)
sudo chage -W 14 jean

# Definir la date d'expiration du compte
sudo chage -E 2026-12-31 jean

# Definir le nombre de jours d'inactivite apres expiration
sudo chage -I 30 jean

# Forcer le changement au prochain login
sudo chage -d 0 jean

# Mode interactif (poser toutes les questions)
sudo chage jean

5.6 /etc/skel - Modele de repertoire home

# Le contenu de /etc/skel est copie dans le home de chaque nouvel utilisateur
ls -la /etc/skel/

# Fichiers par defaut :
# .bashrc     - Configuration du shell bash
# .profile    - Script execute a la connexion
# .bash_logout - Script execute a la deconnexion

# Ajouter des fichiers modeles pour les nouveaux utilisateurs
sudo cp /chemin/vers/config_defaut /etc/skel/.bashrc

# Ajouter un repertoire modele
sudo mkdir /etc/skel/Documents
sudo mkdir /etc/skel/.ssh
sudo chmod 700 /etc/skel/.ssh

# Exemple : ajouter un .vimrc par defaut
sudo tee /etc/skel/.vimrc << 'EOF'
set number
set tabstop=4
set shiftwidth=4
set expandtab
syntax on
EOF

# Les fichiers de /etc/skel sont copies avec useradd -m ou adduser

6. Gestion des groupes

6.1 groupadd - Creer un groupe

# Creer un groupe
sudo groupadd developers

# Creer un groupe avec un GID specifique
sudo groupadd -g 2000 webteam

# Creer un groupe systeme (GID < 1000)
sudo groupadd -r service-group

# Verifier la creation
getent group developers
grep developers /etc/group

6.2 groupmod - Modifier un groupe

# Renommer un groupe
sudo groupmod -n nouveau_nom ancien_nom

# Changer le GID d'un groupe
sudo groupmod -g 3000 developers

# Attention : changer le GID ne met pas a jour les fichiers
# Il faut corriger les fichiers manuellement :
sudo find / -gid 2000 -exec chgrp developers {} \; 2>/dev/null

6.3 groupdel - Supprimer un groupe

# Supprimer un groupe
sudo groupdel developers

# On ne peut pas supprimer un groupe qui est le groupe primaire
# d'un utilisateur. Il faut d'abord changer son groupe primaire :
sudo usermod -g autregroupe jean
sudo groupdel developers

# Trouver les fichiers orphelins (GID sans groupe correspondant)
sudo find / -nogroup 2>/dev/null

6.4 gpasswd - Gestion avancee des groupes

# Ajouter un utilisateur a un groupe
sudo gpasswd -a jean developers

# Supprimer un utilisateur d'un groupe
sudo gpasswd -d jean developers

# Definir la liste des membres (remplace tous les membres)
sudo gpasswd -M jean,marie,admin developers

# Definir un administrateur du groupe
# (peut ajouter/supprimer des membres sans etre root)
sudo gpasswd -A jean developers

# L'administrateur peut ensuite gerer les membres :
gpasswd -a marie developers   # jean n'a pas besoin de sudo

# Definir un mot de passe pour le groupe
# (permet a d'autres utilisateurs de rejoindre avec newgrp)
sudo gpasswd developers

6.5 Groupe primaire vs groupes secondaires

# Chaque utilisateur a exactement UN groupe primaire
# et peut avoir ZERO ou PLUSIEURS groupes secondaires

# Le groupe primaire est utilise pour les nouveaux fichiers crees
# Les groupes secondaires accordent des permissions supplementaires

# Afficher le groupe primaire
id -gn jean

# Afficher tous les groupes (primaire + secondaires)
groups jean
id jean

# Changer le groupe primaire
sudo usermod -g developers jean

# Ajouter des groupes secondaires (garder les existants avec -a)
sudo usermod -aG docker,www-data jean

# Changer de groupe actif temporairement (dans le shell courant)
newgrp developers
# Les fichiers crees utiliseront maintenant 'developers' comme groupe

# Quitter le groupe temporaire
exit

6.6 Exemple pratique : environnement collaboratif

# Scenario : equipe de developpement web avec differents niveaux d'acces

# Creer les groupes
sudo groupadd webdev
sudo groupadd webdesign
sudo groupadd webadmin

# Creer les utilisateurs et les assigner aux groupes
sudo useradd -m -s /bin/bash -G webdev alice
sudo useradd -m -s /bin/bash -G webdev,webadmin bob
sudo useradd -m -s /bin/bash -G webdesign charlie

# Creer le repertoire de projet
sudo mkdir -p /srv/www/projet
sudo chown root:webdev /srv/www/projet
sudo chmod 2775 /srv/www/projet

# Ajouter des ACL pour les designers (lecture seule)
setfacl -R -m g:webdesign:rx /srv/www/projet
setfacl -R -d -m g:webdesign:rx /srv/www/projet

# Ajouter des ACL pour les admins (controle total)
setfacl -R -m g:webadmin:rwx /srv/www/projet
setfacl -R -d -m g:webadmin:rwx /srv/www/projet

# Verifier la configuration
getfacl /srv/www/projet

7. Sudo et elevation de privileges

sudo permet a un utilisateur autorise d'executer des commandes en tant qu'un autre utilisateur (generalement root). La configuration se fait dans /etc/sudoers.

7.1 Configuration de base

# Toujours editer /etc/sudoers avec visudo (verifie la syntaxe)
sudo visudo

# Format d'une regle sudoers :
# QUI  OU=(EN_TANT_QUE)  QUOI
# user host=(runas_user)  commande

# Exemples dans /etc/sudoers :

# root peut tout faire
root    ALL=(ALL:ALL) ALL

# Les membres du groupe sudo peuvent tout faire (Debian/Ubuntu)
%sudo   ALL=(ALL:ALL) ALL

# Les membres du groupe wheel peuvent tout faire (RHEL/Rocky/Alma)
%wheel  ALL=(ALL:ALL) ALL

# jean peut tout faire sur toutes les machines
jean    ALL=(ALL:ALL) ALL

# marie peut redemarrer nginx sans mot de passe
marie   ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx

# le groupe deploy peut deployer sans mot de passe
%deploy ALL=(ALL) NOPASSWD: /usr/local/bin/deploy.sh

7.2 Regles sudoers avancees

# Utiliser des alias pour simplifier la gestion
# Alias d'utilisateurs
User_Alias ADMINS = jean, marie, admin
User_Alias DEVS = alice, bob, charlie

# Alias de commandes
Cmnd_Alias SERVICES = /usr/bin/systemctl start *, \
                       /usr/bin/systemctl stop *, \
                       /usr/bin/systemctl restart *, \
                       /usr/bin/systemctl status *

Cmnd_Alias PACKAGES = /usr/bin/apt update, \
                       /usr/bin/apt upgrade, \
                       /usr/bin/apt install *

Cmnd_Alias NETWORKING = /usr/sbin/iptables, \
                         /usr/bin/ss, \
                         /usr/sbin/ip

# Appliquer les alias
ADMINS  ALL=(ALL:ALL) ALL
DEVS    ALL=(ALL) NOPASSWD: SERVICES
DEVS    ALL=(ALL) PACKAGES

# Autoriser un utilisateur a executer en tant qu'un autre utilisateur
jean    ALL=(www-data) /usr/bin/php, /usr/bin/composer

# Interdire certaines commandes
jean    ALL=(ALL) ALL, !/usr/bin/su, !/usr/bin/bash, !/usr/bin/sh

# Limiter a certains hotes
jean    webserver01=(ALL) SERVICES

7.3 Fichiers dans /etc/sudoers.d/

# Bonne pratique : ne pas modifier /etc/sudoers directement
# Creer des fichiers dans /etc/sudoers.d/ a la place

# Verifier que l'inclusion est active dans /etc/sudoers :
# @includedir /etc/sudoers.d
# ou (ancienne syntaxe) :
# #includedir /etc/sudoers.d

# Creer un fichier de regles pour les developpeurs
sudo visudo -f /etc/sudoers.d/developers

# Contenu du fichier :
%developers ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart php*-fpm, \
                                /usr/bin/systemctl restart nginx, \
                                /usr/bin/systemctl restart apache2

# Creer un fichier pour un utilisateur specifique
sudo visudo -f /etc/sudoers.d/jean

# Permissions du fichier (IMPORTANT)
# Les fichiers dans sudoers.d doivent avoir les permissions 440
sudo chmod 440 /etc/sudoers.d/developers
sudo chmod 440 /etc/sudoers.d/jean

# Verifier la syntaxe d'un fichier sudoers
sudo visudo -cf /etc/sudoers.d/developers
# /etc/sudoers.d/developers: parsed OK

7.4 Sudo sans mot de passe

# Pour un utilisateur specifique (toutes commandes)
jean ALL=(ALL) NOPASSWD: ALL

# Pour un groupe specifique (toutes commandes)
%deploy ALL=(ALL) NOPASSWD: ALL

# Pour des commandes specifiques uniquement
jean ALL=(ALL) NOPASSWD: /usr/bin/systemctl restart nginx, \
                         /usr/bin/journalctl -u nginx

# Augmenter le delai du cache sudo (par defaut 15 minutes)
# Ajouter dans /etc/sudoers :
Defaults timestamp_timeout=30

# Desactiver le cache (demander le mot de passe a chaque fois)
Defaults timestamp_timeout=0

# Desactiver le mot de passe pour tous les membres de sudo
%sudo ALL=(ALL) NOPASSWD: ALL

7.5 Commandes sudo courantes

# Executer une commande en tant que root
sudo commande

# Executer en tant qu'un autre utilisateur
sudo -u www-data commande
sudo -u postgres psql

# Ouvrir un shell root
sudo -i        # Shell de login (charge le profil de root)
sudo -s        # Shell simple (garde l'environnement actuel)
sudo su -      # Equivalent de sudo -i

# Lister les droits sudo de l'utilisateur courant
sudo -l

# Lister les droits sudo d'un autre utilisateur
sudo -l -U jean

# Editer un fichier avec les droits root (conserve l'editeur de l'utilisateur)
sudo -e /etc/nginx/nginx.conf
# ou
sudoedit /etc/nginx/nginx.conf

# Reinitialiser le cache du mot de passe sudo
sudo -k

# Valider le mot de passe sans executer de commande
sudo -v

7.6 Groupes sudo et wheel

# Sur Debian/Ubuntu : le groupe 'sudo' accorde les privileges sudo
sudo usermod -aG sudo jean

# Sur RHEL/Rocky/AlmaLinux : le groupe 'wheel' accorde les privileges sudo
sudo usermod -aG wheel jean

# Verifier l'appartenance
groups jean

# Verifier que la regle est active dans sudoers
sudo grep -E '^%sudo|^%wheel' /etc/sudoers

8. PAM (Pluggable Authentication Modules)

PAM est le framework d'authentification modulaire de Linux. Il permet de configurer de maniere flexible comment les utilisateurs s'authentifient, quelles sont les limites appliquees et quelles actions sont effectuees a la connexion.

8.1 Structure de PAM

# Les fichiers de configuration PAM se trouvent dans /etc/pam.d/
ls /etc/pam.d/

# Fichiers courants :
# common-auth      - regles d'authentification communes (Debian/Ubuntu)
# common-account   - regles de gestion de compte
# common-password  - regles de changement de mot de passe
# common-session   - regles de session
# system-auth      - equivalent sur RHEL/Rocky/Alma
# password-auth    - equivalent sur RHEL/Rocky/Alma
# sshd             - regles specifiques a SSH
# login            - regles pour la connexion locale
# sudo             - regles pour sudo

# Format d'une ligne PAM :
# type  controle  module  [arguments]

# Types :
# auth      - authentification de l'utilisateur
# account   - verification du compte (expire, horaires, etc.)
# password  - changement de mot de passe
# session   - actions a l'ouverture/fermeture de session

# Controles :
# required    - doit reussir, continue meme en cas d'echec
# requisite   - doit reussir, arret immediat en cas d'echec
# sufficient  - si reussit, pas besoin de verifier les suivants
# optional    - echec ou succes sans consequence
# include     - inclure un autre fichier de configuration

8.2 pam_pwquality - Politique de mots de passe

# Installation
sudo apt install libpam-pwquality    # Debian/Ubuntu
sudo dnf install pam_pwquality       # Rocky/Alma

# Configuration dans /etc/security/pwquality.conf
sudo nano /etc/security/pwquality.conf

# Parametres recommandes :
minlen = 12           # Longueur minimale
dcredit = -1          # Au moins 1 chiffre
ucredit = -1          # Au moins 1 majuscule
lcredit = -1          # Au moins 1 minuscule
ocredit = -1          # Au moins 1 caractere special
minclass = 3          # Au moins 3 categories de caracteres
maxrepeat = 3         # Maximum 3 caracteres identiques consecutifs
maxclassrepeat = 4    # Maximum 4 caracteres de la meme classe consecutifs
reject_username       # Refuser si contient le nom d'utilisateur
enforce_for_root      # Appliquer aussi a root
dictcheck = 1         # Verifier dans le dictionnaire

# Verifier que le module est actif dans PAM
# Debian/Ubuntu : /etc/pam.d/common-password
grep pwquality /etc/pam.d/common-password
# password requisite pam_pwquality.so retry=3

# RHEL/Rocky/Alma : /etc/pam.d/system-auth
grep pwquality /etc/pam.d/system-auth

8.3 pam_limits - Limites de ressources

# Configuration dans /etc/security/limits.conf
sudo nano /etc/security/limits.conf

# Format : domaine  type  item  valeur
# domaine : utilisateur, @groupe, *
# type : soft (avertissement), hard (limite stricte)

# Exemples :

# Limiter le nombre de fichiers ouverts
jean        soft    nofile    4096
jean        hard    nofile    65536
@developers soft    nofile    8192
@developers hard    nofile    65536

# Limiter le nombre de processus
*           soft    nproc     4096
*           hard    nproc     8192

# Limiter la memoire
@webservers hard    as        2097152    # 2 Go en Ko

# Limiter la taille des fichiers core dump
*           hard    core      0          # Desactiver les core dumps

# Limiter le nombre de sessions simultanees
jean        hard    maxlogins 3

# Priorite des processus
@batch      soft    priority  19         # Basse priorite

# Appliquer immediatement (sans redemarrage)
# Verifier les limites actuelles :
ulimit -a

# Verifier les limites d'un processus en cours
cat /proc/$(pidof nginx)/limits

# Les limites sont chargees par le module PAM
# Verifier dans /etc/pam.d/common-session :
grep limits /etc/pam.d/common-session
# session required pam_limits.so

# Fichiers supplementaires dans /etc/security/limits.d/
sudo tee /etc/security/limits.d/90-developers.conf << 'EOF'
@developers soft nofile 8192
@developers hard nofile 65536
EOF

8.4 pam_access - Controle d'acces

# Configuration dans /etc/security/access.conf
sudo nano /etc/security/access.conf

# Format : permission : utilisateurs : origines
# permission : + (autoriser) ou - (refuser)

# Autoriser root uniquement en local et depuis un sous-reseau
+ : root : 192.168.1.0/24
+ : root : LOCAL
- : root : ALL

# Autoriser le groupe admins depuis n'importe ou
+ : @admins : ALL

# Autoriser jean depuis un sous-reseau specifique
+ : jean : 10.0.0.0/8

# Refuser tout le reste
- : ALL : ALL

# Activer pam_access dans /etc/pam.d/sshd (par exemple) :
# Ajouter la ligne :
# account required pam_access.so

# Tester avant d'activer definitivement !
# Garder une session root ouverte en cas d'erreur

8.5 Historique d'echecs de connexion

# Verrouillage apres echecs de connexion avec pam_faillock (RHEL 8+/Rocky 9+)
# Configuration dans /etc/security/faillock.conf
sudo nano /etc/security/faillock.conf

deny = 5              # Verrouiller apres 5 echecs
unlock_time = 600     # Deverrouiller apres 600 secondes (10 min)
fail_interval = 900   # Fenetre de temps pour compter les echecs
audit                 # Journaliser les evenements
even_deny_root        # Appliquer aussi a root (optionnel)

# Consulter les echecs de connexion
faillock --user jean

# Reinitialiser les compteurs d'echecs
sudo faillock --user jean --reset

# Sur Debian/Ubuntu, utiliser pam_tally2 ou pam_faillock
# /etc/pam.d/common-auth :
# auth required pam_faillock.so preauth
# auth required pam_faillock.so authfail

9. SELinux et AppArmor

SELinux et AppArmor sont des systemes de controle d'acces obligatoire (MAC - Mandatory Access Control). Ils ajoutent une couche de securite supplementaire au-dessus des permissions classiques Unix.

9.1 SELinux (Rocky Linux / AlmaLinux / RHEL)

9.1.1 Concepts

# SELinux attribue un contexte de securite a chaque fichier, processus, port
# Format du contexte : utilisateur:role:type:niveau
# Exemple : system_u:object_r:httpd_sys_content_t:s0

# Trois modes de fonctionnement :
# Enforcing  - SELinux actif et applique les regles
# Permissive - SELinux actif mais ne bloque pas (journalise seulement)
# Disabled   - SELinux completement desactive

9.1.2 Commandes de base

# Verifier le mode actuel
getenforce
# Enforcing

# Verifier le statut complet
sestatus
# SELinux status:                 enabled
# SELinuxfs mount:                /sys/fs/selinux
# SELinux root directory:         /etc/selinux
# Loaded policy name:             targeted
# Current mode:                   enforcing
# Mode from config file:          enforcing

# Changer le mode temporairement (jusqu'au prochain redemarrage)
sudo setenforce 0    # Passer en permissive
sudo setenforce 1    # Passer en enforcing

# Changer le mode definitivement
sudo nano /etc/selinux/config
# SELINUX=enforcing    (ou permissive ou disabled)
# Necessite un redemarrage

9.1.3 Contextes de fichiers

# Afficher les contextes SELinux des fichiers
ls -laZ /var/www/html/
# -rw-r--r--. root root system_u:object_r:httpd_sys_content_t:s0 index.html

# Afficher le contexte d'un processus
ps auxZ | grep httpd
# system_u:system_r:httpd_t:s0 apache ... /usr/sbin/httpd

# Modifier le contexte d'un fichier
sudo chcon -t httpd_sys_content_t /var/www/html/nouveau.html

# Modifier recursivement
sudo chcon -R -t httpd_sys_content_t /var/www/html/

# Restaurer le contexte par defaut (selon la politique)
sudo restorecon -v /var/www/html/nouveau.html
sudo restorecon -Rv /var/www/html/

# Definir un contexte par defaut pour un chemin
sudo semanage fcontext -a -t httpd_sys_content_t "/srv/www(/.*)?"
sudo restorecon -Rv /srv/www/

# Lister les contextes par defaut
sudo semanage fcontext -l | grep /var/www

9.1.4 Booleens SELinux

# Les booleens permettent d'activer/desactiver des fonctionnalites

# Lister tous les booleens
getsebool -a

# Lister les booleens lies a httpd
getsebool -a | grep httpd

# Activer un booleen temporairement
sudo setsebool httpd_can_network_connect on

# Activer un booleen definitivement (-P = persistent)
sudo setsebool -P httpd_can_network_connect on

# Booleens httpd courants :
sudo setsebool -P httpd_can_network_connect on        # Connexions reseau sortantes
sudo setsebool -P httpd_can_sendmail on                # Envoi d'emails
sudo setsebool -P httpd_enable_homedirs on             # Acces aux homes
sudo setsebool -P httpd_can_network_connect_db on      # Connexion BDD distante

9.1.5 Diagnostic des problemes SELinux

# Installer les outils de diagnostic
sudo dnf install setroubleshoot-server setools-console

# Verifier les logs SELinux
sudo ausearch -m avc -ts recent
sudo ausearch -m avc --start today

# Utiliser sealert pour des diagnostics lisibles
sudo sealert -a /var/log/audit/audit.log

# Generer un module pour autoriser une action bloquee
sudo ausearch -m avc -ts recent | audit2allow -M mon_module
sudo semodule -i mon_module.pp

# Lister les modules SELinux
sudo semodule -l

# Verifier les ports autorises pour un service
sudo semanage port -l | grep http
# http_port_t    tcp    80, 81, 443, 488, 8008, 8009, 8443, 9000

# Ajouter un port autorise
sudo semanage port -a -t http_port_t -p tcp 8080

9.2 AppArmor (Ubuntu / Debian)

9.2.1 Concepts

# AppArmor confine les programmes avec des profils de securite
# Chaque profil definit les fichiers, reseaux et capacites accessibles

# Deux modes :
# enforce  - Le profil est actif et applique
# complain - Le profil journalise mais ne bloque pas (mode apprentissage)

9.2.2 Commandes de base

# Verifier le statut d'AppArmor
sudo aa-status
# ou
sudo apparmor_status

# Sortie typique :
# apparmor module is loaded.
# 25 profiles are loaded.
# 20 profiles are in enforce mode.
# 5 profiles are in complain mode.
# 12 processes have profiles defined.

# Installation des outils supplementaires
sudo apt install apparmor-utils apparmor-profiles apparmor-profiles-extra

# Lister les profils
ls /etc/apparmor.d/

# Profils courants :
# /etc/apparmor.d/usr.sbin.nginx
# /etc/apparmor.d/usr.sbin.mysqld
# /etc/apparmor.d/usr.bin.firefox

9.2.3 Gestion des profils

# Mettre un profil en mode enforce
sudo aa-enforce /etc/apparmor.d/usr.sbin.nginx
# ou par nom de programme
sudo aa-enforce /usr/sbin/nginx

# Mettre un profil en mode complain (apprentissage)
sudo aa-complain /etc/apparmor.d/usr.sbin.nginx
sudo aa-complain /usr/sbin/nginx

# Desactiver un profil
sudo aa-disable /etc/apparmor.d/usr.sbin.nginx

# Recharger un profil apres modification
sudo apparmor_parser -r /etc/apparmor.d/usr.sbin.nginx

# Recharger tous les profils
sudo systemctl reload apparmor

# Generer un nouveau profil (mode interactif)
sudo aa-genprof /usr/local/bin/mon_app

# Scanner les logs et mettre a jour un profil
sudo aa-logprof

9.2.4 Structure d'un profil AppArmor

# Exemple de profil pour un script personnalise
# /etc/apparmor.d/usr.local.bin.mon_app

#include 

/usr/local/bin/mon_app {
  #include 
  #include 

  # Lecture de la configuration
  /etc/mon_app/** r,
  /etc/mon_app/config.conf r,

  # Acces au repertoire de travail
  /var/lib/mon_app/ r,
  /var/lib/mon_app/** rw,

  # Logs
  /var/log/mon_app/ r,
  /var/log/mon_app/** w,

  # Fichiers temporaires
  /tmp/mon_app_* rw,

  # Acces reseau
  network tcp,

  # Execution d'autres programmes
  /usr/bin/curl ix,

  # Capacites
  capability net_bind_service,
}

# Charger le profil
sudo apparmor_parser -r /etc/apparmor.d/usr.local.bin.mon_app

9.2.5 Diagnostic AppArmor

# Verifier les refus dans les logs
sudo journalctl | grep apparmor | grep DENIED

# Ou dans le fichier de log
sudo grep "apparmor=\"DENIED\"" /var/log/syslog

# Scanner les logs et proposer des corrections
sudo aa-logprof

# Mode debug temporaire pour un profil
sudo aa-complain /etc/apparmor.d/usr.sbin.nginx
# Tester, puis revenir en enforce :
sudo aa-enforce /etc/apparmor.d/usr.sbin.nginx

10. Bonnes pratiques

10.1 Principe du moindre privilege

# Regles fondamentales :
# - N'accorder que les permissions strictement necessaires
# - Eviter de travailler en root au quotidien
# - Utiliser sudo pour les taches administratives
# - Limiter les regles sudo au strict necessaire
# - Utiliser des comptes de service sans shell pour les applications

# Creer un compte de service securise
sudo useradd -r -s /usr/sbin/nologin -d /var/lib/monapp -M monapp-service

# Verifier qu'aucun utilisateur n'a un mot de passe vide
sudo awk -F: '($2 == "") {print $1}' /etc/shadow

# Lister les utilisateurs avec UID 0 (doivent etre uniquement root)
awk -F: '($3 == 0) {print $1}' /etc/passwd

# Verifier les permissions des fichiers sensibles
ls -la /etc/passwd      # Doit etre 644
ls -la /etc/shadow      # Doit etre 640 ou 600
ls -la /etc/group       # Doit etre 644
ls -la /etc/gshadow     # Doit etre 640 ou 600
ls -la /etc/sudoers     # Doit etre 440

# Desactiver le login root par mot de passe
sudo passwd -l root

# Verifier que le login root SSH est desactive
grep "^PermitRootLogin" /etc/ssh/sshd_config
# Doit etre : PermitRootLogin no (ou prohibit-password)

10.2 Audit avec auditd

# Installation
sudo apt install auditd audispd-plugins    # Debian/Ubuntu
sudo dnf install audit                      # Rocky/Alma

# Demarrer et activer le service
sudo systemctl enable --now auditd

# Ajouter des regles d'audit

# Surveiller les modifications de /etc/passwd
sudo auditctl -w /etc/passwd -p wa -k passwd_changes

# Surveiller les modifications de /etc/shadow
sudo auditctl -w /etc/shadow -p wa -k shadow_changes

# Surveiller les modifications de /etc/sudoers
sudo auditctl -w /etc/sudoers -p wa -k sudoers_changes
sudo auditctl -w /etc/sudoers.d/ -p wa -k sudoers_d_changes

# Surveiller les changements de permissions
sudo auditctl -a always,exit -F arch=b64 -S chmod,fchmod,fchmodat -k perm_changes

# Surveiller les changements de proprietaire
sudo auditctl -a always,exit -F arch=b64 -S chown,fchown,lchown,fchownat -k owner_changes

# Surveiller les connexions
sudo auditctl -w /var/log/lastlog -p wa -k logins
sudo auditctl -w /var/log/faillog -p wa -k logins

# Rendre les regles permanentes
# Ajouter dans /etc/audit/rules.d/access.rules :
sudo tee /etc/audit/rules.d/access.rules << 'EOF'
-w /etc/passwd -p wa -k passwd_changes
-w /etc/shadow -p wa -k shadow_changes
-w /etc/sudoers -p wa -k sudoers_changes
-w /etc/sudoers.d/ -p wa -k sudoers_d_changes
-a always,exit -F arch=b64 -S chmod,fchmod,fchmodat -k perm_changes
-a always,exit -F arch=b64 -S chown,fchown,lchown,fchownat -k owner_changes
EOF

# Recharger les regles
sudo augenrules --load

# Lister les regles actives
sudo auditctl -l

# Rechercher des evenements d'audit
sudo ausearch -k passwd_changes
sudo ausearch -k sudoers_changes --start today

# Generer un rapport
sudo aureport
sudo aureport --auth     # Rapport d'authentification
sudo aureport --login    # Rapport de connexions
sudo aureport --file     # Rapport d'acces fichiers

10.3 Recherche de fichiers avec permissions specifiques

# Trouver les fichiers world-writable (ecriture pour tous)
sudo find / -type f -perm -0002 -not -path "/proc/*" -not -path "/sys/*" 2>/dev/null

# Trouver les repertoires world-writable sans sticky bit
sudo find / -type d -perm -0002 ! -perm -1000 -not -path "/proc/*" 2>/dev/null

# Trouver les fichiers SUID
sudo find / -type f -perm -4000 2>/dev/null

# Trouver les fichiers SGID
sudo find / -type f -perm -2000 2>/dev/null

# Trouver les fichiers sans proprietaire
sudo find / -nouser 2>/dev/null

# Trouver les fichiers sans groupe
sudo find / -nogroup 2>/dev/null

# Trouver les fichiers modifies dans les dernieres 24h
sudo find /etc -type f -mtime -1 2>/dev/null

# Trouver les fichiers avec des permissions trop ouvertes dans /home
sudo find /home -type f -perm /go+w 2>/dev/null

# Trouver les cles SSH avec des permissions trop ouvertes
find /home -name "*.pub" -o -name "id_*" -o -name "authorized_keys" 2>/dev/null | \
xargs ls -la 2>/dev/null

10.4 Securisation des repertoires critiques

# Permissions recommandees pour les repertoires systeme
sudo chmod 755 /etc /usr /var /opt
sudo chmod 700 /root
sudo chmod 1777 /tmp /var/tmp

# Permissions pour un site web (Apache/Nginx)
sudo chown -R www-data:www-data /var/www/html
sudo find /var/www/html -type d -exec chmod 755 {} \;
sudo find /var/www/html -type f -exec chmod 644 {} \;

# Repertoire d'upload (ecriture pour le serveur web seulement)
sudo chmod 770 /var/www/html/uploads
sudo chown www-data:www-data /var/www/html/uploads

# Fichiers de configuration sensibles
sudo chmod 600 /etc/ssh/sshd_config
sudo chmod 600 /etc/ssl/private/*

# Proteger les cles SSH
chmod 700 ~/.ssh
chmod 600 ~/.ssh/id_rsa
chmod 644 ~/.ssh/id_rsa.pub
chmod 600 ~/.ssh/authorized_keys
chmod 644 ~/.ssh/known_hosts

# Proteger les fichiers cron
sudo chmod 600 /etc/crontab
sudo chmod 700 /etc/cron.d /etc/cron.daily /etc/cron.hourly /etc/cron.monthly /etc/cron.weekly

# Empecher les utilisateurs de voir les processus des autres (hidepid)
# Ajouter dans /etc/fstab :
# proc  /proc  proc  defaults,hidepid=2  0  0
# Puis : sudo mount -o remount /proc

10.5 Script d'audit rapide

#!/bin/bash
# audit-permissions.sh - Script d'audit des permissions

echo "=== AUDIT DES PERMISSIONS ==="
echo "Date : $(date)"
echo ""

echo "--- Utilisateurs avec UID 0 ---"
awk -F: '($3 == 0) {print $1}' /etc/passwd

echo ""
echo "--- Utilisateurs sans mot de passe ---"
sudo awk -F: '($2 == "" || $2 == "!") {print $1}' /etc/shadow

echo ""
echo "--- Fichiers SUID ---"
find / -type f -perm -4000 2>/dev/null | sort

echo ""
echo "--- Fichiers SGID ---"
find / -type f -perm -2000 2>/dev/null | sort

echo ""
echo "--- Fichiers world-writable ---"
find / -type f -perm -0002 -not -path "/proc/*" -not -path "/sys/*" -not -path "/dev/*" 2>/dev/null

echo ""
echo "--- Repertoires world-writable sans sticky bit ---"
find / -type d -perm -0002 ! -perm -1000 -not -path "/proc/*" -not -path "/sys/*" 2>/dev/null

echo ""
echo "--- Fichiers sans proprietaire ---"
find / -nouser -not -path "/proc/*" -not -path "/sys/*" 2>/dev/null

echo ""
echo "--- Fichiers sans groupe ---"
find / -nogroup -not -path "/proc/*" -not -path "/sys/*" 2>/dev/null

echo ""
echo "--- Permissions des fichiers critiques ---"
ls -la /etc/passwd /etc/shadow /etc/group /etc/gshadow /etc/sudoers 2>/dev/null

echo ""
echo "=== FIN DE L'AUDIT ==="

11. Depannage

Diagnostiquer les problemes d'acces est une competence essentielle. Voici les outils et methodes pour identifier rapidement la cause d'un refus d'acces.

11.1 Commandes de diagnostic

# Verifier l'identite de l'utilisateur courant
whoami
id

# Verifier les groupes effectifs
groups

# Verifier les informations d'un utilisateur specifique
id jean
getent passwd jean
getent group | grep jean

# Verifier les permissions d'un fichier
ls -la /chemin/vers/fichier
stat /chemin/vers/fichier

# stat donne des informations detaillees
stat /var/www/html/index.php
#  File: /var/www/html/index.php
#  Size: 1234       Blocks: 8          IO Block: 4096   regular file
# Device: 801h/2049d  Inode: 131073      Links: 1
# Access: (0644/-rw-r--r--)  Uid: (   33/www-data)   Gid: (   33/www-data)
# Access: 2026-03-12 10:00:00.000000000 +0100
# Modify: 2026-03-12 09:30:00.000000000 +0100
# Change: 2026-03-12 09:30:00.000000000 +0100

# Verifier les permissions sur tout le chemin d'acces
namei -l /var/www/html/uploads/document.pdf
# f: /var/www/html/uploads/document.pdf
# drwxr-xr-x root     root     /
# drwxr-xr-x root     root     var
# drwxr-xr-x root     root     www
# drwxr-xr-x www-data www-data html
# drwxrwx--- www-data www-data uploads
# -rw-r--r-- www-data www-data document.pdf

# namei est ESSENTIEL pour diagnostiquer les problemes d'acces
# Si un repertoire parent n'a pas le bit 'x', l'acces est impossible

11.2 Problemes courants et solutions

# PROBLEME : "Permission denied" sur un fichier
# 1. Verifier les permissions classiques
ls -la /chemin/vers/fichier
# 2. Verifier tout le chemin
namei -l /chemin/vers/fichier
# 3. Verifier les ACL
getfacl /chemin/vers/fichier
# 4. Verifier SELinux/AppArmor
ls -laZ /chemin/vers/fichier           # SELinux
sudo journalctl | grep apparmor        # AppArmor

# PROBLEME : Un utilisateur ne peut pas acceder a un repertoire
# meme avec les bonnes permissions sur le fichier final
# -> Verifier le bit 'x' sur TOUS les repertoires parents
namei -l /srv/web/app/public/index.html
# Solution :
sudo chmod o+x /srv /srv/web /srv/web/app /srv/web/app/public

# PROBLEME : Apres ajout a un groupe, les permissions ne fonctionnent pas
# -> L'utilisateur doit se deconnecter/reconnecter
# Verification :
id jean         # Affiche les groupes effectifs
groups jean     # Affiche les groupes configures
# Solution temporaire :
newgrp nom_du_groupe
# Solution definitive : deconnexion/reconnexion

# PROBLEME : "Operation not permitted" meme en root
# -> Peut etre cause par des attributs etendus (immutable)
lsattr /chemin/vers/fichier
# ----i--------e-- fichier   (le 'i' = immutable)
# Solution :
sudo chattr -i /chemin/vers/fichier

# PROBLEME : chmod/chown ne fonctionne pas sur un montage NFS
# -> Verifier les options de montage NFS
mount | grep nfs
# Verifier : no_root_squash ou root_squash dans /etc/exports

# PROBLEME : Les fichiers crees n'ont pas les bonnes permissions
# -> Verifier le umask
umask
# -> Verifier les ACL par defaut
getfacl /chemin/du/repertoire/parent

11.3 Journaux systeme

# Verifier les logs d'authentification
# Debian/Ubuntu
sudo tail -f /var/log/auth.log

# Rocky/AlmaLinux
sudo tail -f /var/log/secure

# Avec journalctl (systemd)
sudo journalctl -u sshd --since today
sudo journalctl _COMM=sudo --since "1 hour ago"
sudo journalctl -t su --since today

# Rechercher les echecs d'authentification
sudo journalctl -p err --since today | grep -i auth
sudo grep "Failed password" /var/log/auth.log

# Dernières connexions
last
last jean
lastb          # Connexions echouees (necessite root)
lastlog        # Derniere connexion de chaque utilisateur

# Verifier les connexions en cours
who
w
users

# Logs SELinux
sudo ausearch -m avc --start today
sudo sealert -a /var/log/audit/audit.log

# Logs AppArmor
sudo journalctl | grep "apparmor=\"DENIED\""
sudo grep "apparmor" /var/log/syslog

11.4 Tester les acces sans se connecter

# Tester l'acces a un fichier en tant qu'un autre utilisateur
sudo -u www-data test -r /var/www/html/index.php && echo "Lecture OK" || echo "Lecture REFUSEE"
sudo -u www-data test -w /var/www/html/index.php && echo "Ecriture OK" || echo "Ecriture REFUSEE"
sudo -u www-data test -x /var/www/html/script.sh && echo "Execution OK" || echo "Execution REFUSEE"

# Tester l'acces a un repertoire
sudo -u www-data ls /var/www/html/uploads/ 2>&1

# Executer une commande en tant qu'un autre utilisateur
sudo -u www-data cat /var/www/html/config.php

# Ouvrir un shell en tant qu'un autre utilisateur
sudo -u www-data bash
# ou
sudo su - www-data -s /bin/bash

# Verifier les droits sudo d'un utilisateur
sudo -l -U jean

11.5 Recapitulatif des commandes essentielles

# Diagnostic rapide en cas de probleme d'acces :

# 1. Qui suis-je ?
id

# 2. Quelles sont les permissions du fichier ?
ls -la /chemin/vers/fichier
stat /chemin/vers/fichier

# 3. Y a-t-il des ACL ?
getfacl /chemin/vers/fichier

# 4. Le chemin complet est-il accessible ?
namei -l /chemin/vers/fichier

# 5. Y a-t-il des attributs speciaux ?
lsattr /chemin/vers/fichier

# 6. SELinux bloque-t-il ? (RHEL/Rocky/Alma)
getenforce
ls -laZ /chemin/vers/fichier
sudo ausearch -m avc --start recent

# 7. AppArmor bloque-t-il ? (Ubuntu/Debian)
sudo aa-status
sudo journalctl | grep "apparmor=\"DENIED\"" | tail -5

# 8. Que disent les logs ?
sudo journalctl --since "5 minutes ago" | grep -i "denied\|error\|permission"

# 9. Le systeme de fichiers est-il monte en lecture seule ?
mount | grep "on /chemin"

# 10. Le disque est-il plein ?
df -h /chemin/vers/fichier