Un brin de réseau

Ce blog propose des articles sur les technologies réseaux et leur utilisation, le tout illustré avec des maquettes et des captures.

Python freeradius-api Python diffplus

OpenSSH : clé publique et fingerprint

Cet article constitue un complément à celui sur la signature-based authentication appliquée à SSH. Il montre la façon dont OpenSSH encode une clé publique RSA dans les fichiers known_hosts et id_rsa.pub, comment il en génère l'empreinte, ou fingerprint, et explique l'intérêt de celle-ci.

Contexte

Lorsqu'un client se connecte à un serveur SSH, il doit s'authentifier auprès du serveur, par clé publique ou mot de passe, mais avant tout, c'est le serveur qui s'authentifie auprès du client.

Pour cela, le serveur envoie—dans un paquet concluant l'échange KEX (Key EXchange)—sa clé publique RSA au client qui doit, à sa première connexion, l'accepter ou non :


    $ ssh admin@192.168.122.254 -vvv
    […]
    debug1: SSH2_MSG_KEXINIT sent
    debug1: SSH2_MSG_KEXINIT received
    […]
    debug1: kex: algorithm: diffie-hellman-group-exchange-sha256
    debug1: kex: host key algorithm: rsa-sha2-256
    debug1: kex: server->client cipher: aes128-ctr MAC: hmac-sha2-256 compression: none
    debug1: kex: client->server cipher: aes128-ctr MAC: hmac-sha2-256 compression: none
    […]
    debug1: SSH2_MSG_KEX_DH_GEX_REQUEST(2048<8192<8192) sent
    debug1: SSH2_MSG_KEX_DH_GEX_GROUP received
    debug1: SSH2_MSG_KEX_DH_GEX_INIT sent
    debug1: SSH2_MSG_KEX_DH_GEX_REPLY received
    […]
    debug3: hostkeys_foreach: reading file "/home/brindereseau/.ssh/known_hosts"
    The authenticity of host '192.168.122.254 (192.168.122.254)' can't be established.
    RSA key fingerprint is SHA256:y5NfcIqOn3D7YLrIg2+1EwX8rD6dv1BP5gfK4jK9Ijw.
    This key is not known by any other names
    Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
    Warning: Permanently added '192.168.122.254' (RSA) to the list of known hosts.
    […]

Cet extrait du debug montre la négociation des différents algorithmes, en particulier celui de la signature ou host key algorithm utilisé pour l'authentification du serveur auprès du client.

Il s'agit ici de l'algorithme rsa-sha2-256 décrit dans la RFC 8332 et associé au schéma de signature \(\text{RSASSA-PKCS1-v1\_5}\) introduit dans l'article Chiffrement et signature RSA.

Retrouver le format OpenSSH depuis la clé publique

En acceptant la clé publique du serveur, OpenSSH ajoute l'entrée suivante dans le fichier known_hosts du client : 


    $ tail -1 .ssh/known_hosts
    192.168.122.254 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

L'entrée contient l'adresse IP ou le hostname du serveur auquel le client se connecte, le type de clé publique du serveur ainsi qu'un charabia—ce qui nous intéresse ici—commençant par AAAA.

Ce charabia contient en fait le type de clé publique (RSA) avec ses deux paramètres \((n, e)\). Il s'agit d'un format binaire spécifique à OpenSSH, encodé en base64, qu'il emprunte à la RFC 4253 :


    The "ssh-rsa" key format has the following specific encoding:

        string    "ssh-rsa"
        mpint     e
        mpint     n

C'est conformément à ce format que le serveur présente sa clé publique RSA au client dans le paquet SSH_MSG_KEXDH_REPLY qui conclue l'échange KEX :

cap-ssh-pubkey
Le serveur envoie sa clé publique RSA \((n, e\)) au client dans le paquet SSH_MSG_KEXDH_REPLY.

La RFC 4251 décrit, elle, les types string et mpint. En gros, ils correspondent à la longueur codée sur 4 octets du nombre d'octets qui va suivre, avec ensuite les octets en question.

La capture le montre clairement. Pour chaque champ, la longueur précède la valeur :


    Host key type length: 7
    Host key type: ssh-rsa
    Multi Precision Integer Length: 3
    RSA public exponent (e): 010001
    Multi Precision Integer Length: 257
    RSA modulus (N) […]: 00d8de3d67b9ba8623682df6875487d1a74457f[…]

