ArchLinux auf einem Laptop installieren (mit Verschlüsselung)

In diesem Blogpost möchte ich zeigen, wie ich ArchLinux auf einem Laptop installiere. Hierbei erfolgt die Installation auf eine verschlüsselte Partition, was bei tragbaren Geräten empfehlenswert ist. So fallen keine Daten in falsche Hände, falls das Gerät geklaut oder vergessen wird.

Image auf Stick flashen

• Lade dir ein aktuelles Arch-Image herunter, siehe https://archlinux.org/download/
• Stecke einen USB-Stick in dein Gerät und checke dessen /dev/-Adresse mittels

$ lsblk

Das kann dann z.B. so aussehen:

NAME            MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS  
sda             259:0    0 931,5G  0 disk
sdb               8:0    1   7,4G  0 disk 

In diesem Beispiel ist sda die Festplatte, und sdb der USB-Stick. Bei euch kann das durchaus anders aussehen.

• Flashe das Arch-Image auf den Stick, z.B. mittels

$ dd if=archlinux*.iso of=/dev/sdb

wobei sdb bei euch evtl. entsprechend angepasst werden muss.

booten vom Stick

Stecke den Stick in den Laptop, und wähle beim Starten den Stick als Bootquelle aus. Bei mir funktioniert das, indem ich F12 beim Starten gedrückt halte.

Es sollte sich recht bald das Arch-Bootmenu melden

Wähle den ersten Eintrag aus und warte, bis dich die Kommandozeile begrüßt.

Netzwerkverbindung herstellen

Ist Arch gestartet, stellen wir als erstes eine Netzwerkverbindung her. Das Netzwerk brauchen wir, um frische Installationspakete zu holen, aber auch, um uns gleich per SSH auf die neue Kiste einzuloggen.

LAN

Wenn ein LAN-Kabel bereit liegt, kann dieses einfach eingesteckt werden, und die Verbindung sollte direkt funktionieren.

WLAN

Möchtet ihr euch mit einem WLAN verbinden, geht dies am Einfachsten mit dem Befehl

$ iwctl

Um den WLAN-Devicenamen herauszufinden hilft der Befehl

$ devices list

Meistens heisst das Device wlan0.

Stelle eine Verbindung zum WLAN her mittels

$ station wlan0 connect <SSID>

Gib das Passwort des WLANs ein. Wenn alles fertig ist, verlasse das Proggi mittels

$ exit

SSH

Ich verbinde mich an dieser Stelle gerne mittels SSH auf den Laptop. Stelle sicher, dass sshd läuft,

$ systemctl start sshd

Setze ein temporäres Admin-Passwort mittels

$ passwd

Finde die IP-Adresse des Laptops heraus, zB mittels

$ ip a

Logge dich von einem anderen PC auf die neue Kiste ein mittels

$ ssh root@IP-ADRESSE

Partitionierung der Festplatte

Nun partitionieren wir die Festplatte. Wir wollen 2 Partitionen erstellen,

• eine EFI-Partition zum Booten,
• und eine verschlüsselte root-Partition für das Archsystem.

Zunächst finden wir wieder die /dev/-Bezeichnungen der Laptopfestplatte heraus mittels

$ lsblk

NAME            MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINTS
sda             259:0    0 931,5G  0 disk 
sdb               8:0    1   7,4G  0 disk  
├─sdb1            8:1    1   917M  0 part  
└─sdb2            8:2    1    15M  0 part  

In diesem Beispiel ist sda die Festplatte des Laptops und sdb der Boot-Stick. Wir wollen also /dev/sda partitionieren.

Starte gdisk mittels

$ gdisk /dev/sda

Wir können mit p schauen, welche Partitionen schon auf der Platte sind. Meine Platte ist neu und leer, und daher gibt es nichts zu sehen. Möchtet ihr eine bereits gebrauchte Festplatte benutzen, könnt ihr die vorhandenen Partitionen mittels d löschen.

Wir erstellen eine neue Partition mittels n.

• die erste Partition wird unsere Boot-Partition.
• die voreingestellte Partitionsnummer 1 ist korrekt, so dass wir einfach ENTER drücken können.
• ebenfalls korrekt ist der erste Sektor. Auch diesen können wir mittels ENTER bestätigen.
• beim “letzten Sektor” geben wir +512M ein, damit die Partition 512 MB groß wird.
• der Partitionscode im Hexformat lautet: ef00 (EFI-Partition)

