SSH-Schlüssel einrichten – Anleitung

Was ist SSH und wofür wird es benötigt?

SSH bedeutet Secure Shell. Damit verbindest du dich verschlüsselt mit einem anderen Rechner und kannst dort im Terminal Befehle ausführen. Das ist beispielsweise für die Verwaltung eines Linux-Rechners, eines Servers oder einer virtuellen Maschine (VM) nützlich. Auch Dateiübertragungen mit SFTP oder SCP verwenden SSH.

Bei einer SSH-Schlüsselanmeldung gehören zwei Dateien zusammen: Der private Schlüssel bleibt auf deinem eigenen Rechner und muss geheim bleiben. Der öffentliche Schlüssel wird auf dem Zielrechner hinterlegt. Beim Anmelden weist dein Rechner nach, dass er den passenden privaten Schlüssel besitzt; dieser wird nicht übertragen. Das Skript richtet diese Anmeldung ein und legt einen kurzen Verbindungsnamen an.

Vorbereiten und starten

SSH-Skript herunterladen

Auf dem Zielrechner muss ein erreichbarer SSH-Dienst laufen. Du benötigst dessen Benutzerkonto und für die erste Übertragung normalerweise dessen Kontopasswort; eine Passwort-Anmeldung muss dort dafür erlaubt sein. Lokal werden Bash, ssh, ssh-keygen und ssh-copy-id benötigt, bei einer Passwortübertragung zusätzlich sshpass. Das Skript richtet keinen SSH-Server ein und installiert keine Pakete.

Speichere das Skript in einem beschreibbaren Ordner und öffne es in einem Texteditor. Passe SSH_USER, SSH_HOST und SSH_ALIAS an. Für das Passwort gibt es zwei Möglichkeiten:

Im Terminal eingeben: Setze SSH_PASSWORT="". Bei Bedarf fragt das Skript das Passwort verdeckt ab.
Im Skript eintragen: Ersetze den Platzhalter bei SSH_PASSWORT durch das Passwort des Zielbenutzers. Lösche es nach der Einrichtung wieder aus der Datei und speichere diese mit SSH_PASSWORT="". Das Skript entfernt es nicht selbst aus der gespeicherten Datei.

Ein direkt eingetragenes Passwort steht im Klartext in der Datei. Bei Shell-Sonderzeichen wie $, Backticks oder Anführungszeichen ist die verdeckte Terminaleingabe einfacher, weil keine Bash-Maskierung nötig ist.

Die folgenden Werte sind nur ein Beispiel für die Variante mit Terminalabfrage:

SSH_USER="josef"
SSH_HOST="192.168.1.50"
SSH_ALIAS="laborvm"
SSH_PASSWORT=""

Öffne ein Terminal im Ordner der Skriptdatei und starte es als dein normaler Benutzer. Bei Verwendung von bash ist kein zusätzliches chmod +x erforderlich.

bash ./ssh_schluessel_einrichten.sh --help
bash ./ssh_schluessel_einrichten.sh --version
bash ./ssh_schluessel_einrichten.sh

Das Skript Schritt für Schritt

Die folgenden Abschnitte enthalten den ausführbaren Teil der Skriptversion 1.0.2 in seiner ursprünglichen Reihenfolge. Der lange Kommentarblock am Dateianfang mit Beschreibung und Änderungshistorie ist ausgelassen. Die Codeblöcke dienen der Erklärung; ausgeführt wird die heruntergeladene vollständige Datei mit deinen angepassten Zielangaben.

1. Bash und Fehlerbehandlung

Die erste Zeile wählt Bash als Interpreter. set -u behandelt den Zugriff auf nicht gesetzte Variablen als Fehler. pipefail sorgt dafür, dass ein Fehler innerhalb einer Befehlskette mit | im Rückgabestatus sichtbar wird. Ein automatischer Abbruch bei jedem fehlgeschlagenen Befehl ist damit nicht eingeschaltet; wichtige Fehler behandelt das Skript gezielt mit Prüfungen und die.

#!/usr/bin/env bash
set -u -o pipefail

2. Version und Zielangaben

