18.16. Chiffrer les partitions d'un disque
Précédent | Chapitre 18. Stockage des données | Suivant

## 18.16. Chiffrer les partitions d'un disque

Contribution de Lucky Green.

FreeBSD offre d'excellentes protections contre un accès non autorisé aux données par l'intermédiaire du réseau. Les permissions sur les fichiers et le contrôle d'accès obligatoire — “Mandatory Access Control” (MAC) (voir Chapitre 16, Mandatory Access Control ** Traduction en Cours **) empêchent l'accès aux données pour des tiers non autorisés quand le système d'exploitation est actif et l'ordinateur en fonctionnement. Cependant, des permissions renforcés sont inutiles si l'attaquant a un accès physique à un ordinateur et peut simplement déplacer le disque dur sur un autre système pour copier et analyser les données sensibles.

Indépendamment de la manière dont une personne malveillante s'est trouvé en possession d'un disque dur ou a arrêté un ordinateur, le chiffrage de disque basé sur GEOM (gbde) (“GEOM Based Disk Encryption”) et le système de chiffrage `geli` de FreeBSD sont en mesure de protéger les données des systèmes de fichiers contre des attaquants très motivés et aux ressources importantes. A la différence des méthodes de chiffrage lourdes qui chiffrent uniquement les fichiers individuels, gbde et `geli` chiffrent de manière transparente l'intégralité du système de fichiers. Aucun texte en clair ne touche les plateaux du disque.

### 18.16.1. Chiffrage des disques avec gbde

1. Devenir `root`

   La configuration de gbde requiert les privilèges du super-utilisateur.

   `%` `su -` Password:

2. Ajouter le support gbde(4) au fichier de configuration du noyau

   Ajoutez la ligne suivante à votre fichier de configuration du noyau:

   `options GEOM_BDE`

   Recompilez le noyau comme décrit dans Chapitre 8, Configurer le noyau de FreeBSD.

   Redémarrez avec le nouveau noyau.

3. Au lieu de recompiler le noyau, on peut utiliser `kldload` pour charger le support gbde(4):

   `#` `kldload geom_bde`

#### 18.16.1.1. Préparation du disque dur chiffré

L'exemple suivant suppose que vous ajoutez un nouveau disque dur à votre système et qui contiendra une seule partition chiffrée. Cette partition sera montée sous `/private`. gbde peut également être utilisé pour chiffrer les répertoires `/home` et `/var/mail`, mais cela demande une configuration plus complexe qui dépasse le cadre de cette introduction.

1. Ajouter le nouveau disque

   Installez le nouveau disque comme expliqué dans Section 18.3, « Ajouter des disques ». Pour les besoins de cet exemple, une nouvelle partition disque a été ajoutée en tant que `/dev/ad4s1c`. Les périphériques du type `/dev/ad0s1`*`` représentent les partitions FreeBSD standards sur le système exemple.

   `#` `ls /dev/ad*` /dev/ad0 /dev/ad0s1b /dev/ad0s1e /dev/ad4s1 /dev/ad0s1 /dev/ad0s1c /dev/ad0s1f /dev/ad4s1c /dev/ad0s1a /dev/ad0s1d /dev/ad4

2. Créer un répertoire pour héberger les fichiers de verrouillage de GBDE

   `#` `mkdir /etc/gbde`

   Le fichier de verrouillage de gbde contient l'information nécessaire à gbde pour accéder aux partitions chiffrées. Sans accès au fichier de verrouillage, gbde sera incapable de déchiffrer les données contenues sur la partition chiffrée sans une aide manuelle significative ce qui n'est pas supporté par le logiciel. Chaque partition chiffrée utilise un fichier de verrouillage propre.

