Installation d'Alpine Linux chiffré sur un serveur distant

Lorsque vous louez un serveur (dédié ou VPS), que ce soit chez Kimsufi, Online ou Hetzner pour citer les plus connus, vous avez généralement le choix d'installer une distribution au choix parmi une liste assez réduite.

C'est effectivement très pratique d'avoir à portée de clic une distribution clé en main, mais plusieurs points me dérangent :

Limitation en FS lors du choix du partitionnement
Impossibilité de choisir le type de table de partitionnement
Distribution pré-installée/pré-configurée et donc pas de contrôle sur ce qui a été fait
Limitation du choix de la distribution. Depuis un rescue boot, on installe ce que l'on veut (Void Linux, Alpine, FreeBSD, etc)
Aucun chiffrement alors que mon serveur se trouve dans un datacenter dans lequel des administrateurs infra/sys ont la main

Parmi tous ses points, l'aspect chiffrement est tout aussi important que l'installation manuelle de la distribution :

Et si mon serveur se fait saisir comme ici ou là ?
Et si mon serveur (et disque dur) est attribué à quelqu'un d'autre et qu'il s'amuse avec testdisk ? toujours penser à shred/dd son serveur avant de le rendre
Et si un administrateur infra/sys de l'hébergeur s'amuse à voir/modifier le contenu (reboot, chroot, mount, etc) ?

L'intérêt d'installer et chiffrer sois même sa distribution c'est que vous savez ce que vous faites, ce que vous ferez et surtout ce qui a été fait.

Je fabriquerais à la fin mon initramfs et j'y intégrerais sshd d'OpenSSH afin de déchiffrer par le réseau ma partition '/' au démarrage. Je n'utilise pas Dropbear car il ne sait pas gérer les clés ed25519 et concernant TinySSH, il pourrait faire l'affaire, mais il n'est pas disponible dans les dépôts.

Je prendrais ici pour exemple le cas d'un serveur dédié Kimsufi mais la manipulation devrait être globalement la même partout à partir du moment où le fournisseur permet de démarrer sur un linux rescue.

Vous pouvez aussi dans un premier temps, tester la manipulation chez vous dans une VM et utiliser SystemRescueCd (choisir rescue64 au boot) afin de tester cette procédure.

Pré-requis
Récupération de la configuration réseau
Partitionnement
Chiffrement et formatage
Installation
Création de l'initramfs intégrant OpenSSH
Redémarrage
Conclusion
Références et remerciements

1. Pré-requis

Avoir la possibilité de booter sur un linux rescue.

2. Récupération de la configuration réseau

Alpine Linux utilisant ifupdown, vous devrez déjà installer une distribution l'utilisant aussi, par exemple Debian afin de récupérer les fichiers de configuration /etc/network/interfaces et /etc/resolv.conf.

Des lignes de commandes valent mieux qu'un long discours :

[user@local ?]$ cd ~
[user@local ~]$ mkdir cfg_save
[user@local ~]$ cd cfg_save/
[user@local cfg_save]$ sftp root@ip
sftp> get /etc/network/interfaces
sftp> get /etc/resolv.conf
sftp> bye

Ceci est la base et vous n'avez normalement besoin de rien d'autre.

Il n'y a normalement rien à modifier dans ~/cfg_save/interfaces, mais on peut légèrement l'épurer et supprimer les commentaires, ce qui donne chez moi :

auto lo
iface lo inet loopback

auto eth0
iface eth0 inet static
    address 5.135.XXX.XXX
    netmask 255.255.255.0
    broadcast 5.135.XXX.255
    gateway 5.135.XXX.254

iface eth0 inet6 static
    address 2001:XXXX:XXXX:XXXX::1
    netmask 128
    dns-nameservers 2001:XXXX:X:XXX::1
    post-up sleep 5; /sbin/ip -family inet6 route add 2001:XXXX:XXXX:XXXX:ff:ff:ff:ff dev eth0
    post-up sleep 5; /sbin/ip -family inet6 route add default via 2001:XXXX:XXXX:XXXX:ff:ff:ff:ff
    pre-down /sbin/ip -family inet6 route del default via 2001:XXXX:XXXX:XXXX:ff:ff:ff:ff
    pre-down /sbin/ip -family inet6 route del 2001:XXXX:XXXX:XXXX:ff:ff:ff:ff dev eth0

