Fichiers et permissions

Fichiers et permissions#

Hide code cell source

 
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import seaborn as sns

sns.set_theme(style="whitegrid", palette="muted", font_scale=1.1)

Opérations sur les fichiers et répertoires#

Avant d’aborder les permissions, il convient de maîtriser les opérations fondamentales sur les fichiers. Linux offre un ensemble de commandes simples et composables pour créer, copier, déplacer et supprimer des fichiers et des répertoires.

touch — créer un fichier ou mettre à jour ses horodatages#

Définition 10 (La commande touch)

touch a deux usages principaux :

  1. Créer un fichier vide s’il n’existe pas encore.

  2. Mettre à jour les horodatages (timestamps) d’un fichier existant sans modifier son contenu (atime = access time, mtime = modification time).

# Créer un fichier vide
touch nouveau_fichier.txt

# Créer plusieurs fichiers en une seule commande
touch fichier1.txt fichier2.txt fichier3.txt

# Créer des fichiers avec expansion d'accolades (brace expansion)
touch fichier{1..5}.txt       # crée fichier1.txt à fichier5.txt

# Mettre à jour uniquement l'heure d'accès (-a)
touch -a fichier.txt

# Mettre à jour uniquement l'heure de modification (-m)
touch -m fichier.txt

# Définir un horodatage spécifique
touch -t 202403151430 fichier.txt    # 15 mars 2024 à 14h30
touch -d "2024-03-15 14:30:00" fichier.txt

# Vérifier les horodatages
stat fichier.txt

cp — copier des fichiers et répertoires#

# Copier un fichier
cp source.txt destination.txt

# Copier dans un répertoire
cp source.txt /tmp/

# Copier plusieurs fichiers dans un répertoire
cp fichier1.txt fichier2.txt /tmp/

# Copier avec expansion de jokers
cp *.txt /tmp/

# -r ou -R : copier un répertoire de façon récursive
cp -r dossier_source/ dossier_destination/

# -p : préserver les permissions, propriétaire et horodatages
cp -p fichier.txt copie.txt

# -a : archive (équivalent de -dpR) : préserver tout, récursif
cp -a source/ destination/

# -i : demander confirmation si la destination existe déjà
cp -i source.txt destination.txt

# -u : ne copier que si la source est plus récente que la destination
cp -u source.txt destination.txt

# -v : verbose (afficher ce qui est copié)
cp -rv source/ destination/

# Copier un fichier vers le répertoire courant
cp /etc/nginx/nginx.conf .

# Copier en changeant le nom
cp /etc/passwd /tmp/passwd_backup_$(date +%Y%m%d).txt

Remarque 7

La différence entre cp -r source/ destination/ et cp -r source destination/ est subtile mais importante. Si destination/ existe déjà et que l’on utilise source/ (avec le slash final), le contenu de source est copié dans destination. Si l’on utilise source (sans slash final), le répertoire source lui-même est copié dans destination, créant destination/source/. Cette distinction est héritée de la norme POSIX et s’applique également à rsync.

mv — déplacer ou renommer#

mv (move) sert à la fois à déplacer des fichiers d’un répertoire à un autre et à renommer des fichiers (qui n’est qu’un cas particulier de déplacement au sein du même répertoire).

# Renommer un fichier
mv ancien_nom.txt nouveau_nom.txt

# Déplacer un fichier dans un répertoire
mv fichier.txt /tmp/

# Déplacer plusieurs fichiers
mv fichier1.txt fichier2.txt /tmp/

# Déplacer un répertoire entier
mv dossier_source/ /opt/

# -i : demander confirmation si la destination existe
mv -i source.txt destination.txt

# -u : ne déplacer que si la source est plus récente
mv -u source.txt /tmp/destination.txt

# -v : verbose
mv -v *.log /var/log/archive/

# Renommer avec pattern (en Bash avec expansion)
# Renommer tous les .txt en .bak
for f in *.txt; do mv "$f" "${f%.txt}.bak"; done

rm — supprimer des fichiers et répertoires#

rm (remove) est irréversible sous Linux : il n’y a pas de corbeille en ligne de commande (sauf avec des outils tiers comme trash-cli). Une mauvaise commande rm peut détruire des données définitivement.

# Supprimer un fichier
rm fichier.txt

# -i : demander confirmation pour chaque fichier
rm -i fichier.txt

