Dies ist der erste Teil einer dreiteiligen Reihe von Blogbeiträgen zur Verwendung von Kali auf Raspberry Pi-Geräten. Dieser erste Beitrag befasst sich mit der Aktivierung der vollständigen Festplattenverschlüsselung (FDE) auf einem Raspberry Pi, Teil zwei befasst sich mit der Fernverbindung zu ihm, und Teil drei schließlich befasst sich mit Debugging-Problemen, auf die wir während der Erstellung dieser Beiträge gestoßen sind, damit andere lernen können, wie es geht so auch.

Mit allem, was in den letzten Jahren auf der Welt passiert ist, arbeiten immer mehr Menschen aus der Ferne. Wir sind da keine Ausnahme, und heute werden wir unsere „Dropbox“-Maschine erneut besuchen, die verschlüsselt wurde, wodurch es schwieriger wird, falls entdeckt zu identifizieren .

Das Ziel ist es, ein eigenständiges „Leave Behind“ headless zu schaffen Gerät, das, falls/wenn es entdeckt wird, es nicht einfach macht, herauszufinden, was wir getan haben, da unsere Daten sicher sind jederzeit. Um dies zu erreichen, verwenden wir Full Disk Encryption (FDE) und ermöglichen die Fernentsperrung (sollte das Gerät aus irgendeinem Grund neu gestartet werden). Es wird auch die Option geben, LUKS Nuke zu verwenden Funktion, falls wir die Festplatte zu irgendeinem Zeitpunkt unzugänglich machen möchten, nachdem wir damit fertig sind. Wir werden dies auf einem Raspberry Pi 4 Model B+ tun, aber es wurde auch auf einem Raspberry Pi 3 Model B getestet. Sie sollten in der Lage sein, die meisten Marken/Modelle ähnlicher Geräte zu verwenden, es sind möglicherweise nur ein paar kreative Anpassungen/Anpassungen erforderlich, um Ihr eigenes System zu sichern.

Dies ist ein aktualisierter Prozess, da wir einen Teil davon bereits zuvor behandelt haben. Dieses Mal nehmen wir zusätzliche Entwicklungen mit einigen Community-Beiträgen auf. Wir möchten Richard Nelson (@unixabg) für sein automatisiertes Skript danken. Wir werden darauf eingehen, nachdem wir die manuelle Methode durchlaufen haben, da wir immer empfehlen, dass Sie verstehen, was unter der Haube vor sich geht.

Übergeordnete Übersicht

Bevor wir in die unteren Ebenen der technischen Details dessen eintauchen, was wir erreichen wollen, werfen wir einen kurzen Blick auf unsere Ziele, die wir erreichen wollen, und schlüsseln sie auf:

• Installieren Sie Kali Linux auf einem Raspberry Pi 4 (im Folgenden „RPi“ genannt)
• Bereiten Sie das System für den verschlüsselten Start vor, damit es für die Remote-Festplattenentsperrung bereit ist
• Richten Sie SSH-Schlüssel ein, damit die Remote-Entsperrung erfolgen kann (mit initramfs und Dropbear)
• Sichern Sie alle vorhandenen Daten
• Konfigurieren Sie die verschlüsselten Partitionen
• Stellen Sie unsere Daten wieder her
• Hack weg !

Das mag nach viel klingen, aber es ist ziemlich einfach, auch wenn es ein paar Schritte gibt. Nach Abschluss haben wir ein RPi, das:

• Starten
• IP von DHCP abrufen
• Warten Sie, bis wir uns über SSH mit Schlüsseln verbinden
• Gestatten Sie uns, entweder die LUKS-Entsperrung oder die LUKS-Nuke-Passphrasen bereitzustellen

Dann, wenn wir mit dem fertig sind, was wir tun möchten, müssen wir es nur noch abrufen …in aller Ruhe!

Installieren von Kali Linux auf einem RPi

