GNU/Linux >> Belajar Linux > >> Linux

Amankan Kali Pi (2022)

Ini adalah bagian pertama dari seri 3 bagian posting blog seputar penggunaan Kali pada perangkat Raspberry Pi. Posting pertama ini akan mencakup pengaktifan Full Disk Encryption (FDE) pada Raspberry Pi, bagian kedua akan membahas cara menghubungkannya dari jarak jauh, dan terakhir, bagian ketiga akan membahas masalah debug yang kami alami saat membuat postingan ini, sehingga orang lain dapat mempelajari caranya begitu juga.

Dengan segala sesuatu yang telah terjadi di dunia dalam beberapa tahun terakhir, semakin banyak orang yang bekerja dari jarak jauh. Kami tidak terkecuali dalam hal ini, dan hari ini, kami akan mengunjungi kembali mesin “drop box” kami, yang telah dienkripsi sehingga membuat lebih sulit untuk mengidentifikasi jika ditemukan .

Tujuannya adalah untuk membuat "tinggalkan" yang berdiri sendiri tanpa kepala perangkat yang, jika/saat ditemukan, tidak memudahkan untuk mengetahui apa yang kami lakukan karena data kami aman selalu. Untuk mencapai ini, kami akan menggunakan Enkripsi Disk Penuh (FDE), dan mengizinkannya dibuka dari jarak jauh (jika perangkat dihidupkan ulang karena alasan apa pun). Akan ada opsi juga untuk menggunakan LUKS Nuke kemampuan jika kita ingin membuat disk tidak dapat diakses kapan saja setelah kita selesai melakukannya. Kita akan melakukan ini pada Raspberry Pi 4 Model B+, tetapi juga telah diuji pada Raspberry Pi 3 Model B juga. Anda seharusnya dapat menggunakan sebagian besar merek/model perangkat serupa, mungkin hanya memerlukan sedikit adaptasi/penyesuaian kreatif untuk mengamankan sistem Anda sendiri.

Ini adalah proses yang diperbarui karena kami sebelumnya telah membahas sebagian dari ini sebelumnya. Kali ini kami menyertakan pengembangan tambahan, dengan beberapa kontribusi komunitas yang dimasukkan. Kami ingin memberi tahu Richard Nelson (@unixabg) untuk skrip otomatisnya. Kami akan membahas ini setelah melalui metode manual, karena kami selalu menyarankan Anda untuk memahami apa yang sedang terjadi.

Ringkasan tingkat lebih tinggi

Sebelum kita menyelami detail teknis tingkat bawah tentang apa yang akan kita capai, mari kita lihat sekilas tujuan yang ingin kita capai, dan uraikan:

Instal Kali Linux pada Raspberry Pi 4 (selanjutnya disebut “RPi”)
Siapkan sistem untuk boot terenkripsi yang siap untuk membuka kunci disk jarak jauh
Siapkan kunci SSH untuk memungkinkan pembukaan kunci jarak jauh (menggunakan initramfs dan Dropbear)
Cadangkan semua data yang ada
Konfigurasikan partisi terenkripsi
Pulihkan data kami
Meretas !

Ini mungkin terdengar seperti banyak, tetapi agak mudah bahkan jika ada beberapa langkah yang adil. Setelah selesai, kita akan memiliki RPi yang akan:

Boot
Dapatkan IP dari DHCP
Tunggu kami terhubung melalui SSH menggunakan kunci
Izinkan kami memberikan frasa sandi LUKS, atau LUKS Nuke

Kemudian di jalan ketika kita selesai dengan apa pun yang ingin kita lakukan, satu-satunya yang tersisa adalah mengambilnya …di waktu luang kita!

Menginstal Kali Linux pada RPi

Jika Anda mengikuti, pastikan untuk mengetahui ke mana Anda akan mencitrakan file, dan ganti /dev/sdX . Jangan menyalin/menempel secara membabi buta!

Kami akan membuat mesin drop box kami pada instalasi Kali yang ada. Seharusnya sangat mudah untuk menggunakan distribusi berbasis Debian lainnya, dan cukup mudah untuk OS lain (kecuali pengguna Windows!)