Le type mpint, abréviation de multi precision integer, permet la représentation d'entiers signés. Pour un entier positif, si son premier bit ne vaut pas 0 (cas de \(n\)), il faut ajouter l'octet 0x00 au début, d'où la taille affichée de 257 octets bien qu'il s'agisse d'une clé de 256 octets (2048 bits).

Conformément à ce format, le type de clé ssh-rsa est encodé ainsi :


    00 00 00 07           # 7 octets vont suivre (nombre exprimé lui-même sur 4 octets)
    73 73 68 2d 72 73 61  # codage ASCII de "ssh-rsa" sur 7 octets

Pour l'exposant \(e = 65537\) :


    00 00 00 03  # 3 octets vont suivre
    01 00 01     # valeur de e en hexadécimal sur 3 octets

Et pour le module \(n\) :


    00 00 01 01  # 257 octets vont suivre
    00           # 1 octet pour le signe positif de n car son premier bit ne vaut pas 0

    # valeur de n en hexadécimal sur 256 octets
    d8 de 3d 67 b9 ba 86 23 68 2d f6 87 54 87 d1 a7 44 57 fc 1b 9c 47 67 aa 7f 96 3b 5a 52 60 17 a8
    50 0d 60 8c a9 75 d0 38 05 9e 0e f0 0e b4 40 56 5b 99 67 c7 a2 67 ea 5b 3c 7e 20 05 43 86 4a fc
    2e f5 32 c8 fc a2 2b 48 7b 5a df 3d 1a 9b 86 47 9d 03 59 23 76 8d 9d 4c d0 01 4a 30 2c c4 bb 06
    56 7c 9e 77 98 89 f6 40 3d 8f 7b d7 67 a1 80 23 67 e2 86 7f 54 35 f2 ca ae e3 25 2e 43 0a a6 99
    34 b7 4b 0e cd fa 89 af 80 2e 3e e1 18 d9 78 e7 63 f5 2a 1a 4e 67 51 10 23 47 c2 1a 8b 30 5c d5
    53 0e 30 1d 16 aa 1a 59 e9 51 a9 42 7c 45 f9 57 3a ce a6 fc b4 2d 04 13 e4 18 f7 15 29 3d 1e dc
    b1 63 44 b7 65 59 10 6a 7d 03 6d 10 5b 2d 49 7d 52 7f e8 fa 47 3b 1f c4 88 de 27 7a 12 67 ac d6
    d9 47 c9 e2 f1 03 37 97 5e 13 db 6d d1 0f 7b f2 9d 8d 5f 3d f7 b2 8c 07 e2 79 65 39 3f b5 c8 e3

Reste à concaténer l'ensemble et à encoder le résultat en base64, par exemple en Python :


    from base64 import b64encode

    hex_string = (
        # key type "ssh-rsa"
        "000000077373682d727361" +
        # exponent "e = 65537"
        "00000003010001" +
        # modulus "n"
        "0000010100d8de3d67b9ba8623682df6875487d1a74457fc1b9c4767aa7f963b5a526017a8500d608ca975d038059e0ef00eb440565b9967c7a267ea5b3c7e200543864afc2ef532c8fca22b487b5adf3d1a9b86479d035923768d9d4cd0014a302cc4bb06567c9e779889f6403d8f7bd767a1802367e2867f5435f2caaee3252e430aa69934b74b0ecdfa89af802e3ee118d978e763f52a1a4e6751102347c21a8b305cd5530e301d16aa1a59e951a9427c45f9573acea6fcb42d0413e418f715293d1edcb16344b76559106a7d036d105b2d497d527fe8fa473b1fc488de277a1267acd6d947c9e2f10337975e13db6dd10f7bf29d8d5f3df7b28c07e27965393fb5c8e3"
    )
    octets = bytearray.fromhex(hex_string)

    encoded_public_key = b64encode(octets)
    print(encoded_public_key.decode(encoding="ascii"))

Ce qui donne :


    AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

Cela correspond exactement à l'entrée ajoutée par OpenSSH dans le fichier known_hosts :


    $ tail -1 .ssh/known_hosts | cut -d" " -f3
    AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

Retrouver la clé publique depuis le format OpenSSH

La section précédente a effectué le plus dur du travail, en expliquant et en montrant que le format OpenSSH n'est autre que l'encodage base64 d'un format binaire emprunté à la RFC 4253 :


    The "ssh-rsa" key format has the following specific encoding:

        string    "ssh-rsa"
        mpint     e
        mpint     n