Die Skriptversion ist 1.0.2. SSH_USER ist das Benutzerkonto auf dem Zielrechner. SSH_HOST ist dessen Rechnername oder IP-Adresse. SSH_ALIAS ist ein frei gewählter Kurzname für die spätere Verbindung und zugleich Teil des Schlüsseldateinamens. Die folgenden Zeilen zeigen den tatsächlichen Dateistand. Der Text bei SSH_PASSWORT ist ein Platzhalter und wird vom Skript als Passwort behandelt, solange er dort steht. Du hast zwei Möglichkeiten: Setze die Zeile auf SSH_PASSWORT="", damit ein benötigtes Passwort verdeckt im Terminal abgefragt wird. Oder ersetze den Platzhalter durch das tatsächliche Passwort des Zielbenutzers und lösche dieses nach der Einrichtung wieder aus der Skriptdatei. Speichere die Datei danach mit SSH_PASSWORT="". Die automatische Leerung der Variablen ändert die gespeicherte Datei nicht.

VERSION="1.0.2"

# Für ein neues Ziel nur diese vier Werte ändern.
SSH_USER="benutzer"
SSH_HOST="rechner.local"
SSH_ALIAS="zielrechner"

# Leer lassen; ein erforderliches Passwort wird verdeckt abgefragt.
SSH_PASSWORT="pw vom zielrechner"

3. Skriptordner, Logdatei und Fehlermeldungen

BASH_SOURCE[0] bezeichnet die laufende Skriptdatei. Daraus entstehen Ordner, Dateiname und Logpfad. Das Log heißt ssh_schluessel_einrichten.log und liegt neben dem Skript. : > "$LOG_FILE" leert es bei jedem Aufruf, auch bei Hilfe und Versionsausgabe. Ist es nicht beschreibbar, endet das Skript mit Code 5. timestamp erzeugt Datum und Uhrzeit; log schreibt mit tee -a gleichzeitig ins Terminal und ins Log. die protokolliert eine Fehlermeldung und beendet das Skript mit dem übergebenen Fehlercode. Nicht jede Ausgabe externer Programme wird dadurch automatisch ins Log übernommen.

SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
SCRIPT_NAME="$(basename -- "${BASH_SOURCE[0]}")"
LOG_FILE="$SCRIPT_DIR/${SCRIPT_NAME%.sh}.log"

: > "$LOG_FILE" || { printf 'FEHLER: Logdatei nicht beschreibbar: %s\n' "$LOG_FILE" >&2; exit 5; }

timestamp() { date '+%d.%m.%Y %H:%M'; }
log() { printf '%s %s\n' "$(timestamp)" "$*" | tee -a "$LOG_FILE"; }
die() { local code="$1"; shift; log "FEHLER: $*"; exit "$code"; }

4. Hilfe und Versionsausgabe

show_help gibt den Text zwischen den beiden EOF-Markierungen aus. Die Anführungszeichen bei der ersten Markierung verhindern eine Ersetzung von Variablen im Hilfetext. case wertet den ersten Aufrufparameter aus: --help oder -h zeigt Hilfe, --version die Version. Ohne Parameter beginnt die Einrichtung. Ein unbekannter erster Parameter führt zu Code 2. ${1:-} erlaubt auch einen Aufruf ohne ersten Parameter trotz set -u.

show_help() {
cat <<'EOF'
SSH-Schlüssel für Rechner/VM einrichten

Verwendung:
  ./ssh_schluessel_einrichten.sh
  ./ssh_schluessel_einrichten.sh --help
  ./ssh_schluessel_einrichten.sh --version

Das Skript prüft zuerst, ob Schlüssel, Alias und Schlüsselanmeldung bereits
funktionieren. Ist alles eingerichtet, werden keine Änderungen vorgenommen.

Für ein neues Ziel im Skript SSH_USER, SSH_HOST und SSH_ALIAS anpassen.
Ein erforderliches Passwort wird verdeckt abgefragt.
EOF
}

case "${1:-}" in
    -h|--help) show_help; exit 0 ;;
    --version) printf '%s\n' "$VERSION"; exit 0 ;;
    "") ;;
    *) show_help >&2; exit 2 ;;
esac

5. Dateipfade und Startinformationen

