fixes pyca#12132 -- implement ssh public key fingerprints

Author: alex

CHANGELOG.rst

@@ -57,6 +57,8 @@ Changelog
   This extension defines the period during which the private key corresponding
   to the certificate's public key may be used.
 * Added support for compiling against `aws-lc`_.
+* Added :func:`~cryptography.hazmat.primitives.serialization.ssh_key_fingerprint`
+  for computing fingerprints of SSH public keys.
 
 .. _v44-0-2:
 

docs/hazmat/primitives/asymmetric/serialization.rst

@@ -426,6 +426,35 @@ DSA keys look almost identical but begin with ``ssh-dss`` rather than
     :raises cryptography.exceptions.UnsupportedAlgorithm: If the serialized
         key is of a type that is not supported.
 
+
+.. function:: ssh_key_fingerprint(key, hash_algorithm)
+
+    .. versionadded:: 45.0.0
+
+    Computes the fingerprint of an SSH public key.
+
+    :param key: The public key to compute the fingerprint for.
+    :type key: One of :data:`SSHPublicKeyTypes`
+
+    :param hash_algorithm: The hash algorithm to use, either ``MD5()`` or
+        ``SHA256()``.
+
+    :return: The key fingerprint.
+    :rtype: bytes
+
+    .. code-block:: pycon
+
+        >>> from cryptography.hazmat.primitives.serialization import load_ssh_public_key, ssh_key_fingerprint
+        >>> key_data = b"ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIAhVNvf1vigXfagQXKjdKN5zEF12KWVMVdDrU3sVLhgd [email protected]"
+        >>> public_key = load_ssh_public_key(key_data)
+        >>> md5_fingerprint = ssh_key_fingerprint(public_key, hashes.MD5())
+        >>> md5_fingerprint
+        b'95f6c0e3736fae6ecc98bbf4d8424a15'
+        >>> sha256_fingerprint = ssh_key_fingerprint(public_key, hashes.SHA256())
+        >>> sha256_fingerprint
+        b'Ug8qIZlmOZrNmFvoLSa6aKZ4loez+eCbsSzMvXTUw7c'
+
+
 OpenSSH Private Key
 ~~~~~~~~~~~~~~~~~~~
 

src/cryptography/hazmat/primitives/serialization/__init__.py

@@ -33,6 +33,7 @@
     load_ssh_private_key,
     load_ssh_public_identity,
     load_ssh_public_key,
+    ssh_key_fingerprint,
 )
 
 __all__ = [
@@ -60,4 +61,5 @@
     "load_ssh_private_key",
     "load_ssh_public_identity",
     "load_ssh_public_key",
+    "ssh_key_fingerprint",
 ]

src/cryptography/hazmat/primitives/serialization/ssh.py

@@ -4,6 +4,7 @@
 
 from __future__ import annotations
 
+import base64
 import binascii
 import enum
 import os
@@ -1152,6 +1153,46 @@ def _parse_exts_opts(exts_opts: memoryview) -> dict[bytes, bytes]:
     return result
 
 
+def ssh_key_fingerprint(
+    key: SSHPublicKeyTypes,
+    hash_algorithm: hashes.MD5 | hashes.SHA256,
+) -> bytes:
+    """
+    Computes the fingerprint of an SSH public key as bytes.
+
+    The fingerprint is computed over the public key's SSH encoding,
+    matching how OpenSSH's ssh-keygen computes fingerprints.
+
+    :param key: The public key to compute the fingerprint for.
+    :param hash_algorithm: The hash algorithm to use, either an instance of
+        MD5 or SHA256.
+
+    :return: The fingerprint as bytes. For MD5, hexadecimal encoded.
+             For SHA256, base64 encoded (without padding).
+    """
+    key_type = _get_ssh_key_type(key)
+    kformat = _lookup_kformat(key_type)
+
+    f_pub = _FragList()
+    f_pub.put_sshstr(key_type)
+    kformat.encode_public(key, f_pub)
+
+    ssh_binary_data = f_pub.tobytes()
+
+    # Hash the binary data
+    hash_obj = hashes.Hash(hash_algorithm)
+    hash_obj.update(ssh_binary_data)
+    digest = hash_obj.finalize()
+
+    # Format the output based on the hash algorithm
+    if isinstance(hash_algorithm, hashes.MD5):
+        return binascii.hexlify(digest)
+    elif isinstance(hash_algorithm, hashes.SHA256):
+        return base64.b64encode(digest).rstrip(b"=")
+    else:
+        raise TypeError("hash_algorithm must be either MD5 or SHA256")
+
+
 def load_ssh_public_key(
     data: utils.Buffer, backend: typing.Any = None
 ) -> SSHPublicKeyTypes:

tests/hazmat/primitives/test_ssh.py

@@ -15,6 +15,7 @@
     InvalidTag,
     UnsupportedAlgorithm,
 )
+from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import (
     dsa,
     ec,
@@ -36,6 +37,7 @@
     load_ssh_public_identity,
     load_ssh_public_key,
     ssh,
+    ssh_key_fingerprint,
 )
 
 from ...doubles import DummyKeySerializationEncryption
@@ -1868,3 +1870,96 @@ def test_load_application(self):
     def test_load_application_valueerror(self):
         with pytest.raises(ValueError):
             ssh.load_application(self.ssh_str("hss:test"))
+
+
+class TestSSHKeyFingerprint:
+    @pytest.mark.supported(
+        only_if=lambda backend: backend.hash_supported(hashes.MD5()),
+        skip_message="Does not support MD5",
+    )
+    def test_ssh_key_fingerprint_rsa_md5(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "rsa-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.MD5())
+        assert fingerprint == b"1047c26573d65149480b811f36047b52"
+
+    def test_ssh_key_fingerprint_rsa_sha256(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "rsa-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.SHA256())
+        assert fingerprint == b"gMB1ylYk/OsEsYNdmh6hjRfEZKIzvmuk6SCSaonm6CU"
+
+    @pytest.mark.supported(
+        only_if=lambda backend: backend.hash_supported(hashes.MD5())
+        and backend.ed25519_supported(),
+        skip_message="Does not support MD5 or Ed25519",
+    )
+    def test_ssh_key_fingerprint_ed25519_md5(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "ed25519-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.MD5())
+        assert fingerprint == b"e5523d019ea0c1e98c3f4c7cc5945785"
+
+    @pytest.mark.supported(
+        only_if=lambda backend: backend.ed25519_supported(),
+        skip_message="Ed25519 not supported",
+    )
+    def test_ssh_key_fingerprint_ed25519_sha256(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "ed25519-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.SHA256())
+        assert fingerprint == b"knottK/0LBWlxvM2cDgzzCJdQ0ppFlY/hzlHWlZTOLk"
+
+    @pytest.mark.supported(
+        only_if=lambda backend: backend.hash_supported(hashes.MD5()),
+        skip_message="Does not support MD5",
+    )
+    def test_ssh_key_fingerprint_ecdsa_md5(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "ecdsa-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.MD5())
+        assert fingerprint == b"0d65f22dfa47718c5e16b0352b061b37"
+
+    def test_ssh_key_fingerprint_ecdsa_sha256(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "ecdsa-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        fingerprint = ssh_key_fingerprint(public_key, hashes.SHA256())
+        assert fingerprint == b"W6Wr6d8N5R5y1rzZl8L03NTgrxc8adxeET7GkXdJSvU"
+
+    def test_ssh_key_fingerprint_unsupported_hash(self):
+        ssh_key = load_vectors_from_file(
+            os.path.join("asymmetric", "OpenSSH", "rsa-nopsw.key.pub"),
+            lambda f: f.read(),
+            mode="rb",
+        )
+        public_key = load_ssh_public_key(ssh_key)
+        with pytest.raises(TypeError):
+            ssh_key_fingerprint(public_key, hashes.SHA1())  # type: ignore[arg-type]
+
+    def test_ssh_key_fingerprint_unsupported_key(self):
+        with pytest.raises(ValueError):
+            ssh_key_fingerprint(object(), hashes.SHA256())  # type: ignore[arg-type]