Droits D'Accès Linux : Sécurise Ton Système !

🎯 Objectifs de ce cours

À la fin, tu seras capable de :

✅ Comprendre les droits Linux : Utilisateurs, groupes, permissions
✅ Lire les droits : Décoder rwxr-xr-x et les notations octales
✅ Modifier les droits : chmod, chown, chgrp sans peur
✅ Protéger tes fichiers : Éviter les failles de sécurité
✅ Gérer les utilisateurs et groupes : Collaborer en sécurité
✅ Utiliser sudo correctement : Escalade de privilèges responsable
✅ Mettre en place une sécurité DevOps : Déploiements protégés

❌ Le Problème : Accès Non Contrôlé

Imagine ça :

Sur un serveur Linux, plusieurs personnes travaillent :
  • Alice (développeuse)
  • Bob (DevOps)
  • Charlie (testeur)

Sans contrôle des droits :
  ❌ Charlie pourrait accidentellement supprimer la DB d'Alice
  ❌ Un pirate s'infiltre et peut tout modifier
  ❌ Les données sensibles sont lisibles par tous
  ❌ Les déploiements peuvent être modifiés n'importe comment
  ❌ Les scripts critiques peuvent être changés par erreur

Avec une bonne gestion des droits ?

  ✅ Alice peut lire/modifier ses fichiers uniquement
  ✅ Bob peut déployer mais pas modifier le code
  ✅ Charlie teste sans rien casser
  ✅ Un pirate entre, mais peut rien faire
  ✅ Les scripts critiques sont protégés

❌ Désastre	✅ Sécurisé
chmod 777 (tout le monde accès complet)	chmod 755 (le propriétaire contrôle, les autres lisent)
Fichiers de config lisibles par tous	Secrets protégés, seul l'app peut les lire
N'importe qui peut modifier les scripts	Scripts critiques en lecture seule
Tout accès en tant que root	sudo pour les actions admin uniquement

Les droits, c'est la base de la sécurité DevOps.

🏗️ L'Architecture : Utilisateurs, Groupes, Droits

Le Système Multi-Utilisateur

Linux est conçu pour plusieurs utilisateurs simultanés :

Utilisateur: alice
  ├─ Fichiers personnels
  ├─ Groupe: dev
  └─ Permissions spécifiques

Utilisateur: bob
  ├─ Fichiers personnels
  ├─ Groupe: devops
  └─ Permissions spécifiques

Utilisateur: root (administrateur)
  └─ TOUS les droits (attention!)

Les Trois Acteurs : U / G / O

┌─────────────────────────────────────┐
│  Un fichier ou dossier appartient à │
├─────────────────────────────────────┤
│  u (user)     = propriétaire        │
│  g (group)    = groupe              │
│  o (others)   = tous les autres     │
└─────────────────────────────────────┘

Exemple :

ls -l deploy.sh
-rwxr-x--- 1 alice devops 1024 Jan 28 10:00 deploy.sh

Décodage :
  - (fichier, pas dossier)
  rwx (alice: lecture/écriture/exécution)
  r-x (groupe devops: lecture/exécution)
  --- (autres: rien du tout)
  alice (propriétaire)
  devops (groupe)

🔐 Les Trois Droits : R / W / X

┌──────────┬──────────────────────────────────────────────────────┐
│ Droit    │ Sur un FICHIER         │ Sur un DOSSIER              │
├──────────┼────────────────────────┬─────────────────────────────┤
│ r (4)    │ Lire le contenu        │ Lister le contenu (ls)      │
│ w (2)    │ Modifier/supprimer     │ Créer/supprimer fichiers    │
│ x (1)    │ Exécuter (script/app)  │ Entrer dans le dossier (cd) │
└──────────┴────────────────────────┴─────────────────────────────┘

Cas Concret :

ls -l
d rwx r-x r-x alice dev 4096 /home/alice/scripts

Pour Alice (propriétaire) :
  • r (4) : Je peux lister le contenu (ls /home/alice/scripts)
  • w (2) : Je peux créer/supprimer des fichiers dedans
  • x (1) : Je peux entrer dedans (cd /home/alice/scripts)
  = rwx = 7 = "je contrôle tout"