On modifie le fichier de configuration ~/cfg_save/resolv.conf afin de supprimer les lignes inutiles comme nameserver 127.0.0.1 servant pour BIND qui est installé depuis le modèle d'origine et search ovh.net, ce qui donne chez moi :

nameserver 213.186.33.99

Vous devez aussi noter le module utilisé par la carte réseau étant donné qu'il faudra l'intégrer à l'initramfs par la suite. Vous pouvez récupérer cette information avec lspci -v ou encore lsmod

[root@serveur ~]# lspci -v
    [...]
    01:00.0 Ethernet controller: Intel Corporation 82574L Gigabit Network Connection
        DeviceName: Intel(R) 82574L Gigabit Ethernet Device
        Subsystem: Intel Corporation 82574L Gigabit Network Connection
        Flags: bus master, fast devsel, latency 0, IRQ 16
        Memory at d0400000 (32-bit, non-prefetchable) [size=128K]
        Memory at d0000000 (32-bit, non-prefetchable) [size=4M]
        I/O ports at 2000 [size=32]
        Memory at d0420000 (32-bit, non-prefetchable) [size=16K]
        Capabilities: [c8] Power Management version 2
        Capabilities: [d0] MSI: Enable- Count=1/1 Maskable- 64bit+
        Capabilities: [e0] Express Endpoint, MSI 00
        Capabilities: [a0] MSI-X: Enable+ Count=5 Masked-
        Capabilities: [100] Advanced Error Reporting
        Capabilities: [140] Device Serial Number 00-22-4d-ff-ff-ad-ba-4d
        Kernel driver in use: e1000e
        Kernel modules: e1000e

Chez moi, il s'agit donc du module e1000e.

3. Partitionnement

Démarrage du serveur sur un linux rescue
Connexion en SSH avec les identifiants envoyés par email
Partitionnement du disque, notez l'utilisation de GPT et prenez l'habitude à ne plus utiliser MBR

Allons-y :

[user@local ~]$ ssh-keygen -R ip
[user@local ~]$ ssh root@ip
[root@serveur ~]# sgdisk -Z /dev/sda
[root@serveur ~]# parted /dev/sda
(parted) mklabel gpt
(parted) mkpart primary ext2 0% 200MB
(parted) mkpart primary 200MB -2GB
(parted) mkpart primary linux-swap -2GB 100%
(parted) quit

Vous pouvez adapter votre partitionnement comme bon vous semble, mais vous devrez adapter la suite.

Il faut maintenant définir le flag legacy_boot sur la partition 1 (/boot) et écrire gptmbr.bin dans les 440 premiers octets du disque.

L'emplacement de gptmbr.bin peut varier selon votre linux rescue, vous devrez sans doute adapter le chemin en fonction de ce que retourne find / -type f -iname 'gptmbr.bin' :

[root@serveur ~]# sgdisk /dev/sda --attributes=1:set:2
[root@serveur ~]# dd bs=440 count=1 if=/nfs/usr/lib/EXTLINUX/gptmbr.bin of=/dev/sda

Voici mon partitionnement :

[root@serveur ~]# parted /dev/sda print
    Model: ATA HGST HUS724020AL (scsi)
    Disk /dev/sda: 2000GB
    Sector size (logical/physical): 512B/512B
    Partition Table: gpt
    Disk Flags:
    Number  Start   End     Size    File system    Name     Flags
     1      1049kB  200MB   199MB   ext2           primary  legacy_boot
     2      200MB   1998GB  1998GB                 primary
     3      1998GB  2000GB  2000MB  linux-swap(v1) primary

Ce qui me donnera approximativement :

/boot : 200MB (ext2)
/     : 2TB (ext4 chiffré)
swap  : 2GB (swap)

4. Chiffrement et formatage

Il va falloir utiliser une méthode efficace et performante et afin de déterminer ça, nous utiliserons la commande suivante :

