Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-11-03 23:21:29 +00:00
Code Issues Projects Releases Packages Wiki Activity

bpo-40645: use C implementation of HMAC (GH-24920)

Browse source 
- [x] fix tests
- [ ] add test scenarios for old/new code.

Signed-off-by: Christian Heimes <christian@python.org>
This commit is contained in:
Christian Heimes 2021-03-27 14:55:03 +01:00 • committed by GitHub
parent 5d6e8c1c1a
commit 933dfd7504
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 269 additions and 126 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Lib/hashlib.py
View file

@ -173,6 +173,7 @@ def __hash_new(name, data=b'', **kwargs):
algorithms_available = algorithms_available.union(
_hashlib.openssl_md_meth_names)
except ImportError:
_hashlib = None
new = __py_new
__get_hash = __get_builtin_constructor

78
Lib/hmac.py
View file

@ -8,11 +8,12 @@
import _hashlib as _hashopenssl
except ImportError:
_hashopenssl = None
_openssl_md_meths = None
_functype = None
from _operator import _compare_digest as compare_digest
else:
_openssl_md_meths = frozenset(_hashopenssl.openssl_md_meth_names)
compare_digest = _hashopenssl.compare_digest
_functype = type(_hashopenssl.openssl_sha256) # builtin type
import hashlib as _hashlib
trans_5C = bytes((x ^ 0x5C) for x in range(256))
@ -23,7 +24,6 @@
digest_size = None
class HMAC:
"""RFC 2104 HMAC class. Also complies with RFC 4231.
@ -32,7 +32,7 @@ class HMAC:
blocksize = 64 # 512-bit HMAC; can be changed in subclasses.
__slots__ = (
"_digest_cons", "_inner", "_outer", "block_size", "digest_size"
"_hmac", "_inner", "_outer", "block_size", "digest_size"
)
def __init__(self, key, msg=None, digestmod=''):
@ -55,15 +55,30 @@ def __init__(self, key, msg=None, digestmod=''):
if not digestmod:
raise TypeError("Missing required parameter 'digestmod'.")
if callable(digestmod):
self._digest_cons = digestmod
elif isinstance(digestmod, str):
self._digest_cons = lambda d=b'': _hashlib.new(digestmod, d)
if _hashopenssl and isinstance(digestmod, (str, _functype)):
try:
self._init_hmac(key, msg, digestmod)
except _hashopenssl.UnsupportedDigestmodError:
self._init_old(key, msg, digestmod)
else:
self._digest_cons = lambda d=b'': digestmod.new(d)
self._init_old(key, msg, digestmod)
self._outer = self._digest_cons()
self._inner = self._digest_cons()
def _init_hmac(self, key, msg, digestmod):
self._hmac = _hashopenssl.hmac_new(key, msg, digestmod=digestmod)
self.digest_size = self._hmac.digest_size
self.block_size = self._hmac.block_size
def _init_old(self, key, msg, digestmod):
if callable(digestmod):
digest_cons = digestmod
elif isinstance(digestmod, str):
digest_cons = lambda d=b'': _hashlib.new(digestmod, d)
else:
digest_cons = lambda d=b'': digestmod.new(d)
self._hmac = None
self._outer = digest_cons()
self._inner = digest_cons()
self.digest_size = self._inner.digest_size
if hasattr(self._inner, 'block_size'):
@ -79,13 +94,13 @@ def __init__(self, key, msg=None, digestmod=''):
RuntimeWarning, 2)
blocksize = self.blocksize
if len(key) > blocksize:
key = digest_cons(key).digest()
# self.blocksize is the default blocksize. self.block_size is
# effective block size as well as the public API attribute.
self.block_size = blocksize
if len(key) > blocksize:
key = self._digest_cons(key).digest()
key = key.ljust(blocksize, b'\0')
self._outer.update(key.translate(trans_5C))
self._inner.update(key.translate(trans_36))
@ -94,23 +109,15 @@ def __init__(self, key, msg=None, digestmod=''):
@property
def name(self):
return "hmac-" + self._inner.name
@property
def digest_cons(self):
return self._digest_cons
@property
def inner(self):
return self._inner
@property
def outer(self):
return self._outer
if self._hmac:
return self._hmac.name
else:
return f"hmac-{self._inner.name}"
def update(self, msg):
"""Feed data from msg into this hashing object."""
self._inner.update(msg)
inst = self._hmac or self._inner
inst.update(msg)
def copy(self):
"""Return a separate copy of this hashing object.
@ -119,8 +126,12 @@ def copy(self):
"""
# Call __new__ directly to avoid the expensive __init__.
other = self.__class__.__new__(self.__class__)
other._digest_cons = self._digest_cons
other.digest_size = self.digest_size
if self._hmac:
other._hmac = self._hmac.copy()
other._inner = other._outer = None
else:
other._hmac = None
other._inner = self._inner.copy()
other._outer = self._outer.copy()
return other
@ -130,6 +141,9 @@ def _current(self):
To be used only internally with digest() and hexdigest().
"""
if self._hmac:
return self._hmac
else:
h = self._outer.copy()
h.update(self._inner.digest())
return h
@ -179,9 +193,11 @@ def digest(key, msg, digest):
A hashlib constructor returning a new hash object. *OR*
A module supporting PEP 247.
"""
if (_hashopenssl is not None and
isinstance(digest, str) and digest in _openssl_md_meths):
if _hashopenssl is not None and isinstance(digest, (str, _functype)):
try:
return _hashopenssl.hmac_digest(key, msg, digest)
except _hashopenssl.UnsupportedDigestmodError:
pass
if callable(digest):
digest_cons = digest

112
Lib/test/test_hmac.py
View file

@ -11,14 +11,21 @@
from _operator import _compare_digest as operator_compare_digest
try:
import _hashlib as _hashopenssl
from _hashlib import HMAC as C_HMAC
from _hashlib import hmac_new as c_hmac_new
from _hashlib import compare_digest as openssl_compare_digest
except ImportError:
_hashopenssl = None
C_HMAC = None
c_hmac_new = None
openssl_compare_digest = None
try:
import _sha256 as sha256_module
except ImportError:
sha256_module = None
def ignore_warning(func):
@functools.wraps(func)
@ -32,22 +39,27 @@ def wrapper(*args, **kwargs):
class TestVectorsTestCase(unittest.TestCase):
def asssert_hmac(
self, key, data, digest, hashfunc, hashname, digest_size, block_size
def assert_hmac_internals(
self, h, digest, hashname, digest_size, block_size
):
h = hmac.HMAC(key, data, digestmod=hashfunc)
self.assertEqual(h.hexdigest().upper(), digest.upper())
self.assertEqual(h.digest(), binascii.unhexlify(digest))
self.assertEqual(h.name, f"hmac-{hashname}")
self.assertEqual(h.digest_size, digest_size)
self.assertEqual(h.block_size, block_size)
def assert_hmac(
self, key, data, digest, hashfunc, hashname, digest_size, block_size
):
h = hmac.HMAC(key, data, digestmod=hashfunc)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
h = hmac.HMAC(key, data, digestmod=hashname)
self.assertEqual(h.hexdigest().upper(), digest.upper())
self.assertEqual(h.digest(), binascii.unhexlify(digest))
self.assertEqual(h.name, f"hmac-{hashname}")
self.assertEqual(h.digest_size, digest_size)
self.assertEqual(h.block_size, block_size)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
h = hmac.HMAC(key, digestmod=hashname)
h2 = h.copy()
@ -56,11 +68,9 @@ def asssert_hmac(
self.assertEqual(h.hexdigest().upper(), digest.upper())
h = hmac.new(key, data, digestmod=hashname)
self.assertEqual(h.hexdigest().upper(), digest.upper())
self.assertEqual(h.digest(), binascii.unhexlify(digest))
self.assertEqual(h.name, f"hmac-{hashname}")
self.assertEqual(h.digest_size, digest_size)
self.assertEqual(h.block_size, block_size)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
h = hmac.new(key, None, digestmod=hashname)
h.update(data)
@ -81,23 +91,18 @@ def asssert_hmac(
hmac.digest(key, data, digest=hashfunc),
binascii.unhexlify(digest)
)
with unittest.mock.patch('hmac._openssl_md_meths', {}):
self.assertEqual(
hmac.digest(key, data, digest=hashname),
binascii.unhexlify(digest)
)
self.assertEqual(
hmac.digest(key, data, digest=hashfunc),
binascii.unhexlify(digest)
h = hmac.HMAC.__new__(hmac.HMAC)
h._init_old(key, data, digestmod=hashname)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
if c_hmac_new is not None:
h = c_hmac_new(key, data, digestmod=hashname)
self.assertEqual(h.hexdigest().upper(), digest.upper())
self.assertEqual(h.digest(), binascii.unhexlify(digest))
self.assertEqual(h.name, f"hmac-{hashname}")
self.assertEqual(h.digest_size, digest_size)
self.assertEqual(h.block_size, block_size)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
h = c_hmac_new(key, digestmod=hashname)
h2 = h.copy()
@ -105,12 +110,24 @@ def asssert_hmac(
h.update(data)
self.assertEqual(h.hexdigest().upper(), digest.upper())
func = getattr(_hashopenssl, f"openssl_{hashname}")
h = c_hmac_new(key, data, digestmod=func)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
h = hmac.HMAC.__new__(hmac.HMAC)
h._init_hmac(key, data, digestmod=hashname)
self.assert_hmac_internals(
h, digest, hashname, digest_size, block_size
)
@hashlib_helper.requires_hashdigest('md5', openssl=True)
def test_md5_vectors(self):
# Test the HMAC module against test vectors from the RFC.
def md5test(key, data, digest):
self.asssert_hmac(
self.assert_hmac(
key, data, digest,
hashfunc=hashlib.md5,
hashname="md5",
@ -150,7 +167,7 @@ def md5test(key, data, digest):
@hashlib_helper.requires_hashdigest('sha1', openssl=True)
def test_sha_vectors(self):
def shatest(key, data, digest):
self.asssert_hmac(
self.assert_hmac(
key, data, digest,
hashfunc=hashlib.sha1,
hashname="sha1",
@ -191,7 +208,7 @@ def _rfc4231_test_cases(self, hashfunc, hash_name, digest_size, block_size):
def hmactest(key, data, hexdigests):
digest = hexdigests[hashfunc]
self.asssert_hmac(
self.assert_hmac(
key, data, digest,
hashfunc=hashfunc,
hashname=hash_name,
@ -427,6 +444,15 @@ def test_internal_types(self):
):
C_HMAC()
@unittest.skipUnless(sha256_module is not None, 'need _sha256')
def test_with_sha256_module(self):
h = hmac.HMAC(b"key", b"hash this!", digestmod=sha256_module.sha256)
self.assertEqual(h.hexdigest(), self.expected)
self.assertEqual(h.name, "hmac-sha256")
digest = hmac.digest(b"key", b"hash this!", sha256_module.sha256)
self.assertEqual(digest, binascii.unhexlify(self.expected))
class SanityTestCase(unittest.TestCase):
@ -447,21 +473,21 @@ def test_exercise_all_methods(self):
class CopyTestCase(unittest.TestCase):
@hashlib_helper.requires_hashdigest('sha256')
def test_attributes(self):
def test_attributes_old(self):
# Testing if attributes are of same type.
h1 = hmac.HMAC(b"key", digestmod="sha256")
h1 = hmac.HMAC.__new__(hmac.HMAC)
h1._init_old(b"key", b"msg", digestmod="sha256")
h2 = h1.copy()
self.assertTrue(h1._digest_cons == h2._digest_cons,
"digest constructors don't match.")
self.assertEqual(type(h1._inner), type(h2._inner),
"Types of inner don't match.")
self.assertEqual(type(h1._outer), type(h2._outer),
"Types of outer don't match.")
@hashlib_helper.requires_hashdigest('sha256')
def test_realcopy(self):
def test_realcopy_old(self):
# Testing if the copy method created a real copy.
h1 = hmac.HMAC(b"key", digestmod="sha256")
h1 = hmac.HMAC.__new__(hmac.HMAC)
h1._init_old(b"key", b"msg", digestmod="sha256")
h2 = h1.copy()
# Using id() in case somebody has overridden __eq__/__ne__.
self.assertTrue(id(h1) != id(h2), "No real copy of the HMAC instance.")
@ -469,17 +495,15 @@ def test_realcopy(self):
"No real copy of the attribute 'inner'.")
self.assertTrue(id(h1._outer) != id(h2._outer),
"No real copy of the attribute 'outer'.")
self.assertEqual(h1._inner, h1.inner)
self.assertEqual(h1._outer, h1.outer)
self.assertEqual(h1._digest_cons, h1.digest_cons)
self.assertIs(h1._hmac, None)
@unittest.skipIf(_hashopenssl is None, "test requires _hashopenssl")
@hashlib_helper.requires_hashdigest('sha256')
def test_properties(self):
# deprecated properties
h1 = hmac.HMAC(b"key", digestmod="sha256")
self.assertEqual(h1._inner, h1.inner)
self.assertEqual(h1._outer, h1.outer)
self.assertEqual(h1._digest_cons, h1.digest_cons)
def test_realcopy_hmac(self):
h1 = hmac.HMAC.__new__(hmac.HMAC)
h1._init_hmac(b"key", b"msg", digestmod="sha256")
h2 = h1.copy()
self.assertTrue(id(h1._hmac) != id(h2._hmac))
@hashlib_helper.requires_hashdigest('sha256')
def test_equality(self):

2
Misc/NEWS.d/next/Library/2021-03-19-10-22-17.bpo-40645.5pXhb-.rst Normal file
View file

@ -0,0 +1,2 @@
The :mod:`hmac` module now uses OpenSSL's HMAC implementation when digestmod
argument is a hash name or builtin hash function.

150
Modules/_hashopenssl.c
View file

@ -86,6 +86,8 @@ typedef struct {
#ifdef PY_OPENSSL_HAS_SHAKE
PyTypeObject *EVPXOFtype;
#endif
PyObject *constructs;
PyObject *unsupported_digestmod_error;
} _hashlibstate;
static inline _hashlibstate*
@ -289,9 +291,56 @@ py_digest_by_name(const char *name)
#endif
}
if (digest == NULL) {
PyErr_Format(PyExc_ValueError, "unsupported hash type %s", name);
return NULL;
}
return digest;
}
/* Get digest EVP from object
*
* * string
* * _hashopenssl builtin function
*
* on error returns NULL with exception set.
*/
static const EVP_MD*
py_digest_by_digestmod(PyObject *module, PyObject *digestmod) {
const EVP_MD* evp;
PyObject *name_obj = NULL;
const char *name;
if (PyUnicode_Check(digestmod)) {
name_obj = digestmod;
} else {
_hashlibstate *state = get_hashlib_state(module);
// borrowed ref
name_obj = PyDict_GetItem(state->constructs, digestmod);
}
if (name_obj == NULL) {
_hashlibstate *state = get_hashlib_state(module);
PyErr_Clear();
PyErr_Format(
state->unsupported_digestmod_error,
"Unsupported digestmod %R", digestmod);
return NULL;
}
name = PyUnicode_AsUTF8(name_obj);
if (name == NULL) {
return NULL;
}
evp = py_digest_by_name(name);
if (evp == NULL) {
return NULL;
}
return evp;
}
static EVPobject *
newEVPobject(PyTypeObject *type)
{
@ -829,6 +878,9 @@ EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj,
GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view);
digest = py_digest_by_name(name);
if (digest == NULL) {
return NULL;
}
ret_obj = EVPnew(module, digest,
(unsigned char*)view.buf, view.len,
@ -1124,7 +1176,6 @@ pbkdf2_hmac_impl(PyObject *module, const char *hash_name,
digest = py_digest_by_name(hash_name);
if (digest == NULL) {
PyErr_SetString(PyExc_ValueError, "unsupported hash type");
goto end;
}
@ -1328,26 +1379,26 @@ _hashlib.hmac_digest as _hashlib_hmac_singleshot
key: Py_buffer
msg: Py_buffer
digest: str
digest: object
Single-shot HMAC.
[clinic start generated code]*/
static PyObject *
_hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
Py_buffer *msg, const char *digest)
/*[clinic end generated code: output=15658ede5ab98185 input=019dffc571909a46]*/
Py_buffer *msg, PyObject *digest)
/*[clinic end generated code: output=82f19965d12706ac input=0a0790cc3db45c2e]*/
{
unsigned char md[EVP_MAX_MD_SIZE] = {0};
unsigned int md_len = 0;
unsigned char *result;
const EVP_MD *evp;
evp = py_digest_by_name(digest);
evp = py_digest_by_digestmod(module, digest);
if (evp == NULL) {
PyErr_SetString(PyExc_ValueError, "unsupported hash type");
return NULL;
}
if (key->len > INT_MAX) {
PyErr_SetString(PyExc_OverflowError,
"key is too long.");
@ -1385,15 +1436,15 @@ _hashlib.hmac_new
key: Py_buffer
msg as msg_obj: object(c_default="NULL") = b''
digestmod: str(c_default="NULL") = None
digestmod: object(c_default="NULL") = None
Return a new hmac object.
[clinic start generated code]*/
static PyObject *
_hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
const char *digestmod)
/*[clinic end generated code: output=9a35673be0cbea1b input=a0878868eb190134]*/
PyObject *digestmod)
/*[clinic end generated code: output=c20d9e4d9ed6d219 input=5f4071dcc7f34362]*/
{
PyTypeObject *type = get_hashlib_state(module)->HMACtype;
const EVP_MD *digest;
@ -1407,15 +1458,14 @@ _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
return NULL;
}
if ((digestmod == NULL) || !strlen(digestmod)) {
if (digestmod == NULL) {
PyErr_SetString(
PyExc_TypeError, "Missing required parameter 'digestmod'.");
return NULL;
}
digest = py_digest_by_name(digestmod);
if (!digest) {
PyErr_SetString(PyExc_ValueError, "unknown hash function");
digest = py_digest_by_digestmod(module, digestmod);
if (digest == NULL) {
return NULL;
}
@ -1985,6 +2035,8 @@ hashlib_traverse(PyObject *m, visitproc visit, void *arg)
#ifdef PY_OPENSSL_HAS_SHAKE
Py_VISIT(state->EVPXOFtype);
#endif
Py_VISIT(state->constructs);
Py_VISIT(state->unsupported_digestmod_error);
return 0;
}
@ -1997,6 +2049,8 @@ hashlib_clear(PyObject *m)
#ifdef PY_OPENSSL_HAS_SHAKE
Py_CLEAR(state->EVPXOFtype);
#endif
Py_CLEAR(state->constructs);
Py_CLEAR(state->unsupported_digestmod_error);
return 0;
}
@ -2071,6 +2125,74 @@ hashlib_init_hmactype(PyObject *module)
return 0;
}
static int
hashlib_init_constructors(PyObject *module)
{
/* Create dict from builtin openssl_hash functions to name
* {_hashlib.openssl_sha256: "sha256", ...}
*/
PyModuleDef *mdef;
PyMethodDef *fdef;
PyObject *proxy;
PyObject *func, *name_obj;
_hashlibstate *state = get_hashlib_state(module);
mdef = PyModule_GetDef(module);
if (mdef == NULL) {
return -1;
}
state->constructs = PyDict_New();
if (state->constructs == NULL) {
return -1;
}
for (fdef = mdef->m_methods; fdef->ml_name != NULL; fdef++) {
if (strncmp(fdef->ml_name, "openssl_", 8)) {
continue;
}
name_obj = PyUnicode_FromString(fdef->ml_name + 8);
if (name_obj == NULL) {
return -1;
}
func = PyObject_GetAttrString(module, fdef->ml_name);
if (func == NULL) {
return -1;
}
if (PyDict_SetItem(state->constructs, func, name_obj) < 0) {
return -1;
}
Py_DECREF(func);
Py_DECREF(name_obj);
}
proxy = PyDictProxy_New(state->constructs);
if (proxy == NULL) {
return -1;
}
if (PyModule_AddObjectRef(module, "_constructors", proxy) < 0) {
return -1;
}
return 0;
}
static int
hashlib_exception(PyObject *module)
{
_hashlibstate *state = get_hashlib_state(module);
state->unsupported_digestmod_error = PyErr_NewException(
"_hashlib.UnsupportedDigestmodError", PyExc_ValueError, NULL);
if (state->unsupported_digestmod_error == NULL) {
return -1;
}
if (PyModule_AddObjectRef(module, "UnsupportedDigestmodError",
state->unsupported_digestmod_error) < 0) {
return -1;
}
return 0;
}
static PyModuleDef_Slot hashlib_slots[] = {
/* OpenSSL 1.0.2 and LibreSSL */
{Py_mod_exec, hashlib_openssl_legacy_init},
@ -2078,6 +2200,8 @@ static PyModuleDef_Slot hashlib_slots[] = {
{Py_mod_exec, hashlib_init_evpxoftype},
{Py_mod_exec, hashlib_init_hmactype},
{Py_mod_exec, hashlib_md_meth_names},
{Py_mod_exec, hashlib_init_constructors},
{Py_mod_exec, hashlib_exception},
{0, NULL}
};

38
Modules/clinic/_hashopenssl.c.h generated
View file

@ -1081,7 +1081,7 @@ PyDoc_STRVAR(_hashlib_hmac_singleshot__doc__,
static PyObject *
_hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
Py_buffer *msg, const char *digest);
Py_buffer *msg, PyObject *digest);
static PyObject *
_hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
@ -1092,7 +1092,7 @@ _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nar
PyObject *argsbuf[3];
Py_buffer key = {NULL, NULL};
Py_buffer msg = {NULL, NULL};
const char *digest;
PyObject *digest;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
if (!args) {
@ -1112,19 +1112,7 @@ _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nar
_PyArg_BadArgument("hmac_digest", "argument 'msg'", "contiguous buffer", args[1]);
goto exit;
}
if (!PyUnicode_Check(args[2])) {
_PyArg_BadArgument("hmac_digest", "argument 'digest'", "str", args[2]);
goto exit;
}
Py_ssize_t digest_length;
digest = PyUnicode_AsUTF8AndSize(args[2], &digest_length);
if (digest == NULL) {
goto exit;
}
if (strlen(digest) != (size_t)digest_length) {
PyErr_SetString(PyExc_ValueError, "embedded null character");
goto exit;
}
digest = args[2];
return_value = _hashlib_hmac_singleshot_impl(module, &key, &msg, digest);
exit:
@ -1151,7 +1139,7 @@ PyDoc_STRVAR(_hashlib_hmac_new__doc__,
static PyObject *
_hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
const char *digestmod);
PyObject *digestmod);
static PyObject *
_hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
@ -1163,7 +1151,7 @@ _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyO
Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
Py_buffer key = {NULL, NULL};
PyObject *msg_obj = NULL;
const char *digestmod = NULL;
PyObject *digestmod = NULL;
args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
if (!args) {
@ -1185,19 +1173,7 @@ _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyO
goto skip_optional_pos;
}
}
if (!PyUnicode_Check(args[2])) {
_PyArg_BadArgument("hmac_new", "argument 'digestmod'", "str", args[2]);
goto exit;
}
Py_ssize_t digestmod_length;
digestmod = PyUnicode_AsUTF8AndSize(args[2], &digestmod_length);
if (digestmod == NULL) {
goto exit;
}
if (strlen(digestmod) != (size_t)digestmod_length) {
PyErr_SetString(PyExc_ValueError, "embedded null character");
goto exit;
}
digestmod = args[2];
skip_optional_pos:
return_value = _hashlib_hmac_new_impl(module, &key, msg_obj, digestmod);
@ -1417,4 +1393,4 @@ exit:
#ifndef _HASHLIB_GET_FIPS_MODE_METHODDEF
#define _HASHLIB_GET_FIPS_MODE_METHODDEF
#endif /* !defined(_HASHLIB_GET_FIPS_MODE_METHODDEF) */
/*[clinic end generated code: output=2bbd6159493f44ea input=a9049054013a1b77]*/
/*[clinic end generated code: output=980087de1b03ad42 input=a9049054013a1b77]*/