implement __eq__ for HashAlgorithm instances

Author: mathiasertl

src/cryptography/hazmat/primitives/hashes.py

@@ -5,6 +5,7 @@
 from __future__ import annotations
 
 import abc
+import typing
 
 from cryptography.hazmat.bindings._rust import openssl as rust_openssl
 from cryptography.utils import Buffer
@@ -36,6 +37,13 @@
 
 
 class HashAlgorithm(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def __eq__(self, other: typing.Any) -> bool:
+        """
+        Implement equality checking.
+        """
+        ...
+
     @property
     @abc.abstractmethod
     def name(self) -> str:
@@ -103,66 +111,99 @@ class SHA1(HashAlgorithm):
     digest_size = 20
     block_size = 64
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA1)
+
 
 class SHA512_224(HashAlgorithm):  # noqa: N801
     name = "sha512-224"
     digest_size = 28
     block_size = 128
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA512_224)
+
 
 class SHA512_256(HashAlgorithm):  # noqa: N801
     name = "sha512-256"
     digest_size = 32
     block_size = 128
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA512_256)
+
 
 class SHA224(HashAlgorithm):
     name = "sha224"
     digest_size = 28
     block_size = 64
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA224)
+
 
 class SHA256(HashAlgorithm):
     name = "sha256"
     digest_size = 32
     block_size = 64
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA256)
+
 
 class SHA384(HashAlgorithm):
     name = "sha384"
     digest_size = 48
     block_size = 128
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA384)
+
 
 class SHA512(HashAlgorithm):
     name = "sha512"
     digest_size = 64
     block_size = 128
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA512)
+
 
 class SHA3_224(HashAlgorithm):  # noqa: N801
     name = "sha3-224"
     digest_size = 28
     block_size = None
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA3_224)
+
 
 class SHA3_256(HashAlgorithm):  # noqa: N801
     name = "sha3-256"
     digest_size = 32
     block_size = None
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA3_256)
+
 
 class SHA3_384(HashAlgorithm):  # noqa: N801
     name = "sha3-384"
     digest_size = 48
     block_size = None
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA3_384)
+
 
 class SHA3_512(HashAlgorithm):  # noqa: N801
     name = "sha3-512"
     digest_size = 64
     block_size = None
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SHA3_512)
+
 
 class SHAKE128(HashAlgorithm, ExtendableOutputFunction):
     name = "shake128"
@@ -177,6 +218,12 @@ def __init__(self, digest_size: int):
 
         self._digest_size = digest_size
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, SHAKE128)
+            and self._digest_size == other._digest_size
+        )
+
     @property
     def digest_size(self) -> int:
         return self._digest_size
@@ -195,6 +242,12 @@ def __init__(self, digest_size: int):
 
         self._digest_size = digest_size
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, SHAKE256)
+            and self._digest_size == other._digest_size
+        )
+
     @property
     def digest_size(self) -> int:
         return self._digest_size
@@ -205,6 +258,9 @@ class MD5(HashAlgorithm):
     digest_size = 16
     block_size = 64
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, MD5)
+
 
 class BLAKE2b(HashAlgorithm):
     name = "blake2b"
@@ -218,6 +274,12 @@ def __init__(self, digest_size: int):
 
         self._digest_size = digest_size
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, BLAKE2b)
+            and self._digest_size == other._digest_size
+        )
+
     @property
     def digest_size(self) -> int:
         return self._digest_size
@@ -235,6 +297,12 @@ def __init__(self, digest_size: int):
 
         self._digest_size = digest_size
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, BLAKE2s)
+            and self._digest_size == other._digest_size
+        )
+
     @property
     def digest_size(self) -> int:
         return self._digest_size
@@ -244,3 +312,6 @@ class SM3(HashAlgorithm):
     name = "sm3"
     digest_size = 32
     block_size = 64
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, SM3)

tests/doubles.py

@@ -2,6 +2,7 @@
 # 2.0, and the BSD License. See the LICENSE file in the root of this repository
 # for complete details.
 
+import typing
 
 from cryptography.hazmat.primitives import hashes, serialization
 from cryptography.hazmat.primitives.asymmetric import padding
@@ -40,6 +41,12 @@ class DummyHashAlgorithm(hashes.HashAlgorithm):
     def __init__(self, digest_size: int = 32) -> None:
         self._digest_size = digest_size
 
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(self, DummyHashAlgorithm)
+            and self._digest_size == other._digest_size
+        )
+
     @property
     def digest_size(self) -> int:
         return self._digest_size

tests/hazmat/primitives/test_hashes.py

@@ -12,7 +12,7 @@
 
 from ...doubles import DummyHashAlgorithm
 from ...utils import raises_unsupported_algorithm
-from .utils import generate_base_hash_test
+from .utils import generate_base_hash_test, generate_eq_hash_test
 
 
 class TestHashContext:
@@ -52,6 +52,7 @@ class TestSHA1:
         hashes.SHA1(),
         digest_size=20,
     )
+    test_sha1_eq = generate_eq_hash_test(hashes.SHA1())
 
 
 @pytest.mark.supported(
@@ -63,6 +64,7 @@ class TestSHA224:
         hashes.SHA224(),
         digest_size=28,
     )
