Protéger ses données : droits d'accès, sauvegardes, et chiffrement

Organiser ses données

Les données ne sont pas égales entre elles, certaines étant plus sensibles que d'autres avec des exigences de :
Vos propres données sont généralement peu sensibles comparativement à des données d'organisations (entreprises, hôpitaux, etc). En effet, si la perte (ou le vol) d'un rendu de TP est gênant, cela ne représente au mieux qu'une semaine de travail. Pour une organisation, la perte (ou le vol) peut concerner des décennies de travail, dont des outils développés en interne par des employés qui ont depuis quitté l'organisation. Pour une entreprise, cela peut se traduire par sa faillite.
Que ce soit du à une défaillance matérielle, à une erreur de manipulation, à un acte de malveillance, ou d'un sinistre (e.g. incendie, inondations), l'indisponibilité des données engendre fréquemment une interruption, ou une dégradation, des services fournis. Pour un hôpital, cela peut se traduire en pertes d'opportunités de soins, et de vies humaines.
Il est donc important d'établir une politique relative à ses données, d'en déterminer en amont la sensibilité et les mesures à mettre en place. Il est en effet important d'anticiper les problèmes, car une fois qu'ils surviennent, il est bien souvent déjà trop tard.

Définir une politique

Dans un premier temps, il est nécessaire d'identifier ses données, leurs besoins, et les solutions à mettre en place :
Pour cela, une première étape est déjà de bien organiser ses fichiers autours d'une arborescence cohérente et consistante. Cela permet non-seulement de facilement pouvoir retrouver un fichier au quotidien, mais aussi d'identifier aisément les fichiers à chiffrer, sauvegarder, archiver, supprimer, etc. Il sera alors possible d'associer une politique à un dossier, e.g. :
Les dossiers, en eux-même, peuvent être de natures très différentes. Un serveur de calcul peut ainsi avoir des dossiers :

Arborescence Linux

Sous Linux les fichiers sont organisés comme suit :
Lorsqu'un fichier temporaire est volumineux, il risque de prendre trop de place en RAM si enregistré dans . On l'enregistrera alors usuellement dans (stocké sur le disque).

Fichiers des applications

Afin de garder une arborescence propre et explicite, les logiciels évitent d'écrire leurs fichiers n'importe où et respectent autant que possible des conventions. Cela permet notamment d'éviter des conflits, e.g. deux exécutables souhaitant utiliser le même chemin pour deux fichiers différents.
Par convention on distingue 3 niveaux :
Par convention, on distingue alors 7 sous-dossiers (pas entièrement consistant) :
StandardLocalPersonnel
Base
Exécutables
Exécutables (admin)
Bibliothèques
Ressources
Configuration
Cache
Lorsqu'on exécute une commande, le shell recherche (puis exécute) le fichier de même nom présent dans les dossiers . Ainsi, pour créer une commande, il faut placer le fichier exécutable dans un de ces dossiers.
Il est aussi possible d'installer ses applications locales dans , évitant ainsi d'avoir à en disperser le contenu entre ses executables, bibliothèques, et configurations.

Droits d'accès

Pour des raisons évidentes de sécurité, n'importe qui ne peut écrire n'importe quoi n'importe où. Par défaut, les utilisateurs n'ont accès qu'à leur propres fichiers, stockés dans leur home. Il est toutefois possible de configurer les droits d'accès d'un fichier. Ces droits d'accès sont stockés dans les méta-données associées au fichier.

Les méta-données

Un ordinateur enregistre ses données dans des espaces de stockage appelés volumes, qui peuvent être tout ou partie :
L'OS ne manipule pas les données directement sur le volume, mais utilise un système de fichiers (filesystem) qui détermine où et comment stocker les données d'un fichier (file), ainsi que ses méta-données (metadata) :
La commande affiche l'ensemble des méta-données d'un fichier, mais est peu utilisée en pratique : 
$ stat foo
  Fichier : foo
   Taille : 4096      	Blocs : 8          Blocs d'E/S : 4096   répertoire
