From 918e294d56e646e67553550c87b4a9e30cac1f67 Mon Sep 17 00:00:00 2001

From: Charalampos Stratakis <cstratak@redhat.com>

Date: Fri, 29 Jan 2021 14:16:21 +0100

Subject: [PATCH 01/13] Use python's fall backs for the crypto it implements

 only if we are not in FIPS mode

---

 Lib/hashlib.py           | 194 +++++++++++++++------------------------

 Lib/test/test_hashlib.py |   1 +

 2 files changed, 76 insertions(+), 119 deletions(-)

diff --git a/Lib/hashlib.py b/Lib/hashlib.py

index 58c340d..1fd80c7 100644

--- a/Lib/hashlib.py

+++ b/Lib/hashlib.py

@@ -68,8 +68,6 @@ __all__ = __always_supported + ('new', 'algorithms_guaranteed',

                                 'algorithms_available', 'pbkdf2_hmac')

-__builtin_constructor_cache = {}

-

 # Prefer our blake2 implementation

 # OpenSSL 1.1.0 comes with a limited implementation of blake2b/s. The OpenSSL

 # implementations neither support keyed blake2 (blake2 MAC) nor advanced

@@ -79,54 +77,64 @@ __block_openssl_constructor = {

     'blake2b', 'blake2s',

 }

-def __get_builtin_constructor(name):

-    cache = __builtin_constructor_cache

-    constructor = cache.get(name)

-    if constructor is not None:

-        return constructor

-    try:

-        if name in {'SHA1', 'sha1'}:

-            import _sha1

-            cache['SHA1'] = cache['sha1'] = _sha1.sha1

-        elif name in {'MD5', 'md5'}:

-            import _md5

-            cache['MD5'] = cache['md5'] = _md5.md5

-        elif name in {'SHA256', 'sha256', 'SHA224', 'sha224'}:

-            import _sha256

-            cache['SHA224'] = cache['sha224'] = _sha256.sha224

-            cache['SHA256'] = cache['sha256'] = _sha256.sha256

-        elif name in {'SHA512', 'sha512', 'SHA384', 'sha384'}:

-            import _sha512

-            cache['SHA384'] = cache['sha384'] = _sha512.sha384

-            cache['SHA512'] = cache['sha512'] = _sha512.sha512

-        elif name in {'blake2b', 'blake2s'}:

-            import _blake2

-            cache['blake2b'] = _blake2.blake2b

-            cache['blake2s'] = _blake2.blake2s

-        elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512'}:

-            import _sha3

-            cache['sha3_224'] = _sha3.sha3_224

-            cache['sha3_256'] = _sha3.sha3_256

-            cache['sha3_384'] = _sha3.sha3_384

-            cache['sha3_512'] = _sha3.sha3_512

-        elif name in {'shake_128', 'shake_256'}:

-            import _sha3

-            cache['shake_128'] = _sha3.shake_128

-            cache['shake_256'] = _sha3.shake_256

-    except ImportError:

-        pass  # no extension module, this hash is unsupported.

-

-    constructor = cache.get(name)

-    if constructor is not None:

-        return constructor

-

-    raise ValueError('unsupported hash type ' + name)

+try:

+    from _hashlib import get_fips_mode

+except ImportError:

+    def get_fips_mode():

+        return 0

+

+if not get_fips_mode():

+    __builtin_constructor_cache = {}

+

+    def __get_builtin_constructor(name):

+        cache = __builtin_constructor_cache

+        constructor = cache.get(name)

+        if constructor is not None:

+            return constructor

+        try:

+            if name in {'SHA1', 'sha1'}:

+                import _sha1

+                cache['SHA1'] = cache['sha1'] = _sha1.sha1

+            elif name in {'MD5', 'md5'}:

+                import _md5

+                cache['MD5'] = cache['md5'] = _md5.md5

+            elif name in {'SHA256', 'sha256', 'SHA224', 'sha224'}:

