Raspberry Pi 4 (8 GB) als Proxmox VE Test-Node

Raspberry Pi 4 – Debian 13, LUKS2, Dropbear und Proxmox VE

Diese Anleitung beschreibt die Einrichtung eines Raspberry Pi 4 mit 8 GB RAM als verschlüsselten Proxmox-Testserver auf Basis von Debian 13 (Trixie).

Debian wird direkt von einem Linux-PC aus mit debootstrap installiert. Die Konfiguration erfolgt innerhalb einer ARM64-chroot-Umgebung.

Das Root-Dateisystem wird mit LUKS2 verschlüsselt. Während des Systemstarts ermöglicht Dropbear eine Entsperrung über SSH mit einem separaten Schlüssel.

1. Voraussetzungen

Raspberry Pi 4 mit 8 GB RAM
USB-SSD mit mindestens 64 GB
Debian-13-Linux-PC
Ethernet-Verbindung
Feste IPv4-Adresse und Gateway
USB-Boot-fähige Raspberry-Pi-Firmware
SSH-Client unter Linux

Datenträgeraufbau

Partition	Format	Verwendung
Partition 1	FAT32	/boot/firmware
Partition 2	LUKS2	Verschlüsselter Root-Datenträger
cryptroot	ext4	Debian, Proxmox und VM-Daten

Die Boot-Partition bleibt unverschlüsselt, da die Raspberry-Pi-Firmware sie lesen können muss. Die Verschlüsselung schützt Daten auf dem ausgeschalteten Datenträger, verhindert jedoch keine Manipulation an der Boot-Partition.

2. SSH-Schlüssel erzeugen

Auf dem Linux-Client zwei voneinander unabhängige SSH-Schlüssel erstellen.

Schlüssel zur LUKS-Entsperrung

ssh-keygen -t ed25519 -a 100 \
-f ~/.ssh/id_pi4_unlock \
-C "Pi4 LUKS Unlock"

Administrationsschlüssel

ssh-keygen -t ed25519 -a 100 \
-f ~/.ssh/id_pi4_admin \
-C "Pi4 Administration"

Beide privaten Schlüssel mit einer eigenen Passphrase schützen.

Öffentliche Schlüssel anzeigen:

cat ~/.ssh/id_pi4_unlock.pub
cat ~/.ssh/id_pi4_admin.pub

Die öffentlichen Schlüssel werden später in Debian hinterlegt. Die privaten Schlüssel verbleiben ausschließlich auf dem Client.

3. Linux-PC vorbereiten

Root-Shell öffnen:

su -

Paketlisten aktualisieren:

apt update
apt full-upgrade

Benötigte Pakete installieren:

apt install -y \
debootstrap \
debian-archive-keyring \
qemu-user \
qemu-user-binfmt \
binfmt-support \
cryptsetup \
parted \
dosfstools \
e2fsprogs \
kmod \
ca-certificates \
curl \
git

QEMU ermöglicht die Ausführung der ARM64-Programme auf einem Linux-PC mit anderer Prozessorarchitektur.

QEMU-Registrierung prüfen:

cat /proc/sys/fs/binfmt_misc/qemu-aarch64

Auf einem x86-64-Host muss der Interpreter aktiviert sein. Bei einem nativen ARM64-Host wird keine CPU-Emulation benötigt.

chroot begrenzt die CPU-Kernzahl nicht. Parallele Programme können mehrere Kerne verwenden. Die Paketinstallation selbst ist allerdings nicht vollständig parallelisiert.

4. USB-SSD auswählen

Angeschlossene Datenträger anzeigen:

lsblk -o NAME,SIZE,MODEL,TYPE,MOUNTPOINTS

Im Beispiel ist /dev/sdb die gewünschte SSD. Der Gerätename muss anhand der tatsächlichen Laufwerksinformationen angepasst werden.

Zieldatenträger festlegen:

DISK=/dev/sdb

Gerät kontrollieren:

lsblk "$DISK"
findmnt /

Die ausgewählte SSD darf nicht das laufende System enthalten. Sämtliche Partitionen des Zielgeräts müssen ausgehängt sein.

Achtung: Die nächsten Befehle löschen sämtliche Daten auf dem ausgewählten Datenträger.

Partitionstabelle erstellen:

parted -s "$DISK" mklabel msdos

