Branch data Line data Source code
1 : : /* Module that wraps all OpenSSL hash algorithms */
2 : :
3 : : /*
4 : : * Copyright (C) 2005-2010 Gregory P. Smith (greg@krypto.org)
5 : : * Licensed to PSF under a Contributor Agreement.
6 : : *
7 : : * Derived from a skeleton of shamodule.c containing work performed by:
8 : : *
9 : : * Andrew Kuchling (amk@amk.ca)
10 : : * Greg Stein (gstein@lyra.org)
11 : : *
12 : : */
13 : :
14 : : /* Don't warn about deprecated functions, */
15 : : #ifndef OPENSSL_API_COMPAT
16 : : // 0x10101000L == 1.1.1, 30000 == 3.0.0
17 : : #define OPENSSL_API_COMPAT 0x10101000L
18 : : #endif
19 : : #define OPENSSL_NO_DEPRECATED 1
20 : :
21 : : #ifndef Py_BUILD_CORE_BUILTIN
22 : : # define Py_BUILD_CORE_MODULE 1
23 : : #endif
24 : :
25 : : #define PY_SSIZE_T_CLEAN
26 : :
27 : : #include "Python.h"
28 : : #include "pycore_hashtable.h"
29 : : #include "hashlib.h"
30 : : #include "pycore_strhex.h" // _Py_strhex()
31 : :
32 : : /* EVP is the preferred interface to hashing in OpenSSL */
33 : : #include <openssl/evp.h>
34 : : #include <openssl/hmac.h>
35 : : #include <openssl/crypto.h>
36 : : /* We use the object interface to discover what hashes OpenSSL supports. */
37 : : #include <openssl/objects.h>
38 : : #include <openssl/err.h>
39 : :
40 : : #include <openssl/crypto.h> // FIPS_mode()
41 : :
42 : : #ifndef OPENSSL_THREADS
43 : : # error "OPENSSL_THREADS is not defined, Python requires thread-safe OpenSSL"
44 : : #endif
45 : :
46 : : #define MUNCH_SIZE INT_MAX
47 : :
48 : : #define PY_OPENSSL_HAS_SCRYPT 1
49 : : #define PY_OPENSSL_HAS_SHA3 1
50 : : #define PY_OPENSSL_HAS_SHAKE 1
51 : : #define PY_OPENSSL_HAS_BLAKE2 1
52 : :
53 : : #if OPENSSL_VERSION_NUMBER >= 0x30000000L
54 : : #define PY_EVP_MD EVP_MD
55 : : #define PY_EVP_MD_fetch(algorithm, properties) EVP_MD_fetch(NULL, algorithm, properties)
56 : : #define PY_EVP_MD_up_ref(md) EVP_MD_up_ref(md)
57 : : #define PY_EVP_MD_free(md) EVP_MD_free(md)
58 : : #else
59 : : #define PY_EVP_MD const EVP_MD
60 : : #define PY_EVP_MD_fetch(algorithm, properties) EVP_get_digestbyname(algorithm)
61 : : #define PY_EVP_MD_up_ref(md) do {} while(0)
62 : : #define PY_EVP_MD_free(md) do {} while(0)
63 : : #endif
64 : :
65 : : /* hash alias map and fast lookup
66 : : *
67 : : * Map between Python's preferred names and OpenSSL internal names. Maintain
68 : : * cache of fetched EVP MD objects. The EVP_get_digestbyname() and
69 : : * EVP_MD_fetch() API calls have a performance impact.
70 : : *
71 : : * The py_hashentry_t items are stored in a _Py_hashtable_t with py_name and
72 : : * py_alias as keys.
73 : : */
74 : :
75 : : enum Py_hash_type {
76 : : Py_ht_evp, // usedforsecurity=True / default
77 : : Py_ht_evp_nosecurity, // usedforsecurity=False
78 : : Py_ht_mac, // HMAC
79 : : Py_ht_pbkdf2, // PKBDF2
80 : : };
81 : :
82 : : typedef struct {
83 : : const char *py_name;
84 : : const char *py_alias;
85 : : const char *ossl_name;
86 : : int ossl_nid;
87 : : int refcnt;
88 : : PY_EVP_MD *evp;
89 : : PY_EVP_MD *evp_nosecurity;
90 : : } py_hashentry_t;
91 : :
92 : : #define Py_hash_md5 "md5"
93 : : #define Py_hash_sha1 "sha1"
94 : : #define Py_hash_sha224 "sha224"
95 : : #define Py_hash_sha256 "sha256"
96 : : #define Py_hash_sha384 "sha384"
97 : : #define Py_hash_sha512 "sha512"
98 : : #define Py_hash_sha512_224 "sha512_224"
99 : : #define Py_hash_sha512_256 "sha512_256"
100 : : #define Py_hash_sha3_224 "sha3_224"
101 : : #define Py_hash_sha3_256 "sha3_256"
102 : : #define Py_hash_sha3_384 "sha3_384"
103 : : #define Py_hash_sha3_512 "sha3_512"
104 : : #define Py_hash_shake_128 "shake_128"
105 : : #define Py_hash_shake_256 "shake_256"
106 : : #define Py_hash_blake2s "blake2s"
107 : : #define Py_hash_blake2b "blake2b"
108 : :
109 : : #define PY_HASH_ENTRY(py_name, py_alias, ossl_name, ossl_nid) \
110 : : {py_name, py_alias, ossl_name, ossl_nid, 0, NULL, NULL}
111 : :
112 : : static const py_hashentry_t py_hashes[] = {
113 : : /* md5 */
114 : : PY_HASH_ENTRY(Py_hash_md5, "MD5", SN_md5, NID_md5),
115 : : /* sha1 */
116 : : PY_HASH_ENTRY(Py_hash_sha1, "SHA1", SN_sha1, NID_sha1),
117 : : /* sha2 family */
118 : : PY_HASH_ENTRY(Py_hash_sha224, "SHA224", SN_sha224, NID_sha224),
119 : : PY_HASH_ENTRY(Py_hash_sha256, "SHA256", SN_sha256, NID_sha256),
120 : : PY_HASH_ENTRY(Py_hash_sha384, "SHA384", SN_sha384, NID_sha384),
121 : : PY_HASH_ENTRY(Py_hash_sha512, "SHA512", SN_sha512, NID_sha512),
122 : : /* truncated sha2 */
123 : : PY_HASH_ENTRY(Py_hash_sha512_224, "SHA512_224", SN_sha512_224, NID_sha512_224),
124 : : PY_HASH_ENTRY(Py_hash_sha512_256, "SHA512_256", SN_sha512_256, NID_sha512_256),
125 : : /* sha3 */
126 : : PY_HASH_ENTRY(Py_hash_sha3_224, NULL, SN_sha3_224, NID_sha3_224),
127 : : PY_HASH_ENTRY(Py_hash_sha3_256, NULL, SN_sha3_256, NID_sha3_256),
128 : : PY_HASH_ENTRY(Py_hash_sha3_384, NULL, SN_sha3_384, NID_sha3_384),
129 : : PY_HASH_ENTRY(Py_hash_sha3_512, NULL, SN_sha3_512, NID_sha3_512),
130 : : /* sha3 shake */
131 : : PY_HASH_ENTRY(Py_hash_shake_128, NULL, SN_shake128, NID_shake128),
132 : : PY_HASH_ENTRY(Py_hash_shake_256, NULL, SN_shake256, NID_shake256),
133 : : /* blake2 digest */
134 : : PY_HASH_ENTRY(Py_hash_blake2s, "blake2s256", SN_blake2s256, NID_blake2s256),
135 : : PY_HASH_ENTRY(Py_hash_blake2b, "blake2b512", SN_blake2b512, NID_blake2b512),
136 : : PY_HASH_ENTRY(NULL, NULL, NULL, 0),
137 : : };
138 : :
139 : : static Py_uhash_t
140 : 36316 : py_hashentry_t_hash_name(const void *key) {
141 : 36316 : return _Py_HashBytes(key, strlen((const char *)key));
142 : : }
143 : :
144 : : static int
145 : 25340 : py_hashentry_t_compare_name(const void *key1, const void *key2) {
146 : 25340 : return strcmp((const char *)key1, (const char *)key2) == 0;
147 : : }
148 : :
149 : : static void
150 : 10972 : py_hashentry_t_destroy_value(void *entry) {
151 : 10972 : py_hashentry_t *h = (py_hashentry_t *)entry;
152 [ + + ]: 10972 : if (--(h->refcnt) == 0) {
153 [ + + ]: 6752 : if (h->evp != NULL) {
154 : 176 : PY_EVP_MD_free(h->evp);
155 : 176 : h->evp = NULL;
156 : : }
157 [ + + ]: 6752 : if (h->evp_nosecurity != NULL) {
158 : 5054 : PY_EVP_MD_free(h->evp_nosecurity);
159 : 5054 : h->evp_nosecurity = NULL;
160 : : }
161 : 6752 : PyMem_Free(entry);
162 : : }
163 : 10972 : }
164 : :
165 : : static _Py_hashtable_t *
166 : 422 : py_hashentry_table_new(void) {
167 : 422 : _Py_hashtable_t *ht = _Py_hashtable_new_full(
168 : : py_hashentry_t_hash_name,
169 : : py_hashentry_t_compare_name,
170 : : NULL,
171 : : py_hashentry_t_destroy_value,
172 : : NULL
173 : : );
174 [ - + ]: 422 : if (ht == NULL) {
175 : 0 : return NULL;
176 : : }
177 : :
178 [ + + ]: 7174 : for (const py_hashentry_t *h = py_hashes; h->py_name != NULL; h++) {
179 : 6752 : py_hashentry_t *entry = (py_hashentry_t *)PyMem_Malloc(sizeof(py_hashentry_t));
180 [ - + ]: 6752 : if (entry == NULL) {
181 : 0 : goto error;
182 : : }
183 : 6752 : memcpy(entry, h, sizeof(py_hashentry_t));
184 : :
185 [ - + ]: 6752 : if (_Py_hashtable_set(ht, (const void*)entry->py_name, (void*)entry) < 0) {
186 : 0 : PyMem_Free(entry);
187 : 0 : goto error;
188 : : }
189 : 6752 : entry->refcnt = 1;
190 : :
191 [ + + ]: 6752 : if (h->py_alias != NULL) {
192 [ - + ]: 4220 : if (_Py_hashtable_set(ht, (const void*)entry->py_alias, (void*)entry) < 0) {
193 : 0 : PyMem_Free(entry);
194 : 0 : goto error;
195 : : }
196 : 4220 : entry->refcnt++;
197 : : }
198 : : }
199 : :
200 : 422 : return ht;
201 : 0 : error:
202 : 0 : _Py_hashtable_destroy(ht);
203 : 0 : return NULL;
204 : : }
205 : :
206 : : /* Module state */
207 : : static PyModuleDef _hashlibmodule;
208 : :
209 : : typedef struct {
210 : : PyTypeObject *EVPtype;
211 : : PyTypeObject *HMACtype;
212 : : #ifdef PY_OPENSSL_HAS_SHAKE
213 : : PyTypeObject *EVPXOFtype;
214 : : #endif
215 : : PyObject *constructs;
216 : : PyObject *unsupported_digestmod_error;
217 : : _Py_hashtable_t *hashtable;
218 : : } _hashlibstate;
219 : :
220 : : static inline _hashlibstate*
221 : 59995 : get_hashlib_state(PyObject *module)
222 : : {
223 : 59995 : void *state = PyModule_GetState(module);
224 : : assert(state != NULL);
225 : 59995 : return (_hashlibstate *)state;
226 : : }
227 : :
228 : : typedef struct {
229 : : PyObject_HEAD
230 : : EVP_MD_CTX *ctx; /* OpenSSL message digest context */
231 : : PyThread_type_lock lock; /* OpenSSL context lock */
232 : : } EVPobject;
233 : :
234 : : typedef struct {
235 : : PyObject_HEAD
236 : : HMAC_CTX *ctx; /* OpenSSL hmac context */
237 : : PyThread_type_lock lock; /* HMAC context lock */
238 : : } HMACobject;
239 : :
240 : : #include "clinic/_hashopenssl.c.h"
241 : : /*[clinic input]
242 : : module _hashlib
243 : : class _hashlib.HASH "EVPobject *" "((_hashlibstate *)PyModule_GetState(module))->EVPtype"
244 : : class _hashlib.HASHXOF "EVPobject *" "((_hashlibstate *)PyModule_GetState(module))->EVPXOFtype"
245 : : class _hashlib.HMAC "HMACobject *" "((_hashlibstate *)PyModule_GetState(module))->HMACtype"
246 : : [clinic start generated code]*/
247 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=7df1bcf6f75cb8ef]*/
248 : :
249 : :
250 : : /* LCOV_EXCL_START */
251 : : static PyObject *
252 : : _setException(PyObject *exc, const char* altmsg, ...)
253 : : {
254 : : unsigned long errcode = ERR_peek_last_error();
255 : : const char *lib, *func, *reason;
256 : : va_list vargs;
257 : :
258 : : va_start(vargs, altmsg);
259 : : if (!errcode) {
260 : : if (altmsg == NULL) {
261 : : PyErr_SetString(exc, "no reason supplied");
262 : : } else {
263 : : PyErr_FormatV(exc, altmsg, vargs);
264 : : }
265 : : va_end(vargs);
266 : : return NULL;
267 : : }
268 : : va_end(vargs);
269 : : ERR_clear_error();
270 : :
271 : : lib = ERR_lib_error_string(errcode);
272 : : func = ERR_func_error_string(errcode);
273 : : reason = ERR_reason_error_string(errcode);
274 : :
275 : : if (lib && func) {
276 : : PyErr_Format(exc, "[%s: %s] %s", lib, func, reason);
277 : : }
278 : : else if (lib) {
279 : : PyErr_Format(exc, "[%s] %s", lib, reason);
280 : : }
281 : : else {
282 : : PyErr_SetString(exc, reason);
283 : : }
284 : : return NULL;
285 : : }
286 : : /* LCOV_EXCL_STOP */
287 : :
288 : : static PyObject*
289 : 8165 : py_digest_name(const EVP_MD *md)
290 : : {
291 : 8165 : int nid = EVP_MD_nid(md);
292 : 8165 : const char *name = NULL;
293 : : const py_hashentry_t *h;
294 : :
295 [ + + ]: 74905 : for (h = py_hashes; h->py_name != NULL; h++) {
296 [ + + ]: 74061 : if (h->ossl_nid == nid) {
297 : 7321 : name = h->py_name;
298 : 7321 : break;
299 : : }
300 : : }
301 [ + + ]: 8165 : if (name == NULL) {
302 : : /* Ignore aliased names and only use long, lowercase name. The aliases
303 : : * pollute the list and OpenSSL appears to have its own definition of
304 : : * alias as the resulting list still contains duplicate and alternate
305 : : * names for several algorithms.
306 : : */
307 : 844 : name = OBJ_nid2ln(nid);
308 [ - + ]: 844 : if (name == NULL)
309 : 0 : name = OBJ_nid2sn(nid);
310 : : }
311 : :
312 : 8165 : return PyUnicode_FromString(name);
313 : : }
314 : :
315 : : /* Get EVP_MD by HID and purpose */
316 : : static PY_EVP_MD*
317 : 25344 : py_digest_by_name(PyObject *module, const char *name, enum Py_hash_type py_ht)
318 : : {
319 : 25344 : PY_EVP_MD *digest = NULL;
320 : 25344 : _hashlibstate *state = get_hashlib_state(module);
321 : 25344 : py_hashentry_t *entry = (py_hashentry_t *)_Py_hashtable_get(
322 : : state->hashtable, (const void*)name
323 : : );
324 : :
325 [ + + ]: 25344 : if (entry != NULL) {
326 [ + + - ]: 25340 : switch (py_ht) {
327 : 19907 : case Py_ht_evp:
328 : : case Py_ht_mac:
329 : : case Py_ht_pbkdf2:
330 [ + + ]: 19907 : if (entry->evp == NULL) {
331 : 176 : entry->evp = PY_EVP_MD_fetch(entry->ossl_name, NULL);
332 : : }
333 : 19907 : digest = entry->evp;
334 : 19907 : break;
335 : 5433 : case Py_ht_evp_nosecurity:
336 [ + + ]: 5433 : if (entry->evp_nosecurity == NULL) {
337 : 5054 : entry->evp_nosecurity = PY_EVP_MD_fetch(entry->ossl_name, "-fips");
338 : : }
339 : 5433 : digest = entry->evp_nosecurity;
340 : 5433 : break;
341 : : }
342 [ + - ]: 25340 : if (digest != NULL) {
343 : 25340 : PY_EVP_MD_up_ref(digest);
344 : : }
345 : : } else {
346 : : // Fall back for looking up an unindexed OpenSSL specific name.
347 [ + + - ]: 4 : switch (py_ht) {
348 : 2 : case Py_ht_evp:
349 : : case Py_ht_mac:
350 : : case Py_ht_pbkdf2:
351 : 2 : digest = PY_EVP_MD_fetch(name, NULL);
352 : 2 : break;
353 : 2 : case Py_ht_evp_nosecurity:
354 : 2 : digest = PY_EVP_MD_fetch(name, "-fips");
355 : 2 : break;
356 : : }
357 : : }
358 [ + + ]: 25344 : if (digest == NULL) {
359 : 2 : _setException(PyExc_ValueError, "unsupported hash type %s", name);
360 : 2 : return NULL;
361 : : }
362 : 25342 : return digest;
363 : : }
364 : :
365 : : /* Get digest EVP from object
366 : : *
367 : : * * string
368 : : * * _hashopenssl builtin function
369 : : *
370 : : * on error returns NULL with exception set.
371 : : */
372 : : static PY_EVP_MD*
373 : 7821 : py_digest_by_digestmod(PyObject *module, PyObject *digestmod, enum Py_hash_type py_ht) {
374 : : PY_EVP_MD* evp;
375 : 7821 : PyObject *name_obj = NULL;
376 : : const char *name;
377 : :
378 [ + + ]: 7821 : if (PyUnicode_Check(digestmod)) {
379 : 7666 : name_obj = digestmod;
380 : : } else {
381 : 155 : _hashlibstate *state = get_hashlib_state(module);
382 : : // borrowed ref
383 : 155 : name_obj = PyDict_GetItem(state->constructs, digestmod);
384 : : }
385 [ + + ]: 7821 : if (name_obj == NULL) {
386 : 2 : _hashlibstate *state = get_hashlib_state(module);
387 : 2 : PyErr_Clear();
388 : 2 : PyErr_Format(
389 : : state->unsupported_digestmod_error,
390 : : "Unsupported digestmod %R", digestmod);
391 : 2 : return NULL;
392 : : }
393 : :
394 : 7819 : name = PyUnicode_AsUTF8(name_obj);
395 [ - + ]: 7819 : if (name == NULL) {
396 : 0 : return NULL;
397 : : }
398 : :
399 : 7819 : evp = py_digest_by_name(module, name, py_ht);
400 [ - + ]: 7819 : if (evp == NULL) {
401 : 0 : return NULL;
402 : : }
403 : :
404 : 7819 : return evp;
405 : : }
406 : :
407 : : static EVPobject *
408 : 17568 : newEVPobject(PyTypeObject *type)
409 : : {
410 : 17568 : EVPobject *retval = (EVPobject *)PyObject_New(EVPobject, type);
411 [ - + ]: 17568 : if (retval == NULL) {
412 : 0 : return NULL;
413 : : }
414 : :
415 : 17568 : retval->lock = NULL;
416 : :
417 : 17568 : retval->ctx = EVP_MD_CTX_new();
418 [ - + ]: 17568 : if (retval->ctx == NULL) {
419 : 0 : Py_DECREF(retval);
420 : : PyErr_NoMemory();
421 : 0 : return NULL;
422 : : }
423 : :
424 : 17568 : return retval;
425 : : }
426 : :
427 : : static int
428 : 2249669 : EVP_hash(EVPobject *self, const void *vp, Py_ssize_t len)
429 : : {
430 : : unsigned int process;
431 : 2249669 : const unsigned char *cp = (const unsigned char *)vp;
432 [ + + ]: 4499296 : while (0 < len) {
433 [ - + ]: 2249627 : if (len > (Py_ssize_t)MUNCH_SIZE)
434 : 0 : process = MUNCH_SIZE;
435 : : else
436 : 2249627 : process = Py_SAFE_DOWNCAST(len, Py_ssize_t, unsigned int);
437 [ - + ]: 2249627 : if (!EVP_DigestUpdate(self->ctx, (const void*)cp, process)) {
438 : 0 : _setException(PyExc_ValueError, NULL);
439 : 0 : return -1;
440 : : }
441 : 2249627 : len -= process;
442 : 2249627 : cp += process;
443 : : }
444 : 2249669 : return 0;
445 : : }
446 : :
447 : : /* Internal methods for a hash object */
448 : :
449 : : static void
450 : 17568 : EVP_dealloc(EVPobject *self)
451 : : {
452 : 17568 : PyTypeObject *tp = Py_TYPE(self);
453 [ + + ]: 17568 : if (self->lock != NULL)
454 : 130 : PyThread_free_lock(self->lock);
455 : 17568 : EVP_MD_CTX_free(self->ctx);
456 : 17568 : PyObject_Free(self);
457 : 17568 : Py_DECREF(tp);
458 : 17568 : }
459 : :
460 : : static int
461 : 13568 : locked_EVP_MD_CTX_copy(EVP_MD_CTX *new_ctx_p, EVPobject *self)
462 : : {
463 : : int result;
464 [ + + - + ]: 13568 : ENTER_HASHLIB(self);
465 : 13568 : result = EVP_MD_CTX_copy(new_ctx_p, self->ctx);
466 [ + + ]: 13568 : LEAVE_HASHLIB(self);
467 : 13568 : return result;
468 : : }
469 : :
470 : : /* External methods for a hash object */
471 : :
472 : : /*[clinic input]
473 : : _hashlib.HASH.copy as EVP_copy
474 : :
475 : : Return a copy of the hash object.
476 : : [clinic start generated code]*/
477 : :
478 : : static PyObject *
479 : 104 : EVP_copy_impl(EVPobject *self)
480 : : /*[clinic end generated code: output=b370c21cdb8ca0b4 input=31455b6a3e638069]*/
481 : : {
482 : : EVPobject *newobj;
483 : :
484 [ - + ]: 104 : if ((newobj = newEVPobject(Py_TYPE(self))) == NULL)
485 : 0 : return NULL;
486 : :
487 [ - + ]: 104 : if (!locked_EVP_MD_CTX_copy(newobj->ctx, self)) {
488 : 0 : Py_DECREF(newobj);
489 : 0 : return _setException(PyExc_ValueError, NULL);
490 : : }
491 : 104 : return (PyObject *)newobj;
492 : : }
493 : :
494 : : /*[clinic input]
495 : : _hashlib.HASH.digest as EVP_digest
496 : :
497 : : Return the digest value as a bytes object.
498 : : [clinic start generated code]*/
499 : :
500 : : static PyObject *
501 : 2492 : EVP_digest_impl(EVPobject *self)
502 : : /*[clinic end generated code: output=0f6a3a0da46dc12d input=03561809a419bf00]*/
503 : : {
504 : : unsigned char digest[EVP_MAX_MD_SIZE];
505 : : EVP_MD_CTX *temp_ctx;
506 : : PyObject *retval;
507 : : unsigned int digest_size;
508 : :
509 : 2492 : temp_ctx = EVP_MD_CTX_new();
510 [ - + ]: 2492 : if (temp_ctx == NULL) {
511 : : PyErr_NoMemory();
512 : 0 : return NULL;
513 : : }
514 : :
515 [ - + ]: 2492 : if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {
516 : 0 : return _setException(PyExc_ValueError, NULL);
517 : : }
518 : 2492 : digest_size = EVP_MD_CTX_size(temp_ctx);
519 [ - + ]: 2492 : if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {
520 : 0 : _setException(PyExc_ValueError, NULL);
521 : 0 : return NULL;
522 : : }
523 : :
524 : 2492 : retval = PyBytes_FromStringAndSize((const char *)digest, digest_size);
525 : 2492 : EVP_MD_CTX_free(temp_ctx);
526 : 2492 : return retval;
527 : : }
528 : :
529 : : /*[clinic input]
530 : : _hashlib.HASH.hexdigest as EVP_hexdigest
531 : :
532 : : Return the digest value as a string of hexadecimal digits.
533 : : [clinic start generated code]*/
534 : :
535 : : static PyObject *
536 : 8852 : EVP_hexdigest_impl(EVPobject *self)
537 : : /*[clinic end generated code: output=18e6decbaf197296 input=aff9cf0e4c741a9a]*/
538 : : {
539 : : unsigned char digest[EVP_MAX_MD_SIZE];
540 : : EVP_MD_CTX *temp_ctx;
541 : : unsigned int digest_size;
542 : :
543 : 8852 : temp_ctx = EVP_MD_CTX_new();
544 [ - + ]: 8852 : if (temp_ctx == NULL) {
545 : : PyErr_NoMemory();
546 : 0 : return NULL;
547 : : }
548 : :
549 : : /* Get the raw (binary) digest value */
550 [ - + ]: 8852 : if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {
551 : 0 : return _setException(PyExc_ValueError, NULL);
552 : : }
553 : 8852 : digest_size = EVP_MD_CTX_size(temp_ctx);
554 [ - + ]: 8852 : if (!EVP_DigestFinal(temp_ctx, digest, NULL)) {
555 : 0 : _setException(PyExc_ValueError, NULL);
556 : 0 : return NULL;
557 : : }
558 : :
559 : 8852 : EVP_MD_CTX_free(temp_ctx);
560 : :
561 : 8852 : return _Py_strhex((const char *)digest, (Py_ssize_t)digest_size);
562 : : }
563 : :
564 : : /*[clinic input]
565 : : _hashlib.HASH.update as EVP_update
566 : :
567 : : obj: object
568 : : /
569 : :
570 : : Update this hash object's state with the provided string.
571 : : [clinic start generated code]*/
572 : :
573 : : static PyObject *
574 : 2246122 : EVP_update(EVPobject *self, PyObject *obj)
575 : : /*[clinic end generated code: output=ec1d55ed2432e966 input=9b30ec848f015501]*/
576 : : {
577 : : int result;
578 : : Py_buffer view;
579 : :
580 [ - + - + : 2246122 : GET_BUFFER_VIEW_OR_ERROUT(obj, &view);
- + - + ]
581 : :
582 [ + + + + ]: 2246122 : if (self->lock == NULL && view.len >= HASHLIB_GIL_MINSIZE) {
583 : 130 : self->lock = PyThread_allocate_lock();
584 : : /* fail? lock = NULL and we fail over to non-threaded code. */
585 : : }
586 : :
587 [ + + ]: 2246122 : if (self->lock != NULL) {
588 : 11321 : Py_BEGIN_ALLOW_THREADS
589 : 11321 : PyThread_acquire_lock(self->lock, 1);
590 : 11321 : result = EVP_hash(self, view.buf, view.len);
591 : 11321 : PyThread_release_lock(self->lock);
592 : 11321 : Py_END_ALLOW_THREADS
593 : : } else {
594 : 2234801 : result = EVP_hash(self, view.buf, view.len);
595 : : }
596 : :
597 : 2246122 : PyBuffer_Release(&view);
598 : :
599 [ - + ]: 2246122 : if (result == -1)
600 : 0 : return NULL;
601 : 2246122 : Py_RETURN_NONE;
602 : : }
603 : :
604 : : static PyMethodDef EVP_methods[] = {
605 : : EVP_UPDATE_METHODDEF
606 : : EVP_DIGEST_METHODDEF
607 : : EVP_HEXDIGEST_METHODDEF
608 : : EVP_COPY_METHODDEF
609 : : {NULL, NULL} /* sentinel */
610 : : };
611 : :
612 : : static PyObject *
613 : 104 : EVP_get_block_size(EVPobject *self, void *closure)
614 : : {
615 : : long block_size;
616 : 104 : block_size = EVP_MD_CTX_block_size(self->ctx);
617 : 104 : return PyLong_FromLong(block_size);
618 : : }
619 : :
620 : : static PyObject *
621 : 2166 : EVP_get_digest_size(EVPobject *self, void *closure)
622 : : {
623 : : long size;
624 : 2166 : size = EVP_MD_CTX_size(self->ctx);
625 : 2166 : return PyLong_FromLong(size);
626 : : }
627 : :
628 : : static PyObject *
629 : 317 : EVP_get_name(EVPobject *self, void *closure)
630 : : {
631 : 317 : return py_digest_name(EVP_MD_CTX_md(self->ctx));
632 : : }
633 : :
634 : : static PyGetSetDef EVP_getseters[] = {
635 : : {"digest_size",
636 : : (getter)EVP_get_digest_size, NULL,
637 : : NULL,
638 : : NULL},
639 : : {"block_size",
640 : : (getter)EVP_get_block_size, NULL,
641 : : NULL,
642 : : NULL},
643 : : {"name",
644 : : (getter)EVP_get_name, NULL,
645 : : NULL,
646 : : PyDoc_STR("algorithm name.")},
647 : : {NULL} /* Sentinel */
648 : : };
649 : :
650 : :
651 : : static PyObject *
652 : 24 : EVP_repr(EVPobject *self)
653 : : {
654 : : PyObject *name_obj, *repr;
655 : 24 : name_obj = py_digest_name(EVP_MD_CTX_md(self->ctx));
656 [ - + ]: 24 : if (!name_obj) {
657 : 0 : return NULL;
658 : : }
659 : 24 : repr = PyUnicode_FromFormat("<%U %s object @ %p>",
660 : 24 : name_obj, Py_TYPE(self)->tp_name, self);
661 : 24 : Py_DECREF(name_obj);
662 : 24 : return repr;
663 : : }
664 : :
665 : : PyDoc_STRVAR(hashtype_doc,
666 : : "HASH(name, string=b\'\')\n"
667 : : "--\n"
668 : : "\n"
669 : : "A hash is an object used to calculate a checksum of a string of information.\n"
670 : : "\n"
671 : : "Methods:\n"
672 : : "\n"
673 : : "update() -- updates the current digest with an additional string\n"
674 : : "digest() -- return the current digest value\n"
675 : : "hexdigest() -- return the current digest as a string of hexadecimal digits\n"
676 : : "copy() -- return a copy of the current hash object\n"
677 : : "\n"
678 : : "Attributes:\n"
679 : : "\n"
680 : : "name -- the hash algorithm being used by this object\n"
681 : : "digest_size -- number of bytes in this hashes output");
682 : :
683 : : static PyType_Slot EVPtype_slots[] = {
684 : : {Py_tp_dealloc, EVP_dealloc},
685 : : {Py_tp_repr, EVP_repr},
686 : : {Py_tp_doc, (char *)hashtype_doc},
687 : : {Py_tp_methods, EVP_methods},
688 : : {Py_tp_getset, EVP_getseters},
689 : : {0, 0},
690 : : };
691 : :
692 : : static PyType_Spec EVPtype_spec = {
693 : : "_hashlib.HASH", /*tp_name*/
694 : : sizeof(EVPobject), /*tp_basicsize*/
695 : : 0, /*tp_itemsize*/
696 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
697 : : EVPtype_slots
698 : : };
699 : :
700 : : #ifdef PY_OPENSSL_HAS_SHAKE
701 : :
702 : : /*[clinic input]
703 : : _hashlib.HASHXOF.digest as EVPXOF_digest
704 : :
705 : : length: Py_ssize_t
706 : :
707 : : Return the digest value as a bytes object.
708 : : [clinic start generated code]*/
709 : :
710 : : static PyObject *
711 : 1076 : EVPXOF_digest_impl(EVPobject *self, Py_ssize_t length)
712 : : /*[clinic end generated code: output=ef9320c23280efad input=816a6537cea3d1db]*/
713 : : {
714 : : EVP_MD_CTX *temp_ctx;
715 : 1076 : PyObject *retval = PyBytes_FromStringAndSize(NULL, length);
716 : :
717 [ - + ]: 1076 : if (retval == NULL) {
718 : 0 : return NULL;
719 : : }
720 : :
721 : 1076 : temp_ctx = EVP_MD_CTX_new();
722 [ - + ]: 1076 : if (temp_ctx == NULL) {
723 : 0 : Py_DECREF(retval);
724 : : PyErr_NoMemory();
725 : 0 : return NULL;
726 : : }
727 : :
728 [ - + ]: 1076 : if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {
729 : 0 : Py_DECREF(retval);
730 : 0 : EVP_MD_CTX_free(temp_ctx);
731 : 0 : return _setException(PyExc_ValueError, NULL);
732 : : }
733 [ - + ]: 1076 : if (!EVP_DigestFinalXOF(temp_ctx,
734 : 1076 : (unsigned char*)PyBytes_AS_STRING(retval),
735 : : length)) {
736 : 0 : Py_DECREF(retval);
737 : 0 : EVP_MD_CTX_free(temp_ctx);
738 : 0 : _setException(PyExc_ValueError, NULL);
739 : 0 : return NULL;
740 : : }
741 : :
742 : 1076 : EVP_MD_CTX_free(temp_ctx);
743 : 1076 : return retval;
744 : : }
745 : :
746 : : /*[clinic input]
747 : : _hashlib.HASHXOF.hexdigest as EVPXOF_hexdigest
748 : :
749 : : length: Py_ssize_t
750 : :
751 : : Return the digest value as a string of hexadecimal digits.
752 : : [clinic start generated code]*/
753 : :
754 : : static PyObject *
755 : 1044 : EVPXOF_hexdigest_impl(EVPobject *self, Py_ssize_t length)
756 : : /*[clinic end generated code: output=eb3e6ee7788bf5b2 input=5f9d6a8f269e34df]*/
757 : : {
758 : : unsigned char *digest;
759 : : EVP_MD_CTX *temp_ctx;
760 : : PyObject *retval;
761 : :
762 : 1044 : digest = (unsigned char*)PyMem_Malloc(length);
763 [ - + ]: 1044 : if (digest == NULL) {
764 : : PyErr_NoMemory();
765 : 0 : return NULL;
766 : : }
767 : :
768 : 1044 : temp_ctx = EVP_MD_CTX_new();
769 [ - + ]: 1044 : if (temp_ctx == NULL) {
770 : 0 : PyMem_Free(digest);
771 : : PyErr_NoMemory();
772 : 0 : return NULL;
773 : : }
774 : :
775 : : /* Get the raw (binary) digest value */
776 [ - + ]: 1044 : if (!locked_EVP_MD_CTX_copy(temp_ctx, self)) {
777 : 0 : PyMem_Free(digest);
778 : 0 : EVP_MD_CTX_free(temp_ctx);
779 : 0 : return _setException(PyExc_ValueError, NULL);
780 : : }
781 [ - + ]: 1044 : if (!EVP_DigestFinalXOF(temp_ctx, digest, length)) {
782 : 0 : PyMem_Free(digest);
783 : 0 : EVP_MD_CTX_free(temp_ctx);
784 : 0 : _setException(PyExc_ValueError, NULL);
785 : 0 : return NULL;
786 : : }
787 : :
788 : 1044 : EVP_MD_CTX_free(temp_ctx);
789 : :
790 : 1044 : retval = _Py_strhex((const char *)digest, length);
791 : 1044 : PyMem_Free(digest);
792 : 1044 : return retval;
793 : : }
794 : :
795 : : static PyMethodDef EVPXOF_methods[] = {
796 : : EVPXOF_DIGEST_METHODDEF
797 : : EVPXOF_HEXDIGEST_METHODDEF
798 : : {NULL, NULL} /* sentinel */
799 : : };
800 : :
801 : :
802 : : static PyObject *
803 : 4 : EVPXOF_get_digest_size(EVPobject *self, void *closure)
804 : : {
805 : 4 : return PyLong_FromLong(0);
806 : : }
807 : :
808 : : static PyGetSetDef EVPXOF_getseters[] = {
809 : : {"digest_size",
810 : : (getter)EVPXOF_get_digest_size, NULL,
811 : : NULL,
812 : : NULL},
813 : : {NULL} /* Sentinel */
814 : : };
815 : :
816 : : PyDoc_STRVAR(hashxoftype_doc,
817 : : "HASHXOF(name, string=b\'\')\n"
818 : : "--\n"
819 : : "\n"
820 : : "A hash is an object used to calculate a checksum of a string of information.\n"
821 : : "\n"
822 : : "Methods:\n"
823 : : "\n"
824 : : "update() -- updates the current digest with an additional string\n"
825 : : "digest(length) -- return the current digest value\n"
826 : : "hexdigest(length) -- return the current digest as a string of hexadecimal digits\n"
827 : : "copy() -- return a copy of the current hash object\n"
828 : : "\n"
829 : : "Attributes:\n"
830 : : "\n"
831 : : "name -- the hash algorithm being used by this object\n"
832 : : "digest_size -- number of bytes in this hashes output");
833 : :
834 : : static PyType_Slot EVPXOFtype_slots[] = {
835 : : {Py_tp_doc, (char *)hashxoftype_doc},
836 : : {Py_tp_methods, EVPXOF_methods},
837 : : {Py_tp_getset, EVPXOF_getseters},
838 : : {0, 0},
839 : : };
840 : :
841 : : static PyType_Spec EVPXOFtype_spec = {
842 : : "_hashlib.HASHXOF", /*tp_name*/
843 : : sizeof(EVPobject), /*tp_basicsize*/
844 : : 0, /*tp_itemsize*/
845 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
846 : : EVPXOFtype_slots
847 : : };
848 : :
849 : :
850 : : #endif
851 : :
852 : : static PyObject*
853 : 17489 : py_evp_fromname(PyObject *module, const char *digestname, PyObject *data_obj,
854 : : int usedforsecurity)
855 : : {
856 : 17489 : Py_buffer view = { 0 };
857 : 17489 : PY_EVP_MD *digest = NULL;
858 : : PyTypeObject *type;
859 : 17489 : EVPobject *self = NULL;
860 : :
861 [ + + ]: 17489 : if (data_obj != NULL) {
862 [ + + - + : 9265 : GET_BUFFER_VIEW_OR_ERROUT(data_obj, &view);
- + - + ]
863 : : }
864 : :
865 : 17465 : digest = py_digest_by_name(
866 : : module, digestname, usedforsecurity ? Py_ht_evp : Py_ht_evp_nosecurity
867 : : );
868 [ + + ]: 17465 : if (digest == NULL) {
869 : 1 : goto exit;
870 : : }
871 : :
872 [ + + ]: 17464 : if ((EVP_MD_flags(digest) & EVP_MD_FLAG_XOF) == EVP_MD_FLAG_XOF) {
873 : 2094 : type = get_hashlib_state(module)->EVPXOFtype;
874 : : } else {
875 : 15370 : type = get_hashlib_state(module)->EVPtype;
876 : : }
877 : :
878 : 17464 : self = newEVPobject(type);
879 [ - + ]: 17464 : if (self == NULL) {
880 : 0 : goto exit;
881 : : }
882 : :
883 : : #if defined(EVP_MD_CTX_FLAG_NON_FIPS_ALLOW) && OPENSSL_VERSION_NUMBER < 0x30000000L
884 : : // In OpenSSL 1.1.1 the non FIPS allowed flag is context specific while
885 : : // in 3.0.0 it is a different EVP_MD provider.
886 : : if (!usedforsecurity) {
887 : : EVP_MD_CTX_set_flags(self->ctx, EVP_MD_CTX_FLAG_NON_FIPS_ALLOW);
888 : : }
889 : : #endif
890 : :
891 : 17464 : int result = EVP_DigestInit_ex(self->ctx, digest, NULL);
892 [ - + ]: 17464 : if (!result) {
893 : 0 : _setException(PyExc_ValueError, NULL);
894 [ # # ]: 0 : Py_CLEAR(self);
895 : 0 : goto exit;
896 : : }
897 : :
898 [ + + + + ]: 17464 : if (view.buf && view.len) {
899 [ + + ]: 3547 : if (view.len >= HASHLIB_GIL_MINSIZE) {
900 : 108 : Py_BEGIN_ALLOW_THREADS
901 : 108 : result = EVP_hash(self, view.buf, view.len);
902 : 108 : Py_END_ALLOW_THREADS
903 : : } else {
904 : 3439 : result = EVP_hash(self, view.buf, view.len);
905 : : }
906 [ + - ]: 3547 : if (result == -1) {
907 [ # # ]: 0 : Py_CLEAR(self);
908 : 0 : goto exit;
909 : : }
910 : : }
911 : :
912 : 17464 : exit:
913 [ + + ]: 17465 : if (data_obj != NULL) {
914 : 9241 : PyBuffer_Release(&view);
915 : : }
916 [ + + ]: 17465 : if (digest != NULL) {
917 : 17464 : PY_EVP_MD_free(digest);
918 : : }
919 : :
920 : 17465 : return (PyObject *)self;
921 : : }
922 : :
923 : :
924 : : /* The module-level function: new() */
925 : :
926 : : /*[clinic input]
927 : : _hashlib.new as EVP_new
928 : :
929 : : name as name_obj: object
930 : : string as data_obj: object(c_default="NULL") = b''
931 : : *
932 : : usedforsecurity: bool = True
933 : :
934 : : Return a new hash object using the named algorithm.
935 : :
936 : : An optional string argument may be provided and will be
937 : : automatically hashed.
938 : :
939 : : The MD5 and SHA1 algorithms are always supported.
940 : : [clinic start generated code]*/
941 : :
942 : : static PyObject *
943 : 7290 : EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj,
944 : : int usedforsecurity)
945 : : /*[clinic end generated code: output=ddd5053f92dffe90 input=c24554d0337be1b0]*/
946 : : {
947 : : char *name;
948 [ + + ]: 7290 : if (!PyArg_Parse(name_obj, "s", &name)) {
949 : 1 : PyErr_SetString(PyExc_TypeError, "name must be a string");
950 : 1 : return NULL;
951 : : }
952 : 7289 : return py_evp_fromname(module, name, data_obj, usedforsecurity);
953 : : }
954 : :
955 : :
956 : : /*[clinic input]
957 : : _hashlib.openssl_md5
958 : :
959 : : string as data_obj: object(py_default="b''") = NULL
960 : : *
961 : : usedforsecurity: bool = True
962 : :
963 : : Returns a md5 hash object; optionally initialized with a string
964 : :
965 : : [clinic start generated code]*/
966 : :
967 : : static PyObject *
968 : 621 : _hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj,
969 : : int usedforsecurity)
970 : : /*[clinic end generated code: output=87b0186440a44f8c input=990e36d5e689b16e]*/
971 : : {
972 : 621 : return py_evp_fromname(module, Py_hash_md5, data_obj, usedforsecurity);
973 : : }
974 : :
975 : :
976 : : /*[clinic input]
977 : : _hashlib.openssl_sha1
978 : :
979 : : string as data_obj: object(py_default="b''") = NULL
980 : : *
981 : : usedforsecurity: bool = True
982 : :
983 : : Returns a sha1 hash object; optionally initialized with a string
984 : :
985 : : [clinic start generated code]*/
986 : :
987 : : static PyObject *
988 : 722 : _hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj,
989 : : int usedforsecurity)
990 : : /*[clinic end generated code: output=6813024cf690670d input=948f2f4b6deabc10]*/
991 : : {
992 : 722 : return py_evp_fromname(module, Py_hash_sha1, data_obj, usedforsecurity);
993 : : }
994 : :
995 : :
996 : : /*[clinic input]
997 : : _hashlib.openssl_sha224
998 : :
999 : : string as data_obj: object(py_default="b''") = NULL
1000 : : *
1001 : : usedforsecurity: bool = True
1002 : :
1003 : : Returns a sha224 hash object; optionally initialized with a string
1004 : :
1005 : : [clinic start generated code]*/
1006 : :
1007 : : static PyObject *
1008 : 547 : _hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj,
1009 : : int usedforsecurity)
1010 : : /*[clinic end generated code: output=a2dfe7cc4eb14ebb input=f9272821fadca505]*/
1011 : : {
1012 : 547 : return py_evp_fromname(module, Py_hash_sha224, data_obj, usedforsecurity);
1013 : : }
1014 : :
1015 : :
1016 : : /*[clinic input]
1017 : : _hashlib.openssl_sha256
1018 : :
1019 : : string as data_obj: object(py_default="b''") = NULL
1020 : : *
1021 : : usedforsecurity: bool = True
1022 : :
1023 : : Returns a sha256 hash object; optionally initialized with a string
1024 : :
1025 : : [clinic start generated code]*/
1026 : :
1027 : : static PyObject *
1028 : 598 : _hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj,
1029 : : int usedforsecurity)
1030 : : /*[clinic end generated code: output=1f874a34870f0a68 input=549fad9d2930d4c5]*/
1031 : : {
1032 : 598 : return py_evp_fromname(module, Py_hash_sha256, data_obj, usedforsecurity);
1033 : : }
1034 : :
1035 : :
1036 : : /*[clinic input]
1037 : : _hashlib.openssl_sha384
1038 : :
1039 : : string as data_obj: object(py_default="b''") = NULL
1040 : : *
1041 : : usedforsecurity: bool = True
1042 : :
1043 : : Returns a sha384 hash object; optionally initialized with a string
1044 : :
1045 : : [clinic start generated code]*/
1046 : :
1047 : : static PyObject *
1048 : 523 : _hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj,
1049 : : int usedforsecurity)
1050 : : /*[clinic end generated code: output=58529eff9ca457b2 input=48601a6e3bf14ad7]*/
1051 : : {
1052 : 523 : return py_evp_fromname(module, Py_hash_sha384, data_obj, usedforsecurity);
1053 : : }
1054 : :
1055 : :
1056 : : /*[clinic input]
1057 : : _hashlib.openssl_sha512
1058 : :
1059 : : string as data_obj: object(py_default="b''") = NULL
1060 : : *
1061 : : usedforsecurity: bool = True
1062 : :
1063 : : Returns a sha512 hash object; optionally initialized with a string
1064 : :
1065 : : [clinic start generated code]*/
1066 : :
1067 : : static PyObject *
1068 : 523 : _hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj,
1069 : : int usedforsecurity)
1070 : : /*[clinic end generated code: output=2c744c9e4a40d5f6 input=c5c46a2a817aa98f]*/
1071 : : {
1072 : 523 : return py_evp_fromname(module, Py_hash_sha512, data_obj, usedforsecurity);
1073 : : }
1074 : :
1075 : :
1076 : : #ifdef PY_OPENSSL_HAS_SHA3
1077 : :
1078 : : /*[clinic input]
1079 : : _hashlib.openssl_sha3_224
1080 : :
1081 : : string as data_obj: object(py_default="b''") = NULL
1082 : : *
1083 : : usedforsecurity: bool = True
1084 : :
1085 : : Returns a sha3-224 hash object; optionally initialized with a string
1086 : :
1087 : : [clinic start generated code]*/
1088 : :
1089 : : static PyObject *
1090 : 1282 : _hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj,
1091 : : int usedforsecurity)
1092 : : /*[clinic end generated code: output=144641c1d144b974 input=e3a01b2888916157]*/
1093 : : {
1094 : 1282 : return py_evp_fromname(module, Py_hash_sha3_224, data_obj, usedforsecurity);
1095 : : }
1096 : :
1097 : : /*[clinic input]
1098 : : _hashlib.openssl_sha3_256
1099 : :
1100 : : string as data_obj: object(py_default="b''") = NULL
1101 : : *
1102 : : usedforsecurity: bool = True
1103 : :
1104 : : Returns a sha3-256 hash object; optionally initialized with a string
1105 : :
1106 : : [clinic start generated code]*/
1107 : :
1108 : : static PyObject *
1109 : 1282 : _hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj,
1110 : : int usedforsecurity)
1111 : : /*[clinic end generated code: output=c61f1ab772d06668 input=e2908126c1b6deed]*/
1112 : : {
1113 : 1282 : return py_evp_fromname(module, Py_hash_sha3_256, data_obj , usedforsecurity);
1114 : : }
1115 : :
1116 : : /*[clinic input]
1117 : : _hashlib.openssl_sha3_384
1118 : :
1119 : : string as data_obj: object(py_default="b''") = NULL
1120 : : *
1121 : : usedforsecurity: bool = True
1122 : :
1123 : : Returns a sha3-384 hash object; optionally initialized with a string
1124 : :
1125 : : [clinic start generated code]*/
1126 : :
1127 : : static PyObject *
1128 : 1282 : _hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj,
1129 : : int usedforsecurity)
1130 : : /*[clinic end generated code: output=f68e4846858cf0ee input=ec0edf5c792f8252]*/
1131 : : {
1132 : 1282 : return py_evp_fromname(module, Py_hash_sha3_384, data_obj , usedforsecurity);
1133 : : }
1134 : :
1135 : : /*[clinic input]
1136 : : _hashlib.openssl_sha3_512
1137 : :
1138 : : string as data_obj: object(py_default="b''") = NULL
1139 : : *
1140 : : usedforsecurity: bool = True
1141 : :
1142 : : Returns a sha3-512 hash object; optionally initialized with a string
1143 : :
1144 : : [clinic start generated code]*/
1145 : :
1146 : : static PyObject *
1147 : 1282 : _hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj,
1148 : : int usedforsecurity)
1149 : : /*[clinic end generated code: output=2eede478c159354a input=64e2cc0c094d56f4]*/
1150 : : {
1151 : 1282 : return py_evp_fromname(module, Py_hash_sha3_512, data_obj , usedforsecurity);
1152 : : }
1153 : : #endif /* PY_OPENSSL_HAS_SHA3 */
1154 : :
1155 : : #ifdef PY_OPENSSL_HAS_SHAKE
1156 : : /*[clinic input]
1157 : : _hashlib.openssl_shake_128
1158 : :
1159 : : string as data_obj: object(py_default="b''") = NULL
1160 : : *
1161 : : usedforsecurity: bool = True
1162 : :
1163 : : Returns a shake-128 variable hash object; optionally initialized with a string
1164 : :
1165 : : [clinic start generated code]*/
1166 : :
1167 : : static PyObject *
1168 : 769 : _hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj,
1169 : : int usedforsecurity)
1170 : : /*[clinic end generated code: output=bc49cdd8ada1fa97 input=6c9d67440eb33ec8]*/
1171 : : {
1172 : 769 : return py_evp_fromname(module, Py_hash_shake_128, data_obj , usedforsecurity);
1173 : : }
1174 : :
1175 : : /*[clinic input]
1176 : : _hashlib.openssl_shake_256
1177 : :
1178 : : string as data_obj: object(py_default="b''") = NULL
1179 : : *
1180 : : usedforsecurity: bool = True
1181 : :
1182 : : Returns a shake-256 variable hash object; optionally initialized with a string
1183 : :
1184 : : [clinic start generated code]*/
1185 : :
1186 : : static PyObject *
1187 : 769 : _hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj,
1188 : : int usedforsecurity)
1189 : : /*[clinic end generated code: output=358d213be8852df7 input=479cbe9fefd4a9f8]*/
1190 : : {
1191 : 769 : return py_evp_fromname(module, Py_hash_shake_256, data_obj , usedforsecurity);
1192 : : }
1193 : : #endif /* PY_OPENSSL_HAS_SHAKE */
1194 : :
1195 : : /*[clinic input]
1196 : : _hashlib.pbkdf2_hmac as pbkdf2_hmac
1197 : :
1198 : : hash_name: str
1199 : : password: Py_buffer
1200 : : salt: Py_buffer
1201 : : iterations: long
1202 : : dklen as dklen_obj: object = None
1203 : :
1204 : : Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.
1205 : : [clinic start generated code]*/
1206 : :
1207 : : static PyObject *
1208 : 60 : pbkdf2_hmac_impl(PyObject *module, const char *hash_name,
1209 : : Py_buffer *password, Py_buffer *salt, long iterations,
1210 : : PyObject *dklen_obj)
1211 : : /*[clinic end generated code: output=144b76005416599b input=ed3ab0d2d28b5d5c]*/
1212 : : {
1213 : 60 : PyObject *key_obj = NULL;
1214 : : char *key;
1215 : : long dklen;
1216 : : int retval;
1217 : :
1218 : 60 : PY_EVP_MD *digest = py_digest_by_name(module, hash_name, Py_ht_pbkdf2);
1219 [ + + ]: 60 : if (digest == NULL) {
1220 : 1 : goto end;
1221 : : }
1222 : :
1223 [ - + ]: 59 : if (password->len > INT_MAX) {
1224 : 0 : PyErr_SetString(PyExc_OverflowError,
1225 : : "password is too long.");
1226 : 0 : goto end;
1227 : : }
1228 : :
1229 [ - + ]: 59 : if (salt->len > INT_MAX) {
1230 : 0 : PyErr_SetString(PyExc_OverflowError,
1231 : : "salt is too long.");
1232 : 0 : goto end;
1233 : : }
1234 : :
1235 [ + + ]: 59 : if (iterations < 1) {
1236 : 2 : PyErr_SetString(PyExc_ValueError,
1237 : : "iteration value must be greater than 0.");
1238 : 2 : goto end;
1239 : : }
1240 [ - + ]: 57 : if (iterations > INT_MAX) {
1241 : 0 : PyErr_SetString(PyExc_OverflowError,
1242 : : "iteration value is too great.");
1243 : 0 : goto end;
1244 : : }
1245 : :
1246 [ + + ]: 57 : if (dklen_obj == Py_None) {
1247 : 37 : dklen = EVP_MD_size(digest);
1248 : : } else {
1249 : 20 : dklen = PyLong_AsLong(dklen_obj);
1250 [ + + - + ]: 20 : if ((dklen == -1) && PyErr_Occurred()) {
1251 : 0 : goto end;
1252 : : }
1253 : : }
1254 [ + + ]: 57 : if (dklen < 1) {
1255 : 2 : PyErr_SetString(PyExc_ValueError,
1256 : : "key length must be greater than 0.");
1257 : 2 : goto end;
1258 : : }
1259 [ - + ]: 55 : if (dklen > INT_MAX) {
1260 : : /* INT_MAX is always smaller than dkLen max (2^32 - 1) * hLen */
1261 : 0 : PyErr_SetString(PyExc_OverflowError,
1262 : : "key length is too great.");
1263 : 0 : goto end;
1264 : : }
1265 : :
1266 : 55 : key_obj = PyBytes_FromStringAndSize(NULL, dklen);
1267 [ - + ]: 55 : if (key_obj == NULL) {
1268 : 0 : goto end;
1269 : : }
1270 : 55 : key = PyBytes_AS_STRING(key_obj);
1271 : :
1272 : 55 : Py_BEGIN_ALLOW_THREADS
1273 : 55 : retval = PKCS5_PBKDF2_HMAC((char*)password->buf, (int)password->len,
1274 : 55 : (unsigned char *)salt->buf, (int)salt->len,
1275 : : iterations, digest, dklen,
1276 : : (unsigned char *)key);
1277 : 55 : Py_END_ALLOW_THREADS
1278 : :
1279 [ + - ]: 55 : if (!retval) {
1280 [ # # ]: 0 : Py_CLEAR(key_obj);
1281 : 0 : _setException(PyExc_ValueError, NULL);
1282 : 0 : goto end;
1283 : : }
1284 : :
1285 : 55 : end:
1286 [ + + ]: 60 : if (digest != NULL) {
1287 : 59 : PY_EVP_MD_free(digest);
1288 : : }
1289 : 60 : return key_obj;
1290 : : }
1291 : :
1292 : : #ifdef PY_OPENSSL_HAS_SCRYPT
1293 : :
1294 : : /* XXX: Parameters salt, n, r and p should be required keyword-only parameters.
1295 : : They are optional in the Argument Clinic declaration only due to a
1296 : : limitation of PyArg_ParseTupleAndKeywords. */
1297 : :
1298 : : /*[clinic input]
1299 : : _hashlib.scrypt
1300 : :
1301 : : password: Py_buffer
1302 : : *
1303 : : salt: Py_buffer = None
1304 : : n as n_obj: object(subclass_of='&PyLong_Type') = None
1305 : : r as r_obj: object(subclass_of='&PyLong_Type') = None
1306 : : p as p_obj: object(subclass_of='&PyLong_Type') = None
1307 : : maxmem: long = 0
1308 : : dklen: long = 64
1309 : :
1310 : :
1311 : : scrypt password-based key derivation function.
1312 : : [clinic start generated code]*/
1313 : :
1314 : : static PyObject *
1315 : 14 : _hashlib_scrypt_impl(PyObject *module, Py_buffer *password, Py_buffer *salt,
1316 : : PyObject *n_obj, PyObject *r_obj, PyObject *p_obj,
1317 : : long maxmem, long dklen)
1318 : : /*[clinic end generated code: output=14849e2aa2b7b46c input=48a7d63bf3f75c42]*/
1319 : : {
1320 : 14 : PyObject *key_obj = NULL;
1321 : : char *key;
1322 : : int retval;
1323 : : unsigned long n, r, p;
1324 : :
1325 [ - + ]: 14 : if (password->len > INT_MAX) {
1326 : 0 : PyErr_SetString(PyExc_OverflowError,
1327 : : "password is too long.");
1328 : 0 : return NULL;
1329 : : }
1330 : :
1331 [ + + ]: 14 : if (salt->buf == NULL) {
1332 : 1 : PyErr_SetString(PyExc_TypeError,
1333 : : "salt is required");
1334 : 1 : return NULL;
1335 : : }
1336 [ - + ]: 13 : if (salt->len > INT_MAX) {
1337 : 0 : PyErr_SetString(PyExc_OverflowError,
1338 : : "salt is too long.");
1339 : 0 : return NULL;
1340 : : }
1341 : :
1342 : 13 : n = PyLong_AsUnsignedLong(n_obj);
1343 [ + + + - ]: 13 : if (n == (unsigned long) -1 && PyErr_Occurred()) {
1344 : 1 : PyErr_SetString(PyExc_TypeError,
1345 : : "n is required and must be an unsigned int");
1346 : 1 : return NULL;
1347 : : }
1348 [ + + - + ]: 12 : if (n < 2 || n & (n - 1)) {
1349 : 2 : PyErr_SetString(PyExc_ValueError,
1350 : : "n must be a power of 2.");
1351 : 2 : return NULL;
1352 : : }
1353 : :
1354 : 10 : r = PyLong_AsUnsignedLong(r_obj);
1355 [ + + + - ]: 10 : if (r == (unsigned long) -1 && PyErr_Occurred()) {
1356 : 1 : PyErr_SetString(PyExc_TypeError,
1357 : : "r is required and must be an unsigned int");
1358 : 1 : return NULL;
1359 : : }
1360 : :
1361 : 9 : p = PyLong_AsUnsignedLong(p_obj);
1362 [ + + + - ]: 9 : if (p == (unsigned long) -1 && PyErr_Occurred()) {
1363 : 1 : PyErr_SetString(PyExc_TypeError,
1364 : : "p is required and must be an unsigned int");
1365 : 1 : return NULL;
1366 : : }
1367 : :
1368 [ + + - + ]: 8 : if (maxmem < 0 || maxmem > INT_MAX) {
1369 : : /* OpenSSL 1.1.0 restricts maxmem to 32 MiB. It may change in the
1370 : : future. The maxmem constant is private to OpenSSL. */
1371 : 1 : PyErr_Format(PyExc_ValueError,
1372 : : "maxmem must be positive and smaller than %d",
1373 : : INT_MAX);
1374 : 1 : return NULL;
1375 : : }
1376 : :
1377 [ + + - + ]: 7 : if (dklen < 1 || dklen > INT_MAX) {
1378 : 1 : PyErr_Format(PyExc_ValueError,
1379 : : "dklen must be greater than 0 and smaller than %d",
1380 : : INT_MAX);
1381 : 1 : return NULL;
1382 : : }
1383 : :
1384 : : /* let OpenSSL validate the rest */
1385 : 6 : retval = EVP_PBE_scrypt(NULL, 0, NULL, 0, n, r, p, maxmem, NULL, 0);
1386 [ + + ]: 6 : if (!retval) {
1387 : 2 : _setException(PyExc_ValueError, "Invalid parameter combination for n, r, p, maxmem.");
1388 : 2 : return NULL;
1389 : : }
1390 : :
1391 : 4 : key_obj = PyBytes_FromStringAndSize(NULL, dklen);
1392 [ - + ]: 4 : if (key_obj == NULL) {
1393 : 0 : return NULL;
1394 : : }
1395 : 4 : key = PyBytes_AS_STRING(key_obj);
1396 : :
1397 : 4 : Py_BEGIN_ALLOW_THREADS
1398 : 4 : retval = EVP_PBE_scrypt(
1399 : 4 : (const char*)password->buf, (size_t)password->len,
1400 : 4 : (const unsigned char *)salt->buf, (size_t)salt->len,
1401 : : n, r, p, maxmem,
1402 : : (unsigned char *)key, (size_t)dklen
1403 : : );
1404 : 4 : Py_END_ALLOW_THREADS
1405 : :
1406 [ - + ]: 4 : if (!retval) {
1407 [ # # ]: 0 : Py_CLEAR(key_obj);
1408 : 0 : _setException(PyExc_ValueError, NULL);
1409 : 0 : return NULL;
1410 : : }
1411 : 4 : return key_obj;
1412 : : }
1413 : : #endif /* PY_OPENSSL_HAS_SCRYPT */
1414 : :
1415 : : /* Fast HMAC for hmac.digest()
1416 : : */
1417 : :
1418 : : /*[clinic input]
1419 : : _hashlib.hmac_digest as _hashlib_hmac_singleshot
1420 : :
1421 : : key: Py_buffer
1422 : : msg: Py_buffer
1423 : : digest: object
1424 : :
1425 : : Single-shot HMAC.
1426 : : [clinic start generated code]*/
1427 : :
1428 : : static PyObject *
1429 : 77 : _hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
1430 : : Py_buffer *msg, PyObject *digest)
1431 : : /*[clinic end generated code: output=82f19965d12706ac input=0a0790cc3db45c2e]*/
1432 : : {
1433 : 77 : unsigned char md[EVP_MAX_MD_SIZE] = {0};
1434 : 77 : unsigned int md_len = 0;
1435 : : unsigned char *result;
1436 : : PY_EVP_MD *evp;
1437 : :
1438 [ - + ]: 77 : if (key->len > INT_MAX) {
1439 : 0 : PyErr_SetString(PyExc_OverflowError,
1440 : : "key is too long.");
1441 : 0 : return NULL;
1442 : : }
1443 [ - + ]: 77 : if (msg->len > INT_MAX) {
1444 : 0 : PyErr_SetString(PyExc_OverflowError,
1445 : : "msg is too long.");
1446 : 0 : return NULL;
1447 : : }
1448 : :
1449 : 77 : evp = py_digest_by_digestmod(module, digest, Py_ht_mac);
1450 [ + + ]: 77 : if (evp == NULL) {
1451 : 1 : return NULL;
1452 : : }
1453 : :
1454 : 76 : Py_BEGIN_ALLOW_THREADS
1455 : 76 : result = HMAC(
1456 : : evp,
1457 : 76 : (const void*)key->buf, (int)key->len,
1458 : 76 : (const unsigned char*)msg->buf, (int)msg->len,
1459 : : md, &md_len
1460 : : );
1461 : 76 : Py_END_ALLOW_THREADS
1462 : 76 : PY_EVP_MD_free(evp);
1463 : :
1464 [ - + ]: 76 : if (result == NULL) {
1465 : 0 : _setException(PyExc_ValueError, NULL);
1466 : 0 : return NULL;
1467 : : }
1468 : 76 : return PyBytes_FromStringAndSize((const char*)md, md_len);
1469 : : }
1470 : :
1471 : : /* OpenSSL-based HMAC implementation
1472 : : */
1473 : :
1474 : : static int _hmac_update(HMACobject*, PyObject*);
1475 : :
1476 : : /*[clinic input]
1477 : : _hashlib.hmac_new
1478 : :
1479 : : key: Py_buffer
1480 : : msg as msg_obj: object(c_default="NULL") = b''
1481 : : digestmod: object(c_default="NULL") = None
1482 : :
1483 : : Return a new hmac object.
1484 : : [clinic start generated code]*/
1485 : :
1486 : : static PyObject *
1487 : 7744 : _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
1488 : : PyObject *digestmod)
1489 : : /*[clinic end generated code: output=c20d9e4d9ed6d219 input=5f4071dcc7f34362]*/
1490 : : {
1491 : 7744 : PyTypeObject *type = get_hashlib_state(module)->HMACtype;
1492 : : PY_EVP_MD *digest;
1493 : 7744 : HMAC_CTX *ctx = NULL;
1494 : 7744 : HMACobject *self = NULL;
1495 : : int r;
1496 : :
1497 [ - + ]: 7744 : if (key->len > INT_MAX) {
1498 : 0 : PyErr_SetString(PyExc_OverflowError,
1499 : : "key is too long.");
1500 : 0 : return NULL;
1501 : : }
1502 : :
1503 [ - + ]: 7744 : if (digestmod == NULL) {
1504 : 0 : PyErr_SetString(
1505 : : PyExc_TypeError, "Missing required parameter 'digestmod'.");
1506 : 0 : return NULL;
1507 : : }
1508 : :
1509 : 7744 : digest = py_digest_by_digestmod(module, digestmod, Py_ht_mac);
1510 [ + + ]: 7744 : if (digest == NULL) {
1511 : 1 : return NULL;
1512 : : }
1513 : :
1514 : 7743 : ctx = HMAC_CTX_new();
1515 [ - + ]: 7743 : if (ctx == NULL) {
1516 : 0 : _setException(PyExc_ValueError, NULL);
1517 : 0 : goto error;
1518 : : }
1519 : :
1520 : 7743 : r = HMAC_Init_ex(
1521 : : ctx,
1522 : 7743 : (const char*)key->buf,
1523 : 7743 : (int)key->len,
1524 : : digest,
1525 : : NULL /*impl*/);
1526 : 7743 : PY_EVP_MD_free(digest);
1527 [ - + ]: 7743 : if (r == 0) {
1528 : 0 : _setException(PyExc_ValueError, NULL);
1529 : 0 : goto error;
1530 : : }
1531 : :
1532 : 7743 : self = (HMACobject *)PyObject_New(HMACobject, type);
1533 [ - + ]: 7743 : if (self == NULL) {
1534 : 0 : goto error;
1535 : : }
1536 : :
1537 : 7743 : self->ctx = ctx;
1538 : 7743 : self->lock = NULL;
1539 : :
1540 [ + + + + ]: 7743 : if ((msg_obj != NULL) && (msg_obj != Py_None)) {
1541 [ - + ]: 7587 : if (!_hmac_update(self, msg_obj))
1542 : 0 : goto error;
1543 : : }
1544 : :
1545 : 7743 : return (PyObject*)self;
1546 : :
1547 : 0 : error:
1548 [ # # ]: 0 : if (ctx) HMAC_CTX_free(ctx);
1549 [ # # ]: 0 : if (self) PyObject_Free(self);
1550 : 0 : return NULL;
1551 : : }
1552 : :
1553 : : /* helper functions */
1554 : : static int
1555 : 8055 : locked_HMAC_CTX_copy(HMAC_CTX *new_ctx_p, HMACobject *self)
1556 : : {
1557 : : int result;
1558 [ - + - - ]: 8055 : ENTER_HASHLIB(self);
1559 : 8055 : result = HMAC_CTX_copy(new_ctx_p, self->ctx);
1560 [ - + ]: 8055 : LEAVE_HASHLIB(self);
1561 : 8055 : return result;
1562 : : }
1563 : :
1564 : : static unsigned int
1565 : 15680 : _hmac_digest_size(HMACobject *self)
1566 : : {
1567 : 15680 : unsigned int digest_size = EVP_MD_size(HMAC_CTX_get_md(self->ctx));
1568 : : assert(digest_size <= EVP_MAX_MD_SIZE);
1569 : 15680 : return digest_size;
1570 : : }
1571 : :
1572 : : static int
1573 : 7818 : _hmac_update(HMACobject *self, PyObject *obj)
1574 : : {
1575 : : int r;
1576 : 7818 : Py_buffer view = {0};
1577 : :
1578 [ - + - + : 7818 : GET_BUFFER_VIEW_OR_ERROR(obj, &view, return 0);
- + - + ]
1579 : :
1580 [ + - - + ]: 7818 : if (self->lock == NULL && view.len >= HASHLIB_GIL_MINSIZE) {
1581 : 0 : self->lock = PyThread_allocate_lock();
1582 : : /* fail? lock = NULL and we fail over to non-threaded code. */
1583 : : }
1584 : :
1585 [ - + ]: 7818 : if (self->lock != NULL) {
1586 : 0 : Py_BEGIN_ALLOW_THREADS
1587 : 0 : PyThread_acquire_lock(self->lock, 1);
1588 : 0 : r = HMAC_Update(self->ctx, (const unsigned char*)view.buf, view.len);
1589 : 0 : PyThread_release_lock(self->lock);
1590 : 0 : Py_END_ALLOW_THREADS
1591 : : } else {
1592 : 7818 : r = HMAC_Update(self->ctx, (const unsigned char*)view.buf, view.len);
1593 : : }
1594 : :
1595 : 7818 : PyBuffer_Release(&view);
1596 : :
1597 [ - + ]: 7818 : if (r == 0) {
1598 : 0 : _setException(PyExc_ValueError, NULL);
1599 : 0 : return 0;
1600 : : }
1601 : 7818 : return 1;
1602 : : }
1603 : :
1604 : : /*[clinic input]
1605 : : _hashlib.HMAC.copy
1606 : :
1607 : : Return a copy ("clone") of the HMAC object.
1608 : : [clinic start generated code]*/
1609 : :
1610 : : static PyObject *
1611 : 80 : _hashlib_HMAC_copy_impl(HMACobject *self)
1612 : : /*[clinic end generated code: output=29aa28b452833127 input=e2fa6a05db61a4d6]*/
1613 : : {
1614 : : HMACobject *retval;
1615 : :
1616 : 80 : HMAC_CTX *ctx = HMAC_CTX_new();
1617 [ - + ]: 80 : if (ctx == NULL) {
1618 : 0 : return _setException(PyExc_ValueError, NULL);
1619 : : }
1620 [ - + ]: 80 : if (!locked_HMAC_CTX_copy(ctx, self)) {
1621 : 0 : HMAC_CTX_free(ctx);
1622 : 0 : return _setException(PyExc_ValueError, NULL);
1623 : : }
1624 : :
1625 : 80 : retval = (HMACobject *)PyObject_New(HMACobject, Py_TYPE(self));
1626 [ - + ]: 80 : if (retval == NULL) {
1627 : 0 : HMAC_CTX_free(ctx);
1628 : 0 : return NULL;
1629 : : }
1630 : 80 : retval->ctx = ctx;
1631 : 80 : retval->lock = NULL;
1632 : :
1633 : 80 : return (PyObject *)retval;
1634 : : }
1635 : :
1636 : : static void
1637 : 7823 : _hmac_dealloc(HMACobject *self)
1638 : : {
1639 : 7823 : PyTypeObject *tp = Py_TYPE(self);
1640 [ - + ]: 7823 : if (self->lock != NULL) {
1641 : 0 : PyThread_free_lock(self->lock);
1642 : : }
1643 : 7823 : HMAC_CTX_free(self->ctx);
1644 : 7823 : PyObject_Free(self);
1645 : 7823 : Py_DECREF(tp);
1646 : 7823 : }
1647 : :
1648 : : static PyObject *
1649 : 0 : _hmac_repr(HMACobject *self)
1650 : : {
1651 : 0 : PyObject *digest_name = py_digest_name(HMAC_CTX_get_md(self->ctx));
1652 [ # # ]: 0 : if (digest_name == NULL) {
1653 : 0 : return NULL;
1654 : : }
1655 : 0 : PyObject *repr = PyUnicode_FromFormat(
1656 : : "<%U HMAC object @ %p>", digest_name, self
1657 : : );
1658 : 0 : Py_DECREF(digest_name);
1659 : 0 : return repr;
1660 : : }
1661 : :
1662 : : /*[clinic input]
1663 : : _hashlib.HMAC.update
1664 : : msg: object
1665 : :
1666 : : Update the HMAC object with msg.
1667 : : [clinic start generated code]*/
1668 : :
1669 : : static PyObject *
1670 : 231 : _hashlib_HMAC_update_impl(HMACobject *self, PyObject *msg)
1671 : : /*[clinic end generated code: output=f31f0ace8c625b00 input=1829173bb3cfd4e6]*/
1672 : : {
1673 [ - + ]: 231 : if (!_hmac_update(self, msg)) {
1674 : 0 : return NULL;
1675 : : }
1676 : 231 : Py_RETURN_NONE;
1677 : : }
1678 : :
1679 : : static int
1680 : 7975 : _hmac_digest(HMACobject *self, unsigned char *buf, unsigned int len)
1681 : : {
1682 : 7975 : HMAC_CTX *temp_ctx = HMAC_CTX_new();
1683 [ - + ]: 7975 : if (temp_ctx == NULL) {
1684 : : PyErr_NoMemory();
1685 : 0 : return 0;
1686 : : }
1687 [ - + ]: 7975 : if (!locked_HMAC_CTX_copy(temp_ctx, self)) {
1688 : 0 : _setException(PyExc_ValueError, NULL);
1689 : 0 : return 0;
1690 : : }
1691 : 7975 : int r = HMAC_Final(temp_ctx, buf, &len);
1692 : 7975 : HMAC_CTX_free(temp_ctx);
1693 [ - + ]: 7975 : if (r == 0) {
1694 : 0 : _setException(PyExc_ValueError, NULL);
1695 : 0 : return 0;
1696 : : }
1697 : 7975 : return 1;
1698 : : }
1699 : :
1700 : : /*[clinic input]
1701 : : _hashlib.HMAC.digest
1702 : : Return the digest of the bytes passed to the update() method so far.
1703 : : [clinic start generated code]*/
1704 : :
1705 : : static PyObject *
1706 : 7535 : _hashlib_HMAC_digest_impl(HMACobject *self)
1707 : : /*[clinic end generated code: output=1b1424355af7a41e input=bff07f74da318fb4]*/
1708 : : {
1709 : : unsigned char digest[EVP_MAX_MD_SIZE];
1710 : 7535 : unsigned int digest_size = _hmac_digest_size(self);
1711 [ - + ]: 7535 : if (digest_size == 0) {
1712 : 0 : return _setException(PyExc_ValueError, NULL);
1713 : : }
1714 : 7535 : int r = _hmac_digest(self, digest, digest_size);
1715 [ - + ]: 7535 : if (r == 0) {
1716 : 0 : return NULL;
1717 : : }
1718 : 7535 : return PyBytes_FromStringAndSize((const char *)digest, digest_size);
1719 : : }
1720 : :
1721 : : /*[clinic input]
1722 : : _hashlib.HMAC.hexdigest
1723 : :
1724 : : Return hexadecimal digest of the bytes passed to the update() method so far.
1725 : :
1726 : : This may be used to exchange the value safely in email or other non-binary
1727 : : environments.
1728 : : [clinic start generated code]*/
1729 : :
1730 : : static PyObject *
1731 : 440 : _hashlib_HMAC_hexdigest_impl(HMACobject *self)
1732 : : /*[clinic end generated code: output=80d825be1eaae6a7 input=5abc42702874ddcf]*/
1733 : : {
1734 : : unsigned char digest[EVP_MAX_MD_SIZE];
1735 : 440 : unsigned int digest_size = _hmac_digest_size(self);
1736 [ - + ]: 440 : if (digest_size == 0) {
1737 : 0 : return _setException(PyExc_ValueError, NULL);
1738 : : }
1739 : 440 : int r = _hmac_digest(self, digest, digest_size);
1740 [ - + ]: 440 : if (r == 0) {
1741 : 0 : return NULL;
1742 : : }
1743 : 440 : return _Py_strhex((const char *)digest, digest_size);
1744 : : }
1745 : :
1746 : : static PyObject *
1747 : 7705 : _hashlib_hmac_get_digest_size(HMACobject *self, void *closure)
1748 : : {
1749 : 7705 : unsigned int digest_size = _hmac_digest_size(self);
1750 [ - + ]: 7705 : if (digest_size == 0) {
1751 : 0 : return _setException(PyExc_ValueError, NULL);
1752 : : }
1753 : 7705 : return PyLong_FromLong(digest_size);
1754 : : }
1755 : :
1756 : : static PyObject *
1757 : 7705 : _hashlib_hmac_get_block_size(HMACobject *self, void *closure)
1758 : : {
1759 : 7705 : const EVP_MD *md = HMAC_CTX_get_md(self->ctx);
1760 [ - + ]: 7705 : if (md == NULL) {
1761 : 0 : return _setException(PyExc_ValueError, NULL);
1762 : : }
1763 : 7705 : return PyLong_FromLong(EVP_MD_block_size(md));
1764 : : }
1765 : :
1766 : : static PyObject *
1767 : 228 : _hashlib_hmac_get_name(HMACobject *self, void *closure)
1768 : : {
1769 : 228 : PyObject *digest_name = py_digest_name(HMAC_CTX_get_md(self->ctx));
1770 [ - + ]: 228 : if (digest_name == NULL) {
1771 : 0 : return NULL;
1772 : : }
1773 : 228 : PyObject *name = PyUnicode_FromFormat("hmac-%U", digest_name);
1774 : 228 : Py_DECREF(digest_name);
1775 : 228 : return name;
1776 : : }
1777 : :
1778 : : static PyMethodDef HMAC_methods[] = {
1779 : : _HASHLIB_HMAC_UPDATE_METHODDEF
1780 : : _HASHLIB_HMAC_DIGEST_METHODDEF
1781 : : _HASHLIB_HMAC_HEXDIGEST_METHODDEF
1782 : : _HASHLIB_HMAC_COPY_METHODDEF
1783 : : {NULL, NULL} /* sentinel */
1784 : : };
1785 : :
1786 : : static PyGetSetDef HMAC_getset[] = {
1787 : : {"digest_size", (getter)_hashlib_hmac_get_digest_size, NULL, NULL, NULL},
1788 : : {"block_size", (getter)_hashlib_hmac_get_block_size, NULL, NULL, NULL},
1789 : : {"name", (getter)_hashlib_hmac_get_name, NULL, NULL, NULL},
1790 : : {NULL} /* Sentinel */
1791 : : };
1792 : :
1793 : :
1794 : : PyDoc_STRVAR(hmactype_doc,
1795 : : "The object used to calculate HMAC of a message.\n\
1796 : : \n\
1797 : : Methods:\n\
1798 : : \n\
1799 : : update() -- updates the current digest with an additional string\n\
1800 : : digest() -- return the current digest value\n\
1801 : : hexdigest() -- return the current digest as a string of hexadecimal digits\n\
1802 : : copy() -- return a copy of the current hash object\n\
1803 : : \n\
1804 : : Attributes:\n\
1805 : : \n\
1806 : : name -- the name, including the hash algorithm used by this object\n\
1807 : : digest_size -- number of bytes in digest() output\n");
1808 : :
1809 : : static PyType_Slot HMACtype_slots[] = {
1810 : : {Py_tp_doc, (char *)hmactype_doc},
1811 : : {Py_tp_repr, (reprfunc)_hmac_repr},
1812 : : {Py_tp_dealloc,(destructor)_hmac_dealloc},
1813 : : {Py_tp_methods, HMAC_methods},
1814 : : {Py_tp_getset, HMAC_getset},
1815 : : {0, NULL}
1816 : : };
1817 : :
1818 : : PyType_Spec HMACtype_spec = {
1819 : : "_hashlib.HMAC", /* name */
1820 : : sizeof(HMACobject), /* basicsize */
1821 : : .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
1822 : : .slots = HMACtype_slots,
1823 : : };
1824 : :
1825 : :
1826 : : /* State for our callback function so that it can accumulate a result. */
1827 : : typedef struct _internal_name_mapper_state {
1828 : : PyObject *set;
1829 : : int error;
1830 : : } _InternalNameMapperState;
1831 : :
1832 : :
1833 : : /* A callback function to pass to OpenSSL's OBJ_NAME_do_all(...) */
1834 : : static void
1835 : : #if OPENSSL_VERSION_NUMBER >= 0x30000000L
1836 : 8862 : _openssl_hash_name_mapper(EVP_MD *md, void *arg)
1837 : : #else
1838 : : _openssl_hash_name_mapper(const EVP_MD *md, const char *from,
1839 : : const char *to, void *arg)
1840 : : #endif
1841 : : {
1842 : 8862 : _InternalNameMapperState *state = (_InternalNameMapperState *)arg;
1843 : : PyObject *py_name;
1844 : :
1845 : : assert(state != NULL);
1846 : : // ignore all undefined providers
1847 [ + - + + ]: 8862 : if ((md == NULL) || (EVP_MD_nid(md) == NID_undef)) {
1848 : 1266 : return;
1849 : : }
1850 : :
1851 : 7596 : py_name = py_digest_name(md);
1852 [ - + ]: 7596 : if (py_name == NULL) {
1853 : 0 : state->error = 1;
1854 : : } else {
1855 [ - + ]: 7596 : if (PySet_Add(state->set, py_name) != 0) {
1856 : 0 : state->error = 1;
1857 : : }
1858 : 7596 : Py_DECREF(py_name);
1859 : : }
1860 : : }
1861 : :
1862 : :
1863 : : /* Ask OpenSSL for a list of supported ciphers, filling in a Python set. */
1864 : : static int
1865 : 422 : hashlib_md_meth_names(PyObject *module)
1866 : : {
1867 : 422 : _InternalNameMapperState state = {
1868 : 422 : .set = PyFrozenSet_New(NULL),
1869 : : .error = 0
1870 : : };
1871 [ - + ]: 422 : if (state.set == NULL) {
1872 : 0 : return -1;
1873 : : }
1874 : :
1875 : : #if OPENSSL_VERSION_NUMBER >= 0x30000000L
1876 : : // get algorithms from all activated providers in default context
1877 : 422 : EVP_MD_do_all_provided(NULL, &_openssl_hash_name_mapper, &state);
1878 : : #else
1879 : : EVP_MD_do_all(&_openssl_hash_name_mapper, &state);
1880 : : #endif
1881 : :
1882 [ - + ]: 422 : if (state.error) {
1883 : 0 : Py_DECREF(state.set);
1884 : 0 : return -1;
1885 : : }
1886 : :
1887 [ - + ]: 422 : if (PyModule_AddObject(module, "openssl_md_meth_names", state.set) < 0) {
1888 : 0 : Py_DECREF(state.set);
1889 : 0 : return -1;
1890 : : }
1891 : :
1892 : 422 : return 0;
1893 : : }
1894 : :
1895 : : /*[clinic input]
1896 : : _hashlib.get_fips_mode -> int
1897 : :
1898 : : Determine the OpenSSL FIPS mode of operation.
1899 : :
1900 : : For OpenSSL 3.0.0 and newer it returns the state of the default provider
1901 : : in the default OSSL context. It's not quite the same as FIPS_mode() but good
1902 : : enough for unittests.
1903 : :
1904 : : Effectively any non-zero return value indicates FIPS mode;
1905 : : values other than 1 may have additional significance.
1906 : : [clinic start generated code]*/
1907 : :
1908 : : static int
1909 : 3 : _hashlib_get_fips_mode_impl(PyObject *module)
1910 : : /*[clinic end generated code: output=87eece1bab4d3fa9 input=2db61538c41c6fef]*/
1911 : :
1912 : : {
1913 : : #if OPENSSL_VERSION_NUMBER >= 0x30000000L
1914 : 3 : return EVP_default_properties_is_fips_enabled(NULL);
1915 : : #else
1916 : : ERR_clear_error();
1917 : : int result = FIPS_mode();
1918 : : if (result == 0) {
1919 : : // "If the library was built without support of the FIPS Object Module,
1920 : : // then the function will return 0 with an error code of
1921 : : // CRYPTO_R_FIPS_MODE_NOT_SUPPORTED (0x0f06d065)."
1922 : : // But 0 is also a valid result value.
1923 : : unsigned long errcode = ERR_peek_last_error();
1924 : : if (errcode) {
1925 : : _setException(PyExc_ValueError, NULL);
1926 : : return -1;
1927 : : }
1928 : : }
1929 : : return result;
1930 : : #endif
1931 : : }
1932 : :
1933 : :
1934 : : static int
1935 : 64 : _tscmp(const unsigned char *a, const unsigned char *b,
1936 : : Py_ssize_t len_a, Py_ssize_t len_b)
1937 : : {
1938 : : /* loop count depends on length of b. Might leak very little timing
1939 : : * information if sizes are different.
1940 : : */
1941 : 64 : Py_ssize_t length = len_b;
1942 : 64 : const void *left = a;
1943 : 64 : const void *right = b;
1944 : 64 : int result = 0;
1945 : :
1946 [ + + ]: 64 : if (len_a != length) {
1947 : 14 : left = b;
1948 : 14 : result = 1;
1949 : : }
1950 : :
1951 : 64 : result |= CRYPTO_memcmp(left, right, length);
1952 : :
1953 : 64 : return (result == 0);
1954 : : }
1955 : :
1956 : : /* NOTE: Keep in sync with _operator.c implementation. */
1957 : :
1958 : : /*[clinic input]
1959 : : _hashlib.compare_digest
1960 : :
1961 : : a: object
1962 : : b: object
1963 : : /
1964 : :
1965 : : Return 'a == b'.
1966 : :
1967 : : This function uses an approach designed to prevent
1968 : : timing analysis, making it appropriate for cryptography.
1969 : :
1970 : : a and b must both be of the same type: either str (ASCII only),
1971 : : or any bytes-like object.
1972 : :
1973 : : Note: If a and b are of different lengths, or if an error occurs,
1974 : : a timing attack could theoretically reveal information about the
1975 : : types and lengths of a and b--but not their values.
1976 : : [clinic start generated code]*/
1977 : :
1978 : : static PyObject *
1979 : 86 : _hashlib_compare_digest_impl(PyObject *module, PyObject *a, PyObject *b)
1980 : : /*[clinic end generated code: output=6f1c13927480aed9 input=9c40c6e566ca12f5]*/
1981 : : {
1982 : : int rc;
1983 : :
1984 : : /* ASCII unicode string */
1985 [ + + + + ]: 86 : if(PyUnicode_Check(a) && PyUnicode_Check(b)) {
1986 [ + - - + ]: 23 : if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
1987 : 0 : return NULL;
1988 : : }
1989 [ + + - + ]: 23 : if (!PyUnicode_IS_ASCII(a) || !PyUnicode_IS_ASCII(b)) {
1990 : 2 : PyErr_SetString(PyExc_TypeError,
1991 : : "comparing strings with non-ASCII characters is "
1992 : : "not supported");
1993 : 2 : return NULL;
1994 : : }
1995 : :
1996 : 42 : rc = _tscmp(PyUnicode_DATA(a),
1997 : 21 : PyUnicode_DATA(b),
1998 : : PyUnicode_GET_LENGTH(a),
1999 : : PyUnicode_GET_LENGTH(b));
2000 : : }
2001 : : /* fallback to buffer interface for bytes, bytearray and other */
2002 : : else {
2003 : : Py_buffer view_a;
2004 : : Py_buffer view_b;
2005 : :
2006 [ + + + + ]: 63 : if (PyObject_CheckBuffer(a) == 0 && PyObject_CheckBuffer(b) == 0) {
2007 : 4 : PyErr_Format(PyExc_TypeError,
2008 : : "unsupported operand types(s) or combination of types: "
2009 : : "'%.100s' and '%.100s'",
2010 : 4 : Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
2011 : 20 : return NULL;
2012 : : }
2013 : :
2014 [ + + ]: 59 : if (PyObject_GetBuffer(a, &view_a, PyBUF_SIMPLE) == -1) {
2015 : 7 : return NULL;
2016 : : }
2017 [ - + ]: 52 : if (view_a.ndim > 1) {
2018 : 0 : PyErr_SetString(PyExc_BufferError,
2019 : : "Buffer must be single dimension");
2020 : 0 : PyBuffer_Release(&view_a);
2021 : 0 : return NULL;
2022 : : }
2023 : :
2024 [ + + ]: 52 : if (PyObject_GetBuffer(b, &view_b, PyBUF_SIMPLE) == -1) {
2025 : 9 : PyBuffer_Release(&view_a);
2026 : 9 : return NULL;
2027 : : }
2028 [ - + ]: 43 : if (view_b.ndim > 1) {
2029 : 0 : PyErr_SetString(PyExc_BufferError,
2030 : : "Buffer must be single dimension");
2031 : 0 : PyBuffer_Release(&view_a);
2032 : 0 : PyBuffer_Release(&view_b);
2033 : 0 : return NULL;
2034 : : }
2035 : :
2036 : 43 : rc = _tscmp((const unsigned char*)view_a.buf,
2037 : 43 : (const unsigned char*)view_b.buf,
2038 : : view_a.len,
2039 : : view_b.len);
2040 : :
2041 : 43 : PyBuffer_Release(&view_a);
2042 : 43 : PyBuffer_Release(&view_b);
2043 : : }
2044 : :
2045 : 64 : return PyBool_FromLong(rc);
2046 : : }
2047 : :
2048 : : /* List of functions exported by this module */
2049 : :
2050 : : static struct PyMethodDef EVP_functions[] = {
2051 : : EVP_NEW_METHODDEF
2052 : : PBKDF2_HMAC_METHODDEF
2053 : : _HASHLIB_SCRYPT_METHODDEF
2054 : : _HASHLIB_GET_FIPS_MODE_METHODDEF
2055 : : _HASHLIB_COMPARE_DIGEST_METHODDEF
2056 : : _HASHLIB_HMAC_SINGLESHOT_METHODDEF
2057 : : _HASHLIB_HMAC_NEW_METHODDEF
2058 : : _HASHLIB_OPENSSL_MD5_METHODDEF
2059 : : _HASHLIB_OPENSSL_SHA1_METHODDEF
2060 : : _HASHLIB_OPENSSL_SHA224_METHODDEF
2061 : : _HASHLIB_OPENSSL_SHA256_METHODDEF
2062 : : _HASHLIB_OPENSSL_SHA384_METHODDEF
2063 : : _HASHLIB_OPENSSL_SHA512_METHODDEF
2064 : : _HASHLIB_OPENSSL_SHA3_224_METHODDEF
2065 : : _HASHLIB_OPENSSL_SHA3_256_METHODDEF
2066 : : _HASHLIB_OPENSSL_SHA3_384_METHODDEF
2067 : : _HASHLIB_OPENSSL_SHA3_512_METHODDEF
2068 : : _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
2069 : : _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
2070 : : {NULL, NULL} /* Sentinel */
2071 : : };
2072 : :
2073 : :
2074 : : /* Initialize this module. */
2075 : :
2076 : : static int
2077 : 5910 : hashlib_traverse(PyObject *m, visitproc visit, void *arg)
2078 : : {
2079 : 5910 : _hashlibstate *state = get_hashlib_state(m);
2080 [ + - - + ]: 5910 : Py_VISIT(state->EVPtype);
2081 [ + + - + ]: 5910 : Py_VISIT(state->HMACtype);
2082 : : #ifdef PY_OPENSSL_HAS_SHAKE
2083 [ + + - + ]: 5910 : Py_VISIT(state->EVPXOFtype);
2084 : : #endif
2085 [ + + - + ]: 5910 : Py_VISIT(state->constructs);
2086 [ + + - + ]: 5910 : Py_VISIT(state->unsupported_digestmod_error);
2087 : 5910 : return 0;
2088 : : }
2089 : :
2090 : : static int
2091 : 844 : hashlib_clear(PyObject *m)
2092 : : {
2093 : 844 : _hashlibstate *state = get_hashlib_state(m);
2094 [ + + ]: 844 : Py_CLEAR(state->EVPtype);
2095 [ + + ]: 844 : Py_CLEAR(state->HMACtype);
2096 : : #ifdef PY_OPENSSL_HAS_SHAKE
2097 [ + + ]: 844 : Py_CLEAR(state->EVPXOFtype);
2098 : : #endif
2099 [ + + ]: 844 : Py_CLEAR(state->constructs);
2100 [ + + ]: 844 : Py_CLEAR(state->unsupported_digestmod_error);
2101 : :
2102 [ + + ]: 844 : if (state->hashtable != NULL) {
2103 : 422 : _Py_hashtable_destroy(state->hashtable);
2104 : 422 : state->hashtable = NULL;
2105 : : }
2106 : :
2107 : 844 : return 0;
2108 : : }
2109 : :
2110 : : static void
2111 : 422 : hashlib_free(void *m)
2112 : : {
2113 : 422 : hashlib_clear((PyObject *)m);
2114 : 422 : }
2115 : :
2116 : : /* Py_mod_exec functions */
2117 : : static int
2118 : 422 : hashlib_init_hashtable(PyObject *module)
2119 : : {
2120 : 422 : _hashlibstate *state = get_hashlib_state(module);
2121 : :
2122 : 422 : state->hashtable = py_hashentry_table_new();
2123 [ - + ]: 422 : if (state->hashtable == NULL) {
2124 : : PyErr_NoMemory();
2125 : 0 : return -1;
2126 : : }
2127 : 422 : return 0;
2128 : : }
2129 : :
2130 : : static int
2131 : 422 : hashlib_init_evptype(PyObject *module)
2132 : : {
2133 : 422 : _hashlibstate *state = get_hashlib_state(module);
2134 : :
2135 : 422 : state->EVPtype = (PyTypeObject *)PyType_FromSpec(&EVPtype_spec);
2136 [ - + ]: 422 : if (state->EVPtype == NULL) {
2137 : 0 : return -1;
2138 : : }
2139 [ - + ]: 422 : if (PyModule_AddType(module, state->EVPtype) < 0) {
2140 : 0 : return -1;
2141 : : }
2142 : 422 : return 0;
2143 : : }
2144 : :
2145 : : static int
2146 : 422 : hashlib_init_evpxoftype(PyObject *module)
2147 : : {
2148 : : #ifdef PY_OPENSSL_HAS_SHAKE
2149 : 422 : _hashlibstate *state = get_hashlib_state(module);
2150 : :
2151 [ - + ]: 422 : if (state->EVPtype == NULL) {
2152 : 0 : return -1;
2153 : : }
2154 : :
2155 : 844 : state->EVPXOFtype = (PyTypeObject *)PyType_FromSpecWithBases(
2156 : 422 : &EVPXOFtype_spec, (PyObject *)state->EVPtype
2157 : : );
2158 [ - + ]: 422 : if (state->EVPXOFtype == NULL) {
2159 : 0 : return -1;
2160 : : }
2161 [ - + ]: 422 : if (PyModule_AddType(module, state->EVPXOFtype) < 0) {
2162 : 0 : return -1;
2163 : : }
2164 : : #endif
2165 : 422 : return 0;
2166 : : }
2167 : :
2168 : : static int
2169 : 422 : hashlib_init_hmactype(PyObject *module)
2170 : : {
2171 : 422 : _hashlibstate *state = get_hashlib_state(module);
2172 : :
2173 : 422 : state->HMACtype = (PyTypeObject *)PyType_FromSpec(&HMACtype_spec);
2174 [ - + ]: 422 : if (state->HMACtype == NULL) {
2175 : 0 : return -1;
2176 : : }
2177 [ - + ]: 422 : if (PyModule_AddType(module, state->HMACtype) < 0) {
2178 : 0 : return -1;
2179 : : }
2180 : 422 : return 0;
2181 : : }
2182 : :
2183 : : static int
2184 : 422 : hashlib_init_constructors(PyObject *module)
2185 : : {
2186 : : /* Create dict from builtin openssl_hash functions to name
2187 : : * {_hashlib.openssl_sha256: "sha256", ...}
2188 : : */
2189 : : PyModuleDef *mdef;
2190 : : PyMethodDef *fdef;
2191 : : PyObject *proxy;
2192 : : PyObject *func, *name_obj;
2193 : 422 : _hashlibstate *state = get_hashlib_state(module);
2194 : :
2195 : 422 : mdef = PyModule_GetDef(module);
2196 [ - + ]: 422 : if (mdef == NULL) {
2197 : 0 : return -1;
2198 : : }
2199 : :
2200 : 422 : state->constructs = PyDict_New();
2201 [ - + ]: 422 : if (state->constructs == NULL) {
2202 : 0 : return -1;
2203 : : }
2204 : :
2205 [ + + ]: 8440 : for (fdef = mdef->m_methods; fdef->ml_name != NULL; fdef++) {
2206 [ + + ]: 8018 : if (strncmp(fdef->ml_name, "openssl_", 8)) {
2207 : 2954 : continue;
2208 : : }
2209 : 5064 : name_obj = PyUnicode_FromString(fdef->ml_name + 8);
2210 [ - + ]: 5064 : if (name_obj == NULL) {
2211 : 0 : return -1;
2212 : : }
2213 : 5064 : func = PyObject_GetAttrString(module, fdef->ml_name);
2214 [ - + ]: 5064 : if (func == NULL) {
2215 : 0 : Py_DECREF(name_obj);
2216 : 0 : return -1;
2217 : : }
2218 : 5064 : int rc = PyDict_SetItem(state->constructs, func, name_obj);
2219 : 5064 : Py_DECREF(func);
2220 : 5064 : Py_DECREF(name_obj);
2221 [ - + ]: 5064 : if (rc < 0) {
2222 : 0 : return -1;
2223 : : }
2224 : : }
2225 : :
2226 : 422 : proxy = PyDictProxy_New(state->constructs);
2227 [ - + ]: 422 : if (proxy == NULL) {
2228 : 0 : return -1;
2229 : : }
2230 : :
2231 : 422 : int rc = PyModule_AddObjectRef(module, "_constructors", proxy);
2232 : 422 : Py_DECREF(proxy);
2233 [ - + ]: 422 : if (rc < 0) {
2234 : 0 : return -1;
2235 : : }
2236 : 422 : return 0;
2237 : : }
2238 : :
2239 : : static int
2240 : 422 : hashlib_exception(PyObject *module)
2241 : : {
2242 : 422 : _hashlibstate *state = get_hashlib_state(module);
2243 : 422 : state->unsupported_digestmod_error = PyErr_NewException(
2244 : : "_hashlib.UnsupportedDigestmodError", PyExc_ValueError, NULL);
2245 [ - + ]: 422 : if (state->unsupported_digestmod_error == NULL) {
2246 : 0 : return -1;
2247 : : }
2248 [ - + ]: 422 : if (PyModule_AddObjectRef(module, "UnsupportedDigestmodError",
2249 : : state->unsupported_digestmod_error) < 0) {
2250 : 0 : return -1;
2251 : : }
2252 : 422 : return 0;
2253 : : }
2254 : :
2255 : :
2256 : : static PyModuleDef_Slot hashlib_slots[] = {
2257 : : {Py_mod_exec, hashlib_init_hashtable},
2258 : : {Py_mod_exec, hashlib_init_evptype},
2259 : : {Py_mod_exec, hashlib_init_evpxoftype},
2260 : : {Py_mod_exec, hashlib_init_hmactype},
2261 : : {Py_mod_exec, hashlib_md_meth_names},
2262 : : {Py_mod_exec, hashlib_init_constructors},
2263 : : {Py_mod_exec, hashlib_exception},
2264 : : {0, NULL}
2265 : : };
2266 : :
2267 : : static struct PyModuleDef _hashlibmodule = {
2268 : : PyModuleDef_HEAD_INIT,
2269 : : .m_name = "_hashlib",
2270 : : .m_doc = "OpenSSL interface for hashlib module",
2271 : : .m_size = sizeof(_hashlibstate),
2272 : : .m_methods = EVP_functions,
2273 : : .m_slots = hashlib_slots,
2274 : : .m_traverse = hashlib_traverse,
2275 : : .m_clear = hashlib_clear,
2276 : : .m_free = hashlib_free
2277 : : };
2278 : :
2279 : : PyMODINIT_FUNC
2280 : 422 : PyInit__hashlib(void)
2281 : : {
2282 : 422 : return PyModuleDef_Init(&_hashlibmodule);
2283 : : }
|
