GeezerVison

The World Wide Web, restored to 800 pixels of glory.

GeezerVison is showing github.com — do not guard against empty buffers for now · python/cpython@db57278

File tree

Expand file treeCollapse file tree

Open diff view settings

Filter options

Modules

Expand file treeCollapse file tree

Open diff view settings

Collapse file

`‎Modules/_hashopenssl.c‎`

Copy file name to clipboardExpand all lines: Modules/_hashopenssl.c

+11-13Lines changed: 11 additions & 13 deletions

Original file line number	Diff line number	Diff line change
`@@ -800,16 +800,16 @@ static PyObject *`
`800`	`800`	`_hashlib_HASH_update_impl(HASHobject self, PyObject obj)`
`801`	`801`	`/[clinic end generated code: output=62ad989754946b86 input=aa1ce20e3f92ceb6]/`
`802`	`802`	`{`
`803`		`- int rc;`
	`803`	`+ int result;`
`804`	`804`	`Py_buffer view;`
`805`	`805`	`GET_BUFFER_VIEW_OR_ERROUT(obj, &view);`
`806`	`806`	`Py_BEGIN_ALLOW_THREADS`
`807`	`807`	`HASHLIB_ACQUIRE_LOCK(self);`
`808`		`- rc = _hashlib_HASH_hash(self, view.buf, view.len);`
	`808`	`+ result = _hashlib_HASH_hash(self, view.buf, view.len);`
`809`	`809`	`HASHLIB_RELEASE_LOCK(self);`
`810`	`810`	`Py_END_ALLOW_THREADS`
`811`	`811`	`PyBuffer_Release(&view);`
`812`		`- return rc < 0 ? NULL : Py_None;`
	`812`	`+ return result < 0 ? NULL : Py_None;`
`813`	`813`	`}`
`814`	`814`
`815`	`815`	`static PyMethodDef HASH_methods[] = {`
`@@ -1806,19 +1806,17 @@ _hashlib_hmac_digest_size(HMACobject *self)`
`1806`	`1806`	`static int`
`1807`	`1807`	`_hmac_update(HMACobject self, PyObject obj)`
`1808`	`1808`	`{`
`1809`		`- int r = 1;`
	`1809`	`+ int r;`
`1810`	`1810`	`Py_buffer view = {0};`
`1811`	`1811`
`1812`	`1812`	`GET_BUFFER_VIEW_OR_ERROR(obj, &view, return 0);`
`1813`		`- if (view.len > 0) {`
`1814`		`- Py_BEGIN_ALLOW_THREADS`
`1815`		`- HASHLIB_ACQUIRE_LOCK(self);`
`1816`		`- r = HMAC_Update(self->ctx,`
`1817`		`- (const unsigned char *)view.buf,`
`1818`		`- (size_t)view.len);`
`1819`		`- HASHLIB_RELEASE_LOCK(self);`
`1820`		`- Py_END_ALLOW_THREADS`
`1821`		`- }`
	`1813`	`+ Py_BEGIN_ALLOW_THREADS`
	`1814`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`1815`	`+ r = HMAC_Update(self->ctx,`
	`1816`	`+ (const unsigned char *)view.buf,`
	`1817`	`+ (size_t)view.len);`
	`1818`	`+ HASHLIB_RELEASE_LOCK(self);`
	`1819`	`+ Py_END_ALLOW_THREADS`
`1822`	`1820`	`PyBuffer_Release(&view);`
`1823`	`1821`
`1824`	`1822`	`if (r == 0) {`

Collapse file

`‎Modules/blake2module.c‎`

Copy file name to clipboardExpand all lines: Modules/blake2module.c

+8-12Lines changed: 8 additions & 12 deletions