Boot-Partition mit 1 GiB erstellen:

parted -s "$DISK" mkpart primary fat32 1MiB 1025MiB

Root-Partition erstellen:

parted -s "$DISK" mkpart primary 1025MiB 100%

Boot-Flag setzen:

parted -s "$DISK" set 1 boot on
partprobe "$DISK"
udevadm settle

Partitionsnamen bestimmen:

case "$DISK" in
  *[0-9])
    BOOT="${DISK}p1"
    ROOT="${DISK}p2"
    ;;
  *)
    BOOT="${DISK}1"
    ROOT="${DISK}2"
    ;;
esac

lsblk "$DISK"

5. LUKS2-Verschlüsselung einrichten

Boot-Partition formatieren:

mkfs.vfat -F32 -n PVEBOOT "$BOOT"

LUKS2 mit AES-256-XTS und Argon2id

Die folgende Konfiguration nutzt AES-XTS mit zwei AES-256-Schlüsseln sowie Argon2id zur Ableitung des Schlüssels aus der Passphrase.

cryptsetup luksFormat \
  --type luks2 \
  --cipher aes-xts-plain64 \
  --key-size 512 \
  --pbkdf argon2id \
  --pbkdf-memory 524288 \
  --pbkdf-parallel 2 \
  --iter-time 2000 \
  --verify-passphrase \
  "$ROOT"

Parameterübersicht:

Parameter	Einstellung
Format	LUKS2
Verschlüsselung	AES-256-XTS
Schlüsselmaterial	512 Bit insgesamt
Passwortableitung	Argon2id
Speichergrenze	512 MiB
Parallelität	2
Kalibrierungsziel	2000 ms

Die Werte sind ein Ausgangspunkt für den Raspberry Pi 4 mit 8 GB RAM. Cryptsetup kalibriert die tatsächlichen Argon2-Parameter auf dem einrichtenden Rechner. Insbesondere bei Verwendung von QEMU oder einem schnelleren Host können sich die späteren Entsperrzeiten deutlich unterscheiden.

Eine zufällige, lange Passphrase verwenden, beispielsweise sieben oder mehr unabhängig ausgewählte Diceware-Wörter.

Keine kurzen Kennwörter, Gerätebezeichnungen, Geburtsdaten oder wiederverwendeten Passwörter nutzen.

Die gewählten Parameter müssen im Raspberry-Pi- Initramfs ausreichend RAM zur Verfügung haben. Höhere Argon2-Werte sind nicht automatisch besser.

SSD-Discard beziehungsweise TRIM für das verschlüsselte Dateisystem zunächst nicht aktivieren. Discard kann Informationen über belegte Datenbereiche preisgeben.

Gespeicherte LUKS-Parameter prüfen:

cryptsetup luksDump "$ROOT"

Insbesondere PBKDF, Memory, Time cost und Threads kontrollieren.

Verschlüsselung öffnen:

cryptsetup open "$ROOT" cryptroot

Ext4-Dateisystem erstellen:

mkfs.ext4 -L pve-root /dev/mapper/cryptroot

Status anzeigen:

cryptsetup status cryptroot

6. UUIDs dokumentieren

Die UUIDs vor dem Betreten der chroot-Umgebung ermitteln und für die Konfiguration notieren.

LUKS-UUID:

cryptsetup luksUUID "$ROOT"

Boot-UUID:

blkid -s UUID -o value "$BOOT"

Die LUKS-UUID bezeichnet die verschlüsselte Partition. Die Boot-UUID bezeichnet das FAT32-Dateisystem.

7. Dateisysteme einhängen

Verschlüsselte Root-Partition einhängen:

mkdir -p /mnt/Temp/1
mount /dev/mapper/cryptroot /mnt/Temp/1

Firmware-Verzeichnis vorbereiten:

mkdir -p /mnt/Temp/1/boot/firmware

Boot-Partition einhängen:

mount "$BOOT" /mnt/Temp/1/boot/firmware

Mountpoints überprüfen:

findmnt /mnt/Temp/1
findmnt /mnt/Temp/1/boot/firmware

8. Debian 13 installieren

Debian wird direkt auf der verschlüsselten Root-Partition installiert.