+                import _sha256

+                cache['SHA224'] = cache['sha224'] = _sha256.sha224

+                cache['SHA256'] = cache['sha256'] = _sha256.sha256

+            elif name in {'SHA512', 'sha512', 'SHA384', 'sha384'}:

+                import _sha512

+                cache['SHA384'] = cache['sha384'] = _sha512.sha384

+                cache['SHA512'] = cache['sha512'] = _sha512.sha512

+            elif name in {'blake2b', 'blake2s'}:

+                import _blake2

+                cache['blake2b'] = _blake2.blake2b

+                cache['blake2s'] = _blake2.blake2s

+            elif name in {'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512'}:

+                import _sha3

+                cache['sha3_224'] = _sha3.sha3_224

+                cache['sha3_256'] = _sha3.sha3_256

+                cache['sha3_384'] = _sha3.sha3_384

+                cache['sha3_512'] = _sha3.sha3_512

+            elif name in {'shake_128', 'shake_256'}:

+                import _sha3

+                cache['shake_128'] = _sha3.shake_128

+                cache['shake_256'] = _sha3.shake_256

+        except ImportError:

+            pass  # no extension module, this hash is unsupported.

+

+        constructor = cache.get(name)

+        if constructor is not None:

+            return constructor

+

+        raise ValueError('unsupported hash type ' + name)

 def __get_openssl_constructor(name):

-    if name in __block_openssl_constructor:

-        # Prefer our builtin blake2 implementation.

-        return __get_builtin_constructor(name)

+    if not get_fips_mode():

+        if name in __block_openssl_constructor:

+            # Prefer our builtin blake2 implementation.

+            return __get_builtin_constructor(name)

     try:

         # MD5, SHA1, and SHA2 are in all supported OpenSSL versions

         # SHA3/shake are available in OpenSSL 1.1.1+

@@ -141,21 +149,23 @@ def __get_openssl_constructor(name):

         return __get_builtin_constructor(name)

-def __py_new(name, data=b'', **kwargs):

-    """new(name, data=b'', **kwargs) - Return a new hashing object using the

-    named algorithm; optionally initialized with data (which must be

-    a bytes-like object).

-    """

-    return __get_builtin_constructor(name)(data, **kwargs)

+if not get_fips_mode():

+    def __py_new(name, data=b'', **kwargs):

+        """new(name, data=b'', **kwargs) - Return a new hashing object using the

+        named algorithm; optionally initialized with data (which must be

+        a bytes-like object).

+        """

+        return __get_builtin_constructor(name)(data, **kwargs)

 def __hash_new(name, data=b'', **kwargs):

     """new(name, data=b'') - Return a new hashing object using the named algorithm;

     optionally initialized with data (which must be a bytes-like object).

     """

-    if name in __block_openssl_constructor:

-        # Prefer our builtin blake2 implementation.

-        return __get_builtin_constructor(name)(data, **kwargs)

+    if not get_fips_mode():

+        if name in __block_openssl_constructor:

+            # Prefer our builtin blake2 implementation.

+            return __get_builtin_constructor(name)(data, **kwargs)

     try:

         return _hashlib.new(name, data, **kwargs)

     except ValueError:

@@ -163,6 +173,8 @@ def __hash_new(name, data=b'', **kwargs):

         # hash, try using our builtin implementations.

         # This allows for SHA224/256 and SHA384/512 support even though

         # the OpenSSL library prior to 0.9.8 doesn't provide them.

+        if get_fips_mode():

+            raise

         return __get_builtin_constructor(name)(data)

@@ -173,72 +185,14 @@ try:

     algorithms_available = algorithms_available.union(

             _hashlib.openssl_md_meth_names)

 except ImportError:

+    if get_fips_mode:

+        raise

     new = __py_new

     __get_hash = __get_builtin_constructor

-try:

-    # OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA

-    from _hashlib import pbkdf2_hmac