3. Initialiser la partition gbde

   Une partition gbde doit être initialisée avant d'être utilisable. Cette initialisation doit être effectuée une seule fois:

   `#` `gbde init /dev/ad4s1c -i -L /etc/gbde/ad4s1c`

   gbde(8) lancera votre éditeur, vous permettant de fixer diverses options de configuration dans un gabarit. Pour une utilisation de UFS1 ou UFS2, fixez l'option `sector_size` à 2048:

   $FreeBSD: src/sbin/gbde/template.txt,v 1.1 2002/10/20 11:16:13 phk Exp $ # # La taille d'un secteur est la plus petite unité de donnée # qui peut être lue ou écrite. # Une valeur trop petite diminue les performances et l'espace # disponible. # Une valeur trop grande peut empêcher des systèmes de # fichiers de fonctionner correctement. 512 est la valeur minimale # et sans risque. Pour l'UFS, utiliser la taille d'un fragment # sector_size = 2048 [...]

   gbde(8) vous demandera de taper deux fois la phrase d'authentification qui devra être utilisée pour sécuriser les données. La phrase d'authentification doit être la même dans les deux cas. La capacité de gbde à protéger vos données dépend de la qualité de la phrase d'authentification que vous avez choisie. [10]

   La commande `gbde init` crée un fichier de verrouillage pour votre partition gbde qui dans cet exemple est stocké sous `/etc/gbde/ad4s1c`.

   ### Attention:

   Les fichiers de verrouillage de gbde doivent être conservés de pair avec le contenu des partitions chiffrées. Alors que la suppression seule d'un fichier de verrouillage ne peut empêcher une personne déterminée de déchiffrer une partition gbde, sans le fichier de verrouillage, le propriétaire légitime sera incapable d'accéder aux données de la partition chiffrée sans beaucoup de travail ce qui est totalement non supporté par gbde(8) et son concepteur.

4. Attacher la partition chiffrée au noyau

   `#` `gbde attach /dev/ad4s1c -l /etc/gbde/ad4s1c`

   On vous demandera de fournir la phrase d'authentification que vous avez choisie lors de l'initialisation de la partition chiffrée. Le nouveau périphérique chiffré apparaîtra dans `/dev` en tant que `/dev/nom_périphérique.bde`:

   `#` `ls /dev/ad*` /dev/ad0 /dev/ad0s1b /dev/ad0s1e /dev/ad4s1 /dev/ad0s1 /dev/ad0s1c /dev/ad0s1f /dev/ad4s1c /dev/ad0s1a /dev/ad0s1d /dev/ad4 /dev/ad4s1c.bde

5. Créer un système de fichiers sur le périphérique chiffré

   Une fois que le périphérique chiffré a été attaché au noyau, vous pouvez créer un système de fichiers sur le périphérique. Pour créer un système de fichiers sur le périphérique, utilisez newfs(8). Puisqu'il est plus rapide d'initialiser un nouveau système de fichiers UFS2 qu'un nouveau système UFS1, l'utilisation de newfs(8) avec l'option `-O2` est recommandé.

   `#` `newfs -U -O2 /dev/ad4s1c.bde`

   ### Note:

   La commande newfs(8) peut être effectuée sur une partition gbde attachée qui est identifiée par une extension ``*`.bde` au niveau du nom de périphérique.

6. Monter la partition chiffrée

   Créez un point de montage pour le système de fichiers chiffré.

   `#` `mkdir /private`

   Montez le système de fichiers chiffré.

   `#` `mount /dev/ad4s1c.bde /private`

7. Vérifiez que le système de fichiers chiffré est disponible

   Le système de fichiers chiffré devrait être visible par df(1) et prêt à être utilisé:

   `%` `df -H` Filesystem Size Used Avail Capacity Mounted on /dev/ad0s1a 1037M 72M 883M 8% / /devfs 1.0K 1.0K 0B 100% /dev /dev/ad0s1f 8.1G 55K 7.5G 0% /home /dev/ad0s1e 1037M 1.1M 953M 0% /tmp /dev/ad0s1d 6.1G 1.9G 3.7G 35% /usr /dev/ad4s1c.bde 150G 4.1K 138G 0% /private

#### 18.16.1.2. Montage des systèmes de fichiers chiffrés

Après chaque démarrage, tout système de fichiers chiffré doit être rattaché au noyau, contrôlé pour les erreurs, et monté, avant que les systèmes de fichiers ne puissent être utilisés. Les commandes nécessaires doivent être exécutées en tant que `root`.

1. Attacher la partition gdbe au noyau

   `#` `gbde attach /dev/ad4s1c -l /etc/gbde/ad4s1c`

   On vous demandera de fournir la phrase d'authentification que vous avez choisie lors de l'initialisation de la partition gbde chiffrée.

2. Contrôler les erreurs du système de fichiers

   Puisque les systèmes de fichiers chiffrés ne peuvent être encore listés dans le fichier `/etc/fstab` pour un montage automatique, on doit donc contrôler les systèmes de fichiers pour d'éventuelles erreurs en exécutant manuellement fsck(8) avant le montage.

   `#` `fsck -p -t ffs /dev/ad4s1c.bde`