debootstrap \
  --arch=arm64 \
  --keyring=/usr/share/keyrings/debian-archive-keyring.gpg \
  trixie \
  /mnt/Temp/1 \
  https://deb.debian.org/debian

Anschließend werden die Partitionen dauerhaft in der neuen Installation konfiguriert.

Crypttab erstellen

nano /mnt/Temp/1/etc/crypttab

Eintrag:

cryptroot UUID=LUKS-UUID none luks,initramfs

LUKS-UUID durch die zuvor ermittelte UUID der verschlüsselten Partition ersetzen.

Fstab konfigurieren

nano /mnt/Temp/1/etc/fstab

Einträge:

/dev/mapper/cryptroot / ext4 defaults,noatime 0 1
UUID=BOOT-UUID /boot/firmware vfat defaults,umask=0077 0 2

BOOT-UUID durch die zuvor ermittelte UUID der FAT32-Partition ersetzen.

9. ARM64-chroot vorbereiten

Systemdateisysteme einbinden:

for DIR in dev proc sys run; do
    mount --rbind "/$DIR" "/mnt/Temp/1/$DIR"
    mount --make-rslave "/mnt/Temp/1/$DIR"
done

DNS-Konfiguration übernehmen:

cp -L /etc/resolv.conf /mnt/Temp/1/etc/resolv.conf

chroot starten:

chroot /mnt/Temp/1 /bin/bash

Architektur überprüfen:

dpkg --print-architecture

Erwartete Ausgabe:

arm64

Die folgenden Schritte werden innerhalb der chroot-Umgebung ausgeführt.

10. APT-Paketquellen einrichten

Paketquellen öffnen:

nano /etc/apt/sources.list

Folgende Quellen verwenden. Bereits vorhandene gleichwertige Einträge unter /etc/apt/sources.list.d nicht duplizieren.

deb https://deb.debian.org/debian trixie main non-free-firmware
deb https://deb.debian.org/debian trixie-updates main non-free-firmware
deb https://security.debian.org/debian-security trixie-security main non-free-firmware

Paketlisten aktualisieren:

apt update

11. Kernel und Basissystem installieren

Benötigte Systempakete installieren:

apt install -y \
linux-image-arm64 \
raspi-firmware \
initramfs-tools \
cryptsetup-initramfs \
dropbear-initramfs \
openssh-server \
ifupdown2 \
systemd-sysv \
ca-certificates \
curl \
git \
nano \
less \
locales \
busybox \
kmod \
e2fsprogs

Hostname setzen:

nano /etc/hostname

Inhalt:

pve-pi4

Hosts-Datei bearbeiten:

nano /etc/hosts

Beispiel:

127.0.0.1 localhost
10.100.0.2 pve-pi4.home.arpa pve-pi4

Root-Passwort setzen:

passwd

Für root eine eigene starke Passphrase verwenden, nicht die LUKS-Passphrase.

SSH-Dienst aktivieren:

systemctl enable ssh

12. SSH absichern

Die reguläre SSH-Administration verwendet ausschließlich den zuvor erzeugten Administrationsschlüssel.

SSH-Verzeichnis erstellen:

install -d -m 0700 /root/.ssh

Authorized-Keys-Datei öffnen:

nano /root/.ssh/authorized_keys

Den vollständigen öffentlichen Schlüssel aus id_pi4_admin.pub einfügen.

Dateirechte setzen:

chmod 0600 /root/.ssh/authorized_keys

SSH-Härtung konfigurieren:

nano /etc/ssh/sshd_config.d/10-pi4-security.conf

Inhalt:

PermitRootLogin prohibit-password
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes
PermitEmptyPasswords no
X11Forwarding no
AllowTcpForwarding no
AllowAgentForwarding no
PermitTunnel no
MaxAuthTries 3
LoginGraceTime 30

Diese Konfiguration ist auf die Administration des Hosts ausgerichtet. Für spätere SSH-basierte Clusterfunktionen oder Migrationen müssen die Weiterleitungsregeln passend überprüft werden.

Konfiguration prüfen:

sshd -t

Der Befehl darf keine Konfigurationsfehler melden.

13. Netzwerk konfigurieren

Beispielnetzwerk:

Management-IP	10.100.0.2
Netzmaske	255.255.0.0
Gateway	10.100.0.1
Interface	eth0
Bridge	vmbr0