[root@serveur ~]# cryptsetup benchmark
    # Tests are approximate using memory only (no storage IO).
    PBKDF2-sha1       218453 iterations per second for 256-bit key
    PBKDF2-sha256     301661 iterations per second for 256-bit key
    PBKDF2-sha512     168907 iterations per second for 256-bit key
    PBKDF2-ripemd160  208050 iterations per second for 256-bit key
    PBKDF2-whirlpool   87148 iterations per second for 256-bit key
    argon2i       4 iterations, 170831 memory, 4 parallel threads (CPUs) for 256-bit key (requested 2000 ms time)
    argon2id      4 iterations, 171825 memory, 4 parallel threads (CPUs) for 256-bit key (requested 2000 ms time)
    #     Algorithm |       Key |      Encryption |      Decryption
            aes-cbc        128b        40.2 MiB/s        42.6 MiB/s
        serpent-cbc        128b        32.3 MiB/s        72.9 MiB/s
        twofish-cbc        128b        33.8 MiB/s        35.0 MiB/s
            aes-cbc        256b        31.1 MiB/s        32.0 MiB/s
        serpent-cbc        256b        32.3 MiB/s        73.0 MiB/s
        twofish-cbc        256b        33.8 MiB/s        35.0 MiB/s
            aes-xts        256b        41.7 MiB/s        42.2 MiB/s
        serpent-xts        256b        68.1 MiB/s        68.5 MiB/s
        twofish-xts        256b        34.1 MiB/s        34.8 MiB/s
            aes-xts        512b        31.4 MiB/s        31.8 MiB/s
        serpent-xts        512b        68.0 MiB/s        68.4 MiB/s
        twofish-xts        512b        34.1 MiB/s        34.8 MiB/s

Vous ne rêvez pas, les performances sont désastreuses étant donné que mon microprocesseur est un Atom N2800 et qu'il ne possède pas le jeu d'instruction AES-NI.

Chiffrement de la partition /dev/sda2 :

[root@serveur ~]# cryptsetup -v -c serpent-xts-plain64 -s 512 --hash sha512 luksFormat /dev/sda2
[root@serveur ~]# cryptsetup luksOpen /dev/sda2 root

Si votre microprocesseur possède le jeu d'instruction AES-NI, il faudra généralement utiliser aes-xts et une clé 256 bit afin d'avoir d'excellentes performances :

[root@serveur ~]# cryptsetup -v -c aes-xts-plain64 -s 256 --hash sha256 luksFormat /dev/sda2
[root@serveur ~]# cryptsetup luksOpen /dev/sda2 root

On peut formater :

[root@serveur ~]# mkfs.ext2 -m0 /dev/sda1
[root@serveur ~]# mkfs.ext4 -m0 /dev/mapper/root
[root@serveur ~]# mkswap /dev/sda3

Vous pouvez utiliser LVM, choisir XFS, faire du thin provisioning, mais vous devrez adapter la suite.

5. Installation

On monte les partitions :

[root@serveur ~]# mkdir /mnt/alpine
[root@serveur ~]# mount -t ext4 /dev/mapper/root /mnt/alpine
[root@serveur ~]# mkdir /mnt/alpine/boot
[root@serveur ~]# mount -t ext2 /dev/sda1 /mnt/alpine/boot

Pour l'installation, vous devrez utiliser la dernière version stable et adapter les versions d'Alpine Linux et d'apk-tools-static. Vous pouvez déterminer ceci sur cette page en utilisant les listes déroulantes :

[root@serveur ~]# mkdir /tmp/workspace
[root@serveur ~]# cd /tmp/workspace/
[root@serveur workspace]# curl -O https://dl-3.alpinelinux.org/alpine/v3.8/main/x86_64/apk-tools-static-2.10.1-r0.apk
[root@serveur workspace]# tar zxf apk-tools-static-2.10.1-r0.apk
[root@serveur workspace]# ./sbin/apk.static -X https://dl-3.alpinelinux.org/alpine/v3.8/main -U --allow-untrusted --root /mnt/alpine --initdb add alpine-base
[root@serveur workspace]# echo 'https://dl-3.alpinelinux.org/alpine/v3.8/main' > /mnt/alpine/etc/apk/repositories
[root@serveur workspace]# mount -t proc none /mnt/alpine/proc
[root@serveur workspace]# mount -o bind /sys /mnt/alpine/sys
[root@serveur workspace]# mount -o bind /dev /mnt/alpine/dev

Vous devez maintenant restaurer les fichiers ~/cfg_save/interfaces et ~/cfg_save/resolv.conf sauvegardés plus tôt :

[user@local cfg_save]$ sftp root@ip
sftp> put interfaces /mnt/alpine/etc/network/
sftp> put resolv.conf /etc/
sftp> bye

Vous pouvez maintenant chroot dans votre futur système :

[root@serveur ~]# chroot /mnt/alpine /bin/sh -l

