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 #define SHA3_MAX_DIGESTSIZE 64 /* 64 Bytes (512 Bits) for 224 to 512 */
28
29 typedef struct {
30 PyTypeObject *sha3_224_type;
31 PyTypeObject *sha3_256_type;
32 PyTypeObject *sha3_384_type;
33 PyTypeObject *sha3_512_type;
34 PyTypeObject *shake_128_type;
35 PyTypeObject *shake_256_type;
36 } SHA3State;
37
38 static inline SHA3State*
sha3_get_state(PyObject * module)39 sha3_get_state(PyObject *module)
40 {
41 void *state = PyModule_GetState(module);
42 assert(state != NULL);
43 return (SHA3State *)state;
44 }
45
46 /*[clinic input]
47 module _sha3
48 class _sha3.sha3_224 "SHA3object *" "&SHA3_224typ"
49 class _sha3.sha3_256 "SHA3object *" "&SHA3_256typ"
50 class _sha3.sha3_384 "SHA3object *" "&SHA3_384typ"
51 class _sha3.sha3_512 "SHA3object *" "&SHA3_512typ"
52 class _sha3.shake_128 "SHA3object *" "&SHAKE128type"
53 class _sha3.shake_256 "SHA3object *" "&SHAKE256type"
54 [clinic start generated code]*/
55 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=b8a53680f370285a]*/
56
57 /* The structure for storing SHA3 info */
58
59 #include "_hacl/Hacl_Hash_SHA3.h"
60
61 typedef struct {
62 PyObject_HEAD
63 // Prevents undefined behavior via multiple threads entering the C API.
64 bool use_mutex;
65 PyMutex mutex;
66 Hacl_Hash_SHA3_state_t *hash_state;
67 } SHA3object;
68
69 #include "clinic/sha3module.c.h"
70
71 static SHA3object *
newSHA3object(PyTypeObject * type)72 newSHA3object(PyTypeObject *type)
73 {
74 SHA3object *newobj;
75 newobj = (SHA3object *)PyObject_New(SHA3object, type);
76 if (newobj == NULL) {
77 return NULL;
78 }
79 HASHLIB_INIT_MUTEX(newobj);
80
81 return newobj;
82 }
83
sha3_update(Hacl_Hash_SHA3_state_t * state,uint8_t * buf,Py_ssize_t len)84 static void sha3_update(Hacl_Hash_SHA3_state_t *state, uint8_t *buf, Py_ssize_t len) {
85 /* Note: we explicitly ignore the error code on the basis that it would take >
86 * 1 billion years to hash more than 2^64 bytes. */
87 #if PY_SSIZE_T_MAX > UINT32_MAX
88 while (len > UINT32_MAX) {
89 Hacl_Hash_SHA3_update(state, buf, UINT32_MAX);
90 len -= UINT32_MAX;
91 buf += UINT32_MAX;
92 }
93 #endif
94 /* Cast to uint32_t is safe: len <= UINT32_MAX at this point. */
95 Hacl_Hash_SHA3_update(state, buf, (uint32_t) len);
96 }
97
98 /*[clinic input]
99 @classmethod
100 _sha3.sha3_224.__new__ as py_sha3_new
101 data: object(c_default="NULL") = b''
102 /
103 *
104 usedforsecurity: bool = True
105
106 Return a new SHA3 hash object.
107 [clinic start generated code]*/
108
109 static PyObject *
py_sha3_new_impl(PyTypeObject * type,PyObject * data,int usedforsecurity)110 py_sha3_new_impl(PyTypeObject *type, PyObject *data, int usedforsecurity)
111 /*[clinic end generated code: output=90409addc5d5e8b0 input=637e5f8f6a93982a]*/
112 {
113 Py_buffer buf = {NULL, NULL};
114 SHA3State *state = _PyType_GetModuleState(type);
115 SHA3object *self = newSHA3object(type);
116 if (self == NULL) {
117 goto error;
118 }
119
120 assert(state != NULL);
121
122 if (type == state->sha3_224_type) {
123 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_SHA3_224);
124 } else if (type == state->sha3_256_type) {
125 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_SHA3_256);
126 } else if (type == state->sha3_384_type) {
127 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_SHA3_384);
128 } else if (type == state->sha3_512_type) {
129 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_SHA3_512);
130 } else if (type == state->shake_128_type) {
131 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_Shake128);
132 } else if (type == state->shake_256_type) {
133 self->hash_state = Hacl_Hash_SHA3_malloc(Spec_Hash_Definitions_Shake256);
134 } else {
135 PyErr_BadInternalCall();
136 goto error;
137 }
138
139 if (data) {
140 GET_BUFFER_VIEW_OR_ERROR(data, &buf, goto error);
141 if (buf.len >= HASHLIB_GIL_MINSIZE) {
142 /* We do not initialize self->lock here as this is the constructor
143 * where it is not yet possible to have concurrent access. */
144 Py_BEGIN_ALLOW_THREADS
145 sha3_update(self->hash_state, buf.buf, buf.len);
146 Py_END_ALLOW_THREADS
147 } else {
148 sha3_update(self->hash_state, buf.buf, buf.len);
149 }
150 }
151
152 PyBuffer_Release(&buf);
153
154 return (PyObject *)self;
155
156 error:
157 if (self) {
158 Py_DECREF(self);
159 }
160 if (data && buf.obj) {
161 PyBuffer_Release(&buf);
162 }
163 return NULL;
164 }
165
166
167 /* Internal methods for a hash object */
168
169 static void
SHA3_dealloc(SHA3object * self)170 SHA3_dealloc(SHA3object *self)
171 {
172 Hacl_Hash_SHA3_free(self->hash_state);
173 PyTypeObject *tp = Py_TYPE(self);
174 PyObject_Free(self);
175 Py_DECREF(tp);
176 }
177
178
179 /* External methods for a hash object */
180
181
182 /*[clinic input]
183 _sha3.sha3_224.copy
184
185 Return a copy of the hash object.
186 [clinic start generated code]*/
187
188 static PyObject *
_sha3_sha3_224_copy_impl(SHA3object * self)189 _sha3_sha3_224_copy_impl(SHA3object *self)
190 /*[clinic end generated code: output=6c537411ecdcda4c input=93a44aaebea51ba8]*/
191 {
192 SHA3object *newobj;
193
194 if ((newobj = newSHA3object(Py_TYPE(self))) == NULL) {
195 return NULL;
196 }
197 ENTER_HASHLIB(self);
198 newobj->hash_state = Hacl_Hash_SHA3_copy(self->hash_state);
199 LEAVE_HASHLIB(self);
200 return (PyObject *)newobj;
201 }
202
203
204 /*[clinic input]
205 _sha3.sha3_224.digest
206
207 Return the digest value as a bytes object.
208 [clinic start generated code]*/
209
210 static PyObject *
_sha3_sha3_224_digest_impl(SHA3object * self)211 _sha3_sha3_224_digest_impl(SHA3object *self)
212 /*[clinic end generated code: output=fd531842e20b2d5b input=5b2a659536bbd248]*/
213 {
214 unsigned char digest[SHA3_MAX_DIGESTSIZE];
215 // This function errors out if the algorithm is Shake. Here, we know this
216 // not to be the case, and therefore do not perform error checking.
217 ENTER_HASHLIB(self);
218 Hacl_Hash_SHA3_digest(self->hash_state, digest);
219 LEAVE_HASHLIB(self);
220 return PyBytes_FromStringAndSize((const char *)digest,
221 Hacl_Hash_SHA3_hash_len(self->hash_state));
222 }
223
224
225 /*[clinic input]
226 _sha3.sha3_224.hexdigest
227
228 Return the digest value as a string of hexadecimal digits.
229 [clinic start generated code]*/
230
231 static PyObject *
_sha3_sha3_224_hexdigest_impl(SHA3object * self)232 _sha3_sha3_224_hexdigest_impl(SHA3object *self)
233 /*[clinic end generated code: output=75ad03257906918d input=2d91bb6e0d114ee3]*/
234 {
235 unsigned char digest[SHA3_MAX_DIGESTSIZE];
236 ENTER_HASHLIB(self);
237 Hacl_Hash_SHA3_digest(self->hash_state, digest);
238 LEAVE_HASHLIB(self);
239 return _Py_strhex((const char *)digest,
240 Hacl_Hash_SHA3_hash_len(self->hash_state));
241 }
242
243
244 /*[clinic input]
245 _sha3.sha3_224.update
246
247 data: object
248 /
249
250 Update this hash object's state with the provided bytes-like object.
251 [clinic start generated code]*/
252
253 static PyObject *
_sha3_sha3_224_update(SHA3object * self,PyObject * data)254 _sha3_sha3_224_update(SHA3object *self, PyObject *data)
255 /*[clinic end generated code: output=d3223352286ed357 input=a887f54dcc4ae227]*/
256 {
257 Py_buffer buf;
258
259 GET_BUFFER_VIEW_OR_ERROUT(data, &buf);
260
261 if (!self->use_mutex && buf.len >= HASHLIB_GIL_MINSIZE) {
262 self->use_mutex = true;
263 }
264 if (self->use_mutex) {
265 Py_BEGIN_ALLOW_THREADS
266 PyMutex_Lock(&self->mutex);
267 sha3_update(self->hash_state, buf.buf, buf.len);
268 PyMutex_Unlock(&self->mutex);
269 Py_END_ALLOW_THREADS
270 } else {
271 sha3_update(self->hash_state, buf.buf, buf.len);
272 }
273
274 PyBuffer_Release(&buf);
275 Py_RETURN_NONE;
276 }
277
278
279 static PyMethodDef SHA3_methods[] = {
280 _SHA3_SHA3_224_COPY_METHODDEF
281 _SHA3_SHA3_224_DIGEST_METHODDEF
282 _SHA3_SHA3_224_HEXDIGEST_METHODDEF
283 _SHA3_SHA3_224_UPDATE_METHODDEF
284 {NULL, NULL} /* sentinel */
285 };
286
287
288 static PyObject *
SHA3_get_block_size(SHA3object * self,void * closure)289 SHA3_get_block_size(SHA3object *self, void *closure)
290 {
291 uint32_t rate = Hacl_Hash_SHA3_block_len(self->hash_state);
292 return PyLong_FromLong(rate);
293 }
294
295
296 static PyObject *
SHA3_get_name(SHA3object * self,void * closure)297 SHA3_get_name(SHA3object *self, void *closure)
298 {
299 PyTypeObject *type = Py_TYPE(self);
300
301 SHA3State *state = _PyType_GetModuleState(type);
302 assert(state != NULL);
303
304 if (type == state->sha3_224_type) {
305 return PyUnicode_FromString("sha3_224");
306 } else if (type == state->sha3_256_type) {
307 return PyUnicode_FromString("sha3_256");
308 } else if (type == state->sha3_384_type) {
309 return PyUnicode_FromString("sha3_384");
310 } else if (type == state->sha3_512_type) {
311 return PyUnicode_FromString("sha3_512");
312 } else if (type == state->shake_128_type) {
313 return PyUnicode_FromString("shake_128");
314 } else if (type == state->shake_256_type) {
315 return PyUnicode_FromString("shake_256");
316 } else {
317 PyErr_BadInternalCall();
318 return NULL;
319 }
320 }
321
322
323 static PyObject *
SHA3_get_digest_size(SHA3object * self,void * closure)324 SHA3_get_digest_size(SHA3object *self, void *closure)
325 {
326 // Preserving previous behavior: variable-length algorithms return 0
327 if (Hacl_Hash_SHA3_is_shake(self->hash_state))
328 return PyLong_FromLong(0);
329 else
330 return PyLong_FromLong(Hacl_Hash_SHA3_hash_len(self->hash_state));
331 }
332
333
334 static PyObject *
SHA3_get_capacity_bits(SHA3object * self,void * closure)335 SHA3_get_capacity_bits(SHA3object *self, void *closure)
336 {
337 uint32_t rate = Hacl_Hash_SHA3_block_len(self->hash_state) * 8;
338 int capacity = 1600 - rate;
339 return PyLong_FromLong(capacity);
340 }
341
342
343 static PyObject *
SHA3_get_rate_bits(SHA3object * self,void * closure)344 SHA3_get_rate_bits(SHA3object *self, void *closure)
345 {
346 uint32_t rate = Hacl_Hash_SHA3_block_len(self->hash_state) * 8;
347 return PyLong_FromLong(rate);
348 }
349
350 static PyObject *
SHA3_get_suffix(SHA3object * self,void * closure)351 SHA3_get_suffix(SHA3object *self, void *closure)
352 {
353 unsigned char suffix[2] = {0x06, 0};
354 return PyBytes_FromStringAndSize((const char *)suffix, 1);
355 }
356
357 static PyGetSetDef SHA3_getseters[] = {
358 {"block_size", (getter)SHA3_get_block_size, NULL, NULL, NULL},
359 {"name", (getter)SHA3_get_name, NULL, NULL, NULL},
360 {"digest_size", (getter)SHA3_get_digest_size, NULL, NULL, NULL},
361 {"_capacity_bits", (getter)SHA3_get_capacity_bits, NULL, NULL, NULL},
362 {"_rate_bits", (getter)SHA3_get_rate_bits, NULL, NULL, NULL},
363 {"_suffix", (getter)SHA3_get_suffix, NULL, NULL, NULL},
364 {NULL} /* Sentinel */
365 };
366
367 #define SHA3_TYPE_SLOTS(type_slots_obj, type_doc, type_methods, type_getseters) \
368 static PyType_Slot type_slots_obj[] = { \
369 {Py_tp_dealloc, SHA3_dealloc}, \
370 {Py_tp_doc, (char*)type_doc}, \
371 {Py_tp_methods, type_methods}, \
372 {Py_tp_getset, type_getseters}, \
373 {Py_tp_new, py_sha3_new}, \
374 {0,0} \
375 }
376
377 // Using _PyType_GetModuleState() on these types is safe since they
378 // cannot be subclassed: it does not have the Py_TPFLAGS_BASETYPE flag.
379 #define SHA3_TYPE_SPEC(type_spec_obj, type_name, type_slots) \
380 static PyType_Spec type_spec_obj = { \
381 .name = "_sha3." type_name, \
382 .basicsize = sizeof(SHA3object), \
383 .flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_IMMUTABLETYPE, \
384 .slots = type_slots \
385 }
386
387 PyDoc_STRVAR(sha3_224__doc__,
388 "sha3_224([data], *, usedforsecurity=True) -> SHA3 object\n\
389 \n\
390 Return a new SHA3 hash object with a hashbit length of 28 bytes.");
391
392 PyDoc_STRVAR(sha3_256__doc__,
393 "sha3_256([data], *, usedforsecurity=True) -> SHA3 object\n\
394 \n\
395 Return a new SHA3 hash object with a hashbit length of 32 bytes.");
396
397 PyDoc_STRVAR(sha3_384__doc__,
398 "sha3_384([data], *, usedforsecurity=True) -> SHA3 object\n\
399 \n\
400 Return a new SHA3 hash object with a hashbit length of 48 bytes.");
401
402 PyDoc_STRVAR(sha3_512__doc__,
403 "sha3_512([data], *, usedforsecurity=True) -> SHA3 object\n\
404 \n\
405 Return a new SHA3 hash object with a hashbit length of 64 bytes.");
406
407 SHA3_TYPE_SLOTS(sha3_224_slots, sha3_224__doc__, SHA3_methods, SHA3_getseters);
408 SHA3_TYPE_SPEC(sha3_224_spec, "sha3_224", sha3_224_slots);
409
410 SHA3_TYPE_SLOTS(sha3_256_slots, sha3_256__doc__, SHA3_methods, SHA3_getseters);
411 SHA3_TYPE_SPEC(sha3_256_spec, "sha3_256", sha3_256_slots);
412
413 SHA3_TYPE_SLOTS(sha3_384_slots, sha3_384__doc__, SHA3_methods, SHA3_getseters);
414 SHA3_TYPE_SPEC(sha3_384_spec, "sha3_384", sha3_384_slots);
415
416 SHA3_TYPE_SLOTS(sha3_512_slots, sha3_512__doc__, SHA3_methods, SHA3_getseters);
417 SHA3_TYPE_SPEC(sha3_512_spec, "sha3_512", sha3_512_slots);
418
419 static PyObject *
_SHAKE_digest(SHA3object * self,unsigned long digestlen,int hex)420 _SHAKE_digest(SHA3object *self, unsigned long digestlen, int hex)
421 {
422 unsigned char *digest = NULL;
423 PyObject *result = NULL;
424
425 if (digestlen >= (1 << 29)) {
426 PyErr_SetString(PyExc_ValueError, "length is too large");
427 return NULL;
428 }
429 digest = (unsigned char*)PyMem_Malloc(digestlen);
430 if (digest == NULL) {
431 return PyErr_NoMemory();
432 }
433
434 /* Get the raw (binary) digest value. The HACL functions errors out if:
435 * - the algorith is not shake -- not the case here
436 * - the output length is zero -- we follow the existing behavior and return
437 * an empty digest, without raising an error */
438 if (digestlen > 0) {
439 Hacl_Hash_SHA3_squeeze(self->hash_state, digest, digestlen);
440 }
441 if (hex) {
442 result = _Py_strhex((const char *)digest, digestlen);
443 } else {
444 result = PyBytes_FromStringAndSize((const char *)digest,
445 digestlen);
446 }
447 if (digest != NULL) {
448 PyMem_Free(digest);
449 }
450 return result;
451 }
452
453
454 /*[clinic input]
455 _sha3.shake_128.digest
456
457 length: unsigned_long
458 /
459
460 Return the digest value as a bytes object.
461 [clinic start generated code]*/
462
463 static PyObject *
_sha3_shake_128_digest_impl(SHA3object * self,unsigned long length)464 _sha3_shake_128_digest_impl(SHA3object *self, unsigned long length)
465 /*[clinic end generated code: output=2313605e2f87bb8f input=418ef6a36d2e6082]*/
466 {
467 return _SHAKE_digest(self, length, 0);
468 }
469
470
471 /*[clinic input]
472 _sha3.shake_128.hexdigest
473
474 length: unsigned_long
475 /
476
477 Return the digest value as a string of hexadecimal digits.
478 [clinic start generated code]*/
479
480 static PyObject *
_sha3_shake_128_hexdigest_impl(SHA3object * self,unsigned long length)481 _sha3_shake_128_hexdigest_impl(SHA3object *self, unsigned long length)
482 /*[clinic end generated code: output=bf8e2f1e490944a8 input=69fb29b0926ae321]*/
483 {
484 return _SHAKE_digest(self, length, 1);
485 }
486
487 static PyObject *
SHAKE_get_digest_size(SHA3object * self,void * closure)488 SHAKE_get_digest_size(SHA3object *self, void *closure)
489 {
490 return PyLong_FromLong(0);
491 }
492
493 static PyObject *
SHAKE_get_suffix(SHA3object * self,void * closure)494 SHAKE_get_suffix(SHA3object *self, void *closure)
495 {
496 unsigned char suffix[2] = {0x1f, 0};
497 return PyBytes_FromStringAndSize((const char *)suffix, 1);
498 }
499
500
501 static PyGetSetDef SHAKE_getseters[] = {
502 {"block_size", (getter)SHA3_get_block_size, NULL, NULL, NULL},
503 {"name", (getter)SHA3_get_name, NULL, NULL, NULL},
504 {"digest_size", (getter)SHAKE_get_digest_size, NULL, NULL, NULL},
505 {"_capacity_bits", (getter)SHA3_get_capacity_bits, NULL, NULL, NULL},
506 {"_rate_bits", (getter)SHA3_get_rate_bits, NULL, NULL, NULL},
507 {"_suffix", (getter)SHAKE_get_suffix, NULL, NULL, NULL},
508 {NULL} /* Sentinel */
509 };
510
511
512 static PyMethodDef SHAKE_methods[] = {
513 _SHA3_SHA3_224_COPY_METHODDEF
514 _SHA3_SHAKE_128_DIGEST_METHODDEF
515 _SHA3_SHAKE_128_HEXDIGEST_METHODDEF
516 _SHA3_SHA3_224_UPDATE_METHODDEF
517 {NULL, NULL} /* sentinel */
518 };
519
520 PyDoc_STRVAR(shake_128__doc__,
521 "shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\
522 \n\
523 Return a new SHAKE hash object.");
524
525 PyDoc_STRVAR(shake_256__doc__,
526 "shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\
527 \n\
528 Return a new SHAKE hash object.");
529
530 SHA3_TYPE_SLOTS(SHAKE128slots, shake_128__doc__, SHAKE_methods, SHAKE_getseters);
531 SHA3_TYPE_SPEC(SHAKE128_spec, "shake_128", SHAKE128slots);
532
533 SHA3_TYPE_SLOTS(SHAKE256slots, shake_256__doc__, SHAKE_methods, SHAKE_getseters);
534 SHA3_TYPE_SPEC(SHAKE256_spec, "shake_256", SHAKE256slots);
535
536
537 static int
_sha3_traverse(PyObject * module,visitproc visit,void * arg)538 _sha3_traverse(PyObject *module, visitproc visit, void *arg)
539 {
540 SHA3State *state = sha3_get_state(module);
541 Py_VISIT(state->sha3_224_type);
542 Py_VISIT(state->sha3_256_type);
543 Py_VISIT(state->sha3_384_type);
544 Py_VISIT(state->sha3_512_type);
545 Py_VISIT(state->shake_128_type);
546 Py_VISIT(state->shake_256_type);
547 return 0;
548 }
549
550 static int
_sha3_clear(PyObject * module)551 _sha3_clear(PyObject *module)
552 {
553 SHA3State *state = sha3_get_state(module);
554 Py_CLEAR(state->sha3_224_type);
555 Py_CLEAR(state->sha3_256_type);
556 Py_CLEAR(state->sha3_384_type);
557 Py_CLEAR(state->sha3_512_type);
558 Py_CLEAR(state->shake_128_type);
559 Py_CLEAR(state->shake_256_type);
560 return 0;
561 }
562
563 static void
_sha3_free(void * module)564 _sha3_free(void *module)
565 {
566 _sha3_clear((PyObject *)module);
567 }
568
569 static int
_sha3_exec(PyObject * m)570 _sha3_exec(PyObject *m)
571 {
572 SHA3State *st = sha3_get_state(m);
573
574 #define init_sha3type(type, typespec) \
575 do { \
576 st->type = (PyTypeObject *)PyType_FromModuleAndSpec( \
577 m, &typespec, NULL); \
578 if (st->type == NULL) { \
579 return -1; \
580 } \
581 if (PyModule_AddType(m, st->type) < 0) { \
582 return -1; \
583 } \
584 } while(0)
585
586 init_sha3type(sha3_224_type, sha3_224_spec);
587 init_sha3type(sha3_256_type, sha3_256_spec);
588 init_sha3type(sha3_384_type, sha3_384_spec);
589 init_sha3type(sha3_512_type, sha3_512_spec);
590 init_sha3type(shake_128_type, SHAKE128_spec);
591 init_sha3type(shake_256_type, SHAKE256_spec);
592 #undef init_sha3type
593
594 if (PyModule_AddStringConstant(m, "implementation",
595 "HACL") < 0) {
596 return -1;
597 }
598
599 return 0;
600 }
601
602 static PyModuleDef_Slot _sha3_slots[] = {
603 {Py_mod_exec, _sha3_exec},
604 {Py_mod_multiple_interpreters, Py_MOD_PER_INTERPRETER_GIL_SUPPORTED},
605 {Py_mod_gil, Py_MOD_GIL_NOT_USED},
606 {0, NULL}
607 };
608
609 /* Initialize this module. */
610 static struct PyModuleDef _sha3module = {
611 PyModuleDef_HEAD_INIT,
612 .m_name = "_sha3",
613 .m_size = sizeof(SHA3State),
614 .m_slots = _sha3_slots,
615 .m_traverse = _sha3_traverse,
616 .m_clear = _sha3_clear,
617 .m_free = _sha3_free,
618 };
619
620
621 PyMODINIT_FUNC
PyInit__sha3(void)622 PyInit__sha3(void)
623 {
624 return PyModuleDef_Init(&_sha3module);
625 }
626