Toto je první část 3dílné série blogových příspěvků o používání Kali na zařízeních Raspberry Pi. Tento první příspěvek se bude týkat povolení Full Disk Encryption (FDE) na Raspberry Pi, část druhá se bude týkat vzdáleného připojení k němu a konečně třetí část pokryje problémy s laděním, na které jsme narazili při vytváření těchto příspěvků, aby se ostatní mohli naučit, jak to udělat. tak také.

Se vším, co se ve světě za posledních pár let děje, stále více lidí pracuje na dálku. Nejsme v tom výjimkou a dnes znovu navštívíme náš počítač „skládací schránky“, který byl zašifrován, takže je obtížnější identifikovat pokud by byl objeven .

Cílem je vytvořit samostatný „nechat za sebou“ bezhlavý zařízení, které v případě odhalení neusnadňuje zjištění, co jsme dělali, protože naše data jsou v bezpečí po celou dobu. Abychom toho dosáhli, použijeme Full Disk Encryption (FDE) a umožníme jeho vzdálené odemykání (pokud by se zařízení z nějakého důvodu restartovalo). Bude také možnost použít LUKS Nuke Pokud bychom si přáli znepřístupnit disk kdykoli poté, co s tím skončíme. Budeme to dělat na Raspberry Pi 4 Model B+, ale také to bylo testováno na Raspberry Pi 3 Model B. Měli byste být schopni používat většinu značek/modelů podobných zařízení, jen to může vyžadovat trochu kreativních úprav/úprav, abyste si zabezpečili svůj vlastní systém.

Toto je aktualizovaný proces, protože jsme se o jeho části již dříve zabývali. Tentokrát zahrnujeme další vývoj s některými příspěvky komunity. Rádi bychom poděkovali Richardu Nelsonovi (@unixabg) za jeho automatický skript. Toho se dotkneme poté, co projdeme manuální metodou, protože vždy doporučujeme, abyste pochopili, co se děje pod kapotou.

Přehled vyšší úrovně

Než se ponoříme do nižších úrovní technických detailů toho, čeho chceme dosáhnout, pojďme se rychle podívat na naše cíle, kterých chceme dosáhnout, a rozebrat si je:

• Nainstalujte Kali Linux na Raspberry Pi 4 (dále jen „RPi“)
• Připravte systém na šifrované spouštění připravené na vzdálené odemknutí disku
• Nastavte klíče SSH, abyste umožnili vzdálené odemknutí (pomocí initramfs a Dropbear)
• Zálohujte všechna existující data
• Nakonfigurujte šifrované oddíly
• Obnovte naše data
• Odstranit !

Může to znít jako hodně, ale je to docela jednoduché, i když je tam pár kroků. Po dokončení budeme mít RPi, které:

• Zavedení
• Získejte IP adresu z DHCP
• Počkejte, až se připojíme přes SSH pomocí klíčů
• Umožněte nám poskytnout přístupové fráze pro odemknutí LUKS nebo LUKS Nuke

Potom, až skončíme s čímkoli, co chceme dělat, zbývá už jen to získat zpět …v našem volném čase!

Instalace Kali Linuxu na RPi

Pokud to sledujete, ujistěte se, že víte, kam soubor zobrazujete, a nahraďte /dev/sdX . Nekopírujte a nevkládejte slepě!

Na stávající instalaci Kali vytvoříme náš stroj drop box. Mělo by být velmi snadné používat jiné distribuce založené na Debianu a docela přímočaré pro ostatní operační systémy (kromě uživatelů Windows!)

Nejprve si stáhneme nejnovější stabilní obraz Kali RPi. V době psaní tohoto článku je to Kali 2022.2. Také jsme zvolili 64bitový obraz, protože máme více než 4 GB RAM a nepoužíváme žádné HAT (Hardware Attached on Top). Kroky pro 32bitovou verzi by byly po úpravě názvů souborů stejné:

$ 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

Příprava systému

Příprava chrootu

Dále se chystáme připravit věci na chroot. Vytvořme místo, kam chceme kartu microSD připojit, a poté ji připevněme:

$ 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/

Poslední dva příkazy se budou hodit, připravené pro initramfs později.

Instalace požadovaných balíčků

Nyní, když je náš systém nastaven, můžeme použít chroot k nastavení obrazu RPi pro šifrování. Nejprve zadejte chroot a nainstalujte některé potřebné balíčky:

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

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

Než začneme, chceme se ujistit, že máme nejnovější jádro, takže se také ujistěte, že je máme nainstalované:

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

Možnosti spouštění

Dále upravíme /boot/cmdline.txt a změnit kořenovou cestu. /boot/cmdline.txt soubor na zařízení RPi se používá k předání voleb příkazového řádku jádra. Budeme chtít změnit kořenovou cestu na /dev/mapper/crypt a poté přidáme cryptdevice=PARTUUID=$partuuid:crypt hned poté.

