Huella digital SHA256 ssh dada por el cliente pero solo la huella digital md5 conocida para el servidor

Al conectarse a un servidor nuevo / desconocido (con OpenSSH reciente), por ejemplo:

ssh example.com

Obtiene la huella digital como a continuación:

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)?

Sin embargo, las huellas digitales generalmente se dan para el servidor de esta forma:

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

¿Cómo puedo verificar la autenticidad (sin molestar a los administradores del servidor para que proporcionen una huella digital SHA256)?

Anteriormente, la huella digital se daba como un hash md5 hexadecimal. Comenzando con OpenSSH 6.8, la huella digital ahora se muestra como base64 SHA256 (por defecto). No puedes compararlos directamente.

También agregaron una nueva opción de configuración FingerprintHash. Puedes poner

FingerprintHash md5

en su ~/.ssh/configpara volver al antiguo valor predeterminado ( menos seguro ) o simplemente use esta opción para un solo uso:

ssh -o FingerprintHash=md5 example.org

lo que daría la huella digital como

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

Esperemos que los administradores del servidor proporcionen ambos tipos de huellas digitales en un futuro próximo.

EDITAR:

Como se da en los foros de Arch Linux , también hay una tercera opción:

Host example.org
    FingerprintHash md5

EDITAR:

Puede generar el hash de una clave arbitraria como se indica en el libro de cocina de OpenSSH :

Recupere la clave:

• descargar la clave con ssh-keyscan example.org > key.pub
• o: encuentre las claves en el servidor en /etc/ssh

Genera el hash:

• asegúrese de tener solo una línea / tipo, de modo que elimine todos los demás key.pubo ejecutessh-keyscan -t rsa example.org > key.pub
• ssh-keygen -l -f key.pub (hash predeterminado, según la versión de OpenSSH)
• ssh-keygen -l -f key.pub -E md5 (md5 en OpenSSH actual)
• awk '{print $2}' ssh_host_rsa_key.pub | base64 -d | sha256sum -b | awk '{print $1}' | xxd -r -p | base64 (sha256 en el antiguo OpenSSH)
• (Es posible que deba comenzar la línea con awk '{print $3}'las versiones más nuevas de ssh-keyscan porque el formato cambió)

Acabo de crear un pequeño script bash que imprimirá la tabla con huellas digitales para todos los cifrados de clave permitidos en el servidor (según /etc/ssh/sshd_config) en ambos SSH-256y MD5algo. Aquí hay un ejemplo de salida:

 +---------+---------+-----------------------------------------------------+
 | 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]-----+

El script también se ejecutará en servidores con la SSHversión siguiente 6.8(antes de que -E md5se agregara la opción).

Editar: versiones actualizadas para versiones aún más recientes de SSH que cambiaron los cifrados predeterminados ahora con soporte de imágenes 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

Esto es bastante impreso usando la información de JonnyJDla respuesta de. Gracias.

Resulta que ssh-keygen (en algún momento después de la versión 6.6; presumiblemente 6.8) tiene una -E md5opción que hará que imprima la huella digital como una huella digital md5. Por lo tanto, si puede tomar independientemente el archivo de clave pública del servidor, puede alimentarlo ssh-keygen -E md5 -l -f ssh_host_rsa_key.puby obtener su huella digital familiar.

El siguiente one-liner funciona (al menos) en Ubuntu 16.04,18.04 / Centos >= 7

(Probado con servidores: 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-

Salida:

# 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

intentó modificar para obtener también arte aleatorio en la tabla:

# 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

... pero en realidad no soy programador y el script no funciona como se esperaba. Agradecería si alguien puede ayudar a arreglar (también la limpieza). Sería bueno tener imágenes de arte aleatorias sha256 y md5 juntas para usar el espacio de manera más eficiente. También modifiqué los comandos md5 y sha256 ya que los originales no funcionaron para mí (probablemente un sistema demasiado nuevo): solo sha256 apareció en la tabla con el signo "=" al final, que no era parte de la huella digital real y no podía eliminarlo.

(lo siento, no pude comentar como me registré recientemente)