Wir erstellen eine weitere Partition mittels n.

• diese zweite Partition soll die verschlüsselte Systempartition werden.
• die voreingestellte Partitionsnummer 2 ist korrekt, so dass wir einfach ENTER drücken können.
• ebenfalls korrekt ist der erste Sektor. Auch diesen können wir mittels ENTER bestätigen
• und auch der letzte Sektor ist korrekt, weil wir den gesamten Rest der Festplatte verwenden möchten. Wir können also einfach ENTER drücken können.
• der Partitionscode im Hexformat lautet: 8309 (LUKS-Partition)

Wir können mittels p überprüfen, ob alles richtig ist.

Zum Schluss schreiben wir die Partitionstabelle mittels w.

Verschlüsselung

Um sicher zu sein, dass alles klappen wird, laden wir die Encryption-Module

$ modprobe dm-crypt
$ modprobe dm-mod

Nun erstellen wir ein LUKS-LVM auf der root-Partition (/dev/sda2):

$ cryptsetup luksFormat -v -s 512 -h sha512 /dev/sda2

Hier geben wir unser gewünschtes Passwort ein und merken es uns!!!. Wenn ihr das Passwort vergesst, kommt ihr nicht mehr an eure Daten!!!

Jetzt können wir das Laufwerk mounten

$ cryptsetup open /dev/sda2 luks_lvm

(hier muss das Passwort eingegeben werden, welches wir soeben für die Partition erzeugt haben)

Volume Setup

Zunächst erstellen wir ein Volume und eine Volume-Gruppe

$ pvcreate /dev/mapper/luks_lvm
$ vgcreate arch /dev/mapper/luks_lvm

Wir benötigen auch ein SWAP-Volume. Als Faustregel gilt: RAM-Größe plus 2GB. Mein Laptop hat zB 8GB RAM, daher erstellen wir 10GB Swap mittels

$ lvcreate -n swap -L 10G arch

Den Rest der Platte verwenden wir für unser Arch-System

$ lvcreate -n root -l +100%FREE arch

Filesystems

Nun müssen die Partitionen formatiert werden.

Die EFI-Partition benötigt das Format FAT32:

$ mkfs.fat -F32 /dev/sda1 

Für die verschlüsselte root-Partition können wir z.B. btrfs oder ext4 verwenden. Ich persönlich begnüge mich mit ext4.

$ mkfs.btrfs -L root /dev/mapper/arch-root
# oder
$ mkfs.ext4 -L root /dev/mapper/arch-root

Nun formatieren wir noch unseren Swap:

$ mkswap /dev/mapper/arch-swap

Mounten

Zuerst mounten und aktivieren wir die SWAP-Partition

$ swapon /dev/mapper/arch-swap
$ swapon -a

Anschließend mounten wir die root-Partition nach /mnt:

$ mount /dev/mapper/arch-root /mnt

Unterhalb von /mnt erstellen wir das /boot-Verzeichnis:

mkdir -p /mnt/boot

Hierhin mounten wir die erzeugte boot Partiton (/dev/sda1)

$ mount /dev/sda1 /mnt/boot

Installiere ArchLinux

Nun ist es endlich an der Zeit gekommen, Archlinux zu installieren. Dieser Befehl bringt die essentiellen Pakete auf die neue Platte:

$ pacstrap -K /mnt base base-devel linux linux-firmware nano openssh

Wir erzeugen die fstab-Datei für unser neues System mittels:

$ genfstab -U -p /mnt > /mnt/etc/fstab

chroot in die Installation

Wir wechseln in unser neues System mittels:

$ arch-chroot /mnt /bin/bash

Hier können wir nun die grundlegenden Konfigurationen vornehmen.

Konfiguration

entschlüssele die Laufwerke

Damit Linux unsere Partition entschlüsseln kann, müssen wir die Datei mkinitcpio.conf anpassen.

Öffne mkinitcpio.conf

$ nano /etc/mkinitcpio.conf

und füge encrypt lvm2 zwischen die Hooks block und filesystem ein. Das sieht dann in etwa so aus:

HOOKS=(... block encrypt lvm2 filesystems fsck)

Wir müssen gleich noch weitere Änderungen an der Datei vornehmen, aber zunächst installieren wir den Volumemanager lvm2