Wenn Sie weitermachen, stellen Sie sicher, dass Sie wissen, wohin Sie die Datei kopieren, und ersetzen Sie /dev/sdX . Nicht blind kopieren/einfügen!

Wir werden unsere Dropbox-Maschine auf einer bestehenden Kali-Installation erstellen. Es sollte sehr einfach sein, andere Debian-basierte Distributionen zu verwenden, und ziemlich einfach für andere Betriebssysteme (außer Windows-Benutzer!)

Wir werden zuerst das neueste stabile Kali RPi-Image herunterladen. Zum Zeitpunkt des Schreibens ist das Kali 2022.2. Wir haben uns auch für das 64-Bit-Image entschieden, da wir mehr als 4 GB RAM haben und keine HATs (Hardware Attached on Top) verwenden. Die Schritte für 32-Bit wären die gleichen, nachdem Sie die Dateinamen angepasst haben:

$ wget https://kali.download/arm-images/kali-2022.2/kali-linux-2022.2-raspberry-pi-arm64.img.xz
$ xzcat kali-linux-2022.2-raspberry-pi-arm64.img.xz | sudo dd of=/dev/sdX bs=512k status=progress

System vorbereiten

Chroot vorbereiten

Als nächstes werden wir die Dinge für eine Chroot vorbereiten. Lassen Sie uns erstellen, wo wir die microSD-Karte montieren möchten, und dann montieren:

$ sudo mkdir -vp /mnt/chroot/
$ sudo mount /dev/sdX2 /mnt/chroot/
$ sudo mount /dev/sdX1 /mnt/chroot/boot/
$ sudo mount -t proc none /mnt/chroot/proc
$ sudo mount -t sysfs none /mnt/chroot/sys
$ sudo mount -o bind /dev /mnt/chroot/dev
$ sudo mount -o bind /dev/pts /mnt/chroot/dev/pts
$ sudo apt install -y qemu-user-static
$ sudo cp /usr/bin/qemu-aarch64-static /mnt/chroot/usr/bin/

Die letzten beiden Befehle werden sich später als nützlich für initramfs erweisen.

Erforderliche Pakete installieren

Nachdem unser System nun eingerichtet ist, können wir die Chroot verwenden, um das RPi-Image für die Verschlüsselung einzurichten. Lassen Sie uns zuerst die Chroot betreten und einige notwendige Pakete installieren:

$ sudo env LANG=C chroot /mnt/chroot/
┌──(root㉿kali)-[/]
└─# apt update

┌──(root㉿kali)-[/]
└─# apt install -y busybox cryptsetup dropbear-initramfs lvm2

Wir wollen sicherstellen, dass wir auf dem neuesten Kernel sind, bevor wir anfangen, also lasst uns auch sicherstellen, dass wir sie installiert haben:

┌──(root㉿kali)-[/]
└─# apt install -y kalipi-kernel kalipi-bootloader kalipi-re4son-firmware

Startoptionen

Als nächstes bearbeiten wir /boot/cmdline.txt und ändern Sie den Root-Pfad. Die /boot/cmdline.txt Datei auf einem RPi-Gerät wird verwendet, um die Kernel-Befehlszeilenoptionen zu übergeben. Wir möchten den Root-Pfad in /dev/mapper/crypt ändern , und dann fügen wir cryptdevice=PARTUUID=$partuuid:crypt hinzu gleich danach.

Der Grund dafür ist, dass der Kernel wissen muss, wo sich das Root-Dateisystem befindet, um es zu mounten und zu verwenden, und da wir die rootfs später im Beitrag verschlüsseln, kann er während des Bootens auch das unverschlüsselte Gerät nicht sehen , wegen der Verschlüsselung! Während wir hier den Namen in „Krypta“ ändern, können Sie es beliebig nennen.

Das Endergebnis sollte so aussehen:

┌──(root㉿kali)-[/]
└─# vim /boot/cmdline.txt