Périphérique : fd01h/64769d	Inœud : 6577172     Liens : 3
Accès : (0775/drwxrwxr-x)  UID : ( 1000/ demigda)   GID : ( 1000/ demigda)
Accès : 2025-03-29 15:02:50.812405953 +0100
Modif. : 2025-03-29 15:02:19.868310502 +0100
Changt : 2025-03-29 15:02:19.868310502 +0100
  Créé : 2025-03-29 15:01:55.808234278 +0100
On préfère bien souvent utiliser la commande : 
$ ls -lh -d foo
Permissions  User    Group   Size       Date Modified        Name  
drwxrwxr-x  demigda demigda 4.0 KB Tue Apr  1 09:16:45 2025 📂  foo
Il convient de ne pas confondre ces méta-données, stockées au niveau du système de fichiers, et communes entre tous les fichiers, avec des méta-données stockées dans le fichier, et dépendant de son format (e.g. png, jpeg, pdf, zip).

Droits d'accès UNIX

La manière dont les droits d'accès sont définis dépend donc du système de fichier utilisé. Dans le cadre de ce cours, nous nous concentrerons sur les droits d'accès UNIX, compatibles avec la grande majorité des systèmes de fichiers, à l'exception de qui ne stocke pas de permissions.
Les droits d'accès UNIX supportent 3 types de droits :
Pour pouvoir exécuter un script (ou une commande), il est nécessaire de posséder les droits d'exécution (et de lecture) sur le fichier. Bien qu'il soit possible d'utiliser ces droits pour contrôler les droits d'exécution de commandes d'administration, il est souvent préférable d'utiliser sudo/sudoers pour un meilleur contrôle.
Les droits d'accès à un fichier sont alors décrits par ses permissions (rwxrwxr-x), indiquant les droits :
La présence d'un à la place d'un , , ou indique que le droit n'est pas attribué.
Par exemple, r-x correspond au droit de lecture () et d'exécution (), sans le droit de lecture ().
Les droits d'un fichier peuvent être modifiés via les commandes suivantes :
(recursive) permet d'appliquer ces changements de manière récursive (i.e. au dossier et à son contenu).
s'écrit sous la forme suivante :
  • (user) : l'utilisateur propriétaire
  • (group) : le groupe propriétaire
  • (other) : les autres
  • (all) : tous les utilisateurs
  • : ajouter
  • : retirer
  • : appliquer
Par exemple :

Droits des fichiers créés

Lors de sa création, un fichier possède des droits par défaut définis via la commande (user mask) :
Par défaut, à la création d'un nouveau fichier, le masque attribue, à tous, le droit de lecture. Il est ainsi potentiellement important de modifier le masque afin de garantir la confidentialité des données :

Le sticky bit