Důvodem je, že jádro potřebuje vědět, kde je kořenový souborový systém, aby jej mohlo připojit a používat, a protože rootfs šifrujeme později v příspěvku, během bootování také nevidí nezašifrované zařízení. , kvůli šifrování! Zatímco zde měníme název na „crypt“, můžete mu říkat, jak chcete.

Konečný výsledek by měl vypadat takto:

┌──(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

Rozvržení oddílu

Nyní potřebujeme aktualizovat /etc/fstab soubor, jedná se o konfigurační soubor v systému, který obsahuje všechny dostupné disky, diskové oddíly a jaké možnosti použít při manipulaci s nimi.

V současné době je naplněn UUID kořenového souborového systému a potřebujeme, aby ukazoval na šifrovaný souborový systém, který budeme vytvářet. V tomto příkladu jsme zakomentovali, jaké UUID mělo předchozí kořenové zařízení, a ukazujeme na /dev/mapper/crypt což je to, co náš šifrovaný souborový systém připojí, jakmile jej vytvoříme:

┌──(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

Konfigurace šifrovaných oddílů

Při použití šifrovaných oddílů musíme upravit nebo vytvořit, pokud neexistuje, /etc/crypttab soubor, který používá cryptsetup, aby věděl, jaké možnosti jsou potřeba k odemknutí šifrovaného zařízení.

Protože tento soubor neexistuje, vytvoříme /etc/crypttab soubor a vyplňte jej možnostmi, které potřebujeme:

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

Nyní uděláme malý trik se souborovým systémem. Vytváříme falešný souborový systém LUKS, který umožní cryptsetup zahrnout do initramfs, protože vidí zašifrovaný oddíl. Když naformátujete jakékoli oddíly LUKS, budete vyzváni k zadání hesla, a zatímco normálně použijete silné heslo, protože to používáme pouze jako hack k zahrnutí cryptsetup do našich initramfs, heslo, které vytvoříte na této výzvě, nebude být potřeba nebo použit po těchto krocích, takže jej můžete nastavit na něco krátkého/rychlého psaní. To se stane na cryptsetup luksFormat krok a budete vyzváni k zadání hesla, které jste nastavili během cryptsetup luksFormat když spustíte cryptsetup luksOpen krok.

Při zadávání hesla neuvidíte žádný vstup

┌──(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

Konfigurace klíčů SSH

Poté musíme zkopírovat NEBO vygenerovat nový ssh klíč, který bude přidán do Dropbearova authorized_keys soubor.

Pokud již máme existující klíč ke zkopírování:

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

Případně vygenerovat nový klíč:

$ 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/

Při zadávání přístupové fráze neuvidíte žádný vstup zadávaný

Konfigurace pro šifrování

Když se vrátíme zpět do chrootu, musíme vytvořit několik nových souborů.

První je zz-cryptsetup hook, který přidá soubory, které potřebujeme pro cryptsetup do initramfs . Aby fungoval, musí být označen jako spustitelný, takže mkinitramfs spustí háček:

$ 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

Pokud byste jej chtěli kdykoli v budoucnu z jakéhokoli důvodu zakázat, jednoduše odstraňte spustitelný bit.

Upravujeme soubor modulů pro initramfs-tools takže zahrneme dm-crypt modul a cat soubor, abyste ověřili, že je správný:

┌──(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

Konfigurace vzdáleného odemykání SSH

Vytvořte unlock.sh skript s následujícím obsahem a poté jej označte jako spustitelný, aby se skript spouštěl v initramfs :

┌──(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

Dále musíme přidat následující na začátek /etc/dropbear/initramfs/authorized_keys , který mu říká, aby spustil tento příkaz, když připojíme SSH, pokud se klíč shoduje:

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

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

Poté můžeme připojit klíč SSH, který jsme zkopírovali, a poté jej z karty odstranit:

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

Až budete hotovi, /etc/dropbear/initramfs/authorized_keys by měl vypadat takto:

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

Vše v authorized_keys soubor by měl být jeden řádek a také mezera mezi koncem příkazu " a klíč ssh (např. [...]exit" ssh-rsa[...] )

Nyní potřebujeme upravit /usr/share/initramfs-tools/scripts/init-premount/dropbear pro přidání časovače spánku to umožní spuštění sítě před Dropbear ano. Je důležité si uvědomit, že když jsou aktualizace dropbear-initramfs balíček, bude nutné tuto úpravu znovu přidat:

┌──(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

Nyní povolíme 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

Jádro

Další krok je důležitý pro lidi, kteří ho následují. Co vybrat, závisí na zařízení RPi, které používáte, bude . Níže je uvedeno pět názvů jader/edic/příchutí, z nichž si musíte jednu vybrat podle svých potřeb (prosím, věnujte pozornost!) :

• Re4son+ je pro 32bitová zařízení ARMEL armv6 – tj. RPi1, RPi0 nebo RPi0w
• Re4son-v7+ je pro 32bitová zařízení ARMHF armv7 – tj. RPi2 v1.2, RPi3 nebo RPi02w
• Re4son-v8+ je pro 64bitová zařízení ARM64 armv8 – tj. RPi2 v1.2, RPi3 nebo RPi02w
• Re4son-v7l+ je pro 32bitová zařízení ARMHF armv7 – tedy zařízení RPi4 nebo RPi400
• Re4son-v8l+ je pro 64bitová zařízení ARM64 armv8 – tedy zařízení RPi4 nebo RPi400

l v názvu znamená lpae - Large Physical Address Extension

Připomínáme, že používáme 64bitový obraz RPi4. Potřebovali bychom tedy Re4son-v8l+ . Ujistěte se, že jste se přizpůsobili vašemu zařízení. Nyní tedy víme, jaký název jádra použít, nyní musíme najít verzi jádra. Toto se bude měnit zařízení od zařízení a také se to změní, když Kali získá aktualizace. V době psaní tohoto článku je to 5.15.44 pro naše RPi:

Mějte na paměti, že verze jádra se mohou změnit, ale název se nezmění:

┌──(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

Mějte na paměti verze jádra (5.15.44 ) se může změnit, ale název jádra (Re4son-v8l+). ) nebude.

Nyní musíme vytvořit initramfs . Zde přichází do hry verze jádra:

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

Nyní se chceme ujistit, že jsme vytvořili initramfs správně. Pokud není výsledek, pak se něco pokazilo:

┌──(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

Zakázat služby

Než budeme moci zálohovat, musíme se ujistit, že rpi-resizerootfs je zakázáno. Toto je služba, kterou obvykle spouštíme na všech našich zařízeních ARM a která mění velikost oddílu kořenového souborového systému, aby se velikost oddílu zvětšila na plnou velikost úložného zařízení, na kterém je. Protože tento krok provádíme ručně, chceme jej zakázat, aby potenciálně neodstranil náš kořenový souborový systém a znovu jej nevytvořil.

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

Zálohujte všechna existující data

Nyní můžeme zajistit, aby byly všechny změny zapsány, pak můžeme zašifrovat disk:

┌──(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

Konfigurace šifrovaných oddílů

V závislosti na tom, jaké zařízení používáte, budete muset použít jeden ze dvou příkazů. Pokud používáte RPi4 se 4 GB nebo více, použijte tento příkaz:

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

V opačném případě budete chtít použít následující, které používá starší verzi LUKS:

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

Obnovte naše data

Poté můžete dokončit obnovu dat zpět do nyní zašifrovaného oddílu:

$ 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

Poslední kroky, které musíme udělat, je opravit /etc/fstab soubor pro nový LUKS UUID, nebo jej můžete ponechat jako /dev/mapper/crypt a nahraďte UUID v našem odemykacím skriptu a předělejte soubor initramfs, tento krok je důležitý, protože se nespustí správně, pokud se neprovede, protože nebude mít informace k použití šifrovaného souborového systému! Nezapomeňte zadat informace z VAŠE systém, protože UUID se bude pro každý systém lišit:

$ 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+

Pokud se zde zobrazí chyba šifrování, podobná jako cryptsetup: ERROR: Couldn't resolve device PARTUUID=ed889dad-02 to znamená, že jste neupravili /etc/crypttab a vložte správný PARTUUID. Varování, že neexistuje žádný fsck.luks, lze ignorovat, protože nic takového neexistuje.

Nyní můžeme vše odpojit a zavřít:

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

Již dříve jsme zmínili schopnost LUKS Nuke. Pokud ho plánujete používat, když je spuštěn na vašem čerstvě zašifrovaném RPi rootfs, jednoduše spusťte následující příkaz pro přidání hesla Nuke a postupujte podle pokynů:

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

Zůstaňte naladěni na druhou část, kde se budeme zabývat vzdáleným připojením k Raspberry Pi jako zařízení dropbox!

Automatizujte!

Co kdybychom to zautomatizovali? Díky Richardu Nelsonovi (@unixabg) může každý, kdo to chce všechno nastavit za mnohem kratší dobu než manuální metoda a mnohem snadněji!

Nejprve si stáhněte skript cryptmypi unixabg:

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

Než však spustíme sestavení skriptů, chceme udělat řadu věcí. Pojďme si je nyní společně projít:

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

Nyní musíme upravit cryptmypi.conf změnit některá nastavení ve fázi 2. Tato nastavení budou osobní, ale uveďme si jen příklad:

$ 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"

Co jsme zde změnili, je blokové zařízení, heslo pro šifrování LUKS a heslo uživatele root. Adresu URL obrázku lze změnit, pokud chcete použít jiný soubor obrázku, takže to v případě potřeby udělejte nyní.

Nyní zbývá pouze spustit skripty obou fází a postupovat podle pokynů. Na konci budete mít plně šifrovaný souborový systém s přístupem Dropbear SSH!