Die Adressen an das eigene Netzwerk anpassen. Die Management-IP sollte dauerhaft reserviert sein.

Netzwerkkonfiguration öffnen:

nano /etc/network/interfaces

Inhalt:

auto lo
iface lo inet loopback

iface eth0 inet manual

auto vmbr0
iface vmbr0 inet static
    address 10.100.0.2/16
    gateway 10.100.0.1
    bridge-ports eth0
    bridge-stp off
    bridge-fd 0

Netzwerkdienst aktivieren:

systemctl enable networking

Für die DNS-Auflösung in /etc/resolv.conf einen erreichbaren DNS-Server konfigurieren. Die dauerhafte DNS-Verwaltung darf nach dem ersten Boot nicht mit einem anderen aktiven Netzwerkmanager in Konflikt stehen.

14. Raspberry-Pi-Boot konfigurieren

Firmware-Konfiguration bearbeiten:

nano /etc/default/raspi-firmware

Folgende Variablen aktivieren beziehungsweise ergänzen:

ROOTPART="/dev/mapper/cryptroot"
KERNEL="auto"
INITRAMFS="auto"

Die Debian-Firmware-Hooks verwenden diese Einstellungen zur Erstellung der Bootdateien.

Zusätzliche Kernelparameter hinterlegen:

nano /etc/default/raspi-extra-cmdline

Inhalt als eine einzelne Zeile:

rootwait ip=10.100.0.2::10.100.0.1:255.255.0.0:pve-pi4:eth0:none

Die Adresse dient dem Netzwerkzugriff im Initramfs vor der Entsperrung.

15. Initramfs vorbereiten

Konfiguration öffnen:

nano /etc/initramfs-tools/initramfs.conf

Folgende Einstellungen setzen:

MODULES=most
DEVICE=eth0
IP=10.100.0.2::10.100.0.1:255.255.0.0:pve-pi4:eth0:none

Das Initramfs benötigt die Treiber für den USB-Controller, die SSD und den Ethernet-Port.

Kernel-Versionen anzeigen:

ls /lib/modules

Die tatsächlich installierte Kernel-Version auswählen:

KVER=$(ls /lib/modules | sort -V | tail -n 1)
echo "$KVER"

Zusätzliche Module konfigurieren:

nano /etc/initramfs-tools/modules

Beim Raspberry Pi 4 ist insbesondere reset_raspberrypi für den USB-Controller relevant. Benötigte Storage- und Netzwerktreiber ebenfalls berücksichtigen.

Beispielsweise folgende Module anhand ihrer tatsächlichen Verfügbarkeit prüfen:

modinfo -k "$KVER" reset_raspberrypi
modinfo -k "$KVER" bcmgenet
modinfo -k "$KVER" usb_storage
modinfo -k "$KVER" uas

Verfügbare und benötigte Module in /etc/initramfs-tools/modules eintragen. Fest in den Kernel eingebaute Treiber benötigen keinen zusätzlichen Moduleintrag.

16. Dropbear-SSH konfigurieren

Dropbear stellt während der Initramfs-Phase eine eigene SSH-Verbindung bereit. Diese wird auf die Entsperrfunktion beschränkt.

Konfigurationsverzeichnis erstellen:

install -d -m 0700 /etc/dropbear/initramfs

Schlüsseldatei bearbeiten:

nano /etc/dropbear/initramfs/authorized_keys

Den öffentlichen Schlüssel aus id_pi4_unlock.pub mit folgenden Optionen eintragen:

no-port-forwarding,no-agent-forwarding,no-X11-forwarding,command="/bin/cryptroot-unlock" ssh-ed25519 SSH-PUBLIC-KEY

SSH-PUBLIC-KEY durch den vollständigen öffentlichen Schlüssel ersetzen. Der gesamte Eintrag muss in einer Zeile stehen.

Der Schlüssel ist damit für die Entsperrung vorgesehen, nicht für eine frei nutzbare Initramfs-Shell.

Dateirechte setzen:

chmod 0600 /etc/dropbear/initramfs/authorized_keys

Dropbear-Konfiguration öffnen:

nano /etc/dropbear/initramfs/dropbear.conf

Inhalt:

DROPBEAR_OPTIONS="-p 2222 -s -j -k -I 120"