┌──(root㉿kali)-[/]
└─# cat /boot/cmdline.txt
dwc_otg.fiq_fix_enable=2 console=serial0,115200 kgdboc=serial0,115200 console=tty1 root=/dev/mapper/crypt cryptdevice=PARTUUID=ed889dad-02:crypt rootfstype=ext4 fsck.repair=yes rootwait net.ifnames=0

Partitionslayout

Wir müssen jetzt den /etc/fstab aktualisieren Datei, dies ist eine Konfigurationsdatei auf dem System, die alle verfügbaren Festplatten, Festplattenpartitionen und die zu verwendenden Optionen für deren Handhabung enthält.

Derzeit ist es mit der UUID des Root-Dateisystems gefüllt, und wir benötigen es, um auf das verschlüsselte Dateisystem zu verweisen, das wir erstellen werden. In diesem Beispiel haben wir die UUID des vorherigen Root-Geräts auskommentiert und zeigen auf /dev/mapper/crypt So wird unser verschlüsseltes Dateisystem gemountet, sobald wir es erstellt haben:

┌──(root㉿kali)-[/]
└─# vim /etc/fstab

┌──(root㉿kali)-[/]
└─# cat /etc/fstab
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
proc            /proc           proc    defaults          0       0

/dev/mapper/crypt /               ext4 errors=remount-ro 0       0
#UUID=747bfa7c-edd2-471f-8fff-0ecafc2d3791 /               ext4 errors=remount-ro 0       1
LABEL=BOOT      /boot           vfat    defaults          0       2

Konfigurieren Sie die verschlüsselten Partitionen

Wenn Sie verschlüsselte Partitionen verwenden, müssen wir den /etc/crypttab bearbeiten oder erstellen, falls er nicht vorhanden ist Datei, die von cryptsetup verwendet wird, um zu wissen, welche Optionen benötigt werden, um das verschlüsselte Gerät zu entsperren.

Da diese Datei nicht existiert, erstellen wir den /etc/crypttab Datei, und füllen Sie sie mit den Optionen, die wir brauchen:

┌──(root㉿kali)-[/]
└─# echo -e 'crypt\tPARTUUID=ed889dad-02\tnone\tluks' > /etc/crypttab

Jetzt machen wir einen kleinen Trick mit dem Dateisystem. Wir erstellen ein gefälschtes LUKS-Dateisystem, mit dem cryptsetup in das initramfs aufgenommen werden kann, da es eine verschlüsselte Partition sieht. Wenn Sie LUKS-Partitionen formatieren, werden Sie nach einem Passwort gefragt, und obwohl Sie normalerweise ein sicheres Passwort verwenden, da wir dies nur als Hack verwenden, um cryptsetup in unser initramfs einzufügen, wird das Passwort, das Sie an dieser Eingabeaufforderung erstellen, dies nicht tun nach diesen Schritten benötigt oder verwendet werden, sodass Sie es auf etwas kurzes/schnelles Tippen einstellen können. Dies wird beim cryptsetup luksFormat geschehen Schritt, und Sie werden nach dem Passwort gefragt, das Sie während cryptsetup luksFormat festgelegt haben wenn Sie cryptsetup luksOpen ausführen Schritt.

Bei der Eingabe des Passworts wird keine Eingabe angezeigt

┌──(root㉿kali)-[/]
└─# dd if=/dev/zero of=/tmp/fakeroot.img bs=1M count=20

┌──(root㉿kali)-[/]
└─# exit
$ sudo cryptsetup luksFormat /mnt/chroot/tmp/fakeroot.img
$ sudo cryptsetup luksOpen /mnt/chroot/tmp/fakeroot.img crypt
$ sudo mkfs.ext4 /dev/mapper/crypt

SSH-Schlüssel konfigurieren

Danach müssen wir kopieren ODER einen neuen SSH-Schlüssel generieren, der zu Dropbears authorized_keys hinzugefügt wird Datei.

Wenn wir bereits einen vorhandenen Schlüssel zum Kopieren haben:

$ sudo cp ~/.ssh/id_rsa.pub /mnt/chroot/