Par conséquent, donnée la clé publique RSA suivante :


    $ tail -1 .ssh/known_hosts | cut -d" " -f3
    AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

Nous retrouvons les paramètres \((n, e)\) en décodant le base64 de cette entrée et en affichant la représentation hexadécimale, par exemple avec la commande xxd :


    $ tail -1 .ssh/known_hosts | cut -d" " -f3 | base64 -d | xxd -p
    000000077373682d727361000000030100010000010100d8de3d67b9ba86
    23682df6875487d1a74457fc1b9c4767aa7f963b5a526017a8500d608ca9
    75d038059e0ef00eb440565b9967c7a267ea5b3c7e200543864afc2ef532
    c8fca22b487b5adf3d1a9b86479d035923768d9d4cd0014a302cc4bb0656
    7c9e779889f6403d8f7bd767a1802367e2867f5435f2caaee3252e430aa6
    9934b74b0ecdfa89af802e3ee118d978e763f52a1a4e6751102347c21a8b
    305cd5530e301d16aa1a59e951a9427c45f9573acea6fcb42d0413e418f7
    15293d1edcb16344b76559106a7d036d105b2d497d527fe8fa473b1fc488
    de277a1267acd6d947c9e2f10337975e13db6dd10f7bf29d8d5f3df7b28c
    07e27965393fb5c8e3

Ensuite, il faut parser le résultat conformément au format défini par la RFC, ce qui donne :


    00000007        -> key type length = 7 bytes
    7373682d727361  -> key type value = ssh-rsa
    00000003        -> exponent e length = 3 bytes
    010001          -> exponent e value = 65537
    00000101        -> modulus n length = 257 bytes
    00d8de3d67b9[…] -> modulus n value = 2737706443409117132602595736[…]

Pour rappel, en raison du type mpint, la taille affichée de \(n\) est 257 octets car, contrairement à \(e\), son premier bit ne valant pas 0, l'octet 0x00 a été ajouté pour lui donner son signe positif.

Le module \(n\) est en réalité codé sur 256 octets. Autrement dit, il s'agit d'une clé RSA de 2048 bits.

Empreinte d'une clé publique

Lorsqu'un client se connecte à un serveur, pour la première fois et les fois suivantes, une empreinte, ou fingerprint, de la clé publique du serveur lui est présentée :


    $ ssh admin@192.168.122.254 -o VisualHostKey=yes
    […]
    RSA key fingerprint is SHA256:y5NfcIqOn3D7YLrIg2+1EwX8rD6dv1BP5gfK4jK9Ijw.
    +---[RSA 2048]----+
    |     .           |
    |      o          |
    |       +         |
    |        +        |
    |       oS o =    |
    |      +. * X .   |
    |   o o.=%.+ + .  |
    |  ..E.OO+O . .   |
    |   o+++OB+=.     |
    +----[SHA256]-----+
    This key is not known by any other names
    Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
    Warning: Permanently added '192.168.122.254' (RSA) to the list of known hosts.

Cette empreinte apparaît sous deux formes : un hash et, optionnellement, une représentation davantage visuelle via l'option VisualHostKey=yes.

Intérêt

La RFC 4716 en explique l'intérêt :


    The security of the SSH protocols relies on the verification of
    public host keys.  Since public keys tend to be very large, it is
    difficult for a human to verify an entire host key.  Even with a
    Public Key Infrastructure (PKI) in place, it is useful to have a
    standard for exchanging short fingerprints of public keys.

En raison de la longueur des clés publiques, souvent de 2048 bits aujourd'hui pour RSA, il ne s'avère pas facile de vérifier en un coup d'œil que la clé publique présentée appartient au bon serveur (dans l'hypothèse où nous connaissons à l'avance la vraie clé publique du serveur pour pouvoir comparer) ou qu'elle n'a pas changé depuis la dernière connexion.

L'empreinte se définit comme une version courte de la clé publique. Elle aide le client, visuellement parlant, à s'assurer qu'il communique avec le bon serveur—toujours dans l'hypothèse où il connaît à l'avance l'empreinte de la clé publique du serveur.