Original file line number	Diff line number	Diff line change
`@@ -642,11 +642,9 @@ py_blake2_new(PyTypeObject type, PyObject data, int digest_size,`
`642`	`642`	`if (data != NULL) {`
`643`	`643`	`Py_buffer buf;`
`644`	`644`	`GET_BUFFER_VIEW_OR_ERROR(data, &buf, goto error);`
`645`		`- if (buf.len > 0) {`
`646`		`- Py_BEGIN_ALLOW_THREADS`
`647`		`- blake2_update_state_unlocked(self, buf.buf, buf.len);`
`648`		`- Py_END_ALLOW_THREADS`
`649`		`- }`
	`645`	`+ Py_BEGIN_ALLOW_THREADS`
	`646`	`+ blake2_update_state_unlocked(self, buf.buf, buf.len);`
	`647`	`+ Py_END_ALLOW_THREADS`
`650`	`648`	`PyBuffer_Release(&buf);`
`651`	`649`	`}`
`652`	`650`
`@@ -819,13 +817,11 @@ _blake2_blake2b_update_impl(Blake2Object self, PyObject data)`
`819`	`817`	`{`
`820`	`818`	`Py_buffer buf;`
`821`	`819`	`GET_BUFFER_VIEW_OR_ERROUT(data, &buf);`
`822`		`- if (buf.len > 0) {`
`823`		`- Py_BEGIN_ALLOW_THREADS`
`824`		`- HASHLIB_ACQUIRE_LOCK(self);`
`825`		`- blake2_update_state_unlocked(self, buf.buf, buf.len);`
`826`		`- HASHLIB_RELEASE_LOCK(self);`
`827`		`- Py_END_ALLOW_THREADS`
`828`		`- }`
	`820`	`+ Py_BEGIN_ALLOW_THREADS`
	`821`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`822`	`+ blake2_update_state_unlocked(self, buf.buf, buf.len);`
	`823`	`+ HASHLIB_RELEASE_LOCK(self);`
	`824`	`+ Py_END_ALLOW_THREADS`
`829`	`825`	`PyBuffer_Release(&buf);`
`830`	`826`	`Py_RETURN_NONE;`
`831`	`827`	`}`

Collapse file

`‎Modules/hmacmodule.c‎`

Copy file name to clipboardExpand all lines: Modules/hmacmodule.c

+10-15Lines changed: 10 additions & 15 deletions

Original file line number	Diff line number	Diff line change
`@@ -739,15 +739,12 @@ hmac_feed_initial_data(HMACObject self, uint8_t msg, Py_ssize_t len)`
`739`	`739`	`{`
`740`	`740`	`assert(self->name != NULL);`
`741`	`741`	`assert(self->state != NULL);`
`742`		`- assert(len >= 0);`
`743`	`742`	`int rc = 0;`
`744`		`- if (len > 0) {`
`745`		`- /* Do not use self->mutex here as this is the constructor`
`746`		`- * where it is not yet possible to have concurrent access. */`
`747`		`- Py_BEGIN_ALLOW_THREADS`
`748`		`- rc = _hacl_hmac_state_update(self->state, msg, len);`
`749`		`- Py_END_ALLOW_THREADS`
`750`		`- }`
	`743`	`+ /* Do not use self->mutex here as this is the constructor`
	`744`	`+ * where it is not yet possible to have concurrent access. */`
	`745`	`+ Py_BEGIN_ALLOW_THREADS`
	`746`	`+ rc = _hacl_hmac_state_update(self->state, msg, len);`
	`747`	`+ Py_END_ALLOW_THREADS`
`751`	`748`	`return rc;`
`752`	`749`	`}`
`753`	`750`
`@@ -906,13 +903,11 @@ _hmac_HMAC_update_impl(HMACObject self, PyObject msgobj)`
`906`	`903`	`int rc = 0;`
`907`	`904`	`Py_buffer msg;`
`908`	`905`	`GET_BUFFER_VIEW_OR_ERROUT(msgobj, &msg);`
`909`		`- if (msg.len > 0) {`
`910`		`- Py_BEGIN_ALLOW_THREADS`
`911`		`- HASHLIB_ACQUIRE_LOCK(self);`
`912`		`- rc = _hacl_hmac_state_update(self->state, msg.buf, msg.len);`
`913`		`- HASHLIB_RELEASE_LOCK(self);`
`914`		`- Py_END_ALLOW_THREADS`
`915`		`- }`
	`906`	`+ Py_BEGIN_ALLOW_THREADS`
	`907`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`908`	`+ rc = _hacl_hmac_state_update(self->state, msg.buf, msg.len);`
	`909`	`+ HASHLIB_RELEASE_LOCK(self);`
	`910`	`+ Py_END_ALLOW_THREADS`
