Bug report

Bug description:

By creating a type or class with a definition of __eq__ that simply returns the other object, it is possible to access the underlying dictionary behind the mapping proxy returned by vars.

This can be (ab)used to bypass mutability restrictions on built-in types, as the example below shows:

class Evil:
    def __eq__(self, other):
        return other
# less readable version of Evil:
# type("Evil", (), {"__eq__": lambda self, other: other})
# this statement adds a method `prepend` to the built-in type `list`
# 1. vars(list) == Evil() returns the underlying dictionary of `list`
# 2. we can then use the dict[name] = value statement to set the attribute `name`
(vars(list) == Evil())["prepend"] = lambda self, value: self.insert(0, value)
x = [3, 5, 2]
x.prepend(7)
print(x)  # [7, 3, 5, 2]

This can be used to cause a segmentation fault:

# reusing Evil from earlier
(vars(type) == Evil())["__instancecheck__"] = lambda *_: False
# fish: Job 1, 'python' terminated by signal SIGSEGV

No FFI, not a single line of C code required.

This also works on CPython 2.7 and 3.9. It might even be possible to do on even earlier versions.

Disclaimer
I have independently discovered this by myself (no LLM).

CPython versions tested on:

3.14, 3.12, 3.11

Operating systems tested on:

Linux

Linked PRs

• gh-152405: Prevent mappingproxy operator dispatch from exposing underlying mappings #152449
• gh-152405: Do not expose the internal mapping when rich-comparing MappingProxyType objects #152483
• gh-152405 Safer mapping proxy comparisons #152489
• [3.15] gh-152405: Do not expose the internal mapping when rich-comparing MappingProxyType objects (GH-152483) #153670