fixes #9403 -- re-allow copying public keys (#9433)

they are immutable, so this is trivial

Author: alex

src/rust/src/backend/dh.rs

@@ -352,6 +352,10 @@ impl DHPublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 #[pyo3::prelude::pymethods]

src/rust/src/backend/dsa.rs

@@ -295,6 +295,10 @@ impl DsaPublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 #[pyo3::prelude::pymethods]

src/rust/src/backend/ec.rs

@@ -558,7 +558,12 @@ impl ECPublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
+
 pub(crate) fn create_module(py: pyo3::Python<'_>) -> pyo3::PyResult<&pyo3::prelude::PyModule> {
     let m = pyo3::prelude::PyModule::new(py, "ec")?;
     m.add_function(pyo3::wrap_pyfunction!(curve_supported, m)?)?;

src/rust/src/backend/ed25519.rs

@@ -160,6 +160,10 @@ impl Ed25519PublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 pub(crate) fn create_module(py: pyo3::Python<'_>) -> pyo3::PyResult<&pyo3::prelude::PyModule> {

src/rust/src/backend/ed448.rs

@@ -158,6 +158,10 @@ impl Ed448PublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 pub(crate) fn create_module(py: pyo3::Python<'_>) -> pyo3::PyResult<&pyo3::prelude::PyModule> {

src/rust/src/backend/x25519.rs

@@ -149,6 +149,10 @@ impl X25519PublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 pub(crate) fn create_module(py: pyo3::Python<'_>) -> pyo3::PyResult<&pyo3::prelude::PyModule> {

src/rust/src/backend/x448.rs

@@ -148,6 +148,10 @@ impl X448PublicKey {
             _ => Err(pyo3::exceptions::PyTypeError::new_err("Cannot be ordered")),
         }
     }
+
+    fn __copy__(slf: pyo3::PyRef<'_, Self>) -> pyo3::PyRef<'_, Self> {
+        slf
+    }
 }
 
 pub(crate) fn create_module(py: pyo3::Python<'_>) -> pyo3::PyResult<&pyo3::prelude::PyModule> {

tests/hazmat/primitives/test_dh.py

@@ -4,6 +4,7 @@
 
 
 import binascii
+import copy
 import itertools
 import os
 import typing
@@ -489,6 +490,21 @@ def test_public_key_equality(self, backend):
         with pytest.raises(TypeError):
             key1 < key2  # type: ignore[operator]
 
+    @pytest.mark.supported(
+        only_if=lambda backend: backend.dh_x942_serialization_supported(),
+        skip_message="DH X9.42 not supported",
+    )
+    def test_public_key_copy(self):
+        key_bytes = load_vectors_from_file(
+            os.path.join("asymmetric", "DH", "dhpub.pem"),
+            lambda pemfile: pemfile.read(),
+            mode="rb",
+        )
+        key1 = serialization.load_pem_public_key(key_bytes)
+        key2 = copy.copy(key1)
+
+        assert key1 == key2
+
 
 @pytest.mark.supported(
     only_if=lambda backend: backend.dh_supported(),

tests/hazmat/primitives/test_dsa.py

@@ -3,6 +3,7 @@
 # for complete details.
 
 
+import copy
 import itertools
 import os
 import typing
@@ -398,6 +399,16 @@ def test_public_key_equality(self, backend):
         with pytest.raises(TypeError):
             key1 < key2  # type: ignore[operator]
 
+    def test_public_key_copy(self):
+        key_bytes = load_vectors_from_file(
+            os.path.join("asymmetric", "PKCS8", "unenc-dsa-pkcs8.pem"),
+            lambda pemfile: pemfile.read().encode(),
+        )
+        key1 = serialization.load_pem_private_key(key_bytes, None).public_key()
+        key2 = copy.copy(key1)
+
+        assert key1 == key2
+
 
 @pytest.mark.supported(
     only_if=lambda backend: backend.dsa_supported(),

tests/hazmat/primitives/test_ec.py

@@ -2,8 +2,8 @@
 # 2.0, and the BSD License. See the LICENSE file in the root of this repository
 # for complete details.
 
-
 import binascii
+import copy
 import itertools
 import os
 import textwrap
@@ -617,6 +617,17 @@ def test_public_key_equality(self, backend):
         with pytest.raises(TypeError):
             key1 < key2  # type: ignore[operator]
 
+    def test_public_key_copy(self, backend):
+        _skip_curve_unsupported(backend, ec.SECP256R1())
+        key_bytes = load_vectors_from_file(
+            os.path.join("asymmetric", "PKCS8", "ec_private_key.pem"),
+            lambda pemfile: pemfile.read().encode(),
+        )
+        key1 = serialization.load_pem_private_key(key_bytes, None).public_key()
+        key2 = copy.copy(key1)
+
+        assert key1 == key2
+
 
 class TestECSerialization:
     @pytest.mark.parametrize(