3. Monter le système de fichiers chiffré

   `#` `mount /dev/ad4s1c.bde /private`

   Le système de fichiers est maintenant disponible à l'utilisation.

##### 18.16.1.2.1. Montage automatique de partitions chiffrées

Il est possible de créer une procédure pour automatiquement attacher, contrôler, et monter une partition chiffrée, mais pour des raisons de sécurité la procédure ne devrait pas contenir le mot de passe gbde(8). A la place, il est recommandé que de telles procédures soient exécutées manuellement tout en fournissant le mot de passe via la console ou ssh(1).

Comme autre possibilité, une procédure `rc.d` est fournie. Des arguments peuvent être passés à cette procédure par l'intermédiaire de rc.conf(5),, par exemple:

gbde_autoattach_all="YES" gbde_devices="ad4s1c"

Cela impose la saisie de la phrase d'authentification gbde au démarrage. Après avoir entré la phrase d'authentification correctement, la partition chiffrée gbde sera montée automatiquement. Cela peut être très utile quand gbde est utilisé sur des ordinateurs portables.

#### 18.16.1.3. Les protections cryptographiques utilisées par gbde

gbde(8) chiffre la partie utile des secteurs en utilisant le chiffrage AES 128 bits en mode CBC. Chaque secteur sur le disque est chiffré avec une clé AES différente. Pour plus d'informations sur l'architecture cryptographique de gbde, y compris comment les clés pour chaque secteur sont des dérivés de la phrase d'authentification donnée par l'utilisateur, voir la page de manuel gbde(4).

#### 18.16.1.4. Problèmes de compatibilité

sysinstall(8) est incompatible avec les périphériques gbde-chiffrés. Tous les périphériques ``*`.bde` doivent être détachés du noyau avant de lancer sysinstall(8) ou ce dernier plantera durant son processus initial de recherche des périphériques. Pour détacher le périphérique chiffré utilisé dans notre exemple, utilisez la commande suivante:

`#` `gbde detach /dev/ad4s1c`

Notez également qu'étant donné que vinum(4) n'utilise pas le sous-système geom(4), vous ne pouvez utiliser gbde avec des volumes vinum.

### 18.16.2. Chiffrage des disques avec `geli`

Contribution de Daniel Gerzo.

Depuis FreeBSD 6.0, une nouvelle classe GEOM pour le chiffrage des données est disponible: `geli`. Cette classe est développée par Pawel Jakub Dawidek. L'outil `geli` est différent de `gbde`; il offre des fonctionnalités différentes et utilise une méthode différente pour chiffrer les données.

Les caractéristiques les plus importantes de geli(8) sont:

- Utilisation du système crypto(9) — quand du matériel destiné au chiffrement est disponible dans la machine, `geli` l'utilisera automatiquement.

- Support de plusieurs algorithmes de chiffrement (actuellement AES, Blowfish, et 3DES).

- Permettre le chiffrage de la partition racine. La phrase d'authentification utilisée pour accéder à la partition racine chiffrée sera demandée au démarrage du système.

- Permettre l'emploi de deux clés indépendantes (par exemple une « clé utilisateur » et une « clé entreprise »).

- `geli` est rapide—il effectue un simple chiffrement de secteur à secteur.

- Permettre la sauvegarde et la restauration des clés principales. Quand un utilisateur doit détruire ses clés, il sera possible d'accéder à nouveau aux données en restaurant les clés à partir de la sauvegarde.

- Permettre d'attacher un disque avec une clé aléatoire à usage unique — utile pour les partitions de pagination et les systèmes de fichiers temporaires.

Plus de caractéristiques concernant `geli` peuvent être trouvées dans la page de manuel de geli(8).

Les points suivants décriront comment activer le support pour `geli` dans le noyau FreeBSD et expliqueront comment créer et utiliser un provider (ou partition) chiffré `geli`.

Afin de pouvoir employer `geli`, vous devez utiliser FreeBSD 6.0-RELEASE ou une version ultérieure. Les privilèges du super-utilisateur seront également nécessaire puisque il faudra effectuer des modifications au niveau du noyau.

1. Ajouter le support `geli` au noyau

   Ajoutez les lignes suivantes au fichier de configuration du noyau:

   options GEOM_ELI device crypto

   Recompilez le noyau comme décrit dans la Chapitre 8, Configurer le noyau de FreeBSD.

   Sinon, le module `geli` peut être chargé au démarrage. Ajoutez la ligne suivante au fichier `/boot/loader.conf`:

   geom_eli_load="YES"

   Le système geli(8) devrait désormais être supporté par le noyau.