-except ImportError:

-    _trans_5C = bytes((x ^ 0x5C) for x in range(256))

-    _trans_36 = bytes((x ^ 0x36) for x in range(256))

-

-    def pbkdf2_hmac(hash_name, password, salt, iterations, dklen=None):

-        """Password based key derivation function 2 (PKCS #5 v2.0)

-        This Python implementations based on the hmac module about as fast

-        as OpenSSL's PKCS5_PBKDF2_HMAC for short passwords and much faster

-        for long passwords.

-        """

-        if not isinstance(hash_name, str):

-            raise TypeError(hash_name)

-

-        if not isinstance(password, (bytes, bytearray)):

-            password = bytes(memoryview(password))

-        if not isinstance(salt, (bytes, bytearray)):

-            salt = bytes(memoryview(salt))

-

-        # Fast inline HMAC implementation

-        inner = new(hash_name)

-        outer = new(hash_name)

-        blocksize = getattr(inner, 'block_size', 64)

-        if len(password) > blocksize:

-            password = new(hash_name, password).digest()

-        password = password + b'\x00' * (blocksize - len(password))

-        inner.update(password.translate(_trans_36))

-        outer.update(password.translate(_trans_5C))

-

-        def prf(msg, inner=inner, outer=outer):

-            # PBKDF2_HMAC uses the password as key. We can re-use the same

-            # digest objects and just update copies to skip initialization.

-            icpy = inner.copy()

-            ocpy = outer.copy()

-            icpy.update(msg)

-            ocpy.update(icpy.digest())

-            return ocpy.digest()

-

-        if iterations < 1:

-            raise ValueError(iterations)

-        if dklen is None:

-            dklen = outer.digest_size

-        if dklen < 1:

-            raise ValueError(dklen)

-

-        dkey = b''

-        loop = 1

-        from_bytes = int.from_bytes

-        while len(dkey) < dklen:

-            prev = prf(salt + loop.to_bytes(4, 'big'))

-            # endianness doesn't matter here as long to / from use the same

-            rkey = int.from_bytes(prev, 'big')

-            for i in range(iterations - 1):

-                prev = prf(prev)

-                # rkey = rkey ^ prev

-                rkey ^= from_bytes(prev, 'big')

-            loop += 1

-            dkey += rkey.to_bytes(inner.digest_size, 'big')

-

-        return dkey[:dklen]

+# OpenSSL's PKCS5_PBKDF2_HMAC requires OpenSSL 1.0+ with HMAC and SHA

+from _hashlib import pbkdf2_hmac

 try:

     # OpenSSL's scrypt requires OpenSSL 1.1+

@@ -259,4 +213,6 @@ for __func_name in __always_supported:

 # Cleanup locals()

 del __always_supported, __func_name, __get_hash

-del __py_new, __hash_new, __get_openssl_constructor

+del __hash_new, __get_openssl_constructor

+if not get_fips_mode():

+    del __py_new

diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py

index 86f31a5..8235505 100644

--- a/Lib/test/test_hashlib.py

+++ b/Lib/test/test_hashlib.py

@@ -1039,6 +1039,7 @@ class KDFTests(unittest.TestCase):

                 iterations=1, dklen=None)

             self.assertEqual(out, self.pbkdf2_results['sha1'][0][0])

+    @unittest.skip("The python implementation of pbkdf2_hmac has been removed")

     @unittest.skipIf(builtin_hashlib is None, "test requires builtin_hashlib")

     def test_pbkdf2_hmac_py(self):

         self._test_pbkdf2_hmac(builtin_hashlib.pbkdf2_hmac, builtin_hashes)

-- 

2.31.1

From 93696af7133bf08fd76fb759b24c7f82b90220da Mon Sep 17 00:00:00 2001

From: Petr Viktorin <pviktori@redhat.com>

Date: Thu, 25 Jul 2019 17:19:06 +0200

