Benutzer-Werkzeuge

Webseiten-Werkzeuge


ssh

SSH (Secure Shell)

Keys & Agent

Schlüssel generieren

mit diesem Kommando wird ein Schlüsselpaar für den User hans generiert:

$ ssh-keygen -t rsa -b 4096 -C "hans-key"
------------------------------------------------------------------------
Generating public/private rsa key pair.
Enter file in which to save the key (/home/hans/.ssh/id_rsa): <Enter>
Created directory '/home/hans/.ssh'.
Enter passphrase (empty for no passphrase): 	<tipperditipp ...>
Enter same passphrase again: 				<nochmal tipperditipp ...>
Your identification has been saved in /home/hans/.ssh/id_rsa.
Your public key has been saved in /home/hans/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:dRLWsnDsC2vj4CXro2rLZxrL+nbDaramX0t7e9QFee0 hans-key
The key's randomart image is:
+---[RSA 4096]----+
|         .oo .   |
|        ..*.o .  |
|         +o=..   |
|        ..oo. E  |
|        S+ o     |
|      o * o      |
|  ..o. O .       |
| o*=*o= o        |
|o@%X+=o+         |
+----[SHA256]-----+
Am Ende dieses Vorgangs hat der user hans in seinem Home-Verzeichnis einen neuen Ordner .ssh angelegt bekommen, der die beiden Dateien id_rsa und id_rsa.pub enthält. Letzteres ist der Public-Key, der mit anderen Rechnern oder Diensten wie GitHub ausgetauscht wird. Auf keinen Fall den Private-Key weggeben!

Die authorized_keys-Datei auf dem Ziel-Host mit keys befüllen

Dies kann man mit dem scp-Befehl. Zunächst übertrage man seinen Publickey auf den Ziel-Host mit einem dem Besitzer zuzuordnendem Dateinamen. Anschließen logge man sich per ssh auf den Ziehlhost ein und dann füge man seinen key an die authorized_keys-Datei an:

user@host1:~$ scp ~/.ssh/id_rsa.pub user@host2:~/user.pub
user@host1:~$ ssh host2
---------------------------------------------------------
user@host2:~$ mkdir .ssh			# <- .ssh-Ordner erstellen, falls noch nicht vorhanden
user@host2:~$ cat user.pub >> .ssh/authorized_keys

Das ganze geht auch schneller mit dem ssh-copy-id-Befehl, der die obigen Scritte, sowie das Permissions setzen erledigt.

user1@host1:~$

ssh-copy-id -i ~/.ssh/key.pub user2@host2
Dar Argument hinter dem Schalter -i gibt hierbei die Keyfile an, die auf den anderen Host kopiert und in die authorized_keys-Datei eingetragen werden soll.

SSH-Agent starten und Schlüssel hinzufügen

Der SSH-Agent muss gestartet werden, damit man einen zuvor generierten Schlüssel entsperren und in den Speicher laden kann. Das ermöglicht eine Authentifizierung ohne Passwort, die sogenannte Publickey-Authentication.
Zunächst einmal starte man den Agenten:

$ eval $(ssh-agent -s)
------------------------------------------------------------
Agent pid 2366

Dieser gibt bei einem erfolgreichem Start zur Information seine PID (=Process ID) auf der Standardausgabe aus. Zur Kontrolle kann man mit dem Kommando ps aux | grep ssh-agent (Process Management in Linux).

Überprüfen ob der Agent läuft:

$ ps aux | grep ssh-agent
------------------------------------------------------------
hans      2366  0.0  0.0  11084   332 ?        Ss   12:26   0:00 ssh-agent -s
hans      2388  0.0  0.0  12784   936 pts/1    S+   12:31   0:00 grep ssh-agent

Hier kann man sehen, dass der SSH-Agent läuft. Sollte man diesen aus versehen zwei mal gestartet haben, kann man einen der beiden mit kill zum Stoppen zwingen oder einfach alle Agenten mit pkill ssh-agent beenden.

Nun kann man den Schlüssel hinzufügen:

user@host:~$

ssh-add .ssh/id_rsa
-------------------------------------------------------
Enter passphrase for .ssh/id_rsa: <tipperditipp...>
Identity added: .ssh/id_rsa (.ssh/id_rsa)

Damit wurde der Schlüssel entsperrt und in den Speicher geladen. Nun kann man sich per Publickey-Authentication auf einem entfernten Rechner einloggen:

user@host1:~$