2. Générer la clé principale

   L'exemple suivant décrira la méthode pour générer un fichier clé qui sera utilisé comme partie de la clé principale pour le provider chiffré monté sous le répertoire `/private`. Le fichier clé fournira des données aléatoires qui seront employées pour chiffrer la clé principale. La clé principale sera également protégée par une phrase d'authentification. La taille des secteurs du provider sera de 4Ko. De plus, sera décrit comment attacher au système le provider geli, créer un système de fichiers dessus, utiliser ce système de fichiers et enfin comment le détacher.

   Il est recommandé d'utiliser une taille de secteur plus grande (comme 4Ko) pour de meilleures performances.

   La clé principale sera protégée avec une phrase d'authentification et la source de données pour le fichier clé sera `/dev/random`. La taille des secteurs de `/dev/da2.eli`, partition que nous appelons provider, sera de 4Ko.

   `#` `dd if=/dev/random of=/root/da2.key bs=64 count=1` `#` `geli init -s 4096 -K /root/da2.key /dev/da2` Enter new passphrase: Reenter new passphrase:

   Il n'est pas obligatoire d'utiliser la phrase d'authentification et le fichier clé; chacune de ces méthodes de sécurisation de la clé principale peut être utilisée séparément.

   Si à la place du fichier clé un « - » est passé, l'entrée standard sera utilisée. Cet exemple montre comment on peut utiliser plus d'un fichier clé:

   `#` `cat keyfile1 keyfile2 keyfile3 | geli init -K - /dev/da2`

3. Attacher le provider avec la clé générée

   `#` `geli attach -k /root/da2.key /dev/da2` Enter passphrase:

   Le nouveau périphérique sera appelé `/dev/`da2`.eli`.

   `#` `ls /dev/da2*` /dev/da2 /dev/da2.eli

4. Créer le nouveau système de fichiers

   `#` `dd if=/dev/random of=/dev/da2.eli bs=1m` `#` `newfs /dev/da2.eli` `#` `mount /dev/da2.eli /private`

   Le système de fichiers chiffré devrait être maintenant visible par df(1) et disponible à l'utilisation:

   `#` `df -H` Filesystem Size Used Avail Capacity Mounted on /dev/ad0s1a 248M 89M 139M 38% / /devfs 1.0K 1.0K 0B 100% /dev /dev/ad0s1f 7.7G 2.3G 4.9G 32% /usr /dev/ad0s1d 989M 1.5M 909M 0% /tmp /dev/ad0s1e 3.9G 1.3G 2.3G 35% /var /dev/da2.eli 150G 4.1K 138G 0% /private

5. Démonter et détacher le provider

   Une fois l'utilisation de la partition chiffrée achevée et que la partition `/private` n'est plus nécessaire, il est prudent de penser à démonter et détacher la partition `geli` chiffrée:

   `#` `umount /private` `#` `geli detach da2.eli`

Plus d'information sur l'utilisation de geli(8) peut être trouvée dans sa page de manuel.

#### 18.16.2.1. Utiliser la procédure `rc.d` de `geli`

La commande `geli` est fournie avec une procédure `rc.d` qui peut être employée pour simplifier l'utilisation de `geli`. Un exemple de configuration de `geli` à l'aide de rc.conf(5) sera:

geli_devices="da2" geli_da2_flags="-p -k /root/da2.key"

Ces lignes configureront `/dev/da2` comme provider `geli` avec une clé principale `/root/da2.key`, de plus `geli` n'utilisera pas de phrase d'authentification pour attacher le provider (notez que ceci n'est utilisable que si l'option `-P` a été passée durant la phase `geli init`). Le système détachera du noyau le provider `geli` avant l'arrêt du système.

Plus d'information sur la configuration du système `rc.d` est fournie dans la section rc.d de ce Manuel.

[10] Pour des conseils sur comment choisir une phrase d'authentification sécurisée et facile à retenir, consultez le site Web Diceware Passphrase.

Précédent | Niveau supérieur | Suivant
18.15. Quotas d'utilisation des disques | Sommaire | 18.17. Chiffrage de l'espace de pagination

Ce document, ainsi que d'autres peut être téléchargé sur ftp://ftp.FreeBSD.org/pub/FreeBSD/doc/

Pour toutes questions à propos de FreeBSD, lisez la documentation avant de contacter <questions@FreeBSD.org>.
Pour les questions sur cette documentation, contactez <doc@FreeBSD.org>.