LCOV - code coverage report
Current view: top level - Modules/clinic - _hashopenssl.c.h (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 204 543 37.6 %
Date: 2023-03-20 08:15:36 Functions: 12 28 42.9 %
Branches: 84 480 17.5 %

           Branch data     Line data    Source code
       1                 :            : /*[clinic input]
       2                 :            : preserve
       3                 :            : [clinic start generated code]*/
       4                 :            : 
       5                 :            : #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
       6                 :            : #  include "pycore_gc.h"            // PyGC_Head
       7                 :            : #  include "pycore_runtime.h"       // _Py_ID()
       8                 :            : #endif
       9                 :            : 
      10                 :            : 
      11                 :            : PyDoc_STRVAR(EVP_copy__doc__,
      12                 :            : "copy($self, /)\n"
      13                 :            : "--\n"
      14                 :            : "\n"
      15                 :            : "Return a copy of the hash object.");
      16                 :            : 
      17                 :            : #define EVP_COPY_METHODDEF    \
      18                 :            :     {"copy", (PyCFunction)EVP_copy, METH_NOARGS, EVP_copy__doc__},
      19                 :            : 
      20                 :            : static PyObject *
      21                 :            : EVP_copy_impl(EVPobject *self);
      22                 :            : 
      23                 :            : static PyObject *
      24                 :          0 : EVP_copy(EVPobject *self, PyObject *Py_UNUSED(ignored))
      25                 :            : {
      26                 :          0 :     return EVP_copy_impl(self);
      27                 :            : }
      28                 :            : 
      29                 :            : PyDoc_STRVAR(EVP_digest__doc__,
      30                 :            : "digest($self, /)\n"
      31                 :            : "--\n"
      32                 :            : "\n"
      33                 :            : "Return the digest value as a bytes object.");
      34                 :            : 
      35                 :            : #define EVP_DIGEST_METHODDEF    \
      36                 :            :     {"digest", (PyCFunction)EVP_digest, METH_NOARGS, EVP_digest__doc__},
      37                 :            : 
      38                 :            : static PyObject *
      39                 :            : EVP_digest_impl(EVPobject *self);
      40                 :            : 
      41                 :            : static PyObject *
      42                 :          0 : EVP_digest(EVPobject *self, PyObject *Py_UNUSED(ignored))
      43                 :            : {
      44                 :          0 :     return EVP_digest_impl(self);
      45                 :            : }
      46                 :            : 
      47                 :            : PyDoc_STRVAR(EVP_hexdigest__doc__,
      48                 :            : "hexdigest($self, /)\n"
      49                 :            : "--\n"
      50                 :            : "\n"
      51                 :            : "Return the digest value as a string of hexadecimal digits.");
      52                 :            : 
      53                 :            : #define EVP_HEXDIGEST_METHODDEF    \
      54                 :            :     {"hexdigest", (PyCFunction)EVP_hexdigest, METH_NOARGS, EVP_hexdigest__doc__},
      55                 :            : 
      56                 :            : static PyObject *
      57                 :            : EVP_hexdigest_impl(EVPobject *self);
      58                 :            : 
      59                 :            : static PyObject *
      60                 :          0 : EVP_hexdigest(EVPobject *self, PyObject *Py_UNUSED(ignored))
      61                 :            : {
      62                 :          0 :     return EVP_hexdigest_impl(self);
      63                 :            : }
      64                 :            : 
      65                 :            : PyDoc_STRVAR(EVP_update__doc__,
      66                 :            : "update($self, obj, /)\n"
      67                 :            : "--\n"
      68                 :            : "\n"
      69                 :            : "Update this hash object\'s state with the provided string.");
      70                 :            : 
      71                 :            : #define EVP_UPDATE_METHODDEF    \
      72                 :            :     {"update", (PyCFunction)EVP_update, METH_O, EVP_update__doc__},
      73                 :            : 
      74                 :            : #if defined(PY_OPENSSL_HAS_SHAKE)
      75                 :            : 
      76                 :            : PyDoc_STRVAR(EVPXOF_digest__doc__,
      77                 :            : "digest($self, /, length)\n"
      78                 :            : "--\n"
      79                 :            : "\n"
      80                 :            : "Return the digest value as a bytes object.");
      81                 :            : 
      82                 :            : #define EVPXOF_DIGEST_METHODDEF    \
      83                 :            :     {"digest", _PyCFunction_CAST(EVPXOF_digest), METH_FASTCALL|METH_KEYWORDS, EVPXOF_digest__doc__},
      84                 :            : 
      85                 :            : static PyObject *
      86                 :            : EVPXOF_digest_impl(EVPobject *self, Py_ssize_t length);
      87                 :            : 
      88                 :            : static PyObject *
      89                 :          0 : EVPXOF_digest(EVPobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
      90                 :            : {
      91                 :          0 :     PyObject *return_value = NULL;
      92                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
      93                 :            : 
      94                 :            :     #define NUM_KEYWORDS 1
      95                 :            :     static struct {
      96                 :            :         PyGC_Head _this_is_not_used;
      97                 :            :         PyObject_VAR_HEAD
      98                 :            :         PyObject *ob_item[NUM_KEYWORDS];
      99                 :            :     } _kwtuple = {
     100                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     101                 :            :         .ob_item = { &_Py_ID(length), },
     102                 :            :     };
     103                 :            :     #undef NUM_KEYWORDS
     104                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     105                 :            : 
     106                 :            :     #else  // !Py_BUILD_CORE
     107                 :            :     #  define KWTUPLE NULL
     108                 :            :     #endif  // !Py_BUILD_CORE
     109                 :            : 
     110                 :            :     static const char * const _keywords[] = {"length", NULL};
     111                 :            :     static _PyArg_Parser _parser = {
     112                 :            :         .keywords = _keywords,
     113                 :            :         .fname = "digest",
     114                 :            :         .kwtuple = KWTUPLE,
     115                 :            :     };
     116                 :            :     #undef KWTUPLE
     117                 :            :     PyObject *argsbuf[1];
     118                 :            :     Py_ssize_t length;
     119                 :            : 
     120   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     121         [ #  # ]:          0 :     if (!args) {
     122                 :          0 :         goto exit;
     123                 :            :     }
     124                 :            :     {
     125                 :          0 :         Py_ssize_t ival = -1;
     126                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     127         [ #  # ]:          0 :         if (iobj != NULL) {
     128                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     129                 :          0 :             Py_DECREF(iobj);
     130                 :            :         }
     131   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     132                 :          0 :             goto exit;
     133                 :            :         }
     134                 :          0 :         length = ival;
     135                 :            :     }
     136                 :          0 :     return_value = EVPXOF_digest_impl(self, length);
     137                 :            : 
     138                 :          0 : exit:
     139                 :          0 :     return return_value;
     140                 :            : }
     141                 :            : 
     142                 :            : #endif /* defined(PY_OPENSSL_HAS_SHAKE) */
     143                 :            : 
     144                 :            : #if defined(PY_OPENSSL_HAS_SHAKE)
     145                 :            : 
     146                 :            : PyDoc_STRVAR(EVPXOF_hexdigest__doc__,
     147                 :            : "hexdigest($self, /, length)\n"
     148                 :            : "--\n"
     149                 :            : "\n"
     150                 :            : "Return the digest value as a string of hexadecimal digits.");
     151                 :            : 
     152                 :            : #define EVPXOF_HEXDIGEST_METHODDEF    \
     153                 :            :     {"hexdigest", _PyCFunction_CAST(EVPXOF_hexdigest), METH_FASTCALL|METH_KEYWORDS, EVPXOF_hexdigest__doc__},
     154                 :            : 
     155                 :            : static PyObject *
     156                 :            : EVPXOF_hexdigest_impl(EVPobject *self, Py_ssize_t length);
     157                 :            : 
     158                 :            : static PyObject *
     159                 :          0 : EVPXOF_hexdigest(EVPobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     160                 :            : {
     161                 :          0 :     PyObject *return_value = NULL;
     162                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     163                 :            : 
     164                 :            :     #define NUM_KEYWORDS 1
     165                 :            :     static struct {
     166                 :            :         PyGC_Head _this_is_not_used;
     167                 :            :         PyObject_VAR_HEAD
     168                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     169                 :            :     } _kwtuple = {
     170                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     171                 :            :         .ob_item = { &_Py_ID(length), },
     172                 :            :     };
     173                 :            :     #undef NUM_KEYWORDS
     174                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     175                 :            : 
     176                 :            :     #else  // !Py_BUILD_CORE
     177                 :            :     #  define KWTUPLE NULL
     178                 :            :     #endif  // !Py_BUILD_CORE
     179                 :            : 
     180                 :            :     static const char * const _keywords[] = {"length", NULL};
     181                 :            :     static _PyArg_Parser _parser = {
     182                 :            :         .keywords = _keywords,
     183                 :            :         .fname = "hexdigest",
     184                 :            :         .kwtuple = KWTUPLE,
     185                 :            :     };
     186                 :            :     #undef KWTUPLE
     187                 :            :     PyObject *argsbuf[1];
     188                 :            :     Py_ssize_t length;
     189                 :            : 
     190   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
     191         [ #  # ]:          0 :     if (!args) {
     192                 :          0 :         goto exit;
     193                 :            :     }
     194                 :            :     {
     195                 :          0 :         Py_ssize_t ival = -1;
     196                 :          0 :         PyObject *iobj = _PyNumber_Index(args[0]);
     197         [ #  # ]:          0 :         if (iobj != NULL) {
     198                 :          0 :             ival = PyLong_AsSsize_t(iobj);
     199                 :          0 :             Py_DECREF(iobj);
     200                 :            :         }
     201   [ #  #  #  # ]:          0 :         if (ival == -1 && PyErr_Occurred()) {
     202                 :          0 :             goto exit;
     203                 :            :         }
     204                 :          0 :         length = ival;
     205                 :            :     }
     206                 :          0 :     return_value = EVPXOF_hexdigest_impl(self, length);
     207                 :            : 
     208                 :          0 : exit:
     209                 :          0 :     return return_value;
     210                 :            : }
     211                 :            : 
     212                 :            : #endif /* defined(PY_OPENSSL_HAS_SHAKE) */
     213                 :            : 
     214                 :            : PyDoc_STRVAR(EVP_new__doc__,
     215                 :            : "new($module, /, name, string=b\'\', *, usedforsecurity=True)\n"
     216                 :            : "--\n"
     217                 :            : "\n"
     218                 :            : "Return a new hash object using the named algorithm.\n"
     219                 :            : "\n"
     220                 :            : "An optional string argument may be provided and will be\n"
     221                 :            : "automatically hashed.\n"
     222                 :            : "\n"
     223                 :            : "The MD5 and SHA1 algorithms are always supported.");
     224                 :            : 
     225                 :            : #define EVP_NEW_METHODDEF    \
     226                 :            :     {"new", _PyCFunction_CAST(EVP_new), METH_FASTCALL|METH_KEYWORDS, EVP_new__doc__},
     227                 :            : 
     228                 :            : static PyObject *
     229                 :            : EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj,
     230                 :            :              int usedforsecurity);
     231                 :            : 
     232                 :            : static PyObject *
     233                 :          0 : EVP_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     234                 :            : {
     235                 :          0 :     PyObject *return_value = NULL;
     236                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     237                 :            : 
     238                 :            :     #define NUM_KEYWORDS 3
     239                 :            :     static struct {
     240                 :            :         PyGC_Head _this_is_not_used;
     241                 :            :         PyObject_VAR_HEAD
     242                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     243                 :            :     } _kwtuple = {
     244                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     245                 :            :         .ob_item = { &_Py_ID(name), &_Py_ID(string), &_Py_ID(usedforsecurity), },
     246                 :            :     };
     247                 :            :     #undef NUM_KEYWORDS
     248                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     249                 :            : 
     250                 :            :     #else  // !Py_BUILD_CORE
     251                 :            :     #  define KWTUPLE NULL
     252                 :            :     #endif  // !Py_BUILD_CORE
     253                 :            : 
     254                 :            :     static const char * const _keywords[] = {"name", "string", "usedforsecurity", NULL};
     255                 :            :     static _PyArg_Parser _parser = {
     256                 :            :         .keywords = _keywords,
     257                 :            :         .fname = "new",
     258                 :            :         .kwtuple = KWTUPLE,
     259                 :            :     };
     260                 :            :     #undef KWTUPLE
     261                 :            :     PyObject *argsbuf[3];
     262         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
     263                 :            :     PyObject *name_obj;
     264                 :          0 :     PyObject *data_obj = NULL;
     265                 :          0 :     int usedforsecurity = 1;
     266                 :            : 
     267   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
             #  #  #  # ]
     268         [ #  # ]:          0 :     if (!args) {
     269                 :          0 :         goto exit;
     270                 :            :     }
     271                 :          0 :     name_obj = args[0];
     272         [ #  # ]:          0 :     if (!noptargs) {
     273                 :          0 :         goto skip_optional_pos;
     274                 :            :     }
     275         [ #  # ]:          0 :     if (args[1]) {
     276                 :          0 :         data_obj = args[1];
     277         [ #  # ]:          0 :         if (!--noptargs) {
     278                 :          0 :             goto skip_optional_pos;
     279                 :            :         }
     280                 :            :     }
     281                 :          0 : skip_optional_pos:
     282         [ #  # ]:          0 :     if (!noptargs) {
     283                 :          0 :         goto skip_optional_kwonly;
     284                 :            :     }
     285                 :          0 :     usedforsecurity = PyObject_IsTrue(args[2]);
     286         [ #  # ]:          0 :     if (usedforsecurity < 0) {
     287                 :          0 :         goto exit;
     288                 :            :     }
     289                 :          0 : skip_optional_kwonly:
     290                 :          0 :     return_value = EVP_new_impl(module, name_obj, data_obj, usedforsecurity);
     291                 :            : 
     292                 :          0 : exit:
     293                 :          0 :     return return_value;
     294                 :            : }
     295                 :            : 
     296                 :            : PyDoc_STRVAR(_hashlib_openssl_md5__doc__,
     297                 :            : "openssl_md5($module, /, string=b\'\', *, usedforsecurity=True)\n"
     298                 :            : "--\n"
     299                 :            : "\n"
     300                 :            : "Returns a md5 hash object; optionally initialized with a string");
     301                 :            : 
     302                 :            : #define _HASHLIB_OPENSSL_MD5_METHODDEF    \
     303                 :            :     {"openssl_md5", _PyCFunction_CAST(_hashlib_openssl_md5), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_md5__doc__},
     304                 :            : 
     305                 :            : static PyObject *
     306                 :            : _hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj,
     307                 :            :                           int usedforsecurity);
     308                 :            : 
     309                 :            : static PyObject *
     310                 :          1 : _hashlib_openssl_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     311                 :            : {
     312                 :          1 :     PyObject *return_value = NULL;
     313                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     314                 :            : 
     315                 :            :     #define NUM_KEYWORDS 2
     316                 :            :     static struct {
     317                 :            :         PyGC_Head _this_is_not_used;
     318                 :            :         PyObject_VAR_HEAD
     319                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     320                 :            :     } _kwtuple = {
     321                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     322                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     323                 :            :     };
     324                 :            :     #undef NUM_KEYWORDS
     325                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     326                 :            : 
     327                 :            :     #else  // !Py_BUILD_CORE
     328                 :            :     #  define KWTUPLE NULL
     329                 :            :     #endif  // !Py_BUILD_CORE
     330                 :            : 
     331                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     332                 :            :     static _PyArg_Parser _parser = {
     333                 :            :         .keywords = _keywords,
     334                 :            :         .fname = "openssl_md5",
     335                 :            :         .kwtuple = KWTUPLE,
     336                 :            :     };
     337                 :            :     #undef KWTUPLE
     338                 :            :     PyObject *argsbuf[2];
     339         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     340                 :          1 :     PyObject *data_obj = NULL;
     341                 :          1 :     int usedforsecurity = 1;
     342                 :            : 
     343   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     344         [ -  + ]:          1 :     if (!args) {
     345                 :          0 :         goto exit;
     346                 :            :     }
     347         [ -  + ]:          1 :     if (!noptargs) {
     348                 :          0 :         goto skip_optional_pos;
     349                 :            :     }
     350         [ +  - ]:          1 :     if (args[0]) {
     351                 :          0 :         data_obj = args[0];
     352         [ #  # ]:          0 :         if (!--noptargs) {
     353                 :          0 :             goto skip_optional_pos;
     354                 :            :         }
     355                 :            :     }
     356                 :          1 : skip_optional_pos:
     357         [ -  + ]:          1 :     if (!noptargs) {
     358                 :          0 :         goto skip_optional_kwonly;
     359                 :            :     }
     360                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     361         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     362                 :          0 :         goto exit;
     363                 :            :     }
     364                 :          1 : skip_optional_kwonly:
     365                 :          1 :     return_value = _hashlib_openssl_md5_impl(module, data_obj, usedforsecurity);
     366                 :            : 
     367                 :          1 : exit:
     368                 :          1 :     return return_value;
     369                 :            : }
     370                 :            : 
     371                 :            : PyDoc_STRVAR(_hashlib_openssl_sha1__doc__,
     372                 :            : "openssl_sha1($module, /, string=b\'\', *, usedforsecurity=True)\n"
     373                 :            : "--\n"
     374                 :            : "\n"
     375                 :            : "Returns a sha1 hash object; optionally initialized with a string");
     376                 :            : 
     377                 :            : #define _HASHLIB_OPENSSL_SHA1_METHODDEF    \
     378                 :            :     {"openssl_sha1", _PyCFunction_CAST(_hashlib_openssl_sha1), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha1__doc__},
     379                 :            : 
     380                 :            : static PyObject *
     381                 :            : _hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj,
     382                 :            :                            int usedforsecurity);
     383                 :            : 
     384                 :            : static PyObject *
     385                 :          1 : _hashlib_openssl_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     386                 :            : {
     387                 :          1 :     PyObject *return_value = NULL;
     388                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     389                 :            : 
     390                 :            :     #define NUM_KEYWORDS 2
     391                 :            :     static struct {
     392                 :            :         PyGC_Head _this_is_not_used;
     393                 :            :         PyObject_VAR_HEAD
     394                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     395                 :            :     } _kwtuple = {
     396                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     397                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     398                 :            :     };
     399                 :            :     #undef NUM_KEYWORDS
     400                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     401                 :            : 
     402                 :            :     #else  // !Py_BUILD_CORE
     403                 :            :     #  define KWTUPLE NULL
     404                 :            :     #endif  // !Py_BUILD_CORE
     405                 :            : 
     406                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     407                 :            :     static _PyArg_Parser _parser = {
     408                 :            :         .keywords = _keywords,
     409                 :            :         .fname = "openssl_sha1",
     410                 :            :         .kwtuple = KWTUPLE,
     411                 :            :     };
     412                 :            :     #undef KWTUPLE
     413                 :            :     PyObject *argsbuf[2];
     414         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     415                 :          1 :     PyObject *data_obj = NULL;
     416                 :          1 :     int usedforsecurity = 1;
     417                 :            : 
     418   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     419         [ -  + ]:          1 :     if (!args) {
     420                 :          0 :         goto exit;
     421                 :            :     }
     422         [ -  + ]:          1 :     if (!noptargs) {
     423                 :          0 :         goto skip_optional_pos;
     424                 :            :     }
     425         [ +  - ]:          1 :     if (args[0]) {
     426                 :          0 :         data_obj = args[0];
     427         [ #  # ]:          0 :         if (!--noptargs) {
     428                 :          0 :             goto skip_optional_pos;
     429                 :            :         }
     430                 :            :     }
     431                 :          1 : skip_optional_pos:
     432         [ -  + ]:          1 :     if (!noptargs) {
     433                 :          0 :         goto skip_optional_kwonly;
     434                 :            :     }
     435                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     436         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     437                 :          0 :         goto exit;
     438                 :            :     }
     439                 :          1 : skip_optional_kwonly:
     440                 :          1 :     return_value = _hashlib_openssl_sha1_impl(module, data_obj, usedforsecurity);
     441                 :            : 
     442                 :          1 : exit:
     443                 :          1 :     return return_value;
     444                 :            : }
     445                 :            : 
     446                 :            : PyDoc_STRVAR(_hashlib_openssl_sha224__doc__,
     447                 :            : "openssl_sha224($module, /, string=b\'\', *, usedforsecurity=True)\n"
     448                 :            : "--\n"
     449                 :            : "\n"
     450                 :            : "Returns a sha224 hash object; optionally initialized with a string");
     451                 :            : 
     452                 :            : #define _HASHLIB_OPENSSL_SHA224_METHODDEF    \
     453                 :            :     {"openssl_sha224", _PyCFunction_CAST(_hashlib_openssl_sha224), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha224__doc__},
     454                 :            : 
     455                 :            : static PyObject *
     456                 :            : _hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj,
     457                 :            :                              int usedforsecurity);
     458                 :            : 
     459                 :            : static PyObject *
     460                 :          1 : _hashlib_openssl_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     461                 :            : {
     462                 :          1 :     PyObject *return_value = NULL;
     463                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     464                 :            : 
     465                 :            :     #define NUM_KEYWORDS 2
     466                 :            :     static struct {
     467                 :            :         PyGC_Head _this_is_not_used;
     468                 :            :         PyObject_VAR_HEAD
     469                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     470                 :            :     } _kwtuple = {
     471                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     472                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     473                 :            :     };
     474                 :            :     #undef NUM_KEYWORDS
     475                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     476                 :            : 
     477                 :            :     #else  // !Py_BUILD_CORE
     478                 :            :     #  define KWTUPLE NULL
     479                 :            :     #endif  // !Py_BUILD_CORE
     480                 :            : 
     481                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     482                 :            :     static _PyArg_Parser _parser = {
     483                 :            :         .keywords = _keywords,
     484                 :            :         .fname = "openssl_sha224",
     485                 :            :         .kwtuple = KWTUPLE,
     486                 :            :     };
     487                 :            :     #undef KWTUPLE
     488                 :            :     PyObject *argsbuf[2];
     489         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     490                 :          1 :     PyObject *data_obj = NULL;
     491                 :          1 :     int usedforsecurity = 1;
     492                 :            : 
     493   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     494         [ -  + ]:          1 :     if (!args) {
     495                 :          0 :         goto exit;
     496                 :            :     }
     497         [ -  + ]:          1 :     if (!noptargs) {
     498                 :          0 :         goto skip_optional_pos;
     499                 :            :     }
     500         [ +  - ]:          1 :     if (args[0]) {
     501                 :          0 :         data_obj = args[0];
     502         [ #  # ]:          0 :         if (!--noptargs) {
     503                 :          0 :             goto skip_optional_pos;
     504                 :            :         }
     505                 :            :     }
     506                 :          1 : skip_optional_pos:
     507         [ -  + ]:          1 :     if (!noptargs) {
     508                 :          0 :         goto skip_optional_kwonly;
     509                 :            :     }
     510                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     511         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     512                 :          0 :         goto exit;
     513                 :            :     }
     514                 :          1 : skip_optional_kwonly:
     515                 :          1 :     return_value = _hashlib_openssl_sha224_impl(module, data_obj, usedforsecurity);
     516                 :            : 
     517                 :          1 : exit:
     518                 :          1 :     return return_value;
     519                 :            : }
     520                 :            : 
     521                 :            : PyDoc_STRVAR(_hashlib_openssl_sha256__doc__,
     522                 :            : "openssl_sha256($module, /, string=b\'\', *, usedforsecurity=True)\n"
     523                 :            : "--\n"
     524                 :            : "\n"
     525                 :            : "Returns a sha256 hash object; optionally initialized with a string");
     526                 :            : 
     527                 :            : #define _HASHLIB_OPENSSL_SHA256_METHODDEF    \
     528                 :            :     {"openssl_sha256", _PyCFunction_CAST(_hashlib_openssl_sha256), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha256__doc__},
     529                 :            : 
     530                 :            : static PyObject *
     531                 :            : _hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj,
     532                 :            :                              int usedforsecurity);
     533                 :            : 
     534                 :            : static PyObject *
     535                 :          1 : _hashlib_openssl_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     536                 :            : {
     537                 :          1 :     PyObject *return_value = NULL;
     538                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     539                 :            : 
     540                 :            :     #define NUM_KEYWORDS 2
     541                 :            :     static struct {
     542                 :            :         PyGC_Head _this_is_not_used;
     543                 :            :         PyObject_VAR_HEAD
     544                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     545                 :            :     } _kwtuple = {
     546                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     547                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     548                 :            :     };
     549                 :            :     #undef NUM_KEYWORDS
     550                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     551                 :            : 
     552                 :            :     #else  // !Py_BUILD_CORE
     553                 :            :     #  define KWTUPLE NULL
     554                 :            :     #endif  // !Py_BUILD_CORE
     555                 :            : 
     556                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     557                 :            :     static _PyArg_Parser _parser = {
     558                 :            :         .keywords = _keywords,
     559                 :            :         .fname = "openssl_sha256",
     560                 :            :         .kwtuple = KWTUPLE,
     561                 :            :     };
     562                 :            :     #undef KWTUPLE
     563                 :            :     PyObject *argsbuf[2];
     564         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     565                 :          1 :     PyObject *data_obj = NULL;
     566                 :          1 :     int usedforsecurity = 1;
     567                 :            : 
     568   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     569         [ -  + ]:          1 :     if (!args) {
     570                 :          0 :         goto exit;
     571                 :            :     }
     572         [ -  + ]:          1 :     if (!noptargs) {
     573                 :          0 :         goto skip_optional_pos;
     574                 :            :     }
     575         [ +  - ]:          1 :     if (args[0]) {
     576                 :          0 :         data_obj = args[0];
     577         [ #  # ]:          0 :         if (!--noptargs) {
     578                 :          0 :             goto skip_optional_pos;
     579                 :            :         }
     580                 :            :     }
     581                 :          1 : skip_optional_pos:
     582         [ -  + ]:          1 :     if (!noptargs) {
     583                 :          0 :         goto skip_optional_kwonly;
     584                 :            :     }
     585                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     586         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     587                 :          0 :         goto exit;
     588                 :            :     }
     589                 :          1 : skip_optional_kwonly:
     590                 :          1 :     return_value = _hashlib_openssl_sha256_impl(module, data_obj, usedforsecurity);
     591                 :            : 
     592                 :          1 : exit:
     593                 :          1 :     return return_value;
     594                 :            : }
     595                 :            : 
     596                 :            : PyDoc_STRVAR(_hashlib_openssl_sha384__doc__,
     597                 :            : "openssl_sha384($module, /, string=b\'\', *, usedforsecurity=True)\n"
     598                 :            : "--\n"
     599                 :            : "\n"
     600                 :            : "Returns a sha384 hash object; optionally initialized with a string");
     601                 :            : 
     602                 :            : #define _HASHLIB_OPENSSL_SHA384_METHODDEF    \
     603                 :            :     {"openssl_sha384", _PyCFunction_CAST(_hashlib_openssl_sha384), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha384__doc__},
     604                 :            : 
     605                 :            : static PyObject *
     606                 :            : _hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj,
     607                 :            :                              int usedforsecurity);
     608                 :            : 
     609                 :            : static PyObject *
     610                 :          1 : _hashlib_openssl_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     611                 :            : {
     612                 :          1 :     PyObject *return_value = NULL;
     613                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     614                 :            : 
     615                 :            :     #define NUM_KEYWORDS 2
     616                 :            :     static struct {
     617                 :            :         PyGC_Head _this_is_not_used;
     618                 :            :         PyObject_VAR_HEAD
     619                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     620                 :            :     } _kwtuple = {
     621                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     622                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     623                 :            :     };
     624                 :            :     #undef NUM_KEYWORDS
     625                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     626                 :            : 
     627                 :            :     #else  // !Py_BUILD_CORE
     628                 :            :     #  define KWTUPLE NULL
     629                 :            :     #endif  // !Py_BUILD_CORE
     630                 :            : 
     631                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     632                 :            :     static _PyArg_Parser _parser = {
     633                 :            :         .keywords = _keywords,
     634                 :            :         .fname = "openssl_sha384",
     635                 :            :         .kwtuple = KWTUPLE,
     636                 :            :     };
     637                 :            :     #undef KWTUPLE
     638                 :            :     PyObject *argsbuf[2];
     639         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     640                 :          1 :     PyObject *data_obj = NULL;
     641                 :          1 :     int usedforsecurity = 1;
     642                 :            : 
     643   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     644         [ -  + ]:          1 :     if (!args) {
     645                 :          0 :         goto exit;
     646                 :            :     }
     647         [ -  + ]:          1 :     if (!noptargs) {
     648                 :          0 :         goto skip_optional_pos;
     649                 :            :     }
     650         [ +  - ]:          1 :     if (args[0]) {
     651                 :          0 :         data_obj = args[0];
     652         [ #  # ]:          0 :         if (!--noptargs) {
     653                 :          0 :             goto skip_optional_pos;
     654                 :            :         }
     655                 :            :     }
     656                 :          1 : skip_optional_pos:
     657         [ -  + ]:          1 :     if (!noptargs) {
     658                 :          0 :         goto skip_optional_kwonly;
     659                 :            :     }
     660                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     661         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     662                 :          0 :         goto exit;
     663                 :            :     }
     664                 :          1 : skip_optional_kwonly:
     665                 :          1 :     return_value = _hashlib_openssl_sha384_impl(module, data_obj, usedforsecurity);
     666                 :            : 
     667                 :          1 : exit:
     668                 :          1 :     return return_value;
     669                 :            : }
     670                 :            : 
     671                 :            : PyDoc_STRVAR(_hashlib_openssl_sha512__doc__,
     672                 :            : "openssl_sha512($module, /, string=b\'\', *, usedforsecurity=True)\n"
     673                 :            : "--\n"
     674                 :            : "\n"
     675                 :            : "Returns a sha512 hash object; optionally initialized with a string");
     676                 :            : 
     677                 :            : #define _HASHLIB_OPENSSL_SHA512_METHODDEF    \
     678                 :            :     {"openssl_sha512", _PyCFunction_CAST(_hashlib_openssl_sha512), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha512__doc__},
     679                 :            : 
     680                 :            : static PyObject *
     681                 :            : _hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj,
     682                 :            :                              int usedforsecurity);
     683                 :            : 
     684                 :            : static PyObject *
     685                 :          1 : _hashlib_openssl_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     686                 :            : {
     687                 :          1 :     PyObject *return_value = NULL;
     688                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     689                 :            : 
     690                 :            :     #define NUM_KEYWORDS 2
     691                 :            :     static struct {
     692                 :            :         PyGC_Head _this_is_not_used;
     693                 :            :         PyObject_VAR_HEAD
     694                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     695                 :            :     } _kwtuple = {
     696                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     697                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     698                 :            :     };
     699                 :            :     #undef NUM_KEYWORDS
     700                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     701                 :            : 
     702                 :            :     #else  // !Py_BUILD_CORE
     703                 :            :     #  define KWTUPLE NULL
     704                 :            :     #endif  // !Py_BUILD_CORE
     705                 :            : 
     706                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     707                 :            :     static _PyArg_Parser _parser = {
     708                 :            :         .keywords = _keywords,
     709                 :            :         .fname = "openssl_sha512",
     710                 :            :         .kwtuple = KWTUPLE,
     711                 :            :     };
     712                 :            :     #undef KWTUPLE
     713                 :            :     PyObject *argsbuf[2];
     714         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     715                 :          1 :     PyObject *data_obj = NULL;
     716                 :          1 :     int usedforsecurity = 1;
     717                 :            : 
     718   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     719         [ -  + ]:          1 :     if (!args) {
     720                 :          0 :         goto exit;
     721                 :            :     }
     722         [ -  + ]:          1 :     if (!noptargs) {
     723                 :          0 :         goto skip_optional_pos;
     724                 :            :     }
     725         [ +  - ]:          1 :     if (args[0]) {
     726                 :          0 :         data_obj = args[0];
     727         [ #  # ]:          0 :         if (!--noptargs) {
     728                 :          0 :             goto skip_optional_pos;
     729                 :            :         }
     730                 :            :     }
     731                 :          1 : skip_optional_pos:
     732         [ -  + ]:          1 :     if (!noptargs) {
     733                 :          0 :         goto skip_optional_kwonly;
     734                 :            :     }
     735                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     736         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     737                 :          0 :         goto exit;
     738                 :            :     }
     739                 :          1 : skip_optional_kwonly:
     740                 :          1 :     return_value = _hashlib_openssl_sha512_impl(module, data_obj, usedforsecurity);
     741                 :            : 
     742                 :          1 : exit:
     743                 :          1 :     return return_value;
     744                 :            : }
     745                 :            : 
     746                 :            : #if defined(PY_OPENSSL_HAS_SHA3)
     747                 :            : 
     748                 :            : PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__,
     749                 :            : "openssl_sha3_224($module, /, string=b\'\', *, usedforsecurity=True)\n"
     750                 :            : "--\n"
     751                 :            : "\n"
     752                 :            : "Returns a sha3-224 hash object; optionally initialized with a string");
     753                 :            : 
     754                 :            : #define _HASHLIB_OPENSSL_SHA3_224_METHODDEF    \
     755                 :            :     {"openssl_sha3_224", _PyCFunction_CAST(_hashlib_openssl_sha3_224), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_224__doc__},
     756                 :            : 
     757                 :            : static PyObject *
     758                 :            : _hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj,
     759                 :            :                                int usedforsecurity);
     760                 :            : 
     761                 :            : static PyObject *
     762                 :          1 : _hashlib_openssl_sha3_224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     763                 :            : {
     764                 :          1 :     PyObject *return_value = NULL;
     765                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     766                 :            : 
     767                 :            :     #define NUM_KEYWORDS 2
     768                 :            :     static struct {
     769                 :            :         PyGC_Head _this_is_not_used;
     770                 :            :         PyObject_VAR_HEAD
     771                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     772                 :            :     } _kwtuple = {
     773                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     774                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     775                 :            :     };
     776                 :            :     #undef NUM_KEYWORDS
     777                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     778                 :            : 
     779                 :            :     #else  // !Py_BUILD_CORE
     780                 :            :     #  define KWTUPLE NULL
     781                 :            :     #endif  // !Py_BUILD_CORE
     782                 :            : 
     783                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     784                 :            :     static _PyArg_Parser _parser = {
     785                 :            :         .keywords = _keywords,
     786                 :            :         .fname = "openssl_sha3_224",
     787                 :            :         .kwtuple = KWTUPLE,
     788                 :            :     };
     789                 :            :     #undef KWTUPLE
     790                 :            :     PyObject *argsbuf[2];
     791         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     792                 :          1 :     PyObject *data_obj = NULL;
     793                 :          1 :     int usedforsecurity = 1;
     794                 :            : 
     795   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     796         [ -  + ]:          1 :     if (!args) {
     797                 :          0 :         goto exit;
     798                 :            :     }
     799         [ -  + ]:          1 :     if (!noptargs) {
     800                 :          0 :         goto skip_optional_pos;
     801                 :            :     }
     802         [ +  - ]:          1 :     if (args[0]) {
     803                 :          0 :         data_obj = args[0];
     804         [ #  # ]:          0 :         if (!--noptargs) {
     805                 :          0 :             goto skip_optional_pos;
     806                 :            :         }
     807                 :            :     }
     808                 :          1 : skip_optional_pos:
     809         [ -  + ]:          1 :     if (!noptargs) {
     810                 :          0 :         goto skip_optional_kwonly;
     811                 :            :     }
     812                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     813         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     814                 :          0 :         goto exit;
     815                 :            :     }
     816                 :          1 : skip_optional_kwonly:
     817                 :          1 :     return_value = _hashlib_openssl_sha3_224_impl(module, data_obj, usedforsecurity);
     818                 :            : 
     819                 :          1 : exit:
     820                 :          1 :     return return_value;
     821                 :            : }
     822                 :            : 
     823                 :            : #endif /* defined(PY_OPENSSL_HAS_SHA3) */
     824                 :            : 
     825                 :            : #if defined(PY_OPENSSL_HAS_SHA3)
     826                 :            : 
     827                 :            : PyDoc_STRVAR(_hashlib_openssl_sha3_256__doc__,
     828                 :            : "openssl_sha3_256($module, /, string=b\'\', *, usedforsecurity=True)\n"
     829                 :            : "--\n"
     830                 :            : "\n"
     831                 :            : "Returns a sha3-256 hash object; optionally initialized with a string");
     832                 :            : 
     833                 :            : #define _HASHLIB_OPENSSL_SHA3_256_METHODDEF    \
     834                 :            :     {"openssl_sha3_256", _PyCFunction_CAST(_hashlib_openssl_sha3_256), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_256__doc__},
     835                 :            : 
     836                 :            : static PyObject *
     837                 :            : _hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj,
     838                 :            :                                int usedforsecurity);
     839                 :            : 
     840                 :            : static PyObject *
     841                 :          1 : _hashlib_openssl_sha3_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     842                 :            : {
     843                 :          1 :     PyObject *return_value = NULL;
     844                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     845                 :            : 
     846                 :            :     #define NUM_KEYWORDS 2
     847                 :            :     static struct {
     848                 :            :         PyGC_Head _this_is_not_used;
     849                 :            :         PyObject_VAR_HEAD
     850                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     851                 :            :     } _kwtuple = {
     852                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     853                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     854                 :            :     };
     855                 :            :     #undef NUM_KEYWORDS
     856                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     857                 :            : 
     858                 :            :     #else  // !Py_BUILD_CORE
     859                 :            :     #  define KWTUPLE NULL
     860                 :            :     #endif  // !Py_BUILD_CORE
     861                 :            : 
     862                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     863                 :            :     static _PyArg_Parser _parser = {
     864                 :            :         .keywords = _keywords,
     865                 :            :         .fname = "openssl_sha3_256",
     866                 :            :         .kwtuple = KWTUPLE,
     867                 :            :     };
     868                 :            :     #undef KWTUPLE
     869                 :            :     PyObject *argsbuf[2];
     870         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     871                 :          1 :     PyObject *data_obj = NULL;
     872                 :          1 :     int usedforsecurity = 1;
     873                 :            : 
     874   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     875         [ -  + ]:          1 :     if (!args) {
     876                 :          0 :         goto exit;
     877                 :            :     }
     878         [ -  + ]:          1 :     if (!noptargs) {
     879                 :          0 :         goto skip_optional_pos;
     880                 :            :     }
     881         [ +  - ]:          1 :     if (args[0]) {
     882                 :          0 :         data_obj = args[0];
     883         [ #  # ]:          0 :         if (!--noptargs) {
     884                 :          0 :             goto skip_optional_pos;
     885                 :            :         }
     886                 :            :     }
     887                 :          1 : skip_optional_pos:
     888         [ -  + ]:          1 :     if (!noptargs) {
     889                 :          0 :         goto skip_optional_kwonly;
     890                 :            :     }
     891                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     892         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     893                 :          0 :         goto exit;
     894                 :            :     }
     895                 :          1 : skip_optional_kwonly:
     896                 :          1 :     return_value = _hashlib_openssl_sha3_256_impl(module, data_obj, usedforsecurity);
     897                 :            : 
     898                 :          1 : exit:
     899                 :          1 :     return return_value;
     900                 :            : }
     901                 :            : 
     902                 :            : #endif /* defined(PY_OPENSSL_HAS_SHA3) */
     903                 :            : 
     904                 :            : #if defined(PY_OPENSSL_HAS_SHA3)
     905                 :            : 
     906                 :            : PyDoc_STRVAR(_hashlib_openssl_sha3_384__doc__,
     907                 :            : "openssl_sha3_384($module, /, string=b\'\', *, usedforsecurity=True)\n"
     908                 :            : "--\n"
     909                 :            : "\n"
     910                 :            : "Returns a sha3-384 hash object; optionally initialized with a string");
     911                 :            : 
     912                 :            : #define _HASHLIB_OPENSSL_SHA3_384_METHODDEF    \
     913                 :            :     {"openssl_sha3_384", _PyCFunction_CAST(_hashlib_openssl_sha3_384), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_384__doc__},
     914                 :            : 
     915                 :            : static PyObject *
     916                 :            : _hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj,
     917                 :            :                                int usedforsecurity);
     918                 :            : 
     919                 :            : static PyObject *
     920                 :          1 : _hashlib_openssl_sha3_384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
     921                 :            : {
     922                 :          1 :     PyObject *return_value = NULL;
     923                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
     924                 :            : 
     925                 :            :     #define NUM_KEYWORDS 2
     926                 :            :     static struct {
     927                 :            :         PyGC_Head _this_is_not_used;
     928                 :            :         PyObject_VAR_HEAD
     929                 :            :         PyObject *ob_item[NUM_KEYWORDS];
     930                 :            :     } _kwtuple = {
     931                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
     932                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
     933                 :            :     };
     934                 :            :     #undef NUM_KEYWORDS
     935                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
     936                 :            : 
     937                 :            :     #else  // !Py_BUILD_CORE
     938                 :            :     #  define KWTUPLE NULL
     939                 :            :     #endif  // !Py_BUILD_CORE
     940                 :            : 
     941                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
     942                 :            :     static _PyArg_Parser _parser = {
     943                 :            :         .keywords = _keywords,
     944                 :            :         .fname = "openssl_sha3_384",
     945                 :            :         .kwtuple = KWTUPLE,
     946                 :            :     };
     947                 :            :     #undef KWTUPLE
     948                 :            :     PyObject *argsbuf[2];
     949         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
     950                 :          1 :     PyObject *data_obj = NULL;
     951                 :          1 :     int usedforsecurity = 1;
     952                 :            : 
     953   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
     954         [ -  + ]:          1 :     if (!args) {
     955                 :          0 :         goto exit;
     956                 :            :     }
     957         [ -  + ]:          1 :     if (!noptargs) {
     958                 :          0 :         goto skip_optional_pos;
     959                 :            :     }
     960         [ +  - ]:          1 :     if (args[0]) {
     961                 :          0 :         data_obj = args[0];
     962         [ #  # ]:          0 :         if (!--noptargs) {
     963                 :          0 :             goto skip_optional_pos;
     964                 :            :         }
     965                 :            :     }
     966                 :          1 : skip_optional_pos:
     967         [ -  + ]:          1 :     if (!noptargs) {
     968                 :          0 :         goto skip_optional_kwonly;
     969                 :            :     }
     970                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
     971         [ -  + ]:          1 :     if (usedforsecurity < 0) {
     972                 :          0 :         goto exit;
     973                 :            :     }
     974                 :          1 : skip_optional_kwonly:
     975                 :          1 :     return_value = _hashlib_openssl_sha3_384_impl(module, data_obj, usedforsecurity);
     976                 :            : 
     977                 :          1 : exit:
     978                 :          1 :     return return_value;
     979                 :            : }
     980                 :            : 
     981                 :            : #endif /* defined(PY_OPENSSL_HAS_SHA3) */
     982                 :            : 
     983                 :            : #if defined(PY_OPENSSL_HAS_SHA3)
     984                 :            : 
     985                 :            : PyDoc_STRVAR(_hashlib_openssl_sha3_512__doc__,
     986                 :            : "openssl_sha3_512($module, /, string=b\'\', *, usedforsecurity=True)\n"
     987                 :            : "--\n"
     988                 :            : "\n"
     989                 :            : "Returns a sha3-512 hash object; optionally initialized with a string");
     990                 :            : 
     991                 :            : #define _HASHLIB_OPENSSL_SHA3_512_METHODDEF    \
     992                 :            :     {"openssl_sha3_512", _PyCFunction_CAST(_hashlib_openssl_sha3_512), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_512__doc__},
     993                 :            : 
     994                 :            : static PyObject *
     995                 :            : _hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj,
     996                 :            :                                int usedforsecurity);
     997                 :            : 
     998                 :            : static PyObject *
     999                 :          1 : _hashlib_openssl_sha3_512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1000                 :            : {
    1001                 :          1 :     PyObject *return_value = NULL;
    1002                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1003                 :            : 
    1004                 :            :     #define NUM_KEYWORDS 2
    1005                 :            :     static struct {
    1006                 :            :         PyGC_Head _this_is_not_used;
    1007                 :            :         PyObject_VAR_HEAD
    1008                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1009                 :            :     } _kwtuple = {
    1010                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1011                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
    1012                 :            :     };
    1013                 :            :     #undef NUM_KEYWORDS
    1014                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1015                 :            : 
    1016                 :            :     #else  // !Py_BUILD_CORE
    1017                 :            :     #  define KWTUPLE NULL
    1018                 :            :     #endif  // !Py_BUILD_CORE
    1019                 :            : 
    1020                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
    1021                 :            :     static _PyArg_Parser _parser = {
    1022                 :            :         .keywords = _keywords,
    1023                 :            :         .fname = "openssl_sha3_512",
    1024                 :            :         .kwtuple = KWTUPLE,
    1025                 :            :     };
    1026                 :            :     #undef KWTUPLE
    1027                 :            :     PyObject *argsbuf[2];
    1028         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1029                 :          1 :     PyObject *data_obj = NULL;
    1030                 :          1 :     int usedforsecurity = 1;
    1031                 :            : 
    1032   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
    1033         [ -  + ]:          1 :     if (!args) {
    1034                 :          0 :         goto exit;
    1035                 :            :     }
    1036         [ -  + ]:          1 :     if (!noptargs) {
    1037                 :          0 :         goto skip_optional_pos;
    1038                 :            :     }
    1039         [ +  - ]:          1 :     if (args[0]) {
    1040                 :          0 :         data_obj = args[0];
    1041         [ #  # ]:          0 :         if (!--noptargs) {
    1042                 :          0 :             goto skip_optional_pos;
    1043                 :            :         }
    1044                 :            :     }
    1045                 :          1 : skip_optional_pos:
    1046         [ -  + ]:          1 :     if (!noptargs) {
    1047                 :          0 :         goto skip_optional_kwonly;
    1048                 :            :     }
    1049                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
    1050         [ -  + ]:          1 :     if (usedforsecurity < 0) {
    1051                 :          0 :         goto exit;
    1052                 :            :     }
    1053                 :          1 : skip_optional_kwonly:
    1054                 :          1 :     return_value = _hashlib_openssl_sha3_512_impl(module, data_obj, usedforsecurity);
    1055                 :            : 
    1056                 :          1 : exit:
    1057                 :          1 :     return return_value;
    1058                 :            : }
    1059                 :            : 
    1060                 :            : #endif /* defined(PY_OPENSSL_HAS_SHA3) */
    1061                 :            : 
    1062                 :            : #if defined(PY_OPENSSL_HAS_SHAKE)
    1063                 :            : 
    1064                 :            : PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__,
    1065                 :            : "openssl_shake_128($module, /, string=b\'\', *, usedforsecurity=True)\n"
    1066                 :            : "--\n"
    1067                 :            : "\n"
    1068                 :            : "Returns a shake-128 variable hash object; optionally initialized with a string");
    1069                 :            : 
    1070                 :            : #define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF    \
    1071                 :            :     {"openssl_shake_128", _PyCFunction_CAST(_hashlib_openssl_shake_128), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_128__doc__},
    1072                 :            : 
    1073                 :            : static PyObject *
    1074                 :            : _hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj,
    1075                 :            :                                 int usedforsecurity);
    1076                 :            : 
    1077                 :            : static PyObject *
    1078                 :          1 : _hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1079                 :            : {
    1080                 :          1 :     PyObject *return_value = NULL;
    1081                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1082                 :            : 
    1083                 :            :     #define NUM_KEYWORDS 2
    1084                 :            :     static struct {
    1085                 :            :         PyGC_Head _this_is_not_used;
    1086                 :            :         PyObject_VAR_HEAD
    1087                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1088                 :            :     } _kwtuple = {
    1089                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1090                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
    1091                 :            :     };
    1092                 :            :     #undef NUM_KEYWORDS
    1093                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1094                 :            : 
    1095                 :            :     #else  // !Py_BUILD_CORE
    1096                 :            :     #  define KWTUPLE NULL
    1097                 :            :     #endif  // !Py_BUILD_CORE
    1098                 :            : 
    1099                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
    1100                 :            :     static _PyArg_Parser _parser = {
    1101                 :            :         .keywords = _keywords,
    1102                 :            :         .fname = "openssl_shake_128",
    1103                 :            :         .kwtuple = KWTUPLE,
    1104                 :            :     };
    1105                 :            :     #undef KWTUPLE
    1106                 :            :     PyObject *argsbuf[2];
    1107         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1108                 :          1 :     PyObject *data_obj = NULL;
    1109                 :          1 :     int usedforsecurity = 1;
    1110                 :            : 
    1111   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
    1112         [ -  + ]:          1 :     if (!args) {
    1113                 :          0 :         goto exit;
    1114                 :            :     }
    1115         [ -  + ]:          1 :     if (!noptargs) {
    1116                 :          0 :         goto skip_optional_pos;
    1117                 :            :     }
    1118         [ +  - ]:          1 :     if (args[0]) {
    1119                 :          0 :         data_obj = args[0];
    1120         [ #  # ]:          0 :         if (!--noptargs) {
    1121                 :          0 :             goto skip_optional_pos;
    1122                 :            :         }
    1123                 :            :     }
    1124                 :          1 : skip_optional_pos:
    1125         [ -  + ]:          1 :     if (!noptargs) {
    1126                 :          0 :         goto skip_optional_kwonly;
    1127                 :            :     }
    1128                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
    1129         [ -  + ]:          1 :     if (usedforsecurity < 0) {
    1130                 :          0 :         goto exit;
    1131                 :            :     }
    1132                 :          1 : skip_optional_kwonly:
    1133                 :          1 :     return_value = _hashlib_openssl_shake_128_impl(module, data_obj, usedforsecurity);
    1134                 :            : 
    1135                 :          1 : exit:
    1136                 :          1 :     return return_value;
    1137                 :            : }
    1138                 :            : 
    1139                 :            : #endif /* defined(PY_OPENSSL_HAS_SHAKE) */
    1140                 :            : 
    1141                 :            : #if defined(PY_OPENSSL_HAS_SHAKE)
    1142                 :            : 
    1143                 :            : PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__,
    1144                 :            : "openssl_shake_256($module, /, string=b\'\', *, usedforsecurity=True)\n"
    1145                 :            : "--\n"
    1146                 :            : "\n"
    1147                 :            : "Returns a shake-256 variable hash object; optionally initialized with a string");
    1148                 :            : 
    1149                 :            : #define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF    \
    1150                 :            :     {"openssl_shake_256", _PyCFunction_CAST(_hashlib_openssl_shake_256), METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_256__doc__},
    1151                 :            : 
    1152                 :            : static PyObject *
    1153                 :            : _hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj,
    1154                 :            :                                 int usedforsecurity);
    1155                 :            : 
    1156                 :            : static PyObject *
    1157                 :          1 : _hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1158                 :            : {
    1159                 :          1 :     PyObject *return_value = NULL;
    1160                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1161                 :            : 
    1162                 :            :     #define NUM_KEYWORDS 2
    1163                 :            :     static struct {
    1164                 :            :         PyGC_Head _this_is_not_used;
    1165                 :            :         PyObject_VAR_HEAD
    1166                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1167                 :            :     } _kwtuple = {
    1168                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1169                 :            :         .ob_item = { &_Py_ID(string), &_Py_ID(usedforsecurity), },
    1170                 :            :     };
    1171                 :            :     #undef NUM_KEYWORDS
    1172                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1173                 :            : 
    1174                 :            :     #else  // !Py_BUILD_CORE
    1175                 :            :     #  define KWTUPLE NULL
    1176                 :            :     #endif  // !Py_BUILD_CORE
    1177                 :            : 
    1178                 :            :     static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
    1179                 :            :     static _PyArg_Parser _parser = {
    1180                 :            :         .keywords = _keywords,
    1181                 :            :         .fname = "openssl_shake_256",
    1182                 :            :         .kwtuple = KWTUPLE,
    1183                 :            :     };
    1184                 :            :     #undef KWTUPLE
    1185                 :            :     PyObject *argsbuf[2];
    1186         [ +  - ]:          1 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
    1187                 :          1 :     PyObject *data_obj = NULL;
    1188                 :          1 :     int usedforsecurity = 1;
    1189                 :            : 
    1190   [ -  +  -  -  :          1 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
             -  -  -  - ]
    1191         [ -  + ]:          1 :     if (!args) {
    1192                 :          0 :         goto exit;
    1193                 :            :     }
    1194         [ -  + ]:          1 :     if (!noptargs) {
    1195                 :          0 :         goto skip_optional_pos;
    1196                 :            :     }
    1197         [ +  - ]:          1 :     if (args[0]) {
    1198                 :          0 :         data_obj = args[0];
    1199         [ #  # ]:          0 :         if (!--noptargs) {
    1200                 :          0 :             goto skip_optional_pos;
    1201                 :            :         }
    1202                 :            :     }
    1203                 :          1 : skip_optional_pos:
    1204         [ -  + ]:          1 :     if (!noptargs) {
    1205                 :          0 :         goto skip_optional_kwonly;
    1206                 :            :     }
    1207                 :          1 :     usedforsecurity = PyObject_IsTrue(args[1]);
    1208         [ -  + ]:          1 :     if (usedforsecurity < 0) {
    1209                 :          0 :         goto exit;
    1210                 :            :     }
    1211                 :          1 : skip_optional_kwonly:
    1212                 :          1 :     return_value = _hashlib_openssl_shake_256_impl(module, data_obj, usedforsecurity);
    1213                 :            : 
    1214                 :          1 : exit:
    1215                 :          1 :     return return_value;
    1216                 :            : }
    1217                 :            : 
    1218                 :            : #endif /* defined(PY_OPENSSL_HAS_SHAKE) */
    1219                 :            : 
    1220                 :            : PyDoc_STRVAR(pbkdf2_hmac__doc__,
    1221                 :            : "pbkdf2_hmac($module, /, hash_name, password, salt, iterations,\n"
    1222                 :            : "            dklen=None)\n"
    1223                 :            : "--\n"
    1224                 :            : "\n"
    1225                 :            : "Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.");
    1226                 :            : 
    1227                 :            : #define PBKDF2_HMAC_METHODDEF    \
    1228                 :            :     {"pbkdf2_hmac", _PyCFunction_CAST(pbkdf2_hmac), METH_FASTCALL|METH_KEYWORDS, pbkdf2_hmac__doc__},
    1229                 :            : 
    1230                 :            : static PyObject *
    1231                 :            : pbkdf2_hmac_impl(PyObject *module, const char *hash_name,
    1232                 :            :                  Py_buffer *password, Py_buffer *salt, long iterations,
    1233                 :            :                  PyObject *dklen_obj);
    1234                 :            : 
    1235                 :            : static PyObject *
    1236                 :          0 : pbkdf2_hmac(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1237                 :            : {
    1238                 :          0 :     PyObject *return_value = NULL;
    1239                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1240                 :            : 
    1241                 :            :     #define NUM_KEYWORDS 5
    1242                 :            :     static struct {
    1243                 :            :         PyGC_Head _this_is_not_used;
    1244                 :            :         PyObject_VAR_HEAD
    1245                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1246                 :            :     } _kwtuple = {
    1247                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1248                 :            :         .ob_item = { &_Py_ID(hash_name), &_Py_ID(password), &_Py_ID(salt), &_Py_ID(iterations), &_Py_ID(dklen), },
    1249                 :            :     };
    1250                 :            :     #undef NUM_KEYWORDS
    1251                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1252                 :            : 
    1253                 :            :     #else  // !Py_BUILD_CORE
    1254                 :            :     #  define KWTUPLE NULL
    1255                 :            :     #endif  // !Py_BUILD_CORE
    1256                 :            : 
    1257                 :            :     static const char * const _keywords[] = {"hash_name", "password", "salt", "iterations", "dklen", NULL};
    1258                 :            :     static _PyArg_Parser _parser = {
    1259                 :            :         .keywords = _keywords,
    1260                 :            :         .fname = "pbkdf2_hmac",
    1261                 :            :         .kwtuple = KWTUPLE,
    1262                 :            :     };
    1263                 :            :     #undef KWTUPLE
    1264                 :            :     PyObject *argsbuf[5];
    1265         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 4;
    1266                 :            :     const char *hash_name;
    1267                 :          0 :     Py_buffer password = {NULL, NULL};
    1268                 :          0 :     Py_buffer salt = {NULL, NULL};
    1269                 :            :     long iterations;
    1270                 :          0 :     PyObject *dklen_obj = Py_None;
    1271                 :            : 
    1272   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 4, 5, 0, argsbuf);
             #  #  #  # ]
    1273         [ #  # ]:          0 :     if (!args) {
    1274                 :          0 :         goto exit;
    1275                 :            :     }
    1276         [ #  # ]:          0 :     if (!PyUnicode_Check(args[0])) {
    1277                 :          0 :         _PyArg_BadArgument("pbkdf2_hmac", "argument 'hash_name'", "str", args[0]);
    1278                 :          0 :         goto exit;
    1279                 :            :     }
    1280                 :            :     Py_ssize_t hash_name_length;
    1281                 :          0 :     hash_name = PyUnicode_AsUTF8AndSize(args[0], &hash_name_length);
    1282         [ #  # ]:          0 :     if (hash_name == NULL) {
    1283                 :          0 :         goto exit;
    1284                 :            :     }
    1285         [ #  # ]:          0 :     if (strlen(hash_name) != (size_t)hash_name_length) {
    1286                 :          0 :         PyErr_SetString(PyExc_ValueError, "embedded null character");
    1287                 :          0 :         goto exit;
    1288                 :            :     }
    1289         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[1], &password, PyBUF_SIMPLE) != 0) {
    1290                 :          0 :         goto exit;
    1291                 :            :     }
    1292         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&password, 'C')) {
    1293                 :          0 :         _PyArg_BadArgument("pbkdf2_hmac", "argument 'password'", "contiguous buffer", args[1]);
    1294                 :          0 :         goto exit;
    1295                 :            :     }
    1296         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[2], &salt, PyBUF_SIMPLE) != 0) {
    1297                 :          0 :         goto exit;
    1298                 :            :     }
    1299         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&salt, 'C')) {
    1300                 :          0 :         _PyArg_BadArgument("pbkdf2_hmac", "argument 'salt'", "contiguous buffer", args[2]);
    1301                 :          0 :         goto exit;
    1302                 :            :     }
    1303                 :          0 :     iterations = PyLong_AsLong(args[3]);
    1304   [ #  #  #  # ]:          0 :     if (iterations == -1 && PyErr_Occurred()) {
    1305                 :          0 :         goto exit;
    1306                 :            :     }
    1307         [ #  # ]:          0 :     if (!noptargs) {
    1308                 :          0 :         goto skip_optional_pos;
    1309                 :            :     }
    1310                 :          0 :     dklen_obj = args[4];
    1311                 :          0 : skip_optional_pos:
    1312                 :          0 :     return_value = pbkdf2_hmac_impl(module, hash_name, &password, &salt, iterations, dklen_obj);
    1313                 :            : 
    1314                 :          0 : exit:
    1315                 :            :     /* Cleanup for password */
    1316         [ #  # ]:          0 :     if (password.obj) {
    1317                 :          0 :        PyBuffer_Release(&password);
    1318                 :            :     }
    1319                 :            :     /* Cleanup for salt */
    1320         [ #  # ]:          0 :     if (salt.obj) {
    1321                 :          0 :        PyBuffer_Release(&salt);
    1322                 :            :     }
    1323                 :            : 
    1324                 :          0 :     return return_value;
    1325                 :            : }
    1326                 :            : 
    1327                 :            : #if defined(PY_OPENSSL_HAS_SCRYPT)
    1328                 :            : 
    1329                 :            : PyDoc_STRVAR(_hashlib_scrypt__doc__,
    1330                 :            : "scrypt($module, /, password, *, salt=None, n=None, r=None, p=None,\n"
    1331                 :            : "       maxmem=0, dklen=64)\n"
    1332                 :            : "--\n"
    1333                 :            : "\n"
    1334                 :            : "scrypt password-based key derivation function.");
    1335                 :            : 
    1336                 :            : #define _HASHLIB_SCRYPT_METHODDEF    \
    1337                 :            :     {"scrypt", _PyCFunction_CAST(_hashlib_scrypt), METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
    1338                 :            : 
    1339                 :            : static PyObject *
    1340                 :            : _hashlib_scrypt_impl(PyObject *module, Py_buffer *password, Py_buffer *salt,
    1341                 :            :                      PyObject *n_obj, PyObject *r_obj, PyObject *p_obj,
    1342                 :            :                      long maxmem, long dklen);
    1343                 :            : 
    1344                 :            : static PyObject *
    1345                 :          0 : _hashlib_scrypt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1346                 :            : {
    1347                 :          0 :     PyObject *return_value = NULL;
    1348                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1349                 :            : 
    1350                 :            :     #define NUM_KEYWORDS 7
    1351                 :            :     static struct {
    1352                 :            :         PyGC_Head _this_is_not_used;
    1353                 :            :         PyObject_VAR_HEAD
    1354                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1355                 :            :     } _kwtuple = {
    1356                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1357                 :            :         .ob_item = { &_Py_ID(password), &_Py_ID(salt), &_Py_ID(n), &_Py_ID(r), &_Py_ID(p), &_Py_ID(maxmem), &_Py_ID(dklen), },
    1358                 :            :     };
    1359                 :            :     #undef NUM_KEYWORDS
    1360                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1361                 :            : 
    1362                 :            :     #else  // !Py_BUILD_CORE
    1363                 :            :     #  define KWTUPLE NULL
    1364                 :            :     #endif  // !Py_BUILD_CORE
    1365                 :            : 
    1366                 :            :     static const char * const _keywords[] = {"password", "salt", "n", "r", "p", "maxmem", "dklen", NULL};
    1367                 :            :     static _PyArg_Parser _parser = {
    1368                 :            :         .keywords = _keywords,
    1369                 :            :         .fname = "scrypt",
    1370                 :            :         .kwtuple = KWTUPLE,
    1371                 :            :     };
    1372                 :            :     #undef KWTUPLE
    1373                 :            :     PyObject *argsbuf[7];
    1374         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
    1375                 :          0 :     Py_buffer password = {NULL, NULL};
    1376                 :          0 :     Py_buffer salt = {NULL, NULL};
    1377                 :          0 :     PyObject *n_obj = Py_None;
    1378                 :          0 :     PyObject *r_obj = Py_None;
    1379                 :          0 :     PyObject *p_obj = Py_None;
    1380                 :          0 :     long maxmem = 0;
    1381                 :          0 :     long dklen = 64;
    1382                 :            : 
    1383   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
    1384         [ #  # ]:          0 :     if (!args) {
    1385                 :          0 :         goto exit;
    1386                 :            :     }
    1387         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &password, PyBUF_SIMPLE) != 0) {
    1388                 :          0 :         goto exit;
    1389                 :            :     }
    1390         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&password, 'C')) {
    1391                 :          0 :         _PyArg_BadArgument("scrypt", "argument 'password'", "contiguous buffer", args[0]);
    1392                 :          0 :         goto exit;
    1393                 :            :     }
    1394         [ #  # ]:          0 :     if (!noptargs) {
    1395                 :          0 :         goto skip_optional_kwonly;
    1396                 :            :     }
    1397         [ #  # ]:          0 :     if (args[1]) {
    1398         [ #  # ]:          0 :         if (PyObject_GetBuffer(args[1], &salt, PyBUF_SIMPLE) != 0) {
    1399                 :          0 :             goto exit;
    1400                 :            :         }
    1401         [ #  # ]:          0 :         if (!PyBuffer_IsContiguous(&salt, 'C')) {
    1402                 :          0 :             _PyArg_BadArgument("scrypt", "argument 'salt'", "contiguous buffer", args[1]);
    1403                 :          0 :             goto exit;
    1404                 :            :         }
    1405         [ #  # ]:          0 :         if (!--noptargs) {
    1406                 :          0 :             goto skip_optional_kwonly;
    1407                 :            :         }
    1408                 :            :     }
    1409         [ #  # ]:          0 :     if (args[2]) {
    1410         [ #  # ]:          0 :         if (!PyLong_Check(args[2])) {
    1411                 :          0 :             _PyArg_BadArgument("scrypt", "argument 'n'", "int", args[2]);
    1412                 :          0 :             goto exit;
    1413                 :            :         }
    1414                 :          0 :         n_obj = args[2];
    1415         [ #  # ]:          0 :         if (!--noptargs) {
    1416                 :          0 :             goto skip_optional_kwonly;
    1417                 :            :         }
    1418                 :            :     }
    1419         [ #  # ]:          0 :     if (args[3]) {
    1420         [ #  # ]:          0 :         if (!PyLong_Check(args[3])) {
    1421                 :          0 :             _PyArg_BadArgument("scrypt", "argument 'r'", "int", args[3]);
    1422                 :          0 :             goto exit;
    1423                 :            :         }
    1424                 :          0 :         r_obj = args[3];
    1425         [ #  # ]:          0 :         if (!--noptargs) {
    1426                 :          0 :             goto skip_optional_kwonly;
    1427                 :            :         }
    1428                 :            :     }
    1429         [ #  # ]:          0 :     if (args[4]) {
    1430         [ #  # ]:          0 :         if (!PyLong_Check(args[4])) {
    1431                 :          0 :             _PyArg_BadArgument("scrypt", "argument 'p'", "int", args[4]);
    1432                 :          0 :             goto exit;
    1433                 :            :         }
    1434                 :          0 :         p_obj = args[4];
    1435         [ #  # ]:          0 :         if (!--noptargs) {
    1436                 :          0 :             goto skip_optional_kwonly;
    1437                 :            :         }
    1438                 :            :     }
    1439         [ #  # ]:          0 :     if (args[5]) {
    1440                 :          0 :         maxmem = PyLong_AsLong(args[5]);
    1441   [ #  #  #  # ]:          0 :         if (maxmem == -1 && PyErr_Occurred()) {
    1442                 :          0 :             goto exit;
    1443                 :            :         }
    1444         [ #  # ]:          0 :         if (!--noptargs) {
    1445                 :          0 :             goto skip_optional_kwonly;
    1446                 :            :         }
    1447                 :            :     }
    1448                 :          0 :     dklen = PyLong_AsLong(args[6]);
    1449   [ #  #  #  # ]:          0 :     if (dklen == -1 && PyErr_Occurred()) {
    1450                 :          0 :         goto exit;
    1451                 :            :     }
    1452                 :          0 : skip_optional_kwonly:
    1453                 :          0 :     return_value = _hashlib_scrypt_impl(module, &password, &salt, n_obj, r_obj, p_obj, maxmem, dklen);
    1454                 :            : 
    1455                 :          0 : exit:
    1456                 :            :     /* Cleanup for password */
    1457         [ #  # ]:          0 :     if (password.obj) {
    1458                 :          0 :        PyBuffer_Release(&password);
    1459                 :            :     }
    1460                 :            :     /* Cleanup for salt */
    1461         [ #  # ]:          0 :     if (salt.obj) {
    1462                 :          0 :        PyBuffer_Release(&salt);
    1463                 :            :     }
    1464                 :            : 
    1465                 :          0 :     return return_value;
    1466                 :            : }
    1467                 :            : 
    1468                 :            : #endif /* defined(PY_OPENSSL_HAS_SCRYPT) */
    1469                 :            : 
    1470                 :            : PyDoc_STRVAR(_hashlib_hmac_singleshot__doc__,
    1471                 :            : "hmac_digest($module, /, key, msg, digest)\n"
    1472                 :            : "--\n"
    1473                 :            : "\n"
    1474                 :            : "Single-shot HMAC.");
    1475                 :            : 
    1476                 :            : #define _HASHLIB_HMAC_SINGLESHOT_METHODDEF    \
    1477                 :            :     {"hmac_digest", _PyCFunction_CAST(_hashlib_hmac_singleshot), METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_singleshot__doc__},
    1478                 :            : 
    1479                 :            : static PyObject *
    1480                 :            : _hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
    1481                 :            :                               Py_buffer *msg, PyObject *digest);
    1482                 :            : 
    1483                 :            : static PyObject *
    1484                 :          0 : _hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1485                 :            : {
    1486                 :          0 :     PyObject *return_value = NULL;
    1487                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1488                 :            : 
    1489                 :            :     #define NUM_KEYWORDS 3
    1490                 :            :     static struct {
    1491                 :            :         PyGC_Head _this_is_not_used;
    1492                 :            :         PyObject_VAR_HEAD
    1493                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1494                 :            :     } _kwtuple = {
    1495                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1496                 :            :         .ob_item = { &_Py_ID(key), &_Py_ID(msg), &_Py_ID(digest), },
    1497                 :            :     };
    1498                 :            :     #undef NUM_KEYWORDS
    1499                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1500                 :            : 
    1501                 :            :     #else  // !Py_BUILD_CORE
    1502                 :            :     #  define KWTUPLE NULL
    1503                 :            :     #endif  // !Py_BUILD_CORE
    1504                 :            : 
    1505                 :            :     static const char * const _keywords[] = {"key", "msg", "digest", NULL};
    1506                 :            :     static _PyArg_Parser _parser = {
    1507                 :            :         .keywords = _keywords,
    1508                 :            :         .fname = "hmac_digest",
    1509                 :            :         .kwtuple = KWTUPLE,
    1510                 :            :     };
    1511                 :            :     #undef KWTUPLE
    1512                 :            :     PyObject *argsbuf[3];
    1513                 :          0 :     Py_buffer key = {NULL, NULL};
    1514                 :          0 :     Py_buffer msg = {NULL, NULL};
    1515                 :            :     PyObject *digest;
    1516                 :            : 
    1517   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
             #  #  #  # ]
    1518         [ #  # ]:          0 :     if (!args) {
    1519                 :          0 :         goto exit;
    1520                 :            :     }
    1521         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
    1522                 :          0 :         goto exit;
    1523                 :            :     }
    1524         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&key, 'C')) {
    1525                 :          0 :         _PyArg_BadArgument("hmac_digest", "argument 'key'", "contiguous buffer", args[0]);
    1526                 :          0 :         goto exit;
    1527                 :            :     }
    1528         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[1], &msg, PyBUF_SIMPLE) != 0) {
    1529                 :          0 :         goto exit;
    1530                 :            :     }
    1531         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&msg, 'C')) {
    1532                 :          0 :         _PyArg_BadArgument("hmac_digest", "argument 'msg'", "contiguous buffer", args[1]);
    1533                 :          0 :         goto exit;
    1534                 :            :     }
    1535                 :          0 :     digest = args[2];
    1536                 :          0 :     return_value = _hashlib_hmac_singleshot_impl(module, &key, &msg, digest);
    1537                 :            : 
    1538                 :          0 : exit:
    1539                 :            :     /* Cleanup for key */
    1540         [ #  # ]:          0 :     if (key.obj) {
    1541                 :          0 :        PyBuffer_Release(&key);
    1542                 :            :     }
    1543                 :            :     /* Cleanup for msg */
    1544         [ #  # ]:          0 :     if (msg.obj) {
    1545                 :          0 :        PyBuffer_Release(&msg);
    1546                 :            :     }
    1547                 :            : 
    1548                 :          0 :     return return_value;
    1549                 :            : }
    1550                 :            : 
    1551                 :            : PyDoc_STRVAR(_hashlib_hmac_new__doc__,
    1552                 :            : "hmac_new($module, /, key, msg=b\'\', digestmod=None)\n"
    1553                 :            : "--\n"
    1554                 :            : "\n"
    1555                 :            : "Return a new hmac object.");
    1556                 :            : 
    1557                 :            : #define _HASHLIB_HMAC_NEW_METHODDEF    \
    1558                 :            :     {"hmac_new", _PyCFunction_CAST(_hashlib_hmac_new), METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_new__doc__},
    1559                 :            : 
    1560                 :            : static PyObject *
    1561                 :            : _hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
    1562                 :            :                        PyObject *digestmod);
    1563                 :            : 
    1564                 :            : static PyObject *
    1565                 :          0 : _hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1566                 :            : {
    1567                 :          0 :     PyObject *return_value = NULL;
    1568                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1569                 :            : 
    1570                 :            :     #define NUM_KEYWORDS 3
    1571                 :            :     static struct {
    1572                 :            :         PyGC_Head _this_is_not_used;
    1573                 :            :         PyObject_VAR_HEAD
    1574                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1575                 :            :     } _kwtuple = {
    1576                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1577                 :            :         .ob_item = { &_Py_ID(key), &_Py_ID(msg), &_Py_ID(digestmod), },
    1578                 :            :     };
    1579                 :            :     #undef NUM_KEYWORDS
    1580                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1581                 :            : 
    1582                 :            :     #else  // !Py_BUILD_CORE
    1583                 :            :     #  define KWTUPLE NULL
    1584                 :            :     #endif  // !Py_BUILD_CORE
    1585                 :            : 
    1586                 :            :     static const char * const _keywords[] = {"key", "msg", "digestmod", NULL};
    1587                 :            :     static _PyArg_Parser _parser = {
    1588                 :            :         .keywords = _keywords,
    1589                 :            :         .fname = "hmac_new",
    1590                 :            :         .kwtuple = KWTUPLE,
    1591                 :            :     };
    1592                 :            :     #undef KWTUPLE
    1593                 :            :     PyObject *argsbuf[3];
    1594         [ #  # ]:          0 :     Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
    1595                 :          0 :     Py_buffer key = {NULL, NULL};
    1596                 :          0 :     PyObject *msg_obj = NULL;
    1597                 :          0 :     PyObject *digestmod = NULL;
    1598                 :            : 
    1599   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
             #  #  #  # ]
    1600         [ #  # ]:          0 :     if (!args) {
    1601                 :          0 :         goto exit;
    1602                 :            :     }
    1603         [ #  # ]:          0 :     if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
    1604                 :          0 :         goto exit;
    1605                 :            :     }
    1606         [ #  # ]:          0 :     if (!PyBuffer_IsContiguous(&key, 'C')) {
    1607                 :          0 :         _PyArg_BadArgument("hmac_new", "argument 'key'", "contiguous buffer", args[0]);
    1608                 :          0 :         goto exit;
    1609                 :            :     }
    1610         [ #  # ]:          0 :     if (!noptargs) {
    1611                 :          0 :         goto skip_optional_pos;
    1612                 :            :     }
    1613         [ #  # ]:          0 :     if (args[1]) {
    1614                 :          0 :         msg_obj = args[1];
    1615         [ #  # ]:          0 :         if (!--noptargs) {
    1616                 :          0 :             goto skip_optional_pos;
    1617                 :            :         }
    1618                 :            :     }
    1619                 :          0 :     digestmod = args[2];
    1620                 :          0 : skip_optional_pos:
    1621                 :          0 :     return_value = _hashlib_hmac_new_impl(module, &key, msg_obj, digestmod);
    1622                 :            : 
    1623                 :          0 : exit:
    1624                 :            :     /* Cleanup for key */
    1625         [ #  # ]:          0 :     if (key.obj) {
    1626                 :          0 :        PyBuffer_Release(&key);
    1627                 :            :     }
    1628                 :            : 
    1629                 :          0 :     return return_value;
    1630                 :            : }
    1631                 :            : 
    1632                 :            : PyDoc_STRVAR(_hashlib_HMAC_copy__doc__,
    1633                 :            : "copy($self, /)\n"
    1634                 :            : "--\n"
    1635                 :            : "\n"
    1636                 :            : "Return a copy (\"clone\") of the HMAC object.");
    1637                 :            : 
    1638                 :            : #define _HASHLIB_HMAC_COPY_METHODDEF    \
    1639                 :            :     {"copy", (PyCFunction)_hashlib_HMAC_copy, METH_NOARGS, _hashlib_HMAC_copy__doc__},
    1640                 :            : 
    1641                 :            : static PyObject *
    1642                 :            : _hashlib_HMAC_copy_impl(HMACobject *self);
    1643                 :            : 
    1644                 :            : static PyObject *
    1645                 :          0 : _hashlib_HMAC_copy(HMACobject *self, PyObject *Py_UNUSED(ignored))
    1646                 :            : {
    1647                 :          0 :     return _hashlib_HMAC_copy_impl(self);
    1648                 :            : }
    1649                 :            : 
    1650                 :            : PyDoc_STRVAR(_hashlib_HMAC_update__doc__,
    1651                 :            : "update($self, /, msg)\n"
    1652                 :            : "--\n"
    1653                 :            : "\n"
    1654                 :            : "Update the HMAC object with msg.");
    1655                 :            : 
    1656                 :            : #define _HASHLIB_HMAC_UPDATE_METHODDEF    \
    1657                 :            :     {"update", _PyCFunction_CAST(_hashlib_HMAC_update), METH_FASTCALL|METH_KEYWORDS, _hashlib_HMAC_update__doc__},
    1658                 :            : 
    1659                 :            : static PyObject *
    1660                 :            : _hashlib_HMAC_update_impl(HMACobject *self, PyObject *msg);
    1661                 :            : 
    1662                 :            : static PyObject *
    1663                 :          0 : _hashlib_HMAC_update(HMACobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
    1664                 :            : {
    1665                 :          0 :     PyObject *return_value = NULL;
    1666                 :            :     #if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE)
    1667                 :            : 
    1668                 :            :     #define NUM_KEYWORDS 1
    1669                 :            :     static struct {
    1670                 :            :         PyGC_Head _this_is_not_used;
    1671                 :            :         PyObject_VAR_HEAD
    1672                 :            :         PyObject *ob_item[NUM_KEYWORDS];
    1673                 :            :     } _kwtuple = {
    1674                 :            :         .ob_base = PyVarObject_HEAD_INIT(&PyTuple_Type, NUM_KEYWORDS)
    1675                 :            :         .ob_item = { &_Py_ID(msg), },
    1676                 :            :     };
    1677                 :            :     #undef NUM_KEYWORDS
    1678                 :            :     #define KWTUPLE (&_kwtuple.ob_base.ob_base)
    1679                 :            : 
    1680                 :            :     #else  // !Py_BUILD_CORE
    1681                 :            :     #  define KWTUPLE NULL
    1682                 :            :     #endif  // !Py_BUILD_CORE
    1683                 :            : 
    1684                 :            :     static const char * const _keywords[] = {"msg", NULL};
    1685                 :            :     static _PyArg_Parser _parser = {
    1686                 :            :         .keywords = _keywords,
    1687                 :            :         .fname = "update",
    1688                 :            :         .kwtuple = KWTUPLE,
    1689                 :            :     };
    1690                 :            :     #undef KWTUPLE
    1691                 :            :     PyObject *argsbuf[1];
    1692                 :            :     PyObject *msg;
    1693                 :            : 
    1694   [ #  #  #  #  :          0 :     args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
             #  #  #  # ]
    1695         [ #  # ]:          0 :     if (!args) {
    1696                 :          0 :         goto exit;
    1697                 :            :     }
    1698                 :          0 :     msg = args[0];
    1699                 :          0 :     return_value = _hashlib_HMAC_update_impl(self, msg);
    1700                 :            : 
    1701                 :          0 : exit:
    1702                 :          0 :     return return_value;
    1703                 :            : }
    1704                 :            : 
    1705                 :            : PyDoc_STRVAR(_hashlib_HMAC_digest__doc__,
    1706                 :            : "digest($self, /)\n"
    1707                 :            : "--\n"
    1708                 :            : "\n"
    1709                 :            : "Return the digest of the bytes passed to the update() method so far.");
    1710                 :            : 
    1711                 :            : #define _HASHLIB_HMAC_DIGEST_METHODDEF    \
    1712                 :            :     {"digest", (PyCFunction)_hashlib_HMAC_digest, METH_NOARGS, _hashlib_HMAC_digest__doc__},
    1713                 :            : 
    1714                 :            : static PyObject *
    1715                 :            : _hashlib_HMAC_digest_impl(HMACobject *self);
    1716                 :            : 
    1717                 :            : static PyObject *
    1718                 :          0 : _hashlib_HMAC_digest(HMACobject *self, PyObject *Py_UNUSED(ignored))
    1719                 :            : {
    1720                 :          0 :     return _hashlib_HMAC_digest_impl(self);
    1721                 :            : }
    1722                 :            : 
    1723                 :            : PyDoc_STRVAR(_hashlib_HMAC_hexdigest__doc__,
    1724                 :            : "hexdigest($self, /)\n"
    1725                 :            : "--\n"
    1726                 :            : "\n"
    1727                 :            : "Return hexadecimal digest of the bytes passed to the update() method so far.\n"
    1728                 :            : "\n"
    1729                 :            : "This may be used to exchange the value safely in email or other non-binary\n"
    1730                 :            : "environments.");
    1731                 :            : 
    1732                 :            : #define _HASHLIB_HMAC_HEXDIGEST_METHODDEF    \
    1733                 :            :     {"hexdigest", (PyCFunction)_hashlib_HMAC_hexdigest, METH_NOARGS, _hashlib_HMAC_hexdigest__doc__},
    1734                 :            : 
    1735                 :            : static PyObject *
    1736                 :            : _hashlib_HMAC_hexdigest_impl(HMACobject *self);
    1737                 :            : 
    1738                 :            : static PyObject *
    1739                 :          0 : _hashlib_HMAC_hexdigest(HMACobject *self, PyObject *Py_UNUSED(ignored))
    1740                 :            : {
    1741                 :          0 :     return _hashlib_HMAC_hexdigest_impl(self);
    1742                 :            : }
    1743                 :            : 
    1744                 :            : PyDoc_STRVAR(_hashlib_get_fips_mode__doc__,
    1745                 :            : "get_fips_mode($module, /)\n"
    1746                 :            : "--\n"
    1747                 :            : "\n"
    1748                 :            : "Determine the OpenSSL FIPS mode of operation.\n"
    1749                 :            : "\n"
    1750                 :            : "For OpenSSL 3.0.0 and newer it returns the state of the default provider\n"
    1751                 :            : "in the default OSSL context. It\'s not quite the same as FIPS_mode() but good\n"
    1752                 :            : "enough for unittests.\n"
    1753                 :            : "\n"
    1754                 :            : "Effectively any non-zero return value indicates FIPS mode;\n"
    1755                 :            : "values other than 1 may have additional significance.");
    1756                 :            : 
    1757                 :            : #define _HASHLIB_GET_FIPS_MODE_METHODDEF    \
    1758                 :            :     {"get_fips_mode", (PyCFunction)_hashlib_get_fips_mode, METH_NOARGS, _hashlib_get_fips_mode__doc__},
    1759                 :            : 
    1760                 :            : static int
    1761                 :            : _hashlib_get_fips_mode_impl(PyObject *module);
    1762                 :            : 
    1763                 :            : static PyObject *
    1764                 :          0 : _hashlib_get_fips_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
    1765                 :            : {
    1766                 :          0 :     PyObject *return_value = NULL;
    1767                 :            :     int _return_value;
    1768                 :            : 
    1769                 :          0 :     _return_value = _hashlib_get_fips_mode_impl(module);
    1770   [ #  #  #  # ]:          0 :     if ((_return_value == -1) && PyErr_Occurred()) {
    1771                 :          0 :         goto exit;
    1772                 :            :     }
    1773                 :          0 :     return_value = PyLong_FromLong((long)_return_value);
    1774                 :            : 
    1775                 :          0 : exit:
    1776                 :          0 :     return return_value;
    1777                 :            : }
    1778                 :            : 
    1779                 :            : PyDoc_STRVAR(_hashlib_compare_digest__doc__,
    1780                 :            : "compare_digest($module, a, b, /)\n"
    1781                 :            : "--\n"
    1782                 :            : "\n"
    1783                 :            : "Return \'a == b\'.\n"
    1784                 :            : "\n"
    1785                 :            : "This function uses an approach designed to prevent\n"
    1786                 :            : "timing analysis, making it appropriate for cryptography.\n"
    1787                 :            : "\n"
    1788                 :            : "a and b must both be of the same type: either str (ASCII only),\n"
    1789                 :            : "or any bytes-like object.\n"
    1790                 :            : "\n"
    1791                 :            : "Note: If a and b are of different lengths, or if an error occurs,\n"
    1792                 :            : "a timing attack could theoretically reveal information about the\n"
    1793                 :            : "types and lengths of a and b--but not their values.");
    1794                 :            : 
    1795                 :            : #define _HASHLIB_COMPARE_DIGEST_METHODDEF    \
    1796                 :            :     {"compare_digest", _PyCFunction_CAST(_hashlib_compare_digest), METH_FASTCALL, _hashlib_compare_digest__doc__},
    1797                 :            : 
    1798                 :            : static PyObject *
    1799                 :            : _hashlib_compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
    1800                 :            : 
    1801                 :            : static PyObject *
    1802                 :          0 : _hashlib_compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
    1803                 :            : {
    1804                 :          0 :     PyObject *return_value = NULL;
    1805                 :            :     PyObject *a;
    1806                 :            :     PyObject *b;
    1807                 :            : 
    1808   [ #  #  #  #  :          0 :     if (!_PyArg_CheckPositional("compare_digest", nargs, 2, 2)) {
                   #  # ]
    1809                 :          0 :         goto exit;
    1810                 :            :     }
    1811                 :          0 :     a = args[0];
    1812                 :          0 :     b = args[1];
    1813                 :          0 :     return_value = _hashlib_compare_digest_impl(module, a, b);
    1814                 :            : 
    1815                 :          0 : exit:
    1816                 :          0 :     return return_value;
    1817                 :            : }
    1818                 :            : 
    1819                 :            : #ifndef EVPXOF_DIGEST_METHODDEF
    1820                 :            :     #define EVPXOF_DIGEST_METHODDEF
    1821                 :            : #endif /* !defined(EVPXOF_DIGEST_METHODDEF) */
    1822                 :            : 
    1823                 :            : #ifndef EVPXOF_HEXDIGEST_METHODDEF
    1824                 :            :     #define EVPXOF_HEXDIGEST_METHODDEF
    1825                 :            : #endif /* !defined(EVPXOF_HEXDIGEST_METHODDEF) */
    1826                 :            : 
    1827                 :            : #ifndef _HASHLIB_OPENSSL_SHA3_224_METHODDEF
    1828                 :            :     #define _HASHLIB_OPENSSL_SHA3_224_METHODDEF
    1829                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHA3_224_METHODDEF) */
    1830                 :            : 
    1831                 :            : #ifndef _HASHLIB_OPENSSL_SHA3_256_METHODDEF
    1832                 :            :     #define _HASHLIB_OPENSSL_SHA3_256_METHODDEF
    1833                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHA3_256_METHODDEF) */
    1834                 :            : 
    1835                 :            : #ifndef _HASHLIB_OPENSSL_SHA3_384_METHODDEF
    1836                 :            :     #define _HASHLIB_OPENSSL_SHA3_384_METHODDEF
    1837                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHA3_384_METHODDEF) */
    1838                 :            : 
    1839                 :            : #ifndef _HASHLIB_OPENSSL_SHA3_512_METHODDEF
    1840                 :            :     #define _HASHLIB_OPENSSL_SHA3_512_METHODDEF
    1841                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHA3_512_METHODDEF) */
    1842                 :            : 
    1843                 :            : #ifndef _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
    1844                 :            :     #define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
    1845                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHAKE_128_METHODDEF) */
    1846                 :            : 
    1847                 :            : #ifndef _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
    1848                 :            :     #define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
    1849                 :            : #endif /* !defined(_HASHLIB_OPENSSL_SHAKE_256_METHODDEF) */
    1850                 :            : 
    1851                 :            : #ifndef _HASHLIB_SCRYPT_METHODDEF
    1852                 :            :     #define _HASHLIB_SCRYPT_METHODDEF
    1853                 :            : #endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */
    1854                 :            : /*[clinic end generated code: output=b339e255db698147 input=a9049054013a1b77]*/

Generated by: LCOV version 1.14