Pour le groupe dev :
  • r (4) : Ils peuvent voir les fichiers
  • - (0) : Ils ne peuvent rien ajouter/supprimer
  • x (1) : Ils peuvent entrer dedans
  = r-x = 5

Pour les autres :
  • r (4) : Ils peuvent voir les fichiers
  • - (0) : Ils ne peuvent rien ajouter/supprimer
  • x (1) : Ils peuvent entrer dedans
  = r-x = 5

Résumé : 755 = "maître + spectateurs"

👀 Lire Les Droits

Afficher Les Droits

ls -l

Exemple :

$ ls -l /var/www/app/

total 48
-rw-r--r-- 1 www-data www-data 2048 Jan 28 09:00 index.php
-rw-r--r-- 1 www-data www-data 1024 Jan 28 09:00 config.php
drwxr-xr-x 2 www-data www-data 4096 Jan 28 09:00 uploads/
-rwxr-xr-x 1 root root 512 Jan 28 09:00 deploy.sh

Décodage Ligne Par Ligne

-rw-r--r-- 1 www-data www-data 2048 Jan 28 09:00 index.php
│ │  │  │
│ │  │  └─ Autres: --- (rien)
│ │  └─── Groupe: r-- (lecture seule)
│ └───── Propriétaire: rw- (lecture + écriture)
└─────── Type: - (fichier)

Type │ Propriétaire │ Groupe │ Autres │ nbre Liens │ Propriétaire │ Groupe │ Taille │ Date │ Nom Fichier

Les Symboles Clés

- = fichier régulier
d = dossier (directory)
l = lien symbolique

Exemple d'un script bash protégé :

-rwxr-xr-x 1 deploy devops 2048 Jan 28 10:00 production-deploy.sh

Lecture :
  - = fichier
  rwx = deploy peut lire/modifier/exécuter
  r-x = groupe devops peut lire et exécuter (mais pas modifier)
  r-x = autres peuvent lire et exécuter
  Notation octale = 755

🔢 La Notation Octale : 0-7

Chaque droit a une valeur numérique :

r (read)    = 4
w (write)   = 2
x (execute) = 1

Additionne-les pour chaque catégorie :

rwx = 4+2+1 = 7  (tous les droits)
rw- = 4+2   = 6  (lecture + écriture)
r-x = 4+1   = 5  (lecture + exécution)
r-- = 4     = 4  (lecture seule)
-wx = 2+1   = 3  (écriture + exécution)
-w- = 2     = 2  (écriture seule)
--x = 1     = 1  (exécution seule)
--- = 0     = 0  (rien)

Exemples Pratiques

chmod 755 script.sh
  │   │││
  │   ├─ 7 = rwx (propriétaire: tous les droits)
  │   ├─ 5 = r-x (groupe: lecture + exécution)
  │   └─ 5 = r-x (autres: lecture + exécution)
  └─ Commande chmod

chmod 644 config.php
  │   │││
  │   ├─ 6 = rw- (propriétaire: lecture + écriture)
  │   ├─ 4 = r-- (groupe: lecture seule)
  │   └─ 4 = r-- (autres: lecture seule)

chmod 400 secret-key.txt
  │   │││
  │   ├─ 4 = r-- (propriétaire: lecture seule)
  │   ├─ 0 = --- (groupe: rien)
  │   └─ 0 = --- (autres: rien)
  Fichier hautement sécurisé

Convertir Octale ↔ Symbolique

Octale	Symbole	Sens
777	rwxrwxrwx	Tout le monde, tout pouvoir (⚠️ DANGEREUX)
755	rwxr-xr-x	Propriétaire maître, les autres exécutent
750	rwxr-x---	Propriétaire + groupe contrôlent, autres dehors
700	rwx------	Propriétaire seul
644	rw-r--r--	Propriétaire peut modifier, les autres lisent
640	rw-r-----	Propriétaire + groupe contrôlent, les autres dehors
600	rw-------	Propriétaire seul, pas exécution
400	r--------	Lecture seule, propriétaire seul
000	---------	Bloqué complètement

✏️ Modifier Les Droits : chmod

Notation Octale (Plus Simple)

chmod 755 script.sh
chmod 644 config.php
chmod 600 secret.txt

Cas d'usage DevOps :

# Script de déploiement : tout le monde peut l'exécuter
chmod 755 /opt/scripts/deploy.sh