Subject: [PATCH 02/13] Disable Python's hash implementations in FIPS mode,

 forcing OpenSSL

---

 Include/_hashopenssl.h         | 66 ++++++++++++++++++++++++++++++++++

 Modules/_blake2/blake2b_impl.c |  5 +++

 Modules/_blake2/blake2module.c |  3 ++

 Modules/_blake2/blake2s_impl.c |  5 +++

 Modules/_hashopenssl.c         | 35 +-----------------

 setup.py                       | 28 ++++++++++-----

 6 files changed, 99 insertions(+), 43 deletions(-)

 create mode 100644 Include/_hashopenssl.h

diff --git a/Include/_hashopenssl.h b/Include/_hashopenssl.h

new file mode 100644

index 0000000..a726c0d

--- /dev/null

+++ b/Include/_hashopenssl.h

@@ -0,0 +1,66 @@

+#ifndef Py_HASHOPENSSL_H

+#define Py_HASHOPENSSL_H

+

+#include "Python.h"

+#include <openssl/crypto.h>

+#include <openssl/err.h>

+

+/* LCOV_EXCL_START */

+static PyObject *

+_setException(PyObject *exc)

+{

+    unsigned long errcode;

+    const char *lib, *func, *reason;

+

+    errcode = ERR_peek_last_error();

+    if (!errcode) {

+        PyErr_SetString(exc, "unknown reasons");

+        return NULL;

+    }

+    ERR_clear_error();

+

+    lib = ERR_lib_error_string(errcode);

+    func = ERR_func_error_string(errcode);

+    reason = ERR_reason_error_string(errcode);

+

+    if (lib && func) {

+        PyErr_Format(exc, "[%s: %s] %s", lib, func, reason);

+    }

+    else if (lib) {

+        PyErr_Format(exc, "[%s] %s", lib, reason);

+    }

+    else {

+        PyErr_SetString(exc, reason);

+    }

+    return NULL;

+}

+/* LCOV_EXCL_STOP */

+

+

+__attribute__((__unused__))

+static int

+_Py_hashlib_fips_error(char *name) {

+    int result = FIPS_mode();

+    if (result == 0) {

+        // "If the library was built without support of the FIPS Object Module,

+        // then the function will return 0 with an error code of

+        // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)."

+        // But 0 is also a valid result value.

+

+        unsigned long errcode = ERR_peek_last_error();

+        if (errcode) {

+            _setException(PyExc_ValueError);

+            return 1;

+        }

+        return 0;

+    }

+    PyErr_Format(PyExc_ValueError, "%s is not available in FIPS mode",

+                 name);

+    return 1;

+}

+

+#define FAIL_RETURN_IN_FIPS_MODE(name) do { \

+    if (_Py_hashlib_fips_error(name)) return NULL; \

+} while (0)

+

+#endif  // !Py_HASHOPENSSL_H

diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c

index 7fb1296..67620af 100644

--- a/Modules/_blake2/blake2b_impl.c

+++ b/Modules/_blake2/blake2b_impl.c

@@ -14,6 +14,7 @@

  */

 #include "Python.h"

+#include "_hashopenssl.h"

 #include "pystrhex.h"

 #include "../hashlib.h"

@@ -96,6 +97,8 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size,

     BLAKE2bObject *self = NULL;

     Py_buffer buf;