`916`	`911`	`PyBuffer_Release(&msg);`
`917`	`912`	`return rc < 0 ? NULL : Py_None;`
`918`	`913`	`}`

Collapse file

`‎Modules/md5module.c‎`

Copy file name to clipboardExpand all lines: Modules/md5module.c

+11-17Lines changed: 11 additions & 17 deletions

Original file line number	Diff line number	Diff line change
`@@ -123,14 +123,6 @@ MD5Type_copy_impl(MD5object self, PyTypeObject cls)`
`123`	`123`	`return (PyObject *)newobj;`
`124`	`124`	`}`
`125`	`125`
`126`		`-static void`
`127`		`-md5_digest_compute_with_lock(MD5object self, uint8_t digest)`
`128`		`-{`
`129`		`- HASHLIB_ACQUIRE_LOCK(self);`
`130`		`- Hacl_Hash_MD5_digest(self->hash_state, digest);`
`131`		`- HASHLIB_RELEASE_LOCK(self);`
`132`		`-}`
`133`		`-`
`134`	`126`	`/*[clinic input]`
`135`	`127`	`MD5Type.digest`
`136`	`128`
`@@ -142,7 +134,9 @@ MD5Type_digest_impl(MD5object *self)`
`142`	`134`	`/[clinic end generated code: output=eb691dc4190a07ec input=bc0c4397c2994be6]/`
`143`	`135`	`{`
`144`	`136`	`uint8_t digest[MD5_DIGESTSIZE];`
`145`		`- md5_digest_compute_with_lock(self, digest);`
	`137`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`138`	`+ Hacl_Hash_MD5_digest(self->hash_state, digest);`
	`139`	`+ HASHLIB_RELEASE_LOCK(self);`
`146`	`140`	`return PyBytes_FromStringAndSize((const char *)digest, MD5_DIGESTSIZE);`
`147`	`141`	`}`
`148`	`142`
`@@ -157,7 +151,9 @@ MD5Type_hexdigest_impl(MD5object *self)`
`157`	`151`	`/[clinic end generated code: output=17badced1f3ac932 input=b60b19de644798dd]/`
`158`	`152`	`{`
`159`	`153`	`uint8_t digest[MD5_DIGESTSIZE];`
`160`		`- md5_digest_compute_with_lock(self, digest);`
	`154`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`155`	`+ Hacl_Hash_MD5_digest(self->hash_state, digest);`
	`156`	`+ HASHLIB_RELEASE_LOCK(self);`
`161`	`157`	`return _Py_strhex((const char *)digest, MD5_DIGESTSIZE);`
`162`	`158`	`}`
`163`	`159`
`@@ -197,13 +193,11 @@ MD5Type_update_impl(MD5object self, PyObject obj)`
`197`	`193`	`{`
`198`	`194`	`Py_buffer buf;`
`199`	`195`	`GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);`
`200`		`- if (buf.len > 0) {`
`201`		`- Py_BEGIN_ALLOW_THREADS`
`202`		`- HASHLIB_ACQUIRE_LOCK(self);`
`203`		`- _hacl_md5_state_update(self->hash_state, buf.buf, buf.len);`
`204`		`- HASHLIB_RELEASE_LOCK(self);`
`205`		`- Py_END_ALLOW_THREADS`
`206`		`- }`
	`196`	`+ Py_BEGIN_ALLOW_THREADS`
	`197`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`198`	`+ _hacl_md5_state_update(self->hash_state, buf.buf, buf.len);`
	`199`	`+ HASHLIB_RELEASE_LOCK(self);`
	`200`	`+ Py_END_ALLOW_THREADS`