En réalité, un utilisateur peut non seulement créer des fichiers dans son home, mais aussi dans et . C'est à dire qu'il a le droit d'écriture dans ces dossiers. On souhaite cependant qu'il ne puisse pas supprimer les fichiers des autres utilisateurs.
Pour cela on utilise un droit UNIX un peu particulier : le sticky bit (t/T), où seul le propriétaire du fichier peut le supprimer (si défini sur un dossier, s'applique à son contenu).
Tout le monde pouvant écrire dans ces dossiers, il est important d'éviter les conflits/collisions de noms. Pour cela on génère aléatoirement les noms de fichiers via : (make temporary [directory]). Les dans , sont remplacés par des caractères aléatoires, e.g. peut créer un fichier .

SUID/SGID

Les droits SUID/SGID (s/S) permettent d'exécuter un fichier binaire avec les droits de l'utilisateur/groupe propriétaire. Ces droits sont notamment utilisés par la commande .
Ces droits sont très dangereux, et peuvent très rapidement permettre de l'exécution de code ou de commandes arbitraires, permettant ensuite une élévation de privilèges. Il convient de toujours utiliser à la place.

Droits d'accès avancés

La méthode usuelle d'attribution des droits permet d'indiquer des permissions uniquement pour le propriétaire, groupe propriétaire, et les autres. Pour une gestion plus fine des droits, on utilise les ACL (Access Control List) afin d'étendre les droits d'accès UNIX :
Lorsqu'un fichier possède des droits ACL, suffixe les permissions par un : 
$ ls -lh /tmp/foo
Permissions User Group Size      Date Modified          Name    
.rw-rwxr--+ root root  0 B  Wed Aug 27 10:44:06 2025   /tmp/foo
En pratique les ACL sont peu utilisés au quotidien.

Les sauvegardes

Une sauvegarde peut s'effectuer à plusieurs niveaux différents :
Il est nécessaire de s'assurer que les différentes solutions et procédures mises en place sont fonctionnelles. Par exemple, que les données sont correctement sauvegardées, et peuvent rapidement être restaurées en cas de perte.

RAID

Le RAID (Redundant Array of Inexpensive Disk) permet de dupliquer, en temps réel, les données sur plusieurs disques (ou volumes) afin d'éviter les pertes de données en cas de défaillance matérielle. Il possède plusieurs "niveaux" :
Nom Description # disques Résilience
RAID 0 (striping) volume sur plusieurs disques N 0
RAID 1 (mirroring) duplique un disque 1+1 1
RAID 5 (distributed parity) bloc de parité bp = b1 ⊕ ... ⊕ bn N+1 1
RAID 6 (dual parity) 2 blocs de parité N+2 2
Il est possible de faire des combinaisons, e.g. RAID 1+0 ou RAID 10.
Images + présenter stripping

Sauvegarde de fichiers

Une méthode triviale de sauvegarde est de simplement copier les fichiers avec (archive).
Il est important que les sauvegardes soient stockées dans des lieux différents afin de se prémunir contre des incidents pouvant toucher toute une zone (e.g. cambriolages, incendies, inondations, etc). Il est aussi possible d'enregistrer ses sauvegardes sur des disques coupés du réseau permettent de se protéger contre des attaques touchant l'intégralité du système informatique (e.g. rançongiciel).
Pour une copie vers, ou depuis, un ordinateur distant, on remplacera par (remote sync) où les chemins sont alors de la forme : .
L'option de permet de voir la progression du transfert.
Sous Linux, les volumes et les périphériques sont représentés par un fichier dans (devices). Cela signifie que vous pouvez aussi copier un volume avec ou , comme on copie un fichier. La copie pouvant être longue, il est toutefois recommandé d'afficher la progression de la copie. Une fois la copie effectuée, il est aussi recommandé d'exécuter la commande afin de vider les écritures encore en cache.

Instantanés (snapshots)

Une sauvegarde n'est pas instantanée et prend du temps à enregistrer les données unes à unes. Pendant ce temps, ces mêmes données peuvent faire l'objet de modifications pouvant conduire à un état sauvegardé incohérent. En effet, la sauvegarde pourrait alors inclure un mélange de données pre et post modification, en fonction des données qui auraient déjà été sauvegardées au moment de la modification.
De même, une modification n'est pas instantanée et prend du temps. Ainsi, la sauvegarde pourrait enregistrer un état intermédiaire. Par exemple, lors de la suppression de plusieurs entrées d'un SGBD, la sauvegarde pourrait enregistrer un état invalide du SGBD où e.g. les entrées auraient été supprimées, mais pas leurs identifiants.
Il est ainsi important, soit d'utiliser les mécanismes d'exportations, soit d'arrêter l'application le temps de la sauvegarde.
Cependant, comme nous l'avons dit, une sauvegarde prend du temps. De plusieurs minutes à plusieurs heures, ce qui est autant de temps pendant lesquels les services devront être arrêtés et seront donc indisponibles.
Pour éviter cela, on créé un instantané (snapshot) du système de fichier. Cet instantané représentera alors l'état du système de fichiers à un instant t, sur lequel on pourra ensuite effectuer la sauvegarde. Il n'est ainsi nécessaire d'arrêter les services que durant la création de l'instantané, qui est très rapide.
Le fonctionnement de l'instantané est très simple. À sa création, il est vide (donc très rapide à créer). Lorsque le système de fichier originel est modifié, la version originale est stockée dans l'instantané. Ainsi l'instantané ne contient que les données modifiées depuis sa création.
Lors de la lecture de l'instantané, la donnée sera alors d'abord recherchée dans l'instantané, puis dans le volume originel si non-trouvée, i.e. si n'a pas été modifiée depuis la création de l'instantané.
IMG instantané

Sauvegardes incrémentales et liens physiques

Les techniques vues précédemment sont des sauvegardes complètes, i.e. sauvegardent l'ensemble des données. Or si la majorité des fichiers ne changent pas d’une sauvegarde sur l’autre, on se retrouve alors avec des fichiers identiques, dupliqués dans différentes sauvegardes, et prenant très vite beaucoup de place pour rien.
Il est possible de créer une archive compressée afin de réduire la taille de la sauvegarde :
Cependant, on souhaite généralement effectuer des sauvegardes incrémentales, i.e. ne sauvegarder que les modifications depuis la dernière sauvegarde. Tout en conservant des sauvegardes qu'on puisse parcourir comme une arborescence normale.
On souhaite ainsi placer un même fichier dans plusieurs sauvegardes différentes (i.e. dans plusieurs endroits à la fois), mais sans le copier. Cela est rendu possible par le fait que les dossiers sont en réalité un fichier spécial contenant la liste des identifiants (inodes) des fichiers qu'il contient. Il est alors possible d'ajouter un même fichier dans plusieurs dossiers différents en créant un lien physique (hard link) via la commande (link). Dès lors, le fichier ne sera réellement supprimé que lorsque toutes ses occurrences seront supprimées.
effectue une sauvegarde incrémentale. Depuis la dernière sauvegarde, si le fichier :
💡 Comme la sauvegarde incrémentale utilise des liens physiques, vous pouvez parcourir, supprimer, renommer, modifier, etc. la sauvegarde comme tous dossiers.
⚠ Il n'est pas possible de faire un lien physique d'un dossier. Dans ce cas, il faudra créer un lien symbolique () : un fichier spécial contenant le chemin du fichier ciblé. Si le fichier ciblé est supprimé ou déplacé, le lien sera cassé.

Autres fonctionnalités

En plus des instantanés, et des sauvegardes incrémentales, il existe d'autres fonctionnalités utiles aux sauvegardes. Ces fonctionnalités peuvent être très variées, e.g. chiffrement, compression, historique, etc. Elles peuvent être portées soit par le système de fichier, ou par le logiciel effectuant la sauvegarde/synchronisation.
Par exemple, dans le cas de dossiers partagés entre plusieurs utilisateurs, on souhaite généralement conserver un historique de chaque modification afin d'en avoir un suivi, et d'être capable, lorsque nécessaire, de restaurer un fichier à une version précédente. Pour cela on utilisera usuellement un logiciel de synchronisation de fichiers (e.g. Seafile).
Les gestionnaires de versions (e.g. git) quant à eux sont très utilisés pour les projets informatiques. Ils stockent différentes versions d'un projet via des sauvegardes incrémentales, tout en offrant de multiples fonctionnalités :
Importance de découper les fichiers de config pour git.

Gérer les volumes

Pourquoi avoir plusieurs volumes ?

Comme nous l'avons vu différents systèmes de fichiers offrent différentes fonctionnalités. Usuellement, les systèmes de fichiers suivants sont utilisés : Il existe toutefois une pléthore de systèmes de fichiers différents, chacun fournissant des fonctionnalités spécifiques :
Comme il ne peut y avoir qu'un seul système de fichier sur un volume, si on souhaite utiliser plusieurs systèmes de fichiers, il est alors nécessaire d'avoir plusieurs volumes. Par exemple, dans le cas d'un dual boot, l'ordinateur aura e.g. un volume pour Windows et un autre pour Linux.
Lorsque le système d'exploitation est installé sur une clef USB, on parle alors de live USB.
Il est très vivement conseillé d'avoir au moins un live USB en cas de problèmes avec l'OS.
Il est même recommandé de stocker ses données sur un volume à part, permettant de (ré)installer le système d'exploitation, sans effacer les données déjà présentes (une sauvegarde préalable des données est toutefois très vivement conseillée).

Partionner

Comme nous l'avons vu, il peut être nécessaire d'avoir plusieurs volumes. Cependant, si on doit avoir un support de stockage (e.g. disque, clef USB) pour chaque volume, cela serait peu pratique. Heureusement, il est possible de partitionner un support de stockage physique en plusieurs volumes appelés partitions, qui auront chacun leur propre système de fichier. Pour cela, on utilisera la commande TUI , ou un logiciel comme gparted.
Il est recommandé de créer au moins une partition sur ses disques, même s'il est possible de les utiliser en entier sans les partitionner.
Nous vous fournissons la commande permettant de visualiser l'ensemble des volumes de l'ordinateur : 
# lsvol
PATH              LABEL TYPE  PARTTYPENAME       SIZE FSUSE% FSTYPE
/dev/nvme0n1            disk                   238,5G                    
├─/dev/nvme0n1p1  EFI   part  EFI System         512M     1% vfat
├─/dev/nvme0n1p2  BOOT  part  Linux filesystem   732M    36% ext4

LVM

LVM (Logical Volume Manager) est un logiciel permettant de gérer les volumes d'un ordinateur, tout en offrant diverses fonctionnalités comme le RAID, les snapshots, etc. Sa principale utilité est de pouvoir regrouper des volumes existant au sein d'un disque virtuel, qu'on peut ensuite redécouper en volumes virtuels. Cela permet ainsi d'étendre un volume sur plusieurs supports physiques, ainsi que d'en faciliter le redimensionnement ou déplacement, sans être limité par les contraintes des supports.
LVM fonctionne ainsi en 3 étapes :
  1. Préparer les volumes : on formate des volumes existant, alors appelés volumes physiques (physical volume) :
  2. Ajouter les volumes au disque virtuel : on regroupe au sein d'un groupe de volume (volume group ≈ disque virtuel) :
  3. Partitionner le disque virtuel : on redécoupe l'ensemble en volumes logiques (logicial volume ≈ partition virtuelle) :
Bien évidemment LVM possède de très nombreuses commandes permettant de manipuler les PV, VG, et LV.
CMD : (lv/pv/vg)(create/reduce/display/s/move/remove/rename/extends)

RAID et snapshots

Les RAID et snapshots sont gérés à la création des volumes logiques :
Pensez à bien supprimer l'instantané une fois la sauvegarde effectuée :

Formatter un volume

Il fois le volume créé, il faut le formatter, c'est à dire lui attribuer un système de fichier. Pour cela, on utilise les commandes (make filesystem). Par exemple pour formatter en . Les options ne sont malheureusement pas consistantes entre les différents systèmes de fichiers.
Une fois le volume formaté, on peut lui donner un nom plus explicite en attribuant une étiquette (label) à son système de fichier, e.g. au lieu de . Malheureusement, chaque système de fichiers a sa propre commande d'attribution d'étiquettes. Pour ext4, la commande est .

Chiffrer un volume

Pour des raisons de sécurité, il est fréquent de chiffrer ses volumes, pour éviter qu'une personne mal intentionnée puisse exploiter les données sensibles d'un volume perdu ou volé (e.g. clefs USB, ordinateur portable).
Pour cela, on utilise pour formatter le volume, qu'on peut ensuite (dé)verrouiller via :
Lorsque le volume chiffré est déverrouillé, le volume est créé, permettant de manipuler en clair, les données du volume chiffré. Comme tout autre volume, doit être formaté pour pouvoir être utilisé.
Il est aussi possible d'ajouter à un groupe de volume LVM. Permettant ainsi, e.g. de partitionner un disque chiffré.
Pour des raisons de sécurité, il est fréquent de remplir un volume de données aléatoires ou de 0, afin d'en effacer les données. Pour cela on peut copier, sur le volume, les fichier de taille infinis suivant :

Monter un volume

Le fichier d'un volume contient des données binaires brutes que seul le système de fichier est capable d'interpréter. Pour en visualiser le contenu, il faudra monter le système de fichier, c'est à dire l'associer à un dossier (existant) de l'arborescence, alors appelé point de montage (mount point) :
possède de nombreuses options, comme pour monter le système de fichier en lecture seule.
Par convention, et par défaut, on monte les systèmes de fichiers dans les dossiers suivants :
Par abus de langage, on peut aussi dire "monter le volume" au lieu de "monter le système de fichier".

Monter un dossier/volume distant

Il est possible de monter un dossier ou un volume distant :
Si plusieurs ordinateurs peuvent écrire dans le dossier ou volume distant, on préfera souvent utiliser un logiciel de synchronisation de données qui synchronisera le dossier tout en offrant les fonctionnalités nécessaires à un usage courant (historique, gestions de conflits, etc.).

Monter la RAM (tmpfs)

Il est aussi possible de monter la RAM dans un dossier, permettant ainsi d'enregistrer des fichiers temporaires en RAM, pour des opérations de lecture/écriture bien plus rapides : .
C'est d'ailleurs généralement ce qui est fait avec .
Les opérations d'entrées/sorties (E/S) sont en effet très coûteux, une simple boucle pouvant être :
On cherche donc à réduire le nombre d'opérations d'E/S qu'on effectue, que ce soit en pré-chargeant les ressources nécessaires, en utilisant un système de cache ou de buffer. Par exemple, au lieu de lire plusieurs fois le même fichier, le charger intégralement en mémoire au début du programme.
La RAM est un stockage temporaire, il est nécessaire de sauvegarder régulièrement les résultats ou l'avancement d'un calcul, afin de ne pas (trop) perdre de données si le programme plante.

Monter un fichier

Comme nous l'avons vu précédemment, un volume est représenté sous la forme d'un fichier dans . Les manipulations effectuées sur le volume reviennent donc à manipuler un fichier un peu spécial. Il est possible de créer un tel fichier via la commande . Le fichier ainsi créé sera creux ( : sparse), c'est à dire que les blocs vides du fichier (i.e. à 0) ne sont pas réellement enregistrés sur le disque.
Lors de la copie d'un tel fichier ou , il convient d'utiliser l'option afin d'éviter que les blocs vides ne prennent trop de places dans la copie.
Il est ainsi possible de chiffrer un dossier, sans chiffrer l'entièreté d'un volume. Pour cela il suffit simplement de créer un volume chiffré sous la forme d'un fichier. Il est toutefois préférable d'utiliser des solutions dédiées, plutôt que de créer un tel volume à la main. Par exemple, de permet de créer un utilisateur dont les informations (et le home) seront chiffrés.
Il est aussi possible de monter une archive via , afin d'en parcourir et manipuler le contenu comme on manipule le contenu d'un dossier. Évitant ainsi des manipulations complexes en lignes de commande.

fstab (filesystem table)

Le fichier (filesystem table) liste les systèmes de fichiers connus. Ses lignes sont structurées ainsi :
Les 4 premières colonnes correspondent aux arguments de mount : .
Les systèmes de fichiers listés dans fstab :
De manière analogue, cryptsetup a un fichier pour les volumes à déverrouiller au démarrage.

Monter un volume en tant qu'utilisateur

Pour des raisons de sécurité, seul l'administrateur peut monter certains systèmes de fichiers avec mount. Les utilisateurs doivent généralitement utiliser à la place (user disks control) :
Un utilisateur ne dispose pas des droits nécessaires pour formatter un volume déverrouillé avec .