1/*[clinic input]
2preserve
3[clinic start generated code]*/
4
5PyDoc_STRVAR(EVP_copy__doc__,
6"copy($self, /)\n"
7"--\n"
8"\n"
9"Return a copy of the hash object.");
10
11#define EVP_COPY_METHODDEF \
12 {"copy", (PyCFunction)EVP_copy, METH_NOARGS, EVP_copy__doc__},
13
14static PyObject *
15EVP_copy_impl(EVPobject *self);
16
17static PyObject *
18EVP_copy(EVPobject *self, PyObject *Py_UNUSED(ignored))
19{
20 return EVP_copy_impl(self);
21}
22
23PyDoc_STRVAR(EVP_digest__doc__,
24"digest($self, /)\n"
25"--\n"
26"\n"
27"Return the digest value as a bytes object.");
28
29#define EVP_DIGEST_METHODDEF \
30 {"digest", (PyCFunction)EVP_digest, METH_NOARGS, EVP_digest__doc__},
31
32static PyObject *
33EVP_digest_impl(EVPobject *self);
34
35static PyObject *
36EVP_digest(EVPobject *self, PyObject *Py_UNUSED(ignored))
37{
38 return EVP_digest_impl(self);
39}
40
41PyDoc_STRVAR(EVP_hexdigest__doc__,
42"hexdigest($self, /)\n"
43"--\n"
44"\n"
45"Return the digest value as a string of hexadecimal digits.");
46
47#define EVP_HEXDIGEST_METHODDEF \
48 {"hexdigest", (PyCFunction)EVP_hexdigest, METH_NOARGS, EVP_hexdigest__doc__},
49
50static PyObject *
51EVP_hexdigest_impl(EVPobject *self);
52
53static PyObject *
54EVP_hexdigest(EVPobject *self, PyObject *Py_UNUSED(ignored))
55{
56 return EVP_hexdigest_impl(self);
57}
58
59PyDoc_STRVAR(EVP_update__doc__,
60"update($self, obj, /)\n"
61"--\n"
62"\n"
63"Update this hash object\'s state with the provided string.");
64
65#define EVP_UPDATE_METHODDEF \
66 {"update", (PyCFunction)EVP_update, METH_O, EVP_update__doc__},
67
68#if defined(PY_OPENSSL_HAS_SHAKE)
69
70PyDoc_STRVAR(EVPXOF_digest__doc__,
71"digest($self, /, length)\n"
72"--\n"
73"\n"
74"Return the digest value as a bytes object.");
75
76#define EVPXOF_DIGEST_METHODDEF \
77 {"digest", (PyCFunction)(void(*)(void))EVPXOF_digest, METH_FASTCALL|METH_KEYWORDS, EVPXOF_digest__doc__},
78
79static PyObject *
80EVPXOF_digest_impl(EVPobject *self, Py_ssize_t length);
81
82static PyObject *
83EVPXOF_digest(EVPobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
84{
85 PyObject *return_value = NULL;
86 static const char * const _keywords[] = {"length", NULL};
87 static _PyArg_Parser _parser = {NULL, _keywords, "digest", 0};
88 PyObject *argsbuf[1];
89 Py_ssize_t length;
90
91 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
92 if (!args) {
93 goto exit;
94 }
95 {
96 Py_ssize_t ival = -1;
97 PyObject *iobj = _PyNumber_Index(args[0]);
98 if (iobj != NULL) {
99 ival = PyLong_AsSsize_t(iobj);
100 Py_DECREF(iobj);
101 }
102 if (ival == -1 && PyErr_Occurred()) {
103 goto exit;
104 }
105 length = ival;
106 }
107 return_value = EVPXOF_digest_impl(self, length);
108
109exit:
110 return return_value;
111}
112
113#endif /* defined(PY_OPENSSL_HAS_SHAKE) */
114
115#if defined(PY_OPENSSL_HAS_SHAKE)
116
117PyDoc_STRVAR(EVPXOF_hexdigest__doc__,
118"hexdigest($self, /, length)\n"
119"--\n"
120"\n"
121"Return the digest value as a string of hexadecimal digits.");
122
123#define EVPXOF_HEXDIGEST_METHODDEF \
124 {"hexdigest", (PyCFunction)(void(*)(void))EVPXOF_hexdigest, METH_FASTCALL|METH_KEYWORDS, EVPXOF_hexdigest__doc__},
125
126static PyObject *
127EVPXOF_hexdigest_impl(EVPobject *self, Py_ssize_t length);
128
129static PyObject *
130EVPXOF_hexdigest(EVPobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
131{
132 PyObject *return_value = NULL;
133 static const char * const _keywords[] = {"length", NULL};
134 static _PyArg_Parser _parser = {NULL, _keywords, "hexdigest", 0};
135 PyObject *argsbuf[1];
136 Py_ssize_t length;
137
138 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
139 if (!args) {
140 goto exit;
141 }
142 {
143 Py_ssize_t ival = -1;
144 PyObject *iobj = _PyNumber_Index(args[0]);
145 if (iobj != NULL) {
146 ival = PyLong_AsSsize_t(iobj);
147 Py_DECREF(iobj);
148 }
149 if (ival == -1 && PyErr_Occurred()) {
150 goto exit;
151 }
152 length = ival;
153 }
154 return_value = EVPXOF_hexdigest_impl(self, length);
155
156exit:
157 return return_value;
158}
159
160#endif /* defined(PY_OPENSSL_HAS_SHAKE) */
161
162PyDoc_STRVAR(EVP_new__doc__,
163"new($module, /, name, string=b\'\', *, usedforsecurity=True)\n"
164"--\n"
165"\n"
166"Return a new hash object using the named algorithm.\n"
167"\n"
168"An optional string argument may be provided and will be\n"
169"automatically hashed.\n"
170"\n"
171"The MD5 and SHA1 algorithms are always supported.");
172
173#define EVP_NEW_METHODDEF \
174 {"new", (PyCFunction)(void(*)(void))EVP_new, METH_FASTCALL|METH_KEYWORDS, EVP_new__doc__},
175
176static PyObject *
177EVP_new_impl(PyObject *module, PyObject *name_obj, PyObject *data_obj,
178 int usedforsecurity);
179
180static PyObject *
181EVP_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
182{
183 PyObject *return_value = NULL;
184 static const char * const _keywords[] = {"name", "string", "usedforsecurity", NULL};
185 static _PyArg_Parser _parser = {NULL, _keywords, "new", 0};
186 PyObject *argsbuf[3];
187 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
188 PyObject *name_obj;
189 PyObject *data_obj = NULL;
190 int usedforsecurity = 1;
191
192 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
193 if (!args) {
194 goto exit;
195 }
196 name_obj = args[0];
197 if (!noptargs) {
198 goto skip_optional_pos;
199 }
200 if (args[1]) {
201 data_obj = args[1];
202 if (!--noptargs) {
203 goto skip_optional_pos;
204 }
205 }
206skip_optional_pos:
207 if (!noptargs) {
208 goto skip_optional_kwonly;
209 }
210 usedforsecurity = PyObject_IsTrue(args[2]);
211 if (usedforsecurity < 0) {
212 goto exit;
213 }
214skip_optional_kwonly:
215 return_value = EVP_new_impl(module, name_obj, data_obj, usedforsecurity);
216
217exit:
218 return return_value;
219}
220
221PyDoc_STRVAR(_hashlib_openssl_md5__doc__,
222"openssl_md5($module, /, string=b\'\', *, usedforsecurity=True)\n"
223"--\n"
224"\n"
225"Returns a md5 hash object; optionally initialized with a string");
226
227#define _HASHLIB_OPENSSL_MD5_METHODDEF \
228 {"openssl_md5", (PyCFunction)(void(*)(void))_hashlib_openssl_md5, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_md5__doc__},
229
230static PyObject *
231_hashlib_openssl_md5_impl(PyObject *module, PyObject *data_obj,
232 int usedforsecurity);
233
234static PyObject *
235_hashlib_openssl_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
236{
237 PyObject *return_value = NULL;
238 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
239 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_md5", 0};
240 PyObject *argsbuf[2];
241 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
242 PyObject *data_obj = NULL;
243 int usedforsecurity = 1;
244
245 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
246 if (!args) {
247 goto exit;
248 }
249 if (!noptargs) {
250 goto skip_optional_pos;
251 }
252 if (args[0]) {
253 data_obj = args[0];
254 if (!--noptargs) {
255 goto skip_optional_pos;
256 }
257 }
258skip_optional_pos:
259 if (!noptargs) {
260 goto skip_optional_kwonly;
261 }
262 usedforsecurity = PyObject_IsTrue(args[1]);
263 if (usedforsecurity < 0) {
264 goto exit;
265 }
266skip_optional_kwonly:
267 return_value = _hashlib_openssl_md5_impl(module, data_obj, usedforsecurity);
268
269exit:
270 return return_value;
271}
272
273PyDoc_STRVAR(_hashlib_openssl_sha1__doc__,
274"openssl_sha1($module, /, string=b\'\', *, usedforsecurity=True)\n"
275"--\n"
276"\n"
277"Returns a sha1 hash object; optionally initialized with a string");
278
279#define _HASHLIB_OPENSSL_SHA1_METHODDEF \
280 {"openssl_sha1", (PyCFunction)(void(*)(void))_hashlib_openssl_sha1, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha1__doc__},
281
282static PyObject *
283_hashlib_openssl_sha1_impl(PyObject *module, PyObject *data_obj,
284 int usedforsecurity);
285
286static PyObject *
287_hashlib_openssl_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
288{
289 PyObject *return_value = NULL;
290 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
291 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha1", 0};
292 PyObject *argsbuf[2];
293 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
294 PyObject *data_obj = NULL;
295 int usedforsecurity = 1;
296
297 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
298 if (!args) {
299 goto exit;
300 }
301 if (!noptargs) {
302 goto skip_optional_pos;
303 }
304 if (args[0]) {
305 data_obj = args[0];
306 if (!--noptargs) {
307 goto skip_optional_pos;
308 }
309 }
310skip_optional_pos:
311 if (!noptargs) {
312 goto skip_optional_kwonly;
313 }
314 usedforsecurity = PyObject_IsTrue(args[1]);
315 if (usedforsecurity < 0) {
316 goto exit;
317 }
318skip_optional_kwonly:
319 return_value = _hashlib_openssl_sha1_impl(module, data_obj, usedforsecurity);
320
321exit:
322 return return_value;
323}
324
325PyDoc_STRVAR(_hashlib_openssl_sha224__doc__,
326"openssl_sha224($module, /, string=b\'\', *, usedforsecurity=True)\n"
327"--\n"
328"\n"
329"Returns a sha224 hash object; optionally initialized with a string");
330
331#define _HASHLIB_OPENSSL_SHA224_METHODDEF \
332 {"openssl_sha224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha224__doc__},
333
334static PyObject *
335_hashlib_openssl_sha224_impl(PyObject *module, PyObject *data_obj,
336 int usedforsecurity);
337
338static PyObject *
339_hashlib_openssl_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
340{
341 PyObject *return_value = NULL;
342 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
343 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha224", 0};
344 PyObject *argsbuf[2];
345 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
346 PyObject *data_obj = NULL;
347 int usedforsecurity = 1;
348
349 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
350 if (!args) {
351 goto exit;
352 }
353 if (!noptargs) {
354 goto skip_optional_pos;
355 }
356 if (args[0]) {
357 data_obj = args[0];
358 if (!--noptargs) {
359 goto skip_optional_pos;
360 }
361 }
362skip_optional_pos:
363 if (!noptargs) {
364 goto skip_optional_kwonly;
365 }
366 usedforsecurity = PyObject_IsTrue(args[1]);
367 if (usedforsecurity < 0) {
368 goto exit;
369 }
370skip_optional_kwonly:
371 return_value = _hashlib_openssl_sha224_impl(module, data_obj, usedforsecurity);
372
373exit:
374 return return_value;
375}
376
377PyDoc_STRVAR(_hashlib_openssl_sha256__doc__,
378"openssl_sha256($module, /, string=b\'\', *, usedforsecurity=True)\n"
379"--\n"
380"\n"
381"Returns a sha256 hash object; optionally initialized with a string");
382
383#define _HASHLIB_OPENSSL_SHA256_METHODDEF \
384 {"openssl_sha256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha256__doc__},
385
386static PyObject *
387_hashlib_openssl_sha256_impl(PyObject *module, PyObject *data_obj,
388 int usedforsecurity);
389
390static PyObject *
391_hashlib_openssl_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
392{
393 PyObject *return_value = NULL;
394 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
395 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha256", 0};
396 PyObject *argsbuf[2];
397 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
398 PyObject *data_obj = NULL;
399 int usedforsecurity = 1;
400
401 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
402 if (!args) {
403 goto exit;
404 }
405 if (!noptargs) {
406 goto skip_optional_pos;
407 }
408 if (args[0]) {
409 data_obj = args[0];
410 if (!--noptargs) {
411 goto skip_optional_pos;
412 }
413 }
414skip_optional_pos:
415 if (!noptargs) {
416 goto skip_optional_kwonly;
417 }
418 usedforsecurity = PyObject_IsTrue(args[1]);
419 if (usedforsecurity < 0) {
420 goto exit;
421 }
422skip_optional_kwonly:
423 return_value = _hashlib_openssl_sha256_impl(module, data_obj, usedforsecurity);
424
425exit:
426 return return_value;
427}
428
429PyDoc_STRVAR(_hashlib_openssl_sha384__doc__,
430"openssl_sha384($module, /, string=b\'\', *, usedforsecurity=True)\n"
431"--\n"
432"\n"
433"Returns a sha384 hash object; optionally initialized with a string");
434
435#define _HASHLIB_OPENSSL_SHA384_METHODDEF \
436 {"openssl_sha384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha384__doc__},
437
438static PyObject *
439_hashlib_openssl_sha384_impl(PyObject *module, PyObject *data_obj,
440 int usedforsecurity);
441
442static PyObject *
443_hashlib_openssl_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
444{
445 PyObject *return_value = NULL;
446 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
447 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha384", 0};
448 PyObject *argsbuf[2];
449 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
450 PyObject *data_obj = NULL;
451 int usedforsecurity = 1;
452
453 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
454 if (!args) {
455 goto exit;
456 }
457 if (!noptargs) {
458 goto skip_optional_pos;
459 }
460 if (args[0]) {
461 data_obj = args[0];
462 if (!--noptargs) {
463 goto skip_optional_pos;
464 }
465 }
466skip_optional_pos:
467 if (!noptargs) {
468 goto skip_optional_kwonly;
469 }
470 usedforsecurity = PyObject_IsTrue(args[1]);
471 if (usedforsecurity < 0) {
472 goto exit;
473 }
474skip_optional_kwonly:
475 return_value = _hashlib_openssl_sha384_impl(module, data_obj, usedforsecurity);
476
477exit:
478 return return_value;
479}
480
481PyDoc_STRVAR(_hashlib_openssl_sha512__doc__,
482"openssl_sha512($module, /, string=b\'\', *, usedforsecurity=True)\n"
483"--\n"
484"\n"
485"Returns a sha512 hash object; optionally initialized with a string");
486
487#define _HASHLIB_OPENSSL_SHA512_METHODDEF \
488 {"openssl_sha512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha512__doc__},
489
490static PyObject *
491_hashlib_openssl_sha512_impl(PyObject *module, PyObject *data_obj,
492 int usedforsecurity);
493
494static PyObject *
495_hashlib_openssl_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
496{
497 PyObject *return_value = NULL;
498 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
499 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha512", 0};
500 PyObject *argsbuf[2];
501 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
502 PyObject *data_obj = NULL;
503 int usedforsecurity = 1;
504
505 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
506 if (!args) {
507 goto exit;
508 }
509 if (!noptargs) {
510 goto skip_optional_pos;
511 }
512 if (args[0]) {
513 data_obj = args[0];
514 if (!--noptargs) {
515 goto skip_optional_pos;
516 }
517 }
518skip_optional_pos:
519 if (!noptargs) {
520 goto skip_optional_kwonly;
521 }
522 usedforsecurity = PyObject_IsTrue(args[1]);
523 if (usedforsecurity < 0) {
524 goto exit;
525 }
526skip_optional_kwonly:
527 return_value = _hashlib_openssl_sha512_impl(module, data_obj, usedforsecurity);
528
529exit:
530 return return_value;
531}
532
533#if defined(PY_OPENSSL_HAS_SHA3)
534
535PyDoc_STRVAR(_hashlib_openssl_sha3_224__doc__,
536"openssl_sha3_224($module, /, string=b\'\', *, usedforsecurity=True)\n"
537"--\n"
538"\n"
539"Returns a sha3-224 hash object; optionally initialized with a string");
540
541#define _HASHLIB_OPENSSL_SHA3_224_METHODDEF \
542 {"openssl_sha3_224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_224__doc__},
543
544static PyObject *
545_hashlib_openssl_sha3_224_impl(PyObject *module, PyObject *data_obj,
546 int usedforsecurity);
547
548static PyObject *
549_hashlib_openssl_sha3_224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
550{
551 PyObject *return_value = NULL;
552 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
553 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_224", 0};
554 PyObject *argsbuf[2];
555 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
556 PyObject *data_obj = NULL;
557 int usedforsecurity = 1;
558
559 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
560 if (!args) {
561 goto exit;
562 }
563 if (!noptargs) {
564 goto skip_optional_pos;
565 }
566 if (args[0]) {
567 data_obj = args[0];
568 if (!--noptargs) {
569 goto skip_optional_pos;
570 }
571 }
572skip_optional_pos:
573 if (!noptargs) {
574 goto skip_optional_kwonly;
575 }
576 usedforsecurity = PyObject_IsTrue(args[1]);
577 if (usedforsecurity < 0) {
578 goto exit;
579 }
580skip_optional_kwonly:
581 return_value = _hashlib_openssl_sha3_224_impl(module, data_obj, usedforsecurity);
582
583exit:
584 return return_value;
585}
586
587#endif /* defined(PY_OPENSSL_HAS_SHA3) */
588
589#if defined(PY_OPENSSL_HAS_SHA3)
590
591PyDoc_STRVAR(_hashlib_openssl_sha3_256__doc__,
592"openssl_sha3_256($module, /, string=b\'\', *, usedforsecurity=True)\n"
593"--\n"
594"\n"
595"Returns a sha3-256 hash object; optionally initialized with a string");
596
597#define _HASHLIB_OPENSSL_SHA3_256_METHODDEF \
598 {"openssl_sha3_256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_256__doc__},
599
600static PyObject *
601_hashlib_openssl_sha3_256_impl(PyObject *module, PyObject *data_obj,
602 int usedforsecurity);
603
604static PyObject *
605_hashlib_openssl_sha3_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
606{
607 PyObject *return_value = NULL;
608 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
609 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_256", 0};
610 PyObject *argsbuf[2];
611 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
612 PyObject *data_obj = NULL;
613 int usedforsecurity = 1;
614
615 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
616 if (!args) {
617 goto exit;
618 }
619 if (!noptargs) {
620 goto skip_optional_pos;
621 }
622 if (args[0]) {
623 data_obj = args[0];
624 if (!--noptargs) {
625 goto skip_optional_pos;
626 }
627 }
628skip_optional_pos:
629 if (!noptargs) {
630 goto skip_optional_kwonly;
631 }
632 usedforsecurity = PyObject_IsTrue(args[1]);
633 if (usedforsecurity < 0) {
634 goto exit;
635 }
636skip_optional_kwonly:
637 return_value = _hashlib_openssl_sha3_256_impl(module, data_obj, usedforsecurity);
638
639exit:
640 return return_value;
641}
642
643#endif /* defined(PY_OPENSSL_HAS_SHA3) */
644
645#if defined(PY_OPENSSL_HAS_SHA3)
646
647PyDoc_STRVAR(_hashlib_openssl_sha3_384__doc__,
648"openssl_sha3_384($module, /, string=b\'\', *, usedforsecurity=True)\n"
649"--\n"
650"\n"
651"Returns a sha3-384 hash object; optionally initialized with a string");
652
653#define _HASHLIB_OPENSSL_SHA3_384_METHODDEF \
654 {"openssl_sha3_384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_384__doc__},
655
656static PyObject *
657_hashlib_openssl_sha3_384_impl(PyObject *module, PyObject *data_obj,
658 int usedforsecurity);
659
660static PyObject *
661_hashlib_openssl_sha3_384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
662{
663 PyObject *return_value = NULL;
664 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
665 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_384", 0};
666 PyObject *argsbuf[2];
667 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
668 PyObject *data_obj = NULL;
669 int usedforsecurity = 1;
670
671 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
672 if (!args) {
673 goto exit;
674 }
675 if (!noptargs) {
676 goto skip_optional_pos;
677 }
678 if (args[0]) {
679 data_obj = args[0];
680 if (!--noptargs) {
681 goto skip_optional_pos;
682 }
683 }
684skip_optional_pos:
685 if (!noptargs) {
686 goto skip_optional_kwonly;
687 }
688 usedforsecurity = PyObject_IsTrue(args[1]);
689 if (usedforsecurity < 0) {
690 goto exit;
691 }
692skip_optional_kwonly:
693 return_value = _hashlib_openssl_sha3_384_impl(module, data_obj, usedforsecurity);
694
695exit:
696 return return_value;
697}
698
699#endif /* defined(PY_OPENSSL_HAS_SHA3) */
700
701#if defined(PY_OPENSSL_HAS_SHA3)
702
703PyDoc_STRVAR(_hashlib_openssl_sha3_512__doc__,
704"openssl_sha3_512($module, /, string=b\'\', *, usedforsecurity=True)\n"
705"--\n"
706"\n"
707"Returns a sha3-512 hash object; optionally initialized with a string");
708
709#define _HASHLIB_OPENSSL_SHA3_512_METHODDEF \
710 {"openssl_sha3_512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha3_512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha3_512__doc__},
711
712static PyObject *
713_hashlib_openssl_sha3_512_impl(PyObject *module, PyObject *data_obj,
714 int usedforsecurity);
715
716static PyObject *
717_hashlib_openssl_sha3_512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
718{
719 PyObject *return_value = NULL;
720 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
721 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha3_512", 0};
722 PyObject *argsbuf[2];
723 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
724 PyObject *data_obj = NULL;
725 int usedforsecurity = 1;
726
727 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
728 if (!args) {
729 goto exit;
730 }
731 if (!noptargs) {
732 goto skip_optional_pos;
733 }
734 if (args[0]) {
735 data_obj = args[0];
736 if (!--noptargs) {
737 goto skip_optional_pos;
738 }
739 }
740skip_optional_pos:
741 if (!noptargs) {
742 goto skip_optional_kwonly;
743 }
744 usedforsecurity = PyObject_IsTrue(args[1]);
745 if (usedforsecurity < 0) {
746 goto exit;
747 }
748skip_optional_kwonly:
749 return_value = _hashlib_openssl_sha3_512_impl(module, data_obj, usedforsecurity);
750
751exit:
752 return return_value;
753}
754
755#endif /* defined(PY_OPENSSL_HAS_SHA3) */
756
757#if defined(PY_OPENSSL_HAS_SHAKE)
758
759PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__,
760"openssl_shake_128($module, /, string=b\'\', *, usedforsecurity=True)\n"
761"--\n"
762"\n"
763"Returns a shake-128 variable hash object; optionally initialized with a string");
764
765#define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF \
766 {"openssl_shake_128", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_128, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_128__doc__},
767
768static PyObject *
769_hashlib_openssl_shake_128_impl(PyObject *module, PyObject *data_obj,
770 int usedforsecurity);
771
772static PyObject *
773_hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
774{
775 PyObject *return_value = NULL;
776 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
777 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_128", 0};
778 PyObject *argsbuf[2];
779 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
780 PyObject *data_obj = NULL;
781 int usedforsecurity = 1;
782
783 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
784 if (!args) {
785 goto exit;
786 }
787 if (!noptargs) {
788 goto skip_optional_pos;
789 }
790 if (args[0]) {
791 data_obj = args[0];
792 if (!--noptargs) {
793 goto skip_optional_pos;
794 }
795 }
796skip_optional_pos:
797 if (!noptargs) {
798 goto skip_optional_kwonly;
799 }
800 usedforsecurity = PyObject_IsTrue(args[1]);
801 if (usedforsecurity < 0) {
802 goto exit;
803 }
804skip_optional_kwonly:
805 return_value = _hashlib_openssl_shake_128_impl(module, data_obj, usedforsecurity);
806
807exit:
808 return return_value;
809}
810
811#endif /* defined(PY_OPENSSL_HAS_SHAKE) */
812
813#if defined(PY_OPENSSL_HAS_SHAKE)
814
815PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__,
816"openssl_shake_256($module, /, string=b\'\', *, usedforsecurity=True)\n"
817"--\n"
818"\n"
819"Returns a shake-256 variable hash object; optionally initialized with a string");
820
821#define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF \
822 {"openssl_shake_256", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_256__doc__},
823
824static PyObject *
825_hashlib_openssl_shake_256_impl(PyObject *module, PyObject *data_obj,
826 int usedforsecurity);
827
828static PyObject *
829_hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
830{
831 PyObject *return_value = NULL;
832 static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
833 static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_256", 0};
834 PyObject *argsbuf[2];
835 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
836 PyObject *data_obj = NULL;
837 int usedforsecurity = 1;
838
839 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
840 if (!args) {
841 goto exit;
842 }
843 if (!noptargs) {
844 goto skip_optional_pos;
845 }
846 if (args[0]) {
847 data_obj = args[0];
848 if (!--noptargs) {
849 goto skip_optional_pos;
850 }
851 }
852skip_optional_pos:
853 if (!noptargs) {
854 goto skip_optional_kwonly;
855 }
856 usedforsecurity = PyObject_IsTrue(args[1]);
857 if (usedforsecurity < 0) {
858 goto exit;
859 }
860skip_optional_kwonly:
861 return_value = _hashlib_openssl_shake_256_impl(module, data_obj, usedforsecurity);
862
863exit:
864 return return_value;
865}
866
867#endif /* defined(PY_OPENSSL_HAS_SHAKE) */
868
869PyDoc_STRVAR(pbkdf2_hmac__doc__,
870"pbkdf2_hmac($module, /, hash_name, password, salt, iterations,\n"
871" dklen=None)\n"
872"--\n"
873"\n"
874"Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.");
875
876#define PBKDF2_HMAC_METHODDEF \
877 {"pbkdf2_hmac", (PyCFunction)(void(*)(void))pbkdf2_hmac, METH_FASTCALL|METH_KEYWORDS, pbkdf2_hmac__doc__},
878
879static PyObject *
880pbkdf2_hmac_impl(PyObject *module, const char *hash_name,
881 Py_buffer *password, Py_buffer *salt, long iterations,
882 PyObject *dklen_obj);
883
884static PyObject *
885pbkdf2_hmac(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
886{
887 PyObject *return_value = NULL;
888 static const char * const _keywords[] = {"hash_name", "password", "salt", "iterations", "dklen", NULL};
889 static _PyArg_Parser _parser = {NULL, _keywords, "pbkdf2_hmac", 0};
890 PyObject *argsbuf[5];
891 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 4;
892 const char *hash_name;
893 Py_buffer password = {NULL, NULL};
894 Py_buffer salt = {NULL, NULL};
895 long iterations;
896 PyObject *dklen_obj = Py_None;
897
898 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 4, 5, 0, argsbuf);
899 if (!args) {
900 goto exit;
901 }
902 if (!PyUnicode_Check(args[0])) {
903 _PyArg_BadArgument("pbkdf2_hmac", "argument 'hash_name'", "str", args[0]);
904 goto exit;
905 }
906 Py_ssize_t hash_name_length;
907 hash_name = PyUnicode_AsUTF8AndSize(args[0], &hash_name_length);
908 if (hash_name == NULL) {
909 goto exit;
910 }
911 if (strlen(hash_name) != (size_t)hash_name_length) {
912 PyErr_SetString(PyExc_ValueError, "embedded null character");
913 goto exit;
914 }
915 if (PyObject_GetBuffer(args[1], &password, PyBUF_SIMPLE) != 0) {
916 goto exit;
917 }
918 if (!PyBuffer_IsContiguous(&password, 'C')) {
919 _PyArg_BadArgument("pbkdf2_hmac", "argument 'password'", "contiguous buffer", args[1]);
920 goto exit;
921 }
922 if (PyObject_GetBuffer(args[2], &salt, PyBUF_SIMPLE) != 0) {
923 goto exit;
924 }
925 if (!PyBuffer_IsContiguous(&salt, 'C')) {
926 _PyArg_BadArgument("pbkdf2_hmac", "argument 'salt'", "contiguous buffer", args[2]);
927 goto exit;
928 }
929 iterations = PyLong_AsLong(args[3]);
930 if (iterations == -1 && PyErr_Occurred()) {
931 goto exit;
932 }
933 if (!noptargs) {
934 goto skip_optional_pos;
935 }
936 dklen_obj = args[4];
937skip_optional_pos:
938 return_value = pbkdf2_hmac_impl(module, hash_name, &password, &salt, iterations, dklen_obj);
939
940exit:
941 /* Cleanup for password */
942 if (password.obj) {
943 PyBuffer_Release(&password);
944 }
945 /* Cleanup for salt */
946 if (salt.obj) {
947 PyBuffer_Release(&salt);
948 }
949
950 return return_value;
951}
952
953#if defined(PY_OPENSSL_HAS_SCRYPT)
954
955PyDoc_STRVAR(_hashlib_scrypt__doc__,
956"scrypt($module, /, password, *, salt=None, n=None, r=None, p=None,\n"
957" maxmem=0, dklen=64)\n"
958"--\n"
959"\n"
960"scrypt password-based key derivation function.");
961
962#define _HASHLIB_SCRYPT_METHODDEF \
963 {"scrypt", (PyCFunction)(void(*)(void))_hashlib_scrypt, METH_FASTCALL|METH_KEYWORDS, _hashlib_scrypt__doc__},
964
965static PyObject *
966_hashlib_scrypt_impl(PyObject *module, Py_buffer *password, Py_buffer *salt,
967 PyObject *n_obj, PyObject *r_obj, PyObject *p_obj,
968 long maxmem, long dklen);
969
970static PyObject *
971_hashlib_scrypt(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
972{
973 PyObject *return_value = NULL;
974 static const char * const _keywords[] = {"password", "salt", "n", "r", "p", "maxmem", "dklen", NULL};
975 static _PyArg_Parser _parser = {NULL, _keywords, "scrypt", 0};
976 PyObject *argsbuf[7];
977 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
978 Py_buffer password = {NULL, NULL};
979 Py_buffer salt = {NULL, NULL};
980 PyObject *n_obj = Py_None;
981 PyObject *r_obj = Py_None;
982 PyObject *p_obj = Py_None;
983 long maxmem = 0;
984 long dklen = 64;
985
986 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
987 if (!args) {
988 goto exit;
989 }
990 if (PyObject_GetBuffer(args[0], &password, PyBUF_SIMPLE) != 0) {
991 goto exit;
992 }
993 if (!PyBuffer_IsContiguous(&password, 'C')) {
994 _PyArg_BadArgument("scrypt", "argument 'password'", "contiguous buffer", args[0]);
995 goto exit;
996 }
997 if (!noptargs) {
998 goto skip_optional_kwonly;
999 }
1000 if (args[1]) {
1001 if (PyObject_GetBuffer(args[1], &salt, PyBUF_SIMPLE) != 0) {
1002 goto exit;
1003 }
1004 if (!PyBuffer_IsContiguous(&salt, 'C')) {
1005 _PyArg_BadArgument("scrypt", "argument 'salt'", "contiguous buffer", args[1]);
1006 goto exit;
1007 }
1008 if (!--noptargs) {
1009 goto skip_optional_kwonly;
1010 }
1011 }
1012 if (args[2]) {
1013 if (!PyLong_Check(args[2])) {
1014 _PyArg_BadArgument("scrypt", "argument 'n'", "int", args[2]);
1015 goto exit;
1016 }
1017 n_obj = args[2];
1018 if (!--noptargs) {
1019 goto skip_optional_kwonly;
1020 }
1021 }
1022 if (args[3]) {
1023 if (!PyLong_Check(args[3])) {
1024 _PyArg_BadArgument("scrypt", "argument 'r'", "int", args[3]);
1025 goto exit;
1026 }
1027 r_obj = args[3];
1028 if (!--noptargs) {
1029 goto skip_optional_kwonly;
1030 }
1031 }
1032 if (args[4]) {
1033 if (!PyLong_Check(args[4])) {
1034 _PyArg_BadArgument("scrypt", "argument 'p'", "int", args[4]);
1035 goto exit;
1036 }
1037 p_obj = args[4];
1038 if (!--noptargs) {
1039 goto skip_optional_kwonly;
1040 }
1041 }
1042 if (args[5]) {
1043 maxmem = PyLong_AsLong(args[5]);
1044 if (maxmem == -1 && PyErr_Occurred()) {
1045 goto exit;
1046 }
1047 if (!--noptargs) {
1048 goto skip_optional_kwonly;
1049 }
1050 }
1051 dklen = PyLong_AsLong(args[6]);
1052 if (dklen == -1 && PyErr_Occurred()) {
1053 goto exit;
1054 }
1055skip_optional_kwonly:
1056 return_value = _hashlib_scrypt_impl(module, &password, &salt, n_obj, r_obj, p_obj, maxmem, dklen);
1057
1058exit:
1059 /* Cleanup for password */
1060 if (password.obj) {
1061 PyBuffer_Release(&password);
1062 }
1063 /* Cleanup for salt */
1064 if (salt.obj) {
1065 PyBuffer_Release(&salt);
1066 }
1067
1068 return return_value;
1069}
1070
1071#endif /* defined(PY_OPENSSL_HAS_SCRYPT) */
1072
1073PyDoc_STRVAR(_hashlib_hmac_singleshot__doc__,
1074"hmac_digest($module, /, key, msg, digest)\n"
1075"--\n"
1076"\n"
1077"Single-shot HMAC.");
1078
1079#define _HASHLIB_HMAC_SINGLESHOT_METHODDEF \
1080 {"hmac_digest", (PyCFunction)(void(*)(void))_hashlib_hmac_singleshot, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_singleshot__doc__},
1081
1082static PyObject *
1083_hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
1084 Py_buffer *msg, PyObject *digest);
1085
1086static PyObject *
1087_hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1088{
1089 PyObject *return_value = NULL;
1090 static const char * const _keywords[] = {"key", "msg", "digest", NULL};
1091 static _PyArg_Parser _parser = {NULL, _keywords, "hmac_digest", 0};
1092 PyObject *argsbuf[3];
1093 Py_buffer key = {NULL, NULL};
1094 Py_buffer msg = {NULL, NULL};
1095 PyObject *digest;
1096
1097 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
1098 if (!args) {
1099 goto exit;
1100 }
1101 if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
1102 goto exit;
1103 }
1104 if (!PyBuffer_IsContiguous(&key, 'C')) {
1105 _PyArg_BadArgument("hmac_digest", "argument 'key'", "contiguous buffer", args[0]);
1106 goto exit;
1107 }
1108 if (PyObject_GetBuffer(args[1], &msg, PyBUF_SIMPLE) != 0) {
1109 goto exit;
1110 }
1111 if (!PyBuffer_IsContiguous(&msg, 'C')) {
1112 _PyArg_BadArgument("hmac_digest", "argument 'msg'", "contiguous buffer", args[1]);
1113 goto exit;
1114 }
1115 digest = args[2];
1116 return_value = _hashlib_hmac_singleshot_impl(module, &key, &msg, digest);
1117
1118exit:
1119 /* Cleanup for key */
1120 if (key.obj) {
1121 PyBuffer_Release(&key);
1122 }
1123 /* Cleanup for msg */
1124 if (msg.obj) {
1125 PyBuffer_Release(&msg);
1126 }
1127
1128 return return_value;
1129}
1130
1131PyDoc_STRVAR(_hashlib_hmac_new__doc__,
1132"hmac_new($module, /, key, msg=b\'\', digestmod=None)\n"
1133"--\n"
1134"\n"
1135"Return a new hmac object.");
1136
1137#define _HASHLIB_HMAC_NEW_METHODDEF \
1138 {"hmac_new", (PyCFunction)(void(*)(void))_hashlib_hmac_new, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_new__doc__},
1139
1140static PyObject *
1141_hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, PyObject *msg_obj,
1142 PyObject *digestmod);
1143
1144static PyObject *
1145_hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1146{
1147 PyObject *return_value = NULL;
1148 static const char * const _keywords[] = {"key", "msg", "digestmod", NULL};
1149 static _PyArg_Parser _parser = {NULL, _keywords, "hmac_new", 0};
1150 PyObject *argsbuf[3];
1151 Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
1152 Py_buffer key = {NULL, NULL};
1153 PyObject *msg_obj = NULL;
1154 PyObject *digestmod = NULL;
1155
1156 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
1157 if (!args) {
1158 goto exit;
1159 }
1160 if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
1161 goto exit;
1162 }
1163 if (!PyBuffer_IsContiguous(&key, 'C')) {
1164 _PyArg_BadArgument("hmac_new", "argument 'key'", "contiguous buffer", args[0]);
1165 goto exit;
1166 }
1167 if (!noptargs) {
1168 goto skip_optional_pos;
1169 }
1170 if (args[1]) {
1171 msg_obj = args[1];
1172 if (!--noptargs) {
1173 goto skip_optional_pos;
1174 }
1175 }
1176 digestmod = args[2];
1177skip_optional_pos:
1178 return_value = _hashlib_hmac_new_impl(module, &key, msg_obj, digestmod);
1179
1180exit:
1181 /* Cleanup for key */
1182 if (key.obj) {
1183 PyBuffer_Release(&key);
1184 }
1185
1186 return return_value;
1187}
1188
1189PyDoc_STRVAR(_hashlib_HMAC_copy__doc__,
1190"copy($self, /)\n"
1191"--\n"
1192"\n"
1193"Return a copy (\"clone\") of the HMAC object.");
1194
1195#define _HASHLIB_HMAC_COPY_METHODDEF \
1196 {"copy", (PyCFunction)_hashlib_HMAC_copy, METH_NOARGS, _hashlib_HMAC_copy__doc__},
1197
1198static PyObject *
1199_hashlib_HMAC_copy_impl(HMACobject *self);
1200
1201static PyObject *
1202_hashlib_HMAC_copy(HMACobject *self, PyObject *Py_UNUSED(ignored))
1203{
1204 return _hashlib_HMAC_copy_impl(self);
1205}
1206
1207PyDoc_STRVAR(_hashlib_HMAC_update__doc__,
1208"update($self, /, msg)\n"
1209"--\n"
1210"\n"
1211"Update the HMAC object with msg.");
1212
1213#define _HASHLIB_HMAC_UPDATE_METHODDEF \
1214 {"update", (PyCFunction)(void(*)(void))_hashlib_HMAC_update, METH_FASTCALL|METH_KEYWORDS, _hashlib_HMAC_update__doc__},
1215
1216static PyObject *
1217_hashlib_HMAC_update_impl(HMACobject *self, PyObject *msg);
1218
1219static PyObject *
1220_hashlib_HMAC_update(HMACobject *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
1221{
1222 PyObject *return_value = NULL;
1223 static const char * const _keywords[] = {"msg", NULL};
1224 static _PyArg_Parser _parser = {NULL, _keywords, "update", 0};
1225 PyObject *argsbuf[1];
1226 PyObject *msg;
1227
1228 args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
1229 if (!args) {
1230 goto exit;
1231 }
1232 msg = args[0];
1233 return_value = _hashlib_HMAC_update_impl(self, msg);
1234
1235exit:
1236 return return_value;
1237}
1238
1239PyDoc_STRVAR(_hashlib_HMAC_digest__doc__,
1240"digest($self, /)\n"
1241"--\n"
1242"\n"
1243"Return the digest of the bytes passed to the update() method so far.");
1244
1245#define _HASHLIB_HMAC_DIGEST_METHODDEF \
1246 {"digest", (PyCFunction)_hashlib_HMAC_digest, METH_NOARGS, _hashlib_HMAC_digest__doc__},
1247
1248static PyObject *
1249_hashlib_HMAC_digest_impl(HMACobject *self);
1250
1251static PyObject *
1252_hashlib_HMAC_digest(HMACobject *self, PyObject *Py_UNUSED(ignored))
1253{
1254 return _hashlib_HMAC_digest_impl(self);
1255}
1256
1257PyDoc_STRVAR(_hashlib_HMAC_hexdigest__doc__,
1258"hexdigest($self, /)\n"
1259"--\n"
1260"\n"
1261"Return hexadecimal digest of the bytes passed to the update() method so far.\n"
1262"\n"
1263"This may be used to exchange the value safely in email or other non-binary\n"
1264"environments.");
1265
1266#define _HASHLIB_HMAC_HEXDIGEST_METHODDEF \
1267 {"hexdigest", (PyCFunction)_hashlib_HMAC_hexdigest, METH_NOARGS, _hashlib_HMAC_hexdigest__doc__},
1268
1269static PyObject *
1270_hashlib_HMAC_hexdigest_impl(HMACobject *self);
1271
1272static PyObject *
1273_hashlib_HMAC_hexdigest(HMACobject *self, PyObject *Py_UNUSED(ignored))
1274{
1275 return _hashlib_HMAC_hexdigest_impl(self);
1276}
1277
1278PyDoc_STRVAR(_hashlib_get_fips_mode__doc__,
1279"get_fips_mode($module, /)\n"
1280"--\n"
1281"\n"
1282"Determine the OpenSSL FIPS mode of operation.\n"
1283"\n"
1284"For OpenSSL 3.0.0 and newer it returns the state of the default provider\n"
1285"in the default OSSL context. It\'s not quite the same as FIPS_mode() but good\n"
1286"enough for unittests.\n"
1287"\n"
1288"Effectively any non-zero return value indicates FIPS mode;\n"
1289"values other than 1 may have additional significance.");
1290
1291#define _HASHLIB_GET_FIPS_MODE_METHODDEF \
1292 {"get_fips_mode", (PyCFunction)_hashlib_get_fips_mode, METH_NOARGS, _hashlib_get_fips_mode__doc__},
1293
1294static int
1295_hashlib_get_fips_mode_impl(PyObject *module);
1296
1297static PyObject *
1298_hashlib_get_fips_mode(PyObject *module, PyObject *Py_UNUSED(ignored))
1299{
1300 PyObject *return_value = NULL;
1301 int _return_value;
1302
1303 _return_value = _hashlib_get_fips_mode_impl(module);
1304 if ((_return_value == -1) && PyErr_Occurred()) {
1305 goto exit;
1306 }
1307 return_value = PyLong_FromLong((long)_return_value);
1308
1309exit:
1310 return return_value;
1311}
1312
1313PyDoc_STRVAR(_hashlib_compare_digest__doc__,
1314"compare_digest($module, a, b, /)\n"
1315"--\n"
1316"\n"
1317"Return \'a == b\'.\n"
1318"\n"
1319"This function uses an approach designed to prevent\n"
1320"timing analysis, making it appropriate for cryptography.\n"
1321"\n"
1322"a and b must both be of the same type: either str (ASCII only),\n"
1323"or any bytes-like object.\n"
1324"\n"
1325"Note: If a and b are of different lengths, or if an error occurs,\n"
1326"a timing attack could theoretically reveal information about the\n"
1327"types and lengths of a and b--but not their values.");
1328
1329#define _HASHLIB_COMPARE_DIGEST_METHODDEF \
1330 {"compare_digest", (PyCFunction)(void(*)(void))_hashlib_compare_digest, METH_FASTCALL, _hashlib_compare_digest__doc__},
1331
1332static PyObject *
1333_hashlib_compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
1334
1335static PyObject *
1336_hashlib_compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
1337{
1338 PyObject *return_value = NULL;
1339 PyObject *a;
1340 PyObject *b;
1341
1342 if (!_PyArg_CheckPositional("compare_digest", nargs, 2, 2)) {
1343 goto exit;
1344 }
1345 a = args[0];
1346 b = args[1];
1347 return_value = _hashlib_compare_digest_impl(module, a, b);
1348
1349exit:
1350 return return_value;
1351}
1352
1353#ifndef EVPXOF_DIGEST_METHODDEF
1354 #define EVPXOF_DIGEST_METHODDEF
1355#endif /* !defined(EVPXOF_DIGEST_METHODDEF) */
1356
1357#ifndef EVPXOF_HEXDIGEST_METHODDEF
1358 #define EVPXOF_HEXDIGEST_METHODDEF
1359#endif /* !defined(EVPXOF_HEXDIGEST_METHODDEF) */
1360
1361#ifndef _HASHLIB_OPENSSL_SHA3_224_METHODDEF
1362 #define _HASHLIB_OPENSSL_SHA3_224_METHODDEF
1363#endif /* !defined(_HASHLIB_OPENSSL_SHA3_224_METHODDEF) */
1364
1365#ifndef _HASHLIB_OPENSSL_SHA3_256_METHODDEF
1366 #define _HASHLIB_OPENSSL_SHA3_256_METHODDEF
1367#endif /* !defined(_HASHLIB_OPENSSL_SHA3_256_METHODDEF) */
1368
1369#ifndef _HASHLIB_OPENSSL_SHA3_384_METHODDEF
1370 #define _HASHLIB_OPENSSL_SHA3_384_METHODDEF
1371#endif /* !defined(_HASHLIB_OPENSSL_SHA3_384_METHODDEF) */
1372
1373#ifndef _HASHLIB_OPENSSL_SHA3_512_METHODDEF
1374 #define _HASHLIB_OPENSSL_SHA3_512_METHODDEF
1375#endif /* !defined(_HASHLIB_OPENSSL_SHA3_512_METHODDEF) */
1376
1377#ifndef _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
1378 #define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
1379#endif /* !defined(_HASHLIB_OPENSSL_SHAKE_128_METHODDEF) */
1380
1381#ifndef _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
1382 #define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
1383#endif /* !defined(_HASHLIB_OPENSSL_SHAKE_256_METHODDEF) */
1384
1385#ifndef _HASHLIB_SCRYPT_METHODDEF
1386 #define _HASHLIB_SCRYPT_METHODDEF
1387#endif /* !defined(_HASHLIB_SCRYPT_METHODDEF) */
1388/*[clinic end generated code: output=162369cb9d43f1cc input=a9049054013a1b77]*/
1389