feat(serialization): add support for OpenSSH private key comments

src/cryptography/hazmat/primitives/asymmetric/dh.py

@@ -144,6 +144,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         Returns the key serialized as bytes.

src/cryptography/hazmat/primitives/asymmetric/dsa.py

@@ -79,6 +79,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         Returns the key serialized as bytes.

src/cryptography/hazmat/primitives/asymmetric/ec.py

@@ -113,6 +113,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         Returns the key serialized as bytes.

src/cryptography/hazmat/primitives/asymmetric/ed25519.py

@@ -82,6 +82,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

src/cryptography/hazmat/primitives/asymmetric/ed448.py

@@ -114,6 +114,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

src/cryptography/hazmat/primitives/asymmetric/mldsa.py

@@ -127,6 +127,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

src/cryptography/hazmat/primitives/asymmetric/mlkem.py

@@ -249,6 +249,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

src/cryptography/hazmat/primitives/asymmetric/rsa.py

@@ -60,6 +60,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         Returns the key serialized as bytes.

src/cryptography/hazmat/primitives/asymmetric/x25519.py

@@ -100,6 +100,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

src/cryptography/hazmat/primitives/asymmetric/x448.py

@@ -102,6 +102,8 @@ def private_bytes(
         encoding: _serialization.Encoding,
         format: _serialization.PrivateFormat,
         encryption_algorithm: _serialization.KeySerializationEncryption,
+        *,
+        comment: bytes = b"",
     ) -> bytes:
         """
         The serialized bytes of the private key.

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

@@ -33,6 +33,7 @@
     SSHPrivateKeyTypes,
     SSHPublicKeyTypes,
     load_ssh_private_key,
+    load_ssh_private_key_with_comment,
     load_ssh_public_identity,
     load_ssh_public_key,
     ssh_key_fingerprint,
@@ -61,6 +62,7 @@
     "load_pem_private_key",
     "load_pem_public_key",
     "load_ssh_private_key",
+    "load_ssh_private_key_with_comment",
     "load_ssh_public_identity",
     "load_ssh_public_key",
     "ssh_key_fingerprint",

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

@@ -669,14 +669,17 @@ def _lookup_kformat(key_type: utils.Buffer):
 ]
 
 
-def load_ssh_private_key(
+def load_ssh_private_key_with_comment(
     data: utils.Buffer,
     password: bytes | None,
     backend: typing.Any = None,
     *,
     unsafe_skip_rsa_key_validation: bool = False,
-) -> SSHPrivateKeyTypes:
-    """Load private key from OpenSSH custom encoding."""
+) -> tuple[SSHPrivateKeyTypes, bytes]:
+    """
+    Load private key from OpenSSH custom encoding and
+    return (key, comment).
+    """
     utils._check_byteslike("data", data)
     if password is not None:
         utils._check_bytes("password", password)
@@ -772,8 +775,9 @@ def load_ssh_private_key(
         pubfields,
         unsafe_skip_rsa_key_validation=unsafe_skip_rsa_key_validation,
     )
-    # We don't use the comment
-    _, edata = _get_sshstr(edata)
+
+    # Capture the comment instead of discarding it with _
+    comment, edata = _get_sshstr(edata)
 
     # yes, SSH does padding check *after* all other parsing is done.
     # need to follow as it writes zero-byte padding too.
@@ -788,20 +792,39 @@ def load_ssh_private_key(
             stacklevel=2,
         )
 
+    return private_key, comment.tobytes()
+
+
+def load_ssh_private_key(
+    data: utils.Buffer,
+    password: bytes | None,
+    backend: typing.Any = None,
+    *,
+    unsafe_skip_rsa_key_validation: bool = False,
+) -> SSHPrivateKeyTypes:
+    """Load private key from OpenSSH custom encoding."""
+    private_key, _ = load_ssh_private_key_with_comment(
+        data,
+        password,
+        backend,
+        unsafe_skip_rsa_key_validation=unsafe_skip_rsa_key_validation,
+    )
     return private_key
 
 
 def _serialize_ssh_private_key(
     private_key: SSHPrivateKeyTypes,
     password: bytes,
     encryption_algorithm: KeySerializationEncryption,
+    comment: bytes = b"",
 ) -> bytes:
     """Serialize private key with OpenSSH custom encoding."""
     utils._check_bytes("password", password)
+    utils._check_bytes("comment", comment)  # <-- Add validation here
     if isinstance(private_key, dsa._DSAPrivateKey):
         warnings.warn(
-            "SSH DSA key support is deprecated and will be "
-            "removed in a future release",
+            "SSH DSA key support is deprecated and will be removed in a "
+            "future release",
             utils.DeprecatedIn40,
             stacklevel=4,
         )
@@ -831,7 +854,9 @@ def _serialize_ssh_private_key(
         ciph = None
     nkeys = 1
     checkval = os.urandom(4)
-    comment = b""
+    # To this (split into two shorter lines):
+    # comment is passed in as a parameter now, so we don't
+    # overwrite it with b"" unless default is used
 
     # encode public and private parts together
     f_public_key = _FragList()
@@ -841,7 +866,7 @@ def _serialize_ssh_private_key(
     f_secrets = _FragList([checkval, checkval])
     f_secrets.put_sshstr(key_type)
     kformat.encode_private(private_key, f_secrets)
-    f_secrets.put_sshstr(comment)
+    f_secrets.put_sshstr(comment)  # <-- Uses the passed comment parameter here
     f_secrets.put_raw(_PADDING[: blklen - (f_secrets.size() % blklen)])
 
     # top-level structure

src/rust/src/backend/dh.rs

@@ -263,12 +263,15 @@ impl DHPrivateKey {
         })
     }
 
+    #[pyo3(signature = (encoding, format, encryption_algorithm, *, comment = None))]
+    #[allow(unused_variables)]
     fn private_bytes<'p>(
         slf: &pyo3::Bound<'p, Self>,
         py: pyo3::Python<'p>,
         encoding: crate::serialization::Encoding,
         format: crate::serialization::PrivateFormat,
         encryption_algorithm: &pyo3::Bound<'p, pyo3::PyAny>,
+        comment: Option<&pyo3::Bound<'p, pyo3::types::PyBytes>>,
     ) -> CryptographyResult<pyo3::Bound<'p, pyo3::types::PyBytes>> {
         if format != crate::serialization::PrivateFormat::PKCS8 {
             return Err(CryptographyError::from(
@@ -285,8 +288,9 @@ impl DHPrivateKey {
             encoding,
             format,
             encryption_algorithm,
-            true,
             false,
+            false,
+            None,
         )
     }
 

src/rust/src/backend/dsa.rs

@@ -3,6 +3,7 @@
 // for complete details.
 
 use pyo3::types::PyAnyMethods;
+use pyo3::types::PyBytesMethods;
 
 use crate::backend::utils;
 use crate::buf::CffiBuf;
@@ -150,13 +151,20 @@ impl DsaPrivateKey {
         })
     }
 
+    #[pyo3(signature = (encoding, format, encryption_algorithm, *, comment = None))]
     fn private_bytes<'p>(
         slf: &pyo3::Bound<'p, Self>,
         py: pyo3::Python<'p>,
         encoding: crate::serialization::Encoding,
         format: crate::serialization::PrivateFormat,
         encryption_algorithm: &pyo3::Bound<'p, pyo3::PyAny>,
+        comment: Option<&pyo3::Bound<'p, pyo3::types::PyBytes>>,
     ) -> CryptographyResult<pyo3::Bound<'p, pyo3::types::PyBytes>> {
+        let comment_bytes = match comment {
+            Some(b) => b.as_bytes(),
+            None => b"",
+        };
+
         utils::pkey_private_bytes(
             py,
             slf,
@@ -166,6 +174,7 @@ impl DsaPrivateKey {
             encryption_algorithm,
             true,
             false,
+            Some(comment_bytes),
         )
     }
 

src/rust/src/backend/ec.rs

@@ -6,6 +6,7 @@ use std::collections::hash_map::DefaultHasher;
 use std::hash::{Hash, Hasher};
 
 use pyo3::types::PyAnyMethods;
+use pyo3::types::PyBytesMethods;
 
 use crate::backend::utils;
 use crate::buf::CffiBuf;
@@ -340,13 +341,20 @@ impl ECPrivateKey {
         })
     }
 
+    #[pyo3(signature = (encoding, format, encryption_algorithm, *, comment = None))]
     fn private_bytes<'p>(
         slf: &pyo3::Bound<'p, Self>,
         py: pyo3::Python<'p>,
         encoding: crate::serialization::Encoding,
         format: crate::serialization::PrivateFormat,
         encryption_algorithm: &pyo3::Bound<'p, pyo3::PyAny>,
+        comment: Option<&pyo3::Bound<'p, pyo3::types::PyBytes>>,
     ) -> CryptographyResult<pyo3::Bound<'p, pyo3::types::PyBytes>> {
+        let comment_bytes = match comment {
+            Some(b) => b.as_bytes(),
+            None => b"",
+        };
+
         utils::pkey_private_bytes(
             py,
             slf,
@@ -356,6 +364,7 @@ impl ECPrivateKey {
             encryption_algorithm,
             true,
             false,
+            Some(comment_bytes),
         )
     }
 

src/rust/src/backend/ed25519.rs

@@ -6,6 +6,7 @@ use crate::backend::utils;
 use crate::buf::CffiBuf;
 use crate::error::{CryptographyError, CryptographyResult};
 use crate::exceptions;
+use pyo3::types::PyBytesMethods;
 
 #[pyo3::pyclass(frozen, module = "cryptography.hazmat.bindings._rust.openssl.ed25519")]
 pub(crate) struct Ed25519PrivateKey {
@@ -100,13 +101,20 @@ impl Ed25519PrivateKey {
         Ok(pyo3::types::PyBytes::new(py, &raw_bytes))
     }
 
+    #[pyo3(signature = (encoding, format, encryption_algorithm, *, comment = None))]
     fn private_bytes<'p>(
         slf: &pyo3::Bound<'p, Self>,
         py: pyo3::Python<'p>,
         encoding: crate::serialization::Encoding,
         format: crate::serialization::PrivateFormat,
         encryption_algorithm: &pyo3::Bound<'p, pyo3::PyAny>,
+        comment: Option<&pyo3::Bound<'p, pyo3::types::PyBytes>>,
     ) -> CryptographyResult<pyo3::Bound<'p, pyo3::types::PyBytes>> {
+        let comment_bytes = match comment {
+            Some(b) => b.as_bytes(),
+            None => b"",
+        };
+
         utils::pkey_private_bytes(
             py,
             slf,
@@ -116,6 +124,7 @@ impl Ed25519PrivateKey {
             encryption_algorithm,
             true,
             true,
+            Some(comment_bytes),
         )
     }
 

src/rust/src/backend/ed448.rs

@@ -6,6 +6,7 @@ use crate::backend::utils;
 use crate::buf::CffiBuf;
 use crate::error::{CryptographyError, CryptographyResult};
 use crate::exceptions;
+use pyo3::types::PyAnyMethods;
 
 #[pyo3::pyclass(frozen, module = "cryptography.hazmat.bindings._rust.openssl.ed448")]
 pub(crate) struct Ed448PrivateKey {
@@ -98,22 +99,34 @@ impl Ed448PrivateKey {
         Ok(pyo3::types::PyBytes::new(py, &raw_bytes))
     }
 
+    #[pyo3(signature = (encoding, format, encryption_algorithm, *, comment = None))]
+    #[allow(unused_variables)]
     fn private_bytes<'p>(
         slf: &pyo3::Bound<'p, Self>,
         py: pyo3::Python<'p>,
         encoding: crate::serialization::Encoding,
         format: crate::serialization::PrivateFormat,
         encryption_algorithm: &pyo3::Bound<'p, pyo3::PyAny>,
+        comment: Option<&pyo3::Bound<'p, pyo3::types::PyBytes>>,
     ) -> CryptographyResult<pyo3::Bound<'p, pyo3::types::PyBytes>> {
+        // Intercept raw requests and route them to private_bytes_raw:
+        if encoding == crate::serialization::Encoding::Raw
+            && format == crate::serialization::PrivateFormat::Raw
+            && encryption_algorithm.is_instance(&crate::types::NO_ENCRYPTION.get(py)?)?
+        {
+            return slf.borrow().private_bytes_raw(py);
+        }
+
         utils::pkey_private_bytes(
             py,
             slf,
             &slf.borrow().pkey,
             encoding,
             format,
             encryption_algorithm,
-            true,
-            true,
+            false,
+            false,
+            None,
         )
     }