# -f : forcer (ne pas demander, ignorer les fichiers inexistants)
rm -f fichier.txt

# Supprimer plusieurs fichiers
rm fichier1.txt fichier2.txt *.log

# -r : récursif (supprimer un répertoire et son contenu)
rm -r dossier/

# -rf : récursif + force (DANGEREUX ! utilisez avec la plus grande prudence)
rm -rf dossier/

# Toujours protéger les chemins avec des guillemets (éviter rm -rf /)
# La protection est assurée sur les systèmes modernes par --no-preserve-root
# mais il vaut mieux ne jamais taper rm -rf / ni rm -rf /*

Remarque 8

La commande rm -rf / est l’une des erreurs les plus catastrophiques possibles sur un système Linux : elle supprime récursivement l’intégralité de l’arborescence, rendant le système inutilisable. Les systèmes modernes protègent contre rm -rf / grâce à l’option --preserve-root activée par défaut, mais rm -rf /chemin/avec/slash/accidentel reste dangereux. Une bonne pratique : toujours utiliser -i en interactif, et ne jamais écrire rm -rf dans un script sans une vérification préalable de la variable contenant le chemin.

mkdir et rmdir — créer et supprimer des répertoires#

# Créer un répertoire
mkdir nouveau_dossier

# Créer plusieurs répertoires
mkdir dossier1 dossier2 dossier3

# -p : créer les répertoires parents si nécessaire (pas d'erreur si existant)
mkdir -p /opt/monapp/config/ssl

# Créer une arborescence complète en une ligne
mkdir -p projet/{src,tests,docs,build}
# Crée : projet/src, projet/tests, projet/docs, projet/build

# -v : verbose
mkdir -pv /opt/monapp/logs

# Supprimer un répertoire vide
rmdir dossier_vide/

# Supprimer une arborescence de répertoires vides
rmdir -p a/b/c/    # supprime c, puis b, puis a (si tous vides)

# Pour les répertoires non vides, utiliser rm -r
rm -r dossier_non_vide/

Le modèle de permissions Unix#

Le système de permissions Unix est simple, élégant et puissant. Chaque fichier possède un ensemble de permissions qui contrôlent l’accès de trois catégories d’utilisateurs.

Les trois catégories et les trois permissions#

Définition 11 (Modèle de permissions Unix)

Chaque fichier ou répertoire possède trois ensembles de permissions, chacun composé de trois bits :

Catégories d’utilisateurs :

  • u (user) : le propriétaire du fichier (son créateur par défaut).

  • g (group) : les membres du groupe propriétaire du fichier.

  • o (others) : tous les autres utilisateurs du système.

  • a (all) : raccourci désignant u+g+o simultanément.

Types de permissions :

  • r (read, valeur octale 4) : lire le contenu d’un fichier, ou lister le contenu d’un répertoire.

  • w (write, valeur octale 2) : modifier le contenu d’un fichier, ou créer/supprimer des fichiers dans un répertoire.

  • x (execute, valeur octale 1) : exécuter un fichier binaire ou script, ou traverser un répertoire (entrer dedans avec cd).

Remarque 9

La permission x sur un répertoire mérite une attention particulière. Elle ne signifie pas « exécuter le répertoire » (ce qui n’a pas de sens) mais traverser le répertoire, c’est-à-dire pouvoir entrer dedans avec cd ou accéder à ses fichiers. On peut avoir r sans x sur un répertoire (lister les noms des fichiers sans pouvoir y accéder) ou x sans r (traverser le répertoire pour atteindre un fichier dont on connaît le nom, sans voir la liste).

Lecture des permissions#

La sortie de ls -l affiche les permissions sous forme d’une chaîne de 10 caractères :

-rwxr-xr--

Position

Signification

1

Type : - fichier, d répertoire, l lien symbolique, c périph. caractère, b périph. bloc

2-4

Permissions du propriétaire (u) : r, w, x

5-7

Permissions du groupe (g) : r, w, x

8-10

Permissions des autres (o) : r, w, x

Un - à la place d’une lettre signifie que la permission correspondante est absente.

Exemple 11 (Lire les permissions)

-rwxr-xr– 1 alice dev 4096 15 mars script.sh drwxr-x— 2 alice dev 4096 10 mars projets/ lrwxrwxrwx 1 root root 11 01 janv. python -> python3.11 -rw——- 1 alice alice 512 20 mars .ssh/id_rsa -rw-r–r– 1 root root 1234 15 janv. /etc/passwd


