master
blallo 2 years ago
parent 15cf7e0776
commit a543387976
  1. 198
      installazione.md
  2. 41
      login.md

@ -1,153 +1,138 @@
### ZFS
# How to rosa
Installiamo zfs nel sistema live (lo script è fornito direttamente da hetzner,
l'ho copiato in questa repo)
```
./install_zfsonlinux.sh
```
Lanciamo lo script `create_pools.sh`
```
./create_pools.sh
```
(per importare delle pool già esistenti, facciamo `zfs import -f <nome_pool>`).
## ATTENZIONE:
Se vuoi solo loggarti sulla macchina, vai [qui](./login.md).
### Installazione debian base
Dal live system, ci segnamo l'output del seguente comando
Dal live system, usiamo `imageinstall -e` provvisto da Hetzner per installare un
sistema debian buster base, in cui configuriamo i dischi con il seguente layout:
```
blkid -s PARTUUID -o value <path/to/efi/partition>
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 2.7T 0 disk
├─sda1 8:1 0 1G 0 part
│ └─md0 9:0 0 1022M 0 raid1 /boot
├─sda2 8:2 0 2.7T 0 part
│ └─md1 9:1 0 2.7T 0 raid1
│ └─vg0-root 253:1 0 300G 0 lvm /
└─sda3 8:3 0 1M 0 part
sdb 8:16 0 2.7T 0 disk
├─sdb1 8:17 0 1G 0 part
│ └─md0 9:0 0 1022M 0 raid1 /boot
├─sdb2 8:18 0 2.7T 0 part
│ └─md1 9:1 0 2.7T 0 raid1
│ └─vg0-root 253:1 0 300G 0 lvm /
└─sdb3 8:19 0 1M 0 part
```
dove `<path/to/efi/partition>` corrisponde al valore puntato da `${DISK1}-part1`
nello script lanciato nello step precedente. Installiamo nella directory target
il sistema base
Il sistema provvede ad installare un sistema con ssh già avviato e l'utente root
con la chiave ssh già configurata (se l'abbiamo impostata nel pannello del
rescue system).
```
debootstrap buster /mnt
```
Entriamo in chroot con systemd-nspawn
```
systemd-nspawn -D /mnt
```
### Cryptoroot
Modificare le `/etc/apt/sources.list` per includere i seguenti
A questo punto, riavviamo di nuovo nel rescue system. Creiamo un disco in ram
abbastanza grande da contenere il tarball di tutto il contenuto della root:
```
deb http://deb.debian.org/debian buster main non-free contrib
deb http://deb.debian.org/debian buster-updates main non-free contrib
deb http://deb.debian.org/debian buster-backports main non-free contrib
deb http://security.debian.org buster/updates main non-free contrib
mkdir /ramdisk
mount -t tmpfs -o size=10G /ramdisk
```
Facciamo il pinning (ovvero diciamo ad apt di prendere certi pacchetti da una
specifica repository) per i pacchetti relativi a ZFS, mettendo questo contenuto
in `/etc/apt/preferences.d/90_zfs`
Montiamo la root
```
Package: libnvpair1linux libuutil1linux libzfs2linux libzfslinux-dev libzpool2linux python3-pyzfs pyzfs-doc spl spl-dkms zfs-dkms zfs-dracut zfs-initramfs zfs-test zfsutils-linux zfsutils-linux-dev zfs-zed
Pin: release n=buster-backports
Pin-Priority: 990
mount /dev/vg0/root /mnt
```
Per lo scopo dell'installazione
Facciamo un backup della root
```
ln -s /proc/self/mounts /etc/mtab
apt update
cd /mnt
tar czvf /ramdisk/root.tar.gz /mnt/*
```
Configurare il locale e la timezone (io ho selezionato `en_US.UTF-8` e locale
`Europe/Berlin`)
Eliminiamo il contenitore vg0 (un volume group LVM) in questa brutale maniera,
creando così uno strato di cifratura
```
apt install --yes locales
dpkg-reconfigure locales
dpkg-reconfigure tzdata
cryptsetup luksFormat /dev/md1
```
Installiamo i pacchetti relativi a ZFS nel nuovo sistema
Ci viene chiesta la conferma, e di immettere due volte la nuova passphrase. Dopo
di questo, montiamo il nuovo contenitore cifrato
```
apt install --yes dpkg-dev linux-headers-amd64 linux-image-amd64
apt install --yes zfs-initramfs
apt install --yes console-setup
echo REMAKE_INITRD=yes > /etc/dkms/zfs.conf
cryptsetup open /dev/md1 crypta
```
Aggiungiamo la seguente riga nell'`/etc/fstab`
creiamo un nuovo volume group e un logical group per la partizione di root
```
PARTUUID=<uuid_da_primo_step> /boot/efi vfat nofail,x-systemd.device-timeout=1 0 1
vgcreate /dev/mapper/crypta vg0
lvcreate -L 300G --name root vg0
```
(dove `<uuid_da_primo_step>` è la stringa ottenuta nel primo passo di questa
sezione) e preoccupiamoci di ciò che riguarda il boot
lo montiamo e ci riversiamo dentro il backup della root
```
apt install dosfstools
apt install --yes grub-efi-amd64 shim-signed
dpkg --purge os-prober
mount /dev/vg0/root /mnt
tar xzvf /ramdisk/root.tar.gz -C /mnt
```
Impostiamo la password root
Il nuovo layout dovrebbe essere questo
```
passwd
```
(Forse non serve) creiamo e abilitiamo questa unit systemd (in
`/etc/systemd/system/zfs-import-bpool.service`) per forzare l'import della pool
di `/boot`
```ini
[Unit]
DefaultDependencies=no
Before=zfs-import-scan.service
Before=zfs-import-cache.service
[Service]
Type=oneshot
RemainAfterExit=yes
ExecStart=/sbin/zpool import -N -o cachefile=none bpool
[Install]
WantedBy=zfs-import.target
NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINT
sda 8:0 0 2.7T 0 disk
├─sda1 8:1 0 1G 0 part
│ └─md0 9:0 0 1022M 0 raid1 /boot
├─sda2 8:2 0 2.7T 0 part
│ └─md1 9:1 0 2.7T 0 raid1
│ └─crypta 253:0 0 2.7T 0 crypt
│ └─vg0-root 253:1 0 300G 0 lvm /
└─sda3 8:3 0 1M 0 part
sdb 8:16 0 2.7T 0 disk
├─sdb1 8:17 0 1G 0 part
│ └─md0 9:0 0 1022M 0 raid1 /boot
├─sdb2 8:18 0 2.7T 0 part
│ └─md1 9:1 0 2.7T 0 raid1
│ └─crypta 253:0 0 2.7T 0 crypt
│ └─vg0-root 253:1 0 300G 0 lvm /
└─sdb3 8:19 0 1M 0 part
```
Adesso installiamo e configuriamo grub
(dove `<uuid_di_dev_md0>` si può ottenere da `lsblk -o +UUID`, alla riga
corrispondente di `/dev/md0`).
Montiamo tutto insieme e facciamo il chroot dentro
```
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=debian --recheck
perl -i -pe 's/(GRUB_CMDLINE_LINUX=")/${1}root=ZFS=rpool /' /etc/default/grub
echo 'GRUB_DISABLE_OS_PROBER=true' >> /etc/default/grub
update-grub
mount /dev/vg0/root /mnt
mount /dev/md0 /mnt/boot
mount -t proc /proc /mnt/proc
for fs in dev sys run; do mount --rbind /${fs} /mnt/${fs}; done
chroot /mnt /bin/bash --login
```
I seguenti passi servono a configurare il boot
Ci assicuriamo che `/etc/fstab` abbia questa forma
```
umount /boot/efi
umount /boot
zfs set mountpoint=legacy bpool
echo "bpool /boot zfs nodev,relatime,x-systemd.requires=zfs-import-bpool.service 0 0" >> /etc/fstab
proc /proc proc defaults 0 0
UUID=<uuid_di_dev_md0> /boot ext3 defaults 0 0
UUID= none swap sw 0 0
/dev/vg0/root / ext4 defaults 0 0
```
e disabilitiamo il suspend/resume (questo è un server)
e che `/etc/crypttab` sia fatto così
```
echo RESUME=none > /etc/initramfs-tools/conf.d/resume
# <target name> <source device> <key file> <options>
crypta /dev/md1 none luks
```
### Dropbear
### Dropbear nell'initram
Installiamo dropbear nell'initramfs
@ -165,6 +150,7 @@ echo 'DROPBEAR_OPTIONS="-s -j -k -p 4747"' >> /etc/dropbear-initramfs/config
disabilita il remote port forwarding; `-p` è la porta a cui bindarsi)
Copiamo la chiave pubblica generata in `/etc/dropbear-initramfs/authorized_keys`
(ATTENZIONE: **non** può essere una chiave ellittica, usate una RSA)
```
cat <LA_CHIAVE_PUBLICA> >> /etc/dropbear-initramfs/authorized_keys
@ -176,27 +162,9 @@ Configuriamo la rete
echo 'IP="144.76.80.140::144.76.80.129:255.255.255.224:::off"' >> /etc/initramfs-tools/initramfs.conf
```
### Stunt per far funzionare zfs al boot in dropbear
Copiamo lo script da [qui][zfsunlock] e mettiamolo in
`/usr/share/initramfs-tools/scripts/zfsunlock` e diamogli l'eseguibilità:
```
chmod +x /usr/share/initramfs-tools/scripts/zfsunlock
```
Poi modifichiamo `/usr/share/initramfs-tools/scripts/zfs` come in [questo
commit][commit] (si può usare la patch in `zfs.patch`, copiandola in
`/tmp/zfs.patch` e invocando `patch < /tmp/zfs.patch`).
Infine, aggiorniamo l'initramfs
Infine, aggiorniamo l'initramfs e grub
```
update-initramfs -u -v
update-grub
```
[zfsunlock]: https://raw.githubusercontent.com/openzfs/zfs/1cc635a2dd0379181950a1458255ea8ae8b9c1e0/contrib/initramfs/zfsunlock
[commit]: https://github.com/openzfs/zfs/commit/1cc635a2dd0379181950a1458255ea8ae8b9c1e0#diff-98a21a3fd74b681e806ecbd958c2352bL409