Alternativ zum Generieren eines neuen Schlüssels:

$ ssh-keygen -t rsa -b 4096
[...]
Enter file in which to save the key (/home/kali/.ssh/id_rsa): /home/kali/.ssh/id_rsa_dropbear
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/kali/.ssh/id_rsa_dropbear
Your public key has been saved in /home/kali/.ssh/id_rsa_dropbear.pub
[...]
$ sudo cp ~/.ssh/id_rsa_dropbear.pub /mnt/chroot/

Bei der Eingabe einer Passphrase wird keine Eingabe angezeigt

Konfiguration für die Verschlüsselung

Zurück in die Chroot müssen wir ein paar neue Dateien erstellen.

Zuerst ist die zz-cryptsetup Hook, der die Dateien hinzufügt, die wir für cryptsetup benötigen in initramfs . Damit es funktioniert, muss es als ausführbar markiert werden, sodass mkinitramfs wird den Hook ausführen:

$ sudo env LANG=C chroot /mnt/chroot/
┌──(root㉿kali)-[/]
└─# vim /etc/initramfs-tools/hooks/zz-cryptsetup

┌──(root㉿kali)-[/]
└─# cat /etc/initramfs-tools/hooks/zz-cryptsetup
#!/bin/sh
set -e

PREREQ=""
prereqs()
{
	echo "${PREREQ}"
}

case "${1}" in
	prereqs)
		prereqs
		exit 0
		;;
esac

. /usr/share/initramfs-tools/hook-functions

mkdir -p ${DESTDIR}/cryptroot || true
cat /etc/crypttab >> ${DESTDIR}/cryptroot/crypttab
cat /etc/fstab >> ${DESTDIR}/cryptroot/fstab
cat /etc/crypttab >> ${DESTDIR}/etc/crypttab
cat /etc/fstab >> ${DESTDIR}/etc/fstab
copy_file config /etc/initramfs-tools/unlock.sh /etc/unlock.sh

┌──(root㉿kali)-[/]
└─# chmod +x /etc/initramfs-tools/hooks/zz-cryptsetup

Sollten Sie es zu einem späteren Zeitpunkt aus irgendeinem Grund deaktivieren wollen, entfernen Sie einfach das ausführbare Bit.

Wir bearbeiten die Moduldatei für initramfs-tools sodass wir den dm-crypt einfügen Modul, und cat die Datei, um zu überprüfen, ob sie korrekt ist:

┌──(root㉿kali)-[/]
└─# grep -q dm_crypt /etc/initramfs-tools/modules || echo dm_crypt >> /etc/initramfs-tools/modules

┌──(root㉿kali)-[/]
└─# cat /etc/initramfs-tools/modules
# List of modules that you want to include in your initramfs.
# They will be loaded at boot time in the order below.
#
# Syntax:  module_name [args ...]
#
# You must run update-initramfs(8) to effect this change.
#
# Examples:
#
# raid1
# sd_mod
dm_crypt

Konfigurieren der Remote-SSH-Entsperrung

Erstellen Sie eine unlock.sh Skript mit folgendem Inhalt und markieren Sie es dann als ausführbar, damit das Skript im initramfs ausgeführt wird :

┌──(root㉿kali)-[/]
└─# vim /etc/initramfs-tools/unlock.sh

┌──(root㉿kali)-[/]
└─# cat /etc/initramfs-tools/unlock.sh
#!/bin/sh

export PATH='/sbin:/bin:/usr/sbin:/usr/bin'

while true; do
	test -e /dev/mapper/crypt && break || cryptsetup luksOpen /dev/disk/by-uuid/$REPLACE_LATER crypt
done