Dropbear verwendet Port 2222. Passwortzugriff und SSH-Portweiterleitungen sind deaktiviert.

17. SSH-Hostkeys kontrollieren

Dropbear und der reguläre SSH-Dienst verwenden unterschiedliche Hostkeys.

Dropbear-Hostkey prüfen:

ls -l /etc/dropbear/initramfs/dropbear_ed25519_host_key

Falls kein entsprechender Schlüssel existiert:

dropbearkey -t ed25519 \
-f /etc/dropbear/initramfs/dropbear_ed25519_host_key

Dropbear-Hostkey anzeigen:

dropbearkey -y \
-f /etc/dropbear/initramfs/dropbear_ed25519_host_key

Regulären SSH-Hostkey anzeigen:

ssh-keygen -y \
-f /etc/ssh/ssh_host_ed25519_key

Die beiden öffentlichen Hostkeys sicher dokumentieren. Sie werden auf dem SSH-Client vor dem ersten Verbindungsaufbau hinterlegt.

Wichtig: Der private Dropbear-Hostkey befindet sich später im unverschlüsselten Initramfs. Physischer Zugriff auf die Boot-Partition ermöglicht daher auch den Zugriff auf diesen Schlüssel. Die Boot-Integrität ist eine separate Sicherheitsanforderung.

18. Initramfs und Firmware erzeugen

Kernel-Version erneut festlegen:

KVER=$(ls /lib/modules | sort -V | tail -n 1)

Initramfs aktualisieren:

update-initramfs -u -k "$KVER"

Falls noch kein Initramfs für die ausgewählte Version existiert, stattdessen eines erstellen:

update-initramfs -c -k "$KVER"

Beide Varianten sind alternativ zu verwenden, nicht nacheinander für dieselbe bereits existierende Datei.

Bootdateien anzeigen:

ls -lh /boot/firmware

Konfiguration prüfen:

cat /boot/firmware/config.txt
cat /boot/firmware/cmdline.txt

config.txt muss den passenden ARM64-Kernel und das zugehörige Initramfs laden.

cmdline.txt muss die verschlüsselte Root-Partition referenzieren:

root=/dev/mapper/cryptroot

Außerdem muss der zuvor festgelegte ip-Parameter vorhanden sein.

Initramfs-Inhalt anzeigen:

lsinitramfs "/boot/initrd.img-$KVER" | less

Wichtige Bestandteile:

Cryptsetup und Device Mapper
Argon2-Unterstützung
Dropbear und der SSH-Hostkey
authorized_keys
cryptroot-unlock
USB- und Storage-Treiber
Ethernet-Treiber
Ext4-Unterstützung

Die verschlüsselte SSD darf erst eingesetzt werden, wenn die erforderlichen Komponenten und Bootdateien vorhanden sind.

19. Installation abschließen

chroot verlassen:

exit

Dateisysteme anzeigen:

findmnt -R /mnt/Temp/1

Alle Ziel-Mountpoints aushängen:

umount -R /mnt/Temp/1

LUKS-Container schließen:

cryptsetup close cryptroot

Schreibvorgänge abschließen:

sync

Die SSD anschließend mit dem Raspberry Pi verbinden und den Bootvorgang starten.

20. SSH-Hostkeys auf dem Client hinterlegen

Auf dem Linux-Client separate Known-Hosts-Dateien für Dropbear und OpenSSH erstellen.

Dateien vorbereiten:

install -m 600 /dev/null ~/.ssh/known_hosts_pi4_unlock
install -m 600 /dev/null ~/.ssh/known_hosts_pi4_admin

Initramfs-Hostkey eintragen:

nano ~/.ssh/known_hosts_pi4_unlock

Den zuvor dokumentierten öffentlichen Dropbear-Hostkey im folgenden Format eintragen:

[10.100.0.2]:2222 ssh-ed25519 HOSTKEY

Regulären SSH-Hostkey hinterlegen:

nano ~/.ssh/known_hosts_pi4_admin

Format:

10.100.0.2 ssh-ed25519 HOSTKEY

HOSTKEY jeweils durch das korrekte öffentliche Schlüsselmaterial ersetzen.

21. SSH-Client konfigurieren

SSH-Konfiguration öffnen:

nano ~/.ssh/config

Folgende Hosts ergänzen:

Host pi4-unlock
    HostName 10.100.0.2
    User root
    Port 2222
    IdentityFile ~/.ssh/id_pi4_unlock
    IdentitiesOnly yes
    RequestTTY force
    StrictHostKeyChecking yes
    UserKnownHostsFile ~/.ssh/known_hosts_pi4_unlock

Host pi4
    HostName 10.100.0.2
    User root
    Port 22
    IdentityFile ~/.ssh/id_pi4_admin
    IdentitiesOnly yes
    StrictHostKeyChecking yes
    UserKnownHostsFile ~/.ssh/known_hosts_pi4_admin

Dateirechte setzen:

chmod 600 ~/.ssh/config
chmod 600 ~/.ssh/id_pi4_unlock
chmod 600 ~/.ssh/id_pi4_admin

22. LUKS über SSH entsperren

Sobald Dropbear im Initramfs gestartet ist, kann die Entsperrung erfolgen:

ssh pi4-unlock

Die LUKS-Passphrase eingeben.

Nach erfolgreicher Entsperrung öffnet das Initramfs die Root-Partition und der normale Debian-Bootvorgang wird fortgesetzt.

Debian anschließend administrieren:

ssh pi4

SSH-Verbindungen mit falschem Hostkey dürfen nicht bestätigt oder durch Abschalten der Hostkey-Prüfung erzwungen werden.

23. Debian prüfen

Root-Dateisystem anzeigen:

findmnt /

Verschlüsselung überprüfen:

cryptsetup status cryptroot

Netzwerk kontrollieren:

ip -br address
ip route show default

Kernel anzeigen:

uname -r

SSH-Konfiguration überprüfen:

sshd -t

Die Root-Partition muss über /dev/mapper/cryptroot eingebunden sein.

Vor weiteren Paketinstallationen einen vollständigen Neustart einschließlich erneuter SSH-Entsperrung durchführen.

24. Proxmox-Pakete vorbereiten

Die angepassten Proxmox-Komponenten werden über das Community-Projekt PXVIRT bereitgestellt.

Pimox ARM64 RPI Control

Das vollständige Installationsskript build.sh wird nicht verwendet, da es Partitionen und Netzwerkkonfiguration automatisch verändern kann.

Repository herunterladen:

cd /root
git clone https://github.com/topa-LE/pve-arm64-rpi-control.git
cd pve-arm64-rpi-control

Verwendeten Commit dokumentieren:

git rev-parse HEAD

Installationsskripte überprüfen:

less scripts/06_add_proxmox_repo.sh
less scripts/07_install_proxmox_ve.sh

Besondere Aufmerksamkeit gilt externen Paketquellen, APT-Signaturschlüsseln, Kernel-Paketen und automatischen Änderungen an der Bootkonfiguration.

Das PXVIRT-Repository ist ein zusätzlicher Vertrauensbereich. Ein gültiger APT-Schlüssel bestätigt nur die Signatur des jeweiligen Herausgebers, nicht die Sicherheit des Codes.

Ohne unabhängige Bestätigung des erwarteten Signaturschlüssel-Fingerprints sollte die Paketquelle nicht hinzugefügt werden.

Nach Überprüfung des Repositories und des Installationsskripts:

bash scripts/06_add_proxmox_repo.sh

APT-Pakete kontrollieren:

apt update
apt-cache policy proxmox-ve

25. Proxmox installieren

Vor der tatsächlichen Installation eine Simulation durchführen:

apt-get -s install proxmox-ve

Folgende Pakete müssen erhalten bleiben:

Raspberry-Pi-kompatibler Linux-Kernel
raspi-firmware
cryptsetup-initramfs
dropbear-initramfs
initramfs-tools
OpenSSH-Server

Die Simulation muss außerdem auf unerwartete Änderungen an Netzwerkpaketen und dem Virtualisierungsstack überprüft werden.

Wenn die Abhängigkeiten kompatibel sind und die Paketquelle als vertrauenswürdig bewertet wurde:

apt install proxmox-ve

Installierte Version anzeigen:

pveversion -v

Webdienst kontrollieren:

systemctl status pveproxy --no-pager

Die Community-Pakete können zusätzliche Anpassungen benötigen. Sollte die Installation Abhängigkeiten oder Boot-Komponenten ersetzen wollen, nicht mit erzwungener Paketinstallation fortfahren.

