gh-155733: validate keyword keys in operator.methodcaller and functools.partial

Author: pranavchoudhary-tech

Lib/test/test_functools.py

@@ -160,6 +160,14 @@ def test_keyword(self):
             empty, got = p(x=None)
             self.assertTrue(expected == got and empty == ())
 
+    def test_non_string_keywords(self):
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            self.partial(capture, **{1: 'x'})
+        p = self.partial(capture)
+        p.keywords[1] = 'x'
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            p()
+
     def test_no_side_effects(self):
         # make sure there are no side effects that affect subsequent calls
         p = self.partial(capture, 0, a=1)

Lib/test/test_operator.py

@@ -511,6 +511,11 @@ def return_arguments(self, *args, **kwds):
         f = operator.methodcaller('return_arguments', *many_positional_arguments, **many_kw_arguments)
         self.assertEqual(f(a), (many_positional_arguments, many_kw_arguments))
 
+    def test_non_string_keywords(self):
+        operator = self.module
+        with self.assertRaisesRegex(TypeError, "keywords must be strings"):
+            operator.methodcaller('x', **{1: 'x'})
+
     def test_inplace(self):
         operator = self.module
         class C(object):

Modules/_functoolsmodule.c

@@ -190,11 +190,16 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
         return NULL;
     }
 
-    /* keyword Placeholder prohibition */
+    /* keyword Placeholder prohibition and key type validation */
     if (kw != NULL) {
         PyObject *key, *val;
         Py_ssize_t pos = 0;
         while (PyDict_Next(kw, &pos, &key, &val)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keywords must be strings");
+                return NULL;
+            }
             if (val == phold) {
                 PyErr_SetString(PyExc_TypeError,
                                 "Placeholder cannot be passed as a keyword argument");
@@ -493,18 +498,27 @@ partial_vectorcall(PyObject *self, PyObject *const *args,
             PyTuple_SET_ITEM(tot_kwnames, pto_nkwds + i, key);
         }
 
-        /* Copy pto_keywords with overlapping call keywords merged
-         * Note, tail is already coppied. */
         Py_ssize_t pos = 0, i = 0;
         PyObject *keyword_dict = n_merges ? pto_kw_merged : pto->kw;
+        int valid_keys = 1;
         Py_BEGIN_CRITICAL_SECTION(keyword_dict);
         while (PyDict_Next(keyword_dict, &pos, &key, &val)) {
+            if (!PyUnicode_Check(key)) {
+                valid_keys = 0;
+                break;
+            }
             assert(i < pto_nkwds);
             PyTuple_SET_ITEM(tot_kwnames, i, Py_NewRef(key));
             stack[tot_nargs + i] = val;
             i++;
         }
         Py_END_CRITICAL_SECTION();
+        if (!valid_keys) {
+            PyErr_SetString(PyExc_TypeError, "keywords must be strings");
+            Py_XDECREF(pto_kw_merged);
+            Py_DECREF(tot_kwnames);
+            goto error;
+        }
         assert(i == pto_nkwds);
         Py_XDECREF(pto_kw_merged);
 

Modules/_operator.c

@@ -1705,6 +1705,18 @@ methodcaller_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
+    if (kwds != NULL && PyDict_Check(kwds)) {
+        PyObject *key, *value;
+        Py_ssize_t pos = 0;
+        while (PyDict_Next(kwds, &pos, &key, &value)) {
+            if (!PyUnicode_Check(key)) {
+                PyErr_SetString(PyExc_TypeError,
+                                "keywords must be strings");
+                return NULL;
+            }
+        }
+    }
+
     _operator_state *state = _PyType_GetModuleState(type);
     /* create methodcallerobject structure */
     mc = PyObject_GC_New(methodcallerobject, (PyTypeObject *)state->methodcaller_type);