Si l'utilisation de certificats (PKI) règle en général le problème de confiance en la clé publique présentée par le serveur, avoir une version courte du certificat demeure quand même pratique. Par exemple, lorsque nous ajoutons le certificat d'une CA sur un CPE Cisco :


    CPE(config)#crypto pki authenticate MY-TP

    Enter the base 64 encoded CA certificate.
    End with a blank line or the word "quit" on a line by itself

    -----BEGIN CERTIFICATE-----
    MIIDeTCCAmGgAwIBAgIUZhHUvZ6xFp+zx6kYvg8iZ1UkWagwDQYJKoZIhvcNAQEL
    BQAwTDELMAkGA1UEBhMCRlIxEzARBgNVBAgMClNvbWUtU3RhdGUxEDAOBgNVBAoM
    B0NlbGVzdGUxFjAUBgNVBAMMDWNhLmNlbGVzdGUuZnIwHhcNMjYwNDI0MDgxN[…]
    -----END CERTIFICATE-----

    Certificate has the following attributes:
           Fingerprint MD5: B226D20A A683785F C961234F 56B26CDC
          Fingerprint SHA1: 1562BF73 1240A1B5 581A33E7 191C1D2D 12DB69FD

    % Do you accept this certificate? [yes/no]: yes

Deux empreintes apparaissent, l'une en MD5 et l'autre en SHA1. Il faut les comparer visuellement à celles fournies par la CA par un moyen hors bande (mail, Web, etc.) afin de s'assurer que nous importons le bon certificat.

Je trouve enfin que l'exemple Cisco ci-dessus illsutre bien le parallèle entre clé publique et certificat : dans les deux cas, l'utilisateur doit l'accepter explicitement (ou refuser).

La section suivante montre comment OpenSSH génère l'empreinte d'une clé publique RSA.

Génération

