LCOV - code coverage report
Current view: top level - Modules/_sha3 - sha3module.c (source / functions) Hit Total Coverage
Test: CPython 3.12 LCOV report [commit 5e6661bce9] Lines: 37 196 18.9 %
Date: 2023-03-20 08:15:36 Functions: 6 24 25.0 %
Branches: 38 170 22.4 %

           Branch data     Line data    Source code
       1                 :            : /* SHA3 module
       2                 :            :  *
       3                 :            :  * This module provides an interface to the SHA3 algorithm
       4                 :            :  *
       5                 :            :  * See below for information about the original code this module was
       6                 :            :  * based upon. Additional work performed by:
       7                 :            :  *
       8                 :            :  *  Andrew Kuchling (amk@amk.ca)
       9                 :            :  *  Greg Stein (gstein@lyra.org)
      10                 :            :  *  Trevor Perrin (trevp@trevp.net)
      11                 :            :  *  Gregory P. Smith (greg@krypto.org)
      12                 :            :  *
      13                 :            :  * Copyright (C) 2012-2022  Christian Heimes (christian@python.org)
      14                 :            :  * Licensed to PSF under a Contributor Agreement.
      15                 :            :  *
      16                 :            :  */
      17                 :            : 
      18                 :            : #ifndef Py_BUILD_CORE_BUILTIN
      19                 :            : #  define Py_BUILD_CORE_MODULE 1
      20                 :            : #endif
      21                 :            : 
      22                 :            : #include "Python.h"
      23                 :            : #include "pycore_strhex.h"        // _Py_strhex()
      24                 :            : #include "pycore_typeobject.h"    // _PyType_GetModuleState()
      25                 :            : #include "../hashlib.h"
      26                 :            : 
      27                 :            : #include "sha3.c"
      28                 :            : 
      29                 :            : #define SHA3_MAX_DIGESTSIZE 64 /* 64 Bytes (512 Bits) for 224 to 512 */
      30                 :            : #define SHA3_LANESIZE 0
      31                 :            : #define SHA3_state sha3_ctx_t
      32                 :            : #define SHA3_init sha3_init
      33                 :            : #define SHA3_process sha3_update
      34                 :            : #define SHA3_done(state, digest) sha3_final(digest, state)
      35                 :            : #define SHA3_squeeze(state, out, len) shake_xof(state), shake_out(state, out, len)
      36                 :            : #define SHA3_copystate(dest, src) memcpy(&(dest), &(src), sizeof(SHA3_state))
      37                 :            : 
      38                 :            : // no optimization
      39                 :            : #define KeccakOpt 0
      40                 :            : 
      41                 :            : typedef enum { SUCCESS = 1, FAIL = 0, BAD_HASHLEN = 2 } HashReturn;
      42                 :            : 
      43                 :            : typedef struct {
      44                 :            :     PyTypeObject *sha3_224_type;
      45                 :            :     PyTypeObject *sha3_256_type;
      46                 :            :     PyTypeObject *sha3_384_type;
      47                 :            :     PyTypeObject *sha3_512_type;
      48                 :            :     PyTypeObject *shake_128_type;
      49                 :            :     PyTypeObject *shake_256_type;
      50                 :            : } SHA3State;
      51                 :            : 
      52                 :            : static inline SHA3State*
      53                 :         11 : sha3_get_state(PyObject *module)
      54                 :            : {
      55                 :         11 :     void *state = PyModule_GetState(module);
      56                 :            :     assert(state != NULL);
      57                 :         11 :     return (SHA3State *)state;
      58                 :            : }
      59                 :            : 
      60                 :            : /*[clinic input]
      61                 :            : module _sha3
      62                 :            : class _sha3.sha3_224 "SHA3object *" "&SHA3_224typ"
      63                 :            : class _sha3.sha3_256 "SHA3object *" "&SHA3_256typ"
      64                 :            : class _sha3.sha3_384 "SHA3object *" "&SHA3_384typ"
      65                 :            : class _sha3.sha3_512 "SHA3object *" "&SHA3_512typ"
      66                 :            : class _sha3.shake_128 "SHA3object *" "&SHAKE128type"
      67                 :            : class _sha3.shake_256 "SHA3object *" "&SHAKE256type"
      68                 :            : [clinic start generated code]*/
      69                 :            : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b8a53680f370285a]*/
      70                 :            : 
      71                 :            : /* The structure for storing SHA3 info */
      72                 :            : 
      73                 :            : typedef struct {
      74                 :            :     PyObject_HEAD
      75                 :            :     SHA3_state hash_state;
      76                 :            :     PyThread_type_lock lock;
      77                 :            : } SHA3object;
      78                 :            : 
      79                 :            : #include "clinic/sha3module.c.h"
      80                 :            : 
      81                 :            : static SHA3object *
      82                 :          0 : newSHA3object(PyTypeObject *type)
      83                 :            : {
      84                 :            :     SHA3object *newobj;
      85                 :          0 :     newobj = (SHA3object *)PyObject_New(SHA3object, type);
      86         [ #  # ]:          0 :     if (newobj == NULL) {
      87                 :          0 :         return NULL;
      88                 :            :     }
      89                 :          0 :     newobj->lock = NULL;
      90                 :          0 :     return newobj;
      91                 :            : }
      92                 :            : 
      93                 :            : /*[clinic input]
      94                 :            : @classmethod
      95                 :            : _sha3.sha3_224.__new__ as py_sha3_new
      96                 :            :     data: object(c_default="NULL") = b''
      97                 :            :     /
      98                 :            :     *
      99                 :            :     usedforsecurity: bool = True
     100                 :            : 
     101                 :            : Return a new BLAKE2b hash object.
     102                 :            : [clinic start generated code]*/
     103                 :            : 
     104                 :            : static PyObject *
     105                 :          0 : py_sha3_new_impl(PyTypeObject *type, PyObject *data, int usedforsecurity)
     106                 :            : /*[clinic end generated code: output=90409addc5d5e8b0 input=bcfcdf2e4368347a]*/
     107                 :            : {
     108                 :            :     HashReturn res;
     109                 :          0 :     Py_buffer buf = {NULL, NULL};
     110                 :          0 :     SHA3State *state = _PyType_GetModuleState(type);
     111                 :          0 :     SHA3object *self = newSHA3object(type);
     112         [ #  # ]:          0 :     if (self == NULL) {
     113                 :          0 :         goto error;
     114                 :            :     }
     115                 :            : 
     116                 :            :     assert(state != NULL);
     117                 :            : 
     118         [ #  # ]:          0 :     if (type == state->sha3_224_type) {
     119                 :          0 :         res = sha3_init(&self->hash_state, 28);
     120         [ #  # ]:          0 :     } else if (type == state->sha3_256_type) {
     121                 :          0 :         res = sha3_init(&self->hash_state, 32);
     122         [ #  # ]:          0 :     } else if (type == state->sha3_384_type) {
     123                 :          0 :         res = sha3_init(&self->hash_state, 48);
     124         [ #  # ]:          0 :     } else if (type == state->sha3_512_type) {
     125                 :          0 :         res = sha3_init(&self->hash_state, 64);
     126         [ #  # ]:          0 :     } else if (type == state->shake_128_type) {
     127                 :          0 :         res = sha3_init(&self->hash_state, 16);
     128         [ #  # ]:          0 :     } else if (type == state->shake_256_type) {
     129                 :          0 :         res = sha3_init(&self->hash_state, 32);
     130                 :            :     } else {
     131                 :          0 :         PyErr_BadInternalCall();
     132                 :          0 :         goto error;
     133                 :            :     }
     134                 :            : 
     135         [ #  # ]:          0 :     if (res != SUCCESS) {
     136                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
     137                 :            :                         "internal error in SHA3 initialize()");
     138                 :          0 :         goto error;
     139                 :            :     }
     140                 :            : 
     141         [ #  # ]:          0 :     if (data) {
     142   [ #  #  #  #  :          0 :         GET_BUFFER_VIEW_OR_ERROR(data, &buf, goto error);
             #  #  #  # ]
     143         [ #  # ]:          0 :         if (buf.len >= HASHLIB_GIL_MINSIZE) {
     144                 :            :             /* invariant: New objects can't be accessed by other code yet,
     145                 :            :              * thus it's safe to release the GIL without locking the object.
     146                 :            :              */
     147                 :          0 :             Py_BEGIN_ALLOW_THREADS
     148                 :          0 :             res = SHA3_process(&self->hash_state, buf.buf, buf.len);
     149                 :          0 :             Py_END_ALLOW_THREADS
     150                 :            :         }
     151                 :            :         else {
     152                 :          0 :             res = SHA3_process(&self->hash_state, buf.buf, buf.len);
     153                 :            :         }
     154         [ #  # ]:          0 :         if (res != SUCCESS) {
     155                 :          0 :             PyErr_SetString(PyExc_RuntimeError,
     156                 :            :                             "internal error in SHA3 Update()");
     157                 :          0 :             goto error;
     158                 :            :         }
     159                 :          0 :         PyBuffer_Release(&buf);
     160                 :            :     }
     161                 :            : 
     162                 :          0 :     return (PyObject *)self;
     163                 :            : 
     164                 :          0 :   error:
     165         [ #  # ]:          0 :     if (self) {
     166                 :          0 :         Py_DECREF(self);
     167                 :            :     }
     168   [ #  #  #  # ]:          0 :     if (data && buf.obj) {
     169                 :          0 :         PyBuffer_Release(&buf);
     170                 :            :     }
     171                 :          0 :     return NULL;
     172                 :            : }
     173                 :            : 
     174                 :            : 
     175                 :            : /* Internal methods for a hash object */
     176                 :            : 
     177                 :            : static void
     178                 :          0 : SHA3_dealloc(SHA3object *self)
     179                 :            : {
     180         [ #  # ]:          0 :     if (self->lock) {
     181                 :          0 :         PyThread_free_lock(self->lock);
     182                 :            :     }
     183                 :            : 
     184                 :          0 :     PyTypeObject *tp = Py_TYPE(self);
     185                 :          0 :     PyObject_Free(self);
     186                 :          0 :     Py_DECREF(tp);
     187                 :          0 : }
     188                 :            : 
     189                 :            : 
     190                 :            : /* External methods for a hash object */
     191                 :            : 
     192                 :            : 
     193                 :            : /*[clinic input]
     194                 :            : _sha3.sha3_224.copy
     195                 :            : 
     196                 :            : Return a copy of the hash object.
     197                 :            : [clinic start generated code]*/
     198                 :            : 
     199                 :            : static PyObject *
     200                 :          0 : _sha3_sha3_224_copy_impl(SHA3object *self)
     201                 :            : /*[clinic end generated code: output=6c537411ecdcda4c input=93a44aaebea51ba8]*/
     202                 :            : {
     203                 :            :     SHA3object *newobj;
     204                 :            : 
     205         [ #  # ]:          0 :     if ((newobj = newSHA3object(Py_TYPE(self))) == NULL) {
     206                 :          0 :         return NULL;
     207                 :            :     }
     208   [ #  #  #  # ]:          0 :     ENTER_HASHLIB(self);
     209                 :          0 :     SHA3_copystate(newobj->hash_state, self->hash_state);
     210         [ #  # ]:          0 :     LEAVE_HASHLIB(self);
     211                 :          0 :     return (PyObject *)newobj;
     212                 :            : }
     213                 :            : 
     214                 :            : 
     215                 :            : /*[clinic input]
     216                 :            : _sha3.sha3_224.digest
     217                 :            : 
     218                 :            : Return the digest value as a bytes object.
     219                 :            : [clinic start generated code]*/
     220                 :            : 
     221                 :            : static PyObject *
     222                 :          0 : _sha3_sha3_224_digest_impl(SHA3object *self)
     223                 :            : /*[clinic end generated code: output=fd531842e20b2d5b input=5b2a659536bbd248]*/
     224                 :            : {
     225                 :            :     unsigned char digest[SHA3_MAX_DIGESTSIZE + SHA3_LANESIZE];
     226                 :            :     SHA3_state temp;
     227                 :            :     HashReturn res;
     228                 :            : 
     229   [ #  #  #  # ]:          0 :     ENTER_HASHLIB(self);
     230                 :          0 :     SHA3_copystate(temp, self->hash_state);
     231         [ #  # ]:          0 :     LEAVE_HASHLIB(self);
     232                 :          0 :     res = SHA3_done(&temp, digest);
     233         [ #  # ]:          0 :     if (res != SUCCESS) {
     234                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "internal error in SHA3 Final()");
     235                 :          0 :         return NULL;
     236                 :            :     }
     237                 :          0 :     return PyBytes_FromStringAndSize((const char *)digest,
     238                 :          0 :                                       self->hash_state.mdlen);
     239                 :            : }
     240                 :            : 
     241                 :            : 
     242                 :            : /*[clinic input]
     243                 :            : _sha3.sha3_224.hexdigest
     244                 :            : 
     245                 :            : Return the digest value as a string of hexadecimal digits.
     246                 :            : [clinic start generated code]*/
     247                 :            : 
     248                 :            : static PyObject *
     249                 :          0 : _sha3_sha3_224_hexdigest_impl(SHA3object *self)
     250                 :            : /*[clinic end generated code: output=75ad03257906918d input=2d91bb6e0d114ee3]*/
     251                 :            : {
     252                 :            :     unsigned char digest[SHA3_MAX_DIGESTSIZE + SHA3_LANESIZE];
     253                 :            :     SHA3_state temp;
     254                 :            :     HashReturn res;
     255                 :            : 
     256                 :            :     /* Get the raw (binary) digest value */
     257   [ #  #  #  # ]:          0 :     ENTER_HASHLIB(self);
     258                 :          0 :     SHA3_copystate(temp, self->hash_state);
     259         [ #  # ]:          0 :     LEAVE_HASHLIB(self);
     260                 :          0 :     res = SHA3_done(&temp, digest);
     261         [ #  # ]:          0 :     if (res != SUCCESS) {
     262                 :          0 :         PyErr_SetString(PyExc_RuntimeError, "internal error in SHA3 Final()");
     263                 :          0 :         return NULL;
     264                 :            :     }
     265                 :          0 :     return _Py_strhex((const char *)digest,
     266                 :          0 :                       self->hash_state.mdlen);
     267                 :            : }
     268                 :            : 
     269                 :            : 
     270                 :            : /*[clinic input]
     271                 :            : _sha3.sha3_224.update
     272                 :            : 
     273                 :            :     data: object
     274                 :            :     /
     275                 :            : 
     276                 :            : Update this hash object's state with the provided bytes-like object.
     277                 :            : [clinic start generated code]*/
     278                 :            : 
     279                 :            : static PyObject *
     280                 :          0 : _sha3_sha3_224_update(SHA3object *self, PyObject *data)
     281                 :            : /*[clinic end generated code: output=d3223352286ed357 input=a887f54dcc4ae227]*/
     282                 :            : {
     283                 :            :     Py_buffer buf;
     284                 :            :     HashReturn res;
     285                 :            : 
     286   [ #  #  #  #  :          0 :     GET_BUFFER_VIEW_OR_ERROUT(data, &buf);
             #  #  #  # ]
     287                 :            : 
     288                 :            :     /* add new data, the function takes the length in bits not bytes */
     289   [ #  #  #  # ]:          0 :     if (self->lock == NULL && buf.len >= HASHLIB_GIL_MINSIZE) {
     290                 :          0 :         self->lock = PyThread_allocate_lock();
     291                 :            :     }
     292                 :            :     /* Once a lock exists all code paths must be synchronized. We have to
     293                 :            :      * release the GIL even for small buffers as acquiring the lock may take
     294                 :            :      * an unlimited amount of time when another thread updates this object
     295                 :            :      * with lots of data. */
     296         [ #  # ]:          0 :     if (self->lock) {
     297                 :          0 :         Py_BEGIN_ALLOW_THREADS
     298                 :          0 :         PyThread_acquire_lock(self->lock, 1);
     299                 :          0 :         res = SHA3_process(&self->hash_state, buf.buf, buf.len);
     300                 :          0 :         PyThread_release_lock(self->lock);
     301                 :          0 :         Py_END_ALLOW_THREADS
     302                 :            :     }
     303                 :            :     else {
     304                 :          0 :         res = SHA3_process(&self->hash_state, buf.buf, buf.len);
     305                 :            :     }
     306                 :            : 
     307         [ #  # ]:          0 :     if (res != SUCCESS) {
     308                 :          0 :         PyBuffer_Release(&buf);
     309                 :          0 :         PyErr_SetString(PyExc_RuntimeError,
     310                 :            :                         "internal error in SHA3 Update()");
     311                 :          0 :         return NULL;
     312                 :            :     }
     313                 :            : 
     314                 :          0 :     PyBuffer_Release(&buf);
     315                 :          0 :     Py_RETURN_NONE;
     316                 :            : }
     317                 :            : 
     318                 :            : 
     319                 :            : static PyMethodDef SHA3_methods[] = {
     320                 :            :     _SHA3_SHA3_224_COPY_METHODDEF
     321                 :            :     _SHA3_SHA3_224_DIGEST_METHODDEF
     322                 :            :     _SHA3_SHA3_224_HEXDIGEST_METHODDEF
     323                 :            :     _SHA3_SHA3_224_UPDATE_METHODDEF
     324                 :            :     {NULL,        NULL}         /* sentinel */
     325                 :            : };
     326                 :            : 
     327                 :            : 
     328                 :            : static PyObject *
     329                 :          0 : SHA3_get_block_size(SHA3object *self, void *closure)
     330                 :            : {
     331                 :          0 :     int rate = self->hash_state.rsiz;
     332                 :          0 :     return PyLong_FromLong(rate);
     333                 :            : }
     334                 :            : 
     335                 :            : 
     336                 :            : static PyObject *
     337                 :          0 : SHA3_get_name(SHA3object *self, void *closure)
     338                 :            : {
     339                 :          0 :     PyTypeObject *type = Py_TYPE(self);
     340                 :            : 
     341                 :          0 :     SHA3State *state = _PyType_GetModuleState(type);
     342                 :            :     assert(state != NULL);
     343                 :            : 
     344         [ #  # ]:          0 :     if (type == state->sha3_224_type) {
     345                 :          0 :         return PyUnicode_FromString("sha3_224");
     346         [ #  # ]:          0 :     } else if (type == state->sha3_256_type) {
     347                 :          0 :         return PyUnicode_FromString("sha3_256");
     348         [ #  # ]:          0 :     } else if (type == state->sha3_384_type) {
     349                 :          0 :         return PyUnicode_FromString("sha3_384");
     350         [ #  # ]:          0 :     } else if (type == state->sha3_512_type) {
     351                 :          0 :         return PyUnicode_FromString("sha3_512");
     352         [ #  # ]:          0 :     } else if (type == state->shake_128_type) {
     353                 :          0 :         return PyUnicode_FromString("shake_128");
     354         [ #  # ]:          0 :     } else if (type == state->shake_256_type) {
     355                 :          0 :         return PyUnicode_FromString("shake_256");
     356                 :            :     } else {
     357                 :          0 :         PyErr_BadInternalCall();
     358                 :          0 :         return NULL;
     359                 :            :     }
     360                 :            : }
     361                 :            : 
     362                 :            : 
     363                 :            : static PyObject *
     364                 :          0 : SHA3_get_digest_size(SHA3object *self, void *closure)
     365                 :            : {
     366                 :          0 :     return PyLong_FromLong(self->hash_state.mdlen);
     367                 :            : }
     368                 :            : 
     369                 :            : 
     370                 :            : static PyObject *
     371                 :          0 : SHA3_get_capacity_bits(SHA3object *self, void *closure)
     372                 :            : {
     373                 :          0 :     int capacity = 1600 - self->hash_state.rsiz * 8;
     374                 :          0 :     return PyLong_FromLong(capacity);
     375                 :            : }
     376                 :            : 
     377                 :            : 
     378                 :            : static PyObject *
     379                 :          0 : SHA3_get_rate_bits(SHA3object *self, void *closure)
     380                 :            : {
     381                 :          0 :     unsigned int rate = self->hash_state.rsiz * 8;
     382                 :          0 :     return PyLong_FromLong(rate);
     383                 :            : }
     384                 :            : 
     385                 :            : static PyObject *
     386                 :          0 : SHA3_get_suffix(SHA3object *self, void *closure)
     387                 :            : {
     388                 :          0 :     unsigned char suffix[2] = {0x06, 0};
     389                 :          0 :     return PyBytes_FromStringAndSize((const char *)suffix, 1);
     390                 :            : }
     391                 :            : 
     392                 :            : static PyGetSetDef SHA3_getseters[] = {
     393                 :            :     {"block_size", (getter)SHA3_get_block_size, NULL, NULL, NULL},
     394                 :            :     {"name", (getter)SHA3_get_name, NULL, NULL, NULL},
     395                 :            :     {"digest_size", (getter)SHA3_get_digest_size, NULL, NULL, NULL},
     396                 :            :     {"_capacity_bits", (getter)SHA3_get_capacity_bits, NULL, NULL, NULL},
     397                 :            :     {"_rate_bits", (getter)SHA3_get_rate_bits, NULL, NULL, NULL},
     398                 :            :     {"_suffix", (getter)SHA3_get_suffix, NULL, NULL, NULL},
     399                 :            :     {NULL}  /* Sentinel */
     400                 :            : };
     401                 :            : 
     402                 :            : #define SHA3_TYPE_SLOTS(type_slots_obj, type_doc, type_methods, type_getseters) \
     403                 :            :     static PyType_Slot type_slots_obj[] = { \
     404                 :            :         {Py_tp_dealloc, SHA3_dealloc}, \
     405                 :            :         {Py_tp_doc, (char*)type_doc}, \
     406                 :            :         {Py_tp_methods, type_methods}, \
     407                 :            :         {Py_tp_getset, type_getseters}, \
     408                 :            :         {Py_tp_new, py_sha3_new}, \
     409                 :            :         {0,0} \
     410                 :            :     }
     411                 :            : 
     412                 :            : // Using _PyType_GetModuleState() on these types is safe since they
     413                 :            : // cannot be subclassed: it does not have the Py_TPFLAGS_BASETYPE flag.
     414                 :            : #define SHA3_TYPE_SPEC(type_spec_obj, type_name, type_slots) \
     415                 :            :     static PyType_Spec type_spec_obj = { \
     416                 :            :         .name = "_sha3." type_name, \
     417                 :            :         .basicsize = sizeof(SHA3object), \
     418                 :            :         .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, \
     419                 :            :         .slots = type_slots \
     420                 :            :     }
     421                 :            : 
     422                 :            : PyDoc_STRVAR(sha3_224__doc__,
     423                 :            : "sha3_224([data], *, usedforsecurity=True) -> SHA3 object\n\
     424                 :            : \n\
     425                 :            : Return a new SHA3 hash object with a hashbit length of 28 bytes.");
     426                 :            : 
     427                 :            : PyDoc_STRVAR(sha3_256__doc__,
     428                 :            : "sha3_256([data], *, usedforsecurity=True) -> SHA3 object\n\
     429                 :            : \n\
     430                 :            : Return a new SHA3 hash object with a hashbit length of 32 bytes.");
     431                 :            : 
     432                 :            : PyDoc_STRVAR(sha3_384__doc__,
     433                 :            : "sha3_384([data], *, usedforsecurity=True) -> SHA3 object\n\
     434                 :            : \n\
     435                 :            : Return a new SHA3 hash object with a hashbit length of 48 bytes.");
     436                 :            : 
     437                 :            : PyDoc_STRVAR(sha3_512__doc__,
     438                 :            : "sha3_512([data], *, usedforsecurity=True) -> SHA3 object\n\
     439                 :            : \n\
     440                 :            : Return a new SHA3 hash object with a hashbit length of 64 bytes.");
     441                 :            : 
     442                 :            : SHA3_TYPE_SLOTS(sha3_224_slots, sha3_224__doc__, SHA3_methods, SHA3_getseters);
     443                 :            : SHA3_TYPE_SPEC(sha3_224_spec, "sha3_224", sha3_224_slots);
     444                 :            : 
     445                 :            : SHA3_TYPE_SLOTS(sha3_256_slots, sha3_256__doc__, SHA3_methods, SHA3_getseters);
     446                 :            : SHA3_TYPE_SPEC(sha3_256_spec, "sha3_256", sha3_256_slots);
     447                 :            : 
     448                 :            : SHA3_TYPE_SLOTS(sha3_384_slots, sha3_384__doc__, SHA3_methods, SHA3_getseters);
     449                 :            : SHA3_TYPE_SPEC(sha3_384_spec, "sha3_384", sha3_384_slots);
     450                 :            : 
     451                 :            : SHA3_TYPE_SLOTS(sha3_512_slots, sha3_512__doc__, SHA3_methods, SHA3_getseters);
     452                 :            : SHA3_TYPE_SPEC(sha3_512_spec, "sha3_512", sha3_512_slots);
     453                 :            : 
     454                 :            : static PyObject *
     455                 :          0 : _SHAKE_digest(SHA3object *self, unsigned long digestlen, int hex)
     456                 :            : {
     457                 :          0 :     unsigned char *digest = NULL;
     458                 :            :     SHA3_state temp;
     459                 :          0 :     PyObject *result = NULL;
     460                 :            : 
     461         [ #  # ]:          0 :     if (digestlen >= (1 << 29)) {
     462                 :          0 :         PyErr_SetString(PyExc_ValueError, "length is too large");
     463                 :          0 :         return NULL;
     464                 :            :     }
     465                 :            :     /* ExtractLane needs at least SHA3_MAX_DIGESTSIZE + SHA3_LANESIZE and
     466                 :            :      * SHA3_LANESIZE extra space.
     467                 :            :      */
     468                 :          0 :     digest = (unsigned char*)PyMem_Malloc(digestlen + SHA3_LANESIZE);
     469         [ #  # ]:          0 :     if (digest == NULL) {
     470                 :          0 :         return PyErr_NoMemory();
     471                 :            :     }
     472                 :            : 
     473                 :            :     /* Get the raw (binary) digest value */
     474   [ #  #  #  # ]:          0 :     ENTER_HASHLIB(self);
     475                 :          0 :     SHA3_copystate(temp, self->hash_state);
     476         [ #  # ]:          0 :     LEAVE_HASHLIB(self);
     477                 :          0 :     SHA3_squeeze(&temp, digest, digestlen);
     478         [ #  # ]:          0 :     if (hex) {
     479                 :          0 :          result = _Py_strhex((const char *)digest, digestlen);
     480                 :            :     } else {
     481                 :          0 :         result = PyBytes_FromStringAndSize((const char *)digest,
     482                 :            :                                            digestlen);
     483                 :            :     }
     484         [ #  # ]:          0 :     if (digest != NULL) {
     485                 :          0 :         PyMem_Free(digest);
     486                 :            :     }
     487                 :          0 :     return result;
     488                 :            : }
     489                 :            : 
     490                 :            : 
     491                 :            : /*[clinic input]
     492                 :            : _sha3.shake_128.digest
     493                 :            : 
     494                 :            :     length: unsigned_long
     495                 :            :     /
     496                 :            : 
     497                 :            : Return the digest value as a bytes object.
     498                 :            : [clinic start generated code]*/
     499                 :            : 
     500                 :            : static PyObject *
     501                 :          0 : _sha3_shake_128_digest_impl(SHA3object *self, unsigned long length)
     502                 :            : /*[clinic end generated code: output=2313605e2f87bb8f input=418ef6a36d2e6082]*/
     503                 :            : {
     504                 :          0 :     return _SHAKE_digest(self, length, 0);
     505                 :            : }
     506                 :            : 
     507                 :            : 
     508                 :            : /*[clinic input]
     509                 :            : _sha3.shake_128.hexdigest
     510                 :            : 
     511                 :            :     length: unsigned_long
     512                 :            :     /
     513                 :            : 
     514                 :            : Return the digest value as a string of hexadecimal digits.
     515                 :            : [clinic start generated code]*/
     516                 :            : 
     517                 :            : static PyObject *
     518                 :          0 : _sha3_shake_128_hexdigest_impl(SHA3object *self, unsigned long length)
     519                 :            : /*[clinic end generated code: output=bf8e2f1e490944a8 input=69fb29b0926ae321]*/
     520                 :            : {
     521                 :          0 :     return _SHAKE_digest(self, length, 1);
     522                 :            : }
     523                 :            : 
     524                 :            : static PyObject *
     525                 :          0 : SHAKE_get_digest_size(SHA3object *self, void *closure)
     526                 :            : {
     527                 :          0 :     return PyLong_FromLong(0);
     528                 :            : }
     529                 :            : 
     530                 :            : static PyObject *
     531                 :          0 : SHAKE_get_suffix(SHA3object *self, void *closure)
     532                 :            : {
     533                 :          0 :     unsigned char suffix[2] = {0x1f, 0};
     534                 :          0 :     return PyBytes_FromStringAndSize((const char *)suffix, 1);
     535                 :            : }
     536                 :            : 
     537                 :            : 
     538                 :            : static PyGetSetDef SHAKE_getseters[] = {
     539                 :            :     {"block_size", (getter)SHA3_get_block_size, NULL, NULL, NULL},
     540                 :            :     {"name", (getter)SHA3_get_name, NULL, NULL, NULL},
     541                 :            :     {"digest_size", (getter)SHAKE_get_digest_size, NULL, NULL, NULL},
     542                 :            :     {"_capacity_bits", (getter)SHA3_get_capacity_bits, NULL, NULL, NULL},
     543                 :            :     {"_rate_bits", (getter)SHA3_get_rate_bits, NULL, NULL, NULL},
     544                 :            :     {"_suffix", (getter)SHAKE_get_suffix, NULL, NULL, NULL},
     545                 :            :     {NULL}  /* Sentinel */
     546                 :            : };
     547                 :            : 
     548                 :            : 
     549                 :            : static PyMethodDef SHAKE_methods[] = {
     550                 :            :     _SHA3_SHA3_224_COPY_METHODDEF
     551                 :            :     _SHA3_SHAKE_128_DIGEST_METHODDEF
     552                 :            :     _SHA3_SHAKE_128_HEXDIGEST_METHODDEF
     553                 :            :     _SHA3_SHA3_224_UPDATE_METHODDEF
     554                 :            :     {NULL,        NULL}         /* sentinel */
     555                 :            : };
     556                 :            : 
     557                 :            : PyDoc_STRVAR(shake_128__doc__,
     558                 :            : "shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\
     559                 :            : \n\
     560                 :            : Return a new SHAKE hash object.");
     561                 :            : 
     562                 :            : PyDoc_STRVAR(shake_256__doc__,
     563                 :            : "shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\
     564                 :            : \n\
     565                 :            : Return a new SHAKE hash object.");
     566                 :            : 
     567                 :            : SHA3_TYPE_SLOTS(SHAKE128slots, shake_128__doc__, SHAKE_methods, SHAKE_getseters);
     568                 :            : SHA3_TYPE_SPEC(SHAKE128_spec, "shake_128", SHAKE128slots);
     569                 :            : 
     570                 :            : SHA3_TYPE_SLOTS(SHAKE256slots, shake_256__doc__, SHAKE_methods, SHAKE_getseters);
     571                 :            : SHA3_TYPE_SPEC(SHAKE256_spec, "shake_256", SHAKE256slots);
     572                 :            : 
     573                 :            : 
     574                 :            : static int
     575                 :          8 : _sha3_traverse(PyObject *module, visitproc visit, void *arg)
     576                 :            : {
     577                 :          8 :     SHA3State *state = sha3_get_state(module);
     578   [ +  -  -  + ]:          8 :     Py_VISIT(state->sha3_224_type);
     579   [ +  -  -  + ]:          8 :     Py_VISIT(state->sha3_256_type);
     580   [ +  -  -  + ]:          8 :     Py_VISIT(state->sha3_384_type);
     581   [ +  -  -  + ]:          8 :     Py_VISIT(state->sha3_512_type);
     582   [ +  -  -  + ]:          8 :     Py_VISIT(state->shake_128_type);
     583   [ +  -  -  + ]:          8 :     Py_VISIT(state->shake_256_type);
     584                 :          8 :     return 0;
     585                 :            : }
     586                 :            : 
     587                 :            : static int
     588                 :          2 : _sha3_clear(PyObject *module)
     589                 :            : {
     590                 :          2 :     SHA3State *state = sha3_get_state(module);
     591         [ +  + ]:          2 :     Py_CLEAR(state->sha3_224_type);
     592         [ +  + ]:          2 :     Py_CLEAR(state->sha3_256_type);
     593         [ +  + ]:          2 :     Py_CLEAR(state->sha3_384_type);
     594         [ +  + ]:          2 :     Py_CLEAR(state->sha3_512_type);
     595         [ +  + ]:          2 :     Py_CLEAR(state->shake_128_type);
     596         [ +  + ]:          2 :     Py_CLEAR(state->shake_256_type);
     597                 :          2 :     return 0;
     598                 :            : }
     599                 :            : 
     600                 :            : static void
     601                 :          1 : _sha3_free(void *module)
     602                 :            : {
     603                 :          1 :     _sha3_clear((PyObject *)module);
     604                 :          1 : }
     605                 :            : 
     606                 :            : static int
     607                 :          1 : _sha3_exec(PyObject *m)
     608                 :            : {
     609                 :          1 :     SHA3State *st = sha3_get_state(m);
     610                 :            : 
     611                 :            : #define init_sha3type(type, typespec)                           \
     612                 :            :     do {                                                        \
     613                 :            :         st->type = (PyTypeObject *)PyType_FromModuleAndSpec(    \
     614                 :            :             m, &typespec, NULL);                                \
     615                 :            :         if (st->type == NULL) {                                 \
     616                 :            :             return -1;                                          \
     617                 :            :         }                                                       \
     618                 :            :         if (PyModule_AddType(m, st->type) < 0) {                \
     619                 :            :             return -1;                                          \
     620                 :            :         }                                                       \
     621                 :            :     } while(0)
     622                 :            : 
     623   [ -  +  -  + ]:          1 :     init_sha3type(sha3_224_type, sha3_224_spec);
     624   [ -  +  -  + ]:          1 :     init_sha3type(sha3_256_type, sha3_256_spec);
     625   [ -  +  -  + ]:          1 :     init_sha3type(sha3_384_type, sha3_384_spec);
     626   [ -  +  -  + ]:          1 :     init_sha3type(sha3_512_type, sha3_512_spec);
     627   [ -  +  -  + ]:          1 :     init_sha3type(shake_128_type, SHAKE128_spec);
     628   [ -  +  -  + ]:          1 :     init_sha3type(shake_256_type, SHAKE256_spec);
     629                 :            : #undef init_sha3type
     630                 :            : 
     631         [ -  + ]:          1 :     if (PyModule_AddIntConstant(m, "keccakopt", KeccakOpt) < 0) {
     632                 :          0 :         return -1;
     633                 :            :     }
     634         [ -  + ]:          1 :     if (PyModule_AddStringConstant(m, "implementation",
     635                 :            :                                    "tiny_sha3") < 0) {
     636                 :          0 :         return -1;
     637                 :            :     }
     638                 :            : 
     639                 :          1 :     return 0;
     640                 :            : }
     641                 :            : 
     642                 :            : static PyModuleDef_Slot _sha3_slots[] = {
     643                 :            :     {Py_mod_exec, _sha3_exec},
     644                 :            :     {0, NULL}
     645                 :            : };
     646                 :            : 
     647                 :            : /* Initialize this module. */
     648                 :            : static struct PyModuleDef _sha3module = {
     649                 :            :     PyModuleDef_HEAD_INIT,
     650                 :            :     .m_name = "_sha3",
     651                 :            :     .m_size = sizeof(SHA3State),
     652                 :            :     .m_slots = _sha3_slots,
     653                 :            :     .m_traverse = _sha3_traverse,
     654                 :            :     .m_clear = _sha3_clear,
     655                 :            :     .m_free = _sha3_free,
     656                 :            : };
     657                 :            : 
     658                 :            : 
     659                 :            : PyMODINIT_FUNC
     660                 :          1 : PyInit__sha3(void)
     661                 :            : {
     662                 :          1 :     return PyModuleDef_Init(&_sha3module);
     663                 :            : }

Generated by: LCOV version 1.14