- `script.sh` : fichier (`-`), propriétaire peut lire/écrire/exécuter (`rwx`), groupe peut lire/exécuter (`r-x`), autres peuvent seulement lire (`r--`).
- `projets/` : répertoire (`d`), propriétaire a tous les droits (`rwx`), groupe peut lire et traverser (`r-x`), autres n'ont aucun droit (`---`).
- `id_rsa` : fichier (`-`), seul le propriétaire peut lire et écrire (`rw-`), groupe et autres n'ont aucun droit (`---`). Configuration obligatoire pour les clés SSH privées.

chmod — modifier les permissions#

chmod (change mode) modifie les permissions d’un fichier. Il accepte deux syntaxes : symbolique et octale.

Notation symbolique#

# Ajouter une permission (+)
chmod u+x script.sh          # ajouter l'exécution pour le propriétaire
chmod g+w fichier.txt        # ajouter l'écriture pour le groupe
chmod o+r fichier.txt        # ajouter la lecture pour les autres
chmod a+x programme          # ajouter l'exécution pour tous

# Retirer une permission (-)
chmod u-w fichier.txt        # retirer l'écriture au propriétaire
chmod o-r fichier.txt        # retirer la lecture aux autres
chmod g-x script.sh          # retirer l'exécution au groupe

# Définir exactement une permission (=)
chmod u=rw fichier.txt       # le propriétaire a exactement rw (pas x)
chmod go=r fichier.txt       # groupe et autres ont exactement r

# Combinaisons
chmod u+x,g-w,o-rw script.sh

# Récursif
chmod -R 755 /var/www/html/

Notation octale#

La notation octale représente chaque ensemble de permissions (u, g, o) par un chiffre de 0 à 7, obtenu en additionnant les valeurs r=4, w=2, x=1.

Exemple 12 (Calcul des permissions en octal)

Octal

Binaire

Symbolique

Signification

0

000

---

Aucune permission

1

001

--x

Exécution seule

2

010

-w-

Écriture seule

3

011

-wx

Écriture + exécution

4

100

r--

Lecture seule

5

101

r-x

Lecture + exécution

6

110

rw-

Lecture + écriture

7

111

rwx

Toutes les permissions

Exemples de valeurs octales à trois chiffres (u g o) :

chmod 755 script.sh     # rwxr-xr-x : standard pour les scripts et binaires
chmod 644 fichier.txt   # rw-r--r-- : standard pour les fichiers ordinaires
chmod 600 .ssh/id_rsa   # rw------- : clé privée SSH (lecture propriétaire seul)
chmod 700 ~/.ssh/       # rwx------ : répertoire SSH privé
chmod 777 /tmp/partage  # rwxrwxrwx : tous les droits pour tous (déconseillé)
chmod 400 backup.tar.gz # r-------- : lecture seule pour le propriétaire
chmod 664 données.csv   # rw-rw-r-- : propriétaire et groupe peuvent modifier


### chown et chgrp — changer propriétaire et groupe

