Jun 22, 2025 · Jun 8, 2025 · Jun 8, 2025 · Jun 8, 2025 · Jun 8, 2025 · Jun 8, 2025
diff --git a/Modules/md5module.c b/Modules/md5module.c
 #include "hashlib.h"
 #include "pycore_strhex.h"              // _Py_strhex()

 /*[clinic input]
 module _md5
 class MD5Type "MD5object *" "&PyType_Type"
 [clinic start generated code]*/
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=6e5261719957a912]*/

 /* The MD5 block size and message digest sizes, in bytes */

 #define MD5_BLOCKSIZE    64
 #define MD5_DIGESTSIZE   16

 #include "_hacl/Hacl_Hash_MD5.h"


 typedef struct {
    PyObject_HEAD
    HASHLIB_LOCK_HEAD
    Hacl_Hash_MD5_state_t *state;
    Hacl_Hash_MD5_state_t *hash_state;
 } MD5object;

 #define _MD5object_CAST(op)     ((MD5object *)(op))

 #include "clinic/md5module.c.h"


 typedef struct {
    PyTypeObject *md5_type;
 }md5module_state;
    PyTypeObject*md5_type;
 }MD5State;

 static inlinemd5module_state*
 get_md5module_state(PyObject *module)
 static inlineMD5State*
 md5_get_state(PyObject *module)
 {
    void *state = PyModule_GetState(module);
    assert(state != NULL);
    return (md5module_state *)state;
    return (MD5State *)state;
 }

 /*[clinic input]
 module _md5
 class MD5Type "MD5object *" "&PyType_Type"
 [clinic start generated code]*/
 /*[clinic end generated code: output=da39a3ee5e6b4b0d input=6e5261719957a912]*/

 #include "clinic/md5module.c.h"

 static MD5object *
 newMD5object(md5module_state *st)
 newMD5object(MD5State *st)
 {
    MD5object *self = PyObject_GC_New(MD5object, st->md5_type);
    if (self == NULL) {
    MD5object *md5 = PyObject_GC_New(MD5object, st->md5_type);
    if (!md5) {
        return NULL;
    }
    HASHLIB_INIT_MUTEX(self);
    PyObject_GC_Track(self);
    return self;
    HASHLIB_INIT_MUTEX(md5);

    PyObject_GC_Track(md5);
    return md5;
 }

 /* Internal methods for a hash object */
 static int
 MD5_traverse(PyObject *op, visitproc visit, void *arg)
 MD5_traverse(PyObject *ptr, visitproc visit, void *arg)
 {
    Py_VISIT(Py_TYPE(op));
    Py_VISIT(Py_TYPE(ptr));
    return 0;
 }

 static void
 MD5_dealloc(PyObject *op)
 {
    MD5object *self = _MD5object_CAST(op);
    Hacl_Hash_MD5_free(self->state);
    MD5object *ptr = _MD5object_CAST(op);
    Hacl_Hash_MD5_free(ptr->hash_state);
    PyTypeObject *tp = Py_TYPE(op);
    PyObject_GC_UnTrack(self);
    PyObject_GC_Del(self);
    PyObject_GC_UnTrack(ptr);
    PyObject_GC_Del(ptr);
    Py_DECREF(tp);
 }


 /* External methods for a hash object */

 /*[clinic input]
 MD5Type_copy_impl(MD5object *self, PyTypeObject *cls)
 /*[clinic end generated code: output=bf055e08244bf5ee input=d89087dcfb2a8620]*/
 {
 md5module_state *st = PyType_GetModuleState(cls);
 MD5State *st = PyType_GetModuleState(cls);

    MD5object *copy = newMD5object(st);
    if (copy == NULL) {
    MD5object *newobj;
    if ((newobj = newMD5object(st)) == NULL) {
        return NULL;
    }

    ENTER_HASHLIB(self);
 copy->state = Hacl_Hash_MD5_copy(self->state);
 newobj->hash_state = Hacl_Hash_MD5_copy(self->hash_state);
    LEAVE_HASHLIB(self);
    if (copy->state == NULL) {
        Py_DECREF(copy);
    if (newobj->hash_state == NULL) {
        Py_DECREF(self);
        return PyErr_NoMemory();
    }
    return (PyObject *)copy;
    return (PyObject *)newobj;
 }

 static void
 md5_digest_compute_cond_lock(MD5object *self, uint8_t *digest)
 {
    ENTER_HASHLIB(self);
    Hacl_Hash_MD5_digest(self->state, digest);
    Hacl_Hash_MD5_digest(self->hash_state, digest);
    LEAVE_HASHLIB(self);
 }

 {
    Py_BEGIN_ALLOW_THREADS
    PyMutex_Lock(&self->mutex); // unconditionally acquire a lock
    _hacl_md5_update(self->state, buf, len);
    _hacl_md5_update(self->hash_state, buf, len);
    PyMutex_Unlock(&self->mutex);
    Py_END_ALLOW_THREADS
 }
 md5_update_state_cond_lock(MD5object *self, uint8_t *buf, Py_ssize_t len)
 {
    ENTER_HASHLIB(self); // conditionally acquire a lock
    _hacl_md5_update(self->state, buf, len);
    _hacl_md5_update(self->hash_state, buf, len);
    LEAVE_HASHLIB(self);
 }

    MD5TYPE_DIGEST_METHODDEF
    MD5TYPE_HEXDIGEST_METHODDEF
    MD5TYPE_UPDATE_METHODDEF
    {NULL, NULL}         /* sentinel */
    {NULL,NULL}         /* sentinel */
 };

 static PyObject *
    {"block_size", MD5_get_block_size, NULL, NULL, NULL},
    {"name", MD5_get_name, NULL, NULL, NULL},
    {"digest_size", md5_get_digest_size, NULL, NULL, NULL},
    {NULL} /*sentinel */
    {NULL}/*Sentinel */
 };

 static PyType_Slot md5_type_slots[] = {
    {Py_tp_dealloc, MD5_dealloc},
    {Py_tp_methods, MD5_methods},
    {Py_tp_getset, MD5_getseters},
    {Py_tp_traverse, MD5_traverse},
    {0,0}
    {0,0}
 };

 static PyType_Spec md5_type_spec = {
    .name = "_md5.md5",
    .basicsize = sizeof(MD5object),
    .basicsize =sizeof(MD5object),
    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_DISALLOW_INSTANTIATION |
              Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_HAVE_GC),
    .slots = md5_type_slots
        return NULL;
    }

 md5module_state *st = get_md5module_state(module);
 MD5object *self =newMD5object(st);
    if (self == NULL) {
 MD5object *new;
 MD5State *st =md5_get_state(module);
    if ((new = newMD5object(st)) == NULL) {
        return NULL;
    }

 self->state = Hacl_Hash_MD5_malloc();
    if (self->state == NULL) {
        Py_DECREF(self);
 new->hash_state = Hacl_Hash_MD5_malloc();
    if (new->hash_state == NULL) {
        Py_DECREF(new);
        return PyErr_NoMemory();
    }

            /* Do not use self->mutex here as this is the constructor
             * where it is not yet possible to have concurrent access. */
            Py_BEGIN_ALLOW_THREADS
            _hacl_md5_update(self->state, buf.buf, buf.len);
            _hacl_md5_update(new->hash_state, buf.buf, buf.len);
            Py_END_ALLOW_THREADS
        }
        else {
            _hacl_md5_update(self->state, buf.buf, buf.len);
            _hacl_md5_update(new->hash_state, buf.buf, buf.len);
        }
        PyBuffer_Release(&buf);
    }

    return (PyObject *)self;
    return (PyObject *)new;

 error:
    Py_XDECREF(self);
    Py_XDECREF(new);
    return NULL;
 }


 static struct PyMethodDef MD5_functions[] = {
    _MD5_MD5_METHODDEF
    {NULL, NULL} /*sentinel */
    {NULL,NULL}/*Sentinel */
 };

 static int
 _md5_traverse(PyObject *module, visitproc visit, void *arg)
 {
 md5module_state *state =get_md5module_state(module);
 MD5State *state =md5_get_state(module);
    Py_VISIT(state->md5_type);
    return 0;
 }

 static int
 _md5_clear(PyObject *module)
 {
 md5module_state *state =get_md5module_state(module);
 MD5State *state =md5_get_state(module);
    Py_CLEAR(state->md5_type);
    return 0;
 }
 static int
 md5_exec(PyObject *m)
 {
 md5module_state *st =get_md5module_state(m);
 MD5State *st =md5_get_state(m);

    st->md5_type = (PyTypeObject *)PyType_FromModuleAndSpec(
        m, &md5_type_spec, NULL);
 static struct PyModuleDef _md5module = {
    PyModuleDef_HEAD_INIT,
    .m_name = "_md5",
    .m_size = sizeof(md5module_state),
    .m_size = sizeof(MD5State),
    .m_methods = MD5_functions,
    .m_slots = _md5_slots,
    .m_traverse = _md5_traverse,
Original file line number	Diff line number	Diff line change
Expand Up		@@ -24,72 +24,76 @@
		#include "hashlib.h"
		#include "pycore_strhex.h" // _Py_strhex()

		/*[clinic input]
		module _md5
		class MD5Type "MD5object *" "&PyType_Type"
		[clinic start generated code]*/
		/[clinic end generated code: output=da39a3ee5e6b4b0d input=6e5261719957a912]/

		/* The MD5 block size and message digest sizes, in bytes */

		#define MD5_BLOCKSIZE 64
		#define MD5_DIGESTSIZE 16

		#include "_hacl/Hacl_Hash_MD5.h"


		typedef struct {
		PyObject_HEAD
		HASHLIB_LOCK_HEAD
		Hacl_Hash_MD5_state_t *state;
		Hacl_Hash_MD5_state_t *hash_state;
		} MD5object;

		#define _MD5object_CAST(op) ((MD5object *)(op))

		#include "clinic/md5module.c.h"


		typedef struct {
		PyTypeObject *md5_type;
		}md5module_state;
		PyTypeObject*md5_type;
		}MD5State;

		static inlinemd5module_state*
		get_md5module_state(PyObject *module)
		static inlineMD5State*
		md5_get_state(PyObject *module)
		{
		void *state = PyModule_GetState(module);
		assert(state != NULL);
		return (md5module_state *)state;
		return (MD5State *)state;
		}

		/*[clinic input]
		module _md5
		class MD5Type "MD5object *" "&PyType_Type"
		[clinic start generated code]*/
		/[clinic end generated code: output=da39a3ee5e6b4b0d input=6e5261719957a912]/

		#include "clinic/md5module.c.h"

		static MD5object *
		newMD5object(md5module_state *st)
		newMD5object(MD5State *st)
		{
		MD5object *self = PyObject_GC_New(MD5object, st->md5_type);
		if (self == NULL) {
		MD5object *md5 = PyObject_GC_New(MD5object, st->md5_type);
		if (!md5) {
		return NULL;
		}
		HASHLIB_INIT_MUTEX(self);
		PyObject_GC_Track(self);
		return self;
		HASHLIB_INIT_MUTEX(md5);

		PyObject_GC_Track(md5);
		return md5;
		}

		/* Internal methods for a hash object */
		static int
		MD5_traverse(PyObject op, visitproc visit, void arg)
		MD5_traverse(PyObject ptr, visitproc visit, void arg)
		{
		Py_VISIT(Py_TYPE(op));
		Py_VISIT(Py_TYPE(ptr));
		return 0;
		}

		static void
		MD5_dealloc(PyObject *op)
		{
		MD5object *self = _MD5object_CAST(op);
		Hacl_Hash_MD5_free(self->state);
		MD5object *ptr = _MD5object_CAST(op);
		Hacl_Hash_MD5_free(ptr->hash_state);
		PyTypeObject *tp = Py_TYPE(op);
		PyObject_GC_UnTrack(self);
		PyObject_GC_Del(self);
		PyObject_GC_UnTrack(ptr);
		PyObject_GC_Del(ptr);
		Py_DECREF(tp);
		}


		/* External methods for a hash object */

		/*[clinic input]
Expand All		@@ -104,28 +108,28 @@ static PyObject *
		MD5Type_copy_impl(MD5object self, PyTypeObject cls)
		/[clinic end generated code: output=bf055e08244bf5ee input=d89087dcfb2a8620]/
		{
		md5module_state *st = PyType_GetModuleState(cls);
		MD5State *st = PyType_GetModuleState(cls);

		MD5object *copy = newMD5object(st);
		if (copy == NULL) {
		MD5object *newobj;
		if ((newobj = newMD5object(st)) == NULL) {
		return NULL;
		}

		ENTER_HASHLIB(self);
		copy->state = Hacl_Hash_MD5_copy(self->state);
		newobj->hash_state = Hacl_Hash_MD5_copy(self->hash_state);
		LEAVE_HASHLIB(self);
		if (copy->state == NULL) {
		Py_DECREF(copy);
		if (newobj->hash_state == NULL) {
		Py_DECREF(self);
		return PyErr_NoMemory();
		}
		return (PyObject *)copy;
		return (PyObject *)newobj;
		}

		static void
		md5_digest_compute_cond_lock(MD5object self, uint8_t digest)
		{
		ENTER_HASHLIB(self);
		Hacl_Hash_MD5_digest(self->state, digest);
		Hacl_Hash_MD5_digest(self->hash_state, digest);
		LEAVE_HASHLIB(self);
		}

Expand DownExpand Up		@@ -183,7 +187,7 @@ md5_update_state_with_lock(MD5object self, uint8_t buf, Py_ssize_t len)
		{
		Py_BEGIN_ALLOW_THREADS
		PyMutex_Lock(&self->mutex); // unconditionally acquire a lock
		_hacl_md5_update(self->state, buf, len);
		_hacl_md5_update(self->hash_state, buf, len);
		PyMutex_Unlock(&self->mutex);
		Py_END_ALLOW_THREADS
		}
Expand All		@@ -192,7 +196,7 @@ static void
		md5_update_state_cond_lock(MD5object self, uint8_t buf, Py_ssize_t len)
		{
		ENTER_HASHLIB(self); // conditionally acquire a lock
		_hacl_md5_update(self->state, buf, len);
		_hacl_md5_update(self->hash_state, buf, len);
		LEAVE_HASHLIB(self);
		}

Expand DownExpand Up		@@ -240,7 +244,7 @@ static PyMethodDef MD5_methods[] = {
		MD5TYPE_DIGEST_METHODDEF
		MD5TYPE_HEXDIGEST_METHODDEF
		MD5TYPE_UPDATE_METHODDEF
		{NULL, NULL} /* sentinel */
		{NULL,NULL} /* sentinel */
		};

		static PyObject *
Expand All		@@ -265,20 +269,20 @@ static PyGetSetDef MD5_getseters[] = {
		{"block_size", MD5_get_block_size, NULL, NULL, NULL},
		{"name", MD5_get_name, NULL, NULL, NULL},
		{"digest_size", md5_get_digest_size, NULL, NULL, NULL},
		{NULL} /sentinel /
		{NULL}/Sentinel /
		};

		static PyType_Slot md5_type_slots[] = {
		{Py_tp_dealloc, MD5_dealloc},
		{Py_tp_methods, MD5_methods},
		{Py_tp_getset, MD5_getseters},
		{Py_tp_traverse, MD5_traverse},
		{0,0}
		{0,0}
		};

		static PyType_Spec md5_type_spec = {
		.name = "_md5.md5",
		.basicsize = sizeof(MD5object),
		.basicsize =sizeof(MD5object),
		.flags = (Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_DISALLOW_INSTANTIATION \|
		Py_TPFLAGS_IMMUTABLETYPE \| Py_TPFLAGS_HAVE_GC),
		.slots = md5_type_slots
Expand DownExpand Up		@@ -307,15 +311,15 @@ _md5_md5_impl(PyObject module, PyObject data, int usedforsecurity,
		return NULL;
		}

		md5module_state *st = get_md5module_state(module);
		MD5object *self =newMD5object(st);
		if (self == NULL) {
		MD5object *new;
		MD5State *st =md5_get_state(module);
		if ((new = newMD5object(st)) == NULL) {
		return NULL;
		}

		self->state = Hacl_Hash_MD5_malloc();
		if (self->state == NULL) {
		Py_DECREF(self);
		new->hash_state = Hacl_Hash_MD5_malloc();
		if (new->hash_state == NULL) {
		Py_DECREF(new);
		return PyErr_NoMemory();
		}

Expand All		@@ -326,19 +330,19 @@ _md5_md5_impl(PyObject module, PyObject data, int usedforsecurity,
		/* Do not use self->mutex here as this is the constructor
		* where it is not yet possible to have concurrent access. */
		Py_BEGIN_ALLOW_THREADS
		_hacl_md5_update(self->state, buf.buf, buf.len);
		_hacl_md5_update(new->hash_state, buf.buf, buf.len);
		Py_END_ALLOW_THREADS
		}
		else {
		_hacl_md5_update(self->state, buf.buf, buf.len);
		_hacl_md5_update(new->hash_state, buf.buf, buf.len);
		}
		PyBuffer_Release(&buf);
		}

		return (PyObject *)self;
		return (PyObject *)new;

		error:
		Py_XDECREF(self);
		Py_XDECREF(new);
		return NULL;
		}

Expand All		@@ -347,21 +351,21 @@ _md5_md5_impl(PyObject module, PyObject data, int usedforsecurity,

		static struct PyMethodDef MD5_functions[] = {
		_MD5_MD5_METHODDEF
		{NULL, NULL} /sentinel /
		{NULL,NULL}/Sentinel /
		};

		static int
		_md5_traverse(PyObject module, visitproc visit, void arg)
		{
		md5module_state *state =get_md5module_state(module);
		MD5State *state =md5_get_state(module);
		Py_VISIT(state->md5_type);
		return 0;
		}

		static int
		_md5_clear(PyObject *module)
		{
		md5module_state *state =get_md5module_state(module);
		MD5State *state =md5_get_state(module);
		Py_CLEAR(state->md5_type);
		return 0;
		}
Expand All		@@ -376,7 +380,7 @@ _md5_free(void *module)
		static int
		md5_exec(PyObject *m)
		{
		md5module_state *st =get_md5module_state(m);
		MD5State *st =md5_get_state(m);

		st->md5_type = (PyTypeObject *)PyType_FromModuleAndSpec(
		m, &md5_type_spec, NULL);
Expand All		@@ -402,7 +406,7 @@ static PyModuleDef_Slot _md5_slots[] = {
		static struct PyModuleDef _md5module = {
		PyModuleDef_HEAD_INIT,
		.m_name = "_md5",
		.m_size = sizeof(md5module_state),
		.m_size = sizeof(MD5State),
		.m_methods = MD5_functions,
		.m_slots = _md5_slots,
		.m_traverse = _md5_traverse,
Expand Down