Définition du password root :

[root@serveur /]# passwd

Installation du kernel linux-vanilla et de syslinux :

[root@serveur /]# apk add linux-vanilla syslinux
[root@serveur /]# extlinux -i /boot

Installation d'OpenSSH et génération des clés :

[root@serveur /]# setup-sshd
[root@serveur /]# ssh-keygen -A

Minimum vital pour démarrer :

[root@serveur /]# rc-update add devfs sysinit
[root@serveur /]# rc-update add dmesg sysinit
[root@serveur /]# rc-update add hwdrivers sysinit
[root@serveur /]# rc-update add mdev sysinit
[root@serveur /]# rc-update add modules boot
[root@serveur /]# rc-update add networking boot
[root@serveur /]# rc-update add swap boot
[root@serveur /]# rc-update add urandom boot

Récupération des UUID, vous devrez en toute logique adapter la suite avec les vôtres :

[root@serveur /]# blkid
    /dev/sda1: UUID="b2e5f196-08b8-4498-b55b-5827378dfc69" TYPE="ext2" PARTLABEL="primary" PARTUUID="23fc3817-3064-4a0a-9954-820bb59362c0"
    /dev/sda2: UUID="cc3d08ba-c565-4ec4-9fa9-9040892a315b" TYPE="crypto_LUKS" PARTLABEL="primary" PARTUUID="87162993-7565-4f21-a73b-3d951cf0d18e"
    /dev/sda3: UUID="fab296b1-bdce-479e-86bc-0efb3918b0ab" TYPE="swap" PARTLABEL="primary" PARTUUID="89b18f33-4273-4f3e-ba9c-ff93a1bd7aac"
    /dev/mapper/root: UUID="4192b64d-e9b8-4f31-851b-fdc1b87ab148" TYPE="ext4"

Modification de /etc/fstab :

UUID=4192b64d-e9b8-4f31-851b-fdc1b87ab148 /     ext4 rw,noatime,nodiratime 0 1
UUID=b2e5f196-08b8-4498-b55b-5827378dfc69 /boot ext2 rw,noatime,nodiratime 0 2
UUID=fab296b1-bdce-479e-86bc-0efb3918b0ab swap  swap defaults              0 0

Modification de /etc/update-extlinux.conf, n'oubliez pas d'utiliser le module que vous avez déterminé plus tôt concernant votre carte réseau, chez moi c'est e1000e :

[...]
default_kernel_opts="quiet rootfstype=ext4 cryptroot=UUID=cc3d08ba-c565-4ec4-9fa9-9040892a315b cryptdm=root openssh ip=5.135.XXX.XXX::5.135.XXX.254:255.255.255.0::eth0"
[...]
modules=sd-mod,usb-storage,ext4,e1000e
[...]
root=UUID=4192b64d-e9b8-4f31-851b-fdc1b87ab148
[...]

Répercussion des modifications ci-dessus dans /boot/extlinux.conf grâce à la commande suivante :

[root@serveur /]# update-extlinux

Modification de /etc/mkinitfs/mkinitfs.conf, n'utilisez pas ma liste mais ajoutez simplement network openssh cryptsetup à la vôtre, ce qui donne chez moi :

features="ata base cdrom ext4 keymap kms mmc raid scsi usb virtio network openssh cryptsetup"

Création du fichier /etc/crypttab :

root UUID=cc3d08ba-c565-4ec4-9fa9-9040892a315b none luks

Ajout d'un utilisateur :

[root@serveur /]# adduser -g '' -s /bin/ash CHANGEME

6. Création de l'initramfs intégrant OpenSSH

Récupération de la configuration basée sur /usr/share/mkinitfs/initramfs-init légèrement remaniée afin d'intégrer OpenSSH :

[root@serveur /]# cd
[root@serveur ~]# wget https://gitea.tetsumaki.net/tetsumaki/alpine-initramfs-openssh/archive/master.tar.gz
[root@serveur ~]# tar zxf master.tar.gz
[root@serveur ~]# rm -f master.tar.gz
[root@serveur ~]# cp -a alpine-initramfs-openssh/* /
[root@serveur ~]# rm -rf alpine-initramfs-openssh*

Comparaison des versions entre l'original et le modifié :