+    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+

     self = new_BLAKE2bObject(type);

     if (self == NULL) {

         goto error;

@@ -274,6 +277,8 @@ _blake2_blake2b_update(BLAKE2bObject *self, PyObject *data)

 {

     Py_buffer buf;

+    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+

     GET_BUFFER_VIEW_OR_ERROUT(data, &buf;;

     if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE)

diff --git a/Modules/_blake2/blake2module.c b/Modules/_blake2/blake2module.c

index ff142c9..bc67529 100644

--- a/Modules/_blake2/blake2module.c

+++ b/Modules/_blake2/blake2module.c

@@ -9,6 +9,7 @@

  */

 #include "Python.h"

+#include "_hashopenssl.h"

 #include "impl/blake2.h"

@@ -57,6 +58,8 @@ PyInit__blake2(void)

     PyObject *m;

     PyObject *d;

+    FAIL_RETURN_IN_FIPS_MODE("blake2");

+

     m = PyModule_Create(&blake2_module);

     if (m == NULL)

         return NULL;

diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c

index e3e90d0..57c0f3f 100644

--- a/Modules/_blake2/blake2s_impl.c

+++ b/Modules/_blake2/blake2s_impl.c

@@ -14,6 +14,7 @@

  */

 #include "Python.h"

+#include "_hashopenssl.h"

 #include "pystrhex.h"

 #include "../hashlib.h"

@@ -96,6 +97,8 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size,

     BLAKE2sObject *self = NULL;

     Py_buffer buf;

+    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+

     self = new_BLAKE2sObject(type);

     if (self == NULL) {

         goto error;

@@ -274,6 +277,8 @@ _blake2_blake2s_update(BLAKE2sObject *self, PyObject *data)

 {

     Py_buffer buf;

+    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+

     GET_BUFFER_VIEW_OR_ERROUT(data, &buf;;

     if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE)

diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c

index ff3a1ae..3d788f5 100644

--- a/Modules/_hashopenssl.c

+++ b/Modules/_hashopenssl.c

@@ -23,6 +23,7 @@

 #include "Python.h"

 #include "hashlib.h"

 #include "pystrhex.h"

+#include "_hashopenssl.h"

 /* EVP is the preferred interface to hashing in OpenSSL */

 #include <openssl/evp.h>

@@ -30,9 +31,6 @@

 #include <openssl/crypto.h>

 /* We use the object interface to discover what hashes OpenSSL supports. */

 #include <openssl/objects.h>

-#include <openssl/err.h>

-

-#include <openssl/crypto.h>       // FIPS_mode()

 #ifndef OPENSSL_THREADS

 #  error "OPENSSL_THREADS is not defined, Python requires thread-safe OpenSSL"

@@ -124,37 +122,6 @@ class _hashlib.HMAC "HMACobject *" "((_hashlibstate *)PyModule_GetState(module))

 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7df1bcf6f75cb8ef]*/

-/* LCOV_EXCL_START */

-static PyObject *

-_setException(PyObject *exc)

-{

-    unsigned long errcode;

-    const char *lib, *func, *reason;

-

-    errcode = ERR_peek_last_error();

-    if (!errcode) {

-        PyErr_SetString(exc, "unknown reasons");

-        return NULL;

-    }

-    ERR_clear_error();

-

-    lib = ERR_lib_error_string(errcode);

-    func = ERR_func_error_string(errcode);

-    reason = ERR_reason_error_string(errcode);

-

-    if (lib && func) {

-        PyErr_Format(exc, "[%s: %s] %s", lib, func, reason);

-    }

-    else if (lib) {

-        PyErr_Format(exc, "[%s] %s", lib, reason);

-    }

-    else {

-        PyErr_SetString(exc, reason);

-    }

-    return NULL;

-}

-/* LCOV_EXCL_STOP */

-

 /* {Py_tp_new, NULL} doesn't block __new__ */

 static PyObject *

 _disabled_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)

diff --git a/setup.py b/setup.py

index 04eb6b2..f72d7ca 100644

--- a/setup.py

+++ b/setup.py

@@ -2306,7 +2306,7 @@ class PyBuildExt(build_ext):

                            sources=sources,

                            depends=depends))

-    def detect_openssl_hashlib(self):

+    def detect_openssl_args(self):

         # Detect SSL support for the socket module (via _ssl)

         config_vars = sysconfig.get_config_vars()

@@ -2327,7 +2327,7 @@ class PyBuildExt(build_ext):

         if not openssl_libs:

             # libssl and libcrypto not found

             self.missing.extend(['_ssl', '_hashlib'])

