LCOV - code coverage report
Current view: top level - Modules - _hashopenssl.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 206 733 28.1 %
Date: 2023-03-20 08:15:36 Functions: 34 69 49.3 %
Branches: 87 414 21.0 %

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

Generated by: LCOV version 1.14