This is an archive of the discontinued Mercurial Phabricator instance.

Differential D7879

sha1dc: use buffer protocol when parsing arguments
ClosedPublic

Authored by indygreg on Jan 14 2020, 10:03 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHGdc9b53482689: sha1dc: use buffer protocol when parsing arguments
Summary

Without this, functions won't accept bytearray, memoryview,
or other types that can be exposed as bytes to the C API.
The most resilient way to obtain a bytes-like object from
the C API is using the Py_buffer interface.

This commit converts use of s#/y# to s*/y* and uses
Py_buffer for accessing the underlying bytes array.

I checked how hashlib is implemented in CPython and the
the implementation agrees with its use of the Py_buffer
interface as well as using BufferError in cases of bad
buffer types. Sadly, there's no good way to test for
ndim > 1 without writing our own C-backed Python type.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

indygreg created this revision.Jan 14 2020, 10:03 PM
indygreg added a commit: rHGdc9b53482689: sha1dc: use buffer protocol when parsing arguments.Jan 15 2020, 8:52 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGdc9b53482689: sha1dc: use buffer protocol when parsing arguments (authored by indygreg). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 19278

mercurial/thirdparty/sha1dc/cext.c

typedef struct { typedef struct {
PyObject_HEAD PyObject_HEAD
SHA1_CTX ctx; SHA1_CTX ctx;
} pysha1ctx; } pysha1ctx;
/* clang-format on */ /* clang-format on */
static int pysha1ctx_init(pysha1ctx *self, PyObject *args) static int pysha1ctx_init(pysha1ctx *self, PyObject *args)
{ {
const char *data = NULL; Py_buffer data;
Py_ssize_t len; data.obj = NULL;
SHA1DCInit(&(self->ctx)); SHA1DCInit(&(self->ctx));
/* We don't want "safe" sha1s, wherein sha1dc can give you a /* We don't want "safe" sha1s, wherein sha1dc can give you a
different hash for something that's trying to give you a different hash for something that's trying to give you a
collision. We just want to detect collisions. collision. We just want to detect collisions.
*/ */
SHA1DCSetSafeHash(&(self->ctx), 0); SHA1DCSetSafeHash(&(self->ctx), 0);
if (!PyArg_ParseTuple(args, PY23("|s#", "|y#"), &data, &len)) { if (!PyArg_ParseTuple(args, PY23("|s*", "|y*"), &data)) {
return -1; return -1;
} }
if (data) { if (data.obj) {
SHA1DCUpdate(&(self->ctx), data, len); if (!PyBuffer_IsContiguous(&data, 'C') || data.ndim > 1) {
PyErr_SetString(PyExc_BufferError,
"buffer must be contiguous and single dimension");
PyBuffer_Release(&data);
return -1;
}
SHA1DCUpdate(&(self->ctx), data.buf, data.len);
PyBuffer_Release(&data);
} }
return 0; return 0;
} }
static void pysha1ctx_dealloc(pysha1ctx *self) static void pysha1ctx_dealloc(pysha1ctx *self)
{ {
PyObject_Del(self); PyObject_Del(self);
} }
static PyObject *pysha1ctx_update(pysha1ctx *self, PyObject *args) static PyObject *pysha1ctx_update(pysha1ctx *self, PyObject *args)
{ {
const char *data; Py_buffer data;
Py_ssize_t len; if (!PyArg_ParseTuple(args, PY23("s*", "y*"), &data)) {
if (!PyArg_ParseTuple(args, PY23("s#", "y#"), &data, &len)) { return NULL;
}
if (!PyBuffer_IsContiguous(&data, 'C') || data.ndim > 1) {
PyErr_SetString(PyExc_BufferError,
"buffer must be contiguous and single dimension");
PyBuffer_Release(&data);
return NULL; return NULL;
} }
SHA1DCUpdate(&(self->ctx), data, len); SHA1DCUpdate(&(self->ctx), data.buf, data.len);
PyBuffer_Release(&data);
Py_RETURN_NONE; Py_RETURN_NONE;
} }
/* it is intentional that this take a ctx by value, as that clones the /* it is intentional that this take a ctx by value, as that clones the
context so we can keep using .update() without poisoning the state context so we can keep using .update() without poisoning the state
with padding. with padding.
*/ */
static int finalize(SHA1_CTX ctx, unsigned char *hash_out) static int finalize(SHA1_CTX ctx, unsigned char *hash_out)

tests/test-hashutil.py

def test_init_hasher(self): def test_init_hasher(self):
h = self.hasher(b'initial string') h = self.hasher(b'initial string')
self.assertEqual( self.assertEqual(
b'\xc9y|n\x1f3S\xa4:\xbaJ\xca,\xc1\x1a\x9e\xb8\xd8\xdd\x86', b'\xc9y|n\x1f3S\xa4:\xbaJ\xca,\xc1\x1a\x9e\xb8\xd8\xdd\x86',
h.digest(), h.digest(),
) )
def test_bytes_like_types(self):
h = self.hasher()
h.update(bytearray(b'foo'))
h.update(memoryview(b'baz'))
self.assertEqual(
'21eb6533733a5e4763acacd1d45a60c2e0e404e1', h.hexdigest()
)
h = self.hasher(bytearray(b'foo'))
h.update(b'baz')
self.assertEqual(
'21eb6533733a5e4763acacd1d45a60c2e0e404e1', h.hexdigest()
)
h = self.hasher(memoryview(b'foo'))
h.update(b'baz')
self.assertEqual(
'21eb6533733a5e4763acacd1d45a60c2e0e404e1', h.hexdigest()
)
class hashlibtests(unittest.TestCase, hashertestsbase): class hashlibtests(unittest.TestCase, hashertestsbase):
hasher = hashlib.sha1 hasher = hashlib.sha1
if sha1dc: if sha1dc:
class sha1dctests(unittest.TestCase, hashertestsbase): class sha1dctests(unittest.TestCase, hashertestsbase):
hasher = sha1dc.sha1 hasher = sha1dc.sha1
if __name__ == '__main__': if __name__ == '__main__':
silenttestrunner.main(__name__) silenttestrunner.main(__name__)