diff --git a/Modules/clinic/sha2module.c.h b/Modules/clinic/sha2module.c.h index 07be91e4f6c68f..4169a759290956 100644 --- a/Modules/clinic/sha2module.c.h +++ b/Modules/clinic/sha2module.c.h @@ -8,181 +8,273 @@ preserve #endif #include "pycore_modsupport.h" // _PyArg_UnpackKeywords() -PyDoc_STRVAR(SHA256Type_copy__doc__, +PyDoc_STRVAR(_sha2_sha224_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__}, +#define _SHA2_SHA224_COPY_METHODDEF \ + {"copy", (PyCFunction)_sha2_sha224_copy, METH_NOARGS, _sha2_sha224_copy__doc__}, static PyObject * -SHA256Type_copy_impl(SHA256object *self, PyTypeObject *cls); +_sha2_sha224_copy_impl(SHA2N_O(224) *self); static PyObject * -SHA256Type_copy(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_sha2_sha224_copy(PyObject *self, PyObject *Py_UNUSED(ignored)) { - if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) { - PyErr_SetString(PyExc_TypeError, "copy() takes no arguments"); - return NULL; - } - return SHA256Type_copy_impl((SHA256object *)self, cls); + return _sha2_sha224_copy_impl((SHA2N_O(224) *)self); } -PyDoc_STRVAR(SHA512Type_copy__doc__, +PyDoc_STRVAR(_sha2_sha256_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__}, +#define _SHA2_SHA256_COPY_METHODDEF \ + {"copy", (PyCFunction)_sha2_sha256_copy, METH_NOARGS, _sha2_sha256_copy__doc__}, static PyObject * -SHA512Type_copy_impl(SHA512object *self, PyTypeObject *cls); +_sha2_sha256_copy_impl(SHA2N_O(256) *self); static PyObject * -SHA512Type_copy(PyObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_sha2_sha256_copy(PyObject *self, PyObject *Py_UNUSED(ignored)) { - if (nargs || (kwnames && PyTuple_GET_SIZE(kwnames))) { - PyErr_SetString(PyExc_TypeError, "copy() takes no arguments"); - return NULL; - } - return SHA512Type_copy_impl((SHA512object *)self, cls); + return _sha2_sha256_copy_impl((SHA2N_O(256) *)self); +} + +PyDoc_STRVAR(_sha2_sha384_copy__doc__, +"copy($self, /)\n" +"--\n" +"\n" +"Return a copy of the hash object."); + +#define _SHA2_SHA384_COPY_METHODDEF \ + {"copy", (PyCFunction)_sha2_sha384_copy, METH_NOARGS, _sha2_sha384_copy__doc__}, + +static PyObject * +_sha2_sha384_copy_impl(SHA2N_O(384) *self); + +static PyObject * +_sha2_sha384_copy(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ + return _sha2_sha384_copy_impl((SHA2N_O(384) *)self); +} + +PyDoc_STRVAR(_sha2_sha512_copy__doc__, +"copy($self, /)\n" +"--\n" +"\n" +"Return a copy of the hash object."); + +#define _SHA2_SHA512_COPY_METHODDEF \ + {"copy", (PyCFunction)_sha2_sha512_copy, METH_NOARGS, _sha2_sha512_copy__doc__}, + +static PyObject * +_sha2_sha512_copy_impl(SHA2N_O(512) *self); + +static PyObject * +_sha2_sha512_copy(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ + return _sha2_sha512_copy_impl((SHA2N_O(512) *)self); +} + +PyDoc_STRVAR(_sha2_sha224_update__doc__, +"update($self, data, /)\n" +"--\n" +"\n" +"Update this hash object\'s state with the provided string."); + +#define _SHA2_SHA224_UPDATE_METHODDEF \ + {"update", (PyCFunction)_sha2_sha224_update, METH_O, _sha2_sha224_update__doc__}, + +PyDoc_STRVAR(_sha2_sha256_update__doc__, +"update($self, data, /)\n" +"--\n" +"\n" +"Update this hash object\'s state with the provided string."); + +#define _SHA2_SHA256_UPDATE_METHODDEF \ + {"update", (PyCFunction)_sha2_sha256_update, METH_O, _sha2_sha256_update__doc__}, + +PyDoc_STRVAR(_sha2_sha384_update__doc__, +"update($self, data, /)\n" +"--\n" +"\n" +"Update this hash object\'s state with the provided string."); + +#define _SHA2_SHA384_UPDATE_METHODDEF \ + {"update", (PyCFunction)_sha2_sha384_update, METH_O, _sha2_sha384_update__doc__}, + +PyDoc_STRVAR(_sha2_sha512_update__doc__, +"update($self, data, /)\n" +"--\n" +"\n" +"Update this hash object\'s state with the provided string."); + +#define _SHA2_SHA512_UPDATE_METHODDEF \ + {"update", (PyCFunction)_sha2_sha512_update, METH_O, _sha2_sha512_update__doc__}, + +PyDoc_STRVAR(_sha2_sha224_digest__doc__, +"digest($self, /)\n" +"--\n" +"\n" +"Return the digest value as a bytes object."); + +#define _SHA2_SHA224_DIGEST_METHODDEF \ + {"digest", (PyCFunction)_sha2_sha224_digest, METH_NOARGS, _sha2_sha224_digest__doc__}, + +static PyObject * +_sha2_sha224_digest_impl(SHA2N_O(224) *self); + +static PyObject * +_sha2_sha224_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ + return _sha2_sha224_digest_impl((SHA2N_O(224) *)self); } -PyDoc_STRVAR(SHA256Type_digest__doc__, +PyDoc_STRVAR(_sha2_sha256_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__}, +#define _SHA2_SHA256_DIGEST_METHODDEF \ + {"digest", (PyCFunction)_sha2_sha256_digest, METH_NOARGS, _sha2_sha256_digest__doc__}, static PyObject * -SHA256Type_digest_impl(SHA256object *self); +_sha2_sha256_digest_impl(SHA2N_O(256) *self); static PyObject * -SHA256Type_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) +_sha2_sha256_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - return SHA256Type_digest_impl((SHA256object *)self); + return _sha2_sha256_digest_impl((SHA2N_O(256) *)self); } -PyDoc_STRVAR(SHA512Type_digest__doc__, +PyDoc_STRVAR(_sha2_sha384_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__}, +#define _SHA2_SHA384_DIGEST_METHODDEF \ + {"digest", (PyCFunction)_sha2_sha384_digest, METH_NOARGS, _sha2_sha384_digest__doc__}, static PyObject * -SHA512Type_digest_impl(SHA512object *self); +_sha2_sha384_digest_impl(SHA2N_O(384) *self); static PyObject * -SHA512Type_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) +_sha2_sha384_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - return SHA512Type_digest_impl((SHA512object *)self); + return _sha2_sha384_digest_impl((SHA2N_O(384) *)self); } -PyDoc_STRVAR(SHA256Type_hexdigest__doc__, -"hexdigest($self, /)\n" +PyDoc_STRVAR(_sha2_sha512_digest__doc__, +"digest($self, /)\n" "--\n" "\n" -"Return the digest value as a string of hexadecimal digits."); +"Return the digest value as a bytes object."); -#define SHA256TYPE_HEXDIGEST_METHODDEF \ - {"hexdigest", (PyCFunction)SHA256Type_hexdigest, METH_NOARGS, SHA256Type_hexdigest__doc__}, +#define _SHA2_SHA512_DIGEST_METHODDEF \ + {"digest", (PyCFunction)_sha2_sha512_digest, METH_NOARGS, _sha2_sha512_digest__doc__}, static PyObject * -SHA256Type_hexdigest_impl(SHA256object *self); +_sha2_sha512_digest_impl(SHA2N_O(512) *self); static PyObject * -SHA256Type_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) +_sha2_sha512_digest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - return SHA256Type_hexdigest_impl((SHA256object *)self); + return _sha2_sha512_digest_impl((SHA2N_O(512) *)self); } -PyDoc_STRVAR(SHA512Type_hexdigest__doc__, +PyDoc_STRVAR(_sha2_sha224_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__}, +#define _SHA2_SHA224_HEXDIGEST_METHODDEF \ + {"hexdigest", (PyCFunction)_sha2_sha224_hexdigest, METH_NOARGS, _sha2_sha224_hexdigest__doc__}, static PyObject * -SHA512Type_hexdigest_impl(SHA512object *self); +_sha2_sha224_hexdigest_impl(SHA2N_O(224) *self); static PyObject * -SHA512Type_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) +_sha2_sha224_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - return SHA512Type_hexdigest_impl((SHA512object *)self); + return _sha2_sha224_hexdigest_impl((SHA2N_O(224) *)self); } -PyDoc_STRVAR(SHA256Type_update__doc__, -"update($self, obj, /)\n" +PyDoc_STRVAR(_sha2_sha256_hexdigest__doc__, +"hexdigest($self, /)\n" "--\n" "\n" -"Update this hash object\'s state with the provided string."); +"Return the digest value as a string of hexadecimal digits."); -#define SHA256TYPE_UPDATE_METHODDEF \ - {"update", (PyCFunction)SHA256Type_update, METH_O, SHA256Type_update__doc__}, +#define _SHA2_SHA256_HEXDIGEST_METHODDEF \ + {"hexdigest", (PyCFunction)_sha2_sha256_hexdigest, METH_NOARGS, _sha2_sha256_hexdigest__doc__}, static PyObject * -SHA256Type_update_impl(SHA256object *self, PyObject *obj); +_sha2_sha256_hexdigest_impl(SHA2N_O(256) *self); static PyObject * -SHA256Type_update(PyObject *self, PyObject *obj) +_sha2_sha256_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - PyObject *return_value = NULL; - - return_value = SHA256Type_update_impl((SHA256object *)self, obj); - - return return_value; + return _sha2_sha256_hexdigest_impl((SHA2N_O(256) *)self); } -PyDoc_STRVAR(SHA512Type_update__doc__, -"update($self, obj, /)\n" +PyDoc_STRVAR(_sha2_sha384_hexdigest__doc__, +"hexdigest($self, /)\n" "--\n" "\n" -"Update this hash object\'s state with the provided string."); +"Return the digest value as a string of hexadecimal digits."); -#define SHA512TYPE_UPDATE_METHODDEF \ - {"update", (PyCFunction)SHA512Type_update, METH_O, SHA512Type_update__doc__}, +#define _SHA2_SHA384_HEXDIGEST_METHODDEF \ + {"hexdigest", (PyCFunction)_sha2_sha384_hexdigest, METH_NOARGS, _sha2_sha384_hexdigest__doc__}, static PyObject * -SHA512Type_update_impl(SHA512object *self, PyObject *obj); +_sha2_sha384_hexdigest_impl(SHA2N_O(384) *self); static PyObject * -SHA512Type_update(PyObject *self, PyObject *obj) +_sha2_sha384_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) { - PyObject *return_value = NULL; + return _sha2_sha384_hexdigest_impl((SHA2N_O(384) *)self); +} - return_value = SHA512Type_update_impl((SHA512object *)self, obj); +PyDoc_STRVAR(_sha2_sha512_hexdigest__doc__, +"hexdigest($self, /)\n" +"--\n" +"\n" +"Return the digest value as a string of hexadecimal digits."); - return return_value; +#define _SHA2_SHA512_HEXDIGEST_METHODDEF \ + {"hexdigest", (PyCFunction)_sha2_sha512_hexdigest, METH_NOARGS, _sha2_sha512_hexdigest__doc__}, + +static PyObject * +_sha2_sha512_hexdigest_impl(SHA2N_O(512) *self); + +static PyObject * +_sha2_sha512_hexdigest(PyObject *self, PyObject *Py_UNUSED(ignored)) +{ + return _sha2_sha512_hexdigest_impl((SHA2N_O(512) *)self); } -PyDoc_STRVAR(_sha2_sha256__doc__, -"sha256($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" +PyDoc_STRVAR(_sha2_sha224__doc__, +"sha224($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" "--\n" "\n" -"Return a new SHA-256 hash object; optionally initialized with a string."); +"Return a new SHA-224 hash object; optionally initialized with a string."); -#define _SHA2_SHA256_METHODDEF \ - {"sha256", _PyCFunction_CAST(_sha2_sha256), METH_FASTCALL|METH_KEYWORDS, _sha2_sha256__doc__}, +#define _SHA2_SHA224_METHODDEF \ + {"sha224", _PyCFunction_CAST(_sha2_sha224), METH_FASTCALL|METH_KEYWORDS, _sha2_sha224__doc__}, static PyObject * -_sha2_sha256_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj); +_sha2_sha224_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string); static PyObject * -_sha2_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_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) @@ -208,7 +300,7 @@ _sha2_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject static const char * const _keywords[] = {"data", "usedforsecurity", "string", NULL}; static _PyArg_Parser _parser = { .keywords = _keywords, - .fname = "sha256", + .fname = "sha224", .kwtuple = KWTUPLE, }; #undef KWTUPLE @@ -216,7 +308,7 @@ _sha2_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; PyObject *data = NULL; int usedforsecurity = 1; - PyObject *string_obj = NULL; + PyObject *string = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf); @@ -245,29 +337,29 @@ _sha2_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject goto skip_optional_kwonly; } } - string_obj = args[2]; + string = args[2]; skip_optional_kwonly: - return_value = _sha2_sha256_impl(module, data, usedforsecurity, string_obj); + return_value = _sha2_sha224_impl(module, data, usedforsecurity, string); exit: return return_value; } -PyDoc_STRVAR(_sha2_sha224__doc__, -"sha224($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" +PyDoc_STRVAR(_sha2_sha256__doc__, +"sha256($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" "--\n" "\n" -"Return a new SHA-224 hash object; optionally initialized with a string."); +"Return a new SHA-256 hash object; optionally initialized with a string."); -#define _SHA2_SHA224_METHODDEF \ - {"sha224", _PyCFunction_CAST(_sha2_sha224), METH_FASTCALL|METH_KEYWORDS, _sha2_sha224__doc__}, +#define _SHA2_SHA256_METHODDEF \ + {"sha256", _PyCFunction_CAST(_sha2_sha256), METH_FASTCALL|METH_KEYWORDS, _sha2_sha256__doc__}, static PyObject * -_sha2_sha224_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj); +_sha2_sha256_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string); static PyObject * -_sha2_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_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) @@ -293,7 +385,7 @@ _sha2_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject static const char * const _keywords[] = {"data", "usedforsecurity", "string", NULL}; static _PyArg_Parser _parser = { .keywords = _keywords, - .fname = "sha224", + .fname = "sha256", .kwtuple = KWTUPLE, }; #undef KWTUPLE @@ -301,7 +393,7 @@ _sha2_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; PyObject *data = NULL; int usedforsecurity = 1; - PyObject *string_obj = NULL; + PyObject *string = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf); @@ -330,29 +422,29 @@ _sha2_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject goto skip_optional_kwonly; } } - string_obj = args[2]; + string = args[2]; skip_optional_kwonly: - return_value = _sha2_sha224_impl(module, data, usedforsecurity, string_obj); + return_value = _sha2_sha256_impl(module, data, usedforsecurity, string); exit: return return_value; } -PyDoc_STRVAR(_sha2_sha512__doc__, -"sha512($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" +PyDoc_STRVAR(_sha2_sha384__doc__, +"sha384($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" "--\n" "\n" -"Return a new SHA-512 hash object; optionally initialized with a string."); +"Return a new SHA-384 hash object; optionally initialized with a string."); -#define _SHA2_SHA512_METHODDEF \ - {"sha512", _PyCFunction_CAST(_sha2_sha512), METH_FASTCALL|METH_KEYWORDS, _sha2_sha512__doc__}, +#define _SHA2_SHA384_METHODDEF \ + {"sha384", _PyCFunction_CAST(_sha2_sha384), METH_FASTCALL|METH_KEYWORDS, _sha2_sha384__doc__}, static PyObject * -_sha2_sha512_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj); +_sha2_sha384_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string); static PyObject * -_sha2_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_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) @@ -378,7 +470,7 @@ _sha2_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject static const char * const _keywords[] = {"data", "usedforsecurity", "string", NULL}; static _PyArg_Parser _parser = { .keywords = _keywords, - .fname = "sha512", + .fname = "sha384", .kwtuple = KWTUPLE, }; #undef KWTUPLE @@ -386,7 +478,7 @@ _sha2_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; PyObject *data = NULL; int usedforsecurity = 1; - PyObject *string_obj = NULL; + PyObject *string = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf); @@ -415,29 +507,29 @@ _sha2_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject goto skip_optional_kwonly; } } - string_obj = args[2]; + string = args[2]; skip_optional_kwonly: - return_value = _sha2_sha512_impl(module, data, usedforsecurity, string_obj); + return_value = _sha2_sha384_impl(module, data, usedforsecurity, string); exit: return return_value; } -PyDoc_STRVAR(_sha2_sha384__doc__, -"sha384($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" +PyDoc_STRVAR(_sha2_sha512__doc__, +"sha512($module, /, data=b\'\', *, usedforsecurity=True, string=None)\n" "--\n" "\n" -"Return a new SHA-384 hash object; optionally initialized with a string."); +"Return a new SHA-512 hash object; optionally initialized with a string."); -#define _SHA2_SHA384_METHODDEF \ - {"sha384", _PyCFunction_CAST(_sha2_sha384), METH_FASTCALL|METH_KEYWORDS, _sha2_sha384__doc__}, +#define _SHA2_SHA512_METHODDEF \ + {"sha512", _PyCFunction_CAST(_sha2_sha512), METH_FASTCALL|METH_KEYWORDS, _sha2_sha512__doc__}, static PyObject * -_sha2_sha384_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj); +_sha2_sha512_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string); static PyObject * -_sha2_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) +_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) @@ -463,7 +555,7 @@ _sha2_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject static const char * const _keywords[] = {"data", "usedforsecurity", "string", NULL}; static _PyArg_Parser _parser = { .keywords = _keywords, - .fname = "sha384", + .fname = "sha512", .kwtuple = KWTUPLE, }; #undef KWTUPLE @@ -471,7 +563,7 @@ _sha2_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0; PyObject *data = NULL; int usedforsecurity = 1; - PyObject *string_obj = NULL; + PyObject *string = NULL; args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, /*minpos*/ 0, /*maxpos*/ 1, /*minkw*/ 0, /*varpos*/ 0, argsbuf); @@ -500,11 +592,11 @@ _sha2_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject goto skip_optional_kwonly; } } - string_obj = args[2]; + string = args[2]; skip_optional_kwonly: - return_value = _sha2_sha384_impl(module, data, usedforsecurity, string_obj); + return_value = _sha2_sha512_impl(module, data, usedforsecurity, string); exit: return return_value; } -/*[clinic end generated code: output=90625b237c774a9f input=a9049054013a1b77]*/ +/*[clinic end generated code: output=c44fd7727002844e input=a9049054013a1b77]*/ diff --git a/Modules/sha2module.c b/Modules/sha2module.c index 6643b7e6b02654..46f8f8eaa929e4 100644 --- a/Modules/sha2module.c +++ b/Modules/sha2module.c @@ -9,6 +9,7 @@ Greg Stein (gstein@lyra.org) Trevor Perrin (trevp@trevp.net) Jonathan Protzenko (jonathan@protzenko.fr) + Bénédikt Tran (10796600+picnixz@users.noreply.github.com) Copyright (C) 2005-2007 Gregory P. Smith (greg@krypto.org) Licensed to PSF under a Contributor Agreement. @@ -21,797 +22,657 @@ #endif #include "Python.h" -#include "pycore_bitutils.h" // _Py_bswap32() -#include "pycore_moduleobject.h" // _PyModule_GetState() -#include "pycore_typeobject.h" // _PyType_GetModuleState() -#include "pycore_strhex.h" // _Py_strhex() +#include "pycore_moduleobject.h" // _PyModule_GetState() +#include "pycore_strhex.h" // _Py_strhex() +#include "pycore_typeobject.h" // _PyType_GetModuleState() #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]*/ +#include "_hacl/Hacl_Hash_SHA2.h" +/* + * Call a macro with all SHA-2 known digest sizes. + * + * The macro MACRO takes as input a SHA-2 digest size + * and produces *syntactally correct* code. + */ +#define SHA2_EXPAND_MACRO(MACRO) \ + MACRO(224); \ + MACRO(256); \ + MACRO(384); \ + MACRO(512); -/* The SHA block sizes and maximum message digest sizes, in bytes */ +/* The name of an HACL* SHA-2 routine. */ +#define HACL_HASH_SHA2_(N, NAME) Hacl_Hash_SHA2_ ## NAME ## _ ## N -#define SHA256_BLOCKSIZE 64 -#define SHA256_DIGESTSIZE 32 -#define SHA512_BLOCKSIZE 128 -#define SHA512_DIGESTSIZE 64 +/* The state attribute name holding the corresponding (PyTypeObject *). */ +#define SHA2N_T(N) sha ## N ## _type +/* The name of the structure used to represent SHA-2 objects. */ +#define SHA2N_O(N) SHA ## N ## object -/* Our SHA2 implementations defer to the HACL* verified library. */ +/* Name of a local (static) helper acting on Python objects. */ +#define SHA2N_HELPER(N, NAME) sha ## N ## _ ## NAME +/* Name of a local (static) helper acting on HACL* objects. */ +#define SHA2N_HACL_HELPER(N, NAME) hacl_sha ## N ## _ ## NAME -#include "_hacl/Hacl_Hash_SHA2.h" +/* Name of a SHA-2 object getter. */ +#define SHA2N_GETTER(N, NAME) _sha2_sha ## N ## _ ## NAME ## _get +/* Name of a SHA-2 object method generated by Argument Clinic. */ +#define SHA2N_CLINIC(N, NAME) _SHA2_SHA ## N ## _ ## NAME -// TODO: Get rid of int digestsize in favor of Hacl state info? +/* The function implementing a SHA-2 type slot. */ +#define SHA2N_TYPE_SLOT(N, NAME) SHA ## N ## object_ ## NAME +/* The name of the array holding the different SHA-2 type slots. */ +#define SHA2N_TYPE_SLOT_ARRAY(N) SHA ## N ## _type_slots +/* The name of the global variable holding the SHA-2 type spec. */ +#define SHA2N_TYPE_SPEC(N) SHA ## N ## _type_spec -typedef struct { - HASHLIB_OBJECT_HEAD - int digestsize; - Hacl_Hash_SHA2_state_t_256 *state; -} SHA256object; +/* The SHA-2 block sizes and maximum message digest sizes, in bytes. */ -typedef struct { - HASHLIB_OBJECT_HEAD - int digestsize; - Hacl_Hash_SHA2_state_t_512 *state; -} SHA512object; +#define SHA224_BLOCK_SIZE 64U +#define SHA224_DIGEST_SIZE 28U -#define _SHA256object_CAST(op) ((SHA256object *)(op)) -#define _SHA512object_CAST(op) ((SHA512object *)(op)) +#define SHA256_BLOCK_SIZE 64U +#define SHA256_DIGEST_SIZE 32U -#include "clinic/sha2module.c.h" +#define SHA384_BLOCK_SIZE 128U +#define SHA384_DIGEST_SIZE 48U + +#define SHA512_BLOCK_SIZE 128U +#define SHA512_DIGEST_SIZE 64U + +#define SHA2N_BLOCK_SIZE(N) SHA ## N ## _ ## BLOCK_SIZE +#define SHA2N_DIGEST_SIZE(N) SHA ## N ## _ ## DIGEST_SIZE + +// --- SHA-2 module state ----------------------------------------------------- -/* 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) +#define SHA2N_TYPE_DECL(N) PyTypeObject *SHA2N_T(N) + SHA2_EXPAND_MACRO(SHA2N_TYPE_DECL) +#undef SHA2N_TYPE_DECL +} sha2module_state; + +static inline sha2module_state * +get_sha2module_state(PyObject *module) { void *state = _PyModule_GetState(module); assert(state != NULL); - return (sha2_state *)state; -} - -static int -SHA256copy(SHA256object *src, SHA256object *dest) -{ - dest->digestsize = src->digestsize; - dest->state = Hacl_Hash_SHA2_copy_256(src->state); - if (dest->state == NULL) { - (void)PyErr_NoMemory(); - return -1; - } - return 0; + return (sha2module_state *)state; } -static int -SHA512copy(SHA512object *src, SHA512object *dest) +static inline sha2module_state * +get_sha2module_state_by_cls(PyTypeObject *cls) { - dest->digestsize = src->digestsize; - dest->state = Hacl_Hash_SHA2_copy_512(src->state); - if (dest->state == NULL) { - (void)PyErr_NoMemory(); - return -1; - } - return 0; + // _PyType_GetModuleState() is safe because the SHA-2 types are final. + void *state = _PyType_GetModuleState(cls); + assert(state != NULL); + return (sha2module_state *)state; } -static SHA256object * -newSHA224object(sha2_state *state) -{ - SHA256object *sha = PyObject_GC_New(SHA256object, state->sha224_type); - if (!sha) { - return NULL; - } - HASHLIB_INIT_MUTEX(sha); +// --- SHA-2 object ----------------------------------------------------------- - PyObject_GC_Track(sha); - return sha; -} - -static SHA256object * -newSHA256object(sha2_state *state) -{ - SHA256object *sha = PyObject_GC_New(SHA256object, state->sha256_type); - if (!sha) { - return NULL; - } - HASHLIB_INIT_MUTEX(sha); +#define SHA2N_OBJECT_STRUCT_DECL(N) \ + typedef struct { \ + HASHLIB_OBJECT_HEAD \ + Hacl_Hash_SHA2_state_t_ ## N *state; \ + } SHA2N_O(N); +SHA2_EXPAND_MACRO(SHA2N_OBJECT_STRUCT_DECL) +#undef SHA2N_OBJECT_STRUCT_DECL - PyObject_GC_Track(sha); - return sha; -} +#define SHA2object_CAST(N, op) ((SHA2N_O(N) *)(op)) -static SHA512object * -newSHA384object(sha2_state *state) -{ - SHA512object *sha = PyObject_GC_New(SHA512object, state->sha384_type); - if (!sha) { - return NULL; - } - HASHLIB_INIT_MUTEX(sha); +/* + * HACL* does not provide a copy function for SHA-224 and SHA-384 + * as their state is the *same* as for SHA-256 and SHA-512, so we + * provide those missing aliases (which must be prefixed with the + * namespace we chose in Modules/_hacl/python_hacl_namespaces.h). + * + * Note: do not use HACL_HASH_SHA2_([256,512], copy) since + * double macro expansion is not supported by C compilers. + */ +#define Hacl_Hash_SHA2_copy_224 Hacl_Hash_SHA2_copy_256 +#define Hacl_Hash_SHA2_copy_384 Hacl_Hash_SHA2_copy_512 - PyObject_GC_Track(sha); - return sha; -} +// --- SHA-2 module clinic configuration -------------------------------------- -static SHA512object * -newSHA512object(sha2_state *state) -{ - SHA512object *sha = PyObject_GC_New(SHA512object, state->sha512_type); - if (!sha) { - return NULL; - } - HASHLIB_INIT_MUTEX(sha); +/*[clinic input] +module _sha2 +class _sha2.sha224 "SHA2N_O(224) *" "clinic_state()->SHA2N_T(224)" +class _sha2.sha256 "SHA2N_O(256) *" "clinic_state()->SHA2N_T(256)" +class _sha2.sha384 "SHA2N_O(384) *" "clinic_state()->SHA2N_T(384)" +class _sha2.sha512 "SHA2N_O(512) *" "clinic_state()->SHA2N_T(512)" +[clinic start generated code]*/ +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=c3e4bea8800f0fd0]*/ - PyObject_GC_Track(sha); - return sha; -} +#define clinic_state() (get_sha2module_state_by_cls(Py_TYPE(self))) +#include "clinic/sha2module.c.h" +#undef clinic_state -/* Internal methods for our hash objects. */ +// --- SHA-2 object: special methods ------------------------------------------ static int -SHA2_traverse(PyObject *ptr, visitproc visit, void *arg) +SHA2object_traverse(PyObject *op, visitproc visit, void *arg) { - Py_VISIT(Py_TYPE(ptr)); + Py_VISIT(Py_TYPE(op)); return 0; } -static void -SHA256_dealloc(PyObject *op) -{ - SHA256object *ptr = _SHA256object_CAST(op); - if (ptr->state != NULL) { - Hacl_Hash_SHA2_free_256(ptr->state); - ptr->state = NULL; +#define SHA224object_traverse SHA2object_traverse +#define SHA256object_traverse SHA2object_traverse +#define SHA384object_traverse SHA2object_traverse +#define SHA512object_traverse SHA2object_traverse + +#define SHA2N_OBJECT_DEALLOC_DECL(N) \ +static void \ +SHA2N_TYPE_SLOT(N, dealloc) (PyObject *op) \ +{ \ + SHA2N_O(N) *self = SHA2object_CAST(N, op); \ + if (self->state != NULL) { \ + HACL_HASH_SHA2_(N, free)(self->state); \ + self->state = NULL; \ + } \ + PyTypeObject *tp = Py_TYPE(self); \ + PyObject_GC_UnTrack(self); \ + PyObject_GC_Del(self); \ + Py_DECREF(tp); \ +} +SHA2_EXPAND_MACRO(SHA2N_OBJECT_DEALLOC_DECL) +#undef SHA2N_OBJECT_DEALLOC_DECL + +// --- SHA-2 object: helpers -------------------------------------------------- + +/* Allocate memory for a new SHA-2 object and initialize its attributes. */ +#define SHA2N_OBJECT_NEW_DECL(N) \ + static SHA2N_O(N) * \ + SHA2N_HELPER(N, new) (sha2module_state *state) \ + { \ + SHA2N_O(N) *self = PyObject_GC_New(SHA2N_O(N), state->SHA2N_T(N)); \ + if (self == NULL) { \ + return NULL; \ + } \ + HASHLIB_INIT_MUTEX(self); \ + PyObject_GC_Track(self); \ + return self; \ + } +SHA2_EXPAND_MACRO(SHA2N_OBJECT_NEW_DECL) +#undef SHA2N_OBJECT_NEW_DECL + +// --- SHA-2 object: public methods ------------------------------------------- + +#define SHA2N_OBJECT_COPY_UNLOCKED_DECL(N) \ + static int \ + SHA2N_HELPER(N, copy_unlocked) (SHA2N_O(N) *src, SHA2N_O(N) *dst) \ + { \ + dst->state = HACL_HASH_SHA2_(N, copy)(src->state); \ + if (dst->state == NULL) { \ + (void)PyErr_NoMemory(); \ + return -1; \ + } \ + return 0; \ + } +SHA2_EXPAND_MACRO(SHA2N_OBJECT_COPY_UNLOCKED_DECL) +#undef SHA2N_OBJECT_COPY_UNLOCKED_DECL + +#define SHA2N_OBJECT_COPY_IMPL_BODY(N, SELF) \ + { \ + PyTypeObject *cls = Py_TYPE(SELF); \ + sha2module_state *state = get_sha2module_state_by_cls(cls); \ + SHA2N_O(N) *copy = SHA2N_HELPER(N, new)(state); \ + if (copy == NULL) { \ + return NULL; \ + } \ + int rc; \ + HASHLIB_ACQUIRE_LOCK(SELF); \ + rc = SHA2N_HELPER(N, copy_unlocked)(SELF, copy); \ + HASHLIB_RELEASE_LOCK(SELF); \ + if (rc < 0) { \ + Py_DECREF(copy); \ + return NULL; \ + } \ + return (PyObject *)copy; \ } - PyTypeObject *tp = Py_TYPE(ptr); - PyObject_GC_UnTrack(ptr); - PyObject_GC_Del(ptr); - Py_DECREF(tp); -} - -static void -SHA512_dealloc(PyObject *op) -{ - SHA512object *ptr = _SHA512object_CAST(op); - if (ptr->state != NULL) { - Hacl_Hash_SHA2_free_512(ptr->state); - ptr->state = NULL; - } - 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_Hash_SHA2_state_t_256 *state, uint8_t *buf, Py_ssize_t len) -{ - /* - * Note: we explicitly ignore the error code on the basis that it would - * take more than 1 billion years to overflow the maximum admissible length - * for SHA-2-256 (2^61 - 1). - */ -#if PY_SSIZE_T_MAX > UINT32_MAX - while (len > UINT32_MAX) { - (void)Hacl_Hash_SHA2_update_256(state, buf, UINT32_MAX); - len -= UINT32_MAX; - buf += UINT32_MAX; - } -#endif - /* cast to uint32_t is now safe */ - (void)Hacl_Hash_SHA2_update_256(state, buf, (uint32_t)len); -} - -static void -update_512(Hacl_Hash_SHA2_state_t_512 *state, uint8_t *buf, Py_ssize_t len) -{ - /* - * Note: we explicitly ignore the error code on the basis that it would - * take more than 1 billion years to overflow the maximum admissible length - * for SHA-2-512 (2^64 - 1). - */ -#if PY_SSIZE_T_MAX > UINT32_MAX - while (len > UINT32_MAX) { - (void)Hacl_Hash_SHA2_update_512(state, buf, UINT32_MAX); - len -= UINT32_MAX; - buf += UINT32_MAX; - } -#endif - /* cast to uint32_t is now safe */ - (void)Hacl_Hash_SHA2_update_512(state, buf, (uint32_t)len); -} - - -/* External methods for our hash objects */ /*[clinic input] -SHA256Type.copy +_sha2.sha224.copy +Return a copy of the hash object. +[clinic start generated code]*/ - cls:defining_class +static PyObject * +_sha2_sha224_copy_impl(SHA2N_O(224) *self) +/*[clinic end generated code: output=15b659d696b1a0ba input=7162c33cbb88084e]*/ +SHA2N_OBJECT_COPY_IMPL_BODY(224, self) +/*[clinic input] +_sha2.sha256.copy 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]*/ -{ - int rc; - 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; - } - } - - HASHLIB_ACQUIRE_LOCK(self); - rc = SHA256copy(self, newobj); - HASHLIB_RELEASE_LOCK(self); - if (rc < 0) { - Py_DECREF(newobj); - return NULL; - } - return (PyObject *)newobj; -} +_sha2_sha256_copy_impl(SHA2N_O(256) *self) +/*[clinic end generated code: output=320dfb9aee48bf50 input=6c05ad66f876c316]*/ +SHA2N_OBJECT_COPY_IMPL_BODY(256, self) /*[clinic input] -SHA512Type.copy +_sha2.sha384.copy +Return a copy of the hash object. +[clinic start generated code]*/ - cls: defining_class +static PyObject * +_sha2_sha384_copy_impl(SHA2N_O(384) *self) +/*[clinic end generated code: output=77e81007d40cae4b input=c23c134ce53c0465]*/ +SHA2N_OBJECT_COPY_IMPL_BODY(384, self) +/*[clinic input] +_sha2.sha512.copy 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]*/ -{ - int rc; - 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; - } +_sha2_sha512_copy_impl(SHA2N_O(512) *self) +/*[clinic end generated code: output=77dfbe2b79137553 input=076f685299a203a6]*/ +SHA2N_OBJECT_COPY_IMPL_BODY(512, self) +#undef SHA2N_OBJECT_COPY_IMPL_BODY + +// The hacl_sha{224,256,384,512}_state_update() functions below ignore +// the error code returned by Hacl_Hash_SHA2_update_{224,256,384,512}() +// on the basis that it would take more than 1 billion years to overflow +// the maximum admissible lengths for SHA-2/{224,256} and SHA-2/{384,512}, +// which are (2^61-1) and (2^64-1) respectively. +#if PY_SSIZE_T_MAX > UINT32_MAX +#define SHA2N_HACL_SHA2_STATE_UPDATE_DECL(N) \ + /* + * 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 \ + SHA2N_HACL_HELPER(N, state_update) (HACL_HASH_SHA2_(N, state_t) *state, \ + uint8_t *buf, Py_ssize_t len) \ + { \ + while (len > UINT32_MAX) { \ + (void)HACL_HASH_SHA2_(N, update)(state, buf, UINT32_MAX); \ + len -= UINT32_MAX; \ + buf += UINT32_MAX; \ + } \ + /* cast to uint32_t is now safe */ \ + (void)HACL_HASH_SHA2_(N, update)(state, buf, (uint32_t)len); \ + } +#else +#define SHA2N_HACL_SHA2_STATE_UPDATE_DECL(N) \ + static inline void \ + SHA2N_HACL_HELPER(N, state_update) (HACL_HASH_SHA2_(N, state_t) *state, \ + uint8_t *buf, Py_ssize_t len) \ + { \ + (void)HACL_HASH_SHA2_(N, update)(state, buf, (uint32_t)len); \ } +#endif +SHA2_EXPAND_MACRO(SHA2N_HACL_SHA2_STATE_UPDATE_DECL) +#undef SHA2N_HACL_SHA2_STATE_UPDATE_DECL - HASHLIB_ACQUIRE_LOCK(self); - rc = SHA512copy(self, newobj); - HASHLIB_RELEASE_LOCK(self); - if (rc < 0) { - Py_DECREF(newobj); - return NULL; +#define SHA2N_HACL_SHA2_STATE_UPDATE_WITH_BUFFER(N, SELF, BUF) \ + SHA2N_HACL_HELPER(N, state_update)((SELF)->state, (BUF).buf, (BUF).len) + +#define SHA2N_OBJECT_UPDATE_IMPL_BODY(N, OP, MSG) \ + { \ + Py_buffer buf; \ + SHA2N_O(N) *self = SHA2object_CAST(N, (OP)); \ + GET_BUFFER_VIEW_OR_ERROUT((MSG), &buf); \ + HASHLIB_EXTERNAL_INSTRUCTIONS_LOCKED( \ + self, buf.len, \ + SHA2N_HACL_SHA2_STATE_UPDATE_WITH_BUFFER(N, self, buf) \ + ); \ + PyBuffer_Release(&buf); \ + Py_RETURN_NONE; \ } - return (PyObject *)newobj; -} /*[clinic input] -SHA256Type.digest +_sha2.sha224.update -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); - HASHLIB_ACQUIRE_LOCK(self); - // HACL* performs copies under the hood so that self->state remains valid - // after this call. - Hacl_Hash_SHA2_digest_256(self->state, digest); - HASHLIB_RELEASE_LOCK(self); - return PyBytes_FromStringAndSize((const char *)digest, self->digestsize); -} - -/*[clinic input] -SHA512Type.digest + op: self + data: object + / -Return the digest value as a bytes object. +Update this hash object's state with the provided string. [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); - HASHLIB_ACQUIRE_LOCK(self); - // HACL* performs copies under the hood so that self->state remains valid - // after this call. - Hacl_Hash_SHA2_digest_512(self->state, digest); - HASHLIB_RELEASE_LOCK(self); - return PyBytes_FromStringAndSize((const char *)digest, self->digestsize); -} +_sha2_sha224_update(PyObject *op, PyObject *data) +/*[clinic end generated code: output=234ae9a31416039f input=3d0c176d74dd455f]*/ +SHA2N_OBJECT_UPDATE_IMPL_BODY(224, op, data) /*[clinic input] -SHA256Type.hexdigest - -Return the digest value as a string of hexadecimal digits. +_sha2.sha256.update = _sha2.sha224.update +Update this hash object's state with the provided string. [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); - HASHLIB_ACQUIRE_LOCK(self); - Hacl_Hash_SHA2_digest_256(self->state, digest); - HASHLIB_RELEASE_LOCK(self); - return _Py_strhex((const char *)digest, self->digestsize); -} +_sha2_sha256_update(PyObject *op, PyObject *data) +/*[clinic end generated code: output=c51b81c8de3fcc84 input=3924a233fae98adc]*/ +SHA2N_OBJECT_UPDATE_IMPL_BODY(256, op, data) /*[clinic input] -SHA512Type.hexdigest - -Return the digest value as a string of hexadecimal digits. +_sha2.sha384.update = _sha2.sha224.update +Update this hash object's state with the provided string. [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); - HASHLIB_ACQUIRE_LOCK(self); - Hacl_Hash_SHA2_digest_512(self->state, digest); - HASHLIB_RELEASE_LOCK(self); - return _Py_strhex((const char *)digest, self->digestsize); -} +_sha2_sha384_update(PyObject *op, PyObject *data) +/*[clinic end generated code: output=9b446dae8df1c57d input=97600fcf46863a2c]*/ +SHA2N_OBJECT_UPDATE_IMPL_BODY(384, op, data) /*[clinic input] -SHA256Type.update - - obj: object - / - +_sha2.sha512.update = _sha2.sha224.update Update this hash object's state with the provided string. [clinic start generated code]*/ static PyObject * -SHA256Type_update_impl(SHA256object *self, PyObject *obj) -/*[clinic end generated code: output=dc58a580cf8905a5 input=b2d449d5b30f0f5a]*/ -{ - Py_buffer buf; - GET_BUFFER_VIEW_OR_ERROUT(obj, &buf); - HASHLIB_EXTERNAL_INSTRUCTIONS_LOCKED( - self, buf.len, - update_256(self->state, buf.buf, buf.len) - ); - PyBuffer_Release(&buf); - Py_RETURN_NONE; -} +_sha2_sha512_update(PyObject *op, PyObject *data) +/*[clinic end generated code: output=59b133f2ff16cd39 input=74ce6f09e5e76aed]*/ +SHA2N_OBJECT_UPDATE_IMPL_BODY(512, op, data) +#undef SHA2N_OBJECT_UPDATE_IMPL_BODY + +/* Compute the raw binary digest of a SHA-2 object. */ +#define SHA2N_OBJECT_DIGEST_IMPL_BODY(N, SELF) \ + { \ + uint8_t digest[SHA2N_DIGEST_SIZE(N)]; \ + HASHLIB_ACQUIRE_LOCK(SELF); \ + HACL_HASH_SHA2_(N, digest)((SELF)->state, digest); \ + HASHLIB_RELEASE_LOCK(SELF); \ + return PyBytes_FromStringAndSize((const char *)digest, \ + SHA2N_DIGEST_SIZE(N)); \ + } /*[clinic input] -SHA512Type.update - - obj: object - / - -Update this hash object's state with the provided string. +_sha2.sha224.digest +Return the digest value as a bytes object. [clinic start generated code]*/ static PyObject * -SHA512Type_update_impl(SHA512object *self, PyObject *obj) -/*[clinic end generated code: output=9af211766c0b7365 input=ded2b46656566283]*/ -{ - Py_buffer buf; - GET_BUFFER_VIEW_OR_ERROUT(obj, &buf); - HASHLIB_EXTERNAL_INSTRUCTIONS_LOCKED( - self, buf.len, - 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 */ -}; +_sha2_sha224_digest_impl(SHA2N_O(224) *self) +/*[clinic end generated code: output=5a0f7e48f8695c13 input=93ea2ea3a95e3b61]*/ +SHA2N_OBJECT_DIGEST_IMPL_BODY(224, self) -static PyMethodDef SHA512_methods[] = { - SHA512TYPE_COPY_METHODDEF - SHA512TYPE_DIGEST_METHODDEF - SHA512TYPE_HEXDIGEST_METHODDEF - SHA512TYPE_UPDATE_METHODDEF - {NULL, NULL} /* sentinel */ -}; +/*[clinic input] +_sha2.sha256.digest +Return the digest value as a bytes object. +[clinic start generated code]*/ static PyObject * -SHA256_get_block_size(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure)) -{ - return PyLong_FromLong(SHA256_BLOCKSIZE); -} +_sha2_sha256_digest_impl(SHA2N_O(256) *self) +/*[clinic end generated code: output=32dd6ea4184960aa input=a8d49fc95711cf59]*/ +SHA2N_OBJECT_DIGEST_IMPL_BODY(256, self) -static PyObject * -SHA512_get_block_size(PyObject *Py_UNUSED(self), void *Py_UNUSED(closure)) -{ - return PyLong_FromLong(SHA512_BLOCKSIZE); -} +/*[clinic input] +_sha2.sha384.digest +Return the digest value as a bytes object. +[clinic start generated code]*/ static PyObject * -SHA256_get_digest_size(PyObject *op, void *Py_UNUSED(closure)) -{ - SHA256object *self = _SHA256object_CAST(op); - return PyLong_FromLong(self->digestsize); -} +_sha2_sha384_digest_impl(SHA2N_O(384) *self) +/*[clinic end generated code: output=cb4518480ed05a6b input=b0c88f92c1c410f6]*/ +SHA2N_OBJECT_DIGEST_IMPL_BODY(384, self) -static PyObject * -SHA512_get_digest_size(PyObject *op, void *Py_UNUSED(closure)) -{ - SHA512object *self = _SHA512object_CAST(op); - return PyLong_FromLong(self->digestsize); -} +/*[clinic input] +_sha2.sha512.digest +Return the digest value as a bytes object. +[clinic start generated code]*/ static PyObject * -SHA256_get_name(PyObject *op, void *Py_UNUSED(closure)) -{ - SHA256object *self = _SHA256object_CAST(op); - if (self->digestsize == 28) { - return PyUnicode_FromStringAndSize("sha224", 6); - } - return PyUnicode_FromStringAndSize("sha256", 6); -} +_sha2_sha512_digest_impl(SHA2N_O(512) *self) +/*[clinic end generated code: output=a923fedb863fb645 input=3f1c7acd439d8524]*/ +SHA2N_OBJECT_DIGEST_IMPL_BODY(512, self) +#undef SHA2N_OBJECT_DIGEST_IMPL_BODY -static PyObject * -SHA512_get_name(PyObject *op, void *Py_UNUSED(closure)) -{ - SHA512object *self = _SHA512object_CAST(op); - if (self->digestsize == 64) { - return PyUnicode_FromStringAndSize("sha512", 6); +/* Compute the hexadecimal representation of a SHA-2 digest. */ +#define SHA2N_OBJECT_HEXDIGEST_IMPL_BODY(N, SELF) \ + { \ + uint8_t digest[SHA2N_DIGEST_SIZE(N)]; \ + HASHLIB_ACQUIRE_LOCK(SELF); \ + HACL_HASH_SHA2_(N, digest)((SELF)->state, digest); \ + HASHLIB_RELEASE_LOCK(SELF); \ + return _Py_strhex((const char *)digest, SHA2N_DIGEST_SIZE(N)); \ } - return PyUnicode_FromStringAndSize("sha384", 6); -} -static PyGetSetDef SHA256_getseters[] = { - {"block_size", SHA256_get_block_size, NULL, NULL, NULL}, - {"name", SHA256_get_name, NULL, NULL, NULL}, - {"digest_size", SHA256_get_digest_size, NULL, NULL, NULL}, - {NULL} /* Sentinel */ -}; - -static PyGetSetDef SHA512_getseters[] = { - {"block_size", SHA512_get_block_size, NULL, NULL, NULL}, - {"name", SHA512_get_name, NULL, NULL, NULL}, - {"digest_size", 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} -}; +/*[clinic input] +_sha2.sha224.hexdigest -// 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 -}; +Return the digest value as a string of hexadecimal digits. +[clinic start generated code]*/ -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 PyObject * +_sha2_sha224_hexdigest_impl(SHA2N_O(224) *self) +/*[clinic end generated code: output=72658011aa3b635b input=ea7596919378aa81]*/ +SHA2N_OBJECT_HEXDIGEST_IMPL_BODY(224, self) -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 -}; +/*[clinic input] +_sha2.sha256.hexdigest -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 -}; +Return the digest value as a string of hexadecimal digits. +[clinic start generated code]*/ -/* The module-level constructors. */ +static PyObject * +_sha2_sha256_hexdigest_impl(SHA2N_O(256) *self) +/*[clinic end generated code: output=b5c61a7ac62e4dd2 input=b5dc9ed1fb19ee00]*/ +SHA2N_OBJECT_HEXDIGEST_IMPL_BODY(256, self) /*[clinic input] -_sha2.sha256 +_sha2.sha384.hexdigest - data: object(c_default="NULL") = b'' - * - usedforsecurity: bool = True - string as string_obj: object(c_default="NULL") = None - -Return a new SHA-256 hash object; optionally initialized with a string. +Return the digest value as a string of hexadecimal digits. [clinic start generated code]*/ static PyObject * -_sha2_sha256_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj) -/*[clinic end generated code: output=49828a7bcd418f45 input=9ce1d70e669abc14]*/ -{ - Py_buffer buf; - PyObject *string; - if (_Py_hashlib_data_argument(&string, data, string_obj) < 0) { - return NULL; - } - - if (string) { - GET_BUFFER_VIEW_OR_ERROUT(string, &buf); - } +_sha2_sha384_hexdigest_impl(SHA2N_O(384) *self) +/*[clinic end generated code: output=a3c146a7daf87ff3 input=ca2fe324306d68a2]*/ +SHA2N_OBJECT_HEXDIGEST_IMPL_BODY(384, self) - sha2_state *state = sha2_get_state(module); +/*[clinic input] +_sha2.sha512.hexdigest - SHA256object *new; - if ((new = newSHA256object(state)) == NULL) { - if (string) { - PyBuffer_Release(&buf); - } - return NULL; - } +Return the digest value as a string of hexadecimal digits. +[clinic start generated code]*/ - new->state = Hacl_Hash_SHA2_malloc_256(); - new->digestsize = 32; +static PyObject * +_sha2_sha512_hexdigest_impl(SHA2N_O(512) *self) +/*[clinic end generated code: output=5b9f840530e770e4 input=8a2578fe8832a2d5]*/ +SHA2N_OBJECT_HEXDIGEST_IMPL_BODY(512, self) +#undef SHA2N_OBJECT_HEXDIGEST_IMPL_BODY + +// --- SHA-2 object: public getters ------------------------------------------- + +#define SHA2N_OBJECT_NAME_GETTER_DECL(N) \ + static inline PyObject * \ + SHA2N_GETTER(N, name) (PyObject *Py_UNUSED(op), \ + void *Py_UNUSED(closure)) \ + { \ + assert(strlen(#N) == 3); \ + return PyUnicode_FromStringAndSize("sha" #N, 6); \ + } +SHA2_EXPAND_MACRO(SHA2N_OBJECT_NAME_GETTER_DECL) +#undef SHA2N_OBJECT_NAME_GETTER_DECL + +#define SHA2N_OBJECT_BLOCK_SIZE_GETTER_DECL(N) \ + static inline PyObject * \ + SHA2N_GETTER(N, block_size) (PyObject *Py_UNUSED(op), \ + void *Py_UNUSED(closure)) \ + { \ + return PyLong_FromLong(SHA2N_BLOCK_SIZE(N)); \ + } +SHA2_EXPAND_MACRO(SHA2N_OBJECT_BLOCK_SIZE_GETTER_DECL) +#undef SHA2N_OBJECT_BLOCK_SIZE_GETTER_DECL + +#define SHA2N_OBJECT_DIGEST_SIZE_GETTER_DECL(N) \ + static inline PyObject * \ + SHA2N_GETTER(N, digest_size) (PyObject *Py_UNUSED(op), \ + void *Py_UNUSED(closure)) \ + { \ + return PyLong_FromLong(SHA2N_DIGEST_SIZE(N)); \ + } +SHA2_EXPAND_MACRO(SHA2N_OBJECT_DIGEST_SIZE_GETTER_DECL) +#undef SHA2N_OBJECT_DIGEST_SIZE_GETTER_DECL + +// --- SHA-2 type specifications ---------------------------------------------- + +#define SHA2N_TYPE_OBJECT_METHODS_DEF_DECL(N) \ + static PyMethodDef SHA2N_TYPE_SLOT(N, methods)[] = { \ + SHA2N_CLINIC(N, COPY_METHODDEF) \ + SHA2N_CLINIC(N, UPDATE_METHODDEF) \ + SHA2N_CLINIC(N, DIGEST_METHODDEF) \ + SHA2N_CLINIC(N, HEXDIGEST_METHODDEF) \ + {NULL, NULL} /* sentinel */ \ + }; +SHA2_EXPAND_MACRO(SHA2N_TYPE_OBJECT_METHODS_DEF_DECL) +#undef SHA2N_TYPE_OBJECT_METHODS_DEF_DECL + +#define SHA2N_TYPE_OBJECT_GETSETS_DEF_DECL(N) \ + static PyGetSetDef SHA2N_TYPE_SLOT(N, getsets)[] = { \ + {"name", SHA2N_GETTER(N, name), NULL, NULL}, \ + {"block_size", SHA2N_GETTER(N, block_size), NULL, NULL}, \ + {"digest_size", SHA2N_GETTER(N, digest_size), NULL, NULL}, \ + {NULL} /* sentinel */ \ + }; +SHA2_EXPAND_MACRO(SHA2N_TYPE_OBJECT_GETSETS_DEF_DECL) +#undef SHA2N_TYPE_OBJECT_GETSETS_DEF_DECL + +#define SHA2N_TYPE_OBJECT_SLOTS_DECL(N) \ + static PyType_Slot SHA2N_TYPE_SLOT_ARRAY(N)[] = { \ + {Py_tp_methods, SHA2N_TYPE_SLOT(N, methods)}, \ + {Py_tp_getset, SHA2N_TYPE_SLOT(N, getsets)}, \ + {Py_tp_dealloc, SHA2N_TYPE_SLOT(N, dealloc)}, \ + {Py_tp_traverse, SHA2N_TYPE_SLOT(N, traverse)}, \ + {0, NULL} /* sentinel */ \ + }; +SHA2_EXPAND_MACRO(SHA2N_TYPE_OBJECT_SLOTS_DECL) +#undef SHA2N_TYPE_OBJECT_SLOTS_DECL - if (new->state == NULL) { - Py_DECREF(new); - if (string) { - PyBuffer_Release(&buf); - } - return PyErr_NoMemory(); - } - if (string) { - /* Do not use self->mutex here as this is the constructor - * where it is not yet possible to have concurrent access. */ - HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( - buf.len, - update_256(new->state, buf.buf, buf.len) - ); - PyBuffer_Release(&buf); +// Using _PyType_GetModuleState() on these types is safe since they +// cannot be subclassed: they don't have the Py_TPFLAGS_BASETYPE flag. +#define SHA2N_TYPE_OBJECT_TYPE_SPEC_DECL(N) \ + static PyType_Spec SHA2N_TYPE_SPEC(N) = { \ + .name = "_sha2.SHA" Py_STRINGIFY(N) "Type", \ + .basicsize = sizeof(SHA2N_O(N)), \ + .flags = ( \ + Py_TPFLAGS_DEFAULT \ + | Py_TPFLAGS_DISALLOW_INSTANTIATION \ + | Py_TPFLAGS_IMMUTABLETYPE \ + | Py_TPFLAGS_HAVE_GC \ + ), \ + .slots = SHA2N_TYPE_SLOT_ARRAY(N) \ + }; +SHA2_EXPAND_MACRO(SHA2N_TYPE_OBJECT_TYPE_SPEC_DECL) +#undef SHA2N_TYPE_OBJECT_TYPE_SPEC_DECL + +// --- SHA-2 module-level named constructors ---------------------------------- + +#define SHA2N_FACTORY_IMPL_BODY(N, MODULE, DATA, STRING, USEDFORSECURITY) \ + { \ + Py_buffer buf; \ + PyObject *msg; \ + /* TODO(picnixz): this should be removed in Python 3.19 */ \ + if (_Py_hashlib_data_argument(&msg, (DATA), (STRING)) < 0) { \ + return NULL; \ + } \ + if (msg) { \ + GET_BUFFER_VIEW_OR_ERROUT(msg, &buf); \ + } \ + sha2module_state *state = get_sha2module_state((MODULE)); \ + SHA2N_O(N) *self = SHA2N_HELPER(N, new)(state); \ + if (self == NULL) { \ + if (msg) { \ + PyBuffer_Release(&buf); \ + } \ + return NULL; \ + } \ + self->state = HACL_HASH_SHA2_(N, malloc)(); \ + if (self->state == NULL) { \ + Py_DECREF(self); \ + if (msg) { \ + PyBuffer_Release(&buf); \ + } \ + return PyErr_NoMemory(); \ + } \ + if (msg) { \ + /* Do not use self->mutex here as this is the constructor + * where it is not yet possible to have concurrent access. */ \ + HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( \ + buf.len, \ + SHA2N_HACL_SHA2_STATE_UPDATE_WITH_BUFFER(N, self, buf) \ + ); \ + PyBuffer_Release(&buf); \ + } \ + return (PyObject *)self; \ } - return (PyObject *)new; -} - /*[clinic input] _sha2.sha224 data: object(c_default="NULL") = b'' * usedforsecurity: bool = True - string as string_obj: object(c_default="NULL") = None + string: object(c_default="NULL") = None Return a new SHA-224 hash object; optionally initialized with a string. [clinic start generated code]*/ static PyObject * _sha2_sha224_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj) -/*[clinic end generated code: output=2163cb03b6cf6157 input=612f7682a889bc2a]*/ -{ - Py_buffer buf; - PyObject *string; - if (_Py_hashlib_data_argument(&string, data, string_obj) < 0) { - return NULL; - } - - 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_Hash_SHA2_malloc_224(); - new->digestsize = 28; - - if (new->state == NULL) { - Py_DECREF(new); - if (string) { - PyBuffer_Release(&buf); - } - return PyErr_NoMemory(); - } - if (string) { - /* Do not use self->mutex here as this is the constructor - * where it is not yet possible to have concurrent access. */ - HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( - buf.len, - update_256(new->state, buf.buf, buf.len) - ); - PyBuffer_Release(&buf); - } - - return (PyObject *)new; -} + PyObject *string) +/*[clinic end generated code: output=e469eb87e6ff5796 input=16ae8ff74ba9ce03]*/ +SHA2N_FACTORY_IMPL_BODY(224, module, data, string, usedforsecurity) /*[clinic input] -_sha2.sha512 +_sha2.sha256 = _sha2.sha224 - data: object(c_default="NULL") = b'' - * - usedforsecurity: bool = True - string as string_obj: object(c_default="NULL") = None - -Return a new SHA-512 hash object; optionally initialized with a string. +Return a new SHA-256 hash object; optionally initialized with a string. [clinic start generated code]*/ static PyObject * -_sha2_sha512_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj) -/*[clinic end generated code: output=cc3fcfce001a4538 input=19c9f2c06d59563a]*/ -{ - SHA512object *new; - Py_buffer buf; - PyObject *string; - if (_Py_hashlib_data_argument(&string, data, string_obj) < 0) { - return NULL; - } - - 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_Hash_SHA2_malloc_512(); - new->digestsize = 64; - - if (new->state == NULL) { - Py_DECREF(new); - if (string) { - PyBuffer_Release(&buf); - } - return PyErr_NoMemory(); - } - if (string) { - /* Do not use self->mutex here as this is the constructor - * where it is not yet possible to have concurrent access. */ - HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( - buf.len, - update_512(new->state, buf.buf, buf.len) - ); - PyBuffer_Release(&buf); - } - - return (PyObject *)new; -} +_sha2_sha256_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string) +/*[clinic end generated code: output=5daec6e448d859b1 input=0f4bdbdf4f8d1be3]*/ +SHA2N_FACTORY_IMPL_BODY(256, module, data, string, usedforsecurity) /*[clinic input] -_sha2.sha384 - - data: object(c_default="NULL") = b'' - * - usedforsecurity: bool = True - string as string_obj: object(c_default="NULL") = None +_sha2.sha384 = _sha2.sha224 Return a new SHA-384 hash object; optionally initialized with a string. [clinic start generated code]*/ static PyObject * _sha2_sha384_impl(PyObject *module, PyObject *data, int usedforsecurity, - PyObject *string_obj) -/*[clinic end generated code: output=b6e3db593b5a0330 input=9fd50c942ad9e0bf]*/ -{ - SHA512object *new; - Py_buffer buf; - PyObject *string; - if (_Py_hashlib_data_argument(&string, data, string_obj) < 0) { - return NULL; - } - - sha2_state *state = sha2_get_state(module); + PyObject *string) +/*[clinic end generated code: output=c4095e5c6974ee63 input=a01376739d75228b]*/ +SHA2N_FACTORY_IMPL_BODY(384, module, data, string, usedforsecurity) - if (string) { - GET_BUFFER_VIEW_OR_ERROUT(string, &buf); - } - - if ((new = newSHA384object(state)) == NULL) { - if (string) { - PyBuffer_Release(&buf); - } - return NULL; - } - - new->state = Hacl_Hash_SHA2_malloc_384(); - new->digestsize = 48; +/*[clinic input] +_sha2.sha512 = _sha2.sha224 - if (new->state == NULL) { - Py_DECREF(new); - if (string) { - PyBuffer_Release(&buf); - } - return PyErr_NoMemory(); - } - if (string) { - /* Do not use self->mutex here as this is the constructor - * where it is not yet possible to have concurrent access. */ - HASHLIB_EXTERNAL_INSTRUCTIONS_UNLOCKED( - buf.len, - update_512(new->state, buf.buf, buf.len) - ); - PyBuffer_Release(&buf); - } +Return a new SHA-512 hash object; optionally initialized with a string. +[clinic start generated code]*/ - return (PyObject *)new; -} +static PyObject * +_sha2_sha512_impl(PyObject *module, PyObject *data, int usedforsecurity, + PyObject *string) +/*[clinic end generated code: output=c49020bd79bf4edc input=7366a3a246f48f29]*/ +SHA2N_FACTORY_IMPL_BODY(512, module, data, string, usedforsecurity) +#undef SHA2N_FACTORY_IMPL_BODY -/* List of functions exported by this module */ +// --- SHA-2 module methods --------------------------------------------------- -static struct PyMethodDef SHA2_functions[] = { +static struct PyMethodDef sha2module_methods[] = { _SHA2_SHA256_METHODDEF _SHA2_SHA224_METHODDEF _SHA2_SHA512_METHODDEF _SHA2_SHA384_METHODDEF - {NULL, NULL} /* Sentinel */ + {NULL, NULL} /* sentinel */ }; +// --- SHA-2 module initialization and finalization functions ----------------- + static int -_sha2_traverse(PyObject *module, visitproc visit, void *arg) +sha2module_traverse(PyObject *module, visitproc visit, void *arg) { - sha2_state *state = sha2_get_state(module); + sha2module_state *state = get_sha2module_state(module); Py_VISIT(state->sha224_type); Py_VISIT(state->sha256_type); Py_VISIT(state->sha384_type); @@ -820,9 +681,9 @@ _sha2_traverse(PyObject *module, visitproc visit, void *arg) } static int -_sha2_clear(PyObject *module) +sha2module_clear(PyObject *module) { - sha2_state *state = sha2_get_state(module); + sha2module_state *state = get_sha2module_state(module); Py_CLEAR(state->sha224_type); Py_CLEAR(state->sha256_type); Py_CLEAR(state->sha384_type); @@ -831,80 +692,59 @@ _sha2_clear(PyObject *module) } static void -_sha2_free(void *module) +sha2module_free(void *module) { - (void)_sha2_clear((PyObject *)module); + (void)sha2module_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; - } +static int +sha2module_exec(PyObject *module) +{ + sha2module_state *state = get_sha2module_state(module); +#define SHA2N_MAKE_TYPE(N) \ + do { \ + state->SHA2N_T(N) = (PyTypeObject *)PyType_FromModuleAndSpec( \ + module, &SHA2N_TYPE_SPEC(N), NULL); \ + if (state->SHA2N_T(N) == NULL) { \ + return -1; \ + } \ + if (PyModule_AddType(module, state->SHA2N_T(N)) < 0) { \ + return -1; \ + } \ + } while (0) + SHA2_EXPAND_MACRO(SHA2N_MAKE_TYPE) +#undef SHA2N_MAKE_TYPE if (PyModule_AddIntConstant(module, "_GIL_MINSIZE", - HASHLIB_GIL_MINSIZE) < 0) - { + HASHLIB_GIL_MINSIZE) < 0) { return -1; } return 0; } -static PyModuleDef_Slot _sha2_slots[] = { - {Py_mod_exec, sha2_exec}, +static PyModuleDef_Slot sha2module_slots[] = { + {Py_mod_exec, sha2module_exec}, {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED}, {Py_mod_gil, Py_MOD_GIL_NOT_USED}, {0, NULL} }; -static struct PyModuleDef _sha2module = { +static struct PyModuleDef sha2module_def = { 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 + .m_size = sizeof(sha2module_state), + .m_methods = sha2module_methods, + .m_slots = sha2module_slots, + .m_traverse = sha2module_traverse, + .m_clear = sha2module_clear, + .m_free = sha2module_free }; PyMODINIT_FUNC PyInit__sha2(void) { - return PyModuleDef_Init(&_sha2module); + return PyModuleDef_Init(&sha2module_def); }