Hay algunas razones diferentes por las que es posible que desee cifrar un sistema de archivos, como proteger información confidencial mientras está en reposo, no tener que preocuparse por cifrar archivos individuales en el sistema de archivos u otras razones. Para cifrar manualmente un sistema de archivos en Red Hat Enterprise Linux (RHEL), puede usar el cryptsetup dominio. Este artículo lo guiará a través de cómo usar Ansible para hacer esto por usted para un servidor RHEL 8.
Antes de sumergirnos en el uso de Ansible para automatizar ese proceso, primero sigamos los pasos para manualmente cree el sistema de archivos encriptado para que entendamos mejor lo que le estamos pidiendo a Ansible que haga. Hay comandos nativos en RHEL que le permiten crear un sistema de archivos cifrados y los usaremos en nuestro tutorial.
[ También puede disfrutar leyendo: Configuración de LUKS:configuración de clave unificada de Linux]
Crear manualmente una partición cifrada
Para empezar, veremos el dispositivo en el que colocaré la partición:
[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):
Podemos ver que mi /dev/vdc ya tiene una partición, pero todavía hay espacio disponible para otra partición. Crearé mi /dev/vdc2 partición:
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 ~]#
Ahora tengo una partición /dev/vdc2 de tamaño 7G. A continuación, formateo esa partición para 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 ~]#
Para abrir el volumen encriptado, uso luksOpen argumento para cryptsetup , y le digo el nombre que quiero que mi objetivo sea 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 ~]# Después de abrirlo, puedo ponerlo en uso. En este ejemplo, pondré un grupo de volumen allí:
[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 ~]#
Tengo un grupo de volumen, manual_luks_vg , por lo que ahora puedo poner un volumen lógico dentro:
[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 ~]#
El lvcreate comando especificó el nombre de mi nuevo volumen lógico, manual_luks_logvol , su tamaño, 5G, y que el volumen lógico debe estar en el grupo de volúmenes de manual_luks_vg .
En este punto, tengo un volumen lógico, pero aún no lo he formateado para ext o xfs . Escribiendo mkfs y luego presionando Tab me muestra que hay varias opciones para formatear esta partición:
# mkfs
mkfs mkfs.cramfs mkfs.ext2 mkfs.ext3 mkfs.ext4 mkfs.minix mkfs.xfs
Aquí, usaré 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
Lo tengo formateado, pero no montado. Para montarlo, crearé un nuevo directorio y luego ejecutaré mount comando:
[root@ansibleclient ~]# mkdir /manual_luks
[root@ansibleclient ~]# mount /dev/manual_luks_vg/manual_luks_logvol /manual_luks
Para verificar que funcionó, puedo usar mount por sí mismo y luego escribir en un nuevo archivo allí:
[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 ~]#
Para permitir que el sistema monte la partición cifrada en el arranque, necesito actualizar mi /etc/crypttab expediente. El formato del archivo es el nombre de tu luks dispositivo, la partición física y luego el archivo cuyo único contenido es la contraseña para ese luks dispositivo:
# cat /etc/crypttab
manualluks /dev/vdc2 /root/manualluks.txt
En el /root/manualluks.txt , solo tengo la contraseña de texto sin formato para mi luks dispositivo.
Yo uso el luksAddKey argumento para agregar la clave al dispositivo:
# cryptsetup luksAddKey /dev/vdc2 /root/manualluks.txt
Para montar el sistema de archivos en el momento del arranque, edite el /etc/fstab archivo por lo que hay una entrada para el volumen lógico y su punto de montaje:
/dev/manual_luks_vg/manual_luks_logvol /manual_luks xfs defaults 0 0 Una vez que haya realizado los pasos manuales para crear la partición y escribir en ella, reinicie el sistema para verificar que la configuración sea persistente y que el sistema se reinicie como se esperaba.
Ahora que entendemos lo que debemos hacer para crear manualmente una partición cifrada, sabemos lo que debemos hacer para automatizar ese proceso.
Automatizar la creación de una partición cifrada
El script alojado en https://people.redhat.com/pgervase/sysadmin/partition.yml brinda un ejemplo de cómo usar Ansible para tomar un disco en blanco y seguir los pasos para crear una partición cifrada, montarla y luego escríbele. Como muchas cosas con la tecnología, hay varias formas diferentes de lograr esto, pero este enfoque también mostrará algunos ejemplos de variables, obtención de datos y uso de un bloqueo y rescate.
---
- 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 la parte superior del libro de jugadas, coloco información básica y declaro algunas variables. En lugar de tener los parámetros codificados en el libro de jugadas, al tenerlos definidos como variables, puedo anularlos cuando ejecuto el juego y hacer que las tareas se puedan usar para otros fines.
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
Las primeras tareas que se ejecuten obtendrán información sobre mi sistema de destino y se asegurarán de que no voy a sobrescribir una partición existente. Luego copio el archivo de claves en mi sistema remoto. Este archivo de claves contiene la frase de contraseña que se usará cuando cree el contenedor LUKS. No todos los sistemas tendrán el cryptsetup paquete instalado, por lo que lo siguiente que debe hacer es instalar ese RPM si aún no está instalado.
- 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 }}'
En este punto, tengo un sistema que está listo y es apropiado para ser particionado. Para mis propios fines de registro, tengo una tarea que imprime la información que parted devuelve para mi dispositivo de destino, /dev/sdb . Las particiones aquí deben estar en blanco porque ya fallé cuando ansible_devices.vdb.partitions.vdb1 está definido, por lo que esto es simplemente para verificación. A continuación, uso parted para crear mi partición. Para detectar cualquier error en este paso, tal vez mi dispositivo de destino es demasiado pequeño o algo más sucedió, utilizo un bloque y rescate para registrar la salida de parted y luego mostrar eso en el fallo parte de mi sección de rescate.
- 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 }}"
Ahora que tengo una partición y cryptsetup instalado, necesito hacer la parte de LUKS y del sistema de archivos de mi configuración. El primer paso es usar el luks_device módulo, junto con el archivo de claves que copié. Después de tener el contenedor LUKS, creo el grupo de volúmenes, luego el volumen lógico y luego el sistema de archivos.
- 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
Después de tener un sistema de archivos allí, monto el sistema de archivos y escribo un archivo de prueba para verificar que todo funciona correctamente. El paso final es crear el /etc/crypttab archivo para que el sistema pueda montar mi sistema de archivos cuando se reinicie.
[ ¿Quiere obtener más información sobre seguridad? Consulte la lista de verificación de cumplimiento y seguridad de TI. ]
Resumir
El proceso de configurar manualmente una partición encriptada no es particularmente difícil, ni requiere mucho tiempo. Sin embargo, estas tareas son perfectas para que Ansible las maneje por usted, lo que ayuda a garantizar configuraciones consistentes, seguras y reproducibles.
Puede encontrar más información sobre los dispositivos LUKS en:
- Cómo crear una imagen cifrada con LUKS y montarla en el arranque
- Cifrado de dispositivos de bloques con LUKS
- Bloqueo de datos con contraseña de LUKS en la consola web de RHEL