new file mode 100644
@@ -0,0 +1,55 @@
+From 1f59b001d140f3c35b813150de48509bcc61713d Mon Sep 17 00:00:00 2001
+From: Daniel Fairhead <daniel@dev.ngo>
+Date: Thu, 12 Mar 2026 09:33:17 +0000
+Subject: [PATCH 1/4] Add a few additional DISALLOW_FUNCTIONS
+
+CVE: CVE-2026-32640
+Upstream-Status: Backport [https://github.com/danthedeckie/simpleeval/commit/9cb4a7b99498c173263bd90f77bc185e160fb6b8]
+
+Backport Changes:
+- Add exec while expanding DISALLOW_FUNCTIONS because simpleeval 0.9.13 does not contain the earlier generator-hardening change that added it.
+
+(cherry picked from commit 9cb4a7b99498c173263bd90f77bc185e160fb6b8)
+Signed-off-by: Hetvi Thakar <hthakar@cisco.com>
+---
+ simpleeval.py | 17 ++++++++++++++++-
+ 1 file changed, 16 insertions(+), 1 deletion(-)
+
+diff --git a/simpleeval.py b/simpleeval.py
+index f6a3ed6..91ed582 100644
+--- a/simpleeval.py
++++ b/simpleeval.py
+@@ -98,6 +98,7 @@ well:
+
+ import ast
+ import operator as op
++import os
+ import sys
+ import warnings
+ from random import random
+@@ -123,7 +124,21 @@ DISALLOW_METHODS = ["format", "format_map", "mro"]
+ # their functionality is required, then please wrap them up in a safe container. And think
+ # very hard about it first. And don't say I didn't warn you.
+ # builtins is a dict in python >3.6 but a module before
+-DISALLOW_FUNCTIONS = {type, isinstance, eval, getattr, setattr, repr, compile, open}
++DISALLOW_FUNCTIONS = {
++ type,
++ isinstance,
++ eval,
++ getattr,
++ setattr,
++ repr,
++ compile,
++ open,
++ exec,
++ globals,
++ locals,
++ os.popen,
++ os.system,
++}
+ if hasattr(__builtins__, "help") or (
+ hasattr(__builtins__, "__contains__") and "help" in __builtins__ # type: ignore
+ ):
+--
+2.35.6
+
new file mode 100644
@@ -0,0 +1,187 @@
+From bf7d5c05015cdbf8af0d298f286e76e9a6abad7c Mon Sep 17 00:00:00 2001
+From: Daniel Fairhead <daniel@dev.ngo>
+Date: Thu, 12 Mar 2026 09:37:22 +0000
+Subject: [PATCH 2/4] Disallow module access & disallowed function access via
+ attributes.
+
+CVE: CVE-2026-32640
+Upstream-Status: Backport [https://github.com/danthedeckie/simpleeval/commit/1654cbf0219345f707c79664b8657be6b8d23e33]
+
+Backport Changes:
+- Import only Hashable from typing because simpleeval 0.9.13 does not contain the later allowed_attrs type API and its Type, Dict, Set, and Union imports.
+- Adapt TestDisallowedFunctions for 0.9.13's Python-2-compatible DISALLOWED setup: remove its two PYTHON3/dynamic-exec blocks; the upstream baseline already listed exec directly.
+
+(cherry picked from commit 1654cbf0219345f707c79664b8657be6b8d23e33)
+Signed-off-by: Hetvi Thakar <hthakar@cisco.com>
+---
+ simpleeval.py | 31 +++++++++++++------
+ test_simpleeval.py | 77 ++++++++++++++++++++++++++++++----------------
+ 2 files changed, 73 insertions(+), 35 deletions(-)
+
+diff --git a/simpleeval.py b/simpleeval.py
+index 91ed582..69aed83 100644
+--- a/simpleeval.py
++++ b/simpleeval.py
+@@ -100,8 +100,10 @@ import ast
+ import operator as op
+ import os
+ import sys
++import types
+ import warnings
+ from random import random
++from typing import Hashable
+
+ PYTHON3 = sys.version_info[0] == 3
+ PYTHON35 = PYTHON3 and sys.version_info > (3, 5)
+@@ -240,6 +242,10 @@ class MultipleExpressions(UserWarning):
+ pass
+
+
++# Sentinal used during attr access
++_ATTR_NOT_FOUND = object()
++
++
+ ########################################
+ # Default simple functions to include:
+
+@@ -603,18 +609,25 @@ class SimpleEval(object): # pylint: disable=too-few-public-methods
+ # eval node
+ node_evaluated = self._eval(node.value)
+
++ item = _ATTR_NOT_FOUND
++
+ # Maybe the base object is an actual object, not just a dict
+ try:
+- return getattr(node_evaluated, node.attr)
++ item = getattr(node_evaluated, node.attr)
+ except (AttributeError, TypeError):
+- pass
+-
+- # TODO: is this a good idea? Try and look for [x] if .x doesn't work?
+- if self.ATTR_INDEX_FALLBACK:
+- try:
+- return node_evaluated[node.attr]
+- except (KeyError, TypeError):
+- pass
++ # TODO: is this a good idea? Try and look for [x] if .x doesn't work?
++ if self.ATTR_INDEX_FALLBACK:
++ try:
++ item = node_evaluated[node.attr]
++ except (KeyError, TypeError):
++ pass
++
++ if item is not _ATTR_NOT_FOUND:
++ if isinstance(item, types.ModuleType):
++ raise FeatureNotAvailable("Sorry, modules are not allowed in attribute access")
++ if isinstance(item, Hashable) and item in DISALLOW_FUNCTIONS:
++ raise FeatureNotAvailable("This function is forbidden")
++ return item
+
+ # If it is neither, raise an exception
+ raise AttributeDoesNotExist(node.attr, self.expr)
+diff --git a/test_simpleeval.py b/test_simpleeval.py
+index bc83d50..c60ec51 100644
+--- a/test_simpleeval.py
++++ b/test_simpleeval.py
+@@ -590,6 +590,34 @@ class TestTryingToBreakOut(DRYTest):
+
+ simpleeval.DISALLOW_PREFIXES = dis
+
++ def test_breakout_via_module_access(self):
++ import os.path
++
++ s = SimpleEval(names={"path": os.path})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("path.os.popen('id').read()")
++
++ def test_breakout_via_module_access_attr(self):
++ import os.path
++
++ class Foo:
++ p = os.path
++
++ s = SimpleEval(names={"thing": Foo()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("thing.p.os.popen('id').read()")
++
++ def test_breakout_via_disallowed_functions_as_attrs(self):
++ class Foo:
++ p = exec
++
++ s = SimpleEval(names={"thing": Foo()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("thing.p('exit')")
++
+
+ class TestCompoundTypes(DRYTest):
+ """Test the compound-types edition of the library"""
+@@ -1199,40 +1227,37 @@ class TestShortCircuiting(DRYTest):
+
+
+ class TestDisallowedFunctions(DRYTest):
+- def test_functions_are_disallowed_at_init(self):
+- DISALLOWED = [type, isinstance, eval, getattr, setattr, help, repr, compile, open]
+- if simpleeval.PYTHON3:
+- # pylint: disable=exec-used
+- exec("DISALLOWED.append(exec)") # exec is not a function in Python2...
+-
+- for f in simpleeval.DISALLOW_FUNCTIONS:
+- assert f in DISALLOWED
++ def test_functions_in_disallowed_functions_list(self):
++ # a bit of double-entry testing. probably pointless.
++ assert simpleeval.DISALLOW_FUNCTIONS.issuperset(
++ {
++ type,
++ isinstance,
++ eval,
++ getattr,
++ setattr,
++ help,
++ repr,
++ compile,
++ open,
++ exec,
++ os.popen,
++ os.system,
++ }
++ )
+
+- for x in DISALLOWED:
++ def test_functions_are_disallowed_at_init(self):
++ for dangerous_function in simpleeval.DISALLOW_FUNCTIONS:
+ with self.assertRaises(FeatureNotAvailable):
+- SimpleEval(functions={"foo": x})
++ SimpleEval(functions={"foo": dangerous_function})
+
+ def test_functions_are_disallowed_in_expressions(self):
+- DISALLOWED = [type, isinstance, eval, getattr, setattr, help, repr, compile, open]
+-
+- if simpleeval.PYTHON3:
+- # pylint: disable=exec-used
+- exec("DISALLOWED.append(exec)") # exec is not a function in Python2...
+-
+- for f in simpleeval.DISALLOW_FUNCTIONS:
+- assert f in DISALLOWED
+-
+- DF = simpleeval.DEFAULT_FUNCTIONS.copy()
+-
+- for x in DISALLOWED:
+- simpleeval.DEFAULT_FUNCTIONS = DF.copy()
++ for dangerous_function in simpleeval.DISALLOW_FUNCTIONS:
+ with self.assertRaises(FeatureNotAvailable):
+ s = SimpleEval()
+- s.functions["foo"] = x
++ s.functions["foo"] = dangerous_function
+ s.eval("foo(42)")
+
+- simpleeval.DEFAULT_FUNCTIONS = DF.copy()
+-
+
+ @unittest.skipIf(simpleeval.PYTHON3 is not True, "Python2 fails - but it's not supported anyway.")
+ @unittest.skipIf(platform.python_implementation() == "PyPy", "GC set_debug not available in PyPy")
+--
+2.35.6
+
new file mode 100644
@@ -0,0 +1,485 @@
+From 030eb59004303dd4b88fedd6d80b7cb3e9d261a7 Mon Sep 17 00:00:00 2001
+From: Daniel Fairhead <daniel@dev.ngo>
+Date: Fri, 13 Mar 2026 06:35:27 +0000
+Subject: [PATCH 3/4] Much stricter lockdown via _check_disallowed_items plus
+ adding ModuleWrapper
+
+CVE: CVE-2026-32640
+Upstream-Status: Backport [https://github.com/danthedeckie/simpleeval/commit/cffa9f68cee54404a2ef43d949a8ae8a3311c503]
+
+Backport Changes:
+- Omit the new ModuleWrapper API and its tests and documentation so the Scarthgap backport does not add an unrelated public feature; raw modules remain fully blocked.
+- Retain only the module-access prohibition documentation because simpleeval 0.9.13 does not contain the later allowed_attrs API or its documentation context.
+- Extend _check_disallowed_items to traverse sets, frozensets, and dictionary keys, with regression coverage, so dangerous callback arguments cannot bypass the recursive check through those containers.
+- Track visited container identities during each recursive check and add cyclic list and dictionary tests to prevent unbounded recursion without weakening forbidden-item detection.
+
+(cherry picked from commit cffa9f68cee54404a2ef43d949a8ae8a3311c503)
+Signed-off-by: Hetvi Thakar <hthakar@cisco.com>
+---
+ README.rst | 1 +
+ simpleeval.py | 34 +++-
+ test_simpleeval.py | 384 +++++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 418 insertions(+), 1 deletion(-)
+
+diff --git a/README.rst b/README.rst
+index ed7c655..6ac327b 100644
+--- a/README.rst
++++ b/README.rst
+@@ -416,6 +416,7 @@ A few builtin functions are listed in ``simpleeval.DISALLOW_FUNCTIONS``. ``type
+ If you need to give access to this kind of functionality to your expressions, then be very
+ careful. You'd be better wrapping the functions in your own safe wrappers.
+
++Accessing modules as attributes is disallowed too.
+ The initial idea came from J.F. Sebastian on Stack Overflow
+ ( http://stackoverflow.com/a/9558001/1973500 ) with modifications and many improvements,
+ see the head of the main file for contributors list.
+diff --git a/simpleeval.py b/simpleeval.py
+index 69aed83..9f3003e 100644
+--- a/simpleeval.py
++++ b/simpleeval.py
+@@ -424,6 +424,36 @@ class SimpleEval(object): # pylint: disable=too-few-public-methods
+ def __del__(self):
+ self.nodes = None
+
++ def _check_disallowed_items(self, item, visited=None):
++ """Check if item contains disallowed functions or modules.
++ Recursively checks containers (dict, list, tuple, set, frozenset).
++ Raises FeatureNotAvailable if forbidden content found.
++ """
++ if isinstance(item, types.ModuleType):
++ raise FeatureNotAvailable("Sorry, modules are not allowed")
++ if isinstance(item, Hashable) and item in DISALLOW_FUNCTIONS:
++ raise FeatureNotAvailable("This function is forbidden")
++
++ if not isinstance(item, (dict, list, tuple, set, frozenset)):
++ return
++
++ if visited is None:
++ visited = set()
++
++ item_id = id(item)
++ if item_id in visited:
++ return
++ visited.add(item_id)
++
++ if isinstance(item, dict):
++ for key in item.keys():
++ self._check_disallowed_items(key, visited)
++ for value in item.values():
++ self._check_disallowed_items(value, visited)
++ else:
++ for element in item:
++ self._check_disallowed_items(element, visited)
++
+ @staticmethod
+ def parse(expr):
+ """parse an expression into a node tree"""
+@@ -458,7 +488,9 @@ class SimpleEval(object): # pylint: disable=too-few-public-methods
+ "Sorry, {0} is not available in this " "evaluator".format(type(node).__name__)
+ )
+
+- return handler(node)
++ result = handler(node)
++ self._check_disallowed_items(result)
++ return result
+
+ def _eval_expr(self, node):
+ return self._eval(node.value)
+diff --git a/test_simpleeval.py b/test_simpleeval.py
+index c60ec51..f3c9a60 100644
+--- a/test_simpleeval.py
++++ b/test_simpleeval.py
+@@ -618,6 +618,390 @@ class TestTryingToBreakOut(DRYTest):
+ with self.assertRaises(FeatureNotAvailable):
+ s.eval("thing.p('exit')")
+
++ def test_breakout_forbidden_function_in_list(self):
++ """Disallowed functions in lists should be blocked"""
++ s = SimpleEval(names={"funcs": [exec, eval]})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("funcs[0]('exit')")
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("funcs[1]('1+1')")
++
++ def test_breakout_module_in_list(self):
++ """Modules in lists should be blocked"""
++ import os.path
++
++ s = SimpleEval(names={"things": [os.path, os.system]})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("things[0].os.popen('id').read()")
++
++ def test_breakout_forbidden_function_in_dict_value(self):
++ """Disallowed functions as dict values should be blocked"""
++ s = SimpleEval(names={"funcs": {"bad": exec, "evil": eval}})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("funcs['bad']('exit')")
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("funcs['evil']('1+1')")
++
++ def test_breakout_module_in_dict_value(self):
++ """Modules as dict values should be blocked"""
++ import os.path
++
++ s = SimpleEval(names={"things": {"p": os.path, "s": os.system}})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("things['p'].os.popen('id').read()")
++
++ def test_breakout_forbidden_function_in_set(self):
++ """Disallowed functions in sets should be blocked"""
++
++ def invoke(items):
++ return next(iter(items))("40+2")
++
++ s = SimpleEval(names={"funcs": {eval}}, functions={"invoke": invoke})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("invoke(funcs)")
++
++ def test_breakout_forbidden_function_in_frozenset(self):
++ """Disallowed functions in frozensets should be blocked"""
++
++ def invoke(items):
++ return next(iter(items))("40+2")
++
++ s = SimpleEval(names={"funcs": frozenset({eval})}, functions={"invoke": invoke})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("invoke(funcs)")
++
++ def test_breakout_forbidden_function_in_dict_key(self):
++ """Disallowed functions as dict keys should be blocked"""
++
++ def invoke(items):
++ return next(iter(items))("40+2")
++
++ s = SimpleEval(names={"funcs": {eval: "value"}}, functions={"invoke": invoke})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("invoke(funcs)")
++
++ def test_cyclic_list(self):
++ """Cyclic lists should be checked without unbounded recursion"""
++ value = []
++ value.append(value)
++
++ self.assertIs(SimpleEval(names={"value": value}).eval("value"), value)
++
++ def test_cyclic_dict(self):
++ """Cyclic dicts should be checked without unbounded recursion"""
++ value = {}
++ value["self"] = value
++
++ self.assertIs(SimpleEval(names={"value": value}).eval("value"), value)
++
++ def test_cyclic_container_with_forbidden_function(self):
++ """A cycle should not hide other forbidden container members"""
++ value = [eval]
++ value.append(value)
++
++ with self.assertRaises(FeatureNotAvailable):
++ SimpleEval(names={"value": value}).eval("value")
++
++ def test_breakout_function_returning_forbidden_function(self):
++ """Functions returning disallowed functions should be blocked"""
++
++ def get_evil():
++ return exec
++
++ s = SimpleEval(names={}, functions={"get_evil": get_evil})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("get_evil()('exit')")
++
++ def test_breakout_function_returning_module(self):
++ """Functions returning modules should be blocked"""
++ import os.path
++
++ def get_module():
++ return os.path
++
++ s = SimpleEval(names={}, functions={"get_module": get_module})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("get_module().os.popen('id').read()")
++
++ def test_dunder_all_in_module(self):
++ """__all__ should be blocked (starts with _)"""
++ import os
++
++ s = SimpleEval(names={"os": os})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("os.__all__")
++
++ def test_dunder_dict_in_module(self):
++ """__dict__ should be blocked (starts with _)"""
++ import os
++
++ s = SimpleEval(names={"os": os})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("os.__dict__")
++
++ def test_forbidden_method_in_tuple(self):
++ """Disallowed functions in tuples should be blocked"""
++ s = SimpleEval(names={"funcs": (exec, eval)})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("funcs[0]('exit')")
++
++ def test_module_in_tuple(self):
++ """Modules in tuples should be blocked"""
++ import os
++
++ s = SimpleEval(names={"mods": (os.path, os.system)})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("mods[0].os.popen('id').read()")
++
++ def test_breakout_via_nested_container_forbidden_func(self):
++ """Disallowed functions nested in containers should be blocked"""
++ s = SimpleEval(names={"data": {"nested": {"funcs": [exec]}}})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("data['nested']['funcs'][0]('exit')")
++
++ def test_breakout_via_nested_container_module(self):
++ """Modules nested in containers should be blocked"""
++ import os
++
++ s = SimpleEval(names={"data": {"mods": {"p": os.path}}})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("data['mods']['p'].os.popen('id').read()")
++
++ def test_forbidden_methods_on_allowed_attrs(self):
++ """Disallowed methods listed in DISALLOW_METHODS should be
++ blocked"""
++ s = SimpleEval()
++
++ # format and format_map are in DISALLOW_METHODS
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("'test {0}'.format")
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("'test'.format_map({0: 'x'})")
++
++ # __mro__ is in DISALLOW_METHODS
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("'test'.mro")
++
++ def test_function_returning_forbidden_method(self):
++ """Functions returning disallowed methods should be blocked"""
++
++ def get_exec_module():
++ import os
++
++ return os
++
++ s = SimpleEval(names={}, functions={"get_os": get_exec_module})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("get_os().__name__")
++
++ def test_compound_module_submodule_access(self):
++ """Accessing submodules of a passed module should be blocked"""
++ import os.path
++
++ s = SimpleEval(names={"path": os.path})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("path.os")
++
++ def test_forbidden_func_via_class_method(self):
++ """Accessing forbidden functions via class methods should be
++ blocked"""
++
++ class Container:
++ @staticmethod
++ def get_exec():
++ return exec
++
++ s = SimpleEval(names={"c": Container()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("c.get_exec()('exit')")
++
++ def test_module_via_class_method(self):
++ """Accessing modules via class methods should be blocked"""
++ import os
++
++ class Container:
++ @staticmethod
++ def get_os():
++ return os
++
++ s = SimpleEval(names={"c": Container()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("c.get_os().popen('id').read()")
++
++ def test_forbidden_func_via_property(self):
++ """Accessing forbidden functions via properties should be
++ blocked"""
++
++ class Container:
++ @property
++ def evil(self):
++ return exec
++
++ s = SimpleEval(names={"c": Container()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("c.evil('exit')")
++
++ def test_module_via_property(self):
++ """Accessing modules via properties should be blocked"""
++ import os
++
++ class Container:
++ @property
++ def mod(self):
++ return os
++
++ s = SimpleEval(names={"c": Container()})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("c.mod.popen('id').read()")
++
++ def test_forbidden_function_direct_from_names(self):
++ """Forbidden functions passed directly in names should
++ be blocked when accessed"""
++ s = SimpleEval(names={"evil": exec})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("evil")
++
++ def test_module_direct_from_names(self):
++ """Modules passed directly in names should be blocked
++ when accessed"""
++ import os
++
++ s = SimpleEval(names={"m": os})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("m")
++
++ def test_forbidden_function_via_callable_name_handler(self):
++ """Forbidden functions from callable name handlers should
++ be blocked"""
++
++ def name_handler(node):
++ if node.id == "evil":
++ return exec
++ raise simpleeval.NameNotDefined(node.id, "")
++
++ s = SimpleEval(names=name_handler)
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("evil")
++
++ def test_module_via_callable_name_handler(self):
++ """Modules from callable name handlers should be blocked"""
++ import os
++
++ def name_handler(node):
++ if node.id == "m":
++ return os
++ raise simpleeval.NameNotDefined(node.id, "")
++
++ s = SimpleEval(names=name_handler)
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("m")
++
++ def test_forbidden_function_passed_to_custom_function(self):
++ """Passing forbidden functions to custom functions should be
++ blocked - they can be executed by the custom function"""
++
++ def evil_caller(func):
++ return func("print('pwned')")
++
++ s = SimpleEval(names={"evil": exec}, functions={"evil_caller": evil_caller})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("evil_caller(evil)")
++
++ def test_module_passed_to_custom_function(self):
++ """Passing modules to custom functions should be blocked - they
++ can be used by the custom function"""
++ import os
++
++ def os_caller(mod):
++ return mod.system("id")
++
++ s = SimpleEval(names={"m": os}, functions={"os_caller": os_caller})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("os_caller(m)")
++
++ def test_forbidden_function_in_list_passed_to_custom_function(self):
++ """Forbidden functions in containers passed to custom functions
++ should be blocked"""
++
++ def extract_and_call(items):
++ return items[0]("print('pwned')")
++
++ s = SimpleEval(names={"funcs": [exec, eval]}, functions={"extract": extract_and_call})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("extract(funcs)")
++
++ def test_module_in_list_passed_to_custom_function(self):
++ """Modules in containers passed to custom functions should be
++ blocked"""
++ import os
++
++ def extract_and_use(items):
++ return items[0].system("id")
++
++ s = SimpleEval(names={"mods": [os.path, os]}, functions={"extract": extract_and_use})
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("extract(mods)")
++
++ def test_forbidden_function_in_dict_passed_to_custom_function(self):
++ """Forbidden functions in dicts passed to custom functions should
++ be blocked"""
++
++ def extract_and_call(d):
++ return d["bad"]("print('pwned')")
++
++ s = SimpleEval(
++ names={"funcs": {"bad": exec, "good": print}}, functions={"extract": extract_and_call}
++ )
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("extract(funcs)")
++
++ def test_module_in_dict_passed_to_custom_function(self):
++ """Modules in dicts passed to custom functions should be blocked"""
++ import os
++
++ def extract_and_use(d):
++ return d["m"].system("id")
++
++ s = SimpleEval(
++ names={"mods": {"m": os, "p": os.path}}, functions={"extract": extract_and_use}
++ )
++
++ with self.assertRaises(FeatureNotAvailable):
++ s.eval("extract(mods)")
++
+
+ class TestCompoundTypes(DRYTest):
+ """Test the compound-types edition of the library"""
+--
+2.35.6
+
new file mode 100644
@@ -0,0 +1,90 @@
+From 42483617f1fd47c81bbf66c71c2ce5cbe2d3df29 Mon Sep 17 00:00:00 2001
+From: Daniel Fairhead <daniel@dev.ngo>
+Date: Fri, 13 Mar 2026 13:27:47 +0000
+Subject: [PATCH 4/4] Fix unhashable items inside tuples bug.
+
+CVE: CVE-2026-32640
+Upstream-Status: Backport [https://github.com/danthedeckie/simpleeval/commit/d1e4569db678a3cb42b779f404aa203665d52ab0]
+
+Backport Changes:
+- Omit the upstream 1.0.6 version metadata change and retain the 0.9.13 setuptools build configuration.
+- Remove the standalone Hashable import added by the preceding 0.9.13 backport while retaining the target Python compatibility flags.
+
+(cherry picked from commit d1e4569db678a3cb42b779f404aa203665d52ab0)
+Signed-off-by: Hetvi Thakar <hthakar@cisco.com>
+---
+ simpleeval.py | 16 +++++++++++++---
+ test_simpleeval.py | 9 +++++++++
+ 2 files changed, 22 insertions(+), 3 deletions(-)
+
+diff --git a/simpleeval.py b/simpleeval.py
+index 9f3003e..a6745db 100644
+--- a/simpleeval.py
++++ b/simpleeval.py
+@@ -103,7 +103,6 @@ import sys
+ import types
+ import warnings
+ from random import random
+-from typing import Hashable
+
+ PYTHON3 = sys.version_info[0] == 3
+ PYTHON35 = PYTHON3 and sys.version_info > (3, 5)
+@@ -119,6 +118,17 @@ MAX_SHIFT_BASE = int(sys.float_info.max) # highest on left side of << or >>
+ DISALLOW_PREFIXES = ["_", "func_"]
+ DISALLOW_METHODS = ["format", "format_map", "mro"]
+
++########################################
++# Tiny helpers:
++
++
++def is_hashable(value):
++ try:
++ return hash(value)
++ except TypeError:
++ return False
++
++
+ # Disallow functions:
+ # This, strictly speaking, is not necessary. These /should/ never be accessable anyway,
+ # if DISALLOW_PREFIXES and DISALLOW_METHODS are all right. This is here to try and help
+@@ -431,7 +441,7 @@ class SimpleEval(object): # pylint: disable=too-few-public-methods
+ """
+ if isinstance(item, types.ModuleType):
+ raise FeatureNotAvailable("Sorry, modules are not allowed")
+- if isinstance(item, Hashable) and item in DISALLOW_FUNCTIONS:
++ if is_hashable(item) and item in DISALLOW_FUNCTIONS:
+ raise FeatureNotAvailable("This function is forbidden")
+
+ if not isinstance(item, (dict, list, tuple, set, frozenset)):
+@@ -657,7 +667,7 @@ class SimpleEval(object): # pylint: disable=too-few-public-methods
+ if item is not _ATTR_NOT_FOUND:
+ if isinstance(item, types.ModuleType):
+ raise FeatureNotAvailable("Sorry, modules are not allowed in attribute access")
+- if isinstance(item, Hashable) and item in DISALLOW_FUNCTIONS:
++ if is_hashable(item) and item in DISALLOW_FUNCTIONS:
+ raise FeatureNotAvailable("This function is forbidden")
+ return item
+
+diff --git a/test_simpleeval.py b/test_simpleeval.py
+index f3c9a60..a654f6d 100644
+--- a/test_simpleeval.py
++++ b/test_simpleeval.py
+@@ -347,6 +347,15 @@ class TestFunctions(DRYTest):
+ self.t("foo(mult=2, to_return=4)", 8)
+ self.t("foo(2, 10)", 20)
+
++ def test_function_with_list_args(self):
++ # Regression test, makes sure we can pass lists (non-hashable) items as
++ # kwargs to functions.
++
++ def func(*args, **kwargs):
++ return 42
++
++ simple_eval("test(boo=x)", functions={"test": func}, names={"x": [1, 2]})
++
+
+ class TestOperators(DRYTest):
+ """Test adding in new operators, removing them, make sure it works."""
+--
+2.35.6
+
@@ -9,7 +9,13 @@ inherit pypi python_setuptools_build_meta ptest
BBCLASSEXTEND = "native nativesdk"
-SRC_URI += "file://run-ptest"
+SRC_URI += " \
+ file://CVE-2026-32640_p1.patch \
+ file://CVE-2026-32640_p2.patch \
+ file://CVE-2026-32640_p3.patch \
+ file://CVE-2026-32640_p4.patch \
+ file://run-ptest \
+"
RDEPENDS:${PN} += " \
python3-math \