```bash
# Changer le propriétaire d'un fichier
sudo chown bob fichier.txt

# Changer le propriétaire et le groupe simultanément
sudo chown alice:developers projet/

# Changer uniquement le groupe
sudo chown :www-data /var/www/html/

# Équivalent avec chgrp
sudo chgrp www-data /var/www/html/

# Récursif
sudo chown -R alice:alice /home/alice/
sudo chgrp -R www-data /var/www/

# Changer en référence à un autre fichier
sudo chown --reference=fichier_reference.txt cible.txt

umask : la valeur de masque#

Lorsqu’un fichier ou un répertoire est créé, ses permissions initiales sont déterminées par la commande qui le crée (en général, 666 pour un fichier et 777 pour un répertoire), modifiée par l”umask de la session courante.

Définition 12 (umask)

L”umask (user file-creation mask) est un masque qui retire des permissions lors de la création d’un fichier. Les permissions effectives d’un nouveau fichier sont calculées ainsi :

permissions_effectives = permissions_par_défaut AND NOT umask


Autrement dit, les bits à 1 dans l'umask sont retirés des permissions par défaut. Un umask de `022` retirera les droits d'écriture pour le groupe et les autres.

# Afficher l'umask courant
umask
# Sortie typique : 0022

# Afficher en notation symbolique
umask -S
# Sortie : u=rwx,g=rx,o=rx

# Calcul pour un fichier (permissions par défaut : 666)
# 666 AND NOT 022 = 666 AND 755 = 644 → rw-r--r--

# Calcul pour un répertoire (permissions par défaut : 777)
# 777 AND NOT 022 = 777 AND 755 = 755 → rwxr-xr-x

# Modifier l'umask (pour la session courante seulement)
umask 027    # retire w pour groupe, retire tout pour others
# Fichiers : 640 (rw-r-----), Répertoires : 750 (rwxr-x---)

# Pour un umask plus restrictif (fichiers confidentiels)
umask 077    # retire tout pour groupe et others
# Fichiers : 600 (rw-------), Répertoires : 700 (rwx------)

# Rendre permanent (ajouter dans ~/.bashrc ou /etc/profile)
echo "umask 022" >> ~/.bashrc

Remarque 10

L’umask 0022 est la valeur par défaut sur la plupart des distributions. Le premier zéro correspond aux bits spéciaux (setuid, setgid, sticky). Cette valeur convient pour un usage général : les fichiers créés sont lisibles par tous mais modifiables seulement par le propriétaire. Pour les répertoires contenant des données sensibles (comme ~/.ssh), il est conseillé d’utiliser un umask de 077 ou de corriger les permissions après création avec chmod.

Utilisateurs et groupes#

Gestion des identités#

# Afficher l'identité de l'utilisateur courant
whoami               # affiche le nom de l'utilisateur
id                   # affiche UID, GID et tous les groupes
id alice             # affiche les IDs de l'utilisateur alice
groups               # affiche les groupes de l'utilisateur courant
groups alice         # affiche les groupes d'alice

Les fichiers /etc/passwd et /etc/group#

Définition 13 (/etc/passwd)

Le fichier /etc/passwd contient une ligne par utilisateur du système. Chaque ligne est composée de sept champs séparés par : :

nom_utilisateur:x:UID:GID:commentaire:répertoire_home:shell


- **nom_utilisateur** : identifiant de connexion.
- **x** : le mot de passe haché est stocké dans `/etc/shadow` (non lisible par les utilisateurs ordinaires).
- **UID** : identifiant numérique unique de l'utilisateur. `0` = root.
- **GID** : identifiant du groupe principal.
- **commentaire** (ou GECOS) : nom complet, numéro de bureau, etc.
- **répertoire_home** : `/home/alice`, `/root`, `/var/www`…
- **shell** : shell de connexion par défaut (`/bin/bash`, `/usr/sbin/nologin` pour les comptes système).

# Afficher les entrées de /etc/passwd
cat /etc/passwd

# Exemple de lignes :
# root:x:0:0:root:/root:/bin/bash
# alice:x:1000:1000:Alice Dupont,,,:/home/alice:/bin/bash
# www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin
# nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin

# Afficher uniquement les utilisateurs qui ont un shell de connexion réel
grep -v nologin /etc/passwd | grep -v false

# Contenu de /etc/group
cat /etc/group
# Format : nom_groupe:x:GID:membres_supplémentaires
# sudo:x:27:alice,bob
# docker:x:998:alice

Créer et gérer des utilisateurs#

# Créer un utilisateur (commande recommandée, interactive)
sudo adduser alice

# Créer un utilisateur (commande bas niveau, non interactive)
sudo useradd -m -s /bin/bash -c "Alice Dupont" alice
# -m : créer le répertoire home
# -s : shell de connexion
# -c : commentaire (GECOS)

# Modifier un utilisateur
sudo usermod -aG sudo alice       # ajouter au groupe sudo (-a = append)
sudo usermod -aG docker alice     # ajouter au groupe docker
sudo usermod -s /bin/zsh alice    # changer le shell
sudo usermod -l nouveau_nom alice # renommer

# Supprimer un utilisateur
sudo userdel alice                # supprimer sans toucher au home
sudo userdel -r alice             # supprimer avec le répertoire home

# Modifier le mot de passe
sudo passwd alice                 # définir/changer le mot de passe d'alice
passwd                            # changer son propre mot de passe

# Verrouiller/déverrouiller un compte
sudo passwd -l alice              # verrouiller
sudo passwd -u alice              # déverrouiller

sudo et l’élévation de privilèges#

Définition 14 (sudo)

sudo (superuser do) permet à un utilisateur autorisé d’exécuter une commande avec les privilèges d’un autre utilisateur (par défaut root), après authentification par son propre mot de passe. La liste des utilisateurs et groupes autorisés, ainsi que les règles d’autorisation, est définie dans /etc/sudoers (ou dans les fichiers de /etc/sudoers.d/).

# Exécuter une commande en tant que root
sudo apt update
sudo systemctl restart nginx

# Ouvrir un shell root interactif
sudo -i            # shell de connexion root
sudo -s            # shell root sans sourcer les profils de root
sudo bash          # alternative

# Exécuter en tant qu'un autre utilisateur
sudo -u bob commande

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

# Modifier /etc/sudoers de façon sécurisée (valide la syntaxe avant de sauvegarder)
sudo visudo

# Donner les droits sudo à un utilisateur (en l'ajoutant au groupe sudo)
sudo usermod -aG sudo alice

# Exemple de règle dans /etc/sudoers :
# alice ALL=(ALL:ALL) ALL         # alice peut tout faire en sudo
# bob   ALL=(ALL) NOPASSWD: /bin/systemctl restart nginx  # sans mot de passe

Remarque 11

Ne jamais éditer /etc/sudoers directement avec un éditeur ordinaire. Utiliser visudo qui vérifie la syntaxe avant d’enregistrer. Une erreur de syntaxe dans /etc/sudoers peut rendre sudo totalement inutilisable, vous empêchant d’effectuer toute opération privilégiée (y compris la correction de l’erreur).

Bits spéciaux : setuid, setgid, sticky bit#

Au-delà des permissions standard rwx, Linux dispose de trois bits spéciaux qui modifient le comportement des fichiers et répertoires.

Le bit setuid (SUID)#

Le bit setuid (set user ID) sur un fichier exécutable fait que le programme s’exécute avec les privilèges du propriétaire du fichier plutôt que de l’utilisateur qui le lance. L’exemple classique est passwd : il appartient à root et a le bit setuid, ce qui permet à n’importe quel utilisateur de changer son mot de passe (opération qui nécessite d’écrire dans /etc/shadow, accessible seulement à root).

# Identifier les fichiers setuid sur le système
find /usr/bin /bin -perm -4000 -type f
# Exemples typiques :
# /usr/bin/passwd
# /usr/bin/sudo
# /usr/bin/pkexec

# Ajouter le bit setuid (notation symbolique)
sudo chmod u+s programme

# Ajouter le bit setuid (notation octale : 4 en tête)
sudo chmod 4755 programme
# Résultat dans ls -l : -rwsr-xr-x
# Le 's' remplace 'x' dans les permissions propriétaire

Le bit setgid (SGID)#

Le bit setgid (set group ID) a deux comportements selon qu’il est positionné sur un fichier ou un répertoire :

  • Sur un fichier exécutable : le programme s’exécute avec le GID du groupe propriétaire.

  • Sur un répertoire : tout fichier créé dans ce répertoire héritera automatiquement du groupe du répertoire (plutôt que du groupe principal de l’utilisateur créateur). Très utile pour les répertoires de travail partagés entre plusieurs membres d’un groupe.

# Ajouter le bit setgid
chmod g+s répertoire_partagé/
chmod 2755 répertoire_partagé/
# Résultat : drwxr-sr-x
# Le 's' apparaît dans les permissions groupe

# Vérifier l'effet : les nouveaux fichiers créés dans le répertoire
# auront le groupe du répertoire, pas le groupe principal du créateur

Le sticky bit#

Le sticky bit sur un répertoire interdit aux utilisateurs de supprimer ou renommer les fichiers des autres, même s’ils ont la permission d’écriture sur le répertoire. C’est exactement le comportement de /tmp : tout le monde peut créer des fichiers dans /tmp, mais on ne peut supprimer que ses propres fichiers.

# Voir le sticky bit sur /tmp
ls -ld /tmp
# drwxrwxrwt 15 root root 4096  ...
# Le 't' (sticky bit + x) ou 'T' (sticky bit sans x) à la fin

# Ajouter le sticky bit
chmod +t répertoire_partagé/
chmod 1777 /tmp   # 1 en tête = sticky bit

# Vérifier
ls -ld /tmp
# drwxrwxrwt ...

Visualisation des permissions#

Hide code cell source

 
fig, axes = plt.subplots(1, 2, figsize=(16, 8))
palette = sns.color_palette("muted", 10)

# --- Graphique 1 : tableau des permissions rwx ---
ax = axes[0]
ax.set_xlim(-0.5, 9.5)
ax.set_ylim(-1, 7)
ax.axis('off')
ax.set_title('Décomposition des permissions Unix', fontsize=13, fontweight='bold')

# En-têtes
headers = ['', 'r', 'w', 'x', 'r', 'w', 'x', 'r', 'w', 'x']
group_labels = [('Propriétaire (u)', 1, 4, palette[0]),
                ('Groupe (g)', 4, 7, palette[2]),
                ('Autres (o)', 7, 10, palette[4])]

for i, h in enumerate(headers):
    bg = '#f0f0f0'
    if 1 <= i <= 3:
        bg = sns.color_palette("pastel")[0]
    elif 4 <= i <= 6:
        bg = sns.color_palette("pastel")[2]
    elif 7 <= i <= 9:
        bg = sns.color_palette("pastel")[4]
    rect = patches.FancyBboxPatch((i * 0.95, 5.5), 0.85, 0.85,
                                   boxstyle="round,pad=0.05",
                                   facecolor=bg, edgecolor='#aaaaaa', lw=1)
    ax.add_patch(rect)
    ax.text(i * 0.95 + 0.425, 5.925, h, ha='center', va='center',
            fontsize=11, fontweight='bold')

# Groupes en en-tête
for (label, x1, x2, color) in group_labels:
    mid = (x1 + x2) / 2 * 0.95 - 0.05
    ax.text(mid, 6.7, label, ha='center', va='center',
            fontsize=10, fontweight='bold', color=color,
            bbox=dict(boxstyle='round,pad=0.3', facecolor=color,
                      alpha=0.15, edgecolor=color))
    ax.plot([x1 * 0.95 - 0.05, x2 * 0.95 - 0.1], [6.4, 6.4],
            color=color, lw=2)

# Exemples de permissions courantes
examples = [
    ("644 (rw-r--r--)", "fichier texte standard",
     [1,1,0, 1,0,0, 1,0,0]),
    ("755 (rwxr-xr-x)", "script ou binaire standard",
     [1,1,1, 1,0,1, 1,0,1]),
    ("600 (rw-------)", "clé SSH privée",
     [1,1,0, 0,0,0, 0,0,0]),
    ("700 (rwx------)", "répertoire privé",
     [1,1,1, 0,0,0, 0,0,0]),
    ("777 (rwxrwxrwx)", "accès complet (déconseillé)",
     [1,1,1, 1,1,1, 1,1,1]),
]

letters = ['', 'r', 'w', 'x', 'r', 'w', 'x', 'r', 'w', 'x']
colors_perm = [palette[0]] * 3 + [palette[2]] * 3 + [palette[4]] * 3

for row_idx, (title, desc, perms) in enumerate(examples):
    y = 4.3 - row_idx * 0.95
    ax.text(0, y + 0.35, title, ha='left', va='center',
            fontsize=8.5, fontweight='bold', color='#333333',
            fontfamily='monospace')
    ax.text(0, y - 0.05, desc, ha='left', va='center',
            fontsize=7.5, color='#666666', style='italic')
    for col_idx, (has_perm, letter) in enumerate(zip(perms, letters[1:])):
        col_x = (col_idx + 1) * 0.95
        color = colors_perm[col_idx]
        bg_c = color if has_perm else '#eeeeee'
        rect = patches.FancyBboxPatch(
            (col_x, y - 0.1), 0.8, 0.75,
            boxstyle="round,pad=0.04",
            facecolor=bg_c, edgecolor=color,
            alpha=0.6 if has_perm else 0.3, lw=1.2)
        ax.add_patch(rect)
        ax.text(col_x + 0.4, y + 0.27,
                letter if has_perm else '-',
                ha='center', va='center',
                fontsize=9, fontweight='bold',
                color='white' if has_perm else '#aaaaaa')

# --- Graphique 2 : tableau chmod symbolique vs octal ---
ax2 = axes[1]
ax2.set_xlim(-0.5, 10)
ax2.set_ylim(-0.5, 10)
ax2.axis('off')
ax2.set_title('chmod : notation symbolique vs octale', fontsize=13, fontweight='bold')

# Tableau des valeurs octales
data = [
    ("0", "000", "---", "Aucun droit"),
    ("1", "001", "--x", "Exécution"),
    ("2", "010", "-w-", "Écriture"),
    ("3", "011", "-wx", "Écriture + exécution"),
    ("4", "100", "r--", "Lecture"),
    ("5", "101", "r-x", "Lecture + exécution"),
    ("6", "110", "rw-", "Lecture + écriture"),
    ("7", "111", "rwx", "Tous les droits"),
]
col_headers = ["Octal", "Binaire", "Symbole", "Signification"]
col_widths = [1.2, 1.5, 1.5, 4.0]
col_starts = [0.2, 1.6, 3.3, 5.0]

# En-têtes du tableau
for j, (header, cx) in enumerate(zip(col_headers, col_starts)):
    rect = patches.Rectangle((cx, 8.8), col_widths[j] - 0.1, 0.7,
                              facecolor=palette[3], alpha=0.7,
                              edgecolor='white', lw=1)
    ax2.add_patch(rect)
    ax2.text(cx + (col_widths[j] - 0.1) / 2, 9.15, header,
             ha='center', va='center',
             fontsize=9, fontweight='bold', color='white')

# Lignes du tableau
row_colors = [palette[j % 6] for j in range(8)]
for i, (octal, binary, symbol, meaning) in enumerate(data):
    y = 7.7 - i * 0.95
    for j, (value, cx) in enumerate(zip([octal, binary, symbol, meaning],
                                         col_starts)):
        bg = row_colors[i] if j == 0 else ('#f9f9f9' if i % 2 == 0 else 'white')
        alpha = 0.7 if j == 0 else 0.5
        rect = patches.Rectangle((cx, y - 0.1), col_widths[j] - 0.1, 0.75,
                                  facecolor=bg, alpha=alpha,
                                  edgecolor='#dddddd', lw=0.8)
        ax2.add_patch(rect)
        fw = 'bold' if j <= 2 else 'normal'
        fm = 'monospace' if j <= 2 else 'sans-serif'
        color = 'white' if j == 0 else '#333333'
        ax2.text(cx + (col_widths[j] - 0.1) / 2, y + 0.27, value,
                 ha='center', va='center',
                 fontsize=9, fontweight=fw, color=color,
                 fontfamily=fm)

# Note en bas
ax2.text(0.2, -0.2,
         "Exemples courants : 644 (fichier), 755 (script), 600 (clé SSH), 777 (déconseillé)",
         ha='left', va='center', fontsize=8, color='#555555', style='italic')

plt.tight_layout()
plt.show()
_images/df08a005eb20552c6e228fce50e8bc7caae294f5eec23f27b158ef575d42ce64.png

Résumé#

Ce chapitre a couvert la gestion des fichiers et le modèle de permissions Unix :

  • Les opérations fondamentales sur les fichiers sont touch (créer/mettre à jour), cp (copier), mv (déplacer/renommer) et rm (supprimer). Pour les répertoires, mkdir -p et rm -r sont les plus utilisées.

  • Le modèle de permissions Unix associe à chaque fichier trois ensembles (u/g/o) de trois bits (r/w/x). La lecture de ls -l révèle le type de fichier, les permissions, le propriétaire, le groupe, la taille et la date.

  • chmod modifie les permissions en notation symbolique (u+x, g-w, o=r) ou en notation octale (755, 644, 600). chown et chgrp changent le propriétaire et le groupe.

  • L”umask soustrait des permissions lors de la création de fichiers : 022 produit 644 pour les fichiers et 755 pour les répertoires.

  • Les fichiers de référence /etc/passwd et /etc/group stockent les comptes et groupes. sudo permet l’élévation de privilèges ; /etc/sudoers (éditable avec visudo) contrôle les autorisations.

  • Les bits spéciaux ajoutent des comportements avancés : setuid (exécution avec les droits du propriétaire), setgid (héritage du groupe dans un répertoire), sticky bit (protection des fichiers des autres dans /tmp).

Dans le prochain chapitre, nous aborderons la lecture et la recherche de contenu dans les fichiers : cat, less, grep, les expressions régulières, find avancé et les outils de localisation (locate, which, whereis).

Contenu