`207`	`201`	`PyBuffer_Release(&buf);`
`208`	`202`	`Py_RETURN_NONE;`
`209`	`203`	`}`

Collapse file

`‎Modules/sha1module.c‎`

Copy file name to clipboardExpand all lines: Modules/sha1module.c

+5-7Lines changed: 5 additions & 7 deletions

Original file line number	Diff line number	Diff line change
`@@ -196,13 +196,11 @@ SHA1Type_update_impl(SHA1object self, PyObject obj)`
`196`	`196`	`{`
`197`	`197`	`Py_buffer buf;`
`198`	`198`	`GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);`
`199`		`- if (buf.len > 0) {`
`200`		`- Py_BEGIN_ALLOW_THREADS`
`201`		`- HASHLIB_ACQUIRE_LOCK(self);`
`202`		`- _hacl_sha1_state_update(self->hash_state, buf.buf, buf.len);`
`203`		`- HASHLIB_RELEASE_LOCK(self);`
`204`		`- Py_END_ALLOW_THREADS`
`205`		`- }`
	`199`	`+ Py_BEGIN_ALLOW_THREADS`
	`200`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`201`	`+ _hacl_sha1_state_update(self->hash_state, buf.buf, buf.len);`
	`202`	`+ HASHLIB_RELEASE_LOCK(self);`
	`203`	`+ Py_END_ALLOW_THREADS`
`206`	`204`	`PyBuffer_Release(&buf);`
`207`	`205`	`Py_RETURN_NONE;`
`208`	`206`	`}`

Collapse file

`‎Modules/sha2module.c‎`

Copy file name to clipboardExpand all lines: Modules/sha2module.c

+13-19Lines changed: 13 additions & 19 deletions

Original file line number	Diff line number	Diff line change
`@@ -406,13 +406,11 @@ SHA256Type_update_impl(SHA256object self, PyObject obj)`
`406`	`406`	`{`
`407`	`407`	`Py_buffer buf;`
`408`	`408`	`GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);`
`409`		`- if (buf.len > 0) {`
`410`		`- Py_BEGIN_ALLOW_THREADS`
`411`		`- HASHLIB_ACQUIRE_LOCK(self);`
`412`		`- _hacl_sha2_state_update_256(self->state, buf.buf, buf.len);`
`413`		`- HASHLIB_RELEASE_LOCK(self);`
`414`		`- Py_END_ALLOW_THREADS`
`415`		`- }`
	`409`	`+ Py_BEGIN_ALLOW_THREADS`
	`410`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`411`	`+ _hacl_sha2_state_update_256(self->state, buf.buf, buf.len);`
	`412`	`+ HASHLIB_RELEASE_LOCK(self);`
	`413`	`+ Py_END_ALLOW_THREADS`
`416`	`414`	`PyBuffer_Release(&buf);`
`417`	`415`	`Py_RETURN_NONE;`
`418`	`416`	`}`
`@@ -432,13 +430,11 @@ SHA512Type_update_impl(SHA512object self, PyObject obj)`
`432`	`430`	`{`
`433`	`431`	`Py_buffer buf;`
`434`	`432`	`GET_BUFFER_VIEW_OR_ERROUT(obj, &buf);`
`435`		`- if (buf.len > 0) {`
`436`		`- Py_BEGIN_ALLOW_THREADS`
`437`		`- HASHLIB_ACQUIRE_LOCK(self);`
`438`		`- _hacl_sha2_state_update_512(self->state, buf.buf, buf.len);`
`439`		`- HASHLIB_RELEASE_LOCK(self);`
`440`		`- Py_END_ALLOW_THREADS`
`441`		`- }`
	`433`	`+ Py_BEGIN_ALLOW_THREADS`
	`434`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`435`	`+ _hacl_sha2_state_update_512(self->state, buf.buf, buf.len);`
	`436`	`+ HASHLIB_RELEASE_LOCK(self);`
	`437`	`+ Py_END_ALLOW_THREADS`
