SHA256 impronta digitale ssh fornita dal client ma solo impronta md5 nota per il server

Quando ci si connette a un server nuovo / sconosciuto (con OpenSSH recente), ad esempio:

ssh example.com

Ottieni l'impronta digitale come di seguito:

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

Tuttavia, le impronte digitali vengono generalmente fornite per il server in questo formato:

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

Come posso verificare l'autenticità (senza disturbare gli amministratori del server a fornire un'impronta digitale SHA256)?

In precedenza l'impronta digitale veniva data come hash md5 esadecimale. A partire da OpenSSH 6.8 l'impronta digitale viene ora visualizzata come base64 SHA256 (per impostazione predefinita). Non puoi confrontarli direttamente.

Hanno anche aggiunto una nuova opzione di configurazione FingerprintHash. Puoi mettere

FingerprintHash md5

nella vostra ~/.ssh/configper tornare al vecchio ( meno sicuro di default) o semplicemente usare questa opzione uso singola:

ssh -o FingerprintHash=md5 example.org

che darebbe l'impronta digitale come

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

Si spera che gli amministratori del server forniscano entrambi i tipi di impronte digitali nel prossimo futuro.

MODIFICARE:

Come indicato nei forum di Arch Linux , esiste anche una terza opzione:

Host example.org
    FingerprintHash md5

MODIFICARE:

Puoi generare l'hash di una chiave arbitraria come indicato nel ricettario OpenSSH :

Recupera la chiave:

• scarica la chiave con ssh-keyscan example.org > key.pub
• oppure: trova le chiavi sul server in /etc/ssh

Genera l'hash:

• assicurati di avere solo una riga / tipo, quindi elimina tutti gli altri key.pubo eseguissh-keyscan -t rsa example.org > key.pub
• ssh-keygen -l -f key.pub (hash predefinito, a seconda della versione di OpenSSH)
• ssh-keygen -l -f key.pub -E md5 (md5 sull'attuale OpenSSH)
• awk '{print $2}' ssh_host_rsa_key.pub | base64 -d | sha256sum -b | awk '{print $1}' | xxd -r -p | base64 (sha256 sul vecchio OpenSSH)
• (Potrebbe essere necessario iniziare la riga con awk '{print $3}'le versioni più recenti di ssh-keyscan perché il formato è cambiato)

Ho appena creato un piccolo script bash che stamperà la tabella con le impronte digitali per tutte le cifre chiave consentite sul server (secondo /etc/ssh/sshd_config) in entrambi SSH-256e in MD5algo. Ecco un esempio di output:

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

Lo script verrà eseguito anche su server con la SSHversione seguente 6.8(prima -E md5dell'aggiunta dell'opzione).

Modifica: versioni aggiornate per versioni ancora più recenti di SSH che ora hanno cambiato le cifre predefinite con il supporto delle immagini 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

Questa è solo una bella stampa usando le informazioni della JonnyJDrisposta. Grazie.

risulta che ssh-keygen (qualche tempo dopo la versione 6.6; presumibilmente 6.8) ha -E md5un'opzione che le farà stampare l'impronta digitale come impronta digitale md5. Quindi, se puoi prendere in modo indipendente il file della chiave pubblica del server, puoi alimentarlo ssh-keygen -E md5 -l -f ssh_host_rsa_key.pube ottenere la tua impronta digitale familiare.

Il seguente one-liner funziona (almeno) su Ubuntu 16.04,18.04 / Centos >= 7

(Testato con server: 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-

Produzione:

# 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

provato a modificare per ottenere anche arte casuale nella tabella:

# 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

... ma in realtà non sono un programmatore e lo script non funziona come previsto. Gradirei se qualcuno potesse aiutare a risolvere (anche la pulizia). Sarebbe bello avere immagini d'arte casuali sha256 e md5 fianco a fianco per usare lo spazio in modo più efficiente. Ho modificato anche i comandi md5 e sha256 poiché quelli originali non funzionavano per me (probabilmente un sistema troppo nuovo) - solo sha256 è stato creato nella tabella con il segno "=" alla fine che non faceva parte dell'impronta digitale effettiva e non è stato possibile rimuoverlo.

(scusate non ho potuto commentare come mi sono registrato di recente)