L'empreinte correspond simplement à un hash de la clé publique encodée selon le format binaire ssh-rsa abordé dans la section précédente, comme stipulé par la RFC 4716 :


    The fingerprint of a public key consists of the output of the MD5
    message-digest algorithm [RFC1321].  The input to the algorithm is
    the public key data as specified by [RFC4253].  (This is the same
    data that is base64 encoded to form the body of the public key file.

L'extrait mentionne le MD5 comme hash, ce qui valait jusqu'à la version 6.8 d'OpenSSH qui, depuis, utilise le SHA-256 :


    * Add FingerprintHash option to ssh(1) and sshd(8), and equivalent
      command-line flags to the other tools to control algorithm used
      for key fingerprints. The default changes from MD5 to SHA256 and
      format from hex to base64.

De plus, OpenSSH encode le hash en base64. Je suppose qu'il considère la longueur du hash en SHA-256, 64 caractères, trop grande pour une vérification visuelle, comparée à celle en base64 réduite à 44 caractères—sachant qu'il retire le dernier = issu du padding et considéré superflu.

Le paramètre d'entrée de la fonction hash est la clé publique encodée au format binaire ssh-rsa, c'est-à-dire la troisème colonne de :


    $ tail -1 .ssh/known_hosts
    192.168.122.254 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

J'illustre ci-dessous trois méthodes de génération d'empreinte, de la plus pénible à la plus simple.

Appliquer le hash sur clé publique encodée manuellement

Reprenons le code Python qui construit l'encodage de la clé publique du serveur :


    from base64 import b64encode

    hex_string = (
        # key type "ssh-rsa"
        "000000077373682d727361" +
        # exponent "e = 65537"
        "00000003010001" +
        # modulus "n"
        "0000010100d8de3d67b9ba8623682df6875487d1a74457fc1b9c4767aa7f963b5a526017a8500d608ca975d038059e0ef00eb440565b9967c7a267ea5b3c7e200543864afc2ef532c8fca22b487b5adf3d1a9b86479d035923768d9d4cd0014a302cc4bb06567c9e779889f6403d8f7bd767a1802367e2867f5435f2caaee3252e430aa69934b74b0ecdfa89af802e3ee118d978e763f52a1a4e6751102347c21a8b305cd5530e301d16aa1a59e951a9427c45f9573acea6fcb42d0413e418f715293d1edcb16344b76559106a7d036d105b2d497d527fe8fa473b1fc488de277a1267acd6d947c9e2f10337975e13db6dd10f7bf29d8d5f3df7b28c07e27965393fb5c8e3"
    )
    octets = bytearray.fromhex(hex_string)

Il suffit d'appliquer le hash SHA-256 sur les octets puis d'encoder le résultat en base64 :


    from hashlib import sha256

    hash = sha256(octets)
    print(hash.hexdigest())
    # cb935f708a8e9f70fb60bac8836fb51305fcac3e9dbf504fe607cae232bd223c

    fingerprint = b64encode(hash.digest())
    print(fingerprint.decode(encoding="ascii"))
    # y5NfcIqOn3D7YLrIg2+1EwX8rD6dv1BP5gfK4jK9Ijw=

Nous retrouvons bien l'empreinte avec ici en plus le caractère final = qui reste à enlever.

Appliquer le hash sur clé publique déjà encodée

Nous partons cette fois de la clé publique déjà encodée par OpenSSH que j'ai placée, pour simplifier les commandes, dans un fichier rsa-key.pub :


    $ cat rsa-key.pub
    192.168.122.254 ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDY3j1nubqGI2gt9odUh9GnRFf8G5xHZ6p/ljtaUmAXqFANYIypddA4BZ4O8A60QFZbmWfHomfqWzx+IAVDhkr8LvUyyPyiK0h7Wt89GpuGR50DWSN2jZ1M0AFKMCzEuwZWfJ53mIn2QD2Pe9dnoYAjZ+KGf1Q18squ4yUuQwqmmTS3Sw7N+omvgC4+4RjZeOdj9SoaTmdRECNHwhqLMFzVUw4wHRaqGlnpUalCfEX5VzrOpvy0LQQT5Bj3FSk9HtyxY0S3ZVkQan0DbRBbLUl9Un/o+kc7H8SI3id6Emes1tlHyeLxAzeXXhPbbdEPe/KdjV8997KMB+J5ZTk/tcjj

Cela demande quelques manipulations, à commencer par sha256sum après avoir décodé le base64 :


    $ cat rsa-key.pub | base64 -d | sha256sum | cut -d" " -f1
    cb935f708a8e9f70fb60bac8836fb51305fcac3e9dbf504fe607cae232bd223c

Nous retrouvons bien ci-dessus le hash SHA-256 calculé en Python. Il reste, après l'avoir interprété comme suite d'octets avec xxd, à l'encoder en base64 :


    $ cat rsa-key.pub | base64 -d | sha256sum | cut -d" " -f1 | xxd -r -p | base64
    y5NfcIqOn3D7YLrIg2+1EwX8rD6dv1BP5gfK4jK9Ijw=

Nous retrouvons bien l'empreinte avec ici en plus le caractère final = qui reste à enlever.

La solution de facilité

OpenSSH propose un utilitaire de génération d'empreinte depuis un fichier de clé publique :


    $ ssh-keygen -lf rsa-key.pub -E sha256 -v
    2048 SHA256:y5NfcIqOn3D7YLrIg2+1EwX8rD6dv1BP5gfK4jK9Ijw 192.168.122.174 (RSA)
    +---[RSA 2048]----+
    |     .           |
    |      o          |
    |       +         |
    |        +        |
    |       oS o =    |
    |      +. * X .   |
    |   o o.=%.+ + .  |
    |  ..E.OO+O . .   |
    |   o+++OB+=.     |
    +----[SHA256]-----+

Nous pouvons aussi générer l'ancienne empreinte MD5 :


    $ ssh-keygen -lf rsa-key.pub -E md5 -v
    2048 MD5:ee:04:a8:20:0a:9b:21:6b:d0:b0:79:c8:eb:01:ae:73 192.168.122.174 (RSA)
    +---[RSA 2048]----+
    |                 |
    |                 |
    |.                |
    |.*   .           |
    |%.o . . S        |
    |OB..   o         |
    |==.     o        |
    |= E    o         |
    |.+      .        |
    +------[MD5]------+

De plus, en donnant l'option -v, OpenSSH génère une représentation visuelle en ASCII de l'empreinte. Vous le verrez aussi lors de la génération de la paire de clés qui engendre la création du fichier id_rsa.pub. OpenSSH parle de random art et en explique l'intérêt dans sshkey.c#L1106 :


    /*
     * Draw an ASCII-Art representing the fingerprint so human brain can
     * profit from its built-in pattern recognition ability.
     * This technique is called "random art" and can be found in some
     * scientific publications like this original paper:
     *
     * "Hash Visualization: a New Technique to improve Real-World Security",
     * Perrig A. and Song D., 1999, […]
     */
     static char * fingerprint_randomart()

Il s'agit juste d'une autre façon de représenter la clé publique, censée être plus simple à retenir et à comparer que la version écrite de l'empreinte. En pratique, à ma connaissance, personne ne s'attarde vraiment sur ces dessins, ni ne les compare.