Es gibt verschiedene Gründe, warum Sie ein Dateisystem möglicherweise verschlüsseln möchten, z. B. um vertrauliche Informationen zu schützen, während sie ruhen, sich keine Gedanken über die Verschlüsselung einzelner Dateien im Dateisystem machen zu müssen oder aus anderen Gründen. Um ein Dateisystem in Red Hat Enterprise Linux (RHEL) manuell zu verschlüsseln, können Sie das cryptsetup verwenden Befehl. Dieser Artikel führt Sie durch die Verwendung von Ansible, um dies für Sie für einen RHEL 8-Server zu tun.
Bevor wir uns mit der Verwendung von Ansible zur Automatisierung dieses Prozesses befassen, gehen wir zunächst die Schritte zur manuellen Ausführung durch Erstellen Sie das verschlüsselte Dateisystem, damit wir besser verstehen, was wir von Ansible verlangen. Es gibt native Befehle in RHEL, mit denen Sie ein verschlüsseltes Dateisystem erstellen können, und wir werden diese in unserer exemplarischen Vorgehensweise verwenden.
[Sie könnten auch gerne lesen: Konfigurieren von LUKS:Linux Unified Key Setup]
Manuell eine verschlüsselte Partition erstellen
Zunächst sehen wir uns das Gerät an, auf dem ich die Partition ablegen werde:
[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):
Wir können sehen, dass mein /dev/vdc enthält bereits eine Partition, aber es ist noch Platz für eine andere Partition verfügbar. Ich erstelle mein /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 ~]#
Ich habe jetzt eine Partition /dev/vdc2 der Größe 7G. Als nächstes formatiere ich diese Partition für 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 ~]#
Um das verschlüsselte Volume zu öffnen, verwende ich den luksOpen Argument für cryptsetup , und ich sage ihm den Namen, den ich als Ziel manualluks haben möchte :
[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 ~]# Nachdem es geöffnet wurde, kann ich es tatsächlich verwenden. In diesem Beispiel lege ich dort eine Datenträgergruppe ab:
[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 ~]#
Ich habe eine Volumengruppe, manual_luks_vg , also kann ich jetzt ein logisches Volume hineinlegen:
[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 ~]#
Die lvcreate Der Befehl gab den Namen für mein neues logisches Volume an, manual_luks_logvol , seine Größe, 5 GB, und dass sich das logische Volume in der Volume-Gruppe von manual_luks_vg befinden sollte .
An diesem Punkt habe ich ein logisches Volume, aber ich habe es noch nicht für ext formatiert oder xfs . Geben Sie mkfs ein und drücken Sie dann Tab zeigt mir, dass es eine Reihe von Optionen für mich gibt, diese Partition zu formatieren:
# mkfs
mkfs mkfs.cramfs mkfs.ext2 mkfs.ext3 mkfs.ext4 mkfs.minix mkfs.xfs
Hier verwende ich 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
Ich habe es formatiert, aber nicht gemountet. Um es zu mounten, erstelle ich ein neues Verzeichnis und führe dann mount aus Befehl:
[root@ansibleclient ~]# mkdir /manual_luks
[root@ansibleclient ~]# mount /dev/manual_luks_vg/manual_luks_logvol /manual_luks
Um zu überprüfen, ob das funktioniert hat, kann ich mount verwenden selbst und schreibt dort dann in eine neue Datei:
[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 ~]#
Damit das System die verschlüsselte Partition beim Booten mounten kann, muss ich meine /etc/crypttab aktualisieren Datei. Das Format für die Datei ist der Name Ihres luks Gerät, die physische Partition und dann die Datei, deren einziger Inhalt das Passwort für diesen luks ist Gerät:
# cat /etc/crypttab
manualluks /dev/vdc2 /root/manualluks.txt
In der /root/manualluks.txt , ich habe nur das Klartext-Passwort für mein luks Gerät.
Ich verwende den luksAddKey Argument zum Hinzufügen des Schlüssels zum Gerät:
# cryptsetup luksAddKey /dev/vdc2 /root/manualluks.txt
Um das Dateisystem beim Booten einzuhängen, bearbeiten Sie die Datei /etc/fstab Datei, sodass es einen Eintrag für das logische Volume und seinen Einhängepunkt gibt:
/dev/manual_luks_vg/manual_luks_logvol /manual_luks xfs defaults 0 0 Nachdem Sie die manuellen Schritte zum Erstellen der Partition und zum Schreiben darauf ausgeführt haben, starten Sie das System neu, um zu überprüfen, ob die Einstellungen dauerhaft sind und das System wie erwartet neu startet.
Nachdem wir nun verstanden haben, was wir tun müssen, um eine verschlüsselte Partition manuell zu erstellen, wissen wir, was wir tun müssen, um diesen Prozess zu automatisieren.
Automatisieren Sie die Erstellung einer verschlüsselten Partition
Das unter https://people.redhat.com/pgervase/sysadmin/partition.yml gehostete Skript gibt ein Beispiel für die Verwendung von Ansible, um eine leere Festplatte zu nehmen und die Schritte zum Erstellen einer verschlüsselten Partition zu durchlaufen, sie zu mounten und dann schreib dazu. Wie bei so vielen Dingen in der Technologie gibt es verschiedene Möglichkeiten, dies zu erreichen, aber dieser Ansatz zeigt auch einige Beispiele für Variablen, das Abrufen von Fakten und die Verwendung eines Blocks und einer Rettung.
---
- 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 Oben im Playbook platziere ich einige grundlegende Informationen und deklariere einige Variablen. Anstatt die Parameter im Playbook fest codiert zu haben, kann ich sie, indem ich sie als Variablen definiere, überschreiben, wenn ich das Stück starte, und die Aufgaben für andere Zwecke nutzbar machen.
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
Die ersten Aufgaben, die ausgeführt werden, werden Informationen über mein Zielsystem abrufen und sicherstellen, dass ich keine vorhandene Partition überschreibe. Ich kopiere dann die Schlüsseldatei auf mein entferntes System. Diese Schlüsseldatei enthält die Passphrase, die verwendet wird, wenn ich den LUKS-Container erstelle. Nicht alle Systeme haben das cryptsetup Paket installiert, also müssen Sie als Nächstes dieses RPM installieren, falls es noch nicht installiert ist.
- 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 }}'
An diesem Punkt habe ich ein System, das bereit und geeignet ist, partitioniert zu werden. Für meine eigenen Protokollierungszwecke habe ich eine Aufgabe, die die Informationen ausgibt, die parted gibt für mein Zielgerät /dev/sdb zurück . Die Partitionen hier sollten leer sein, da ich bereits bei ansible_devices.vdb.partitions.vdb1 gescheitert bin definiert ist, dient also nur der Überprüfung. Als nächstes verwende ich parted um meine Partition zu erstellen. Um Fehler in diesem Schritt abzufangen – vielleicht ist mein Zielgerät zu klein oder etwas anderes ist passiert – verwende ich einen Block und eine Rettung, um die Ausgabe von parted zu registrieren und zeigen Sie das dann im fail an Teil meiner Rettungsabteilung.
- 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 }}"
Jetzt habe ich eine Partition und cryptsetup installiert ist, muss ich den LUKS- und Dateisystemteil meines Setups ausführen. Der erste Schritt ist die Verwendung des luks_device Modul, zusammen mit der Schlüsseldatei die ich kopiert habe. Nachdem ich den LUKS-Container habe, erstelle ich die Volumengruppe, dann das logische Volumen und dann das Dateisystem.
- 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
Nachdem ich dort ein Dateisystem habe, mounte ich das Dateisystem und schreibe eine Testdatei, um zu überprüfen, ob alles richtig funktioniert. Der letzte Schritt besteht darin, /etc/crypttab zu erstellen Datei, damit das System mein Dateisystem einhängen kann, wenn es neu gestartet wird.
[ Möchten Sie mehr über Sicherheit erfahren? Sehen Sie sich die Checkliste für IT-Sicherheit und Compliance an. ]
Abschluss
Der Prozess der manuellen Konfiguration einer verschlüsselten Partition ist nicht besonders schwierig oder sogar zeitaufwändig. Solche Aufgaben können jedoch perfekt von Ansible für Sie erledigt werden, um konsistente, sichere und reproduzierbare Konfigurationen zu gewährleisten.
Weitere Informationen zu LUKS-Geräten finden Sie unter:
- Wie man ein LUKS-verschlüsseltes Image erstellt und es beim Booten einbindet
- Verschlüsseln von Blockgeräten mit LUKS
- Sperren von Daten mit LUKS-Passwort in der RHEL-Webkonsole