/scripts/local-top/cryptroot
for i in $(ps aux | grep 'cryptroot' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep 'askpass' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep 'ask-for-password' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep '\\-sh' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
exit 0

┌──(root㉿kali)-[/]
└─# chmod +x /etc/initramfs-tools/unlock.sh

Als nächstes müssen wir am Anfang von /etc/dropbear/initramfs/authorized_keys Folgendes hinzufügen , der es anweist, diesen Befehl auszuführen, wenn wir uns per SSH einloggen, wenn der Schlüssel übereinstimmt:

┌──(root㉿kali)-[/]
└─# vim /etc/dropbear/initramfs/authorized_keys

┌──(root㉿kali)-[/]
└─# cat /etc/dropbear/initramfs/authorized_keys
command="/etc/unlock.sh; exit"

Danach können wir den kopierten SSH-Schlüssel anhängen und dann von der Karte entfernen:

┌──(root㉿kali)-[/]
└─# cat id_rsa.pub >> /etc/dropbear/initramfs/authorized_keys && rm -v id_rsa.pub

Sobald Sie fertig sind, /etc/dropbear/initramfs/authorized_keys sollte so aussehen:

┌──(root㉿kali)-[/]
└─# cat /etc/dropbear/initramfs/authorized_keys
command="/etc/unlock.sh; exit" ssh-rsa <key> [email protected]

Alles im authorized_keys Datei sollte eine Zeile sein, sowie ein Leerzeichen zwischen dem Ende des Befehls " und den ssh-Schlüssel (z.B. [...]exit" ssh-rsa[...] )

Wir müssen jetzt /usr/share/initramfs-tools/scripts/init-premount/dropbear bearbeiten um einen Sleep-Timer hinzuzufügen, damit das Netzwerk vorher gestartet werden kann Dropbear tut es. Es ist wichtig zu beachten, dass bei Aktualisierungen des dropbear-initramfs Paket, muss diese Bearbeitung erneut hinzugefügt werden:

┌──(root㉿kali)-[/]
└─# vim /usr/share/initramfs-tools/scripts/init-premount/dropbear

┌──(root㉿kali)-[/]
└─# cat /usr/share/initramfs-tools/scripts/init-premount/dropbear
[ "$BOOT" != nfs ] || configure_networking
sleep 5
run_dropbear &
echo $! >/run/dropbear.pid

Jetzt aktivieren wir cryptsetup:

┌──(root㉿kali)-[/]
└─# echo CRYPTSETUP=y >> /etc/cryptsetup-initramfs/conf-hook

┌──(root㉿kali)-[/]
└─# tail /etc/cryptsetup-initramfs/conf-hook
#
# Whether to include the askpass binary to the initramfs image.  askpass
# is required for interactive passphrase prompts, and ASKPASS=y (the
# default) is implied when the hook detects that same device needs to be
# unlocked interactively (i.e., not via keyfile nor keyscript) at
# initramfs stage.  Setting ASKPASS=n also skips `cryptroot-unlock`
# inclusion as it requires the askpass executable.

#ASKPASS=y
CRYPTSETUP=y

Kernel

Der nächste Schritt ist wichtig für die Menschen, die nachfolgen. Was Sie auswählen müssen, hängt von dem von Ihnen verwendeten RPi-Gerät ab. Unten sind fünf Kernel-Namen/Editionen/Varianten, von denen Sie eine für Ihre Bedürfnisse auswählen müssen (Bitte beachten Sie!) :

• Re4son+ ist für 32-Bit-Armel-armv6-Geräte – d. h. RPi1, RPi0 oder RPi0w
• Re4son-v7+ ist für 32-Bit-ARMHF-armv7-Geräte – d. h. RPi2 v1.2, RPi3 oder RPi02w
• Re4son-v8+ ist für 64-Bit-ARM64-armv8-Geräte – d. h. RPi2 v1.2, RPi3 oder RPi02w
• Re4son-v7l+ ist für 32-Bit-ARMHF-armv7-Geräte – also RPi4- oder RPi400-Geräte
• Re4son-v8l+ ist für 64-Bit-ARM64-Armv8-Geräte - d. h. RPi4- oder RPi400-Geräte

Der l im Namen steht für lpae - Large Physical Address Extension