Pertama kita akan mendownload image Kali RPi stable terbaru. Pada saat penulisan, itulah Kali 2022.2.Kami juga telah memilih gambar 64-bit, karena kami memiliki RAM lebih dari 4GB, dan tidak menggunakan HAT (Perangkat Keras Terlampir di Atas). Langkah-langkah untuk 32-bit akan sama, setelah menyesuaikan nama file:

$ 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

Menyiapkan sistem

Menyiapkan chroot

Kami selanjutnya akan menyiapkan segala sesuatunya untuk chroot. Mari kita buat di mana kita ingin memasang kartu microSD, lalu pasang:

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

Dua perintah terakhir akan berguna untuk initramfs nanti.

Menginstal paket yang diperlukan

Sekarang sistem kami sudah diatur, kami dapat menggunakan chroot untuk mengatur gambar RPi untuk enkripsi. Pertama-tama mari kita masuk ke chroot dan menginstal beberapa paket yang diperlukan:

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

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

Kami ingin memastikan bahwa kami menggunakan kernel terbaru sebelum memulai, jadi pastikan juga kami telah menginstalnya:

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

Opsi booting

Selanjutnya kita akan mengedit /boot/cmdline.txt dan mengubah jalur root. /boot/cmdline.txt file pada perangkat RPi digunakan untuk melewati opsi baris perintah kernel. Kami ingin mengubah jalur root menjadi /dev/mapper/crypt , dan kemudian kita akan menambahkan cryptdevice=PARTUUID=$partuuid:crypt tepat setelah itu.

Alasan untuk ini adalah bahwa kernel perlu mengetahui di mana sistem file root, untuk memasangnya dan menggunakannya, dan karena kami mengenkripsi rootfs nanti di posting, selama waktu boot, ia juga tidak dapat melihat perangkat yang tidak terenkripsi. , karena enkripsi! Sementara kami mengubah nama di sini menjadi "crypt", Anda dapat menyebutnya apa pun yang Anda inginkan.

Hasil akhirnya akan terlihat seperti ini:

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

Tata letak partisi

Sekarang kita perlu memperbarui /etc/fstab file, ini adalah file konfigurasi pada sistem yang berisi semua disk yang tersedia, partisi disk, dan opsi apa yang digunakan saat menanganinya.

Saat ini diisi dengan UUID dari sistem file root, dan kita membutuhkannya untuk menunjuk ke sistem file terenkripsi yang akan kita buat. Dalam contoh ini, kami telah mengomentari UUID perangkat root sebelumnya, dan menunjuk ke /dev/mapper/crypt yang akan dipasang sebagai sistem file terenkripsi kami, setelah kami membuatnya:

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

Konfigurasikan partisi terenkripsi

Saat menggunakan partisi terenkripsi, kita perlu mengedit, atau membuat, jika tidak ada, /etc/crypttab file, yang digunakan oleh cryptsetup untuk mengetahui opsi apa yang diperlukan untuk membuka kunci perangkat terenkripsi.

Karena file ini tidak ada, kami akan membuat /etc/crypttab file, dan isi dengan opsi yang kita butuhkan:

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

Sekarang kita melakukan sedikit tipuan sistem file. Kami membuat sistem file LUKS palsu yang memungkinkan cryptsetup untuk disertakan dalam initramfs karena ia melihat partisi terenkripsi. Ketika Anda memformat partisi LUKS, Anda akan dimintai kata sandi, dan meskipun biasanya Anda akan menggunakan kata sandi yang kuat, karena kami hanya menggunakan ini sebagai peretasan untuk memasukkan cryptsetup ke initramfs kami, kata sandi yang Anda buat pada prompt ini tidak akan diperlukan atau digunakan melewati langkah-langkah ini, sehingga Anda dapat mengaturnya menjadi sesuatu yang pendek/cepat untuk diketik. Ini akan terjadi di cryptsetup luksFormat langkah, dan Anda akan dimintai kata sandi yang Anda atur selama cryptsetup luksFormat ketika Anda menjalankan cryptsetup luksOpen langkah.

Anda tidak akan melihat input apa pun yang diketik saat memasukkan kata sandi

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

Mengonfigurasi kunci SSH

Setelah itu kita perlu menyalin ATAU menghasilkan kunci ssh baru untuk ditambahkan ke authorized_keys Dropbear berkas.