-            return None, None

+            raise ValueError('Cannot build for RHEL without OpenSSL')

         # Find OpenSSL includes

         ssl_incs = find_file(

@@ -2335,7 +2335,7 @@ class PyBuildExt(build_ext):

         )

         if ssl_incs is None:

             self.missing.extend(['_ssl', '_hashlib'])

-            return None, None

+            raise ValueError('Cannot build for RHEL without OpenSSL')

         # OpenSSL 1.0.2 uses Kerberos for KRB5 ciphers

         krb5_h = find_file(

@@ -2345,12 +2345,23 @@ class PyBuildExt(build_ext):

         if krb5_h:

             ssl_incs.extend(krb5_h)

+

+        ssl_args = {

+            'include_dirs': openssl_includes,

+            'library_dirs': openssl_libdirs,

+            'libraries': ['ssl', 'crypto'],

+        }

+

+        return ssl_args

+

+    def detect_openssl_hashlib(self):

+

+        config_vars = sysconfig.get_config_vars()

+

         if config_vars.get("HAVE_X509_VERIFY_PARAM_SET1_HOST"):

             self.add(Extension(

                 '_ssl', ['_ssl.c'],

-                include_dirs=openssl_includes,

-                library_dirs=openssl_libdirs,

-                libraries=openssl_libs,

+                **self.detect_openssl_args(),

                 depends=[

                     'socketmodule.h',

                     '_ssl/debughelpers.c',

@@ -2363,9 +2374,7 @@ class PyBuildExt(build_ext):

         self.add(Extension('_hashlib', ['_hashopenssl.c'],

                            depends=['hashlib.h'],

-                           include_dirs=openssl_includes,

-                           library_dirs=openssl_libdirs,

-                           libraries=openssl_libs))

+                           **self.detect_openssl_args()) )

     def detect_hash_builtins(self):

         # By default we always compile these even when OpenSSL is available

@@ -2422,6 +2431,7 @@ class PyBuildExt(build_ext):

                     '_blake2/blake2b_impl.c',

                     '_blake2/blake2s_impl.c'

                 ],

+                **self.detect_openssl_args(),

                 depends=blake2_deps

             ))

-- 

2.31.1

From 0b9b72c27e24e159ed3180e9a7a2a9efa24de7e8 Mon Sep 17 00:00:00 2001

From: Charalampos Stratakis <cstratak@redhat.com>

Date: Thu, 12 Dec 2019 16:58:31 +0100

Subject: [PATCH 03/13] Expose all hashes available to OpenSSL

---

 Include/_hashopenssl.h          |  11 ++--

 Modules/_blake2/blake2b_impl.c  |   4 +-

 Modules/_blake2/blake2module.c  |   2 +-

 Modules/_blake2/blake2s_impl.c  |   4 +-

 Modules/_hashopenssl.c          |  43 +++++++++++++

 Modules/clinic/_hashopenssl.c.h | 106 +++++++++++++++++++++++++++++++-

 6 files changed, 158 insertions(+), 12 deletions(-)

diff --git a/Include/_hashopenssl.h b/Include/_hashopenssl.h

index a726c0d..47ed003 100644

--- a/Include/_hashopenssl.h

+++ b/Include/_hashopenssl.h

@@ -39,7 +39,7 @@ _setException(PyObject *exc)

 __attribute__((__unused__))

 static int

