gh-99108: Refactor _sha256 & _sha512 into _sha2. (#101924)

This merges their code. They're backed by the same single HACL* static library, having them be a single module simplifies maintenance.

This should unbreak the wasm enscripten builds that currently fail due to linking in --whole-archive mode and the HACL* library appearing twice.

Long unnoticed error fixed: _sha512.SHA384Type was doubly assigned and was actually SHA512Type. Nobody depends on those internal names.

Also rename LIBHACL_ make vars to LIBHACL_SHA2_ in preperation for other future HACL things.

8 files changed, 1247 insertions, 1375 deletions

diff --git a/Modules/Setup b/Modules/Setup
index 428be0a..1d5183b 100644
--- a/Modules/Setup
+++ b/Modules/Setup
@@ -165,8 +165,7 @@ PYTHONPATH=$(COREPYTHONPATH)
 #_blake2 _blake2/blake2module.c _blake2/blake2b_impl.c _blake2/blake2s_impl.c
 #_md5 md5module.c
 #_sha1 sha1module.c
-#_sha256 sha256module.c
-#_sha512 sha512module.c
+#_sha2 sha2module.c -I$(srcdir)/Modules/_hacl/include Modules/_hacl/libHacl_Streaming_SHA2.a
 #_sha3 _sha3/sha3module.c
 
 # text encodings and unicode
diff --git a/Modules/Setup.stdlib.in b/Modules/Setup.stdlib.in
index 22bcb42..8f5e14a 100644
--- a/Modules/Setup.stdlib.in
+++ b/Modules/Setup.stdlib.in
@@ -79,8 +79,7 @@
 # hashing builtins, can be disabled with --without-builtin-hashlib-hashes
 @MODULE__MD5_TRUE@_md5 md5module.c
 @MODULE__SHA1_TRUE@_sha1 sha1module.c
-@MODULE__SHA256_TRUE@_sha256 sha256module.c -I$(srcdir)/Modules/_hacl/include Modules/_hacl/libHacl_Streaming_SHA2.a
-@MODULE__SHA512_TRUE@_sha512 sha512module.c -I$(srcdir)/Modules/_hacl/include Modules/_hacl/libHacl_Streaming_SHA2.a
+@MODULE__SHA2_TRUE@_sha2 sha2module.c -I$(srcdir)/Modules/_hacl/include Modules/_hacl/libHacl_Streaming_SHA2.a
 @MODULE__SHA3_TRUE@_sha3 _sha3/sha3module.c
 @MODULE__BLAKE2_TRUE@_blake2 _blake2/blake2module.c _blake2/blake2b_impl.c _blake2/blake2s_impl.c
 
diff --git a/Modules/clinic/sha256module.c.h b/Modules/clinic/sha256module.c.h
deleted file mode 100644
index 10d09fa..0000000
--- a/Modules/clinic/sha256module.c.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*[clinic input]
-preserve
-[clinic start generated code]*/
-
-#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-#  include "pycore_gc.h"            // PyGC_Head
-#  include "pycore_runtime.h"       // _Py_ID()
-#endif
-
-
-PyDoc_STRVAR(SHA256Type_copy__doc__,
-"copy($self, /)\n"
-"--\n"
-"\n"
-"Return a copy of the hash object.");
-
-#define SHA256TYPE_COPY_METHODDEF    \
-    {"copy", _PyCFunction_CAST(SHA256Type_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, SHA256Type_copy__doc__},
-
-static PyObject *
-SHA256Type_copy_impl(SHAobject *self, PyTypeObject *cls);
-
-static PyObject *
-SHA256Type_copy(SHAobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    if (nargs) {
-        PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
-        return NULL;
-    }
-    return SHA256Type_copy_impl(self, cls);
-}
-
-PyDoc_STRVAR(SHA256Type_digest__doc__,
-"digest($self, /)\n"
-"--\n"
-"\n"
-"Return the digest value as a bytes object.");
-
-#define SHA256TYPE_DIGEST_METHODDEF    \
-    {"digest", (PyCFunction)SHA256Type_digest, METH_NOARGS, SHA256Type_digest__doc__},
-
-static PyObject *
-SHA256Type_digest_impl(SHAobject *self);
-
-static PyObject *
-SHA256Type_digest(SHAobject *self, PyObject *Py_UNUSED(ignored))
-{
-    return SHA256Type_digest_impl(self);
-}
-
-PyDoc_STRVAR(SHA256Type_hexdigest__doc__,
-"hexdigest($self, /)\n"
-"--\n"
-"\n"
-"Return the digest value as a string of hexadecimal digits.");
-
-#define SHA256TYPE_HEXDIGEST_METHODDEF    \
-    {"hexdigest", (PyCFunction)SHA256Type_hexdigest, METH_NOARGS, SHA256Type_hexdigest__doc__},
-
-static PyObject *
-SHA256Type_hexdigest_impl(SHAobject *self);
-
-static PyObject *
-SHA256Type_hexdigest(SHAobject *self, PyObject *Py_UNUSED(ignored))
-{
-    return SHA256Type_hexdigest_impl(self);
-}
-
-PyDoc_STRVAR(SHA256Type_update__doc__,
-"update($self, obj, /)\n"
-"--\n"
-"\n"
-"Update this hash object\'s state with the provided string.");
-
-#define SHA256TYPE_UPDATE_METHODDEF    \
-    {"update", (PyCFunction)SHA256Type_update, METH_O, SHA256Type_update__doc__},
-
-PyDoc_STRVAR(_sha256_sha256__doc__,
-"sha256($module, /, string=b\'\', *, usedforsecurity=True)\n"
-"--\n"
-"\n"
-"Return a new SHA-256 hash object; optionally initialized with a string.");
-
-#define _SHA256_SHA256_METHODDEF    \
-    {"sha256", _PyCFunction_CAST(_sha256_sha256), METH_FASTCALL|METH_KEYWORDS, _sha256_sha256__doc__},
-
-static PyObject *
-_sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity);
-
-static PyObject *
-_sha256_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    PyObject *return_value = NULL;
-    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-
-    #define NUM_KEYWORDS 2
-    static struct {
-        PyGC_Head _this_is_not_used;
-        PyObject_VAR_HEAD
-        PyObject *ob_item[NUM_KEYWORDS];
-    } _kwtuple = {
-        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
-        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
-    };
-    #undef NUM_KEYWORDS
-    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
-
-    #else  // !Py_BUILD_CORE
-    #  define KWTUPLE NULL
-    #endif  // !Py_BUILD_CORE
-
-    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
-    static _PyArg_Parser _parser = {
-        .keywords = _keywords,
-        .fname = "sha256",
-        .kwtuple = KWTUPLE,
-    };
-    #undef KWTUPLE
-    PyObject *argsbuf[2];
-    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
-    PyObject *string = NULL;
-    int usedforsecurity = 1;
-
-    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
-    if (!args) {
-        goto exit;
-    }
-    if (!noptargs) {
-        goto skip_optional_pos;
-    }
-    if (args[0]) {
-        string = args[0];
-        if (!--noptargs) {
-            goto skip_optional_pos;
-        }
-    }
-skip_optional_pos:
-    if (!noptargs) {
-        goto skip_optional_kwonly;
-    }
-    usedforsecurity = PyObject_IsTrue(args[1]);
-    if (usedforsecurity < 0) {
-        goto exit;
-    }
-skip_optional_kwonly:
-    return_value = _sha256_sha256_impl(module, string, usedforsecurity);
-
-exit:
-    return return_value;
-}
-
-PyDoc_STRVAR(_sha256_sha224__doc__,
-"sha224($module, /, string=b\'\', *, usedforsecurity=True)\n"
-"--\n"
-"\n"
-"Return a new SHA-224 hash object; optionally initialized with a string.");
-
-#define _SHA256_SHA224_METHODDEF    \
-    {"sha224", _PyCFunction_CAST(_sha256_sha224), METH_FASTCALL|METH_KEYWORDS, _sha256_sha224__doc__},
-
-static PyObject *
-_sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity);
-
-static PyObject *
-_sha256_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    PyObject *return_value = NULL;
-    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-
-    #define NUM_KEYWORDS 2
-    static struct {
-        PyGC_Head _this_is_not_used;
-        PyObject_VAR_HEAD
-        PyObject *ob_item[NUM_KEYWORDS];
-    } _kwtuple = {
-        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
-        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
-    };
-    #undef NUM_KEYWORDS
-    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
-
-    #else  // !Py_BUILD_CORE
-    #  define KWTUPLE NULL
-    #endif  // !Py_BUILD_CORE
-
-    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
-    static _PyArg_Parser _parser = {
-        .keywords = _keywords,
-        .fname = "sha224",
-        .kwtuple = KWTUPLE,
-    };
-    #undef KWTUPLE
-    PyObject *argsbuf[2];
-    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
-    PyObject *string = NULL;
-    int usedforsecurity = 1;
-
-    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
-    if (!args) {
-        goto exit;
-    }
-    if (!noptargs) {
-        goto skip_optional_pos;
-    }
-    if (args[0]) {
-        string = args[0];
-        if (!--noptargs) {
-            goto skip_optional_pos;
-        }
-    }
-skip_optional_pos:
-    if (!noptargs) {
-        goto skip_optional_kwonly;
-    }
-    usedforsecurity = PyObject_IsTrue(args[1]);
-    if (usedforsecurity < 0) {
-        goto exit;
-    }
-skip_optional_kwonly:
-    return_value = _sha256_sha224_impl(module, string, usedforsecurity);
-
-exit:
-    return return_value;
-}
-/*[clinic end generated code: output=ae926f7ec85e7c97 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/sha2module.c.h b/Modules/clinic/sha2module.c.h
new file mode 100644
index 0000000..8f855ca
--- /dev/null
+++ b/Modules/clinic/sha2module.c.h
@@ -0,0 +1,440 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+#  include "pycore_gc.h"            // PyGC_Head
+#  include "pycore_runtime.h"       // _Py_ID()
+#endif
+
+
+PyDoc_STRVAR(SHA256Type_copy__doc__,
+"copy($self, /)\n"
+"--\n"
+"\n"
+"Return a copy of the hash object.");
+
+#define SHA256TYPE_COPY_METHODDEF    \
+    {"copy", _PyCFunction_CAST(SHA256Type_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, SHA256Type_copy__doc__},
+
+static PyObject *
+SHA256Type_copy_impl(SHA256object *self, PyTypeObject *cls);
+
+static PyObject *
+SHA256Type_copy(SHA256object *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs) {
+        PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
+        return NULL;
+    }
+    return SHA256Type_copy_impl(self, cls);
+}
+
+PyDoc_STRVAR(SHA512Type_copy__doc__,
+"copy($self, /)\n"
+"--\n"
+"\n"
+"Return a copy of the hash object.");
+
+#define SHA512TYPE_COPY_METHODDEF    \
+    {"copy", _PyCFunction_CAST(SHA512Type_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, SHA512Type_copy__doc__},
+
+static PyObject *
+SHA512Type_copy_impl(SHA512object *self, PyTypeObject *cls);
+
+static PyObject *
+SHA512Type_copy(SHA512object *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    if (nargs) {
+        PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
+        return NULL;
+    }
+    return SHA512Type_copy_impl(self, cls);
+}
+
+PyDoc_STRVAR(SHA256Type_digest__doc__,
+"digest($self, /)\n"
+"--\n"
+"\n"
+"Return the digest value as a bytes object.");
+
+#define SHA256TYPE_DIGEST_METHODDEF    \
+    {"digest", (PyCFunction)SHA256Type_digest, METH_NOARGS, SHA256Type_digest__doc__},
+
+static PyObject *
+SHA256Type_digest_impl(SHA256object *self);
+
+static PyObject *
+SHA256Type_digest(SHA256object *self, PyObject *Py_UNUSED(ignored))
+{
+    return SHA256Type_digest_impl(self);
+}
+
+PyDoc_STRVAR(SHA512Type_digest__doc__,
+"digest($self, /)\n"
+"--\n"
+"\n"
+"Return the digest value as a bytes object.");
+
+#define SHA512TYPE_DIGEST_METHODDEF    \
+    {"digest", (PyCFunction)SHA512Type_digest, METH_NOARGS, SHA512Type_digest__doc__},
+
+static PyObject *
+SHA512Type_digest_impl(SHA512object *self);
+
+static PyObject *
+SHA512Type_digest(SHA512object *self, PyObject *Py_UNUSED(ignored))
+{
+    return SHA512Type_digest_impl(self);
+}
+
+PyDoc_STRVAR(SHA256Type_hexdigest__doc__,
+"hexdigest($self, /)\n"
+"--\n"
+"\n"
+"Return the digest value as a string of hexadecimal digits.");
+
+#define SHA256TYPE_HEXDIGEST_METHODDEF    \
+    {"hexdigest", (PyCFunction)SHA256Type_hexdigest, METH_NOARGS, SHA256Type_hexdigest__doc__},
+
+static PyObject *
+SHA256Type_hexdigest_impl(SHA256object *self);
+
+static PyObject *
+SHA256Type_hexdigest(SHA256object *self, PyObject *Py_UNUSED(ignored))
+{
+    return SHA256Type_hexdigest_impl(self);
+}
+
+PyDoc_STRVAR(SHA512Type_hexdigest__doc__,
+"hexdigest($self, /)\n"
+"--\n"
+"\n"
+"Return the digest value as a string of hexadecimal digits.");
+
+#define SHA512TYPE_HEXDIGEST_METHODDEF    \
+    {"hexdigest", (PyCFunction)SHA512Type_hexdigest, METH_NOARGS, SHA512Type_hexdigest__doc__},
+
+static PyObject *
+SHA512Type_hexdigest_impl(SHA512object *self);
+
+static PyObject *
+SHA512Type_hexdigest(SHA512object *self, PyObject *Py_UNUSED(ignored))
+{
+    return SHA512Type_hexdigest_impl(self);
+}
+
+PyDoc_STRVAR(SHA256Type_update__doc__,
+"update($self, obj, /)\n"
+"--\n"
+"\n"
+"Update this hash object\'s state with the provided string.");
+
+#define SHA256TYPE_UPDATE_METHODDEF    \
+    {"update", (PyCFunction)SHA256Type_update, METH_O, SHA256Type_update__doc__},
+
+PyDoc_STRVAR(SHA512Type_update__doc__,
+"update($self, obj, /)\n"
+"--\n"
+"\n"
+"Update this hash object\'s state with the provided string.");
+
+#define SHA512TYPE_UPDATE_METHODDEF    \
+    {"update", (PyCFunction)SHA512Type_update, METH_O, SHA512Type_update__doc__},
+
+PyDoc_STRVAR(_sha2_sha256__doc__,
+"sha256($module, /, string=b\'\', *, usedforsecurity=True)\n"
+"--\n"
+"\n"
+"Return a new SHA-256 hash object; optionally initialized with a string.");
+
+#define _SHA2_SHA256_METHODDEF    \
+    {"sha256", _PyCFunction_CAST(_sha2_sha256), METH_FASTCALL|METH_KEYWORDS, _sha2_sha256__doc__},
+
+static PyObject *
+_sha2_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity);
+
+static PyObject *
+_sha2_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "sha256",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *string = NULL;
+    int usedforsecurity = 1;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        string = args[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    usedforsecurity = PyObject_IsTrue(args[1]);
+    if (usedforsecurity < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = _sha2_sha256_impl(module, string, usedforsecurity);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_sha2_sha224__doc__,
+"sha224($module, /, string=b\'\', *, usedforsecurity=True)\n"
+"--\n"
+"\n"
+"Return a new SHA-224 hash object; optionally initialized with a string.");
+
+#define _SHA2_SHA224_METHODDEF    \
+    {"sha224", _PyCFunction_CAST(_sha2_sha224), METH_FASTCALL|METH_KEYWORDS, _sha2_sha224__doc__},
+
+static PyObject *
+_sha2_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity);
+
+static PyObject *
+_sha2_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "sha224",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *string = NULL;
+    int usedforsecurity = 1;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        string = args[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    usedforsecurity = PyObject_IsTrue(args[1]);
+    if (usedforsecurity < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = _sha2_sha224_impl(module, string, usedforsecurity);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_sha2_sha512__doc__,
+"sha512($module, /, string=b\'\', *, usedforsecurity=True)\n"
+"--\n"
+"\n"
+"Return a new SHA-512 hash object; optionally initialized with a string.");
+
+#define _SHA2_SHA512_METHODDEF    \
+    {"sha512", _PyCFunction_CAST(_sha2_sha512), METH_FASTCALL|METH_KEYWORDS, _sha2_sha512__doc__},
+
+static PyObject *
+_sha2_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity);
+
+static PyObject *
+_sha2_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "sha512",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *string = NULL;
+    int usedforsecurity = 1;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        string = args[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    usedforsecurity = PyObject_IsTrue(args[1]);
+    if (usedforsecurity < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = _sha2_sha512_impl(module, string, usedforsecurity);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_sha2_sha384__doc__,
+"sha384($module, /, string=b\'\', *, usedforsecurity=True)\n"
+"--\n"
+"\n"
+"Return a new SHA-384 hash object; optionally initialized with a string.");
+
+#define _SHA2_SHA384_METHODDEF    \
+    {"sha384", _PyCFunction_CAST(_sha2_sha384), METH_FASTCALL|METH_KEYWORDS, _sha2_sha384__doc__},
+
+static PyObject *
+_sha2_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity);
+
+static PyObject *
+_sha2_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
+{
+    PyObject *return_value = NULL;
+    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
+
+    #define NUM_KEYWORDS 2
+    static struct {
+        PyGC_Head _this_is_not_used;
+        PyObject_VAR_HEAD
+        PyObject *ob_item[NUM_KEYWORDS];
+    } _kwtuple = {
+        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
+        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
+    };
+    #undef NUM_KEYWORDS
+    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
+
+    #else  // !Py_BUILD_CORE
+    #  define KWTUPLE NULL
+    #endif  // !Py_BUILD_CORE
+
+    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
+    static _PyArg_Parser _parser = {
+        .keywords = _keywords,
+        .fname = "sha384",
+        .kwtuple = KWTUPLE,
+    };
+    #undef KWTUPLE
+    PyObject *argsbuf[2];
+    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
+    PyObject *string = NULL;
+    int usedforsecurity = 1;
+
+    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
+    if (!args) {
+        goto exit;
+    }
+    if (!noptargs) {
+        goto skip_optional_pos;
+    }
+    if (args[0]) {
+        string = args[0];
+        if (!--noptargs) {
+            goto skip_optional_pos;
+        }
+    }
+skip_optional_pos:
+    if (!noptargs) {
+        goto skip_optional_kwonly;
+    }
+    usedforsecurity = PyObject_IsTrue(args[1]);
+    if (usedforsecurity < 0) {
+        goto exit;
+    }
+skip_optional_kwonly:
+    return_value = _sha2_sha384_impl(module, string, usedforsecurity);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=f81dacb48f3fee72 input=a9049054013a1b77]*/
diff --git a/Modules/clinic/sha512module.c.h b/Modules/clinic/sha512module.c.h
deleted file mode 100644
index f8d3263..0000000
--- a/Modules/clinic/sha512module.c.h
+++ /dev/null
@@ -1,225 +0,0 @@
-/*[clinic input]
-preserve
-[clinic start generated code]*/
-
-#if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-#  include "pycore_gc.h"            // PyGC_Head
-#  include "pycore_runtime.h"       // _Py_ID()
-#endif
-
-
-PyDoc_STRVAR(SHA512Type_copy__doc__,
-"copy($self, /)\n"
-"--\n"
-"\n"
-"Return a copy of the hash object.");
-
-#define SHA512TYPE_COPY_METHODDEF    \
-    {"copy", _PyCFunction_CAST(SHA512Type_copy), METH_METHOD|METH_FASTCALL|METH_KEYWORDS, SHA512Type_copy__doc__},
-
-static PyObject *
-SHA512Type_copy_impl(SHAobject *self, PyTypeObject *cls);
-
-static PyObject *
-SHA512Type_copy(SHAobject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    if (nargs) {
-        PyErr_SetString(PyExc_TypeError, "copy() takes no arguments");
-        return NULL;
-    }
-    return SHA512Type_copy_impl(self, cls);
-}
-
-PyDoc_STRVAR(SHA512Type_digest__doc__,
-"digest($self, /)\n"
-"--\n"
-"\n"
-"Return the digest value as a bytes object.");
-
-#define SHA512TYPE_DIGEST_METHODDEF    \
-    {"digest", (PyCFunction)SHA512Type_digest, METH_NOARGS, SHA512Type_digest__doc__},
-
-static PyObject *
-SHA512Type_digest_impl(SHAobject *self);
-
-static PyObject *
-SHA512Type_digest(SHAobject *self, PyObject *Py_UNUSED(ignored))
-{
-    return SHA512Type_digest_impl(self);
-}
-
-PyDoc_STRVAR(SHA512Type_hexdigest__doc__,
-"hexdigest($self, /)\n"
-"--\n"
-"\n"
-"Return the digest value as a string of hexadecimal digits.");
-
-#define SHA512TYPE_HEXDIGEST_METHODDEF    \
-    {"hexdigest", (PyCFunction)SHA512Type_hexdigest, METH_NOARGS, SHA512Type_hexdigest__doc__},
-
-static PyObject *
-SHA512Type_hexdigest_impl(SHAobject *self);
-
-static PyObject *
-SHA512Type_hexdigest(SHAobject *self, PyObject *Py_UNUSED(ignored))
-{
-    return SHA512Type_hexdigest_impl(self);
-}
-
-PyDoc_STRVAR(SHA512Type_update__doc__,
-"update($self, obj, /)\n"
-"--\n"
-"\n"
-"Update this hash object\'s state with the provided string.");
-
-#define SHA512TYPE_UPDATE_METHODDEF    \
-    {"update", (PyCFunction)SHA512Type_update, METH_O, SHA512Type_update__doc__},
-
-PyDoc_STRVAR(_sha512_sha512__doc__,
-"sha512($module, /, string=b\'\', *, usedforsecurity=True)\n"
-"--\n"
-"\n"
-"Return a new SHA-512 hash object; optionally initialized with a string.");
-
-#define _SHA512_SHA512_METHODDEF    \
-    {"sha512", _PyCFunction_CAST(_sha512_sha512), METH_FASTCALL|METH_KEYWORDS, _sha512_sha512__doc__},
-
-static PyObject *
-_sha512_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity);
-
-static PyObject *
-_sha512_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    PyObject *return_value = NULL;
-    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-
-    #define NUM_KEYWORDS 2
-    static struct {
-        PyGC_Head _this_is_not_used;
-        PyObject_VAR_HEAD
-        PyObject *ob_item[NUM_KEYWORDS];
-    } _kwtuple = {
-        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
-        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
-    };
-    #undef NUM_KEYWORDS
-    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
-
-    #else  // !Py_BUILD_CORE
-    #  define KWTUPLE NULL
-    #endif  // !Py_BUILD_CORE
-
-    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
-    static _PyArg_Parser _parser = {
-        .keywords = _keywords,
-        .fname = "sha512",
-        .kwtuple = KWTUPLE,
-    };
-    #undef KWTUPLE
-    PyObject *argsbuf[2];
-    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
-    PyObject *string = NULL;
-    int usedforsecurity = 1;
-
-    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
-    if (!args) {
-        goto exit;
-    }
-    if (!noptargs) {
-        goto skip_optional_pos;
-    }
-    if (args[0]) {
-        string = args[0];
-        if (!--noptargs) {
-            goto skip_optional_pos;
-        }
-    }
-skip_optional_pos:
-    if (!noptargs) {
-        goto skip_optional_kwonly;
-    }
-    usedforsecurity = PyObject_IsTrue(args[1]);
-    if (usedforsecurity < 0) {
-        goto exit;
-    }
-skip_optional_kwonly:
-    return_value = _sha512_sha512_impl(module, string, usedforsecurity);
-
-exit:
-    return return_value;
-}
-
-PyDoc_STRVAR(_sha512_sha384__doc__,
-"sha384($module, /, string=b\'\', *, usedforsecurity=True)\n"
-"--\n"
-"\n"
-"Return a new SHA-384 hash object; optionally initialized with a string.");
-
-#define _SHA512_SHA384_METHODDEF    \
-    {"sha384", _PyCFunction_CAST(_sha512_sha384), METH_FASTCALL|METH_KEYWORDS, _sha512_sha384__doc__},
-
-static PyObject *
-_sha512_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity);
-
-static PyObject *
-_sha512_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
-{
-    PyObject *return_value = NULL;
-    #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
-
-    #define NUM_KEYWORDS 2
-    static struct {
-        PyGC_Head _this_is_not_used;
-        PyObject_VAR_HEAD
-        PyObject *ob_item[NUM_KEYWORDS];
-    } _kwtuple = {
-        .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
-        .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
-    };
-    #undef NUM_KEYWORDS
-    #define KWTUPLE (&_kwtuple.ob_base.ob_base)
-
-    #else  // !Py_BUILD_CORE
-    #  define KWTUPLE NULL
-    #endif  // !Py_BUILD_CORE
-
-    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
-    static _PyArg_Parser _parser = {
-        .keywords = _keywords,
-        .fname = "sha384",
-        .kwtuple = KWTUPLE,
-    };
-    #undef KWTUPLE
-    PyObject *argsbuf[2];
-    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
-    PyObject *string = NULL;
-    int usedforsecurity = 1;
-
-    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
-    if (!args) {
-        goto exit;
-    }
-    if (!noptargs) {
-        goto skip_optional_pos;
-    }
-    if (args[0]) {
-        string = args[0];
-        if (!--noptargs) {
-            goto skip_optional_pos;
-        }
-    }
-skip_optional_pos:
-    if (!noptargs) {
-        goto skip_optional_kwonly;
-    }
-    usedforsecurity = PyObject_IsTrue(args[1]);
-    if (usedforsecurity < 0) {
-        goto exit;
-    }
-skip_optional_kwonly:
-    return_value = _sha512_sha384_impl(module, string, usedforsecurity);
-
-exit:
-    return return_value;
-}
-/*[clinic end generated code: output=dd168f3f21097afe input=a9049054013a1b77]*/
diff --git a/Modules/sha256module.c b/Modules/sha256module.c
deleted file mode 100644
index 301c983..0000000
--- a/Modules/sha256module.c
+++ /dev/null
@@ -1,465 +0,0 @@
-/* SHA256 module */
-
-/* This module provides an interface to NIST's SHA-256 and SHA-224 Algorithms */
-
-/* See below for information about the original code this module was
-   based upon. Additional work performed by:
-
-   Andrew Kuchling (amk@amk.ca)
-   Greg Stein (gstein@lyra.org)
-   Trevor Perrin (trevp@trevp.net)
-   Jonathan Protzenko (jonathan@protzenko.fr)
-
-   Copyright (C) 2005-2007   Gregory P. Smith (greg@krypto.org)
-   Licensed to PSF under a Contributor Agreement.
-
-*/
-
-/* SHA objects */
-#ifndef Py_BUILD_CORE_BUILTIN
-#  define Py_BUILD_CORE_MODULE 1
-#endif
-
-#include "Python.h"
-#include "pycore_bitutils.h"      // _Py_bswap32()
-#include "pycore_strhex.h"        // _Py_strhex()
-#include "structmember.h"         // PyMemberDef
-#include "hashlib.h"
-
-/*[clinic input]
-module _sha256
-class SHA256Type "SHAobject *" "&PyType_Type"
-[clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=71a39174d4f0a744]*/
-
-
-/* The SHA block size and maximum message digest sizes, in bytes */
-
-#define SHA_BLOCKSIZE    64
-#define SHA_DIGESTSIZE   32
-
-/* The SHA2-224 and SHA2-256 implementations defer to the HACL* verified
- * library. */
-
-#include "_hacl/Hacl_Streaming_SHA2.h"
-
-typedef struct {
-  PyObject_HEAD
-  // Even though one could conceivably perform run-type checks to tell apart a
-  // sha224_type from a sha256_type (and thus deduce the digest size), we must
-  // keep this field because it's exposed as a member field on the underlying
-  // python object.
-  // TODO: could we transform this into a getter and get rid of the redundant
-  // field?
-  int digestsize;
-  Hacl_Streaming_SHA2_state_sha2_256 *state;
-} SHAobject;
-
-#include "clinic/sha256module.c.h"
-
-/* We shall use run-time type information in the remainder of this module to
- * tell apart SHA2-224 and SHA2-256 */
-typedef struct {
-    PyTypeObject* sha224_type;
-    PyTypeObject* sha256_type;
-} _sha256_state;
-
-static inline _sha256_state*
-_sha256_get_state(PyObject *module)
-{
-    void *state = PyModule_GetState(module);
-    assert(state != NULL);
-    return (_sha256_state *)state;
-}
-
-static void SHAcopy(SHAobject *src, SHAobject *dest)
-{
-    dest->digestsize = src->digestsize;
-    dest->state = Hacl_Streaming_SHA2_copy_256(src->state);
-}
-
-static SHAobject *
-newSHA224object(_sha256_state *state)
-{
-    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject,
-                                                  state->sha224_type);
-    PyObject_GC_Track(sha);
-    return sha;
-}
-
-static SHAobject *
-newSHA256object(_sha256_state *state)
-{
-    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject,
-                                                  state->sha256_type);
-    PyObject_GC_Track(sha);
-    return sha;
-}
-
-/* Internal methods for a hash object */
-static int
-SHA_traverse(PyObject *ptr, visitproc visit, void *arg)
-{
-    Py_VISIT(Py_TYPE(ptr));
-    return 0;
-}
-
-static void
-SHA_dealloc(SHAobject *ptr)
-{
-    Hacl_Streaming_SHA2_free_256(ptr->state);
-    PyTypeObject *tp = Py_TYPE(ptr);
-    PyObject_GC_UnTrack(ptr);
-    PyObject_GC_Del(ptr);
-    Py_DECREF(tp);
-}
-
-/* HACL* takes a uint32_t for the length of its parameter, but Py_ssize_t can be
- * 64 bits. */
-static void update_256(Hacl_Streaming_SHA2_state_sha2_256 *state, uint8_t *buf, Py_ssize_t len) {
-  /* Note: we explicitly ignore the error code on the basis that it would take >
-   * 1 billion years to overflow the maximum admissible length for SHA2-256
-   * (namely, 2^61-1 bytes). */
-  while (len > UINT32_MAX) {
-    Hacl_Streaming_SHA2_update_256(state, buf, UINT32_MAX);
-    len -= UINT32_MAX;
-    buf += UINT32_MAX;
-  }
-  /* Cast to uint32_t is safe: upon exiting the loop, len <= UINT32_MAX, and
-   * therefore fits in a uint32_t */
-  Hacl_Streaming_SHA2_update_256(state, buf, (uint32_t) len);
-}
-
-
-/* External methods for a hash object */
-
-/*[clinic input]
-SHA256Type.copy
-
-    cls:defining_class
-
-Return a copy of the hash object.
-[clinic start generated code]*/
-
-static PyObject *
-SHA256Type_copy_impl(SHAobject *self, PyTypeObject *cls)
-/*[clinic end generated code: output=9273f92c382be12f input=3137146fcb88e212]*/
-{
-    SHAobject *newobj;
-    _sha256_state *state = PyType_GetModuleState(cls);
-    if (Py_IS_TYPE(self, state->sha256_type)) {
-        if ( (newobj = newSHA256object(state)) == NULL) {
-            return NULL;
-        }
-    } else {
-        if ( (newobj = newSHA224object(state))==NULL) {
-            return NULL;
-        }
-    }
-
-    SHAcopy(self, newobj);
-    return (PyObject *)newobj;
-}
-
-/*[clinic input]
-SHA256Type.digest
-
-Return the digest value as a bytes object.
-[clinic start generated code]*/
-
-static PyObject *
-SHA256Type_digest_impl(SHAobject *self)
-/*[clinic end generated code: output=46616a5e909fbc3d input=f1f4cfea5cbde35c]*/
-{
-    uint8_t digest[SHA_DIGESTSIZE];
-    // HACL performs copies under the hood so that self->state remains valid
-    // after this call.
-    Hacl_Streaming_SHA2_finish_256(self->state, digest);
-    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
-}
-
-/*[clinic input]
-SHA256Type.hexdigest
-
-Return the digest value as a string of hexadecimal digits.
-[clinic start generated code]*/
-
-static PyObject *
-SHA256Type_hexdigest_impl(SHAobject *self)
-/*[clinic end generated code: output=725f8a7041ae97f3 input=0cc4c714693010d1]*/
-{
-    uint8_t digest[SHA_DIGESTSIZE];
-    Hacl_Streaming_SHA2_finish_256(self->state, digest);
-    return _Py_strhex((const char *)digest, self->digestsize);
-}
-
-/*[clinic input]
-SHA256Type.update
-
-    obj: object
-    /
-
-Update this hash object's state with the provided string.
-[clinic start generated code]*/
-
-static PyObject *
-SHA256Type_update(SHAobject *self, PyObject *obj)
-/*[clinic end generated code: output=0967fb2860c66af7 input=b2d449d5b30f0f5a]*/
-{
-    Py_buffer buf;
-
-    GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
-
-    update_256(self->state, buf.buf, buf.len);
-
-    PyBuffer_Release(&buf);
-    Py_RETURN_NONE;
-}
-
-static PyMethodDef SHA_methods[] = {
-    SHA256TYPE_COPY_METHODDEF
-    SHA256TYPE_DIGEST_METHODDEF
-    SHA256TYPE_HEXDIGEST_METHODDEF
-    SHA256TYPE_UPDATE_METHODDEF
-    {NULL,        NULL}         /* sentinel */
-};
-
-static PyObject *
-SHA256_get_block_size(PyObject *self, void *closure)
-{
-    return PyLong_FromLong(SHA_BLOCKSIZE);
-}
-
-static PyObject *
-SHA256_get_name(SHAobject *self, void *closure)
-{
-    if (self->digestsize == 28) {
-        return PyUnicode_FromStringAndSize("sha224", 6);
-    }
-    return PyUnicode_FromStringAndSize("sha256", 6);
-}
-
-static PyGetSetDef SHA_getseters[] = {
-    {"block_size",
-     (getter)SHA256_get_block_size, NULL,
-     NULL,
-     NULL},
-    {"name",
-     (getter)SHA256_get_name, NULL,
-     NULL,
-     NULL},
-    {NULL}  /* Sentinel */
-};
-
-static PyMemberDef SHA_members[] = {
-    {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
-    {NULL}  /* Sentinel */
-};
-
-static PyType_Slot sha256_types_slots[] = {
-    {Py_tp_dealloc, SHA_dealloc},
-    {Py_tp_methods, SHA_methods},
-    {Py_tp_members, SHA_members},
-    {Py_tp_getset, SHA_getseters},
-    {Py_tp_traverse, SHA_traverse},
-    {0,0}
-};
-
-static PyType_Spec sha224_type_spec = {
-    .name = "_sha256.sha224",
-    .basicsize = sizeof(SHAobject),
-    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
-              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
-    .slots = sha256_types_slots
-};
-
-static PyType_Spec sha256_type_spec = {
-    .name = "_sha256.sha256",
-    .basicsize = sizeof(SHAobject),
-    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
-              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
-    .slots = sha256_types_slots
-};
-
-/* The single module-level function: new() */
-
-/*[clinic input]
-_sha256.sha256
-
-    string: object(c_default="NULL") = b''
-    *
-    usedforsecurity: bool = True
-
-Return a new SHA-256 hash object; optionally initialized with a string.
-[clinic start generated code]*/
-
-static PyObject *
-_sha256_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity)
-/*[clinic end generated code: output=a1de327e8e1185cf input=9be86301aeb14ea5]*/
-{
-    Py_buffer buf;
-
-    if (string) {
-        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
-    }
-
-    _sha256_state *state = PyModule_GetState(module);
-
-    SHAobject *new;
-    if ((new = newSHA256object(state)) == NULL) {
-        if (string) {
-            PyBuffer_Release(&buf);
-        }
-        return NULL;
-    }
-
-    new->state = Hacl_Streaming_SHA2_create_in_256();
-    new->digestsize = 32;
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(new);
-        if (string) {
-            PyBuffer_Release(&buf);
-        }
-        return NULL;
-    }
-    if (string) {
-        update_256(new->state, buf.buf, buf.len);
-        PyBuffer_Release(&buf);
-    }
-
-    return (PyObject *)new;
-}
-
-/*[clinic input]
-_sha256.sha224
-
-    string: object(c_default="NULL") = b''
-    *
-    usedforsecurity: bool = True
-
-Return a new SHA-224 hash object; optionally initialized with a string.
-[clinic start generated code]*/
-
-static PyObject *
-_sha256_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity)
-/*[clinic end generated code: output=08be6b36569bc69c input=9fcfb46e460860ac]*/
-{
-    Py_buffer buf;
-    if (string) {
-        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
-    }
-
-    _sha256_state *state = PyModule_GetState(module);
-    SHAobject *new;
-    if ((new = newSHA224object(state)) == NULL) {
-        if (string) {
-            PyBuffer_Release(&buf);
-        }
-        return NULL;
-    }
-
-    new->state = Hacl_Streaming_SHA2_create_in_224();
-    new->digestsize = 28;
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(new);
-        if (string) {
-            PyBuffer_Release(&buf);
-        }
-        return NULL;
-    }
-    if (string) {
-        update_256(new->state, buf.buf, buf.len);
-        PyBuffer_Release(&buf);
-    }
-
-    return (PyObject *)new;
-}
-
-
-/* List of functions exported by this module */
-
-static struct PyMethodDef SHA_functions[] = {
-    _SHA256_SHA256_METHODDEF
-    _SHA256_SHA224_METHODDEF
-    {NULL,      NULL}            /* Sentinel */
-};
-
-static int
-_sha256_traverse(PyObject *module, visitproc visit, void *arg)
-{
-    _sha256_state *state = _sha256_get_state(module);
-    Py_VISIT(state->sha224_type);
-    Py_VISIT(state->sha256_type);
-    return 0;
-}
-
-static int
-_sha256_clear(PyObject *module)
-{
-    _sha256_state *state = _sha256_get_state(module);
-    Py_CLEAR(state->sha224_type);
-    Py_CLEAR(state->sha256_type);
-    return 0;
-}
-
-static void
-_sha256_free(void *module)
-{
-    _sha256_clear((PyObject *)module);
-}
-
-static int sha256_exec(PyObject *module)
-{
-    _sha256_state *state = _sha256_get_state(module);
-
-    state->sha224_type = (PyTypeObject *)PyType_FromModuleAndSpec(
-        module, &sha224_type_spec, NULL);
-
-    if (state->sha224_type == NULL) {
-        return -1;
-    }
-
-    state->sha256_type = (PyTypeObject *)PyType_FromModuleAndSpec(
-        module, &sha256_type_spec, NULL);
-
-    if (state->sha256_type == NULL) {
-        return -1;
-    }
-
-    Py_INCREF((PyObject *)state->sha224_type);
-    if (PyModule_AddObject(module, "SHA224Type", (PyObject *)state->sha224_type) < 0) {
-        Py_DECREF((PyObject *)state->sha224_type);
-        return -1;
-    }
-    Py_INCREF((PyObject *)state->sha256_type);
-    if (PyModule_AddObject(module, "SHA256Type", (PyObject *)state->sha256_type) < 0) {
-        Py_DECREF((PyObject *)state->sha256_type);
-        return -1;
-    }
-    return 0;
-}
-
-static PyModuleDef_Slot _sha256_slots[] = {
-    {Py_mod_exec, sha256_exec},
-    {0, NULL}
-};
-
-static struct PyModuleDef _sha256module = {
-    PyModuleDef_HEAD_INIT,
-    .m_name = "_sha256",
-    .m_size = sizeof(_sha256_state),
-    .m_methods = SHA_functions,
-    .m_slots = _sha256_slots,
-    .m_traverse = _sha256_traverse,
-    .m_clear = _sha256_clear,
-    .m_free = _sha256_free
-};
-
-/* Initialize this module. */
-PyMODINIT_FUNC
-PyInit__sha256(void)
-{
-    return PyModuleDef_Init(&_sha256module);
-}
diff --git a/Modules/sha2module.c b/Modules/sha2module.c
new file mode 100644
index 0000000..9999f25
--- /dev/null
+++ b/Modules/sha2module.c
@@ -0,0 +1,805 @@
+/* SHA2 module */
+
+/* This provides an interface to NIST's SHA2 224, 256, 384, & 512 Algorithms */
+
+/* See below for information about the original code this module was
+   based upon. Additional work performed by:
+
+   Andrew Kuchling (amk@amk.ca)
+   Greg Stein (gstein@lyra.org)
+   Trevor Perrin (trevp@trevp.net)
+   Jonathan Protzenko (jonathan@protzenko.fr)
+
+   Copyright (C) 2005-2007   Gregory P. Smith (greg@krypto.org)
+   Licensed to PSF under a Contributor Agreement.
+
+*/
+
+/* SHA objects */
+#ifndef Py_BUILD_CORE_BUILTIN
+#  define Py_BUILD_CORE_MODULE 1
+#endif
+
+#include "Python.h"
+#include "pycore_bitutils.h"      // _Py_bswap32()
+#include "pycore_moduleobject.h"  // _PyModule_GetState()
+#include "pycore_strhex.h"        // _Py_strhex()
+#include "structmember.h"         // PyMemberDef
+#include "hashlib.h"
+
+/*[clinic input]
+module _sha2
+class SHA256Type "SHA256object *" "&PyType_Type"
+class SHA512Type "SHA512object *" "&PyType_Type"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=b5315a7b611c9afc]*/
+
+
+/* The SHA block sizes and maximum message digest sizes, in bytes */
+
+#define SHA256_BLOCKSIZE   64
+#define SHA256_DIGESTSIZE  32
+#define SHA512_BLOCKSIZE   128
+#define SHA512_DIGESTSIZE  64
+
+/* Our SHA2 implementations defer to the HACL* verified library. */
+
+#include "_hacl/Hacl_Streaming_SHA2.h"
+
+// TODO: Get rid of int digestsize in favor of Hacl state info?
+
+typedef struct {
+    PyObject_HEAD
+    int digestsize;
+    Hacl_Streaming_SHA2_state_sha2_256 *state;
+} SHA256object;
+
+typedef struct {
+    PyObject_HEAD
+    int digestsize;
+    Hacl_Streaming_SHA2_state_sha2_512 *state;
+} SHA512object;
+
+#include "clinic/sha2module.c.h"
+
+/* We shall use run-time type information in the remainder of this module to
+ * tell apart SHA2-224 and SHA2-256 */
+typedef struct {
+    PyTypeObject* sha224_type;
+    PyTypeObject* sha256_type;
+    PyTypeObject* sha384_type;
+    PyTypeObject* sha512_type;
+} sha2_state;
+
+static inline sha2_state*
+sha2_get_state(PyObject *module)
+{
+    void *state = _PyModule_GetState(module);
+    assert(state != NULL);
+    return (sha2_state *)state;
+}
+
+static void SHA256copy(SHA256object *src, SHA256object *dest)
+{
+    dest->digestsize = src->digestsize;
+    dest->state = Hacl_Streaming_SHA2_copy_256(src->state);
+}
+
+static void SHA512copy(SHA512object *src, SHA512object *dest)
+{
+    dest->digestsize = src->digestsize;
+    dest->state = Hacl_Streaming_SHA2_copy_512(src->state);
+}
+
+static SHA256object *
+newSHA224object(sha2_state *state)
+{
+    SHA256object *sha = (SHA256object *)PyObject_GC_New(
+        SHA256object, state->sha224_type);
+    if (!sha) {
+        return NULL;
+    }
+    PyObject_GC_Track(sha);
+    return sha;
+}
+
+static SHA256object *
+newSHA256object(sha2_state *state)
+{
+    SHA256object *sha = (SHA256object *)PyObject_GC_New(
+        SHA256object, state->sha256_type);
+    if (!sha) {
+        return NULL;
+    }
+    PyObject_GC_Track(sha);
+    return sha;
+}
+
+static SHA512object *
+newSHA384object(sha2_state *state)
+{
+    SHA512object *sha = (SHA512object *)PyObject_GC_New(
+        SHA512object, state->sha384_type);
+    if (!sha) {
+        return NULL;
+    }
+    PyObject_GC_Track(sha);
+    return sha;
+}
+
+static SHA512object *
+newSHA512object(sha2_state *state)
+{
+    SHA512object *sha = (SHA512object *)PyObject_GC_New(
+        SHA512object, state->sha512_type);
+    if (!sha) {
+        return NULL;
+    }
+    PyObject_GC_Track(sha);
+    return sha;
+}
+
+/* Internal methods for our hash objects. */
+
+static int
+SHA2_traverse(PyObject *ptr, visitproc visit, void *arg)
+{
+    Py_VISIT(Py_TYPE(ptr));
+    return 0;
+}
+
+static void
+SHA256_dealloc(SHA256object *ptr)
+{
+    Hacl_Streaming_SHA2_free_256(ptr->state);
+    PyTypeObject *tp = Py_TYPE(ptr);
+    PyObject_GC_UnTrack(ptr);
+    PyObject_GC_Del(ptr);
+    Py_DECREF(tp);
+}
+
+static void
+SHA512_dealloc(SHA512object *ptr)
+{
+    Hacl_Streaming_SHA2_free_512(ptr->state);
+    PyTypeObject *tp = Py_TYPE(ptr);
+    PyObject_GC_UnTrack(ptr);
+    PyObject_GC_Del(ptr);
+    Py_DECREF(tp);
+}
+
+/* HACL* takes a uint32_t for the length of its parameter, but Py_ssize_t can be
+ * 64 bits so we loop in <4gig chunks when needed. */
+
+static void update_256(Hacl_Streaming_SHA2_state_sha2_256 *state, uint8_t *buf, Py_ssize_t len) {
+  /* Note: we explicitly ignore the error code on the basis that it would take >
+   * 1 billion years to overflow the maximum admissible length for SHA2-256
+   * (namely, 2^61-1 bytes). */
+#if PY_SSIZE_T_MAX > UINT32_MAX
+  while (len > UINT32_MAX) {
+    Hacl_Streaming_SHA2_update_256(state, buf, UINT32_MAX);
+    len -= UINT32_MAX;
+    buf += UINT32_MAX;
+  }
+#endif
+  /* Cast to uint32_t is safe: len <= UINT32_MAX at this point. */
+  Hacl_Streaming_SHA2_update_256(state, buf, (uint32_t) len);
+}
+
+static void update_512(Hacl_Streaming_SHA2_state_sha2_512 *state, uint8_t *buf, Py_ssize_t len) {
+  /* Note: we explicitly ignore the error code on the basis that it would take >
+   * 1 billion years to overflow the maximum admissible length for this API
+   * (namely, 2^64-1 bytes). */
+#if PY_SSIZE_T_MAX > UINT32_MAX
+  while (len > UINT32_MAX) {
+    Hacl_Streaming_SHA2_update_512(state, buf, UINT32_MAX);
+    len -= UINT32_MAX;
+    buf += UINT32_MAX;
+  }
+#endif
+  /* Cast to uint32_t is safe: len <= UINT32_MAX at this point. */
+  Hacl_Streaming_SHA2_update_512(state, buf, (uint32_t) len);
+}
+
+
+/* External methods for our hash objects */
+
+/*[clinic input]
+SHA256Type.copy
+
+    cls:defining_class
+
+Return a copy of the hash object.
+[clinic start generated code]*/
+
+static PyObject *
+SHA256Type_copy_impl(SHA256object *self, PyTypeObject *cls)
+/*[clinic end generated code: output=fabd515577805cd3 input=3137146fcb88e212]*/
+{
+    SHA256object *newobj;
+    sha2_state *state = PyType_GetModuleState(cls);
+    if (Py_IS_TYPE(self, state->sha256_type)) {
+        if ((newobj = newSHA256object(state)) == NULL) {
+            return NULL;
+        }
+    } else {
+        if ((newobj = newSHA224object(state)) == NULL) {
+            return NULL;
+        }
+    }
+
+    SHA256copy(self, newobj);
+    return (PyObject *)newobj;
+}
+
+/*[clinic input]
+SHA512Type.copy
+
+    cls: defining_class
+
+Return a copy of the hash object.
+[clinic start generated code]*/
+
+static PyObject *
+SHA512Type_copy_impl(SHA512object *self, PyTypeObject *cls)
+/*[clinic end generated code: output=66d2a8ef20de8302 input=f673a18f66527c90]*/
+{
+    SHA512object *newobj;
+    sha2_state *state = PyType_GetModuleState(cls);
+
+    if (Py_IS_TYPE((PyObject*)self, state->sha512_type)) {
+        if ((newobj = newSHA512object(state)) == NULL) {
+            return NULL;
+        }
+    }
+    else {
+        if ((newobj = newSHA384object(state)) == NULL) {
+            return NULL;
+        }
+    }
+
+    SHA512copy(self, newobj);
+    return (PyObject *)newobj;
+}
+
+/*[clinic input]
+SHA256Type.digest
+
+Return the digest value as a bytes object.
+[clinic start generated code]*/
+
+static PyObject *
+SHA256Type_digest_impl(SHA256object *self)
+/*[clinic end generated code: output=3a2e3997a98ee792 input=f1f4cfea5cbde35c]*/
+{
+    uint8_t digest[SHA256_DIGESTSIZE];
+    assert(self->digestsize <= SHA256_DIGESTSIZE);
+    // HACL* performs copies under the hood so that self->state remains valid
+    // after this call.
+    Hacl_Streaming_SHA2_finish_256(self->state, digest);
+    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+}
+
+/*[clinic input]
+SHA512Type.digest
+
+Return the digest value as a bytes object.
+[clinic start generated code]*/
+
+static PyObject *
+SHA512Type_digest_impl(SHA512object *self)
+/*[clinic end generated code: output=dd8c6320070458e0 input=f6470dd359071f4b]*/
+{
+    uint8_t digest[SHA512_DIGESTSIZE];
+    assert(self->digestsize <= SHA512_DIGESTSIZE);
+    // HACL* performs copies under the hood so that self->state remains valid
+    // after this call.
+    Hacl_Streaming_SHA2_finish_512(self->state, digest);
+    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
+}
+
+/*[clinic input]
+SHA256Type.hexdigest
+
+Return the digest value as a string of hexadecimal digits.
+[clinic start generated code]*/
+
+static PyObject *
+SHA256Type_hexdigest_impl(SHA256object *self)
+/*[clinic end generated code: output=96cb68996a780ab3 input=0cc4c714693010d1]*/
+{
+    uint8_t digest[SHA256_DIGESTSIZE];
+    assert(self->digestsize <= SHA256_DIGESTSIZE);
+    Hacl_Streaming_SHA2_finish_256(self->state, digest);
+    return _Py_strhex((const char *)digest, self->digestsize);
+}
+
+/*[clinic input]
+SHA512Type.hexdigest
+
+Return the digest value as a string of hexadecimal digits.
+[clinic start generated code]*/
+
+static PyObject *
+SHA512Type_hexdigest_impl(SHA512object *self)
+/*[clinic end generated code: output=cbd6f844aba1fe7c input=498b877b25cbe0a2]*/
+{
+    uint8_t digest[SHA512_DIGESTSIZE];
+    assert(self->digestsize <= SHA512_DIGESTSIZE);
+    Hacl_Streaming_SHA2_finish_512(self->state, digest);
+    return _Py_strhex((const char *)digest, self->digestsize);
+}
+
+/*[clinic input]
+SHA256Type.update
+
+    obj: object
+    /
+
+Update this hash object's state with the provided string.
+[clinic start generated code]*/
+
+static PyObject *
+SHA256Type_update(SHA256object *self, PyObject *obj)
+/*[clinic end generated code: output=1b240f965ddbd8c6 input=b2d449d5b30f0f5a]*/
+{
+    Py_buffer buf;
+
+    GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
+
+    update_256(self->state, buf.buf, buf.len);
+
+    PyBuffer_Release(&buf);
+    Py_RETURN_NONE;
+}
+
+/*[clinic input]
+SHA512Type.update
+
+    obj: object
+    /
+
+Update this hash object's state with the provided string.
+[clinic start generated code]*/
+
+static PyObject *
+SHA512Type_update(SHA512object *self, PyObject *obj)
+/*[clinic end generated code: output=745f51057a985884 input=ded2b46656566283]*/
+{
+    Py_buffer buf;
+
+    GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
+
+    update_512(self->state, buf.buf, buf.len);
+
+    PyBuffer_Release(&buf);
+    Py_RETURN_NONE;
+}
+
+static PyMethodDef SHA256_methods[] = {
+    SHA256TYPE_COPY_METHODDEF
+    SHA256TYPE_DIGEST_METHODDEF
+    SHA256TYPE_HEXDIGEST_METHODDEF
+    SHA256TYPE_UPDATE_METHODDEF
+    {NULL,        NULL}         /* sentinel */
+};
+
+static PyMethodDef SHA512_methods[] = {
+    SHA512TYPE_COPY_METHODDEF
+    SHA512TYPE_DIGEST_METHODDEF
+    SHA512TYPE_HEXDIGEST_METHODDEF
+    SHA512TYPE_UPDATE_METHODDEF
+    {NULL,        NULL}         /* sentinel */
+};
+
+static PyObject *
+SHA256_get_block_size(PyObject *self, void *closure)
+{
+    return PyLong_FromLong(SHA256_BLOCKSIZE);
+}
+
+static PyObject *
+SHA512_get_block_size(PyObject *self, void *closure)
+{
+    return PyLong_FromLong(SHA512_BLOCKSIZE);
+}
+
+static PyObject *
+SHA256_get_digest_size(SHA256object *self, void *closure)
+{
+    return PyLong_FromLong(self->digestsize);
+}
+
+static PyObject *
+SHA512_get_digest_size(SHA512object *self, void *closure)
+{
+    return PyLong_FromLong(self->digestsize);
+}
+
+static PyObject *
+SHA256_get_name(SHA256object *self, void *closure)
+{
+    if (self->digestsize == 28) {
+        return PyUnicode_FromStringAndSize("sha224", 6);
+    }
+    return PyUnicode_FromStringAndSize("sha256", 6);
+}
+
+static PyObject *
+SHA512_get_name(SHA512object *self, void *closure)
+{
+    if (self->digestsize == 64) {
+        return PyUnicode_FromStringAndSize("sha512", 6);
+    }
+    return PyUnicode_FromStringAndSize("sha384", 6);
+}
+
+static PyGetSetDef SHA256_getseters[] = {
+    {"block_size",
+     (getter)SHA256_get_block_size, NULL,
+     NULL,
+     NULL},
+    {"name",
+     (getter)SHA256_get_name, NULL,
+     NULL,
+     NULL},
+    {"digest_size",
+     (getter)SHA256_get_digest_size, NULL,
+     NULL,
+     NULL},
+    {NULL}  /* Sentinel */
+};
+
+static PyGetSetDef SHA512_getseters[] = {
+    {"block_size",
+     (getter)SHA512_get_block_size, NULL,
+     NULL,
+     NULL},
+    {"name",
+     (getter)SHA512_get_name, NULL,
+     NULL,
+     NULL},
+    {"digest_size",
+     (getter)SHA512_get_digest_size, NULL,
+     NULL,
+     NULL},
+    {NULL}  /* Sentinel */
+};
+
+static PyType_Slot sha256_types_slots[] = {
+    {Py_tp_dealloc, SHA256_dealloc},
+    {Py_tp_methods, SHA256_methods},
+    {Py_tp_getset, SHA256_getseters},
+    {Py_tp_traverse, SHA2_traverse},
+    {0,0}
+};
+
+static PyType_Slot sha512_type_slots[] = {
+    {Py_tp_dealloc, SHA512_dealloc},
+    {Py_tp_methods, SHA512_methods},
+    {Py_tp_getset, SHA512_getseters},
+    {Py_tp_traverse, SHA2_traverse},
+    {0,0}
+};
+
+// Using PyType_GetModuleState() on these types is safe since they
+// cannot be subclassed: they don't have the Py_TPFLAGS_BASETYPE flag.
+static PyType_Spec sha224_type_spec = {
+    .name = "_sha2.SHA224Type",
+    .basicsize = sizeof(SHA256object),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha256_types_slots
+};
+
+static PyType_Spec sha256_type_spec = {
+    .name = "_sha2.SHA256Type",
+    .basicsize = sizeof(SHA256object),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha256_types_slots
+};
+
+static PyType_Spec sha384_type_spec = {
+    .name = "_sha2.SHA384Type",
+    .basicsize =  sizeof(SHA512object),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha512_type_slots
+};
+
+static PyType_Spec sha512_type_spec = {
+    .name = "_sha2.SHA512Type",
+    .basicsize =  sizeof(SHA512object),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
+              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
+    .slots = sha512_type_slots
+};
+
+/* The module-level constructors. */
+
+/*[clinic input]
+_sha2.sha256
+
+    string: object(c_default="NULL") = b''
+    *
+    usedforsecurity: bool = True
+
+Return a new SHA-256 hash object; optionally initialized with a string.
+[clinic start generated code]*/
+
+static PyObject *
+_sha2_sha256_impl(PyObject *module, PyObject *string, int usedforsecurity)
+/*[clinic end generated code: output=243c9dd289931f87 input=6249da1de607280a]*/
+{
+    Py_buffer buf;
+
+    if (string) {
+        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+    }
+
+    sha2_state *state = sha2_get_state(module);
+
+    SHA256object *new;
+    if ((new = newSHA256object(state)) == NULL) {
+        if (string) {
+            PyBuffer_Release(&buf);
+        }
+        return NULL;
+    }
+
+    new->state = Hacl_Streaming_SHA2_create_in_256();
+    new->digestsize = 32;
+
+    if (PyErr_Occurred()) {
+        Py_DECREF(new);
+        if (string) {
+            PyBuffer_Release(&buf);
+        }
+        return NULL;
+    }
+    if (string) {
+        update_256(new->state, buf.buf, buf.len);
+        PyBuffer_Release(&buf);
+    }
+
+    return (PyObject *)new;
+}
+
+/*[clinic input]
+_sha2.sha224
+
+    string: object(c_default="NULL") = b''
+    *
+    usedforsecurity: bool = True
+
+Return a new SHA-224 hash object; optionally initialized with a string.
+[clinic start generated code]*/
+
+static PyObject *
+_sha2_sha224_impl(PyObject *module, PyObject *string, int usedforsecurity)
+/*[clinic end generated code: output=68191f232e4a3843 input=c42bcba47fd7d2b7]*/
+{
+    Py_buffer buf;
+    if (string) {
+        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+    }
+
+    sha2_state *state = sha2_get_state(module);
+    SHA256object *new;
+    if ((new = newSHA224object(state)) == NULL) {
+        if (string) {
+            PyBuffer_Release(&buf);
+        }
+        return NULL;
+    }
+
+    new->state = Hacl_Streaming_SHA2_create_in_224();
+    new->digestsize = 28;
+
+    if (PyErr_Occurred()) {
+        Py_DECREF(new);
+        if (string) {
+            PyBuffer_Release(&buf);
+        }
+        return NULL;
+    }
+    if (string) {
+        update_256(new->state, buf.buf, buf.len);
+        PyBuffer_Release(&buf);
+    }
+
+    return (PyObject *)new;
+}
+
+/*[clinic input]
+_sha2.sha512
+
+    string: object(c_default="NULL") = b''
+    *
+    usedforsecurity: bool = True
+
+Return a new SHA-512 hash object; optionally initialized with a string.
+[clinic start generated code]*/
+
+static PyObject *
+_sha2_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity)
+/*[clinic end generated code: output=d55c8996eca214d7 input=0576ae2a6ebfad25]*/
+{
+    SHA512object *new;
+    Py_buffer buf;
+
+    sha2_state *state = sha2_get_state(module);
+
+    if (string)
+        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+
+    if ((new = newSHA512object(state)) == NULL) {
+        if (string)
+            PyBuffer_Release(&buf);
+        return NULL;
+    }
+
+    new->state = Hacl_Streaming_SHA2_create_in_512();
+    new->digestsize = 64;
+
+    if (PyErr_Occurred()) {
+        Py_DECREF(new);
+        if (string)
+            PyBuffer_Release(&buf);
+        return NULL;
+    }
+    if (string) {
+        update_512(new->state, buf.buf, buf.len);
+        PyBuffer_Release(&buf);
+    }
+
+    return (PyObject *)new;
+}
+
+/*[clinic input]
+_sha2.sha384
+
+    string: object(c_default="NULL") = b''
+    *
+    usedforsecurity: bool = True
+
+Return a new SHA-384 hash object; optionally initialized with a string.
+[clinic start generated code]*/
+
+static PyObject *
+_sha2_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity)
+/*[clinic end generated code: output=b29a0d81d51d1368 input=4e9199d8de0d2f9b]*/
+{
+    SHA512object *new;
+    Py_buffer buf;
+
+    sha2_state *state = sha2_get_state(module);
+
+    if (string)
+        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
+
+    if ((new = newSHA384object(state)) == NULL) {
+        if (string)
+            PyBuffer_Release(&buf);
+        return NULL;
+    }
+
+    new->state = Hacl_Streaming_SHA2_create_in_384();
+    new->digestsize = 48;
+
+    if (PyErr_Occurred()) {
+        Py_DECREF(new);
+        if (string)
+            PyBuffer_Release(&buf);
+        return NULL;
+    }
+    if (string) {
+        update_512(new->state, buf.buf, buf.len);
+        PyBuffer_Release(&buf);
+    }
+
+    return (PyObject *)new;
+}
+
+/* List of functions exported by this module */
+
+static struct PyMethodDef SHA2_functions[] = {
+    _SHA2_SHA256_METHODDEF
+    _SHA2_SHA224_METHODDEF
+    _SHA2_SHA512_METHODDEF
+    _SHA2_SHA384_METHODDEF
+    {NULL,      NULL}            /* Sentinel */
+};
+
+static int
+_sha2_traverse(PyObject *module, visitproc visit, void *arg)
+{
+    sha2_state *state = sha2_get_state(module);
+    Py_VISIT(state->sha224_type);
+    Py_VISIT(state->sha256_type);
+    Py_VISIT(state->sha384_type);
+    Py_VISIT(state->sha512_type);
+    return 0;
+}
+
+static int
+_sha2_clear(PyObject *module)
+{
+    sha2_state *state = sha2_get_state(module);
+    Py_CLEAR(state->sha224_type);
+    Py_CLEAR(state->sha256_type);
+    Py_CLEAR(state->sha384_type);
+    Py_CLEAR(state->sha512_type);
+    return 0;
+}
+
+static void
+_sha2_free(void *module)
+{
+    _sha2_clear((PyObject *)module);
+}
+
+/* Initialize this module. */
+static int sha2_exec(PyObject *module)
+{
+    sha2_state *state = sha2_get_state(module);
+
+    state->sha224_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha224_type_spec, NULL);
+    if (state->sha224_type == NULL) {
+        return -1;
+    }
+    state->sha256_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha256_type_spec, NULL);
+    if (state->sha256_type == NULL) {
+        return -1;
+    }
+    state->sha384_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha384_type_spec, NULL);
+    if (state->sha384_type == NULL) {
+        return -1;
+    }
+    state->sha512_type = (PyTypeObject *)PyType_FromModuleAndSpec(
+        module, &sha512_type_spec, NULL);
+    if (state->sha512_type == NULL) {
+        return -1;
+    }
+
+    if (PyModule_AddType(module, state->sha224_type) < 0) {
+        return -1;
+    }
+    if (PyModule_AddType(module, state->sha256_type) < 0) {
+        return -1;
+    }
+    if (PyModule_AddType(module, state->sha384_type) < 0) {
+        return -1;
+    }
+    if (PyModule_AddType(module, state->sha512_type) < 0) {
+        return -1;
+    }
+
+    return 0;
+}
+
+static PyModuleDef_Slot _sha2_slots[] = {
+    {Py_mod_exec, sha2_exec},
+    {0, NULL}
+};
+
+static struct PyModuleDef _sha2module = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "_sha2",
+    .m_size = sizeof(sha2_state),
+    .m_methods = SHA2_functions,
+    .m_slots = _sha2_slots,
+    .m_traverse = _sha2_traverse,
+    .m_clear = _sha2_clear,
+    .m_free = _sha2_free
+};
+
+PyMODINIT_FUNC
+PyInit__sha2(void)
+{
+    return PyModuleDef_Init(&_sha2module);
+}
diff --git a/Modules/sha512module.c b/Modules/sha512module.c
deleted file mode 100644
index d7dfed4..0000000
--- a/Modules/sha512module.c
+++ /dev/null
@@ -1,456 +0,0 @@
-/* SHA512 module */
-
-/* This module provides an interface to NIST's SHA-512 and SHA-384 Algorithms */
-
-/* See below for information about the original code this module was
-   based upon. Additional work performed by:
-
-   Andrew Kuchling (amk@amk.ca)
-   Greg Stein (gstein@lyra.org)
-   Trevor Perrin (trevp@trevp.net)
-   Jonathan Protzenko (jonathan@protzenko.fr)
-
-   Copyright (C) 2005-2007   Gregory P. Smith (greg@krypto.org)
-   Licensed to PSF under a Contributor Agreement.
-
-*/
-
-/* SHA objects */
-#ifndef Py_BUILD_CORE_BUILTIN
-#  define Py_BUILD_CORE_MODULE 1
-#endif
-
-#include "Python.h"
-#include "pycore_bitutils.h"      // _Py_bswap64()
-#include "pycore_strhex.h"        // _Py_strhex()
-#include "structmember.h"         // PyMemberDef
-#include "hashlib.h"
-
-/*[clinic input]
-module _sha512
-class SHA512Type "SHAobject *" "&PyType_Type"
-[clinic start generated code]*/
-/*[clinic end generated code: output=da39a3ee5e6b4b0d input=81a3ccde92bcfe8d]*/
-
-
-/* The SHA block size and message digest sizes, in bytes */
-
-#define SHA_BLOCKSIZE   128
-#define SHA_DIGESTSIZE  64
-
-/* The SHA2-384 and SHA2-512 implementations defer to the HACL* verified
- * library. */
-
-#include "_hacl/Hacl_Streaming_SHA2.h"
-
-typedef struct {
-    PyObject_HEAD
-    int digestsize;
-    Hacl_Streaming_SHA2_state_sha2_512 *state;
-} SHAobject;
-
-#include "clinic/sha512module.c.h"
-
-
-static void SHAcopy(SHAobject *src, SHAobject *dest)
-{
-    dest->digestsize = src->digestsize;
-    dest->state = Hacl_Streaming_SHA2_copy_512(src->state);
-}
-
-typedef struct {
-    PyTypeObject* sha384_type;
-    PyTypeObject* sha512_type;
-} SHA512State;
-
-static inline SHA512State*
-sha512_get_state(PyObject *module)
-{
-    void *state = PyModule_GetState(module);
-    assert(state != NULL);
-    return (SHA512State *)state;
-}
-
-static SHAobject *
-newSHA384object(SHA512State *st)
-{
-    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject, st->sha384_type);
-    PyObject_GC_Track(sha);
-    return sha;
-}
-
-static SHAobject *
-newSHA512object(SHA512State *st)
-{
-    SHAobject *sha = (SHAobject *)PyObject_GC_New(SHAobject, st->sha512_type);
-    PyObject_GC_Track(sha);
-    return sha;
-}
-
-/* Internal methods for a hash object */
-static int
-SHA_traverse(PyObject *ptr, visitproc visit, void *arg)
-{
-    Py_VISIT(Py_TYPE(ptr));
-    return 0;
-}
-
-static void
-SHA512_dealloc(SHAobject *ptr)
-{
-    Hacl_Streaming_SHA2_free_512(ptr->state);
-    PyTypeObject *tp = Py_TYPE(ptr);
-    PyObject_GC_UnTrack(ptr);
-    PyObject_GC_Del(ptr);
-    Py_DECREF(tp);
-}
-
-/* HACL* takes a uint32_t for the length of its parameter, but Py_ssize_t can be
- * 64 bits. */
-static void update_512(Hacl_Streaming_SHA2_state_sha2_512 *state, uint8_t *buf, Py_ssize_t len) {
-  /* Note: we explicitly ignore the error code on the basis that it would take >
-   * 1 billion years to overflow the maximum admissible length for this API
-   * (namely, 2^64-1 bytes). */
-  while (len > UINT32_MAX) {
-    Hacl_Streaming_SHA2_update_512(state, buf, UINT32_MAX);
-    len -= UINT32_MAX;
-    buf += UINT32_MAX;
-  }
-  /* Cast to uint32_t is safe: upon exiting the loop, len <= UINT32_MAX, and
-   * therefore fits in a uint32_t */
-  Hacl_Streaming_SHA2_update_512(state, buf, (uint32_t) len);
-}
-
-
-/* External methods for a hash object */
-
-/*[clinic input]
-SHA512Type.copy
-
-    cls: defining_class
-
-Return a copy of the hash object.
-[clinic start generated code]*/
-
-static PyObject *
-SHA512Type_copy_impl(SHAobject *self, PyTypeObject *cls)
-/*[clinic end generated code: output=85ea5b47837a08e6 input=f673a18f66527c90]*/
-{
-    SHAobject *newobj;
-    SHA512State *st = PyType_GetModuleState(cls);
-
-    if (Py_IS_TYPE((PyObject*)self, st->sha512_type)) {
-        if ( (newobj = newSHA512object(st))==NULL) {
-            return NULL;
-        }
-    }
-    else {
-        if ( (newobj = newSHA384object(st))==NULL) {
-            return NULL;
-        }
-    }
-
-    SHAcopy(self, newobj);
-    return (PyObject *)newobj;
-}
-
-/*[clinic input]
-SHA512Type.digest
-
-Return the digest value as a bytes object.
-[clinic start generated code]*/
-
-static PyObject *
-SHA512Type_digest_impl(SHAobject *self)
-/*[clinic end generated code: output=1080bbeeef7dde1b input=f6470dd359071f4b]*/
-{
-    uint8_t digest[SHA_DIGESTSIZE];
-    // HACL performs copies under the hood so that self->state remains valid
-    // after this call.
-    Hacl_Streaming_SHA2_finish_512(self->state, digest);
-    return PyBytes_FromStringAndSize((const char *)digest, self->digestsize);
-}
-
-/*[clinic input]
-SHA512Type.hexdigest
-
-Return the digest value as a string of hexadecimal digits.
-[clinic start generated code]*/
-
-static PyObject *
-SHA512Type_hexdigest_impl(SHAobject *self)
-/*[clinic end generated code: output=7373305b8601e18b input=498b877b25cbe0a2]*/
-{
-    uint8_t digest[SHA_DIGESTSIZE];
-    Hacl_Streaming_SHA2_finish_512(self->state, digest);
-    return _Py_strhex((const char *)digest, self->digestsize);
-}
-
-/*[clinic input]
-SHA512Type.update
-
-    obj: object
-    /
-
-Update this hash object's state with the provided string.
-[clinic start generated code]*/
-
-static PyObject *
-SHA512Type_update(SHAobject *self, PyObject *obj)
-/*[clinic end generated code: output=1cf333e73995a79e input=ded2b46656566283]*/
-{
-    Py_buffer buf;
-
-    GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);
-
-    update_512(self->state, buf.buf, buf.len);
-
-    PyBuffer_Release(&buf);
-    Py_RETURN_NONE;
-}
-
-static PyMethodDef SHA_methods[] = {
-    SHA512TYPE_COPY_METHODDEF
-    SHA512TYPE_DIGEST_METHODDEF
-    SHA512TYPE_HEXDIGEST_METHODDEF
-    SHA512TYPE_UPDATE_METHODDEF
-    {NULL,        NULL}         /* sentinel */
-};
-
-static PyObject *
-SHA512_get_block_size(PyObject *self, void *closure)
-{
-    return PyLong_FromLong(SHA_BLOCKSIZE);
-}
-
-static PyObject *
-SHA512_get_name(PyObject *self, void *closure)
-{
-    if (((SHAobject *)self)->digestsize == 64)
-        return PyUnicode_FromStringAndSize("sha512", 6);
-    else
-        return PyUnicode_FromStringAndSize("sha384", 6);
-}
-
-static PyGetSetDef SHA_getseters[] = {
-    {"block_size",
-     (getter)SHA512_get_block_size, NULL,
-     NULL,
-     NULL},
-    {"name",
-     (getter)SHA512_get_name, NULL,
-     NULL,
-     NULL},
-    {NULL}  /* Sentinel */
-};
-
-static PyMemberDef SHA_members[] = {
-    {"digest_size", T_INT, offsetof(SHAobject, digestsize), READONLY, NULL},
-    {NULL}  /* Sentinel */
-};
-
-static PyType_Slot sha512_sha384_type_slots[] = {
-    {Py_tp_dealloc, SHA512_dealloc},
-    {Py_tp_methods, SHA_methods},
-    {Py_tp_members, SHA_members},
-    {Py_tp_getset, SHA_getseters},
-    {Py_tp_traverse, SHA_traverse},
-    {0,0}
-};
-
-static PyType_Spec sha512_sha384_type_spec = {
-    .name = "_sha512.sha384",
-    .basicsize =  sizeof(SHAobject),
-    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
-              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
-    .slots = sha512_sha384_type_slots
-};
-
-// Using PyType_GetModuleState() on this type is safe since
-// it cannot be subclassed: it does not have the Py_TPFLAGS_BASETYPE flag.
-static PyType_Spec sha512_sha512_type_spec = {
-    .name = "_sha512.sha512",
-    .basicsize =  sizeof(SHAobject),
-    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
-              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
-    .slots = sha512_sha384_type_slots
-};
-
-/* The single module-level function: new() */
-
-/*[clinic input]
-_sha512.sha512
-
-    string: object(c_default="NULL") = b''
-    *
-    usedforsecurity: bool = True
-
-Return a new SHA-512 hash object; optionally initialized with a string.
-[clinic start generated code]*/
-
-static PyObject *
-_sha512_sha512_impl(PyObject *module, PyObject *string, int usedforsecurity)
-/*[clinic end generated code: output=a8d9e5f9e6a0831c input=23b4daebc2ebb9c9]*/
-{
-    SHAobject *new;
-    Py_buffer buf;
-
-    SHA512State *st = sha512_get_state(module);
-
-    if (string)
-        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
-
-    if ((new = newSHA512object(st)) == NULL) {
-        if (string)
-            PyBuffer_Release(&buf);
-        return NULL;
-    }
-
-    new->state = Hacl_Streaming_SHA2_create_in_512();
-    new->digestsize = 64;
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(new);
-        if (string)
-            PyBuffer_Release(&buf);
-        return NULL;
-    }
-    if (string) {
-        update_512(new->state, buf.buf, buf.len);
-        PyBuffer_Release(&buf);
-    }
-
-    return (PyObject *)new;
-}
-
-/*[clinic input]
-_sha512.sha384
-
-    string: object(c_default="NULL") = b''
-    *
-    usedforsecurity: bool = True
-
-Return a new SHA-384 hash object; optionally initialized with a string.
-[clinic start generated code]*/
-
-static PyObject *
-_sha512_sha384_impl(PyObject *module, PyObject *string, int usedforsecurity)
-/*[clinic end generated code: output=da7d594a08027ac3 input=59ef72f039a6b431]*/
-{
-    SHAobject *new;
-    Py_buffer buf;
-
-    SHA512State *st = sha512_get_state(module);
-
-    if (string)
-        GET_BUFFER_VIEW_OR_ERROUT(string, &buf);
-
-    if ((new = newSHA384object(st)) == NULL) {
-        if (string)
-            PyBuffer_Release(&buf);
-        return NULL;
-    }
-
-    new->state = Hacl_Streaming_SHA2_create_in_384();
-    new->digestsize = 48;
-
-    if (PyErr_Occurred()) {
-        Py_DECREF(new);
-        if (string)
-            PyBuffer_Release(&buf);
-        return NULL;
-    }
-    if (string) {
-        update_512(new->state, buf.buf, buf.len);
-        PyBuffer_Release(&buf);
-    }
-
-    return (PyObject *)new;
-}
-
-
-/* List of functions exported by this module */
-
-static struct PyMethodDef SHA_functions[] = {
-    _SHA512_SHA512_METHODDEF
-    _SHA512_SHA384_METHODDEF
-    {NULL,      NULL}            /* Sentinel */
-};
-
-static int
-_sha512_traverse(PyObject *module, visitproc visit, void *arg)
-{
-    SHA512State *state = sha512_get_state(module);
-    Py_VISIT(state->sha384_type);
-    Py_VISIT(state->sha512_type);
-    return 0;
-}
-
-static int
-_sha512_clear(PyObject *module)
-{
-    SHA512State *state = sha512_get_state(module);
-    Py_CLEAR(state->sha384_type);
-    Py_CLEAR(state->sha512_type);
-    return 0;
-}
-
-static void
-_sha512_free(void *module)
-{
-    _sha512_clear((PyObject *)module);
-}
-
-
-/* Initialize this module. */
-static int
-_sha512_exec(PyObject *m)
-{
-    SHA512State* st = sha512_get_state(m);
-
-    st->sha384_type = (PyTypeObject *)PyType_FromModuleAndSpec(
-        m, &sha512_sha384_type_spec, NULL);
-
-    st->sha512_type = (PyTypeObject *)PyType_FromModuleAndSpec(
-        m, &sha512_sha512_type_spec, NULL);
-
-    if (st->sha384_type == NULL || st->sha512_type == NULL) {
-        return -1;
-    }
-
-    Py_INCREF(st->sha384_type);
-    if (PyModule_AddObject(m, "SHA384Type", (PyObject *)st->sha384_type) < 0) {
-        Py_DECREF(st->sha384_type);
-        return -1;
-    }
-
-    Py_INCREF(st->sha512_type);
-    if (PyModule_AddObject(m, "SHA384Type", (PyObject *)st->sha512_type) < 0) {
-        Py_DECREF(st->sha512_type);
-        return -1;
-    }
-
-    return 0;
-}
-
-static PyModuleDef_Slot _sha512_slots[] = {
-    {Py_mod_exec, _sha512_exec},
-    {0, NULL}
-};
-
-static struct PyModuleDef _sha512module = {
-        PyModuleDef_HEAD_INIT,
-        .m_name = "_sha512",
-        .m_size = sizeof(SHA512State),
-        .m_methods = SHA_functions,
-        .m_slots = _sha512_slots,
-        .m_traverse = _sha512_traverse,
-        .m_clear = _sha512_clear,
-        .m_free = _sha512_free
-};
-
-PyMODINIT_FUNC
-PyInit__sha512(void)
-{
-    return PyModuleDef_Init(&_sha512module);
-}