+    test_sha224_eq = generate_eq_hash_test(hashes.SHA224())
 
 
 @pytest.mark.supported(
@@ -74,6 +76,7 @@ class TestSHA256:
         hashes.SHA256(),
         digest_size=32,
     )
+    test_sha256_eq = generate_eq_hash_test(hashes.SHA256())
 
 
 @pytest.mark.supported(
@@ -85,6 +88,7 @@ class TestSHA384:
         hashes.SHA384(),
         digest_size=48,
     )
+    test_sha384_eq = generate_eq_hash_test(hashes.SHA384())
 
 
 @pytest.mark.supported(
@@ -96,6 +100,79 @@ class TestSHA512:
         hashes.SHA512(),
         digest_size=64,
     )
+    test_sha512_eq = generate_eq_hash_test(hashes.SHA512())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA512_224()),
+    skip_message="Does not support SHA512 224",
+)
+class TestSHA512224:
+    test_sha512_224 = generate_base_hash_test(
+        hashes.SHA512_224(),
+        digest_size=28,
+    )
+    test_sha512_224_eq = generate_eq_hash_test(hashes.SHA512_224())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA512_256()),
+    skip_message="Does not support SHA512 256",
+)
+class TestSHA512256:
+    test_sha512_256 = generate_base_hash_test(
+        hashes.SHA512_256(),
+        digest_size=32,
+    )
+    test_sha512_256_eq = generate_eq_hash_test(hashes.SHA512_256())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA3_224()),
+    skip_message="Does not support SHA3 224",
+)
+class TestSHA3224:
+    test_sha3_224 = generate_base_hash_test(
+        hashes.SHA3_224(),
+        digest_size=28,
+    )
+    test_sha3_224_eq = generate_eq_hash_test(hashes.SHA3_224())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA3_256()),
+    skip_message="Does not support SHA3 256",
+)
+class TestSHA3256:
+    test_sha3_256 = generate_base_hash_test(
+        hashes.SHA3_256(),
+        digest_size=32,
+    )
+    test_sha3_256_eq = generate_eq_hash_test(hashes.SHA3_256())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA3_384()),
+    skip_message="Does not support SHA3 384",
+)
+class TestSHA3384:
+    test_sha3_384 = generate_base_hash_test(
+        hashes.SHA3_384(),
+        digest_size=48,
+    )
+    test_sha3_384_eq = generate_eq_hash_test(hashes.SHA3_384())
+
+
+@pytest.mark.supported(
+    only_if=lambda backend: backend.hash_supported(hashes.SHA3_512()),
+    skip_message="Does not support SHA3 512",
+)
+class TestSHA3512:
+    test_sha3_512 = generate_base_hash_test(
+        hashes.SHA3_512(),
+        digest_size=64,
+    )
+    test_sha3_512_eq = generate_eq_hash_test(hashes.SHA3_512())
 
 
 @pytest.mark.supported(
@@ -107,6 +184,7 @@ class TestMD5:
         hashes.MD5(),
         digest_size=16,
     )
+    test_md5_eq = generate_eq_hash_test(hashes.MD5())
 
 
 @pytest.mark.supported(
@@ -120,6 +198,7 @@ class TestBLAKE2b:
         hashes.BLAKE2b(digest_size=64),
         digest_size=64,
     )
+    test_blake2b_eq = generate_eq_hash_test(hashes.BLAKE2b(digest_size=64))
 
     def test_invalid_digest_size(self, backend):
         with pytest.raises(ValueError):
@@ -143,6 +222,7 @@ class TestBLAKE2s:
         hashes.BLAKE2s(digest_size=32),
         digest_size=32,
     )
+    test_blake2s_eq = generate_eq_hash_test(hashes.BLAKE2s(digest_size=32))
 
     def test_invalid_digest_size(self, backend):
         with pytest.raises(ValueError):
@@ -165,6 +245,14 @@ def test_buffer_protocol_hash(backend):
 
 
 class TestSHAKE:
+    @pytest.mark.parametrize("xof", [hashes.SHAKE128, hashes.SHAKE256])
+    def test_eq(self, xof):
+        value_one = xof(digest_size=32)
+        value_two = xof(digest_size=32)  # identical
+        value_three = xof(digest_size=64)
+        assert value_one == value_two
+        assert value_one != value_three
+
     @pytest.mark.parametrize("xof", [hashes.SHAKE128, hashes.SHAKE256])
     def test_invalid_digest_type(self, xof):
         with pytest.raises(TypeError):
@@ -188,3 +276,4 @@ class TestSM3:
         hashes.SM3(),
         digest_size=32,
     )
+    test_sm3_eq = generate_eq_hash_test(hashes.SM3())

tests/hazmat/primitives/utils.py

@@ -35,6 +35,7 @@
     Mode,
 )
 
+from ...doubles import DummyHashAlgorithm
 from ...utils import load_vectors_from_file
 
 
@@ -207,6 +208,14 @@ def test_base_hash(self, backend):
     return test_base_hash
 
 
+def generate_eq_hash_test(algorithm):
+    def test_eq(self):
+        assert algorithm == algorithm
+        assert algorithm != DummyHashAlgorithm()
+
+    return test_eq
+
+
 def base_hash_test(backend, algorithm, digest_size):
     m = hashes.Hash(algorithm, backend=backend)
     assert m.algorithm.digest_size == digest_size