Jika kita sudah memiliki kunci yang ada untuk disalin:

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

Atau untuk membuat kunci baru:

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

Anda tidak akan melihat input apa pun yang diketik saat memasukkan frasa sandi

Mengonfigurasi enkripsi

Kembali ke chroot, kita perlu membuat beberapa file baru.

Pertama adalah zz-cryptsetup hook yang menambahkan file yang kita butuhkan untuk cryptsetup ke dalam initramfs . Agar berfungsi, itu perlu ditandai sebagai dapat dieksekusi sehingga mkinitramfs akan menjalankan hook:

$ 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

Jika Anda ingin menonaktifkannya kapan saja di masa mendatang karena alasan apa pun, cukup hapus bit yang dapat dieksekusi.

Kami mengedit file modul untuk initramfs-tools sehingga kami menyertakan dm-crypt modul, dan cat file untuk memverifikasi itu benar:

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

Mengonfigurasi buka kunci SSH jarak jauh

Buat unlock.sh skrip dengan konten berikut, lalu tandai sebagai dapat dieksekusi sehingga skrip berjalan di 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

Selanjutnya kita harus menambahkan yang berikut ke awal /etc/dropbear/initramfs/authorized_keys , yang memerintahkannya untuk menjalankan perintah ini saat kita memasukkan SSH jika kuncinya cocok:

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

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

Setelah melakukannya, kita dapat menambahkan kunci SSH yang telah kita salin dan kemudian menghapusnya dari kartu:

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

Setelah selesai, /etc/dropbear/initramfs/authorized_keys akan terlihat seperti ini:

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

Semua yang ada di authorized_keys file harus satu baris, serta spasi di antara akhiran perintah " dan kunci ssh (mis. [...]exit" ssh-rsa[...] )

Sekarang kita perlu mengedit /usr/share/initramfs-tools/scripts/init-premount/dropbear untuk menambahkan pengatur waktu tidur, ini memungkinkan jaringan dimulai sebelum Dropbear melakukannya. Penting untuk dicatat bahwa ketika ada pembaruan pada dropbear-initramfs paket, suntingan ini perlu ditambahkan kembali:

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

Sekarang kita aktifkan 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

Langkah selanjutnya penting bagi orang-orang yang mengikuti. Apa yang harus dipilih, tergantung pada perangkat RPi yang Anda gunakan, akan . Di bawah ini adalah lima nama kernel/edisi/rasa yang perlu Anda pilih salah satu untuk kebutuhan Anda (harap diperhatikan!) :

Re4son+ adalah untuk perangkat ARMEL armv6 32-bit - yaitu RPi1, RPi0, atau RPi0w
Re4son-v7+ adalah untuk perangkat ARMHF armv7 32-bit - yaitu RPi2 v1.2, RPi3 atau RPi02w
Re4son-v8+ adalah untuk perangkat ARM64 armv8 64-bit - yaitu RPi2 v1.2, RPi3 atau RPi02w
Re4son-v7l+ adalah untuk perangkat ARMHF armv7 32-bit - yaitu perangkat RPi4 atau RPi400
Re4son-v8l+ adalah untuk perangkat ARM64 armv8 64-bit - yaitu perangkat RPi4 atau RPi400

l dalam nama singkatan lpae - Ekstensi Alamat Fisik Besar

Sebagai pengingat, kami menggunakan gambar RPi4, 64-bit. Jadi kita membutuhkan Re4son-v8l+ . Harap pastikan Anda menyesuaikan dengan perangkat Anda. Jadi sekarang kami tahu nama kernel apa yang akan digunakan, sekarang kami perlu menemukan versi kernel apa. Ini akan berubah dari perangkat ke perangkat, dan itu juga akan berubah ketika Kali mendapat pembaruan Pada saat penulisan, ini adalah 5.15.44 untuk RPi kami:

Perlu diingat bahwa versi kernel dapat berubah, namun namanya tidak akan berubah:

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

Perhatikan versi kernel (5.15.44 ) dapat berubah, namun nama kernel (Re4son-v8l+ ) tidak akan.

Sekarang kita perlu membuat initramfs . Di sinilah versi kernel berperan:

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