Zur Erinnerung:Wir verwenden das RPi4, 64-Bit-Image. Wir bräuchten also Re4son-v8l+ . Bitte stellen Sie sicher, dass Sie sich an Ihr Gerät anpassen. Nachdem wir nun wissen, welchen Kernelnamen Sie verwenden müssen, müssen wir nun die Kernelversion finden. Dies ändert sich von Gerät zu Gerät, und es ändert sich auch, wenn Kali Updates erhält. Zum Zeitpunkt des Schreibens ist es 5.15.44 für unser RPi:

Denken Sie daran, dass sich die Kernel-Versionen ändern können, der Name jedoch nicht:

┌──(root㉿kali)-[/]
└─# ls -l /lib/modules/ | awk -F" " '{print $9}'
5.15.44-Re4son+
5.15.44-Re4son-v7+
5.15.44-Re4son-v7l+
5.15.44-Re4son-v8+
5.15.44-Re4son-v8l+

┌──(root㉿kali)-[/]
└─# echo "initramfs initramfs.gz followkernel" >> /boot/config.txt

Beachten Sie die Kernel-Versionen (5.15.44 ) kann sich ändern, der Kernelname (Re4son-v8l+ ) nicht.

Jetzt müssen wir den initramfs erstellen . Hier kommt die Kernel-Version ins Spiel:

┌──(root㉿kali)-[/]
└─# mkinitramfs -o /boot/initramfs.gz 5.15.44-Re4son-v8l+

Jetzt wollen wir sicherstellen, dass wir den initramfs erstellt haben korrekt. Wenn es kein Ergebnis gibt, ist etwas schief gelaufen:

┌──(root㉿kali)-[/]
└─# lsinitramfs /boot/initramfs.gz | grep cryptsetup
usr/lib/aarch64-linux-gnu/libcryptsetup.so.12
usr/lib/aarch64-linux-gnu/libcryptsetup.so.12.7.0
usr/lib/cryptsetup
usr/lib/cryptsetup-nuke-password
usr/lib/cryptsetup-nuke-password/crypt
usr/lib/cryptsetup/askpass
usr/lib/cryptsetup/askpass.cryptsetup
usr/lib/cryptsetup/functions
usr/sbin/cryptsetup

┌──(root㉿kali)-[/]
└─# lsinitramfs /boot/initramfs.gz | grep authorized
root-Q2iWOODUwk/.ssh/authorized_keys

┌──(root㉿kali)-[/]
└─# lsinitramfs /boot/initramfs.gz | grep unlock.sh
etc/unlock.sh

Dienste deaktivieren

Bevor wir sichern können, müssen wir sicherstellen, dass rpi-resizerootfs ist behindert. Dies ist ein Dienst, den wir normalerweise auf allen unseren ARM-Geräten ausführen, der die Größe der Root-Dateisystempartition ändert, um die Größe der Partition auf die volle Größe des Speichergeräts zu erhöhen, auf dem sie sich befindet. Da wir diesen Schritt manuell durchführen, möchten wir ihn deaktivieren, damit er unser Root-Dateisystem nicht möglicherweise löscht und neu erstellt.

┌──(root㉿kali)-[/]
└─# systemctl disable rpi-resizerootfs

Alle vorhandenen Daten sichern

Jetzt können wir sicherstellen, dass alle Änderungen geschrieben werden, dann können wir die Festplatte verschlüsseln:

┌──(root㉿kali)-[/]
└─# sync

