Nach der Einrichtung des Servers bekommt man normalerweise das Passwort für den ssh-Zugang per Mail geschickt. Damit kann man sich z.B. von einem Linux-Computer mit dem Terminal-Programm am Server anmelden.
Wenn dieser Befehl für den Server das erste mal ausgeführt wird, muss man mit `yes` bestätigen, dass der "Fingerprint" des Server-Schlüssels in die Liste der bekannten Server aufgenommen werden soll:
Zunächst sollte überprüft werden, ob alle Software-Pakete aktuell sind. Bei der Anmeldung bekommt man zwar schon einen entsprechenden Hinweis, der muss aber nicht aktuell sein, je nachdem, wann das letzte mal nach Updates gesucht wurde. Mit den folgenden Befehlen kann die Überprüfung durchgeführt und eventuelle Updates eingespielt werden.
Viele Linux-Admins benötigen für die Verwaltung eines Servers kaum zusätzliche Programme und erledigen alles an der SSH-Konsole mit den standardmäßig installierten Tools (vi, nano,...). Wer nicht jeden Tag auf der Linux-Konsole unterwegs ist, kommt mit einem Datei-Explorer schneller zurecht. Dafür bietet sich das Programm "Midnight-Commander" an, welches sich folgendermaßen installieren lässt:
Gestartet wird der Commander einfach mit dem Befehl `mc`. In einer 2-Fenster Ansicht (Wechsel mit "Tab"-Taste) kann man sich nun mit den Pfeil-Tasten und "Enter" durch das Dateisystem bewegen und z.B. Dateien mit der Taste "F3" anschauen oder mit "F4" bearbeiten. Beim ersten Bearbeiten muss man sich noch für einen Editor entscheiden, der dann immer beim Drücken von "F4" verwendet werden soll.
Der Benutzer "root" hat alle Rechte auf dem Server und muss gut gesichert werden. Bei der Installation des Servers wird zwar automatisch ein starkes, zufälliges root-Passwort generiert, aber das wird erstens unverschlüsselt per Mail verschickt und zweitens im Server-Control-Panel des Hosters gespeichert. Sollte ein Angreifer Zugang zu einem von beiden erlangen, ist der Server damit kompromittiert.
Es ist daher ratsam, das initiale root-Passwort durch ein eigenes, starkes Passwort zu ersetzen. Ein zufälliges Passwort kann man unter Linux mit verschiedenen Programmen erstellen. Hier werden nur 2 Beispiele vorgestellt.
Der folgende Befehl erzeugt ein zufälliges, 15-stelliges Passwort an der Linux-Konsole:
Mit dem Befehl `pwgen --help` kann man sich die möglichen Parameter und deren Bedeutung anschauen. Ein besonders starkes, zufälliges Passwort mit Sonderzeichen erzeugt man mit dem Befehl:
### Tastatur- und Spracheinstellungen anpassen (optional)
Bei manchen Server-Images sind Sprache und Region bereits voreingestellt und es muss nichts weiter getan werden. Wenn man im SSH-Terminal z.B. deutsche Sonderzeichen eintippt (ä,ö,...) und diese werden nicht richtig dargestellt, dann muss die Spracheinstellung angepasst werden.
Sollte die Zeit nicht stimmen (um exakt 1 oder mehrere Stunden abweichen), muss noch die Zeitzone eingestellt werden. Das erledigt man mit dem folgenden Befehl:
Die Änderung der Zeitzone wird sofort übernommen. Um die geänderten Sprach-/Tastatureinstellungen zu aktivieren, muss man sich von der Konsole ab- und wieder anmelden.
## SSH-Zugang sichern
Der SSH-Zugang ist das wichtigste Instrument, um den Server zu verwalten. Dementsprechend ist er auch ein beliebtes Angriffsziel und sollte unbedingt sorgfältig gesichert werden. Das erfolgt in mehreren Schritten.
Normalerweise ist der SSH-Server so eingestellt, dass er an Port 22 auf eingehende Verbindungen wartet. Das wissen natürlich auch alle Hacker und Spammer. Wenn ein neuer Server mit einer öffentlichen IP-Adresse eingerichtet wird, dauert es meist nicht lange, bis man in den Log-Dateien erste gescheiterte Verbindungsversuche findet, weil irgendwer versucht, sich Zugang zu verschaffen. Mit einem starken Passwort sollte das eigentlich nicht gelingen, aber es erzeugt immerhin unnötigen Datenverkehr und Log-Einträge.
Es ist daher empfehlenswert, den Port des SSH-Servers zu ändern, um damit einen großen Teil der Angriffsversuche auszuschließen. Auf Wikipedia findet man eine [Liste der standardisierten Ports](https://de.wikipedia.org/wiki/Liste_der_standardisierten_Ports), aus der man entnehmen kann, dass die Ports 49152-65535 für diesen Zweck genutz werden können.
Um den Port zu ändern, wird die Datei `/etc/ssh/sshd_config` bearbeitet. Im Ausgangszustand ist die entsprechende Zeile meistens auskommentiert, da Port 22 als Standard gesetzt ist. In dem Fall muss "#" am Anfang der Zeile entfernt, und der neue Port eingetragen werden (in diesem Beispiel 54683).
Eine weitere Sicherheitsebene wird eingebaut, indem man dem Benutzer "root" den direkten Zugang per SSH verbietet. Sollte sich ein Angreifer Zugang zum System über SSH verschaffen, hat er dann nur eingeschränkte Möglichkeiten, bzw. müsste zusätzlich noch das Passwort von "root" herausfinden, um alle Rechte zu erlangen.
Es wird daher empfohlen, einen neuen Benutzer anzulegen, der dann Zugang über SSH bekommt.
Normalerweise müssen Angreifer nach dieser Änderung nicht nur das Passwort, sondern auch den Benutzernamen "erraten". Daher sollten hier übliche Administrator-Namen wie "Admin", "Administrator",... vermieden werden.
Jetzt wird die ssh-Konfiguration so geändert, dass sich der Benutzer "root" nicht mehr direkt anmelden darf. Dazu wird ein entsprechender Eintrag entweder auf "no" gesetzt, oder als Kommentar deklariert.
=== "/etc/ssh/sshd_config"
```sh hl_lines="10"
...
# Example of overriding settings on a per-user basis
#Match User anoncvs
# X11Forwarding no
# AllowTcpForwarding no
# PermitTTY no
# ForceCommand cvs server
PasswordAuthentication yes
#PermitRootLogin yes
...
```
Dann noch einmal:
```bash
service ssh restart
```
Von nun an muss bei der Anmeldung per SSH der zuvor angelegte Benutzername mit angegeben werden.
Nach der Anmeldung erscheint der neue Benutzername auch in der Eingabeaufforderung. Wenn man jetzt administrative Aufgaben am Server durchführen will, kann man dann mit einem entsprechenden Befehl zum Benutzer "root" wechseln und muss dessen Passwort eingeben. Dadurch hat man jetzt eine zusätzliche Sicherheitsebene.
Eine der sichersten Möglichkeiten, den Server per ssh-Zugang zu erreichen, ist das sogenannte "Public-Key-Verfahren". Dazu wird auf dem Computer, von dem aus der Server erreicht werden soll, ein Schlüsselpaar erzeugt und dessen öffentlicher Teil auf den Server kopiert. Der ssh-Server wird dann so konfiguriert, dass sich der Benutzer mit der Schlüssel-Authentifizierung anmelden kann, ohne dabei das Passwort eingeben zu müssen. Die Anmeldung ist dann nur von dem Gerät aus möglich, auf dem der Schlüssel gespeichert ist.
!!! warning "Achtung"
Auf transportablen Geräten sollte die Schlüsseldatei mit einem Passwort geschützt werden.
#### Vorbereitung am Client (Ubuntu-PC)
Ein Schlüsselpaar mit `ssh-keygen` erstellen:
```
~$ ssh-keygen -b 4096
Generating public/private rsa key pair.
Enter file in which to save the key (/home/user/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/user/.ssh/id_rsa.
Your public key has been saved in /home/user/.ssh/id_rsa.pub.
#### Den öffentlichen Teil des Schlüssels auf den Server übertragen
Das Übertragen des öffentlichen Schlüssels auf den Server erfolgt noch mittels Passwort-Authentifizierung. Wenn später ein weiterer Client für dieses Verfahren eingerichtet werden soll, muss die ssh-Konfiguration vorübergehend auf dieses Verfahren umgestellt werden. Als Werkzeug für die Schlüssel-Übertragung dient das Programm `ssh-copy-id`. Als zusätzlicher Parameter ist der Port anzugeben, der vorher für den ssh-Zugang zum Server festgelegt wurde.
Wenn man es noch komfortabler haben möchte, kann man sich am Client-PC ein Lesezeichen für den ssh-Server anlegen. Dazu wird die Datei `home/user/.ssh/config` angelegt, bzw. geändert:
Für einen sicheren Server ist eine Firewall unverzichtbar. Im proffessionellen Bereich wird meistens mit einer Hardware-Firewall (also ein eigener Computer mit mehreren Netzwerk-Interfaces) oder einer Firewall-VM gearbeitet. Für kleinere Installationen reicht aber meistens die integrierte Linux-Firewall aus. Dabei gibt es wiederum mehrere Möglichkeiten, diese zu verwalten. Eine der einfachsten Möglichkeiten ist "ufw" - ein Programm, mit dem man unter Ubuntu schnell und unkompliziert Regeln erstellen kann. Leider funktioniert das nicht immer wie gewünscht (z.B. bei der Verwendung von Docker). Hier wird daher die Verwendung von `iptables` bzw. `ip6tables` beschrieben. Obwohl bereits ein Nachfolger von iptables existiert (nftables), werden hier die "alten" Regeln verwendet, da diese weit verbreitet und gut dokumentiert sind. Sofern IPV4 und IPV6 aktiv sind (standard bei root-Servern), müssen die Regeln immer für beide Protokolle gesetzt werden.
Eine komplette Beschreibung von `iptaples` würde an dieser Stelle zu weit führen. In den [Quellenangaben](#quellen) sind einige hilfreiche Artikel dazu verlinkt. Besonders hervorzuheben wäre dabei: [https://de.wikibooks.org/wiki/Linux-Praxisbuch/_Linux-Firewall_mit_IP-Tables](https://de.wikibooks.org/wiki/Linux-Praxisbuch/_Linux-Firewall_mit_IP-Tables).
Zunächst sollte sichergestellt werden, dass "ufw" nicht aktiv ist:
```
root@srv:/home/sshuser# ufw status
Status: Inaktiv
```
Gegebenenfalls deaktivieren:
```
ufw disable
```
### Firewallregeln dauerhaft speichern
Die Regleln, welche mit `iptables` und `ip6tables` erstellt werden, gelten normalerweise nur zur Laufzeit des Servers, also bis zum nächsten Neustart. Das ist eine gewisse Schutzfunktion gegen Fehleingaben, die das System komplett von außen abschotten und damit unbrauchbar machen würden. Dann wäre das System nach einem Neustart über das Server-Control-Panel wieder erreichbar.
Damit man dann nicht alle Regeln neu eingeben muss, gibt es die Programme `iptables-save` und `ip6tables-save` bzw. `iptables-restore` und `ip6tables-restore`.
Mit den Befehlen
```
iptables-save > /etc/iptables/rules.v4
ip6tables-save > /etc/iptables/rules.v6
```
werden die aktuellen Regeln gespeichert und können nach einem Neustart mit
```
iptables-restore < /etc/iptables/rules.v4
ip6tables-restore < /etc/iptables/rules.v6
```
wieder geladen werden.
Mit dem Paket `iptables-persistent` gibt es für Ubuntu die Möglichkeit, das Speichern und Laden zu automatisieren.
```
apt install iptables-persistent
```
Dabei werden zwei Dialoge angezeigt, die jeweils mit "Ja" zu bestätigen sind.
Wie man den Informationen entnehman kann, werden die aktuell geltenden Firewall-Regeln gespeichert und es wird ein Dienst eingerichtet, der sie beim Neustart wieder aktiviert. Zu beachten ist, dass **nur** während einer Paketinstallation neu erstellte Regeln gespeichert werden. Wenn die Firewall-Konfiguration von Hand geändert wird, muss auch manuell gespeichert werden.
Dafür gibt es den Befehl `netfilter-persistent`, der mit dem Paket `iptables-persistent` automatisch mit installiert wurde.
```
netfilter-persistent save
```
### Die wichtigsten Befehle
!!! note "Anmerkung"
Alle hier aufgelisteten Befehle, die mit "iptables" beginnen, können/müssen mit "ip6tables" für IPv6 angewendet werden.
- anzeigen der aktuell geltenden Regeln
```
iptables -L
```
```
iptables -L INPUT # nur die Regeln der Kette INPUT anzeigen
```
```
iptables -L INPUT --line-numbers # mit Ausgabe der Zeilennummer
```
- anzeigen der Befehle, mit denen die aktuell geltenden Regeln erstellt wurden
```
iptables -S
```
- einfache Freigabe eines Ports
```
iptables -A INPUT -p tcp --dport 54683 -m state --state NEW,ESTABLISHED -j ACCEPT
iptables -A OUTPUT -p tcp --sport 54683 -m state --state ESTABLISHED -j ACCEPT
```
In diesem Beispiel wird der Port 54683 (unser Beispiel-Port für die ssh-Verbindung zum Server) für Verbindungen von außen geöffnet und bestehende Verbindungen können auch Daten nach außen senden.
!!! note "Anmerkung"
Der zweite Befehl ist nur nötig, wenn die Standard-Regel der OUTPUT-Kette auf "DROP" steht.
- Regel einfügen
Die Firewall-Regeln einer Kette haben intern eine Nummer und werden der Reihenfolge nach abgearbeitet. Bei der ersten Übereinstimmung wird die Kette unterbrochen und die entsprechende Anweisung ausgeführt. Die nachfolgenden Regeln der Kette haben also keine Auswirkung mehr. Es ist daher wichtig, bestimmte Regeln in der richtigen Reihenfolge anzulegen, bzw. einzufügen. Mit dem bereits beschriebenen Befehl `iptables -L <KETTE> --line-numbers` kann man sich die Nummern anzeigen lassen und dann mit dem Parameter `-I <KETTE> <NR>` eine neue Regel einfügen.
Dieses Beispiel blockiert Ping-Anfragen, aber die von dem PCs mit der IP-Adresse 192.168.1.10 sollen erlaubt werden. Würde man die Ausnahme-Regel mit dem Befehl `iptables -A ...` anfügen, hätte sie keine Wirkung, weil die erste Regel bereits zutrifft. Durch das Einfügen der Regel mit `iptables -I INPUT 1 ...`, wird sie vor der bestehenden Regel eingefügt und erlaubt damit Ping-Anfragen von dem entsprechenden Computer.
- alle Regeln löschen
```
iptables -F
```
```
iptables -F OUTPUT # nur die Kette OUTPUT löschen
```
!!! warning "Achtung"
Wenn die Regel-Ketten INPUT und OUTPUT standardmäßig auf "DROP" stehen, sperrt man sich nach dem löschen aller Regeln aus! Entweder, man setzt vorher `iptables -P INPUT ACCEPT` und `iptables -P OUTPUT ACCEPT`, oder man löscht nur einzelne Regeln.