$HOME ist das Heimatverzeichnis des ausführenden Benutzers; ~ bezeichnet denselben Ort. Der private Schlüssel erhält beispielsweise den Namen ~/.ssh/id_ed25519_zielrechner; der öffentliche Schlüssel bekommt zusätzlich .pub. CONFIG bezeichnet die persönliche SSH-Konfiguration und ORIGINAL deren einmalige Sicherung. Danach werden Programm, Version, Startzeit, Ziel und Alias protokolliert. Deshalb das Skript als der Benutzer starten, der die Verbindung später nutzen soll, ohne sudo.

KEY="$HOME/.ssh/id_ed25519_${SSH_ALIAS}"
CONFIG="$HOME/.ssh/config"
ORIGINAL="${CONFIG}.original"

log "PROGRAMM: $SCRIPT_NAME"
log "VERSION: $VERSION"
log "START: $(timestamp)"
log "ZIEL: ${SSH_USER}@${SSH_HOST}"
log "ALIAS: ${SSH_ALIAS}"

6. Benötigte Werkzeuge prüfen

command -v prüft, ob ssh, ssh-keygen und ssh-copy-id verfügbar sind. Fehlende Befehle werden in der Liste missing gesammelt. Fehlt etwas, zeigt das Skript einen Installationsvorschlag für Linux Mint und beendet sich mit Code 3. Es installiert selbst nichts. sshpass wird erst später geprüft, falls eine Schlüsselübertragung nötig bleibt.

missing=()
for cmd in ssh ssh-keygen ssh-copy-id; do
    command -v "$cmd" >/dev/null 2>&1 || missing+=("$cmd")
done