┌──(root㉿kali)-[/]
└─# exit
$ sudo umount /mnt/chroot/{boot,sys,proc,dev/pts,dev}
$ sudo mkdir -vp /mnt/{backup,encrypted}
$ sudo rsync -avh /mnt/chroot/* /mnt/backup/
$ sudo cryptsetup luksClose crypt
$ sudo umount /mnt/chroot
$ echo -e "d\n2\nw" | sudo fdisk /dev/sdX
$ echo -e "n\np\n2\n\n\nw" | sudo fdisk /dev/sdX

Konfigurieren Sie die verschlüsselten Partitionen

Je nachdem, welches Gerät Sie verwenden, müssen Sie einen von zwei Befehlen verwenden. Wenn Sie einen RPi4 mit 4 GB oder mehr verwenden, verwenden Sie diesen Befehl:

$ sudo cryptsetup -v -y --cipher aes-cbc-essiv:sha256 --key-size 256 luksFormat /dev/sdX2

Andernfalls sollten Sie Folgendes verwenden, das eine ältere Version von LUKS verwendet:

$ sudo cryptsetup -v -y --pbkdf pbkdf2 --cipher aes-cbc-essiv:sha256 --key-size 256 luksFormat /dev/sdX2

Stellen Sie unsere Daten wieder her

Danach können Sie die Wiederherstellung der Daten auf der nun verschlüsselten Partition abschließen:

$ sudo cryptsetup -v luksOpen /dev/sdX2 crypt
$ sudo mkfs.ext4 /dev/mapper/crypt
$ sudo mount /dev/mapper/crypt /mnt/encrypted/
$ sudo rsync -avh /mnt/backup/* /mnt/encrypted/
$ sync

Die letzten Schritte, die wir machen müssen, sind, den /etc/fstab zu reparieren Datei für die neue LUKS-UUID, oder Sie können sie als /dev/mapper/crypt belassen und ersetzen Sie die UUID in unserem Unlock-Skript und erstellen Sie die initramfs-Datei neu. Dieser Schritt ist wichtig, da er nicht ordnungsgemäß gestartet wird, wenn er nicht ausgeführt wird, da er nicht über die Informationen verfügt, um das verschlüsselte Dateisystem zu verwenden! Denken Sie daran, die Informationen von IHREM einzugeben System, da die UUID für jedes System anders sein wird:

$ sudo mount /dev/sdX1 /mnt/encrypted/boot/
$ sudo mount -t proc none /mnt/encrypted/proc
$ sudo mount -t sysfs none /mnt/encrypted/sys
$ sudo mount -o bind /dev /mnt/encrypted/dev
$ sudo mount -o bind /dev/pts /mnt/encrypted/dev/pts
$ sudo env LANG=C chroot /mnt/encrypted
┌──(root㉿kali)-[/]
└─# blkid /dev/sdX2
/dev/sdX2: UUID="173e2de4-0501-4d8e-9039-a4923bfa5ee7" TYPE="crypto_LUKS" PARTUUID="e1750e08-02"

┌──(root㉿kali)-[/]
└─# cat /etc/fstab
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
proc            /proc           proc    defaults          0       0

UUID=173e2de4-0501-4d8e-9039-a4923bfa5ee7 /               ext4 errors=remount-ro 0       1
LABEL=BOOT      /boot           vfat    defaults          0       2

┌──(root㉿kali)-[/]
└─# vim /etc/initramfs-tools/unlock.sh

┌──(root㉿kali)-[/]
└─# cat /etc/initramfs-tools/unlock.sh
#!/bin/sh

export PATH='/sbin:/bin:/usr/sbin:/usr/bin'

while true; do
	test -e /dev/mapper/crypt && break || cryptsetup luksOpen /dev/disk/by-uuid/173e2de4-0501-4d8e-9039-a4923bfa5ee7 crypt
done

/scripts/local-top/cryptroot
for i in $(ps aux | grep 'cryptroot' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep 'askpass' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep 'ask-for-password' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
for i in $(ps aux | grep '\\-sh' | grep -v 'grep' | awk '{print $1}'); do kill -9 $i; done
exit 0

┌──(root㉿kali)-[/]
└─# vim /etc/crypttab

┌──(root㉿kali)-[/]
└─# cat /etc/crypttab
crypt	PARTUUID=e1750e08-02	none	luks

┌──(root㉿kali)-[/]
└─# mkinitramfs -o /boot/initramfs.gz 5.15.44-Re4son-v8l+

Wenn Sie hier einen Cryptsetup-Fehler erhalten, ähnlich cryptsetup: ERROR: Couldn't resolve device PARTUUID=ed889dad-02 das bedeutet, dass Sie /etc/crypttab nicht bearbeitet haben Datei und geben Sie die richtige PARTUUID ein. Die Warnung, dass fsck.luks nicht existiert, kann ignoriert werden, da es so etwas nicht gibt.

Jetzt können wir alles aushängen und schließen:

┌──(root㉿kali)-[/]
└─# exit
$ sudo umount /mnt/encrypted/{boot,sys,proc,dev/pts,dev}
$ sudo umount /mnt/encrypted
$ sudo cryptsetup luksClose crypt

Zuvor haben wir die LUKS Nuke-Fähigkeit erwähnt. Wenn Sie vorhaben, es zu verwenden, während Sie auf Ihren frisch verschlüsselten RPi-Rootfs booten, führen Sie einfach den folgenden Befehl aus, um das Nuke-Passwort hinzuzufügen, und folgen Sie der Eingabeaufforderung:

[email protected]:~$ sudo dpkg-reconfigure cryptsetup-nuke-password

Seien Sie gespannt auf Teil zwei, in dem wir die Fernverbindung zum Raspberry Pi als Dropbox-Gerät behandeln!

Automatisieren!

Wie wäre es, wenn wir das jetzt automatisieren? Dank Richard Nelson (@unixabg) kann jeder, der dies alles in viel kürzerer Zeit als mit der manuellen Methode und viel einfacher einrichten möchte, das tun!

Das Wichtigste zuerst, lass uns das cryptmypi-Skript von unixabg herunterladen:

$ git clone https://github.com/unixabg/cryptmypi.git
$ cd cryptmypi/

Es gibt jedoch eine Reihe von Dingen, die wir tun möchten, bevor wir die Build-Skripte ausführen können. Gehen wir diese jetzt gemeinsam durch:

$ cp cryptmypi.conf config/.
$ cat ~/.ssh/id_rsa.pub >> config/authorized_keys

Jetzt müssen wir cryptmypi.conf bearbeiten um einige Einstellungen in Stufe 2 zu ändern. Diese Einstellungen werden persönlich sein, aber lassen Sie uns Ihnen allen nur ein Beispiel geben:

$ vim config/cryptmypi.conf
$ cat config/cryptmypi.conf
##################
## cryptmypi settings
##################
# export prefix for hooks
export _VER="2.2-beta"

# base and build
export _BASEDIR=$(pwd)
export _BUILDDIR=${_BASEDIR}/cryptmypi-build

##################
## Stage-1
##################
_IMAGEURL=https://kali.download/arm-images/kali-2022.2/kali-linux-2022.2-raspberry-pi-arm64.img.xz

# compose package actions
export _PKGSPURGE=""
export _PKGSINSTALL=""

# iodine settings
_IODINE_PASSWORD="your iodine password goes here"
_IODINE_DOMAIN="your iodine domain goes here"

# final package actions
export _FINALPKGPURGE=""
export _FINALPKGINSTALL="telnet dsniff bettercap"

##################
## Stage-2
##################
# block device
_BLKDEV="/dev/sdb"

# luks encryption cipher
_LUKSCIPHER="aes-cbc-essiv:sha256"

# luks encryption password
_LUKSPASSWD="toor"

# root password
export _ROOTPASSWD="toor"

Was wir hier geändert haben, ist das Blockgerät, das LUKS-Verschlüsselungspasswort und das Root-Passwort. Die Bild-URL kann geändert werden, wenn Sie eine andere Bilddatei verwenden möchten, tun Sie dies also bei Bedarf jetzt.

Jetzt müssen Sie nur noch die Skripte beider Phasen ausführen und den Anweisungen folgen. Am Ende haben Sie ein vollständig verschlüsseltes Dateisystem mit Dropbear SSH-Zugriff!