26. Bootkonfiguration nach Updates prüfen

Nach Änderungen am Kernel, Cryptsetup oder Dropbear das Initramfs aktualisieren.

update-initramfs -u -k all

Boot-Konfiguration kontrollieren:

cat /boot/firmware/config.txt
cat /boot/firmware/cmdline.txt

Prüfen, ob Kernel, Initramfs, root=/dev/mapper/cryptroot und der statische ip-Parameter weiterhin stimmen.

Ein Kernel-Update darf nicht ungeprüft auf einen für den Raspberry Pi ungeeigneten Kernel umstellen.

27. Proxmox-Weboberfläche

Die Weboberfläche kann nach erfolgreicher Installation über HTTPS geöffnet werden:

https://10.100.0.2:8006

Anmeldung:

Benutzer: root
Passwort: Debian-Root-Passwort
Realm: Linux PAM

Das TLS-Zertifikat vor dem ersten Zugriff kontrollieren. Das anfängliche Zertifikat kann selbstsigniert sein.

Für den dauerhaften Betrieb sollte ein vertrauenswürdiges Zertifikat eingerichtet werden, dessen Hostname zum System passt.

28. Netzwerk absichern

Die Management-Oberfläche sollte ausschließlich aus einem dafür vorgesehenen Verwaltungsnetz erreichbar sein.

Zu schützen sind insbesondere:

SSH auf Port 22
Dropbear im Initramfs auf Port 2222
Proxmox HTTPS auf Port 8006

Den Zugriff nach Möglichkeit bereits am Router beziehungsweise an der Netzwerk-Firewall anhand des Management-Netzes begrenzen.

Für den Initramfs-Zugriff gilt das besonders, da die normale Firewall-Konfiguration von Debian in dieser Bootphase noch nicht läuft.

Bei Verwendung der Proxmox-Firewall deren Regeln so konfigurieren, dass die erlaubten Management-Verbindungen erhalten bleiben.

29. LUKS-Header sichern

Ein beschädigter LUKS-Header kann den Zugriff auf sämtliche verschlüsselte Daten dauerhaft verhindern.

Verschlüsseltes Gerät identifizieren:

lsblk -f

Header auf einem externen Datenträger sichern:

cryptsetup luksHeaderBackup /dev/sda2 \
--header-backup-file /PFAD/ZUM/BACKUP/pi4-luks-header.img

/dev/sda2 und den Sicherungspfad anhand der tatsächlichen Umgebung anpassen.

Der Backup-Datenträger muss geschützt sein. Den Header nicht ausschließlich auf der verschlüsselten SSD selbst sichern.

Einen separaten Wiederherstellungsplan mit LUKS-Passphrase, Header-Backup und einem dokumentierten Wiederherstellungsweg aufbewahren.

30. Sicherheitsregeln

Für LUKS, Debian-root und SSH unterschiedliche Zugangsdaten verwenden.
SSH ausschließlich mit Schlüsselauthentifizierung betreiben.
Private SSH-Schlüssel niemals auf die unverschlüsselte Boot-Partition kopieren.
Dropbear ausschließlich für cryptroot-unlock freigeben.
Den SSH-Hostkey vor der ersten Verbindung verifizieren.
Keine öffentlichen Portweiterleitungen für die Managementdienste verwenden.
Debian-Sicherheitsupdates zeitnah installieren.
Kernel-, Firmware- und Initramfs-Änderungen vor einem unbeaufsichtigten Neustart prüfen.
Nur vertrauenswürdige APT-Paketquellen verwenden.
Community-Pakete vor größeren Updates prüfen und Backups erstellen.
Keine unverschlüsselten zusätzlichen VM-Datenträger oder Swap-Partitionen verwenden.
Den unverschlüsselten Bootbereich vor Manipulationen schützen.
Für VM- und Container-Backups ebenfalls Verschlüsselung einsetzen.
Die LUKS-Entsperrung nach Änderungen durch einen vollständigen Neustart testen.

31. Weiterführende Dokumentation

Stand: Oktober 2026. Installationskonzept für Debian 13 ARM64, LUKS2, Dropbear und Community-Proxmox. Der vollständige Ablauf wurde nicht auf einem Raspberry Pi 4 mit dieser konkreten Datenträgerkonfiguration validiert.