Sekarang kami ingin memastikan bahwa kami telah membuat initramfs benar. Jika tidak ada hasil, maka ada yang tidak beres:

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

Nonaktifkan layanan

Sebelum kami dapat membuat cadangan, kami harus memastikan bahwa rpi-resizerootfs dinonaktifkan. Ini adalah layanan yang biasanya kami jalankan di semua perangkat ARM kami yang mengubah ukuran partisi sistem file root untuk meningkatkan ukuran partisi ke ukuran penuh perangkat penyimpanan yang digunakan. Karena kami melakukan langkah ini secara manual, kami ingin menonaktifkannya, sehingga tidak berpotensi menghapus sistem file root kami dan membuatnya kembali.

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

Cadangkan semua data yang ada

Sekarang kita dapat memastikan bahwa semua perubahan telah ditulis, kemudian kita dapat mengenkripsi 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

Konfigurasikan partisi terenkripsi

Bergantung pada perangkat apa yang Anda gunakan, Anda harus menggunakan salah satu dari dua perintah. Jika Anda menggunakan RPi4 dengan 4GB atau lebih, gunakan perintah ini:

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

Jika tidak, Anda akan ingin menggunakan yang berikut ini yang menggunakan versi LUKS yang lebih lama:

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

Pulihkan data kami

Setelah itu Anda dapat menyelesaikan pemulihan data kembali ke partisi yang sekarang dienkripsi:

$ 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

Langkah terakhir yang harus kita lakukan adalah memperbaiki /etc/fstab file untuk LUKS UUID baru, atau Anda dapat membiarkannya sebagai /dev/mapper/crypt dan ganti UUID di skrip buka kunci kami dan buat ulang file initramfs, langkah ini penting karena tidak akan boot dengan benar jika tidak dilakukan, karena tidak akan memiliki informasi untuk menggunakan sistem file terenkripsi! Ingatlah untuk memasukkan informasi dari ANDA sistem, karena UUID akan berbeda untuk setiap sistem:

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

Jika Anda mendapatkan kesalahan cryptsetup di sini, mirip dengan cryptsetup: ERROR: Couldn't resolve device PARTUUID=ed889dad-02 itu berarti Anda tidak mengedit /etc/crypttab file dan masukkan PARTUUID yang benar. Peringatan tentang tidak ada fsck.luks yang ada dapat diabaikan, karena tidak ada hal seperti itu.

Sekarang kita dapat meng-unmount dan menutup semuanya:

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

Sebelumnya, kami menyebutkan kemampuan LUKS Nuke. Jika Anda berencana untuk menggunakannya, saat boot pada rootf RPi Anda yang baru dienkripsi, cukup jalankan perintah berikut untuk menambahkan kata sandi Nuke dan ikuti perintahnya:

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

Nantikan bagian kedua di mana kita membahas koneksi jarak jauh ke Raspberry Pi sebagai perangkat dropbox!

Otomatiskan!

Sekarang bagaimana kalau kita membuat ini otomatis? Terima kasih kepada Richard Nelson (@unixabg), siapa pun yang ingin menyiapkan semua ini dalam waktu yang jauh lebih singkat daripada metode manual dan jauh lebih mudah, bisa!

Pertama-tama, mari unduh skrip cryptmypi unixabg:

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

Namun ada beberapa hal yang ingin kami lakukan sebelum kami dapat menjalankan skrip build. Mari kita bahas bersama sekarang:

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

Sekarang kita perlu mengedit cryptmypi.conf untuk mengubah beberapa pengaturan di tahap-2. Pengaturan ini akan bersifat pribadi, tetapi mari kita beri Anda semua contoh:

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

Apa yang kami ubah di sini adalah perangkat blok, kata sandi enkripsi LUKS, dan kata sandi root. URL gambar dapat diubah jika Anda ingin menggunakan file gambar yang berbeda, jadi pastikan untuk melakukannya sekarang jika perlu.

Sekarang satu-satunya yang tersisa untuk dilakukan adalah menjalankan skrip kedua tahap dan ikuti instruksi. Pada akhirnya, Anda akan memiliki sistem file terenkripsi sepenuhnya dengan akses Dropbear SSH!

Kali Linux 2022.3 Rilis (Discord &Test Lab) Mesin Virtual Mingguan, dengan Skrip Build

Linux