if ((${#missing[@]})); then
    {
        echo "FEHLENDE VORAUSSETZUNGEN"
        printf 'Fehlt: %s\n' "${missing[@]}"
        echo "Vorschlag unter Linux Mint:"
        echo "sudo apt install openssh-client"
        echo "Es wird NICHT automatisch installiert."
    } | tee -a "$LOG_FILE"
    exit 3
fi

7. Zielangaben auf gültige Zeichen prüfen

Diese regulären Ausdrücke begrenzen die erlaubten Zeichen. Der Alias darf Buchstaben, Ziffern, Unterstriche und Bindestriche enthalten. Benutzername und Host erlauben zusätzlich die im Code angegebenen Zeichen. Leerzeichen sind nicht zugelassen. Ein ungültiger Wert führt zu Code 2. Diese Prüfung bestätigt noch nicht, dass der Rechner erreichbar ist oder das Benutzerkonto existiert.

[[ "$SSH_ALIAS" =~ ^[a-zA-Z0-9_-]+$ && "$SSH_USER" =~ ^[a-zA-Z0-9_.-]+$ &&
   "$SSH_HOST" =~ ^[a-zA-Z0-9_.:-]+$ ]] || die 2 "Ungültiger Alias, Benutzer oder Host."

8. Einen vorhandenen SSH-Alias prüfen

Das Skript sucht in ~/.ssh/config nach einem passenden Host-Eintrag. ssh -G gibt die wirksame SSH-Konfiguration aus, ohne sich anzumelden. awk liest daraus Hostname, Benutzer und den ersten angezeigten Schlüsselpfad. Diese Werte müssen genau den eingetragenen Werten entsprechen. Bei einer Abweichung bricht das Skript ab und überschreibt den vorhandenen Eintrag nicht. Auch eine anders geschriebene, aber gleichbedeutende Pfadangabe kann bei diesem Textvergleich abweichen.

alias_ok=false
if [[ -f "$CONFIG" ]] && grep -Eq "^[[:space:]]*Host[[:space:]]+${SSH_ALIAS}([[:space:]]|$)" "$CONFIG"; then
    effective="$(ssh -G "$SSH_ALIAS" 2>/dev/null)" || die 5 "SSH-Konfiguration ist ungültig."
    actual_host="$(awk '$1 == "hostname" {print $2; exit}' <<< "$effective")"
    actual_user="$(awk '$1 == "user" {print $2; exit}' <<< "$effective")"
    actual_key="$(awk '$1 == "identityfile" {print $2; exit}' <<< "$effective")"
    if [[ "$actual_host" != "$SSH_HOST" || "$actual_user" != "$SSH_USER" || "$actual_key" != "$KEY" ]]; then
        die 5 "Alias '$SSH_ALIAS' zeigt nicht auf die eingetragenen Werte. Bitte ~/.ssh/config prüfen."
    fi
    alias_ok=true
fi

9. Ein vorhandenes Schlüsselpaar prüfen

Sobald eine der beiden Schlüsseldateien existiert, müssen beide als reguläre Dateien vorhanden sein. ssh-keygen -y leitet den öffentlichen Schlüssel aus dem privaten ab. Verglichen werden Schlüsseltyp und Schlüsseldaten, nicht der Kommentar am Ende. Bei unvollständigen oder nicht zusammenpassenden Dateien erfolgt ein Abbruch mit Code 5. Vorhandene Schlüssel werden nicht überschrieben. Ein bereits passphrasegeschützter privater Schlüssel kann bei dieser Prüfung eine Eingabe verlangen.

key_ok=false
if [[ -e "$KEY" || -e "${KEY}.pub" ]]; then
    [[ -f "$KEY" && -f "${KEY}.pub" ]] || die 5 "Schlüsselpaar unvollständig; vorhandene Dateien bleiben unverändert."
    derived="$(ssh-keygen -y -f "$KEY" 2>/dev/null)" || die 5 "Privater Schlüssel kann nicht geprüft werden."
    [[ "$(awk '{print $1, $2}' <<< "$derived")" == "$(awk 'NR==1 {print $1, $2}' "${KEY}.pub")" ]] ||
        die 5 "Privater und öffentlicher Schlüssel passen nicht zusammen."
    key_ok=true
fi

10. Bereits funktionierende Einrichtung erkennen

Sind Schlüssel und Alias vorhanden, führt SSH auf dem Ziel den Befehl true aus. Dieser beendet sich erfolgreich, ohne eine interaktive Sitzung zu öffnen. BatchMode=yes verhindert interaktive Rückfragen im Verbindungstest; Passwort- und Tastaturdialog-Anmeldung sind ausgeschaltet. PreferredAuthentications=publickey verlangt Schlüsselanmeldung. -i nennt die Schlüsseldatei, IdentitiesOnly=yes beschränkt die verwendeten Identitäten auf die konfigurierten; ConnectTimeout=8 begrenzt den Verbindungsaufbau. Bei Erfolg endet das Skript sofort. Schlüssel und SSH-Konfiguration bleiben dann unverändert; die Logdatei wurde bereits neu geschrieben. Ein fehlgeschlagener Test kann auch an Netzwerk, SSH-Dienst oder Hostschlüssel liegen.

# Zuerst ausschließlich prüfen. Bei funktionierender Einrichtung nichts ändern.
if $key_ok && $alias_ok; then
    log "INFO: Schlüssel und Alias sind vorhanden."
    if ssh -o BatchMode=yes \
           -o PasswordAuthentication=no \
           -o KbdInteractiveAuthentication=no \
           -o PreferredAuthentications=publickey \
           -o IdentitiesOnly=yes -i "$KEY" \
           -o ConnectTimeout=8 \
           "$SSH_ALIAS" true >/dev/null 2>&1; then
        log "BESTANDEN: SSH-Schlüsselanmeldung funktioniert."
        log "Keine Änderung erforderlich."
        exit 0
    fi
    log "WARNUNG: Schlüssel und Alias vorhanden, Verbindungstest fehlgeschlagen."
fi

11. Schlüssel erzeugen und Zugriffsrechte setzen

Nur wenn noch kein Schlüsselpaar vorhanden ist, wird ein ED25519-Schlüssel erzeugt. -f legt den Dateinamen fest, -C einen Kommentar und -q reduziert Meldungen. -N "" bedeutet: Der neu erzeugte private Schlüssel besitzt keine Passphrase. Wer diesen privaten Schlüssel erhält, kann ihn daher ohne zusätzliches Schlüsselpasswort benutzen. Gib nur die .pub-Datei weiter. chmod 700 erlaubt nur dem Besitzer den Zugriff auf das SSH-Verzeichnis; 600 erlaubt nur ihm Lesen und Schreiben des privaten Schlüssels. 644 macht den öffentlichen Schlüssel für andere lesbar, aber nur für den Besitzer beschreibbar.

if ! $key_ok; then
    mkdir -p "$HOME/.ssh" || die 5 "Kann $HOME/.ssh nicht erstellen."
    chmod 700 "$HOME/.ssh" || die 5 "Kann Rechte von ~/.ssh nicht setzen."
    log "Erzeuge ED25519-Schlüssel: $KEY"
    ssh-keygen -q -t ed25519 -f "$KEY" -C "PC-${SSH_ALIAS}" -N "" ||
        die 1 "SSH-Schlüssel konnte nicht erzeugt werden."
else
    log "INFO: Vorhandener Schlüssel wird weiterverwendet: $KEY"
fi

[[ -f "${KEY}.pub" ]] || die 1 "Öffentlicher Schlüssel fehlt: ${KEY}.pub"
chmod 600 "$KEY" || die 5 "Kann Rechte des privaten Schlüssels nicht setzen."
chmod 644 "${KEY}.pub" || die 5 "Kann Rechte des öffentlichen Schlüssels nicht setzen."

12. Alias ergänzen und Konfiguration sichern

Fehlt der Alias, legt das Skript die Konfigurationsdatei bei Bedarf an und setzt ihre Rechte auf 600. Eine bereits vorhandene, nicht leere Konfiguration wird vor dem Anhängen einmalig als config.original kopiert. Eine vorhandene Originalsicherung bleibt erhalten; bei einer leeren Datei entsteht keine Sicherung. Die Dateirechte wurden zu diesem Zeitpunkt bereits angepasst. cat >> hängt den Host-Block an. Er verbindet den Kurznamen mit Ziel, Benutzer und Schlüssel. Anschließend prüft ssh -G erneut die wirksamen Werte, weil andere SSH-Einstellungen Vorrang haben können. Ein Fehler nach dem Anhängen führt nicht zu einer automatischen Rücknahme.

if ! $alias_ok; then
    mkdir -p "$HOME/.ssh" || die 5 "Kann $HOME/.ssh nicht erstellen."
    chmod 700 "$HOME/.ssh" || die 5 "Kann Rechte von ~/.ssh nicht setzen."
    touch "$CONFIG" || die 5 "SSH-Konfiguration konnte nicht angelegt werden."
    chmod 600 "$CONFIG" || die 5 "Kann Rechte der SSH-Konfiguration nicht setzen."

    if [[ -s "$CONFIG" && ! -e "$ORIGINAL" ]]; then
        cp -a -- "$CONFIG" "$ORIGINAL" ||
            die 5 "Originalsicherung konnte nicht erstellt werden."
        log "Originalsicherung erstellt: $ORIGINAL"
    elif [[ -e "$ORIGINAL" ]]; then
        log "INFO: $ORIGINAL existiert bereits und wird nicht überschrieben."
    fi

    cat >> "$CONFIG" <<EOF

Host ${SSH_ALIAS}
    HostName ${SSH_HOST}
    User ${SSH_USER}
    IdentityFile ${KEY}
    IdentitiesOnly yes
EOF
    [[ $? -eq 0 ]] || die 5 "SSH-Alias konnte nicht geschrieben werden."
    effective="$(ssh -G "$SSH_ALIAS" 2>/dev/null)" || die 5 "SSH-Konfiguration ist ungültig."
    [[ "$(awk '$1 == "hostname" {print $2; exit}' <<< "$effective")" == "$SSH_HOST" &&
       "$(awk '$1 == "user" {print $2; exit}' <<< "$effective")" == "$SSH_USER" &&
       "$(awk '$1 == "identityfile" {print $2; exit}' <<< "$effective")" == "$KEY" ]] ||
        die 5 "Wirksamer Alias weicht ab; bitte ~/.ssh/config prüfen."
    log "SSH-Alias '${SSH_ALIAS}' wurde ergänzt."
fi

13. Vor einer Übertragung nochmals testen

Mit dem nun vorhandenen Schlüssel und Alias wird derselbe reine Schlüsseltest erneut ausgeführt. Funktioniert die Anmeldung bereits, ist keine Passwortübertragung nötig und sshpass wird nicht benötigt. Das ist beispielsweise möglich, wenn der öffentliche Schlüssel schon früher am Ziel hinterlegt wurde.

# Nach Schlüssel/Alias erneut prüfen, bevor sshpass benötigt wird.
if ssh -o BatchMode=yes \
       -o PasswordAuthentication=no \
       -o KbdInteractiveAuthentication=no \
       -o PreferredAuthentications=publickey \
       -o IdentitiesOnly=yes -i "$KEY" \
       -o ConnectTimeout=8 \
       "$SSH_ALIAS" true >/dev/null 2>&1; then
    log "BESTANDEN: SSH-Schlüsselanmeldung funktioniert."
    log "Keine weitere Änderung erforderlich."
    exit 0
fi

14. sshpass nur bei Bedarf prüfen

Erst nach einem fehlgeschlagenen Schlüsseltest wird geprüft, ob sshpass verfügbar ist. Es ermöglicht die Passwortübergabe an ssh-copy-id. Fehlt das Werkzeug, nennt das Skript den Installationsbefehl und endet mit Code 3. Bereits erzeugte Schlüssel und Konfigurationseinträge bleiben bestehen.

if ! command -v sshpass >/dev/null 2>&1; then
    {
        echo "FEHLENDE VORAUSSETZUNG"
        echo "Fehlt: sshpass"
        echo "Vorschlag unter Linux Mint:"
        echo "sudo apt install sshpass"
        echo "Es wird NICHT automatisch installiert."
    } | tee -a "$LOG_FILE"
    exit 3
fi

15. Passwort verdeckt abfragen

Die Abfrage findet nur statt, wenn SSH_PASSWORT leer ist. -t 0 prüft, ob die Standardeingabe ein Terminal ist. read -r -s -p liest das Passwort unverändert ein, zeigt die Eingabezeichen nicht an und gibt zuvor den Fragetext aus. Eine leere Eingabe oder ein fehlendes Terminal führt zu Code 7. Bei einem direkt eingetragenen Passwort wird dieser Abfrageblock übersprungen. Das gilt auch für den mitgelieferten Platzhalter: Er muss entweder geleert oder durch das tatsächliche Passwort ersetzt werden. Ein direkt eingetragenes Passwort danach wieder aus der Datei löschen und speichern.

if [[ -z "$SSH_PASSWORT" ]]; then
    [[ -t 0 ]] || die 7 "Passwort nötig; bitte interaktiv im Terminal starten."
    read -r -s -p "SSH-Passwort für ${SSH_USER}@${SSH_HOST}: " SSH_PASSWORT
    printf '\n'
    [[ -n "$SSH_PASSWORT" ]] || die 7 "Kein Passwort eingegeben."
fi

16. Öffentlichen Schlüssel auf das Ziel übertragen

SSHPASS wird als Umgebungsvariable gesetzt; sshpass -e liest daraus das Passwort. Es steht dadurch nicht als Kommandozeilenargument im Aufruf. Das ist keine verschlüsselte Passwortablage. ssh-copy-id -i überträgt den öffentlichen Schlüssel und ergänzt normalerweise ~/.ssh/authorized_keys des Zielbenutzers. Der private Schlüssel bleibt lokal. StrictHostKeyChecking=accept-new akzeptiert und speichert erstmals unbekannte Hostschlüssel automatisch, weist geänderte bekannte Hostschlüssel aber zurück. Prüfe deshalb vor der ersten Übertragung die Identität des Ziels über einen vertrauenswürdigen Weg. Die Verbindung nutzt hier Benutzer@Host, nicht den Alias. Nach der Übertragung wird die Umgebungsvariable entfernt, bei Erfolg auch die Skriptvariable geleert. Bei einem Übertragungsfehler endet das Skript mit Code 6.

# sshpass liest das Passwort aus der Umgebungsvariable; es erscheint nicht
# als Kommandozeilenargument.
export SSHPASS="$SSH_PASSWORT"

log "Übertrage öffentlichen Schlüssel auf den Zielrechner ..."
if ! sshpass -e ssh-copy-id \
        -o StrictHostKeyChecking=accept-new \
        -i "${KEY}.pub" \
        "${SSH_USER}@${SSH_HOST}"; then
    unset SSHPASS
    die 6 "ssh-copy-id ist fehlgeschlagen."
fi
unset SSHPASS
SSH_PASSWORT=""

17. Abschlussprüfung und spätere Anmeldung

Zum Abschluss wird wieder ausschließlich die Schlüsselanmeldung geprüft. Bei Erfolg nennt das Skript den späteren Verbindungsbefehl und beendet sich mit Code 0. Die bisherige Passwort-Anmeldung am Ziel bleibt weiterhin erlaubt. Schlägt der Test fehl, wird Code 6 zurückgegeben; zuvor ausgeführte Änderungen werden nicht automatisch rückgängig gemacht.

log "Teste Anmeldung ausschließlich mit SSH-Schlüssel ..."
if ssh -o BatchMode=yes \
       -o PasswordAuthentication=no \
       -o KbdInteractiveAuthentication=no \
       -o PreferredAuthentications=publickey \
       -o IdentitiesOnly=yes -i "$KEY" \
       -o ConnectTimeout=8 \
       "$SSH_ALIAS" true; then
    log "BESTANDEN: SSH-Schlüsselanmeldung funktioniert."
    log "Künftig genügt: ssh ${SSH_ALIAS}"
    log "Die Passwort-Anmeldung auf dem Ziel wurde NICHT deaktiviert."
    exit 0
fi

die 6 "Der abschließende SSH-Schlüsseltest ist fehlgeschlagen."

Nach erfolgreicher Einrichtung

Falls du das Passwort direkt eingetragen hast, öffne die Skriptdatei jetzt wieder im Editor, ersetze die Passwortzeile durch SSH_PASSWORT="" und speichere die Datei.

Verwende den von dir gewählten Alias. Für das Beispiel aus der Vorbereitung lautet der Befehl:

ssh laborvm

Mit exit beendest du die Sitzung auf dem Zielrechner. Das Kontopasswort wird bei funktionierender Schlüsselanmeldung nicht mehr benötigt. Der vom Skript neu erzeugte private Schlüssel hat keine Passphrase.

Dateien und Fehlersuche

Lokal: privater Schlüssel ~/.ssh/id_ed25519_<alias> und öffentlicher Schlüssel mit Endung .pub.
Lokal: Alias in ~/.ssh/config; gegebenenfalls einmalige Sicherung ~/.ssh/config.original.
Lokal: bekannte Hostschlüssel werden üblicherweise in ~/.ssh/known_hosts gespeichert.
Neben dem Skript: ssh_schluessel_einrichten.log, bei jedem Aufruf neu begonnen. Sichere ein benötigtes Fehlerlog vor dem nächsten Aufruf.
Am Ziel: öffentlicher Schlüssel normalerweise in ~/.ssh/authorized_keys des Zielbenutzers.

Den Rückgabecode kannst du unmittelbar nach dem Skriptaufruf mit echo $? anzeigen. 0 bedeutet Erfolg; 1 einen allgemeinen Fehler, 2 ungültige Parameter oder Zielangaben, 3 fehlende Werkzeuge, 5 Datei-, Berechtigungs- oder Konfigurationsprobleme, 6 einen SSH-/Übertragungsfehler und 7 eine erforderliche oder fehlende Benutzereingabe.

Bei einem Fehler zuerst die Terminalmeldung und das Log lesen. Prüfe Zieladresse, Erreichbarkeit und SSH-Dienst sowie Benutzername und Passwort. Bei einem vorhandenen, abweichenden Alias die SSH-Konfiguration prüfen; bei einem unvollständigen Schlüsselpaar die Dateien prüfen. Vorhandene Schlüssel nicht vorschnell löschen. Das Skript arbeitet mit den üblichen SSH-Einstellungen; es bietet kein eigenes Eingabefeld für einen abweichenden SSH-Port. Änderungen vor einem späteren Fehler bleiben erhalten.

Zurück zu Skripte