From 674b83ae9dd062c3614e82278675956c6b9c0a9b Mon Sep 17 00:00:00 2001 From: sobolevn Date: Tue, 17 Nov 2026 01:06:04 +0300 Subject: [PATCH 1/3] gh-161767: Fix crash in `PyDict_AsFrozenDictAndClear` on `embedded` values --- Lib/test/test_capi/test_dict.py | 31 +++++++++++++++++++++++++++++++ Objects/dictobject.c | 7 +++++++ 2 files changed, 38 insertions(+) diff --git a/Lib/test/test_capi/test_dict.py b/Lib/test/test_capi/test_dict.py index 9a2e79d4da7e71..e4121e6b11a494 100644 --- a/Lib/test/test_capi/test_dict.py +++ b/Lib/test/test_capi/test_dict.py @@ -635,11 +635,42 @@ class DictSubtype(dict): ... self.assertIs(type(d), DictSubtype) self.assertEqual(d, DictSubtype({})) + # non str keys: + d = {1: 'a', 2: 'b', 3: 'c', None: 'f'} + f = as_frozendict(d) + self.assertIs(type(f), frozendict) + self.assertEqual(f, frozendict({1: 'a', 2: 'b', 3: 'c', None: 'f'})) + self.assertIs(type(d), dict) + self.assertEqual(d, {}) + + d = DictSubtype({1: 'a', 2: 'b', 3: 'c', None: 'f'}) + f = as_frozendict(d) + self.assertIs(type(f), frozendict) + self.assertEqual(f, frozendict({1: 'a', 2: 'b', 3: 'c', None: 'f'})) + self.assertIs(type(d), DictSubtype) + self.assertEqual(d, DictSubtype({})) + + # wrong inputs: for wrong_input in (frozendict(), [], None): with self.subTest(wrong_input=wrong_input): with self.assertRaises(SystemError): as_frozendict(wrong_input) + # gh-161767: check embedded values + class Regular: ... + + for klass in (Regular, _testcapi.ManagedDictType): + with self.subTest(klass=klass): + instance = klass() + instance.key = 'value' + with self.assertRaisesRegex(ValueError, 'embedded values'): + as_frozendict(instance.__dict__) + + self.assertEqual(instance.__dict__, {'key': 'value'}) + # Both of these actions were needed to cause a crash: + instance.other = 'new' + del instance # must not crash + def test_frozendict_check(self): # Test PyFrozenDict_Check() check = _testcapi.frozendict_check diff --git a/Objects/dictobject.c b/Objects/dictobject.c index 5d3edbc4ed9578..f81242820a3d32 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -8700,6 +8700,13 @@ PyDict_AsFrozenDictAndClear(PyObject *dict) return NULL; } + PyDictObject *ma = (PyDictObject*)dict; + if (ma->ma_values && ma->ma_values->embedded) { + PyErr_SetString(PyExc_ValueError, + "can't convert dict with embedded values"); + return NULL; + } + PyObject *res = frozendict_new_untracked(&PyFrozenDict_Type); if (res == NULL) { return NULL; From 70256550e8276db38765623115264bb49040bbfb Mon Sep 17 00:00:00 2001 From: sobolevn Date: Tue, 17 Nov 2026 01:06:04 +0300 Subject: [PATCH 2/3] gh-161767: Fix crash in `PyDict_AsFrozenDictAndClear` on `embedded` values --- Doc/c-api/dict.rst | 2 ++ Lib/test/test_capi/test_dict.py | 31 +++++++++++++++++++++++++++++++ Objects/dictobject.c | 7 +++++++ 3 files changed, 40 insertions(+) diff --git a/Doc/c-api/dict.rst b/Doc/c-api/dict.rst index e986c8b6456b74..cdb3d8fba5af80 100644 --- a/Doc/c-api/dict.rst +++ b/Doc/c-api/dict.rst @@ -526,6 +526,8 @@ Dictionary objects as an argument, prefer :c:func:`PyFrozenDict_New` to leave the source intact. + Does not work for dicts with embedded values. + .. impl-detail:: Works with O(1) complexity. diff --git a/Lib/test/test_capi/test_dict.py b/Lib/test/test_capi/test_dict.py index 9a2e79d4da7e71..e4121e6b11a494 100644 --- a/Lib/test/test_capi/test_dict.py +++ b/Lib/test/test_capi/test_dict.py @@ -635,11 +635,42 @@ class DictSubtype(dict): ... self.assertIs(type(d), DictSubtype) self.assertEqual(d, DictSubtype({})) + # non str keys: + d = {1: 'a', 2: 'b', 3: 'c', None: 'f'} + f = as_frozendict(d) + self.assertIs(type(f), frozendict) + self.assertEqual(f, frozendict({1: 'a', 2: 'b', 3: 'c', None: 'f'})) + self.assertIs(type(d), dict) + self.assertEqual(d, {}) + + d = DictSubtype({1: 'a', 2: 'b', 3: 'c', None: 'f'}) + f = as_frozendict(d) + self.assertIs(type(f), frozendict) + self.assertEqual(f, frozendict({1: 'a', 2: 'b', 3: 'c', None: 'f'})) + self.assertIs(type(d), DictSubtype) + self.assertEqual(d, DictSubtype({})) + + # wrong inputs: for wrong_input in (frozendict(), [], None): with self.subTest(wrong_input=wrong_input): with self.assertRaises(SystemError): as_frozendict(wrong_input) + # gh-161767: check embedded values + class Regular: ... + + for klass in (Regular, _testcapi.ManagedDictType): + with self.subTest(klass=klass): + instance = klass() + instance.key = 'value' + with self.assertRaisesRegex(ValueError, 'embedded values'): + as_frozendict(instance.__dict__) + + self.assertEqual(instance.__dict__, {'key': 'value'}) + # Both of these actions were needed to cause a crash: + instance.other = 'new' + del instance # must not crash + def test_frozendict_check(self): # Test PyFrozenDict_Check() check = _testcapi.frozendict_check diff --git a/Objects/dictobject.c b/Objects/dictobject.c index 5d3edbc4ed9578..f81242820a3d32 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -8700,6 +8700,13 @@ PyDict_AsFrozenDictAndClear(PyObject *dict) return NULL; } + PyDictObject *ma = (PyDictObject*)dict; + if (ma->ma_values && ma->ma_values->embedded) { + PyErr_SetString(PyExc_ValueError, + "can't convert dict with embedded values"); + return NULL; + } + PyObject *res = frozendict_new_untracked(&PyFrozenDict_Type); if (res == NULL) { return NULL; From 6e163b0ae08b0c4cb32edb687c1be578d468c2b2 Mon Sep 17 00:00:00 2001 From: sobolevn Date: Tue, 17 Nov 2026 08:49:42 +0300 Subject: [PATCH 3/3] Address review --- Lib/test/test_capi/test_dict.py | 11 ++++++++--- Objects/dictobject.c | 24 ++++++++++++++---------- 2 files changed, 22 insertions(+), 13 deletions(-) diff --git a/Lib/test/test_capi/test_dict.py b/Lib/test/test_capi/test_dict.py index e4121e6b11a494..4028b56a9cc22c 100644 --- a/Lib/test/test_capi/test_dict.py +++ b/Lib/test/test_capi/test_dict.py @@ -656,14 +656,19 @@ class DictSubtype(dict): ... with self.assertRaises(SystemError): as_frozendict(wrong_input) - # gh-161767: check embedded values + # gh-161767: check type with inline values and dict with embedded values class Regular: ... for klass in (Regular, _testcapi.ManagedDictType): with self.subTest(klass=klass): - instance = klass() + instance = klass() # empty `.__dict__` + with self.assertRaisesRegex(ValueError, 'dict with embedded values'): + as_frozendict(instance.__dict__) + self.assertEqual(instance.__dict__, {}) + + instance = klass() # non-empty `.__dict__` instance.key = 'value' - with self.assertRaisesRegex(ValueError, 'embedded values'): + with self.assertRaisesRegex(ValueError, 'dict with embedded values'): as_frozendict(instance.__dict__) self.assertEqual(instance.__dict__, {'key': 'value'}) diff --git a/Objects/dictobject.c b/Objects/dictobject.c index f81242820a3d32..16cb1c93177b03 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -8663,16 +8663,22 @@ frozendict_new(PyTypeObject *type, PyObject *args, PyObject *kwds) return d; } -static void +static int transfer_keys_and_values_lock_held(PyObject *res, PyObject *dict) { PyDictObject *new = (PyDictObject *)res; PyDictObject *old = (PyDictObject *)dict; assert(can_modify_dict(old)); + if (old->ma_values && old->ma_values->embedded) { + PyErr_SetString(PyExc_ValueError, + "can't convert dict with embedded values"); + return -1; + } + // Fast path: do nothing on an empty dict: if (old->ma_keys == Py_EMPTY_KEYS) { - return; + return 0; } Py_ssize_t used = old->ma_used; @@ -8690,6 +8696,7 @@ transfer_keys_and_values_lock_held(PyObject *res, PyObject *dict) new->ma_keys = keys; new->ma_values = values; ASSERT_CONSISTENT(new); + return 0; } PyObject * @@ -8700,21 +8707,18 @@ PyDict_AsFrozenDictAndClear(PyObject *dict) return NULL; } - PyDictObject *ma = (PyDictObject*)dict; - if (ma->ma_values && ma->ma_values->embedded) { - PyErr_SetString(PyExc_ValueError, - "can't convert dict with embedded values"); - return NULL; - } - PyObject *res = frozendict_new_untracked(&PyFrozenDict_Type); if (res == NULL) { return NULL; } + int trasfer; Py_BEGIN_CRITICAL_SECTION(dict); - transfer_keys_and_values_lock_held(res, dict); + trasfer = transfer_keys_and_values_lock_held(res, dict); Py_END_CRITICAL_SECTION(); + if (trasfer < 0) { + return NULL; + } _PyObject_GC_TRACK(res); assert(_PyFrozenDictObject_CAST(res)->ma_hash == -1);