Il existe plusieurs raisons pour lesquelles vous pourriez vouloir chiffrer un système de fichiers, telles que la protection des informations sensibles lorsqu'elles sont au repos, ne pas avoir à vous soucier du chiffrement de fichiers individuels sur le système de fichiers, ou d'autres raisons. Pour chiffrer manuellement un système de fichiers dans Red Hat Enterprise Linux (RHEL), vous pouvez utiliser le cryptsetup commande. Cet article vous expliquera comment utiliser Ansible pour le faire pour vous pour un serveur RHEL 8.
Avant de plonger dans l'utilisation d'Ansible pour automatiser ce processus, passons d'abord par les étapes pour manuellement créer le système de fichiers chiffré afin que nous comprenions mieux ce que nous demandons à Ansible de faire. Il existe des commandes natives dans RHEL qui vous permettent de créer un système de fichiers chiffré, et nous les utiliserons dans notre procédure pas à pas.
[ Vous aimerez peut-être également lire : Configuration de LUKS :Configuration de la clé unifiée Linux ]
Créer manuellement une partition chiffrée
Pour commencer, nous allons regarder le périphérique sur lequel je vais mettre la partition :
[root@ansibleclient ~]# fdisk /dev/vdc
Welcome to fdisk (util-linux 2.32.1).
Changes will remain only in memory until you decide to write them.
Be careful before using the write command.
Command (m for help): p
Disk /dev/vdc: 30 GiB, 32212254720 bytes, 62914560 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x803e8b19
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 6291455 6289408 3G 83 Linux
Command (m for help):
Nous pouvons voir que mon /dev/vdc contient déjà une partition, mais il reste de l'espace disponible pour une autre partition. Je vais créer mon /dev/vdc2 partition :
Command (m for help): n
Partition type
p primary (1 primary, 0 extended, 3 free)
e extended (container for logical partitions)
Select (default p):
Using default response p.
Partition number (2-4, default 2):
First sector (6291456-62914559, default 6291456):
Last sector, +sectors or +size{K,M,G,T,P} (6291456-62914559, default 62914559): +7G
Created a new partition 2 of type 'Linux' and of size 7 GiB.
Command (m for help): p
Disk /dev/vdc: 30 GiB, 32212254720 bytes, 62914560 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x803e8b19
Device Boot Start End Sectors Size Id Type
/dev/vdc1 2048 6291455 6289408 3G 83 Linux
/dev/vdc2 6291456 20971519 14680064 7G 83 Linux
Command (m for help): w
The partition table has been altered.
Syncing disks.
[root@ansibleclient ~]# partprobe /dev/vdc
[root@ansibleclient ~]#
J'ai maintenant une partition /dev/vdc2 de taille 7G. Ensuite, je formate cette partition pour luks :
[root@ansibleclient ~]# cryptsetup luksFormat /dev/vdc2
WARNING!
========
This will overwrite data on /dev/vdc2 irrevocably.
Are you sure? (Type uppercase yes): YES
Enter passphrase for /dev/vdc2:
Verify passphrase:
[root@ansibleclient ~]#
Pour ouvrir le volume chiffré, j'utilise le luksOpen argument pour cryptsetup , et je lui dis le nom que je veux que ma cible soit manualluks :
[root@ansibleclient ~]# cryptsetup luksOpen /dev/vdc2 manualluks
Enter passphrase for /dev/vdc2:
[root@ansibleclient ~]# ls /dev/mapper/
control examplevg-examplelv manualluks mycrypt rhel-root rhel-swap
[root@ansibleclient ~]# Une fois ouvert, je peux réellement l'utiliser. Dans cet exemple, je vais y mettre un groupe de volumes :
[root@ansibleclient ~]# vgcreate manual_luks_vg /dev/mapper/manualluks
Physical volume "/dev/mapper/manualluks" successfully created.
Volume group "manual_luks_vg" successfully created
[root@ansibleclient ~]# vgdisplay manual_luks_vg
--- Volume group ---
VG Name manual_luks_vg
System ID
Format lvm2
Metadata Areas 1
Metadata Sequence No 1
VG Access read/write
VG Status resizable
MAX LV 0
Cur LV 0
Open LV 0
Max PV 0
Cur PV 1
Act PV 1
VG Size 6.98 GiB
PE Size 4.00 MiB
Total PE 1787
Alloc PE / Size 0 / 0
Free PE / Size 1787 / 6.98 GiB
VG UUID bjZ7FM-9jNw-pdfs-Dd5y-5IsF-tEdK-CpVqH4
[root@ansibleclient ~]#
J'ai un groupe de volumes, manual_luks_vg , donc je peux maintenant mettre un volume logique à l'intérieur :
[root@ansibleclient ~]# lvcreate -n manual_luks_logvol -L +5G manual_luks_vg
Logical volume "manual_luks_logvol" created.
[root@ansibleclient ~]# lvdisplay manual_luks_vg
--- Logical volume ---
LV Path /dev/manual_luks_vg/manual_luks_logvol
LV Name manual_luks_logvol
VG Name manual_luks_vg
LV UUID nR5UKo-jRvR-97L0-60YF-dbSp-D0pc-l8W3Td
LV Write Access read/write
LV Creation host, time ansibleclient.usersys.redhat.com, 2020-12-03 10:15:03 -0500
LV Status available
# open 0
LV Size 5.00 GiB
Current LE 1280
Segments 1
Allocation inherit
Read ahead sectors auto
- currently set to 8192
Block device 253:5
[root@ansibleclient ~]#
Le lvcreate la commande a spécifié le nom de mon nouveau volume logique, manual_luks_logvol , sa taille, 5G, et que le volume logique doit être dans le groupe de volumes de manual_luks_vg .
À ce stade, j'ai un volume logique, mais je ne l'ai pas encore formaté pour ext ou xfs . Taper mkfs puis en appuyant sur Tab me montre qu'il existe un certain nombre d'options pour formater cette partition :
# mkfs
mkfs mkfs.cramfs mkfs.ext2 mkfs.ext3 mkfs.ext4 mkfs.minix mkfs.xfs
Ici, je vais utiliser mkfs.xfs :
[root@ansibleclient ~]# mkfs.xfs /dev/manual_luks_vg/manual_luks_logvol
meta-data=/dev/manual_luks_vg/manual_luks_logvol isize=512 agcount=4, agsize=327680 blks
= sectsz=512 attr=2, projid32bit=1
= crc=1 finobt=1, sparse=1, rmapbt=0
= reflink=1
data = bsize=4096 blocks=1310720, imaxpct=25
= sunit=0 swidth=0 blks
naming =version 2 bsize=4096 ascii-ci=0, ftype=1
log =internal log bsize=4096 blocks=2560, version=2
= sectsz=512 sunit=0 blks, lazy-count=1
realtime =none extsz=4096 blocks=0, rtextents=0
Je l'ai formaté, mais pas monté. Pour le monter, je vais créer un nouveau répertoire puis lancer le mount commande :
[root@ansibleclient ~]# mkdir /manual_luks
[root@ansibleclient ~]# mount /dev/manual_luks_vg/manual_luks_logvol /manual_luks
Pour vérifier que cela a fonctionné, je peux utiliser mount par lui-même, puis écrivez dans un nouveau fichier :
[root@ansibleclient ~]# mount | grep luks
/dev/mapper/manual_luks_vg-manual_luks_logvol on /manual_luks type xfs (rw,relatime,seclabel,attr2,inode64,noquota)
[root@ansibleclient ~]# date > /manual_luks/testing
[root@ansibleclient ~]# cat /manual_luks/testing
Thu Dec 3 10:24:42 EST 2020
[root@ansibleclient ~]#
Pour permettre au système de monter la partition chiffrée au démarrage, je dois mettre à jour mon /etc/crypttab dossier. Le format du fichier est le nom de votre luks périphérique, la partition physique, puis le fichier dont le seul contenu est le mot de passe pour ce luks appareil :
# cat /etc/crypttab
manualluks /dev/vdc2 /root/manualluks.txt
Dans le /root/manualluks.txt , j'ai juste le mot de passe en clair pour mon luks appareil.
J'utilise le luksAddKey argument pour ajouter la clé à l'appareil :
# cryptsetup luksAddKey /dev/vdc2 /root/manualluks.txt
Pour monter le système de fichiers au démarrage, modifiez le /etc/fstab fichier afin qu'il y ait une entrée pour le volume logique et son point de montage :
/dev/manual_luks_vg/manual_luks_logvol /manual_luks xfs defaults 0 0 Une fois que vous avez effectué les étapes manuelles pour créer la partition et y écrire, redémarrez le système pour vérifier que les paramètres sont persistants et que le système redémarre comme prévu.
Maintenant que nous comprenons ce que nous devons faire pour créer manuellement une partition chiffrée, nous savons ce que nous devons faire pour automatiser ce processus.
Automatiser la création d'une partition chiffrée
Le script hébergé sur https://people.redhat.com/pgervase/sysadmin/partition.yml donne un exemple d'utilisation d'Ansible pour prendre un disque vierge et suivre les étapes pour créer une partition chiffrée, la monter, puis écrivez-lui. Comme tant d'autres choses avec la technologie, il existe plusieurs façons d'y parvenir, mais cette approche montrera également quelques exemples de variables, d'obtention de faits et d'utilisation d'un blocage et d'un sauvetage.
---
- name: pb to create partition
hosts: all
become: true
vars:
target_size: 3GiB
target_device: /dev/vdc
myvg: examplevg
mylv: examplelv
keyfile: /root/mylukskey.yml
mycrypt: mycrypt En haut du playbook, je place quelques informations de base et déclare quelques variables. Plutôt que d'avoir les paramètres codés en dur dans le playbook, en les définissant comme des variables, je peux les remplacer lorsque j'exécute le jeu et rendre les tâches utilisables à d'autres fins.
tasks:
- name: block for doing basic setup and verification for target system
block:
- name: get facts for "{{ target_device }}"
parted:
device: "{{ target_device }}"
register: target_facts
- name: print facts for "{{ target_device }}"
debug:
msg: "{{ target_facts }}"
- name: check to see if there are any facts for /dev/vdb1. this means there are existing partitions that we would overwrite, so fail
debug:
msg: "{{ target_facts }}.partitions"
failed_when: ansible_devices.vdb.partitions.vdb1 is defined ### if vdb1 is defined, there's already a partition there, so abort.
- name: print size for the disk
debug:
msg: "the size is {{ target_facts['disk']['size'] }} kib"
- name: copy keyfile to remote system
copy:
src: mylukskey.yml
dest: "{{ keyfile }}"
- name: make sure cryptsetup is installed
yum:
name: cryptsetup
state: installed
Les premières tâches exécutées vont obtenir des informations sur mon système cible et m'assurer que je ne vais pas écraser une partition existante. Je copie ensuite le keyfile sur mon système distant. Ce fichier clé contient la phrase secrète qui sera utilisée lors de la création du conteneur LUKS. Tous les systèmes n'auront pas le cryptsetup package installé, donc la prochaine chose à faire est d'installer ce RPM s'il n'est pas déjà installé.
- name: block to attempt to get info on what my destination device will become
block:
- name: task to attempt to get info on what my destination device will be
parted:
device: "{{ target_device}}"
number: 1
state: info
register: info_output
- name: print info_output
debug:
msg: "{{ info_output }}"
- name: block to attempt parted
block:
- name: use parted in block to create new partition
parted:
device: "{{ target_device }}"
number: 1
state: present
part_end: "{{ target_size }}"
register: parted_output
rescue:
- name: parted failed
fail:
msg: 'parted failed: {{ parted_output }}'
À ce stade, j'ai un système qui est prêt et approprié pour être partitionné. Pour mes propres besoins de journalisation, j'ai une tâche qui imprime les informations qui parted rend pour mon appareil cible, /dev/sdb . Les partitions ici doivent être vides car j'ai déjà échoué lorsque ansible_devices.vdb.partitions.vdb1 est défini, c'est donc simplement pour vérification. Ensuite, j'utilise parted pour créer ma partition. Pour détecter les erreurs de cette étape (peut-être que mon appareil de destination est trop petit ou qu'il s'est passé quelque chose d'autre), j'utilise un bloc et un sauvetage pour enregistrer la sortie de parted puis affichez-le dans le champ fail partie de ma section de sauvetage.
- name: block for LUKS and filesystem tasks
block:
- name: create LUKS container with passphrase
luks_device:
device: "{{ target_device }}1"
state: present
name: "{{ mycrypt }}"
keyfile: "{{ keyfile }}"
- name: open luks container
luks_device:
device: "{{ target_device }}1"
state: opened
name: "{{ mycrypt }}"
keyfile: "{{ keyfile }}"
- name: create a new volgroup in that partition
lvg:
vg: "{{ myvg }}"
pvs: "/dev/mapper/{{ mycrypt }}"
- name: create a logvol in my new vg
lvol:
vg: "{{ myvg }}"
lv: "{{ mylv }}"
size: +100%FREE`
- name: create a filesystem
filesystem:
fstype: xfs
dev: "/dev/mapper/{{ myvg }}-{{ mylv }}"
Maintenant que j'ai une partition et cryptsetup installé, je dois faire la partie LUKS et système de fichiers de ma configuration. La première étape consiste à utiliser le luks_device module, ainsi que le fichier clé que j'ai copié. Une fois que j'ai le conteneur LUKS, je crée le groupe de volumes, puis le volume logique, puis le système de fichiers.
- name: mount device
mount:
path: /mnt
src: "/dev/mapper/{{ myvg }}-{{ mylv }}"
state: mounted
fstype: xfs
- name: put some content in my new filesystem
copy:
content: "this is secure content!"
dest: /mnt/newcontent.txt
- name: set content in /etc/crypttab so I can mount the partition on reboot
copy:
content: "{{ mycrypt }} {{ target_device }}1 {{ keyfile }}"
dest: /etc/crypttab
owner: root
group: root
mode: 0644
Une fois que j'ai un système de fichiers là-bas, je monte le système de fichiers et j'écris un fichier de test pour vérifier que tout fonctionne correctement. La dernière étape consiste à créer le /etc/crypttab fichier afin que le système puisse monter mon système de fichiers lorsqu'il est redémarré.
[ Vous voulez en savoir plus sur la sécurité ? Consultez la liste de vérification de la sécurité informatique et de la conformité. ]
Récapitulez
Le processus de configuration manuelle d'une partition cryptée n'est pas particulièrement difficile, ni même chronophage. Cependant, ces tâches sont parfaites pour qu'Ansible puisse les gérer pour vous, ce qui permet de garantir des configurations cohérentes, sécurisées et reproductibles.
Pour plus d'informations sur les appareils LUKS, rendez-vous sur :
- Comment créer une image cryptée par LUKS et la monter au démarrage
- Chiffrer les périphériques de bloc à l'aide de LUKS
- Verrouillage des données avec le mot de passe LUKS dans la console Web RHEL