@ -0,0 +1,41 @@
# How to login
Per loggarti devi avere accesso a due chiavi ssh diverse. Si trovano entrambe
nel pass condiviso. Quella per loggarsi al boot è `unit/rosa_dropbear_key` e
quella per loggarsi sul sistema avviato è `unit/server_common_key`.
Queste vanno decifrate e messe in un posto adeguato
```
pass unit/rosa_dropbear_key >> $HOME/.ssh/rosa_boot
pass unit/server_common_key >> $HOME/.ssh/unit
chmod 600 $HOME/.ssh/rosa_boot
chmod 600 $HOME/.ssh/unit
```
### Decifrare il disco cifrato
Alla partenza, la macchina non è in uno stato utilizzabile: la partizione di
root è ancora cifrata. Il server espone ssh sulla porta `4747`, quindi per
loggarsi
```
ssh -i $HOME/.ssh/rosa_boot -p 4747 root@144.76.80.140
```
A questo punto, per decifrare il disco e avviare definitivamente la macchina si
può usare lo script
```
cryptroot-unlock
```
che chiede la passphrase del disco (`pass unit/rosa_root_passphrase`). Una volta
immessa e premuto invio, la connessione ssh si chiude e il server termina il
processo di avvio.
### Per loggarsi normalmente
```
ssh -i $HOME/.ssh/unit root@144.76.80.140
```
Loading…
Cancel
Save