# Config sensible : propriétaire seul peut lire
chmod 600 /etc/myapp/database.conf

# Fichiers statiques : lisibles par tous
chmod 644 /var/www/html/index.html

Notation Symbolique (Plus Flexible)

chmod [u|g|o|a][+|-|=][r|w|x] fichier
         └─ Qui   |      └─ Quel droit (Read|Write|eXecute)
                  └─ Ajouter/Retirer/Définir

Exemples :

# Ajouter droit d'exécution au propriétaire
chmod u+x script.sh

# Retirer écriture du groupe
chmod g-w config.txt

# Donner lecture/exécution à tous
chmod a+rx document.pdf

# Retirer tous les droits des autres
chmod o-rwx secret.txt

# Donner lecture/écriture au groupe
chmod g+rw report.xlsx

Cas d'usage :

# Rendre un script exécutable immédiatement après création
chmod +x deploy.sh

# Retirer accès aux autres utilisateurs du serveur
chmod o-rx secrets.conf

# Donner droits à tout le groupe dev
chmod g+rw project-files/

Modifier Récursivement Un Dossier

# Appliquer à tous les fichiers et sous-dossiers
chmod -R 755 /home/alice/scripts/

# Retirer droits en profondeur
chmod -R o-rwx /var/www/sensitive-data/

👤 Changer Propriétaire Et Groupe : chown / chgrp

Changer Le Propriétaire

chown alice deploy.sh
# deploy.sh appartient maintenant à alice

Cas d'usage :

# Après un backup, attribuer la DB à l'utilisateur correct
chown postgres /var/lib/postgresql/data/backup.sql

# Transférer un projet à un nouveau développeur
chown bob /home/bob/project/

Changer Le Groupe

chgrp devops deploy.sh
# Le groupe de deploy.sh est maintenant devops

Cas d'usage :

# Mettre des scripts à disposition d'une équipe
chgrp developers /opt/scripts/

# Fichier de config pour un service
chgrp postgres /etc/postgresql/config.conf

Changer Les Deux En Même Temps

chown alice:devops deploy.sh
        │     │
        │     └─ Groupe
        └─ Propriétaire

# Ou avec -chown seulement propriétaire
chown alice: deploy.sh  # Garde le groupe existant

Cas d'usage DevOps :

# Nouvelle app, tout attribuer à l'utilisateur app et groupe web
chown app:web /opt/myapp/

# Changer propriétaire d'un dossier entier
chown -R nginx:nginx /var/www/html/

# Script de déploiement : propriétaire deploy, groupe devops
chown -R deploy:devops /opt/deploy-scripts/

Vérifier Propriétaire/Groupe

ls -l fichier.txt
stat fichier.txt     # Plus de détails

👥 Utilisateurs Et Groupes

Voir Tes Informations

whoami           # Qui suis-je ?
id               # Mes infos (UID, GID, groupes)
id -ng           # Mon groupe principal
id -nG           # Tous mes groupes

Exemple :

$ id
uid=1001(alice) gid=1002(dev) groupes=1002(dev),1003(devops),4(adm)

Traduction :
  • Je suis alice (UID 1001)
  • Mon groupe principal est dev (GID 1002)
  • Je suis aussi dans les groupes devops et adm

Voir Tous Les Utilisateurs Et Groupes

cat /etc/passwd      # Liste des utilisateurs
cat /etc/group       # Liste des groupes

Ajouter Un Utilisateur À Un Groupe

# Syntaxe
usermod -aG groupname username

# Exemple : ajouter alice au groupe docker
sudo usermod -aG docker alice

# Ajouter bob à plusieurs groupes
sudo usermod -aG dev,devops,sudo bob

Après, l'utilisateur doit se reconnecter pour que le changement prenne effet.

🔑 Utiliser sudo : Escalade De Privilèges

Qu'est-Ce Que sudo ?

Au lieu d'être root, tu executes UNE COMMANDE en tant que root.

# Sans sudo : tu es alice
$ whoami
alice

# Avec sudo : cette commande s'exécute en tant que root
$ sudo whoami
root

# Après : tu es de nouveau alice
$ whoami
alice

Utilisation Basique

sudo commande arguments

# Exemples
sudo apt update
sudo systemctl restart nginx
sudo useradd newuser
sudo chown root:root /etc/config.conf