-_Py_hashlib_fips_error(char *name) {

+_Py_hashlib_fips_error(PyObject *exc, char *name) {

     int result = FIPS_mode();

     if (result == 0) {

         // "If the library was built without support of the FIPS Object Module,

@@ -49,18 +49,17 @@ _Py_hashlib_fips_error(char *name) {

         unsigned long errcode = ERR_peek_last_error();

         if (errcode) {

-            _setException(PyExc_ValueError);

+            _setException(exc);

             return 1;

         }

         return 0;

     }

-    PyErr_Format(PyExc_ValueError, "%s is not available in FIPS mode",

-                 name);

+    PyErr_Format(exc, "%s is not available in FIPS mode", name);

     return 1;

 }

-#define FAIL_RETURN_IN_FIPS_MODE(name) do { \

-    if (_Py_hashlib_fips_error(name)) return NULL; \

+#define FAIL_RETURN_IN_FIPS_MODE(exc, name) do { \

+    if (_Py_hashlib_fips_error(exc, name)) return NULL; \

 } while (0)

 #endif  // !Py_HASHOPENSSL_H

diff --git a/Modules/_blake2/blake2b_impl.c b/Modules/_blake2/blake2b_impl.c

index 67620af..9e125dc 100644

--- a/Modules/_blake2/blake2b_impl.c

+++ b/Modules/_blake2/blake2b_impl.c

@@ -97,7 +97,7 @@ py_blake2b_new_impl(PyTypeObject *type, PyObject *data, int digest_size,

     BLAKE2bObject *self = NULL;

     Py_buffer buf;

-    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+    FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2");

     self = new_BLAKE2bObject(type);

     if (self == NULL) {

@@ -277,7 +277,7 @@ _blake2_blake2b_update(BLAKE2bObject *self, PyObject *data)

 {

     Py_buffer buf;

-    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+    FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2");

     GET_BUFFER_VIEW_OR_ERROUT(data, &buf;;

diff --git a/Modules/_blake2/blake2module.c b/Modules/_blake2/blake2module.c

index bc67529..79a9eed 100644

--- a/Modules/_blake2/blake2module.c

+++ b/Modules/_blake2/blake2module.c

@@ -58,7 +58,7 @@ PyInit__blake2(void)

     PyObject *m;

     PyObject *d;

-    FAIL_RETURN_IN_FIPS_MODE("blake2");

+    FAIL_RETURN_IN_FIPS_MODE(PyExc_ImportError, "blake2");

     m = PyModule_Create(&blake2_module);

     if (m == NULL)

diff --git a/Modules/_blake2/blake2s_impl.c b/Modules/_blake2/blake2s_impl.c

index 57c0f3f..b59624d 100644

--- a/Modules/_blake2/blake2s_impl.c

+++ b/Modules/_blake2/blake2s_impl.c

@@ -97,7 +97,7 @@ py_blake2s_new_impl(PyTypeObject *type, PyObject *data, int digest_size,

     BLAKE2sObject *self = NULL;

     Py_buffer buf;

-    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+    FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2");

     self = new_BLAKE2sObject(type);

     if (self == NULL) {

@@ -277,7 +277,7 @@ _blake2_blake2s_update(BLAKE2sObject *self, PyObject *data)

 {

     Py_buffer buf;

-    FAIL_RETURN_IN_FIPS_MODE("_blake2");

+    FAIL_RETURN_IN_FIPS_MODE(PyExc_ValueError, "_blake2");

     GET_BUFFER_VIEW_OR_ERROUT(data, &buf;;

diff --git a/Modules/_hashopenssl.c b/Modules/_hashopenssl.c

index 3d788f5..dc130f6 100644

--- a/Modules/_hashopenssl.c

+++ b/Modules/_hashopenssl.c

@@ -259,6 +259,12 @@ py_digest_by_name(const char *name)

         else if (!strcmp(name, "blake2b512")) {

             digest = EVP_blake2b512();

         }

+        else if (!strcmp(name, "blake2s")) {

+            digest = EVP_blake2s256();

+        }

+        else if (!strcmp(name, "blake2b")) {

+            digest = EVP_blake2b512();

+        }

 #endif

     }

@@ -952,6 +958,41 @@ _hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj,

 }

+/*[clinic input]

+_hashlib.openssl_blake2b

+    string as data_obj: object(py_default="b''") = NULL

+    *

+    usedforsecurity: bool = True