[root@serveur ~]# cat /usr/share/mkinitfs/initramfs-init /usr/local/share/initramfs-init-openssh/initramfs-init-openssh | grep 'VERSION='
    VERSION=3.3.0-r1
    VERSION=3.3.0-r1

Si la version diffère, il suffira d'en créer un nouveau (explication plus bas).

Ajoutez votre clé publique dans le fichier /usr/local/share/initramfs-init-openssh/conf/authorized_keys :

command="/etc/ssh/unlock_disk.sh" ssh-ed25519 changemykey changeme@domain.tld

Vous pouvez modifier le fichier /usr/local/share/initramfs-init-openssh/conf/sshd_config si vous souhaitez :

Port 22
LogLevel QUIET
PermitRootLogin yes
MaxSessions 1
AuthorizedKeysFile /etc/ssh/authorized_keys
PasswordAuthentication no
ChallengeResponseAuthentication no
AllowAgentForwarding no
AllowTcpForwarding no
PrintMotd no
AllowUsers root
KexAlgorithms curve25519-sha256@libssh.org,diffie-hellman-group-exchange-sha256
Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes256-ctr
MACs umac-128-etm@openssh.com,hmac-sha2-512-etm@openssh.com,hmac-sha2-512

Création de l'initramfs :

[root@serveur ~]# mkinitfs -i /usr/local/share/initramfs-init-openssh/initramfs-init-openssh $(ls /lib/modules)

Si la version entre vos fichiers /usr/share/mkinitfs/initramfs-init et /usr/local/share/initramfs-init-openssh/initramfs-init-openssh diffère, il vous suffira de le créer vous-même, c'est très simple et seulement 3 points sont ajoutés :

[root@serveur ~]# cp /usr/share/mkinitfs/initramfs-init /usr/local/share/initramfs-init-openssh/initramfs-init-openssh
[root@serveur ~]# vi /usr/local/share/initramfs-init-openssh/initramfs-init-openssh

Ajout de la fonction setup_openssh() sous setup_nbd() :