Vérifier Si Tu Peux Utiliser sudo

sudo -l      # Liste les commandes que tu peux faire en sudo

# Ou simple test
sudo whoami  # Si ça affiche "root", c'est bon

Cas d'Usage DevOps

# Installer un package système
sudo apt install nodejs

# Redémarrer un service
sudo systemctl restart myapp

# Modifier un fichier système
sudo nano /etc/myapp/config.conf

# Changer propriétaire/groupe (nécessite droits admin)
sudo chown root:root /opt/critical-app/

# Voir les logs système
sudo journalctl -xe

# Arrêter/démarrer une interface réseau
sudo ip link set eth0 down

⚠️ Bonnes Pratiques

# ❌ NE PAS faire
sudo bash        # Ne pas devenir root interactivement
sudo -i          # Ne pas faire un shell root

# ✅ BON
sudo commande-specifique

# ❌ DANGER
sudo chmod 777 /etc/important  # Jamais 777 !
sudo rm -rf /var/www/*         # Attention avec rm !

# ✅ BON
sudo chmod 755 /etc/important
sudo rm -rf /var/www/old/

Configurer sudo (Très Avancé)

# Ne pas faire sans expérience !
sudo visudo      # Édite la config sudo en sécurité

Exemple de config sudo :

# Utilisateur alice peut utiliser docker sans mot de passe
alice ALL=(ALL) NOPASSWD: /usr/bin/docker

# Groupe devops peut exécuter les scripts de déploiement
%devops ALL=(ALL) /opt/scripts/deploy.sh

🎯 Cas D'Usage DevOps Réels

1️⃣ Sécuriser Une Application Web

# App tourne sous www-data, dossier appartient à www-data
sudo chown -R www-data:www-data /var/www/myapp/

# Permissions : www-data contrôle tout, autres lisent juste
sudo chmod -R 755 /var/www/myapp/

# Fichier de config très sensible : www-data seul
sudo chmod 600 /var/www/myapp/config/database.conf

# Dossier uploads : www-data peut écrire
sudo chmod 775 /var/www/myapp/uploads/

2️⃣ Protéger Les Scripts De Déploiement

# Les scripts sont détenus par l'équipe devops
sudo chown -R deploy:devops /opt/scripts/

# Propriétaire peut tout faire
# Groupe devops peut exécuter et lire
# Autres : rien du tout
sudo chmod -R 750 /opt/scripts/

# Script particulier : personne ne peut le modifier
sudo chmod 555 /opt/scripts/critical-backup.sh

3️⃣ Données Sensibles (Clés API, Secrets)

# Fichier de secrets : propriétaire seul peut lire
sudo chmod 600 /opt/app/secrets.env

# Changer propriétaire si l'app change
sudo chown app:app /opt/app/secrets.env

# Aucune entrée pour les autres
sudo chmod go-rwx /opt/app/secrets.env

4️⃣ Collaboration Entre DevOps Et Développeurs

# Dossier partagé
mkdir /shared/project

# Propriétaire : alice (dev lead)
# Groupe : devops (equipe)
sudo chown alice:devops /shared/project

# Alice contrôle, groupe devops peut lire et ajouter
sudo chmod 775 /shared/project

# Fichiers dedans : compatibles
sudo chmod 664 /shared/project/*

5️⃣ Service Systemd Sécurisé

# App tourne avec utilisateur spécifique
sudo useradd -r -s /bin/false myservice

# Fichiers de l'app
sudo chown -R myservice:myservice /opt/myservice/

# App peut lire/exécuter, autres non
sudo chmod -R 750 /opt/myservice/

# Fichier de config
sudo chmod 640 /opt/myservice/config.conf

# Log files
sudo chmod 755 /var/log/myservice/
sudo chmod 640 /var/log/myservice/*.log

⚠️ Les Pièges Courants

❌ Erreur	✅ Solution	🎯 Pourquoi
`chmod 777 /etc/config`	`chmod 755 /etc/config`	777 = n'importe qui peut tout faire !
`chmod 777 /root`	`chmod 700 /root`	Home du root doit être protégé
Oublier le `-R` pour changer dossiers	`sudo chown -R user:group dossier/`	Sinon seul le dossier change
Ne pas vérifier droits existants	`ls -l` avant de faire des changements	Évite les fausses manipulations
Donner `sudo` à des scripts sans contrôle	Limiter avec `visudo`	Risque de sécurité énorme
Garder secrets en `644`	`chmod 600 secrets.env`	Tout le monde peut lire les API keys !
Oublier que les permissions s'héritent	Utiliser `-R` et vérifier les sous-fichiers	Les fichiers vieux peuvent rester mal sécurisés
Ne pas changer de propriétaire après déploiement	`chown app:app /opt/app` après extraction	L'app peut ne pas avoir accès à ses fichiers

🧠 Debugging : Quand l'Accès Est Refusé

"Permission Denied"

$ ./script.sh
bash: ./script.sh: Permission denied

Solution :
$ ls -l script.sh
-rw-r--r-- alice alice script.sh
         ^ Pas x !

Fix :
$ chmod +x script.sh
$ ./script.sh
OK !

"Cannot Open File"

$ cat /root/.ssh/id_rsa
cat: /root/.ssh/id_rsa: Permission denied

Raison : tu n'es pas root, et le fichier est protégé

Option 1 (déconseillé) :
$ sudo cat /root/.ssh/id_rsa

Option 2 (bon) :
Demander à l'admin de copier la clé là où tu as accès

Vérifier Droits En Cascade

ls -ld /home
ls -ld /home/alice
ls -ld /home/alice/docs
ls -l /home/alice/docs/document.txt

# Chacun doit avoir au minimum rx (r-x = 5)
# pour que tu puisses entrer et voir les fichiers

🧾 Cheat Sheet : Droits Et Permissions

But	Commande	Exemple
Voir les droits	`ls -l`	`ls -l script.sh`
Rendre exécutable	`chmod +x`	`chmod +x script.sh`
Droits octaux	`chmod NNN`	`chmod 755 script.sh`
Ajouter droit	`chmod u+x`	`chmod u+x script.sh`
Retirer droit	`chmod g-w`	`chmod g-w config.txt`
Récursif	`chmod -R`	`chmod -R 755 dossier/`
Changer proprio	`chown user`	`chown alice file.txt`
Changer groupe	`chgrp group`	`chgrp dev file.txt`
Tous les deux	`chown u:g`	`chown alice:dev file.txt`
Récursif proprio	`chown -R`	`chown -R alice:dev /home/alice/`
Voir groupes	`id -nG`	`id -nG`
Ajouter à groupe	`usermod -aG`	`sudo usermod -aG docker alice`
Sudo une commande	`sudo`	`sudo systemctl restart app`
Vérifier sudo	`sudo -l`	`sudo -l`

🎯 Tableau De Référence : Droits Classiques

Droits	Octal	Utilisation	Exemple
`rwxr-xr-x`	755	Scripts/exécutables, lisibles par tous	`chmod 755 deploy.sh`
`rwxr-x---`	750	Scripts d'équipe, privés aux autres	`chmod 750 internal-script.sh`
`rwx------`	700	Script perso, secret total	`chmod 700 my-secret.sh`
`rw-r--r--`	644	Fichiers de config standards	`chmod 644 config.php`
`rw-r-----`	640	Config sensible (app + groupe)	`chmod 640 database.conf`
`rw-------`	600	Config très sensible (app seule)	`chmod 600 api-keys.env`
`r--------`	400	Lecture seule, backup	`chmod 400 backup.sql`
`rwxrwxrwx`	777	⚠️ DANGER ! Jamais utiliser	Ne JAMAIS faire

🚀 Tips Pro

1️⃣ Toujours Vérifier Avant De Changer

# Voir l'état actuel
ls -l fichier

# PUIS changer
chmod 755 fichier

# PUIS vérifier
ls -l fichier

2️⃣ Utiliser Umask Pour Les Droits Par Défaut

# Voir le umask courant
umask

# Changer pour nouveaux fichiers
umask 022   # Nouveaux fichiers = 644

3️⃣ Créer Des Dossiers Protégés

# Dossier partagé sécurisé
mkdir /shared/project
chmod 775 /shared/project
chown alice:devops /shared/project

# Les fichiers dedans hériteront des droits du groupe
# (selon le umask)

4️⃣ Script Pour Vérifier Les Droits Dangereux

#!/bin/bash
# Trouver les fichiers trop ouverts
find / -perm 777 -type f 2>/dev/null
find / -perm 777 -type d 2>/dev/null

# Résultat = DANGER, à corriger !

5️⃣ Utiliser `stat` Pour Plus De Détails

stat fichier.txt

# Affiche :
# - Accès (permissions)
# - Propriétaire/groupe
# - Dates modification
# - Taille

🎯 Checklist : Tu Maîtrises Les Droits Quand...

✅ Tu lis rwxr-xr-x et tu sais ce que c'est (755)
✅ Tu convertis octal ↔ symbole mentalement
✅ Tu utilises chmod +x sans réfléchir
✅ Tu protèges les fichiers sensibles en 600
✅ Tu utilises chown pour changer propriétaire
✅ Tu ajoutes des utilisateurs aux groupes avec usermod
✅ Tu utilises sudo responsablement
✅ Tu ne fais JAMAIS chmod 777 sur rien
✅ Tu vérifies toujours les droits avec ls -l
✅ Tu debugues "Permission denied" rapidement

🚀 Prochaines Étapes

Maintenant que tu maîtrises les droits :

Apprendre les ACL (Access Control Lists) : Droits plus granulaires
Configurer SELinux/AppArmor : Sécurité avancée
Chiffrer les données sensibles : GPG, openssl
Implémenter RBAC dans tes scripts : Contrôle d'accès par rôle
Auditer les droits régulièrement : Trouver les failles de sécurité
Combiner avec sudo : Scripts sécurisés pour toute l'équipe

Les droits Linux, c'est la première ligne de défense contre les intrusions. La maîtriser, c'est être un vrai DevOps. 🛡️

Tu maitrises maintenant Terminal + Droits + Scripting = tu es armé pour sécuriser n'importe quel système ! 🚀

Droits D'Accès Linux : Sécurise Ton Système !

🎯 Objectifs de ce cours

❌ Le Problème : Accès Non Contrôlé

🏗️ L'Architecture : Utilisateurs, Groupes, Droits

Le Système Multi-Utilisateur

Les Trois Acteurs : U / G / O

🔐 Les Trois Droits : R / W / X

👀 Lire Les Droits

Afficher Les Droits

Décodage Ligne Par Ligne

Les Symboles Clés

🔢 La Notation Octale : 0-7

Exemples Pratiques

Convertir Octale ↔ Symbolique

✏️ Modifier Les Droits : chmod

Notation Octale (Plus Simple)

Notation Symbolique (Plus Flexible)

Modifier Récursivement Un Dossier

👤 Changer Propriétaire Et Groupe : chown / chgrp

Changer Le Propriétaire

Changer Le Groupe

Changer Les Deux En Même Temps

Vérifier Propriétaire/Groupe

👥 Utilisateurs Et Groupes

Voir Tes Informations

Voir Tous Les Utilisateurs Et Groupes

Ajouter Un Utilisateur À Un Groupe

🔑 Utiliser sudo : Escalade De Privilèges

Qu'est-Ce Que sudo ?

Utilisation Basique

Vérifier Si Tu Peux Utiliser sudo

Cas d'Usage DevOps

⚠️ Bonnes Pratiques

Configurer sudo (Très Avancé)

🎯 Cas D'Usage DevOps Réels

1️⃣ Sécuriser Une Application Web

2️⃣ Protéger Les Scripts De Déploiement

3️⃣ Données Sensibles (Clés API, Secrets)

4️⃣ Collaboration Entre DevOps Et Développeurs

5️⃣ Service Systemd Sécurisé

⚠️ Les Pièges Courants

🧠 Debugging : Quand l'Accès Est Refusé

"Permission Denied"

"Cannot Open File"

Vérifier Droits En Cascade

🧾 Cheat Sheet : Droits Et Permissions

🎯 Tableau De Référence : Droits Classiques

🚀 Tips Pro

1️⃣ Toujours Vérifier Avant De Changer

2️⃣ Utiliser Umask Pour Les Droits Par Défaut

3️⃣ Créer Des Dossiers Protégés

4️⃣ Script Pour Vérifier Les Droits Dangereux

5️⃣ Utiliser stat Pour Plus De Détails

🎯 Checklist : Tu Maîtrises Les Droits Quand...

🚀 Prochaines Étapes

5️⃣ Utiliser `stat` Pour Plus De Détails