Empreinte SHA256 ssh donnée par le client mais uniquement empreinte md5 connue pour le serveur

Lors de la connexion à un nouveau serveur / inconnu (avec OpenSSH récent), par exemple:

ssh example.com

Vous obtenez l'empreinte digitale comme ci-dessous:

The authenticity of host 'example.org (192.0.2.42)' can't be established.
RSA key fingerprint is SHA256:7KMZvJiITZ+HbOyqjNPV5AeC5As2GSZES5baxy1NIe4.
Are you sure you want to continue connecting (yes/no)?

Cependant, les empreintes digitales sont généralement données pour le serveur sous cette forme:

f6:fc:1c:03:17:5f:67:4f:1f:0b:50:5a:9f:f9:30:e5

Comment puis-je vérifier l'authenticité (sans déranger les administrateurs du serveur pour qu'ils fournissent une empreinte SHA256)?

Auparavant, l'empreinte digitale était donnée sous la forme d'un hachage md5 hexadécimal. Depuis OpenSSH 6.8, l’empreinte est maintenant affichée en base64 SHA256 (par défaut). Vous ne pouvez pas les comparer directement.

Ils ont également ajouté une nouvelle option de configuration FingerprintHash. Tu peux mettre

FingerprintHash md5

dans votre ~/.ssh/configpour revenir à l'ancienne valeur par défaut ( moins sécurisée ) ou utilisez simplement cette option pour un usage unique:

ssh -o FingerprintHash=md5 example.org

ce qui donnerait l'empreinte digitale comme

MD5:f6:fc:1c:03:17:5f:67:4f:1f:0b:50:5a:9f:f9:30:e5

Espérons que les administrateurs de serveur fournissent les deux types d'empreintes dans un proche avenir.

MODIFIER:

Comme indiqué dans les forums Arch Linux , il existe également une troisième option:

Host example.org
    FingerprintHash md5

MODIFIER:

Vous pouvez générer le hachage d'une clé arbitraire comme indiqué sur le livre de cuisine OpenSSH :

Récupérer la clé:

• télécharger la clé avec ssh-keyscan example.org > key.pub
• ou: trouvez les clés sur le serveur dans /etc/ssh

Générez le hachage:

• assurez-vous que vous n’avez qu’une seule ligne / type, supprimez tous les autres key.pubou exécutez-le.ssh-keyscan -t rsa example.org > key.pub
• ssh-keygen -l -f key.pub (hachage par défaut, en fonction de la version d'OpenSSH)
• ssh-keygen -l -f key.pub -E md5 (md5 sur OpenSSH actuel)
• awk '{print $2}' ssh_host_rsa_key.pub | base64 -d | sha256sum -b | awk '{print $1}' | xxd -r -p | base64 (sha256 sur le vieil OpenSSH)
• (Vous devrez peut-être commencer la ligne avec les awk '{print $3}'nouvelles versions de ssh-keyscan car le format a changé)

Je viens de créer un petit script bash qui imprimera une table avec les empreintes digitales de tous les chiffrements clés autorisés sur le serveur (selon /etc/ssh/sshd_config) dans algo SSH-256et MD5al. Voici un exemple de sortie:

 +---------+---------+-----------------------------------------------------+
 | Cipher  | Algo    | Fingerprint                                         |
 +---------+---------+-----------------------------------------------------+
 | RSA     | MD5     | MD5:15:66:80:fd:79:d8:c0:92:e8:39:4a:bc:4e:c4:00:15 |
 | RSA     | SHA-256 | SHA256:G+rKuLGk+8Z1oxUV3cox0baNsH0qGQWm/saWPr4qZMM  |
 +---------+---------+-----------------------------------------------------+
 | ECDSA   | MD5     | MD5:f5:90:5c:03:2e:38:1b:c9:86:bd:86:47:5d:22:79:17 |
 | ECDSA   | SHA-256 | SHA256:GGmuOzsG4EGeRV9KD1WK7tRf3nIc40k/5jRgbTZDpTo  |
 +---------+---------+-----------------------------------------------------+
 | ED25519 | MD5     | MD5:d1:5a:04:56:37:f4:75:19:22:e6:e5:d7:41:fd:79:fa |
 | ED25519 | SHA-256 | SHA256:QVdqYeVzvsP4n5yjuN3D2fu8hDhskOxQCQAV5f9QK7w  |
 +---------+---------+-----------------------------------------------------+

 +---[RSA 2048]----+ +---[RSA 2048]----+ +---[ECDSA 256]---+ +---[ECDSA 256]---+ +--[ED25519 256]--+ +--[ED25519 256]--+
 |.oE.   +.++      | |        .o+=     | |      ... Eoo    | |  .. o.o..      .| |        ooo++o.+*| |   .o++o. +oo    |
 |  .   o +oo.     | |        .o= =    | |     +.=.=.o .   | | . .o *..      ..| |       . oo.+o.o=| |      ...o.+     |
 |   + . . o.=     | |       ... X +   | |    . X.o.*      | |o o  ++o      .. | |        . o. ...+| |       ..oo.o .  |
 |    = +  .+ o    | |      ..  = + o  | |     + = o o     | |.+  .o.o     .o  | |         +    ..o| |        =oo .+   |
 |   o o .S  .     | |     . .S  o o   | |    . = S   .    | |...  oo.S  .E* * | |        S      ..| |       .SO .  .  |
 |    +            | |    . E. =o..    | |     o           | | .. o.  . o *.O o| |              .  | |        o B .o.. |
 |   o             | | .o. *.o. *.     | |                 | |   ...   . o * * | |               . | |         E *..=.o|
 |    .            | | oo=...  +.      | |                 | |    +.      o + o| |                E| |          . +.+B+|
 |                 | |o+=.o....o+o     | |                 | |   .o+         . | |                 | |           o.ooOX|
 +------[MD5]------+ +----[SHA256]-----+ +------[MD5]------+ +----[SHA256]-----+ +------[MD5]------+ +----[SHA256]-----+

Le script sera également exécuté sur les serveurs de SSHversion ci-dessous 6.8(avant que l' -E md5option ait été ajoutée).

Éditer: versions mises à jour pour des versions encore plus récentes de SSH qui permutaient maintenant les chiffrements par défaut avec le support des images ASCII.

#!/bin/bash
# server_ssh_fingerprints
#
# Version 0.2
#
# 2016 Kepi <kepi@igloonet.cz
# MIT License
#
# Print fingerprint matrix for all allowed Host Keys
# with all allowed ciphers and MD5 and SHA-256 algos
#
# Changelog:
#
# 2018-03-11 (0.2):
# - Support for newer versions of OpenSSH
# - Added visual keys for all algos too - only in recent OpenSSH versions

# standard sshd config path
SSHD_CONFIG=/etc/ssh/sshd_config

# helper functions
function tablize {
    awk '{printf(" | %-7s | %-7s | %-51s |\n", $1, $2, $3)}'
}
LINE=" +---------+---------+-----------------------------------------------------+"

# header
echo "$LINE"
echo "Cipher" "Algo" "Fingerprint" | tablize
echo "$LINE"

declare -A ALGOS
declare -a ASCII

# fingerprints
while read -r host_key; do
    cipher=$(echo "$host_key" | sed -r 's/^.*ssh_host_([^_]+)_key\.pub$/\1/'| tr 'a-z' 'A-Z')
    if [[ -f "$host_key" ]]; then
        if ssh-keygen -E md5 -l -f "$host_key" &>/dev/null; then
        IFS=$'\n'

        for algo in md5 sha256; do
            n=0
            for line in $(ssh-keygen -E $algo -lv -f "$host_key"); do
                n=$(( n + 1))
                if [[ $n -eq 1 ]]; then
                    ALGOS[$algo]=$(echo "$line" | awk '{print $2}')
                else
                    ASCII[$n]="${ASCII[$n]} ${line}"
                fi
            done
        done
        else
            ALGOS[md5]=$(ssh-keygen -l -f "$host_key" | awk '{print $2}')
            ALGOS[sha256]=$(awk '{print $2}' "$host_key" | base64 -d | sha256sum -b | awk '{print $1}' | xxd -r -p | base64)
        fi

        echo "$cipher" MD5 "${ALGOS[md5]}" | tablize
        echo "$cipher" SHA-256 "${ALGOS[sha256]}" | tablize
        echo "$LINE"
    fi
 done < <(awk '/^HostKey/ {sub(/^HostKey\s+/,"");print $0".pub"};' $SSHD_CONFIG)

echo
for line in "${ASCII[@]}"; do
    echo "$line"
done

Ceci est juste joli imprimer en utilisant les informations de JonnyJDla réponse de. Merci.

il s'avère que ssh-keygen (quelque temps après la version 6.6; vraisemblablement, la 6.8) a une -E md5option qui lui permettra d’imprimer l’empreinte digitale sous la forme d’une empreinte digitale md5. Ainsi, si vous pouvez récupérer indépendamment le fichier de clé publique du serveur, vous pouvez l’alimenter ssh-keygen -E md5 -l -f ssh_host_rsa_key.pubet obtenir votre empreinte digitale.

Le one-liner suivant fonctionne (au moins) sur Ubuntu 16.04,18.04 / Centos >= 7

(Testé avec des serveurs: openssh 3.9- openssh 7.4)

ssh-keygen -l -E md5 -f <(ssh-keyscan -t rsa 192.168.2.1) \
| awk '{print $2}' | cut -d":" -f 2-

Sortie:

# 192.168.2.1:22 SSH-2.0-OpenSSH_5.3
65:2c:c4:03:03:2f:6d:c0:c0:09:79:e7:33:c4:f1:78

essayé de modifier pour obtenir également l'art aléatoire dans la table:

# standard sshd config path
SSHD_CONFIG=/etc/ssh/sshd_config

# helper functions
function tablize {
        awk '{printf("| %-7s | %-51s |\n", $1, $3)}'
}
LINE="+---------+-----------------------------------------------------+"

# header
echo $LINE
echo "Cipher" "Fingerprint" "Fingerprint" | tablize
echo $LINE

# fingerprints
for host_key in $(awk '/^HostKey/ {sub(/^HostKey\s+/,"");print $0".pub"};' $SSHD_CONFIG); do
        cipher=$(echo $host_key | sed -r 's/^.*ssh_host_([^_]+)_key\.pub$/\1/'| tr '[a-z]' '[A-Z]')
        if [[ -f "$host_key" ]]; then
                md5=$(ssh-keygen -l -f $host_key -E md5 | awk '{print $2}')
                sha256=$(ssh-keygen -l -f $host_key | awk '{print $2}')
                art_sha256=$(ssh-keygen -lv -f $host_key | grep -v -w "256 SHA256" | grep -v -w "1024 SHA256" | grep -v -w "2048 SHA256")
                art_md5=$(ssh-keygen -lv -f $host_key -E md5 | grep -v "256 MD5" | grep -v "1024 MD5" | grep -v "2048 MD5")

                echo $cipher MD5 $md5 | tablize
                echo $cipher SHA-256 $sha256 | tablize
                echo $art_sha256 | tablize
                echo $art_md5 | tablize
                echo $LINE
        fi
done

... mais je ne suis pas un programmeur et le script ne fonctionne pas comme prévu. J'apprécierais si quelqu'un peut aider à réparer (également le nettoyage). Il serait bien d’avoir côte à côte des images d’art aléatoires sha256 et md5 pour utiliser l’espace plus efficacement. J'ai également modifié les commandes md5 et sha256 car les commandes d'origine ne fonctionnaient pas pour moi (système probablement trop nouveau) - seul sha256 a été placé dans une table avec le signe "=" à la fin, ce qui ne faisait pas partie de l'empreinte réelle et ne pouvait pas l'enlever.

(désolé je ne pouvais pas commenter car je me suis inscrit récemment)