setup_openssh() {
    mv /usr/local/share/initramfs-init-openssh/conf/* /etc/ssh/
    mkdir -p /var/empty
    /usr/sbin/sshd -D -q
    [ -b /dev/mapper/${KOPT_cryptdm} ] || return 1
}

Ajout d'openssh dans la variable myopts où l'on va modifier :

myopts="alpine_dev autodetect autoraid chart cryptroot cryptdm cryptheader cryptoffset
    cryptdiscards cryptkey debug_init dma init_args keep_apk_new modules ovl_dev
    pkgs quiet root_size root usbdelay ip alpine_repo apkovl alpine_start splash
    blacklist overlaytmpfs rootfstype rootflags nbd resume s390x_net dasd ssh_key"

Par :

myopts="alpine_dev autodetect autoraid chart cryptroot cryptdm cryptheader cryptoffset
    cryptdiscards cryptkey debug_init dma init_args keep_apk_new modules ovl_dev
    pkgs quiet root_size root usbdelay ip alpine_repo apkovl alpine_start splash
    blacklist overlaytmpfs rootfstype rootflags nbd resume s390x_net dasd ssh_key openssh"

Ajout de l'appel à OpenSSH où l'on va modifier :

if [ -n "$KOPT_cryptroot" ]; then

Par :

if [ -n "$KOPT_openssh" ] && [ -n "$KOPT_cryptroot" ]; then
    configure_ip
    setup_openssh || echo "Failed to uncrypt root via ssh"
elif [ -n "$KOPT_cryptroot" ]; then

Voici ce que donne un diff pour la version 3.3.0-r1 :

--- initramfs-init
+++ initramfs-init-openssh
@@ -269,6 +269,13 @@
    [ "$n" != 0 ] || return 1
 }

+setup_openssh() {
+   mv /usr/local/share/initramfs-init-openssh/conf/* /etc/ssh/
+   mkdir -p /var/empty
+   /usr/sbin/sshd -D -q
+   [ -b /dev/mapper/${KOPT_cryptdm} ] || return 1
+}
+
 # read the kernel options. we need surve things like:
 #  acpi_osi="!Windows 2006" xen-pciback.hide=(01:00.0)
 set -- $(cat /proc/cmdline)
@@ -276,7 +283,7 @@
 myopts="alpine_dev autodetect autoraid chart cryptroot cryptdm cryptheader cryptoffset
    cryptdiscards cryptkey debug_init dma init_args keep_apk_new modules ovl_dev
    pkgs quiet root_size root usbdelay ip alpine_repo apkovl alpine_start splash
-   blacklist overlaytmpfs rootfstype rootflags nbd resume s390x_net dasd ssh_key"
+   blacklist overlaytmpfs rootfstype rootflags nbd resume s390x_net dasd ssh_key openssh"

 for opt; do
    case "$opt" in
@@ -383,7 +390,10 @@
 fi
 eend 0

-if [ -n "$KOPT_cryptroot" ]; then
+if [ -n "$KOPT_openssh" ] && [ -n "$KOPT_cryptroot" ]; then
+   configure_ip
+   setup_openssh || echo "Failed to uncrypt root via ssh"
+elif [ -n "$KOPT_cryptroot" ]; then
    cryptopts="-c ${KOPT_cryptroot}"
    if [ "$KOPT_cryptdiscards" = "yes" ]; then
        cryptopts="$cryptopts -D"

7. Redémarrage

Vous avez normalement tout configuré et pour résumer, vous devez controler que :

/etc/mkinitfs/mkinitfs.conf : avoir ajouté network openssh cryptsetup
/etc/update-extlinux.conf : avoir correctement configuré module, ip, uuid
/usr/local/share/initramfs-init-openssh/conf/authorized_keys : votre clé publique soit bien présente
/usr/local/share/initramfs-init-openssh/initramfs-init-openssh : variable VERSION identique à /usr/share/mkinitfs/initramfs-init, vous pouvez créer ce fichier vous même

Le moment de vérité, sortez du chroot et redémarrez :

[root@serveur ~]# exit
[root@serveur ~]# reboot

Si tout va bien, vous pouvez vous connecter et vous aurez un prompt passphrase afin de déchiffrer la partition :

[user@local ~]$ ssh root@ip
    Enter passphrase for /dev/sda2:

Vous perdez maintenant la connexion ssh, vous pouvez vous reconnecter et terminer la configuration du système :

[user@local ~]$ ssh user@ip
[user@serveur ~]$ su -
[root@serveur ~]# setup-alpine

Vous devrez ignorer les étapes setup-interfaces et setup-disk, ce qui donne pour moi :

Available keyboard layouts: fr
Select variant []: fr-latin9
Enter system hostname (short form, e.g. 'foo') [maki]: changeme
Which one do you want to initialize? (or '?' or 'done') [eth0] done
Do you want to do any manual network configuration? [no]
DNS domain name? (e.g 'bar.com') []
DNS nameserver(s)? [213.186.33.99]
Changing password for root
New password:
Retype password:
Which timezone are you in? ('?' for list) [UTC] Europe/Paris
HTTP/FTP proxy URL? (e.g. 'http://proxy:8080', or 'none') [none]
Enter mirror number (1-39) or URL to add (or r/f/e/done) [f]: 5
Which SSH server? ('openssh', 'dropbear' or 'none') [openssh]
Which NTP client to run? ('busybox', 'openntpd', 'chrony' or 'none') [chrony]
Which disk(s) would you like to use? (or '?' for help or 'none') [none]
Enter where to store configs ('floppy', 'usb' or 'none') [none]:
Enter apk cache directory (or '?' or 'none') [/var/cache/apk]:

Un dernier redémarrage :

[root@serveur ~]# reboot

8. Conclusion

Votre système est maintenant installé.

Attention, lorsque vous effectuerez une mise à jour, si l'initramfs est mis à jour lors d'un apk upgrade par exemple, vérifiez si vous ne devez pas recréer le fichier /usr/local/share/initramfs-init-openssh/initramfs-init-openssh comme expliqué précédemment. Suite à cela et dans tous les cas, vous devrez reconstruire l'initramfs :

[root@serveur ~]# mkinitfs -i /usr/local/share/initramfs-init-openssh/initramfs-init-openssh $(ls /lib/modules)

Si votre système ne répond plus ou que vous ne pouvez pas y accéder par SSH c'est que vous avez mal fais quelque chose.

Dans ce cas vous pouvez faire un reboot hardware en rescue et voir ce qui cloche en chrootant, il pourra sans doute s'agir d'un problème dans un des fichiers de configuration, des clés OpenSSH non générées, d'un problème avec syslinux, etc...

Il est fortement conseillé de configurer OpenSSH avec un système de clé publique/privée
D'installer iptables et ip6tables puis de créer vos règles