logo

oasis

Own branch of Oasis Linux (upstream: <https://git.sr.ht/~mcf/oasis/>) git clone https://anongit.hacktivis.me/git/oasis.git

0001-Add-BearSSL-implementation-of-_hashlib.patch (65569B)

    

  1. From 61ad7f5ec78d4c80a99ac71820d9bc8b62c3fbae Mon Sep 17 00:00:00 2001
  2. From: Michael Forney <mforney@mforney.org>
  3. Date: Sat, 15 May 2021 22:48:13 -0700
  4. Subject: [PATCH] Add BearSSL implementation of _hashlib
  6. ---
  7.  Modules/_hashbearssl.c          | 1126 +++++++++++++++++++++++++++++++
  8.  Modules/clinic/_hashbearssl.c.h | 1113 ++++++++++++++++++++++++++++++
  9.  2 files changed, 2239 insertions(+)
  10.  create mode 100644 Modules/_hashbearssl.c
  11.  create mode 100644 Modules/clinic/_hashbearssl.c.h
  13. diff --git a/Modules/_hashbearssl.c b/Modules/_hashbearssl.c
  14. new file mode 100644
  15. index 0000000000..2d1a76296d
  16. --- /dev/null
  17. +++ b/Modules/_hashbearssl.c
  18. @@ -0,0 +1,1126 @@
  19. +/* Module that wraps all BearSSL hash algorithms */
  20. +#define PY_SSIZE_T_CLEAN
  21. +#include "Python.h"
  22. +#include "hashlib.h"
  23. +#include "pystrhex.h"
  24. +
  25. +#include <bearssl.h>
  26. +
  27. +static PyModuleDef _hashlibmodule;
  28. +static PyTypeObject Hash_Type;
  29. +static PyTypeObject SHAKE_Type;
  30. +static PyTypeObject HMAC_Type;
  31. +
  32. +typedef struct {
  33. +    PyObject_HEAD
  34. +    br_hash_compat_context ctx;
  35. +    PyThread_type_lock lock;
  36. +} Hash;
  37. +
  38. +typedef struct {
  39. +    PyObject_HEAD
  40. +    br_hmac_context ctx;
  41. +    br_hmac_key_context key;
  42. +    PyThread_type_lock lock;
  43. +} HMAC;
  44. +
  45. +typedef struct {
  46. +    PyObject_HEAD
  47. +    br_shake_context ctx;
  48. +    int bits;
  49. +    PyThread_type_lock lock;
  50. +} SHAKE;
  51. +
  52. +#include "clinic/_hashbearssl.c.h"
  53. +/*[clinic input]
  54. +module _hashlib
  55. +class _hashlib.Hash "Hash *" "Hash_Type"
  56. +class _hashlib.HMAC "HMAC *" "HMAC_Type"
  57. +class _hashlib.SHAKE "SHAKE *" "SHAKE_Type"
  58. +[clinic start generated code]*/
  59. +/*[clinic end generated code: output=da39a3ee5e6b4b0d input=7a269412ec77c79a]*/
  60. +
  61. +static const br_hash_class *
  62. +py_hash_by_name(const char *name)
  63. +{
  64. +    if (strcmp(name, "md5") == 0)
  65. +        return &br_md5_vtable;
  66. +    else if (strcmp(name, "sha1") == 0)
  67. +        return &br_sha1_vtable;
  68. +    else if (strcmp(name, "sha224") == 0)
  69. +        return &br_sha224_vtable;
  70. +    else if (strcmp(name, "sha256") == 0)
  71. +        return &br_sha256_vtable;
  72. +    else if (strcmp(name, "sha384") == 0)
  73. +        return &br_sha384_vtable;
  74. +    else if (strcmp(name, "sha512") == 0)
  75. +        return &br_sha512_vtable;
  76. +    return NULL;
  77. +}
  78. +
  79. +PyDoc_STRVAR(Hash_doc,
  80. +"Hash(name, string=b\'\')\n"
  81. +"--\n"
  82. +"\n"
  83. +"A hash is an object used to calculate a checksum of a string of information.\n"
  84. +"\n"
  85. +"Methods:\n"
  86. +"\n"
  87. +"update() -- updates the current digest with an additional string\n"
  88. +"digest() -- return the current digest value\n"
  89. +"hexdigest() -- return the current digest as a string of hexadecimal digits\n"
  90. +"copy() -- return a copy of the current hash object\n"
  91. +"\n"
  92. +"Attributes:\n"
  93. +"\n"
  94. +"name -- the hash algorithm being used by this object\n"
  95. +"digest_size -- number of bytes in this hashes output");
  96. +
  97. +static void
  98. +Hash_dealloc(Hash *self)
  99. +{
  100. +    if (self->lock)
  101. +        PyThread_free_lock(self->lock);
  102. +    PyObject_Free(self);
  103. +}
  104. +
  105. +/*[clinic input]
  106. +_hashlib.Hash.update as Hash_update
  107. +
  108. +    data: Py_buffer
  109. +    /
  110. +
  111. +Update this hash object's state with the provided string.
  112. +[clinic start generated code]*/
  113. +
  114. +static PyObject *
  115. +Hash_update_impl(Hash *self, Py_buffer *data)
  116. +/*[clinic end generated code: output=eed11f7503e289a3 input=0547d16ba3981abf]*/
  117. +{
  118. +    if (!self->lock && data->len >= HASHLIB_GIL_MINSIZE)
  119. +        self->lock = PyThread_allocate_lock();
  120. +    if (self->lock) {
  121. +        Py_BEGIN_ALLOW_THREADS
  122. +        PyThread_acquire_lock(self->lock, 1);
  123. +        self->ctx.vtable->update(&self->ctx.vtable, data->buf, data->len);
  124. +        PyThread_release_lock(self->lock);
  125. +        Py_END_ALLOW_THREADS
  126. +    } else {
  127. +        self->ctx.vtable->update(&self->ctx.vtable, data->buf, data->len);
  128. +    }
  129. +    Py_RETURN_NONE;
  130. +}
  131. +
  132. +/*[clinic input]
  133. +_hashlib.Hash.digest as Hash_digest
  134. +
  135. +Return the digest value as a bytes object.
  136. +[clinic start generated code]*/
  137. +
  138. +static PyObject *
  139. +Hash_digest_impl(Hash *self)
  140. +/*[clinic end generated code: output=b3eafdc9f37cf341 input=6d4afcd832edc55a]*/
  141. +{
  142. +    char digest[64];
  143. +    Py_ssize_t digest_size;
  144. +
  145. +    ENTER_HASHLIB(self)
  146. +    self->ctx.vtable->out(&self->ctx.vtable, digest);
  147. +    LEAVE_HASHLIB(self)
  148. +    digest_size = (self->ctx.vtable->desc >> BR_HASHDESC_OUT_OFF) & BR_HASHDESC_OUT_MASK;
  149. +
  150. +    return PyBytes_FromStringAndSize(digest, digest_size);
  151. +}
  152. +
  153. +/*[clinic input]
  154. +_hashlib.Hash.hexdigest as Hash_hexdigest
  155. +
  156. +Return the digest value as a string of hexadecimal digits.
  157. +[clinic start generated code]*/
  158. +
  159. +static PyObject *
  160. +Hash_hexdigest_impl(Hash *self)
  161. +/*[clinic end generated code: output=eff810494302910a input=6b224236fad6ff65]*/
  162. +{
  163. +    char digest[64];
  164. +    Py_ssize_t digest_size;
  165. +
  166. +    ENTER_HASHLIB(self)
  167. +    self->ctx.vtable->out(&self->ctx.vtable, digest);
  168. +    LEAVE_HASHLIB(self)
  169. +    digest_size = (self->ctx.vtable->desc >> BR_HASHDESC_OUT_OFF) & BR_HASHDESC_OUT_MASK;
  170. +
  171. +    return _Py_strhex(digest, digest_size);
  172. +}
  173. +
  174. +/*[clinic input]
  175. +_hashlib.Hash.copy as Hash_copy
  176. +
  177. +Return a copy of the hash object.
  178. +[clinic start generated code]*/
  179. +
  180. +static PyObject *
  181. +Hash_copy_impl(Hash *self)
  182. +/*[clinic end generated code: output=e97863340f55061b input=b830c9d949d08256]*/
  183. +{
  184. +    Hash *newobj;
  185. +
  186. +    newobj = PyObject_New(Hash, &Hash_Type);
  187. +    if (!newobj)
  188. +        return NULL;
  189. +    newobj->lock = NULL;
  190. +    ENTER_HASHLIB(self)
  191. +    newobj->ctx = self->ctx;
  192. +    LEAVE_HASHLIB(self)
  193. +
  194. +    return (PyObject *)newobj;
  195. +}
  196. +
  197. +static PyMethodDef Hash_methods[] = {
  198. +    HASH_UPDATE_METHODDEF
  199. +    HASH_DIGEST_METHODDEF
  200. +    HASH_HEXDIGEST_METHODDEF
  201. +    HASH_COPY_METHODDEF
  202. +    {0}
  203. +};
  204. +
  205. +static PyObject *
  206. +Hash_get_digest_size(Hash *self, void *closure)
  207. +{
  208. +    long digest_size;
  209. +
  210. +    digest_size = self->ctx.vtable->desc >> BR_HASHDESC_OUT_OFF & BR_HASHDESC_OUT_MASK;
  211. +    return PyLong_FromLong(digest_size);
  212. +}
  213. +
  214. +static PyObject *
  215. +Hash_get_block_size(Hash *self, void *closure)
  216. +{
  217. +    long block_size;
  218. +
  219. +    block_size = 1 << (self->ctx.vtable->desc >> BR_HASHDESC_LBLEN_OFF & BR_HASHDESC_LBLEN_MASK);
  220. +    return PyLong_FromLong(block_size);
  221. +}
  222. +
  223. +static PyObject *
  224. +Hash_get_name(Hash *self, void *closure)
  225. +{
  226. +    const char *name = NULL;
  227. +
  228. +    switch (self->ctx.vtable->desc >> BR_HASHDESC_ID_OFF & BR_HASHDESC_ID_MASK) {
  229. +    case br_md5_ID:    name = "md5";    break;
  230. +    case br_sha1_ID:   name = "sha1";   break;
  231. +    case br_sha224_ID: name = "sha224"; break;
  232. +    case br_sha256_ID: name = "sha256"; break;
  233. +    case br_sha384_ID: name = "sha384"; break;
  234. +    case br_sha512_ID: name = "sha512"; break;
  235. +    }
  236. +
  237. +    return PyUnicode_FromString(name);
  238. +}
  239. +
  240. +static PyGetSetDef Hash_getset[] = {
  241. +    {"digest_size", (getter)Hash_get_digest_size, NULL, NULL, NULL},
  242. +    {"block_size", (getter)Hash_get_block_size, NULL, NULL, NULL},
  243. +    {"name", (getter)Hash_get_name, NULL, NULL, NULL},
  244. +    {0}
  245. +};
  246. +
  247. +static PyTypeObject Hash_Type = {
  248. +    PyVarObject_HEAD_INIT(NULL, 0)
  249. +    .tp_name = "_hashlib.Hash",
  250. +    .tp_dealloc = (destructor)Hash_dealloc,
  251. +    .tp_doc = Hash_doc,
  252. +    .tp_basicsize = sizeof(Hash),
  253. +    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
  254. +    .tp_methods = Hash_methods,
  255. +    .tp_getset = Hash_getset,
  256. +};
  257. +
  258. +PyDoc_STRVAR(SHAKE_doc,
  259. +"SHAKE(name, string=b\'\')\n"
  260. +"--\n"
  261. +"\n"
  262. +"A hash is an object used to calculate a checksum of a string of information.\n"
  263. +"\n"
  264. +"Methods:\n"
  265. +"\n"
  266. +"update() -- updates the current digest with an additional string\n"
  267. +"digest(length) -- return the current digest value\n"
  268. +"hexdigest(length) -- return the current digest as a string of hexadecimal digits\n"
  269. +"copy() -- return a copy of the current hash object\n"
  270. +"\n"
  271. +"Attributes:\n"
  272. +"\n"
  273. +"name -- the hash algorithm being used by this object\n"
  274. +"digest_size -- number of bytes in this hashes output");
  275. +
  276. +static void
  277. +SHAKE_dealloc(SHAKE *self)
  278. +{
  279. +    if (self->lock)
  280. +        PyThread_free_lock(self->lock);
  281. +    PyObject_Free(self);
  282. +}
  283. +
  284. +/*[clinic input]
  285. +_hashlib.SHAKE.update as SHAKE_update
  286. +
  287. +    data: Py_buffer
  288. +    /
  289. +
  290. +Update this hash object's state with the provided string.
  291. +[clinic start generated code]*/
  292. +
  293. +static PyObject *
  294. +SHAKE_update_impl(SHAKE *self, Py_buffer *data)
  295. +/*[clinic end generated code: output=b7f5cd67459e2fb3 input=87a80642380b615f]*/
  296. +{
  297. +    if (!self->lock && data->len >= HASHLIB_GIL_MINSIZE)
  298. +        self->lock = PyThread_allocate_lock();
  299. +    if (self->lock) {
  300. +        Py_BEGIN_ALLOW_THREADS
  301. +        PyThread_acquire_lock(self->lock, 1);
  302. +        br_shake_inject(&self->ctx, data->buf, data->len);
  303. +        PyThread_release_lock(self->lock);
  304. +        Py_END_ALLOW_THREADS
  305. +    } else {
  306. +        br_shake_inject(&self->ctx, data->buf, data->len);
  307. +    }
  308. +    Py_RETURN_NONE;
  309. +}
  310. +
  311. +/*[clinic input]
  312. +_hashlib.SHAKE.digest as SHAKE_digest
  313. +
  314. +  length: Py_ssize_t
  315. +
  316. +Return the digest value as a bytes object.
  317. +[clinic start generated code]*/
  318. +
  319. +static PyObject *
  320. +SHAKE_digest_impl(SHAKE *self, Py_ssize_t length)
  321. +/*[clinic end generated code: output=4235ee593cba0b23 input=9e31587954f5e87a]*/
  322. +{
  323. +    br_shake_context ctx;
  324. +    PyObject *bytes;
  325. +
  326. +    bytes = PyBytes_FromStringAndSize(NULL, length);
  327. +    if (!bytes)
  328. +        return NULL;
  329. +
  330. +    ENTER_HASHLIB(self)
  331. +    ctx = self->ctx;
  332. +    LEAVE_HASHLIB(self)
  333. +    br_shake_flip(&ctx);
  334. +    br_shake_produce(&ctx, PyBytes_AS_STRING(bytes), length);
  335. +
  336. +    return bytes;
  337. +}
  338. +
  339. +/*[clinic input]
  340. +_hashlib.SHAKE.hexdigest as SHAKE_hexdigest
  341. +
  342. +    length: Py_ssize_t
  343. +
  344. +Return the digest value as a string of hexadecimal digits.
  345. +[clinic start generated code]*/
  346. +
  347. +static PyObject *
  348. +SHAKE_hexdigest_impl(SHAKE *self, Py_ssize_t length)
  349. +/*[clinic end generated code: output=fd9a7905a89a1509 input=2c43a9638ca1db5e]*/
  350. +{
  351. +    br_shake_context ctx;
  352. +    char *bytes;
  353. +    PyObject *str;
  354. +
  355. +    bytes = PyMem_Malloc(length);
  356. +    if (!bytes) {
  357. +        PyErr_NoMemory();
  358. +        return NULL;
  359. +    }
  360. +
  361. +    ENTER_HASHLIB(self)
  362. +    ctx = self->ctx;
  363. +    LEAVE_HASHLIB(self)
  364. +    br_shake_flip(&ctx);
  365. +    br_shake_produce(&ctx, bytes, length);
  366. +
  367. +    str = _Py_strhex(bytes, length);
  368. +    PyMem_Free(bytes);
  369. +    return str;
  370. +}
  371. +
  372. +/*[clinic input]
  373. +_hashlib.SHAKE.copy as SHAKE_copy
  374. +
  375. +Return a copy of the SHAKE object.
  376. +[clinic start generated code]*/
  377. +
  378. +static PyObject *
  379. +SHAKE_copy_impl(SHAKE *self)
  380. +/*[clinic end generated code: output=19cff23538f29dc6 input=34c8368c5c9e910c]*/
  381. +{
  382. +    SHAKE *newobj;
  383. +
  384. +    newobj = PyObject_New(SHAKE, &SHAKE_Type);
  385. +    if (!newobj)
  386. +        return NULL;
  387. +    newobj->lock = NULL;
  388. +    ENTER_HASHLIB(self)
  389. +    newobj->ctx = self->ctx;
  390. +    newobj->bits = self->bits;
  391. +    LEAVE_HASHLIB(self)
  392. +
  393. +    return (PyObject *)newobj;
  394. +}
  395. +
  396. +static PyMethodDef SHAKE_methods[] = {
  397. +    SHAKE_UPDATE_METHODDEF
  398. +    SHAKE_DIGEST_METHODDEF
  399. +    SHAKE_HEXDIGEST_METHODDEF
  400. +    SHAKE_COPY_METHODDEF
  401. +    {0}
  402. +};
  403. +
  404. +static PyObject *
  405. +SHAKE_get_digest_size(SHAKE *self, void *closure)
  406. +{
  407. +    return PyLong_FromLong(0);
  408. +}
  409. +
  410. +static PyObject *
  411. +SHAKE_get_block_size(SHAKE *self, void *closure)
  412. +{
  413. +    return PyLong_FromLong(self->ctx.rate);
  414. +}
  415. +
  416. +static PyObject *
  417. +SHAKE_get_name(SHAKE *self, void *closure)
  418. +{
  419. +    const char *name = NULL;
  420. +
  421. +    switch (self->bits) {
  422. +    case 128: name = "shake_128"; break;
  423. +    case 256: name = "shake_256"; break;
  424. +    }
  425. +
  426. +    return PyUnicode_FromString(name);
  427. +}
  428. +
  429. +static PyGetSetDef SHAKE_getset[] = {
  430. +    {"digest_size", (getter)SHAKE_get_digest_size, NULL, NULL, NULL},
  431. +    {"block_size", (getter)SHAKE_get_block_size, NULL, NULL, NULL},
  432. +    {"name", (getter)SHAKE_get_name, NULL, NULL, NULL},
  433. +    {0}
  434. +};
  435. +
  436. +static PyTypeObject SHAKE_Type = {
  437. +    PyVarObject_HEAD_INIT(NULL, 0)
  438. +    .tp_name = "_hashlib.SHAKE",
  439. +    .tp_dealloc = (destructor)SHAKE_dealloc,
  440. +    .tp_doc = SHAKE_doc,
  441. +    .tp_basicsize = sizeof(SHAKE),
  442. +    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
  443. +    .tp_methods = SHAKE_methods,
  444. +    .tp_getset = SHAKE_getset,
  445. +};
  446. +
  447. +PyDoc_STRVAR(HMAC_doc,
  448. +"The object used to calculate HMAC of a message.\n\
  449. +\n\
  450. +Methods:\n\
  451. +\n\
  452. +update() -- updates the current digest with an additional string\n\
  453. +digest() -- return the current digest value\n\
  454. +hexdigest() -- return the current digest as a string of hexadecimal digits\n\
  455. +copy() -- return a copy of the current hash object\n\
  456. +\n\
  457. +Attributes:\n\
  458. +\n\
  459. +name -- the name, including the hash algorithm used by this object\n\
  460. +digest_size -- number of bytes in digest() output\n");
  461. +
  462. +static void
  463. +HMAC_dealloc(HMAC *self)
  464. +{
  465. +    if (self->lock)
  466. +        PyThread_free_lock(self->lock);
  467. +    PyObject_Free(self);
  468. +}
  469. +/*[clinic input]
  470. +_hashlib.HMAC.copy as HMAC_copy
  471. +
  472. +Return a copy of the HMAC object.
  473. +[clinic start generated code]*/
  474. +
  475. +static PyObject *
  476. +HMAC_copy_impl(HMAC *self)
  477. +/*[clinic end generated code: output=6a3595133ec708a5 input=c471e903458ee9a7]*/
  478. +{
  479. +    HMAC *newobj;
  480. +
  481. +    newobj = PyObject_New(HMAC, &HMAC_Type);
  482. +    if (!newobj)
  483. +        return NULL;
  484. +    newobj->lock = NULL;
  485. +    ENTER_HASHLIB(self)
  486. +    newobj->ctx = self->ctx;
  487. +    newobj->key = self->key;
  488. +    LEAVE_HASHLIB(self)
  489. +
  490. +    return (PyObject *)newobj;
  491. +}
  492. +
  493. +/*[clinic input]
  494. +_hashlib.HMAC.update as HMAC_update
  495. +
  496. +    data: Py_buffer
  497. +    /
  498. +
  499. +Update the HMAC object with data.
  500. +[clinic start generated code]*/
  501. +
  502. +static PyObject *
  503. +HMAC_update_impl(HMAC *self, Py_buffer *data)
  504. +/*[clinic end generated code: output=d3520ecffa6cc3ab input=827e77e990887267]*/
  505. +{
  506. +    if (!self->lock && data->len >= HASHLIB_GIL_MINSIZE)
  507. +        self->lock = PyThread_allocate_lock();
  508. +    if (self->lock) {
  509. +        Py_BEGIN_ALLOW_THREADS
  510. +        PyThread_acquire_lock(self->lock, 1);
  511. +        br_hmac_update(&self->ctx, data->buf, data->len);
  512. +        PyThread_release_lock(self->lock);
  513. +        Py_END_ALLOW_THREADS
  514. +    } else {
  515. +        br_hmac_update(&self->ctx, data->buf, data->len);
  516. +    }
  517. +    Py_RETURN_NONE;
  518. +}
  519. +
  520. +/*[clinic input]
  521. +_hashlib.HMAC.digest as HMAC_digest
  522. +
  523. +Return the digest of the bytes passed to the update() method so far.
  524. +[clinic start generated code]*/
  525. +
  526. +static PyObject *
  527. +HMAC_digest_impl(HMAC *self)
  528. +/*[clinic end generated code: output=9853eeca2bdd96df input=d39cb2285b557318]*/
  529. +{
  530. +    char digest[64];
  531. +    Py_ssize_t digest_size;
  532. +
  533. +    ENTER_HASHLIB(self)
  534. +    digest_size = br_hmac_out(&self->ctx, digest);
  535. +    LEAVE_HASHLIB(self)
  536. +
  537. +    return PyBytes_FromStringAndSize(digest, digest_size);
  538. +}
  539. +
  540. +/*[clinic input]
  541. +_hashlib.HMAC.hexdigest as HMAC_hexdigest
  542. +
  543. +Return hexadecimal digest of the bytes passed to the update() method so far.
  544. +
  545. +This may be used to exchange the value safely in email or other non-binary
  546. +environments.
  547. +[clinic start generated code]*/
  548. +
  549. +static PyObject *
  550. +HMAC_hexdigest_impl(HMAC *self)
  551. +/*[clinic end generated code: output=9bb0c7abb6940bab input=2471f22b8dba7433]*/
  552. +{
  553. +    char digest[64];
  554. +    Py_ssize_t digest_size;
  555. +
  556. +    ENTER_HASHLIB(self)
  557. +    digest_size = br_hmac_out(&self->ctx, digest);
  558. +    LEAVE_HASHLIB(self)
  559. +
  560. +    return _Py_strhex(digest, digest_size);
  561. +}
  562. +
  563. +static PyMethodDef HMAC_methods[] = {
  564. +    HMAC_UPDATE_METHODDEF
  565. +    HMAC_DIGEST_METHODDEF
  566. +    HMAC_HEXDIGEST_METHODDEF
  567. +    HMAC_COPY_METHODDEF
  568. +    {0},
  569. +};
  570. +
  571. +static PyObject *
  572. +HMAC_get_digest_size(HMAC *self, void *closure)
  573. +{
  574. +    const br_hash_class *hc;
  575. +    long digest_size;
  576. +
  577. +    hc = br_hmac_get_digest(&self->ctx);
  578. +    digest_size = hc->desc >> BR_HASHDESC_OUT_OFF & BR_HASHDESC_OUT_MASK;
  579. +    return PyLong_FromLong(digest_size);
  580. +}
  581. +
  582. +static PyObject *
  583. +HMAC_get_block_size(HMAC *self, void *closure)
  584. +{
  585. +    const br_hash_class *hc;
  586. +    long block_size;
  587. +
  588. +    hc = br_hmac_get_digest(&self->ctx);
  589. +    block_size = 1 << (hc->desc >> BR_HASHDESC_LBLEN_OFF & BR_HASHDESC_LBLEN_MASK);
  590. +    return PyLong_FromLong(block_size);
  591. +}
  592. +
  593. +static PyObject *
  594. +HMAC_get_name(HMAC *self, void *closure)
  595. +{
  596. +    const br_hash_class *hc;
  597. +    const char *name = NULL;
  598. +
  599. +    hc = br_hmac_get_digest(&self->ctx);
  600. +    switch (hc->desc >> BR_HASHDESC_ID_OFF & BR_HASHDESC_ID_MASK) {
  601. +    case br_md5_ID:    name = "hmac-md5";    break;
  602. +    case br_sha1_ID:   name = "hmac-sha1";   break;
  603. +    case br_sha224_ID: name = "hmac-sha224"; break;
  604. +    case br_sha256_ID: name = "hmac-sha256"; break;
  605. +    case br_sha384_ID: name = "hmac-sha384"; break;
  606. +    case br_sha512_ID: name = "hmac-sha512"; break;
  607. +    }
  608. +
  609. +    return PyUnicode_FromString(name);
  610. +}
  611. +
  612. +static PyGetSetDef HMAC_getset[] = {
  613. +    {"digest_size", (getter)HMAC_get_digest_size, NULL, NULL, NULL},
  614. +    {"block_size", (getter)HMAC_get_block_size, NULL, NULL, NULL},
  615. +    {"name", (getter)HMAC_get_name, NULL, NULL, NULL},
  616. +    {0}
  617. +};
  618. +
  619. +static PyTypeObject HMAC_Type = {
  620. +    PyVarObject_HEAD_INIT(NULL, 0)
  621. +    .tp_name = "_hashlib.HMAC",
  622. +    .tp_dealloc = (destructor)HMAC_dealloc,
  623. +    .tp_doc = HMAC_doc,
  624. +    .tp_basicsize = sizeof(HMAC),
  625. +    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION | Py_TPFLAGS_IMMUTABLETYPE,
  626. +    .tp_methods = HMAC_methods,
  627. +    .tp_getset = HMAC_getset,
  628. +};
  629. +
  630. +static PyObject *
  631. +Hash_new_vtable(PyObject *module, const br_hash_class *hc,
  632. +                Py_buffer *string, int usedforsecurity)
  633. +{
  634. +    Hash *self;
  635. +
  636. +    self = PyObject_New(Hash, &Hash_Type);
  637. +    if (!self)
  638. +        return NULL;
  639. +    self->lock = NULL;
  640. +    hc->init(&self->ctx.vtable);
  641. +
  642. +    if (string->len >= HASHLIB_GIL_MINSIZE) {
  643. +        Py_BEGIN_ALLOW_THREADS
  644. +        hc->update(&self->ctx.vtable, string->buf, string->len);
  645. +        Py_END_ALLOW_THREADS
  646. +    } else {
  647. +        hc->update(&self->ctx.vtable, string->buf, string->len);
  648. +    }
  649. +
  650. +    return (PyObject *)self;
  651. +}
  652. +
  653. +static PyObject *
  654. +SHAKE_new(PyObject *module, int bits, Py_buffer *string, int usedforsecurity)
  655. +{
  656. +    SHAKE *self;
  657. +
  658. +    self = PyObject_New(SHAKE, &SHAKE_Type);
  659. +    if (!self)
  660. +        return NULL;
  661. +    self->lock = NULL;
  662. +    self->bits = bits;
  663. +    br_shake_init(&self->ctx, bits);
  664. +
  665. +    if (string->len >= HASHLIB_GIL_MINSIZE) {
  666. +        Py_BEGIN_ALLOW_THREADS
  667. +        br_shake_inject(&self->ctx, string->buf, string->len);
  668. +        Py_END_ALLOW_THREADS
  669. +    } else {
  670. +        br_shake_inject(&self->ctx, string->buf, string->len);
  671. +    }
  672. +
  673. +    return (PyObject *)self;
  674. +}
  675. +
  676. +/*[clinic input]
  677. +_hashlib.new
  678. +
  679. +    name: str
  680. +    string: Py_buffer = None
  681. +    *
  682. +    usedforsecurity: bool = True
  683. +
  684. +Return a new hash object using the named algorithm.
  685. +
  686. +An optional string argument may be provided and will be
  687. +automatically hashed.
  688. +
  689. +The MD5 and SHA1 algorithms are always supported.
  690. +[clinic start generated code]*/
  691. +
  692. +static PyObject *
  693. +_hashlib_new_impl(PyObject *module, const char *name, Py_buffer *string,
  694. +                  int usedforsecurity)
  695. +/*[clinic end generated code: output=5459beb11946eb8d input=c7e3a9928c6af923]*/
  696. +{
  697. +    const br_hash_class *hc = NULL;
  698. +    int shake = 0;
  699. +
  700. +    hc = py_hash_by_name(name);
  701. +    if (hc)
  702. +        ;
  703. +    else if (strcmp(name, "shake_128") == 0)
  704. +        shake = 128;
  705. +    else if (strcmp(name, "shake_256") == 0)
  706. +        shake = 256;
  707. +    else {
  708. +        PyErr_SetString(PyExc_ValueError, "unsupported hash type");
  709. +        return NULL;
  710. +    }
  711. +
  712. +    if (hc)
  713. +        return Hash_new_vtable(module, hc, string, usedforsecurity);
  714. +    if (shake)
  715. +        return SHAKE_new(module, shake, string, usedforsecurity);
  716. +}
  717. +
  718. +/*[clinic input]
  719. +_hashlib.openssl_md5
  720. +
  721. +    string: Py_buffer = None
  722. +    *
  723. +    usedforsecurity: bool = True
  724. +
  725. +Returns a md5 hash object; optionally initialized with a string.
  726. +[clinic start generated code]*/
  727. +
  728. +static PyObject *
  729. +_hashlib_openssl_md5_impl(PyObject *module, Py_buffer *string,
  730. +                          int usedforsecurity)
  731. +/*[clinic end generated code: output=bf0df21c3ecd9d85 input=75e59cc38a292e51]*/
  732. +{
  733. +    return Hash_new_vtable(module, &br_md5_vtable, string, usedforsecurity);
  734. +}
  735. +
  736. +/*[clinic input]
  737. +_hashlib.openssl_sha1
  738. +
  739. +    string: Py_buffer = None
  740. +    *
  741. +    usedforsecurity: bool = True
  742. +
  743. +Returns a sha1 hash object; optionally initialized with a string.
  744. +[clinic start generated code]*/
  745. +
  746. +static PyObject *
  747. +_hashlib_openssl_sha1_impl(PyObject *module, Py_buffer *string,
  748. +                           int usedforsecurity)
  749. +/*[clinic end generated code: output=9c468cf3cfdd2e57 input=0f8ad0fa5d988be8]*/
  750. +{
  751. +    return Hash_new_vtable(module, &br_sha1_vtable, string, usedforsecurity);
  752. +}
  753. +
  754. +/*[clinic input]
  755. +_hashlib.openssl_sha224
  756. +
  757. +    string: Py_buffer = None
  758. +    *
  759. +    usedforsecurity: bool = True
  760. +
  761. +Returns a sha224 hash object; optionally initialized with a string.
  762. +[clinic start generated code]*/
  763. +
  764. +static PyObject *
  765. +_hashlib_openssl_sha224_impl(PyObject *module, Py_buffer *string,
  766. +                             int usedforsecurity)
  767. +/*[clinic end generated code: output=9b3fea17aacc8dfe input=21aacab0e6949431]*/
  768. +{
  769. +    return Hash_new_vtable(module, &br_sha224_vtable, string, usedforsecurity);
  770. +}
  771. +
  772. +/*[clinic input]
  773. +_hashlib.openssl_sha256
  774. +
  775. +    string: Py_buffer = None
  776. +    *
  777. +    usedforsecurity: bool = True
  778. +
  779. +Returns a sha256 hash object; optionally initialized with a string.
  780. +[clinic start generated code]*/
  781. +
  782. +static PyObject *
  783. +_hashlib_openssl_sha256_impl(PyObject *module, Py_buffer *string,
  784. +                             int usedforsecurity)
  785. +/*[clinic end generated code: output=2c0585ccc6dfa22a input=81dd291675e0f6c9]*/
  786. +{
  787. +    return Hash_new_vtable(module, &br_sha256_vtable, string, usedforsecurity);
  788. +}
  789. +
  790. +/*[clinic input]
  791. +_hashlib.openssl_sha384
  792. +
  793. +    string: Py_buffer = None
  794. +    *
  795. +    usedforsecurity: bool = True
  796. +
  797. +Returns a sha384 hash object; optionally initialized with a string.
  798. +[clinic start generated code]*/
  799. +
  800. +static PyObject *
  801. +_hashlib_openssl_sha384_impl(PyObject *module, Py_buffer *string,
  802. +                             int usedforsecurity)
  803. +/*[clinic end generated code: output=196d8d7558cfd155 input=eed0b0128dd67969]*/
  804. +{
  805. +    return Hash_new_vtable(module, &br_sha384_vtable, string, usedforsecurity);
  806. +}
  807. +
  808. +/*[clinic input]
  809. +_hashlib.openssl_sha512
  810. +
  811. +    string: Py_buffer = None
  812. +    *
  813. +    usedforsecurity: bool = True
  814. +
  815. +Returns a sha512 hash object; optionally initialized with a string.
  816. +[clinic start generated code]*/
  817. +
  818. +static PyObject *
  819. +_hashlib_openssl_sha512_impl(PyObject *module, Py_buffer *string,
  820. +                             int usedforsecurity)
  821. +/*[clinic end generated code: output=7349b37b20ff6f75 input=da1228b585897043]*/
  822. +{
  823. +    return Hash_new_vtable(module, &br_sha512_vtable, string, usedforsecurity);
  824. +}
  825. +
  826. +/*[clinic input]
  827. +_hashlib.openssl_shake_128
  828. +
  829. +    string: Py_buffer = None
  830. +    *
  831. +    usedforsecurity: bool = True
  832. +
  833. +Returns a shake-128 variable hash object; optionally initialized with a string.
  834. +[clinic start generated code]*/
  835. +
  836. +static PyObject *
  837. +_hashlib_openssl_shake_128_impl(PyObject *module, Py_buffer *string,
  838. +                                int usedforsecurity)
  839. +/*[clinic end generated code: output=e51cc0e4bded887e input=fb6dce24fc91d53d]*/
  840. +{
  841. +    return SHAKE_new(module, 128, string, usedforsecurity);
  842. +}
  843. +
  844. +/*[clinic input]
  845. +_hashlib.openssl_shake_256
  846. +
  847. +    string: Py_buffer = None
  848. +    *
  849. +    usedforsecurity: bool = True
  850. +
  851. +Returns a shake-256 variable hash object; optionally initialized with a string.
  852. +[clinic start generated code]*/
  853. +
  854. +static PyObject *
  855. +_hashlib_openssl_shake_256_impl(PyObject *module, Py_buffer *string,
  856. +                                int usedforsecurity)
  857. +/*[clinic end generated code: output=983a76ff0796751b input=9eb2a133d11e34dc]*/
  858. +{
  859. +    return SHAKE_new(module, 256, string, usedforsecurity);
  860. +}
  861. +
  862. +static int
  863. +_tscmp(const unsigned char *a, const unsigned char *b,
  864. +        Py_ssize_t len_a, Py_ssize_t len_b)
  865. +{
  866. +    /* loop count depends on length of b. Might leak very little timing
  867. +     * information if sizes are different.
  868. +     */
  869. +    Py_ssize_t length = len_b;
  870. +    unsigned result = 0;
  871. +    size_t i;
  872. +
  873. +    if (len_a != length) {
  874. +        a = b;
  875. +        result = 1;
  876. +    }
  877. +
  878. +    for (i = 0; i < length; i++)
  879. +        result |= (unsigned)a[i] ^ (unsigned)b[i];
  880. +
  881. +    return ~(result | -result) >> CHAR_BIT * sizeof(result) - 1;
  882. +}
  883. +
  884. +/*[clinic input]
  885. +_hashlib.compare_digest
  886. +
  887. +    a: object
  888. +    b: object
  889. +    /
  890. +
  891. +Return 'a == b'.
  892. +
  893. +This function uses an approach designed to prevent
  894. +timing analysis, making it appropriate for cryptography.
  895. +
  896. +a and b must both be of the same type: either str (ASCII only),
  897. +or any bytes-like object.
  898. +
  899. +Note: If a and b are of different lengths, or if an error occurs,
  900. +a timing attack could theoretically reveal information about the
  901. +types and lengths of a and b--but not their values.
  902. +[clinic start generated code]*/
  903. +
  904. +static PyObject *
  905. +_hashlib_compare_digest_impl(PyObject *module, PyObject *a, PyObject *b)
  906. +/*[clinic end generated code: output=6f1c13927480aed9 input=f9cc6da970b1b1d5]*/
  907. +{
  908. +    int rc;
  909. +
  910. +    /* ASCII unicode string */
  911. +    if(PyUnicode_Check(a) && PyUnicode_Check(b)) {
  912. +        if (PyUnicode_READY(a) == -1 || PyUnicode_READY(b) == -1) {
  913. +            return NULL;
  914. +        }
  915. +        if (!PyUnicode_IS_ASCII(a) || !PyUnicode_IS_ASCII(b)) {
  916. +            PyErr_SetString(PyExc_TypeError,
  917. +                            "comparing strings with non-ASCII characters is "
  918. +                            "not supported");
  919. +            return NULL;
  920. +        }
  921. +
  922. +        rc = _tscmp(PyUnicode_DATA(a),
  923. +                    PyUnicode_DATA(b),
  924. +                    PyUnicode_GET_LENGTH(a),
  925. +                    PyUnicode_GET_LENGTH(b));
  926. +    }
  927. +    /* fallback to buffer interface for bytes, bytesarray and other */
  928. +    else {
  929. +        Py_buffer view_a;
  930. +        Py_buffer view_b;
  931. +
  932. +        if (PyObject_CheckBuffer(a) == 0 && PyObject_CheckBuffer(b) == 0) {
  933. +            PyErr_Format(PyExc_TypeError,
  934. +                         "unsupported operand types(s) or combination of types: "
  935. +                         "'%.100s' and '%.100s'",
  936. +                         Py_TYPE(a)->tp_name, Py_TYPE(b)->tp_name);
  937. +            return NULL;
  938. +        }
  939. +
  940. +        if (PyObject_GetBuffer(a, &view_a, PyBUF_SIMPLE) == -1) {
  941. +            return NULL;
  942. +        }
  943. +        if (view_a.ndim > 1) {
  944. +            PyErr_SetString(PyExc_BufferError,
  945. +                            "Buffer must be single dimension");
  946. +            PyBuffer_Release(&view_a);
  947. +            return NULL;
  948. +        }
  949. +
  950. +        if (PyObject_GetBuffer(b, &view_b, PyBUF_SIMPLE) == -1) {
  951. +            PyBuffer_Release(&view_a);
  952. +            return NULL;
  953. +        }
  954. +        if (view_b.ndim > 1) {
  955. +            PyErr_SetString(PyExc_BufferError,
  956. +                            "Buffer must be single dimension");
  957. +            PyBuffer_Release(&view_a);
  958. +            PyBuffer_Release(&view_b);
  959. +            return NULL;
  960. +        }
  961. +
  962. +        rc = _tscmp((const unsigned char*)view_a.buf,
  963. +                    (const unsigned char*)view_b.buf,
  964. +                    view_a.len,
  965. +                    view_b.len);
  966. +
  967. +        PyBuffer_Release(&view_a);
  968. +        PyBuffer_Release(&view_b);
  969. +    }
  970. +
  971. +    return PyBool_FromLong(rc);
  972. +}
  973. +
  974. +static struct PyMethodDef hashlib_methods[] = {
  975. +    _HASHLIB_NEW_METHODDEF
  976. +    _HASHLIB_HMAC_SINGLESHOT_METHODDEF
  977. +    _HASHLIB_HMAC_NEW_METHODDEF
  978. +    _HASHLIB_OPENSSL_MD5_METHODDEF
  979. +    _HASHLIB_OPENSSL_SHA1_METHODDEF
  980. +    _HASHLIB_OPENSSL_SHA224_METHODDEF
  981. +    _HASHLIB_OPENSSL_SHA256_METHODDEF
  982. +    _HASHLIB_OPENSSL_SHA384_METHODDEF
  983. +    _HASHLIB_OPENSSL_SHA512_METHODDEF
  984. +    _HASHLIB_OPENSSL_SHAKE_128_METHODDEF
  985. +    _HASHLIB_OPENSSL_SHAKE_256_METHODDEF
  986. +    _HASHLIB_COMPARE_DIGEST_METHODDEF
  987. +    {0}
  988. +};
  989. +
  990. +/* Fast HMAC for hmac.digest() */
  991. +
  992. +/*[clinic input]
  993. +_hashlib.hmac_digest as _hashlib_hmac_singleshot
  994. +
  995. +    key: Py_buffer
  996. +    msg: Py_buffer
  997. +    digest: str
  998. +
  999. +Single-shot HMAC.
  1000. +[clinic start generated code]*/
  1001. +
  1002. +static PyObject *
  1003. +_hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
  1004. +                              Py_buffer *msg, const char *digest)
  1005. +/*[clinic end generated code: output=15658ede5ab98185 input=019dffc571909a46]*/
  1006. +{
  1007. +    char buf[64];
  1008. +    Py_ssize_t buf_len;
  1009. +    br_hmac_context ctx;
  1010. +    br_hmac_key_context keyctx;
  1011. +    const br_hash_class *hc;
  1012. +
  1013. +    hc = py_hash_by_name(digest);
  1014. +    if (!hc) {
  1015. +        PyErr_SetString(PyExc_ValueError, "unsupported hash type");
  1016. +        return NULL;
  1017. +    }
  1018. +    if (msg->len >= HASHLIB_GIL_MINSIZE) {
  1019. +        Py_BEGIN_ALLOW_THREADS
  1020. +        br_hmac_key_init(&keyctx, hc, key->buf, key->len);
  1021. +        br_hmac_init(&ctx, &keyctx, 0);
  1022. +        br_hmac_update(&ctx, msg->buf, msg->len);
  1023. +        br_hmac_out(&ctx, buf);
  1024. +        Py_END_ALLOW_THREADS
  1025. +    } else {
  1026. +        br_hmac_key_init(&keyctx, hc, key->buf, key->len);
  1027. +        br_hmac_init(&ctx, &keyctx, 0);
  1028. +        br_hmac_update(&ctx, msg->buf, msg->len);
  1029. +        br_hmac_out(&ctx, buf);
  1030. +    }
  1031. +    buf_len = br_hmac_size(&ctx);
  1032. +
  1033. +    return PyBytes_FromStringAndSize(buf, buf_len);
  1034. +}
  1035. +
  1036. +/*[clinic input]
  1037. +_hashlib.hmac_new
  1038. +
  1039. +    key: Py_buffer
  1040. +    msg: Py_buffer = None
  1041. +    digestmod: str(c_default="NULL") = None
  1042. +
  1043. +Return a new hmac object.
  1044. +[clinic start generated code]*/
  1045. +
  1046. +static PyObject *
  1047. +_hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, Py_buffer *msg,
  1048. +                       const char *digestmod)
  1049. +/*[clinic end generated code: output=5733a8600554bba2 input=b0125f4222a0d06d]*/
  1050. +{
  1051. +    HMAC *self;
  1052. +    const br_hash_class *hc;
  1053. +
  1054. +    printf("hmac new\n");
  1055. +
  1056. +    if (!digestmod || !digestmod[0]) {
  1057. +        PyErr_SetString(
  1058. +            PyExc_TypeError, "missing required parameter 'digestmod'");
  1059. +        return NULL;
  1060. +    }
  1061. +    hc = py_hash_by_name(digestmod);
  1062. +    if (!hc) {
  1063. +        PyErr_SetString(PyExc_ValueError, "unknown hash function");
  1064. +        return NULL;
  1065. +    }
  1066. +    self = PyObject_New(HMAC, &HMAC_Type);
  1067. +    if (!self)
  1068. +        return NULL;
  1069. +    self->lock = NULL;
  1070. +    br_hmac_key_init(&self->key, hc, key->buf, key->len);
  1071. +    br_hmac_init(&self->ctx, &self->key, 0);
  1072. +
  1073. +    if (msg->len >= HASHLIB_GIL_MINSIZE) {
  1074. +        Py_BEGIN_ALLOW_THREADS
  1075. +        br_hmac_update(&self->ctx, msg->buf, msg->len);
  1076. +        Py_END_ALLOW_THREADS
  1077. +    } else {
  1078. +        br_hmac_update(&self->ctx, msg->buf, msg->len);
  1079. +    }
  1080. +
  1081. +    return (PyObject *)self;
  1082. +}
  1083. +
  1084. +static struct PyModuleDef _hashlibmodule = {
  1085. +    PyModuleDef_HEAD_INIT,
  1086. +    .m_name = "_hashlib",
  1087. +    .m_doc = "BearSSL interface for hashlib module",
  1088. +    .m_methods = hashlib_methods,
  1089. +};
  1090. +
  1091. +PyMODINIT_FUNC
  1092. +PyInit__hashlib(void)
  1093. +{
  1094. +    PyObject *m = NULL, *set = NULL, *name;
  1095. +    static const char *const names[] = {
  1096. +        "md5",
  1097. +        "sha1",
  1098. +        "sha224",
  1099. +        "sha256",
  1100. +        "sha384",
  1101. +        "sha512",
  1102. +        "shake_128",
  1103. +        "shake_256",
  1104. +    };
  1105. +    int r;
  1106. +
  1107. +    m = PyState_FindModule(&_hashlibmodule);
  1108. +    if (m) {
  1109. +        Py_INCREF(m);
  1110. +        return m;
  1111. +    }
  1112. +    m = PyModule_Create(&_hashlibmodule);
  1113. +    if (!m)
  1114. +        goto err;
  1115. +    if (PyModule_AddType(m, &Hash_Type) < 0)
  1116. +        goto err;
  1117. +    if (PyModule_AddType(m, &SHAKE_Type) < 0)
  1118. +        goto err;
  1119. +    if (PyModule_AddType(m, &HMAC_Type) < 0)
  1120. +        goto err;
  1121. +    set = PyFrozenSet_New(NULL);
  1122. +    if (!set)
  1123. +        goto err;
  1124. +    for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); i++) {
  1125. +        name = PyUnicode_FromString(names[i]);
  1126. +        if (!name)
  1127. +            goto err;
  1128. +        r = PySet_Add(set, name);
  1129. +        Py_DECREF(name);
  1130. +        if (r != 0)
  1131. +            goto err;
  1132. +    }
  1133. +    if (PyModule_AddObject(m, "openssl_md_meth_names", set) < 0)
  1134. +        goto err;
  1135. +
  1136. +    return m;
  1137. +
  1138. +  err:
  1139. +    if (set)
  1140. +        Py_DECREF(set);
  1141. +    if (m)
  1142. +        Py_DECREF(m);
  1143. +    return NULL;
  1144. +}
  1145. diff --git a/Modules/clinic/_hashbearssl.c.h b/Modules/clinic/_hashbearssl.c.h
  1146. new file mode 100644
  1147. index 0000000000..49bf8f9287
  1148. --- /dev/null
  1149. +++ b/Modules/clinic/_hashbearssl.c.h
  1150. @@ -0,0 +1,1113 @@
  1151. +/*[clinic input]
  1152. +preserve
  1153. +[clinic start generated code]*/
  1154. +
  1155. +PyDoc_STRVAR(Hash_update__doc__,
  1156. +"update($self, data, /)\n"
  1157. +"--\n"
  1158. +"\n"
  1159. +"Update this hash object\'s state with the provided string.");
  1160. +
  1161. +#define HASH_UPDATE_METHODDEF    \
  1162. +    {"update", (PyCFunction)Hash_update, METH_O, Hash_update__doc__},
  1163. +
  1164. +static PyObject *
  1165. +Hash_update_impl(Hash *self, Py_buffer *data);
  1166. +
  1167. +static PyObject *
  1168. +Hash_update(Hash *self, PyObject *arg)
  1169. +{
  1170. +    PyObject *return_value = NULL;
  1171. +    Py_buffer data = {NULL, NULL};
  1172. +
  1173. +    if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
  1174. +        goto exit;
  1175. +    }
  1176. +    if (!PyBuffer_IsContiguous(&data, 'C')) {
  1177. +        _PyArg_BadArgument("update", "argument", "contiguous buffer", arg);
  1178. +        goto exit;
  1179. +    }
  1180. +    return_value = Hash_update_impl(self, &data);
  1181. +
  1182. +exit:
  1183. +    /* Cleanup for data */
  1184. +    if (data.obj) {
  1185. +       PyBuffer_Release(&data);
  1186. +    }
  1187. +
  1188. +    return return_value;
  1189. +}
  1190. +
  1191. +PyDoc_STRVAR(Hash_digest__doc__,
  1192. +"digest($self, /)\n"
  1193. +"--\n"
  1194. +"\n"
  1195. +"Return the digest value as a bytes object.");
  1196. +
  1197. +#define HASH_DIGEST_METHODDEF    \
  1198. +    {"digest", (PyCFunction)Hash_digest, METH_NOARGS, Hash_digest__doc__},
  1199. +
  1200. +static PyObject *
  1201. +Hash_digest_impl(Hash *self);
  1202. +
  1203. +static PyObject *
  1204. +Hash_digest(Hash *self, PyObject *Py_UNUSED(ignored))
  1205. +{
  1206. +    return Hash_digest_impl(self);
  1207. +}
  1208. +
  1209. +PyDoc_STRVAR(Hash_hexdigest__doc__,
  1210. +"hexdigest($self, /)\n"
  1211. +"--\n"
  1212. +"\n"
  1213. +"Return the digest value as a string of hexadecimal digits.");
  1214. +
  1215. +#define HASH_HEXDIGEST_METHODDEF    \
  1216. +    {"hexdigest", (PyCFunction)Hash_hexdigest, METH_NOARGS, Hash_hexdigest__doc__},
  1217. +
  1218. +static PyObject *
  1219. +Hash_hexdigest_impl(Hash *self);
  1220. +
  1221. +static PyObject *
  1222. +Hash_hexdigest(Hash *self, PyObject *Py_UNUSED(ignored))
  1223. +{
  1224. +    return Hash_hexdigest_impl(self);
  1225. +}
  1226. +
  1227. +PyDoc_STRVAR(Hash_copy__doc__,
  1228. +"copy($self, /)\n"
  1229. +"--\n"
  1230. +"\n"
  1231. +"Return a copy of the hash object.");
  1232. +
  1233. +#define HASH_COPY_METHODDEF    \
  1234. +    {"copy", (PyCFunction)Hash_copy, METH_NOARGS, Hash_copy__doc__},
  1235. +
  1236. +static PyObject *
  1237. +Hash_copy_impl(Hash *self);
  1238. +
  1239. +static PyObject *
  1240. +Hash_copy(Hash *self, PyObject *Py_UNUSED(ignored))
  1241. +{
  1242. +    return Hash_copy_impl(self);
  1243. +}
  1244. +
  1245. +PyDoc_STRVAR(SHAKE_update__doc__,
  1246. +"update($self, data, /)\n"
  1247. +"--\n"
  1248. +"\n"
  1249. +"Update this hash object\'s state with the provided string.");
  1250. +
  1251. +#define SHAKE_UPDATE_METHODDEF    \
  1252. +    {"update", (PyCFunction)SHAKE_update, METH_O, SHAKE_update__doc__},
  1253. +
  1254. +static PyObject *
  1255. +SHAKE_update_impl(SHAKE *self, Py_buffer *data);
  1256. +
  1257. +static PyObject *
  1258. +SHAKE_update(SHAKE *self, PyObject *arg)
  1259. +{
  1260. +    PyObject *return_value = NULL;
  1261. +    Py_buffer data = {NULL, NULL};
  1262. +
  1263. +    if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
  1264. +        goto exit;
  1265. +    }
  1266. +    if (!PyBuffer_IsContiguous(&data, 'C')) {
  1267. +        _PyArg_BadArgument("update", "argument", "contiguous buffer", arg);
  1268. +        goto exit;
  1269. +    }
  1270. +    return_value = SHAKE_update_impl(self, &data);
  1271. +
  1272. +exit:
  1273. +    /* Cleanup for data */
  1274. +    if (data.obj) {
  1275. +       PyBuffer_Release(&data);
  1276. +    }
  1277. +
  1278. +    return return_value;
  1279. +}
  1280. +
  1281. +PyDoc_STRVAR(SHAKE_digest__doc__,
  1282. +"digest($self, /, length)\n"
  1283. +"--\n"
  1284. +"\n"
  1285. +"Return the digest value as a bytes object.");
  1286. +
  1287. +#define SHAKE_DIGEST_METHODDEF    \
  1288. +    {"digest", (PyCFunction)(void(*)(void))SHAKE_digest, METH_FASTCALL|METH_KEYWORDS, SHAKE_digest__doc__},
  1289. +
  1290. +static PyObject *
  1291. +SHAKE_digest_impl(SHAKE *self, Py_ssize_t length);
  1292. +
  1293. +static PyObject *
  1294. +SHAKE_digest(SHAKE *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1295. +{
  1296. +    PyObject *return_value = NULL;
  1297. +    static const char * const _keywords[] = {"length", NULL};
  1298. +    static _PyArg_Parser _parser = {NULL, _keywords, "digest", 0};
  1299. +    PyObject *argsbuf[1];
  1300. +    Py_ssize_t length;
  1301. +
  1302. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
  1303. +    if (!args) {
  1304. +        goto exit;
  1305. +    }
  1306. +    if (PyFloat_Check(args[0])) {
  1307. +        PyErr_SetString(PyExc_TypeError,
  1308. +                        "integer argument expected, got float" );
  1309. +        goto exit;
  1310. +    }
  1311. +    {
  1312. +        Py_ssize_t ival = -1;
  1313. +        PyObject *iobj = PyNumber_Index(args[0]);
  1314. +        if (iobj != NULL) {
  1315. +            ival = PyLong_AsSsize_t(iobj);
  1316. +            Py_DECREF(iobj);
  1317. +        }
  1318. +        if (ival == -1 && PyErr_Occurred()) {
  1319. +            goto exit;
  1320. +        }
  1321. +        length = ival;
  1322. +    }
  1323. +    return_value = SHAKE_digest_impl(self, length);
  1324. +
  1325. +exit:
  1326. +    return return_value;
  1327. +}
  1328. +
  1329. +PyDoc_STRVAR(SHAKE_hexdigest__doc__,
  1330. +"hexdigest($self, /, length)\n"
  1331. +"--\n"
  1332. +"\n"
  1333. +"Return the digest value as a string of hexadecimal digits.");
  1334. +
  1335. +#define SHAKE_HEXDIGEST_METHODDEF    \
  1336. +    {"hexdigest", (PyCFunction)(void(*)(void))SHAKE_hexdigest, METH_FASTCALL|METH_KEYWORDS, SHAKE_hexdigest__doc__},
  1337. +
  1338. +static PyObject *
  1339. +SHAKE_hexdigest_impl(SHAKE *self, Py_ssize_t length);
  1340. +
  1341. +static PyObject *
  1342. +SHAKE_hexdigest(SHAKE *self, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1343. +{
  1344. +    PyObject *return_value = NULL;
  1345. +    static const char * const _keywords[] = {"length", NULL};
  1346. +    static _PyArg_Parser _parser = {NULL, _keywords, "hexdigest", 0};
  1347. +    PyObject *argsbuf[1];
  1348. +    Py_ssize_t length;
  1349. +
  1350. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 1, 0, argsbuf);
  1351. +    if (!args) {
  1352. +        goto exit;
  1353. +    }
  1354. +    if (PyFloat_Check(args[0])) {
  1355. +        PyErr_SetString(PyExc_TypeError,
  1356. +                        "integer argument expected, got float" );
  1357. +        goto exit;
  1358. +    }
  1359. +    {
  1360. +        Py_ssize_t ival = -1;
  1361. +        PyObject *iobj = PyNumber_Index(args[0]);
  1362. +        if (iobj != NULL) {
  1363. +            ival = PyLong_AsSsize_t(iobj);
  1364. +            Py_DECREF(iobj);
  1365. +        }
  1366. +        if (ival == -1 && PyErr_Occurred()) {
  1367. +            goto exit;
  1368. +        }
  1369. +        length = ival;
  1370. +    }
  1371. +    return_value = SHAKE_hexdigest_impl(self, length);
  1372. +
  1373. +exit:
  1374. +    return return_value;
  1375. +}
  1376. +
  1377. +PyDoc_STRVAR(SHAKE_copy__doc__,
  1378. +"copy($self, /)\n"
  1379. +"--\n"
  1380. +"\n"
  1381. +"Return a copy of the SHAKE object.");
  1382. +
  1383. +#define SHAKE_COPY_METHODDEF    \
  1384. +    {"copy", (PyCFunction)SHAKE_copy, METH_NOARGS, SHAKE_copy__doc__},
  1385. +
  1386. +static PyObject *
  1387. +SHAKE_copy_impl(SHAKE *self);
  1388. +
  1389. +static PyObject *
  1390. +SHAKE_copy(SHAKE *self, PyObject *Py_UNUSED(ignored))
  1391. +{
  1392. +    return SHAKE_copy_impl(self);
  1393. +}
  1394. +
  1395. +PyDoc_STRVAR(HMAC_copy__doc__,
  1396. +"copy($self, /)\n"
  1397. +"--\n"
  1398. +"\n"
  1399. +"Return a copy of the HMAC object.");
  1400. +
  1401. +#define HMAC_COPY_METHODDEF    \
  1402. +    {"copy", (PyCFunction)HMAC_copy, METH_NOARGS, HMAC_copy__doc__},
  1403. +
  1404. +static PyObject *
  1405. +HMAC_copy_impl(HMAC *self);
  1406. +
  1407. +static PyObject *
  1408. +HMAC_copy(HMAC *self, PyObject *Py_UNUSED(ignored))
  1409. +{
  1410. +    return HMAC_copy_impl(self);
  1411. +}
  1412. +
  1413. +PyDoc_STRVAR(HMAC_update__doc__,
  1414. +"update($self, data, /)\n"
  1415. +"--\n"
  1416. +"\n"
  1417. +"Update the HMAC object with data.");
  1418. +
  1419. +#define HMAC_UPDATE_METHODDEF    \
  1420. +    {"update", (PyCFunction)HMAC_update, METH_O, HMAC_update__doc__},
  1421. +
  1422. +static PyObject *
  1423. +HMAC_update_impl(HMAC *self, Py_buffer *data);
  1424. +
  1425. +static PyObject *
  1426. +HMAC_update(HMAC *self, PyObject *arg)
  1427. +{
  1428. +    PyObject *return_value = NULL;
  1429. +    Py_buffer data = {NULL, NULL};
  1430. +
  1431. +    if (PyObject_GetBuffer(arg, &data, PyBUF_SIMPLE) != 0) {
  1432. +        goto exit;
  1433. +    }
  1434. +    if (!PyBuffer_IsContiguous(&data, 'C')) {
  1435. +        _PyArg_BadArgument("update", "argument", "contiguous buffer", arg);
  1436. +        goto exit;
  1437. +    }
  1438. +    return_value = HMAC_update_impl(self, &data);
  1439. +
  1440. +exit:
  1441. +    /* Cleanup for data */
  1442. +    if (data.obj) {
  1443. +       PyBuffer_Release(&data);
  1444. +    }
  1445. +
  1446. +    return return_value;
  1447. +}
  1448. +
  1449. +PyDoc_STRVAR(HMAC_digest__doc__,
  1450. +"digest($self, /)\n"
  1451. +"--\n"
  1452. +"\n"
  1453. +"Return the digest of the bytes passed to the update() method so far.");
  1454. +
  1455. +#define HMAC_DIGEST_METHODDEF    \
  1456. +    {"digest", (PyCFunction)HMAC_digest, METH_NOARGS, HMAC_digest__doc__},
  1457. +
  1458. +static PyObject *
  1459. +HMAC_digest_impl(HMAC *self);
  1460. +
  1461. +static PyObject *
  1462. +HMAC_digest(HMAC *self, PyObject *Py_UNUSED(ignored))
  1463. +{
  1464. +    return HMAC_digest_impl(self);
  1465. +}
  1466. +
  1467. +PyDoc_STRVAR(HMAC_hexdigest__doc__,
  1468. +"hexdigest($self, /)\n"
  1469. +"--\n"
  1470. +"\n"
  1471. +"Return hexadecimal digest of the bytes passed to the update() method so far.\n"
  1472. +"\n"
  1473. +"This may be used to exchange the value safely in email or other non-binary\n"
  1474. +"environments.");
  1475. +
  1476. +#define HMAC_HEXDIGEST_METHODDEF    \
  1477. +    {"hexdigest", (PyCFunction)HMAC_hexdigest, METH_NOARGS, HMAC_hexdigest__doc__},
  1478. +
  1479. +static PyObject *
  1480. +HMAC_hexdigest_impl(HMAC *self);
  1481. +
  1482. +static PyObject *
  1483. +HMAC_hexdigest(HMAC *self, PyObject *Py_UNUSED(ignored))
  1484. +{
  1485. +    return HMAC_hexdigest_impl(self);
  1486. +}
  1487. +
  1488. +PyDoc_STRVAR(_hashlib_new__doc__,
  1489. +"new($module, /, name, string=None, *, usedforsecurity=True)\n"
  1490. +"--\n"
  1491. +"\n"
  1492. +"Return a new hash object using the named algorithm.\n"
  1493. +"\n"
  1494. +"An optional string argument may be provided and will be\n"
  1495. +"automatically hashed.\n"
  1496. +"\n"
  1497. +"The MD5 and SHA1 algorithms are always supported.");
  1498. +
  1499. +#define _HASHLIB_NEW_METHODDEF    \
  1500. +    {"new", (PyCFunction)(void(*)(void))_hashlib_new, METH_FASTCALL|METH_KEYWORDS, _hashlib_new__doc__},
  1501. +
  1502. +static PyObject *
  1503. +_hashlib_new_impl(PyObject *module, const char *name, Py_buffer *string,
  1504. +                  int usedforsecurity);
  1505. +
  1506. +static PyObject *
  1507. +_hashlib_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1508. +{
  1509. +    PyObject *return_value = NULL;
  1510. +    static const char * const _keywords[] = {"name", "string", "usedforsecurity", NULL};
  1511. +    static _PyArg_Parser _parser = {NULL, _keywords, "new", 0};
  1512. +    PyObject *argsbuf[3];
  1513. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
  1514. +    const char *name;
  1515. +    Py_buffer string = {NULL, NULL};
  1516. +    int usedforsecurity = 1;
  1517. +
  1518. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 2, 0, argsbuf);
  1519. +    if (!args) {
  1520. +        goto exit;
  1521. +    }
  1522. +    if (!PyUnicode_Check(args[0])) {
  1523. +        _PyArg_BadArgument("new", "argument 'name'", "str", args[0]);
  1524. +        goto exit;
  1525. +    }
  1526. +    Py_ssize_t name_length;
  1527. +    name = PyUnicode_AsUTF8AndSize(args[0], &name_length);
  1528. +    if (name == NULL) {
  1529. +        goto exit;
  1530. +    }
  1531. +    if (strlen(name) != (size_t)name_length) {
  1532. +        PyErr_SetString(PyExc_ValueError, "embedded null character");
  1533. +        goto exit;
  1534. +    }
  1535. +    if (!noptargs) {
  1536. +        goto skip_optional_pos;
  1537. +    }
  1538. +    if (args[1]) {
  1539. +        if (PyObject_GetBuffer(args[1], &string, PyBUF_SIMPLE) != 0) {
  1540. +            goto exit;
  1541. +        }
  1542. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1543. +            _PyArg_BadArgument("new", "argument 'string'", "contiguous buffer", args[1]);
  1544. +            goto exit;
  1545. +        }
  1546. +        if (!--noptargs) {
  1547. +            goto skip_optional_pos;
  1548. +        }
  1549. +    }
  1550. +skip_optional_pos:
  1551. +    if (!noptargs) {
  1552. +        goto skip_optional_kwonly;
  1553. +    }
  1554. +    usedforsecurity = PyObject_IsTrue(args[2]);
  1555. +    if (usedforsecurity < 0) {
  1556. +        goto exit;
  1557. +    }
  1558. +skip_optional_kwonly:
  1559. +    return_value = _hashlib_new_impl(module, name, &string, usedforsecurity);
  1560. +
  1561. +exit:
  1562. +    /* Cleanup for string */
  1563. +    if (string.obj) {
  1564. +       PyBuffer_Release(&string);
  1565. +    }
  1566. +
  1567. +    return return_value;
  1568. +}
  1569. +
  1570. +PyDoc_STRVAR(_hashlib_openssl_md5__doc__,
  1571. +"openssl_md5($module, /, string=None, *, usedforsecurity=True)\n"
  1572. +"--\n"
  1573. +"\n"
  1574. +"Returns a md5 hash object; optionally initialized with a string.");
  1575. +
  1576. +#define _HASHLIB_OPENSSL_MD5_METHODDEF    \
  1577. +    {"openssl_md5", (PyCFunction)(void(*)(void))_hashlib_openssl_md5, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_md5__doc__},
  1578. +
  1579. +static PyObject *
  1580. +_hashlib_openssl_md5_impl(PyObject *module, Py_buffer *string,
  1581. +                          int usedforsecurity);
  1582. +
  1583. +static PyObject *
  1584. +_hashlib_openssl_md5(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1585. +{
  1586. +    PyObject *return_value = NULL;
  1587. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1588. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_md5", 0};
  1589. +    PyObject *argsbuf[2];
  1590. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1591. +    Py_buffer string = {NULL, NULL};
  1592. +    int usedforsecurity = 1;
  1593. +
  1594. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1595. +    if (!args) {
  1596. +        goto exit;
  1597. +    }
  1598. +    if (!noptargs) {
  1599. +        goto skip_optional_pos;
  1600. +    }
  1601. +    if (args[0]) {
  1602. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1603. +            goto exit;
  1604. +        }
  1605. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1606. +            _PyArg_BadArgument("openssl_md5", "argument 'string'", "contiguous buffer", args[0]);
  1607. +            goto exit;
  1608. +        }
  1609. +        if (!--noptargs) {
  1610. +            goto skip_optional_pos;
  1611. +        }
  1612. +    }
  1613. +skip_optional_pos:
  1614. +    if (!noptargs) {
  1615. +        goto skip_optional_kwonly;
  1616. +    }
  1617. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1618. +    if (usedforsecurity < 0) {
  1619. +        goto exit;
  1620. +    }
  1621. +skip_optional_kwonly:
  1622. +    return_value = _hashlib_openssl_md5_impl(module, &string, usedforsecurity);
  1623. +
  1624. +exit:
  1625. +    /* Cleanup for string */
  1626. +    if (string.obj) {
  1627. +       PyBuffer_Release(&string);
  1628. +    }
  1629. +
  1630. +    return return_value;
  1631. +}
  1632. +
  1633. +PyDoc_STRVAR(_hashlib_openssl_sha1__doc__,
  1634. +"openssl_sha1($module, /, string=None, *, usedforsecurity=True)\n"
  1635. +"--\n"
  1636. +"\n"
  1637. +"Returns a sha1 hash object; optionally initialized with a string.");
  1638. +
  1639. +#define _HASHLIB_OPENSSL_SHA1_METHODDEF    \
  1640. +    {"openssl_sha1", (PyCFunction)(void(*)(void))_hashlib_openssl_sha1, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha1__doc__},
  1641. +
  1642. +static PyObject *
  1643. +_hashlib_openssl_sha1_impl(PyObject *module, Py_buffer *string,
  1644. +                           int usedforsecurity);
  1645. +
  1646. +static PyObject *
  1647. +_hashlib_openssl_sha1(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1648. +{
  1649. +    PyObject *return_value = NULL;
  1650. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1651. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha1", 0};
  1652. +    PyObject *argsbuf[2];
  1653. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1654. +    Py_buffer string = {NULL, NULL};
  1655. +    int usedforsecurity = 1;
  1656. +
  1657. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1658. +    if (!args) {
  1659. +        goto exit;
  1660. +    }
  1661. +    if (!noptargs) {
  1662. +        goto skip_optional_pos;
  1663. +    }
  1664. +    if (args[0]) {
  1665. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1666. +            goto exit;
  1667. +        }
  1668. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1669. +            _PyArg_BadArgument("openssl_sha1", "argument 'string'", "contiguous buffer", args[0]);
  1670. +            goto exit;
  1671. +        }
  1672. +        if (!--noptargs) {
  1673. +            goto skip_optional_pos;
  1674. +        }
  1675. +    }
  1676. +skip_optional_pos:
  1677. +    if (!noptargs) {
  1678. +        goto skip_optional_kwonly;
  1679. +    }
  1680. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1681. +    if (usedforsecurity < 0) {
  1682. +        goto exit;
  1683. +    }
  1684. +skip_optional_kwonly:
  1685. +    return_value = _hashlib_openssl_sha1_impl(module, &string, usedforsecurity);
  1686. +
  1687. +exit:
  1688. +    /* Cleanup for string */
  1689. +    if (string.obj) {
  1690. +       PyBuffer_Release(&string);
  1691. +    }
  1692. +
  1693. +    return return_value;
  1694. +}
  1695. +
  1696. +PyDoc_STRVAR(_hashlib_openssl_sha224__doc__,
  1697. +"openssl_sha224($module, /, string=None, *, usedforsecurity=True)\n"
  1698. +"--\n"
  1699. +"\n"
  1700. +"Returns a sha224 hash object; optionally initialized with a string.");
  1701. +
  1702. +#define _HASHLIB_OPENSSL_SHA224_METHODDEF    \
  1703. +    {"openssl_sha224", (PyCFunction)(void(*)(void))_hashlib_openssl_sha224, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha224__doc__},
  1704. +
  1705. +static PyObject *
  1706. +_hashlib_openssl_sha224_impl(PyObject *module, Py_buffer *string,
  1707. +                             int usedforsecurity);
  1708. +
  1709. +static PyObject *
  1710. +_hashlib_openssl_sha224(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1711. +{
  1712. +    PyObject *return_value = NULL;
  1713. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1714. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha224", 0};
  1715. +    PyObject *argsbuf[2];
  1716. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1717. +    Py_buffer string = {NULL, NULL};
  1718. +    int usedforsecurity = 1;
  1719. +
  1720. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1721. +    if (!args) {
  1722. +        goto exit;
  1723. +    }
  1724. +    if (!noptargs) {
  1725. +        goto skip_optional_pos;
  1726. +    }
  1727. +    if (args[0]) {
  1728. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1729. +            goto exit;
  1730. +        }
  1731. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1732. +            _PyArg_BadArgument("openssl_sha224", "argument 'string'", "contiguous buffer", args[0]);
  1733. +            goto exit;
  1734. +        }
  1735. +        if (!--noptargs) {
  1736. +            goto skip_optional_pos;
  1737. +        }
  1738. +    }
  1739. +skip_optional_pos:
  1740. +    if (!noptargs) {
  1741. +        goto skip_optional_kwonly;
  1742. +    }
  1743. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1744. +    if (usedforsecurity < 0) {
  1745. +        goto exit;
  1746. +    }
  1747. +skip_optional_kwonly:
  1748. +    return_value = _hashlib_openssl_sha224_impl(module, &string, usedforsecurity);
  1749. +
  1750. +exit:
  1751. +    /* Cleanup for string */
  1752. +    if (string.obj) {
  1753. +       PyBuffer_Release(&string);
  1754. +    }
  1755. +
  1756. +    return return_value;
  1757. +}
  1758. +
  1759. +PyDoc_STRVAR(_hashlib_openssl_sha256__doc__,
  1760. +"openssl_sha256($module, /, string=None, *, usedforsecurity=True)\n"
  1761. +"--\n"
  1762. +"\n"
  1763. +"Returns a sha256 hash object; optionally initialized with a string.");
  1764. +
  1765. +#define _HASHLIB_OPENSSL_SHA256_METHODDEF    \
  1766. +    {"openssl_sha256", (PyCFunction)(void(*)(void))_hashlib_openssl_sha256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha256__doc__},
  1767. +
  1768. +static PyObject *
  1769. +_hashlib_openssl_sha256_impl(PyObject *module, Py_buffer *string,
  1770. +                             int usedforsecurity);
  1771. +
  1772. +static PyObject *
  1773. +_hashlib_openssl_sha256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1774. +{
  1775. +    PyObject *return_value = NULL;
  1776. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1777. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha256", 0};
  1778. +    PyObject *argsbuf[2];
  1779. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1780. +    Py_buffer string = {NULL, NULL};
  1781. +    int usedforsecurity = 1;
  1782. +
  1783. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1784. +    if (!args) {
  1785. +        goto exit;
  1786. +    }
  1787. +    if (!noptargs) {
  1788. +        goto skip_optional_pos;
  1789. +    }
  1790. +    if (args[0]) {
  1791. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1792. +            goto exit;
  1793. +        }
  1794. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1795. +            _PyArg_BadArgument("openssl_sha256", "argument 'string'", "contiguous buffer", args[0]);
  1796. +            goto exit;
  1797. +        }
  1798. +        if (!--noptargs) {
  1799. +            goto skip_optional_pos;
  1800. +        }
  1801. +    }
  1802. +skip_optional_pos:
  1803. +    if (!noptargs) {
  1804. +        goto skip_optional_kwonly;
  1805. +    }
  1806. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1807. +    if (usedforsecurity < 0) {
  1808. +        goto exit;
  1809. +    }
  1810. +skip_optional_kwonly:
  1811. +    return_value = _hashlib_openssl_sha256_impl(module, &string, usedforsecurity);
  1812. +
  1813. +exit:
  1814. +    /* Cleanup for string */
  1815. +    if (string.obj) {
  1816. +       PyBuffer_Release(&string);
  1817. +    }
  1818. +
  1819. +    return return_value;
  1820. +}
  1821. +
  1822. +PyDoc_STRVAR(_hashlib_openssl_sha384__doc__,
  1823. +"openssl_sha384($module, /, string=None, *, usedforsecurity=True)\n"
  1824. +"--\n"
  1825. +"\n"
  1826. +"Returns a sha384 hash object; optionally initialized with a string.");
  1827. +
  1828. +#define _HASHLIB_OPENSSL_SHA384_METHODDEF    \
  1829. +    {"openssl_sha384", (PyCFunction)(void(*)(void))_hashlib_openssl_sha384, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha384__doc__},
  1830. +
  1831. +static PyObject *
  1832. +_hashlib_openssl_sha384_impl(PyObject *module, Py_buffer *string,
  1833. +                             int usedforsecurity);
  1834. +
  1835. +static PyObject *
  1836. +_hashlib_openssl_sha384(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1837. +{
  1838. +    PyObject *return_value = NULL;
  1839. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1840. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha384", 0};
  1841. +    PyObject *argsbuf[2];
  1842. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1843. +    Py_buffer string = {NULL, NULL};
  1844. +    int usedforsecurity = 1;
  1845. +
  1846. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1847. +    if (!args) {
  1848. +        goto exit;
  1849. +    }
  1850. +    if (!noptargs) {
  1851. +        goto skip_optional_pos;
  1852. +    }
  1853. +    if (args[0]) {
  1854. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1855. +            goto exit;
  1856. +        }
  1857. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1858. +            _PyArg_BadArgument("openssl_sha384", "argument 'string'", "contiguous buffer", args[0]);
  1859. +            goto exit;
  1860. +        }
  1861. +        if (!--noptargs) {
  1862. +            goto skip_optional_pos;
  1863. +        }
  1864. +    }
  1865. +skip_optional_pos:
  1866. +    if (!noptargs) {
  1867. +        goto skip_optional_kwonly;
  1868. +    }
  1869. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1870. +    if (usedforsecurity < 0) {
  1871. +        goto exit;
  1872. +    }
  1873. +skip_optional_kwonly:
  1874. +    return_value = _hashlib_openssl_sha384_impl(module, &string, usedforsecurity);
  1875. +
  1876. +exit:
  1877. +    /* Cleanup for string */
  1878. +    if (string.obj) {
  1879. +       PyBuffer_Release(&string);
  1880. +    }
  1881. +
  1882. +    return return_value;
  1883. +}
  1884. +
  1885. +PyDoc_STRVAR(_hashlib_openssl_sha512__doc__,
  1886. +"openssl_sha512($module, /, string=None, *, usedforsecurity=True)\n"
  1887. +"--\n"
  1888. +"\n"
  1889. +"Returns a sha512 hash object; optionally initialized with a string.");
  1890. +
  1891. +#define _HASHLIB_OPENSSL_SHA512_METHODDEF    \
  1892. +    {"openssl_sha512", (PyCFunction)(void(*)(void))_hashlib_openssl_sha512, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_sha512__doc__},
  1893. +
  1894. +static PyObject *
  1895. +_hashlib_openssl_sha512_impl(PyObject *module, Py_buffer *string,
  1896. +                             int usedforsecurity);
  1897. +
  1898. +static PyObject *
  1899. +_hashlib_openssl_sha512(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1900. +{
  1901. +    PyObject *return_value = NULL;
  1902. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1903. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_sha512", 0};
  1904. +    PyObject *argsbuf[2];
  1905. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1906. +    Py_buffer string = {NULL, NULL};
  1907. +    int usedforsecurity = 1;
  1908. +
  1909. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1910. +    if (!args) {
  1911. +        goto exit;
  1912. +    }
  1913. +    if (!noptargs) {
  1914. +        goto skip_optional_pos;
  1915. +    }
  1916. +    if (args[0]) {
  1917. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1918. +            goto exit;
  1919. +        }
  1920. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1921. +            _PyArg_BadArgument("openssl_sha512", "argument 'string'", "contiguous buffer", args[0]);
  1922. +            goto exit;
  1923. +        }
  1924. +        if (!--noptargs) {
  1925. +            goto skip_optional_pos;
  1926. +        }
  1927. +    }
  1928. +skip_optional_pos:
  1929. +    if (!noptargs) {
  1930. +        goto skip_optional_kwonly;
  1931. +    }
  1932. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1933. +    if (usedforsecurity < 0) {
  1934. +        goto exit;
  1935. +    }
  1936. +skip_optional_kwonly:
  1937. +    return_value = _hashlib_openssl_sha512_impl(module, &string, usedforsecurity);
  1938. +
  1939. +exit:
  1940. +    /* Cleanup for string */
  1941. +    if (string.obj) {
  1942. +       PyBuffer_Release(&string);
  1943. +    }
  1944. +
  1945. +    return return_value;
  1946. +}
  1947. +
  1948. +PyDoc_STRVAR(_hashlib_openssl_shake_128__doc__,
  1949. +"openssl_shake_128($module, /, string=None, *, usedforsecurity=True)\n"
  1950. +"--\n"
  1951. +"\n"
  1952. +"Returns a shake-128 variable hash object; optionally initialized with a string.");
  1953. +
  1954. +#define _HASHLIB_OPENSSL_SHAKE_128_METHODDEF    \
  1955. +    {"openssl_shake_128", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_128, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_128__doc__},
  1956. +
  1957. +static PyObject *
  1958. +_hashlib_openssl_shake_128_impl(PyObject *module, Py_buffer *string,
  1959. +                                int usedforsecurity);
  1960. +
  1961. +static PyObject *
  1962. +_hashlib_openssl_shake_128(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  1963. +{
  1964. +    PyObject *return_value = NULL;
  1965. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  1966. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_128", 0};
  1967. +    PyObject *argsbuf[2];
  1968. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  1969. +    Py_buffer string = {NULL, NULL};
  1970. +    int usedforsecurity = 1;
  1971. +
  1972. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  1973. +    if (!args) {
  1974. +        goto exit;
  1975. +    }
  1976. +    if (!noptargs) {
  1977. +        goto skip_optional_pos;
  1978. +    }
  1979. +    if (args[0]) {
  1980. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  1981. +            goto exit;
  1982. +        }
  1983. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  1984. +            _PyArg_BadArgument("openssl_shake_128", "argument 'string'", "contiguous buffer", args[0]);
  1985. +            goto exit;
  1986. +        }
  1987. +        if (!--noptargs) {
  1988. +            goto skip_optional_pos;
  1989. +        }
  1990. +    }
  1991. +skip_optional_pos:
  1992. +    if (!noptargs) {
  1993. +        goto skip_optional_kwonly;
  1994. +    }
  1995. +    usedforsecurity = PyObject_IsTrue(args[1]);
  1996. +    if (usedforsecurity < 0) {
  1997. +        goto exit;
  1998. +    }
  1999. +skip_optional_kwonly:
  2000. +    return_value = _hashlib_openssl_shake_128_impl(module, &string, usedforsecurity);
  2001. +
  2002. +exit:
  2003. +    /* Cleanup for string */
  2004. +    if (string.obj) {
  2005. +       PyBuffer_Release(&string);
  2006. +    }
  2007. +
  2008. +    return return_value;
  2009. +}
  2010. +
  2011. +PyDoc_STRVAR(_hashlib_openssl_shake_256__doc__,
  2012. +"openssl_shake_256($module, /, string=None, *, usedforsecurity=True)\n"
  2013. +"--\n"
  2014. +"\n"
  2015. +"Returns a shake-256 variable hash object; optionally initialized with a string.");
  2016. +
  2017. +#define _HASHLIB_OPENSSL_SHAKE_256_METHODDEF    \
  2018. +    {"openssl_shake_256", (PyCFunction)(void(*)(void))_hashlib_openssl_shake_256, METH_FASTCALL|METH_KEYWORDS, _hashlib_openssl_shake_256__doc__},
  2019. +
  2020. +static PyObject *
  2021. +_hashlib_openssl_shake_256_impl(PyObject *module, Py_buffer *string,
  2022. +                                int usedforsecurity);
  2023. +
  2024. +static PyObject *
  2025. +_hashlib_openssl_shake_256(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  2026. +{
  2027. +    PyObject *return_value = NULL;
  2028. +    static const char * const _keywords[] = {"string", "usedforsecurity", NULL};
  2029. +    static _PyArg_Parser _parser = {NULL, _keywords, "openssl_shake_256", 0};
  2030. +    PyObject *argsbuf[2];
  2031. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 0;
  2032. +    Py_buffer string = {NULL, NULL};
  2033. +    int usedforsecurity = 1;
  2034. +
  2035. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 0, 1, 0, argsbuf);
  2036. +    if (!args) {
  2037. +        goto exit;
  2038. +    }
  2039. +    if (!noptargs) {
  2040. +        goto skip_optional_pos;
  2041. +    }
  2042. +    if (args[0]) {
  2043. +        if (PyObject_GetBuffer(args[0], &string, PyBUF_SIMPLE) != 0) {
  2044. +            goto exit;
  2045. +        }
  2046. +        if (!PyBuffer_IsContiguous(&string, 'C')) {
  2047. +            _PyArg_BadArgument("openssl_shake_256", "argument 'string'", "contiguous buffer", args[0]);
  2048. +            goto exit;
  2049. +        }
  2050. +        if (!--noptargs) {
  2051. +            goto skip_optional_pos;
  2052. +        }
  2053. +    }
  2054. +skip_optional_pos:
  2055. +    if (!noptargs) {
  2056. +        goto skip_optional_kwonly;
  2057. +    }
  2058. +    usedforsecurity = PyObject_IsTrue(args[1]);
  2059. +    if (usedforsecurity < 0) {
  2060. +        goto exit;
  2061. +    }
  2062. +skip_optional_kwonly:
  2063. +    return_value = _hashlib_openssl_shake_256_impl(module, &string, usedforsecurity);
  2064. +
  2065. +exit:
  2066. +    /* Cleanup for string */
  2067. +    if (string.obj) {
  2068. +       PyBuffer_Release(&string);
  2069. +    }
  2070. +
  2071. +    return return_value;
  2072. +}
  2073. +
  2074. +PyDoc_STRVAR(_hashlib_compare_digest__doc__,
  2075. +"compare_digest($module, a, b, /)\n"
  2076. +"--\n"
  2077. +"\n"
  2078. +"Return \'a == b\'.\n"
  2079. +"\n"
  2080. +"This function uses an approach designed to prevent\n"
  2081. +"timing analysis, making it appropriate for cryptography.\n"
  2082. +"\n"
  2083. +"a and b must both be of the same type: either str (ASCII only),\n"
  2084. +"or any bytes-like object.\n"
  2085. +"\n"
  2086. +"Note: If a and b are of different lengths, or if an error occurs,\n"
  2087. +"a timing attack could theoretically reveal information about the\n"
  2088. +"types and lengths of a and b--but not their values.");
  2089. +
  2090. +#define _HASHLIB_COMPARE_DIGEST_METHODDEF    \
  2091. +    {"compare_digest", (PyCFunction)(void(*)(void))_hashlib_compare_digest, METH_FASTCALL, _hashlib_compare_digest__doc__},
  2092. +
  2093. +static PyObject *
  2094. +_hashlib_compare_digest_impl(PyObject *module, PyObject *a, PyObject *b);
  2095. +
  2096. +static PyObject *
  2097. +_hashlib_compare_digest(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
  2098. +{
  2099. +    PyObject *return_value = NULL;
  2100. +    PyObject *a;
  2101. +    PyObject *b;
  2102. +
  2103. +    if (!_PyArg_CheckPositional("compare_digest", nargs, 2, 2)) {
  2104. +        goto exit;
  2105. +    }
  2106. +    a = args[0];
  2107. +    b = args[1];
  2108. +    return_value = _hashlib_compare_digest_impl(module, a, b);
  2109. +
  2110. +exit:
  2111. +    return return_value;
  2112. +}
  2113. +
  2114. +PyDoc_STRVAR(_hashlib_hmac_singleshot__doc__,
  2115. +"hmac_digest($module, /, key, msg, digest)\n"
  2116. +"--\n"
  2117. +"\n"
  2118. +"Single-shot HMAC.");
  2119. +
  2120. +#define _HASHLIB_HMAC_SINGLESHOT_METHODDEF    \
  2121. +    {"hmac_digest", (PyCFunction)(void(*)(void))_hashlib_hmac_singleshot, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_singleshot__doc__},
  2122. +
  2123. +static PyObject *
  2124. +_hashlib_hmac_singleshot_impl(PyObject *module, Py_buffer *key,
  2125. +                              Py_buffer *msg, const char *digest);
  2126. +
  2127. +static PyObject *
  2128. +_hashlib_hmac_singleshot(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  2129. +{
  2130. +    PyObject *return_value = NULL;
  2131. +    static const char * const _keywords[] = {"key", "msg", "digest", NULL};
  2132. +    static _PyArg_Parser _parser = {NULL, _keywords, "hmac_digest", 0};
  2133. +    PyObject *argsbuf[3];
  2134. +    Py_buffer key = {NULL, NULL};
  2135. +    Py_buffer msg = {NULL, NULL};
  2136. +    const char *digest;
  2137. +
  2138. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 3, 3, 0, argsbuf);
  2139. +    if (!args) {
  2140. +        goto exit;
  2141. +    }
  2142. +    if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
  2143. +        goto exit;
  2144. +    }
  2145. +    if (!PyBuffer_IsContiguous(&key, 'C')) {
  2146. +        _PyArg_BadArgument("hmac_digest", "argument 'key'", "contiguous buffer", args[0]);
  2147. +        goto exit;
  2148. +    }
  2149. +    if (PyObject_GetBuffer(args[1], &msg, PyBUF_SIMPLE) != 0) {
  2150. +        goto exit;
  2151. +    }
  2152. +    if (!PyBuffer_IsContiguous(&msg, 'C')) {
  2153. +        _PyArg_BadArgument("hmac_digest", "argument 'msg'", "contiguous buffer", args[1]);
  2154. +        goto exit;
  2155. +    }
  2156. +    if (!PyUnicode_Check(args[2])) {
  2157. +        _PyArg_BadArgument("hmac_digest", "argument 'digest'", "str", args[2]);
  2158. +        goto exit;
  2159. +    }
  2160. +    Py_ssize_t digest_length;
  2161. +    digest = PyUnicode_AsUTF8AndSize(args[2], &digest_length);
  2162. +    if (digest == NULL) {
  2163. +        goto exit;
  2164. +    }
  2165. +    if (strlen(digest) != (size_t)digest_length) {
  2166. +        PyErr_SetString(PyExc_ValueError, "embedded null character");
  2167. +        goto exit;
  2168. +    }
  2169. +    return_value = _hashlib_hmac_singleshot_impl(module, &key, &msg, digest);
  2170. +
  2171. +exit:
  2172. +    /* Cleanup for key */
  2173. +    if (key.obj) {
  2174. +       PyBuffer_Release(&key);
  2175. +    }
  2176. +    /* Cleanup for msg */
  2177. +    if (msg.obj) {
  2178. +       PyBuffer_Release(&msg);
  2179. +    }
  2180. +
  2181. +    return return_value;
  2182. +}
  2183. +
  2184. +PyDoc_STRVAR(_hashlib_hmac_new__doc__,
  2185. +"hmac_new($module, /, key, msg=None, digestmod=None)\n"
  2186. +"--\n"
  2187. +"\n"
  2188. +"Return a new hmac object.");
  2189. +
  2190. +#define _HASHLIB_HMAC_NEW_METHODDEF    \
  2191. +    {"hmac_new", (PyCFunction)(void(*)(void))_hashlib_hmac_new, METH_FASTCALL|METH_KEYWORDS, _hashlib_hmac_new__doc__},
  2192. +
  2193. +static PyObject *
  2194. +_hashlib_hmac_new_impl(PyObject *module, Py_buffer *key, Py_buffer *msg,
  2195. +                       const char *digestmod);
  2196. +
  2197. +static PyObject *
  2198. +_hashlib_hmac_new(PyObject *module, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
  2199. +{
  2200. +    PyObject *return_value = NULL;
  2201. +    static const char * const _keywords[] = {"key", "msg", "digestmod", NULL};
  2202. +    static _PyArg_Parser _parser = {NULL, _keywords, "hmac_new", 0};
  2203. +    PyObject *argsbuf[3];
  2204. +    Py_ssize_t noptargs = nargs + (kwnames ? PyTuple_GET_SIZE(kwnames) : 0) - 1;
  2205. +    Py_buffer key = {NULL, NULL};
  2206. +    Py_buffer msg = {NULL, NULL};
  2207. +    const char *digestmod = NULL;
  2208. +
  2209. +    args = _PyArg_UnpackKeywords(args, nargs, NULL, kwnames, &_parser, 1, 3, 0, argsbuf);
  2210. +    if (!args) {
  2211. +        goto exit;
  2212. +    }
  2213. +    if (PyObject_GetBuffer(args[0], &key, PyBUF_SIMPLE) != 0) {
  2214. +        goto exit;
  2215. +    }
  2216. +    if (!PyBuffer_IsContiguous(&key, 'C')) {
  2217. +        _PyArg_BadArgument("hmac_new", "argument 'key'", "contiguous buffer", args[0]);
  2218. +        goto exit;
  2219. +    }
  2220. +    if (!noptargs) {
  2221. +        goto skip_optional_pos;
  2222. +    }
  2223. +    if (args[1]) {
  2224. +        if (PyObject_GetBuffer(args[1], &msg, PyBUF_SIMPLE) != 0) {
  2225. +            goto exit;
  2226. +        }
  2227. +        if (!PyBuffer_IsContiguous(&msg, 'C')) {
  2228. +            _PyArg_BadArgument("hmac_new", "argument 'msg'", "contiguous buffer", args[1]);
  2229. +            goto exit;
  2230. +        }
  2231. +        if (!--noptargs) {
  2232. +            goto skip_optional_pos;
  2233. +        }
  2234. +    }
  2235. +    if (!PyUnicode_Check(args[2])) {
  2236. +        _PyArg_BadArgument("hmac_new", "argument 'digestmod'", "str", args[2]);
  2237. +        goto exit;
  2238. +    }
  2239. +    Py_ssize_t digestmod_length;
  2240. +    digestmod = PyUnicode_AsUTF8AndSize(args[2], &digestmod_length);
  2241. +    if (digestmod == NULL) {
  2242. +        goto exit;
  2243. +    }
  2244. +    if (strlen(digestmod) != (size_t)digestmod_length) {
  2245. +        PyErr_SetString(PyExc_ValueError, "embedded null character");
  2246. +        goto exit;
  2247. +    }
  2248. +skip_optional_pos:
  2249. +    return_value = _hashlib_hmac_new_impl(module, &key, &msg, digestmod);
  2250. +
  2251. +exit:
  2252. +    /* Cleanup for key */
  2253. +    if (key.obj) {
  2254. +       PyBuffer_Release(&key);
  2255. +    }
  2256. +    /* Cleanup for msg */
  2257. +    if (msg.obj) {
  2258. +       PyBuffer_Release(&msg);
  2259. +    }
  2260. +
  2261. +    return return_value;
  2262. +}
  2263. +/*[clinic end generated code: output=b4705bad5ece43e9 input=a9049054013a1b77]*/
  2264. -- 
  2265. 2.32.0