`442`	`438`	`PyBuffer_Release(&buf);`
`443`	`439`	`Py_RETURN_NONE;`
`444`	`440`	`}`
`@@ -793,11 +789,9 @@ _sha2_sha384_impl(PyObject module, PyObject data, int usedforsecurity,`
`793`	`789`	`if (string) {`
`794`	`790`	`/* Do not use self->mutex here as this is the constructor`
`795`	`791`	`* where it is not yet possible to have concurrent access. */`
`796`		`- if (buf.len > 0) {`
`797`		`- Py_BEGIN_ALLOW_THREADS`
`798`		`- _hacl_sha2_state_update_512(new->state, buf.buf, buf.len);`
`799`		`- Py_END_ALLOW_THREADS`
`800`		`- }`
	`792`	`+ Py_BEGIN_ALLOW_THREADS`
	`793`	`+ _hacl_sha2_state_update_512(new->state, buf.buf, buf.len);`
	`794`	`+ Py_END_ALLOW_THREADS`
`801`	`795`	`PyBuffer_Release(&buf);`
`802`	`796`	`}`
`803`	`797`

Collapse file

`‎Modules/sha3module.c‎`

Copy file name to clipboardExpand all lines: Modules/sha3module.c

+8-12Lines changed: 8 additions & 12 deletions

Original file line number	Diff line number	Diff line change
`@@ -162,11 +162,9 @@ py_sha3_new_impl(PyTypeObject type, PyObject data_obj, int usedforsecurity,`
`162`	`162`	`GET_BUFFER_VIEW_OR_ERROR(data, &buf, goto error);`
`163`	`163`	`/* Do not use self->mutex here as this is the constructor`
`164`	`164`	`* where it is not yet possible to have concurrent access. */`
`165`		`- if (buf.len > 0) {`
`166`		`- Py_BEGIN_ALLOW_THREADS`
`167`		`- sha3_update(self->hash_state, buf.buf, buf.len);`
`168`		`- Py_END_ALLOW_THREADS`
`169`		`- }`
	`165`	`+ Py_BEGIN_ALLOW_THREADS`
	`166`	`+ sha3_update(self->hash_state, buf.buf, buf.len);`
	`167`	`+ Py_END_ALLOW_THREADS`
`170`	`168`	`}`
`171`	`169`
`172`	`170`	`PyBuffer_Release(&buf);`
`@@ -298,13 +296,11 @@ _sha3_sha3_224_update_impl(SHA3object self, PyObject data)`
`298`	`296`	`{`
`299`	`297`	`Py_buffer buf;`
`300`	`298`	`GET_BUFFER_VIEW_OR_ERROUT(data, &buf);`
`301`		`- if (buf.len > 0) {`
`302`		`- Py_BEGIN_ALLOW_THREADS`
`303`		`- HASHLIB_ACQUIRE_LOCK(self);`
`304`		`- sha3_update(self->hash_state, buf.buf, buf.len);`
`305`		`- HASHLIB_RELEASE_LOCK(self);`
`306`		`- Py_END_ALLOW_THREADS`
`307`		`- }`
	`299`	`+ Py_BEGIN_ALLOW_THREADS`
	`300`	`+ HASHLIB_ACQUIRE_LOCK(self);`
	`301`	`+ sha3_update(self->hash_state, buf.buf, buf.len);`
	`302`	`+ HASHLIB_RELEASE_LOCK(self);`
	`303`	`+ Py_END_ALLOW_THREADS`
`308`	`304`	`PyBuffer_Release(&buf);`
`309`	`305`	`Py_RETURN_NONE;`
`310`	`306`	`}`

0 commit comments

Comments

0 (0)

You are visitor 01402520 — GeezerVison does not store the pages you look up.
Best viewed with Netscape Navigator 4.7 or Internet Explorer 6 at 800×600. No cookies required.