$ pacman -S lvm2

Bootloader

Wir werden systemd-boot für unser System nutzen. Dafür benötigen wir noch ein paar Pakete:

$ pacman -S efibootmgr dosfstools gptfdisk

Zuerst installieren wir den EFI-Booteintrag per:

$ bootctl install

Jetzt müssen wir die UUID unserer verschlüsselten LUKS-Partition herausfinden. Da wir Partition /dev/sda2 verschlüsselt haben, erhalten wir dessen UUID per:

$ blkid /dev/sda2

Das sieht dann in etwa so aus:

/dev/sda2: UUID="272b13c4-ce78-47de-b04c-66210edb977d" TYPE="crypto_LUKS" PARTLABEL="Linux LUKS" PARTUUID="6b6b86e4-b8fe-4b7d-874d-96c67075b90c"

Die UUID lautet in unserem Beispiel also 272b13c4-ce78-47de-b04c-66210edb977d.

Mit diesem Wissen können wir die Datei /boot/loader/entries/arch-uefi.conf mit folgendem Inhalt erstellen:

$ nano /boot/loader/entries/arch-uefi.conf

title    Arch Linux
linux    /vmlinuz-linux
initrd   /initramfs-linux.img
options  root=/dev/mapper/arch-root cryptdevice=UUID=<uuid>:luks_lvm  locale=de_DE.UTF-8

In unserem Beispiel ändert sich die letzte Zeile in

options  root=/dev/mapper/arch-root cryptdevice=UUID=272b13c4-ce78-47de-b04c-66210edb977d:luks_lvm  locale=de_DE.UTF-8

Nun bearbeiten wir die Datei /boot/loader/loader.conf so, dass automatisch in unser Archsystem gebootet wird:

$ nano /boot/loader/loader.conf

default   arch-uefi
timeout   1

Keyfile

Optional können wir noch Keyfiles erstellen. Hierfür erzeugen wir ein eigenes Verzeichnis:

$ mkdir /secure

…und erstelle ein Keyfile für unserer root-Partition.

$ dd if=/dev/random of=/secure/root_keyfile.bin bs=512 count=8

Anschließend muss die Berechtigung geändert werden:

$ chmod 000 /secure/*

Jetzt können wir den Keyfile der Partition zuweisen:

$ cryptsetup luksAddKey /dev/sda2 /secure/root_keyfile.bin

(hier muss wieder das Passwort eingegeben werden, welches wir für die Partition erzeugt haben)

Den Schlüssel müssen wir noch für Linux bekanntmachen:

$ nano /etc/mkinitcpio.conf

Unter FILES fügen wir den Pfad auf den Keyfile hinzu:

FILES=(/secure/root_keyfile.bin)

…und erstellen Linux neu:

$ mkinitcpio -p linux

Systemkonfiguration

Zeit für ein paar weitere Systemkonfigurationen.

Timezone

Unsere Zeitzone ist Europe/Berlin.

$ ln -sf /usr/share/zoneinfo/Europe/Berlin /etc/localtime

NTP

Mittels NTP holen wir uns die aktuelle Zeit aus dem Netz

$ nano /etc/systemd/timesyncd.conf

Folgende NTP Server können wir verwenden.

[Time]
NTP=0.arch.pool.ntp.org 1.arch.pool.ntp.org 2.arch.pool.ntp.org 3.arch.pool.ntp.org 
FallbackNTP=0.pool.ntp.org 1.pool.ntp.org

Jetzt kann NTP aktiviert werden

$ systemctl enable systemd-timesyncd.service

Locale

Wir stellen die Sprache auf “deutsch”. Hierfür öffnen wir /etc/locale.gen

$ nano /etc/locale.gen

und kommentieren die Zeile mit de_DE.utf8 aus.

#de_CH ISO-8859-1
de_DE.UTF-8 UTF-8
#de_DE ISO-8859-1
#de_DE@euro ISO-8859-15

Jetzt erzeugen wir alle lokalen Sprachdateien

$ locale-gen

…und schreiben es auch noch in /etc/locale.conf

$ nano /etc/locale.conf

LANG=de_DE.UTF-8

virtuelle und TTY Konsolen

Damit auch die virtuellen Tastaturen auf deutsch eingestellt sind, gebe ich noch ein:

$ echo KEYMAP=de-latin1-nodeadkeys > /etc/vconsole.conf
$ localectl --no-convert set-x11-keymap de pc105 deadgraveacute
$ localectl --no-convert set-keymap de-latin1-nodeadkeys

Wir können die Einstellungen noch überprüfen mit

$ localectl status

Die Ausgabe sollte so aussehen:

System Locale: LANG=de_DE.UTF-8
    VC Keymap: de-latin1-nodeadkeys
   X11 Layout: de
    X11 Model: pc105
  X11 Variant: deadgraveacute

Beim nächsten Neustart ist das Tastaturlayout auch für TTY auf deutsch.

Hostname

Mein Laptop soll “Norbert” heissen.

$ echo "Norbert" > /etc/hostname

Users

Bislang waren wir als root unterwegs. Erzeugen wir uns also einen neuen Benutzer “produnis” mit sudo-Rechten

$ useradd -m -G wheel -s /bin/bash produnis

und vergeben ein Passwort für diesen User mittels

$ passwd produnis

Damit “produnis” sudo-Rechte bekommt, führen wir folgenden Befehl aus

$ EDITOR=nano visudo

und kommentieren die folgende Zeile aus:

%wheel ALL=(ALL:ALL) ALL

Damit unsere sudo-Befehle nicht aus-timen, kann am Ende der Datei noch hinzugefügt werden:

Defaults passwd_timeout=0

Netzwerk

Damit wir beim Neustart Netzwerk haben, installieren und aktivieren wir den Networkmanager.

$ pacman -S networkmanager
$ systemctl enable NetworkManager

Damit auch ssh funktioniert, ergänzen wir

$ systemctl enable sshd

Microcode

Es wird empfohlen, die Micorcodes entsprechend eurer CPU zu installieren.

# Für AMD
$ pacman -S amd-ucode
# ODER
# Für Intel
$ pacman -S intel-ucode

Desktop

An dieser Stelle sind wir eigentlich schon fertig und können zum ersten Mal neustarten. Ich installiere aber noch einen Desktop und Login-Manager, damit ich direkt auf einer graphischen Oberfläche loslegen kann. Ich selbst verwende am liebsten KDE (also Plasma) mit Wayland (ihr könnt aber auch GNOME oder XFCE installieren). Für eine minimale Installation wähle ich

$ pacman -S plasma-desktop plasma-wayland-session  kde-applications  sddm sddm-kcm plasma-nm

Ich bestätige immmer die Vorauswahl, falls Pacman fragt.

Zum Schluss aktiviere ich noch den Loginmanager sddm

$ systemctl enable sddm

Fertig, Zeit für einen Reboot.

Reboot

Zunächst verlassen wir die chroot-Umgebung und unmounten die Partitionen.

$ exit
$ umount -R /mnt
$ reboot now

Bei mir meldet sich nach dem Start nun das UEFI-Bootmenu, welches nach 2 Sekunden Archlinux bootet. Hier werde ich nach dem Verschlüsslungspasswort gefragt. Anschließend meldet sich der sddm-Loginbildschirm, und ich kann meine Plasmasession starten.

Deutsches Tastaturlayout

Noch ist die KDE-Tastatur nicht auf deutsch eingestellt. Hierfür geht ihr in die Systemeinstellungen, und wählt unter “Tastaur” den Reiter “Belegungen”.

Setzt den Haken bei “Belegungen einrichten” und fügt “Deutsch” hinzu. Sobald ihr unten auf “Anwenden” klickt, ist die Tastatur auf deutsches Layout eingestellt.

…what if?

Falls doch etwas schief laufen sollte, und ihr z.B. nicht ins System booten könnt, stellt ihr wie folgt wieder die chroot-Umgebung her:

• boote vom USB-Stick, so wie oben beschrieben
• cryptsetup open /dev/sda2 luks_lvm
• mount /dev/mapper/arch-root /mnt
• mount /dev/sda1 /mnt/boot
• arch-chroot /mnt /bin/bash

Jetzt liegt es aber an euch, den Fehler zu finden… ;)

Weblinks

• https://wiki.archlinux.de/title/Anleitung_f%C3%BCr_Einsteiger
• https://github.com/dreamsofautonomy/arch-from-scratch
• https://www.youtube.com/watch?v=YC7NMbl4goo

Diskussion per Matrix unter https://matrix.to/#/#produnis-blog:tchncs.de