ssh host2
--------------------------------------------------------
The authenticity of host 'host2:2222 ([10.0.100.30])' can't be established.
ECDSA key fingerprint is SHA256:OfMsQ9LPoXgX1H4aAMRq/P+HfQmxrrVUa5HgY2YfLJk.
Are you sure you want to continue connecting (yes/no)? yes

Hier begegnet man bei der ersten Verbindung dem host2 zunächst mit Misstrauen. Dies dient dem verhindern von Man-in-the-Middle-Attacks, bei denen Jemand böswilliges einen Rechner zwischen host1 und host2 schaltet um die Verbindung zu kapern.
Es wird nur der "Fingerabdruck" des entfernten Rechners gezeigt. Wenn man ganz sicher gehen möchte, was man auch sollte, so gehe man auf den Zielrechner und Überprüfe von Hand den key fingerprint mit folgendem Kommando:

user@host2:~$

ssh-keygen -l -f /etc/ssh/ssh_host_ecdsa_key
-------------------------------------------------------------
256 SHA256:OfMsQ9LPoXgX1H4aAMRq/P+HfQmxrrVUa5HgY2YfLJk user@host2 (ECDSA)

Man sollte sehen, dass sich die Zeichenkolonnen gleichen. dann tippe man yes auf die Frage Are you sure you want to continue connecting (yes/no)?
Dann kann man das Passwort angeben.
Oder falls der Public key (der Inhalt von id_rsa.pub) in der entprechenden authorized_keys-file steht, kommt man auch ohne Passwort rein.

SSH-Agent beim öffnen einer Shell starten

Damit man das Procedere mit dem SSH-Agenten und dem Hinzufügen des Keys nicht manuell von Hand erledigen muss, schreibt man in die Konfigurationsdatei der Shell (~/.bashrc) einen Schnipsel, der das für einen bequem übernimmt:

~/.bashrc

SSH_ENV=$HOME/.ssh/environment

start_agent()
{
    echo "initializing new SSH agent ..."
    ssh-agent | sed 's/^echo/#echo/' > $SSH_ENV
    echo "succeeded"
    chmod 600 $SSH_ENV
    . $SSH_ENV
    ssh-add
}

# source SSH settings, if applicable
if [[ -f $SSH_ENV ]]
then
    . $SSH_ENV
    ps -ef | grep $SSH_AGENT_PID | grep ssh-agent > /dev/null || {
        start_agent
    }
else
    start_agent
fi

Kopieren von Dateien über das SSH-Protokoll

mit scp

die allgemeine Syntax lautet:

user@host1:~$

scp /path/to/srcfile user@host2:/path/to/dstfile
scp user@host2:/path/to/srcfile /path/to/dstfile
Hierbei kann der Pfad relativ wie auch absolut angegeben werden. Das user@ kann weggelassen werden, wenn man sich als der gleiche User auf der Zielmaschine authentifizieren möchte. host kann ein Rechnername oder eine IP sein.

SSH-Server

Login mit Passwort deaktivieren

Den Login mit einem Passwort zu deaktivieren ist eine gängige Methode um die Sicherheit des SSH-Servers, der auf einem Rechner läuft zu erhöhen. Damit wird sichergestellt, dass auch nur die User auf die Maschine kommen, die im Besizt der zugelassenen Keys sind. Dazu müssen einige Einstellungen in der Konfigurationsdatei vom SSH-Server anpassen:

Für root

Für den root ist die Default-Einstellung bereits gegeben, ansonsten muss man das Argument zur PermitRootLogin-Direktive von yes zu prohibit-password ändern:

user@host:~$

sudo nano /etc/ssh/sshd_config
--------------------------------------------------------------
[...]
# Authentication:

#LoginGraceTime 2m
PermitRootLogin prohibit-password	# <-- hier
#StrictModes yes
#MaxAuthTries 6
#MaxSessions 10
[...]

Für alle anderen User

Dazu benutzt man am Ende der sshd_config ein Match auf die jeweiligen User, für die man besondere Konfigurationen vornimmt. In diesm Fall die PasswordAuthentication-Direktive, die man zu no ändert:

user@host:~$

sudo nano /etc/ssh/sshd_config
--------------------------------------------------------------
[...]
Match User user1, user2
        PasswordAuthentication no

Setzt man PasswordAuthentication no vor das erste Match, dann wird die Passwort-Authentifizierung für alle User, einschließlich root deaktiviert.

ssh.txt · Zuletzt geändert: 2018/02/13 11:21 von admin