Einführung
In diesem Lab lernen Sie die Grundlagen der Absicherung des Fernzugriffs auf ein Linux-System mithilfe des Secure Shell (SSH)-Protokolls. Sie werden praktische Erfahrungen mit wesentlichen SSH-Funktionalitäten sammeln, einschließlich der Einrichtung der schlüsselbasierten Authentifizierung für erhöhte Sicherheit, der sicheren Übertragung von Dateien zwischen Systemen und der Erstellung von SSH-Tunnels für Port-Weiterleitung.
Sie beginnen mit der Einrichtung eines Docker-Containers, um eine Remote-Serverumgebung zu simulieren, was das Lab realistischer macht. Anschließend installieren Sie den OpenSSH-Client auf Ihrem Host-System und generieren ein neues RSA-Schlüsselpaar mithilfe des ssh-keygen-Dienstprogramms. Als Nächstes konfigurieren Sie den Docker-Server so, dass dieser Schlüssel zur Authentifizierung akzeptiert wird, wodurch eine sichere, passwortlose Verbindung zwischen Ihrem Host und dem containerisierten Server hergestellt wird. Abschließend üben Sie die Verwendung des scp-Befehls für sichere Dateiübertragungen und des ssh -L-Befehls zur Weiterleitung eines lokalen Ports an einen Remote-Dienst, wodurch effektiv ein sicherer Tunnel erstellt wird.
Docker SSH-Server einrichten und Schlüsselpaar generieren
In diesem Schritt richten Sie einen Docker-Container ein, um einen entfernten SSH-Server zu simulieren, und generieren ein sicheres Schlüsselpaar auf Ihrem Host-System. Dieser Ansatz bietet eine realistischere Umgebung, indem der Client (Ihr Host) vom Server (Docker-Container) getrennt wird.
Da Docker und der OpenSSH-Client in dieser Umgebung bereits installiert sind, können Sie direkt mit der Konfiguration des Servers fortfahren.
Stellen Sie zunächst sicher, dass der Docker-Dienst läuft:
sudo systemctl start docker
sudo systemctl enable docker
Erstellen wir nun einen Docker-Container, der als unser SSH-Server fungiert. Wir verwenden Ubuntu als Basis-Image und konfigurieren es mit SSH-Server-Funktionen. Erstellen Sie eine Dockerfile:
cat > Dockerfile << 'EOF'
FROM ubuntu:22.04
## Install OpenSSH server and other utilities
RUN apt-get update && \
apt-get install -y openssh-server nginx sudo && \
apt-get clean && \
rm -rf /var/lib/apt/lists/*
## Create a user for SSH access
RUN useradd -m -s /bin/bash sshuser && \
echo 'sshuser:password123' | chpasswd && \
usermod -aG sudo sshuser
## Configure SSH
RUN mkdir /var/run/sshd && \
sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin no/' /etc/ssh/sshd_config && \
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication yes/' /etc/ssh/sshd_config && \
sed -i 's/#PubkeyAuthentication yes/PubkeyAuthentication yes/' /etc/ssh/sshd_config
## Create SSH directory for the user
RUN mkdir -p /home/sshuser/.ssh && \
chown sshuser:sshuser /home/sshuser/.ssh && \
chmod 700 /home/sshuser/.ssh
## Expose SSH port
EXPOSE 22 80
## Start SSH service
CMD ["/usr/sbin/sshd", "-D"]
EOF
Bauen Sie das Docker-Image:
sudo docker build -t ssh-server .
Führen Sie den Docker-Container aus und mappen Sie Port 2222 auf Ihrem Host auf Port 22 im Container:
sudo docker run -d --name ssh-lab-server -p 2222:22 -p 8080:80 ssh-server
Überprüfen Sie, ob der Container läuft:
sudo docker ps
Sie sollten eine Ausgabe sehen, die den laufenden Container anzeigt:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
... ssh-server "/usr/sbin/sshd -D" ... Up ... 0.0.0.0:2222->22/tcp, 0.0.0.0:8080->80/tcp ssh-lab-server
Als Nächstes generieren Sie ein SSH-Schlüsselpaar. SSH-Schlüssel bieten eine sicherere Methode zur Anmeldung an einem Server mit SSH als die alleinige Verwendung eines Passworts. Ein Schlüsselpaar besteht aus einem privaten Schlüssel, der geheim gehalten werden muss, und einem öffentlichen Schlüssel, der geteilt werden kann.
Wir verwenden den Befehl ssh-keygen, um ein neues Schlüsselpaar zu erstellen. Wir geben den Schlüsseltyp als rsa und die Schlüsselgröße als 2048 Bits für starke Sicherheit an. Das Flag -f ermöglicht es uns, einen Dateinamen für unsere Schlüssel anzugeben, was bei deren Organisation hilft. Wir werden unseren Schlüssel ~/.ssh/id_rsa_lab_ssh nennen.
Führen Sie den folgenden Befehl aus. Wenn Sie nach einer Passphrase gefragt werden, drücken Sie einfach zweimal Enter, um ohne eine fortzufahren. Für dieses Lab werden wir die Passphrase der Einfachheit halber weglassen, aber in einem realen Szenario sollten Sie immer eine starke Passphrase verwenden, um Ihren privaten Schlüssel zu schützen.
ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa_lab_ssh
Der Befehl generiert das Schlüsselpaar und zeigt Ihnen an, wo die Dateien gespeichert sind.
Generating public/private rsa key pair.
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /home/labex/.ssh/id_rsa_lab_ssh
Your public key has been saved in /home/labex/.ssh/id_rsa_lab_ssh.pub
The key fingerprint is:
SHA256:... labex@...
The key's randomart image is:
+---[RSA 2048]----+
| .o*+.. |
| . =.o. . |
| . o o. . |
| o . . |
| . S |
| . . . |
| o . |
| o . |
| E . |
+----[SHA256]-----+
Um zu bestätigen, dass die Schlüsseldateien erstellt wurden, können Sie den Inhalt des Verzeichnisses ~/.ssh auflisten. Sie sollten Ihren neuen privaten Schlüssel (id_rsa_lab_ssh) und Ihren öffentlichen Schlüssel (id_rsa_lab_ssh.pub) sehen.
ls -l ~/.ssh/id_rsa_lab_ssh*
Die Ausgabe wird ähnlich wie folgt aussehen und die beiden neuen Dateien anzeigen:
-rw------- 1 labex labex 1876 ... /home/labex/.ssh/id_rsa_lab_ssh
-rw-r--r-- 1 labex labex 401 ... /home/labex/.ssh/id_rsa_lab_ssh.pub
Sie haben nun erfolgreich den SSH-Server installiert und ein Schlüsselpaar erstellt, das Sie in den nächsten Schritten zur Konfiguration und zum Testen der sicheren Authentifizierung verwenden werden.
SSH-Schlüsselbasierte Authentifizierung konfigurieren und testen
In diesem Schritt konfigurieren Sie den Docker SSH-Server so, dass er Ihren öffentlichen Schlüssel erkennt, was Ihnen die passwortlose Anmeldung ermöglicht. Dieser Prozess umfasst das Kopieren Ihres öffentlichen Schlüssels in den Docker-Container und das anschließende Testen der Verbindung.
Damit der SSH-Server Sie anhand Ihres Schlüssels authentifizieren kann, muss Ihr öffentlicher Schlüssel auf dem Server in der Datei ~/.ssh/authorized_keys abgelegt werden. Da unser Server in einem Docker-Container läuft, müssen wir den öffentlichen Schlüssel von Ihrem Host-System in den Container kopieren.
Kopieren Sie zunächst Ihren öffentlichen Schlüssel mit dem Befehl docker cp in den Docker-Container:
sudo docker cp ~/.ssh/id_rsa_lab_ssh.pub ssh-lab-server:/home/sshuser/.ssh/authorized_keys
Als Nächstes müssen wir die richtigen Dateiberechtigungen innerhalb des Containers festlegen. SSH ist sehr sicherheitsbewusst und weigert sich, Schlüssel zu verwenden, wenn die Berechtigungen zu offen sind. Führen Sie den folgenden Befehl aus, um die richtigen Berechtigungen festzulegen:
sudo docker exec ssh-lab-server chown sshuser:sshuser /home/sshuser/.ssh/authorized_keys
sudo docker exec ssh-lab-server chmod 600 /home/sshuser/.ssh/authorized_keys
Nachdem der öffentliche Schlüssel hinzugefügt und die Berechtigungen festgelegt wurden, können Sie die schlüsselbasierte Authentifizierung testen. Sie versuchen, sich mit dem Benutzer sshuser über Port 2222 (den wir auf Port 22 des Containers gemappt haben) in den Docker-Container einzuloggen und dabei den von Ihnen erstellten privaten Schlüssel anzugeben.
Verwenden Sie den ssh-Befehl mit dem Flag -i, um auf Ihre private Schlüsseldatei zu verweisen, und -p, um den Port anzugeben:
ssh -i ~/.ssh/id_rsa_lab_ssh -p 2222 sshuser@localhost
Da Sie sich zum ersten Mal mit einem neuen Host verbinden, werden Sie möglicherweise aufgefordert, die Authentizität des Hosts zu überprüfen. Geben Sie yes ein und drücken Sie Enter.
The authenticity of host '[localhost]:2222 ([127.0.0.1]:2222)' can't be established.
ED25519 key fingerprint is SHA256:....
This key is not known by any other names
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[localhost]:2222' (ED25519) to the list of known hosts.
Wenn alles korrekt konfiguriert ist, werden Sie sofort ohne Passwortabfrage angemeldet. Sie sehen eine Willkommensnachricht, und Ihre Eingabeaufforderung ändert sich, um anzuzeigen, dass Sie sich jetzt im Docker-Container befinden:
Welcome to Ubuntu 22.04.3 LTS (GNU/Linux 5.15.0-88-generic x86_64)
...
sshuser@containerid:~$
Um die SSH-Sitzung zu beenden und zu Ihrer Host-Terminal-Eingabeaufforderung zurückzukehren, geben Sie einfach exit ein und drücken Sie Enter.
exit
Die erfolgreiche Anmeldung ohne Passwort bestätigt, dass Ihre schlüsselbasierte Authentifizierung zwischen Ihrem Host und dem Docker-Container korrekt funktioniert. Diese Methode ist deutlich sicherer als die herkömmliche Passwortauthentifizierung.
Dateien sicher mit scp übertragen
In diesem Schritt lernen Sie, wie Sie das Secure Copy Protocol (scp) verwenden, um Dateien sicher zwischen Hosts zu übertragen. scp nutzt das zugrunde liegende SSH-Protokoll, was bedeutet, dass es von denselben Verschlüsselungs- und Authentifizierungsmechanismen profitiert, die Sie bereits konfiguriert haben, einschließlich der schlüsselbasierten Authentifizierung.
Erstellen wir zunächst eine Beispieldatei in Ihrem aktuellen Arbeitsverzeichnis, ~/project, die wir für die Übertragung verwenden können. Wir nennen sie source_file.txt.
echo "This is a test file for scp." > source_file.txt
Sie können die Erstellung der Datei überprüfen, indem Sie sie auflisten:
ls -l source_file.txt
Die Ausgabe sollte Ihre neu erstellte Datei anzeigen:
-rw-r--r-- 1 labex labex 29 ... source_file.txt
Nun verwenden Sie scp, um source_file.txt in das Verzeichnis /tmp auf dem Docker-Container zu kopieren, was die sichere Dateiübertragung auf einen entfernten Server demonstriert. Die grundlegende Syntax für scp lautet scp -i [private_key] -P [port] [source_file] [user]@[host]:[destination_path].
Sie verwenden das Flag -i, um Ihren privaten Schlüssel anzugeben, -P, um Port 2222 (den SSH-Port unseres Docker-Containers) anzugeben, und übertragen die Datei an das Konto sshuser auf dem Container:
scp -i ~/.ssh/id_rsa_lab_ssh -P 2222 source_file.txt sshuser@localhost:/tmp/destination_file.txt
Sie sehen eine Ausgabe, die den Fortschritt der Dateiübertragung anzeigt, die bei einer kleinen Datei sofort erfolgen sollte.
source_file.txt 100% 29 6.7KB/s 00:00
Um zu bestätigen, dass die Datei erfolgreich kopiert wurde, verbinden Sie sich mit dem Docker-Container und listen Sie die Zieldatei auf:
sudo docker exec ssh-lab-server ls -l /tmp/destination_file.txt
Die Ausgabe bestätigt die Existenz und die Details der kopierten Datei:
-rw-r--r-- 1 sshuser sshuser 29 ... /tmp/destination_file.txt
Sie können auch überprüfen, ob der Dateiinhalt korrekt übertragen wurde:
sudo docker exec ssh-lab-server cat /tmp/destination_file.txt
Dies sollte Folgendes anzeigen:
This is a test file for scp.
Sie haben nun erfolgreich eine Datei mit scp übertragen und damit eine sichere und praktische Methode zum Verschieben von Daten zwischen Systemen über ein Netzwerk demonstriert.
SSH-Tunnel für Portweiterleitung mit ssh -L erstellen
In diesem Schritt lernen Sie eine der leistungsfähigsten Funktionen von SSH kennen: das Tunneling, auch bekannt als Portweiterleitung. Dies ermöglicht es Ihnen, Netzwerkverkehr sicher von einem Port auf Ihrem lokalen Rechner zu einem Port auf einem entfernten Server weiterzuleiten und damit ein unverschlüsseltes Protokoll innerhalb einer sicheren SSH-Verbindung zu verpacken. Wir werden die lokale Portweiterleitung üben.
Um dies zu demonstrieren, benötigen wir einen Dienst, der auf einem Port läuft und zu dem wir eine Verbindung herstellen können. Glücklicherweise ist in unserem Docker-Container bereits Nginx installiert und konfiguriert. Wir müssen den Nginx-Dienst innerhalb des Containers starten.
Starten Sie zuerst den Nginx-Dienst innerhalb des Docker-Containers:
sudo docker exec ssh-lab-server service nginx start
Sie können überprüfen, ob Nginx im Container korrekt läuft:
sudo docker exec ssh-lab-server service nginx status
Die Ausgabe sollte anzeigen, dass der Dienst läuft:
* nginx is running
Erstellen wir nun den SSH-Tunnel. Wir verwenden den ssh-Befehl mit dem Flag -L, was für lokale Portweiterleitung steht. Die Syntax lautet ssh -L [LOCAL_PORT]:[DESTINATION_HOST]:[DESTINATION_PORT] [USER]@[SERVER].
Wir werden den Datenverkehr vom Port 9090 auf unserem lokalen Rechner zum Port 80 innerhalb des Docker-Containers weiterleiten. Das Flag -N weist SSH an, keinen entfernten Befehl auszuführen, was ideal ist, um nur Ports weiterzuleiten. Beachten Sie, dass wir Port 2222 verwenden, um uns mit dem SSH-Dienst unseres Docker-Containers zu verbinden.
Führen Sie diesen Befehl aus. Dieser Befehl wird Ihr aktuelles Terminal belegen und keine Eingabeaufforderung zurückgeben. Sie müssen ein neues Terminal öffnen, um den Tunnel zu testen.
ssh -i ~/.ssh/id_rsa_lab_ssh -N -L 9090:localhost:80 -p 2222 sshuser@localhost
Öffnen Sie nun ein neues Terminal, indem Sie auf das +-Symbol in der Registerkartenleiste des Terminals klicken. In diesem neuen Terminal können Sie den Tunnel mit curl testen. Durch den Zugriff auf localhost:9090 wird Ihre Anfrage sicher über SSH zum Port 80 innerhalb des Docker-Containers getunnelt.
curl http://localhost:9090
Sie sollten den HTML-Inhalt der standardmäßigen Nginx-Begrüßungsseite sehen, was bestätigt, dass der Tunnel funktioniert.
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
body {
width: 35em;
margin: 0 auto;
font-family: Tahoma, Verdana, Arial, sans-serif;
}
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>
<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>
<p><em>Thank you for using nginx.</em></p>
</body>
</html>
Sie haben erfolgreich einen sicheren Tunnel erstellt, der den Datenverkehr von Ihrem Host-Rechner an einen Dienst weiterleitet, der innerhalb des Docker-Containers läuft. Um die Verbindung zu schließen, kehren Sie zum ersten Terminal (dem, das den ssh-Befehl ausführt) zurück und drücken Sie Ctrl+C. Anschließend können Sie das zweite Terminal schließen.
Zusammenfassung
In diesem Lab haben Sie die wesentlichen Fähigkeiten zur Sicherung des Fernzugriffs auf einem Linux-System mithilfe des Secure Shell (SSH)-Protokolls erlernt. Die wichtigsten abgedeckten Ziele umfassen die Einrichtung und das Testen der schlüsselbasierten Authentifizierung, die sichere Übertragung von Dateien mit scp und die Erstellung eines SSH-Tunnels für die Portweiterleitung.
Sie begannen mit der Vorbereitung der Umgebung, die das Aktualisieren der Paketliste des Systems und die Installation der Pakete openssh-server und openssh-client umfasste. Nachdem Sie überprüft hatten, dass der SSH-Dienst aktiv war, generierten Sie ein sicheres 2048-Bit RSA-Schlüsselpaar mit dem Befehl ssh-keygen. Dieser grundlegende Schritt erzeugte die öffentlichen und privaten Schlüssel, die für den Aufbau sicherer, passwortloser Verbindungen in den nachfolgenden Schritten erforderlich sind.
