Ci sono diversi motivi per cui potresti voler crittografare un filesystem, come proteggere le informazioni sensibili mentre sono a riposo, non doversi preoccupare di crittografare singoli file sul filesystem o altri motivi. Per crittografare manualmente un filesystem in Red Hat Enterprise Linux (RHEL), puoi usare cryptsetup comando. Questo articolo ti spiegherà come utilizzare Ansible per farlo per te per un server RHEL 8.
Prima di approfondire l'utilizzo di Ansible per automatizzare tale processo, eseguiamo innanzitutto i passaggi per manualmente creare il filesystem crittografato in modo da capire meglio cosa stiamo chiedendo di fare ad Ansible. Ci sono comandi nativi in RHEL che ti consentono di creare un filesystem crittografato e li useremo nella nostra procedura dettagliata.
[ Potresti anche divertirti a leggere: Configurazione di LUKS:Linux Unified Key Setup ]
Crea manualmente una partizione crittografata
Per cominciare, esamineremo il dispositivo su cui inserirò la partizione:
[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):
Possiamo vedere che il mio /dev/vdc ha già una partizione su di essa, ma c'è ancora spazio disponibile per un'altra partizione. Creerò il mio /dev/vdc2 partizione:
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 ~]#
Ora ho una partizione /dev/vdc2 di taglia 7G. Successivamente, formatto quella partizione per 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 ~]#
Per aprire il volume crittografato, utilizzo luksOpen argomento per cryptsetup , e gli dico il nome che voglio che il mio target sia 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 ~]# Dopo che è stato aperto, posso effettivamente metterlo in uso. In questo esempio, inserirò un gruppo di volumi:
[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 ~]#
Ho un gruppo di volumi, manual_luks_vg , quindi ora posso inserire un volume logico all'interno:
[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 ~]#
Il lvcreate command ha specificato il nome per il mio nuovo volume logico, manual_luks_logvol , la sua dimensione, 5G, e che il volume logico dovrebbe essere nel gruppo di volumi di manual_luks_vg .
A questo punto ho un volume logico, ma non l'ho ancora formattato per ext o xfs . Digitando mkfs e quindi premendo Tab mi mostra che ci sono un certo numero di opzioni per formattare questa partizione:
# mkfs
mkfs mkfs.cramfs mkfs.ext2 mkfs.ext3 mkfs.ext4 mkfs.minix mkfs.xfs
Qui userò 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
L'ho formattato, ma non montato. Per montarlo, creerò una nuova directory e quindi eseguirò mount comando:
[root@ansibleclient ~]# mkdir /manual_luks
[root@ansibleclient ~]# mount /dev/manual_luks_vg/manual_luks_logvol /manual_luks
Per verificare che abbia funzionato, posso usare mount da solo e quindi scrivere in un nuovo file lì:
[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 ~]#
Per consentire al sistema di montare la partizione crittografata all'avvio, devo aggiornare il mio /etc/crypttab file. Il formato del file è il nome del tuo luks dispositivo, la partizione fisica e quindi il file il cui unico contenuto è la password per quel luks dispositivo:
# cat /etc/crypttab
manualluks /dev/vdc2 /root/manualluks.txt
Nel /root/manualluks.txt , ho solo la password in chiaro per i miei luks dispositivo.
Uso il luksAddKey argomento per aggiungere la chiave al dispositivo:
# cryptsetup luksAddKey /dev/vdc2 /root/manualluks.txt
Per montare il filesystem all'avvio, modifica il /etc/fstab file quindi c'è una voce per il volume logico e il suo punto di montaggio:
/dev/manual_luks_vg/manual_luks_logvol /manual_luks xfs defaults 0 0 Dopo aver eseguito i passaggi manuali per la creazione della partizione e la scrittura su di essa, riavviare il sistema per verificare che le impostazioni siano persistenti e che il sistema si riavvii come previsto.
Ora che abbiamo capito cosa dobbiamo fare per creare manualmente una partizione crittografata, sappiamo cosa dobbiamo fare per automatizzare quel processo.
Automatizzare la creazione di una partizione crittografata
Lo script ospitato su https://people.redhat.com/pgervase/sysadmin/partition.yml fornisce un esempio di come utilizzare Ansible per prendere un disco vuoto e seguire i passaggi per creare una partizione crittografata, montarla e quindi scrivici. Come tante altre cose con la tecnologia, ci sono diversi modi per farlo, ma questo approccio mostrerà anche alcuni esempi di variabili, ottenere fatti e usare un blocco e salvataggio.
---
- 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 Nella parte superiore del playbook, inserisco alcune informazioni di base e dichiaro alcune variabili. Invece di avere i parametri hardcoded nel playbook, definendoli come variabili, posso sovrascriverli quando eseguo il gioco e rendere le attività utilizzabili per altri scopi.
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
Le prime attività che verranno eseguite otterranno informazioni sul mio sistema di destinazione e si assicureranno di non sovrascrivere una partizione esistente. Quindi copio il file di chiavi sul mio sistema remoto. Questo file di chiavi contiene la passphrase che verrà utilizzata quando creo il contenitore LUKS. Non tutti i sistemi avranno il cryptsetup pacchetto installato, quindi la prossima cosa da fare è installare quell'RPM se non è già installato.
- 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 }}'
A questo punto, ho un sistema pronto e appropriato per essere partizionato. Per i miei scopi di registrazione, ho un'attività che stampa le informazioni che parted restituisce per il mio dispositivo di destinazione, /dev/sdb . Le partizioni qui dovrebbero essere vuote perché ho già fallito quando ansible_devices.vdb.partitions.vdb1 è definito, quindi questo è semplicemente per la verifica. Successivamente, utilizzo parted per creare la mia partizione. Per rilevare eventuali errori in questo passaggio, forse il mio dispositivo di destinazione è troppo piccolo o è successo qualcos'altro, utilizzo un blocco e un salvataggio per registrare l'output di parted e poi visualizzalo in errore parte della mia sezione di salvataggio.
- 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 }}"
Ora che ho una partizione e cryptsetup installato, devo eseguire LUKS e la parte del filesystem della mia configurazione. Il primo passo è usare il luks_device modulo, insieme al file di chiavi che ho copiato. Dopo aver ottenuto il contenitore LUKS, creo il gruppo di volumi, quindi il volume logico e quindi il filesystem.
- 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
Dopo che ho un filesystem lì, monto il filesystem e scrivo un file di test per verificare che tutto funzioni correttamente. Il passaggio finale è creare il /etc/crypttab file in modo che il sistema possa montare il mio filesystem quando viene riavviato.
[ Vuoi saperne di più sulla sicurezza? Consulta la checklist di sicurezza e conformità IT. ]
Concludi
Il processo di configurazione manuale di una partizione crittografata non è particolarmente difficile, né richiede molto tempo. Tuttavia, tali attività sono perfette per Ansible da gestire per te, contribuendo a garantire configurazioni coerenti, sicure e riproducibili.
Ulteriori informazioni sui dispositivi LUKS sono disponibili all'indirizzo:
- Come creare un'immagine con crittografia LUKS e montarla all'avvio
- Crittografia dei dispositivi a blocchi utilizzando LUKS
- Blocco dei dati con password LUKS nella console web di RHEL