Vulnerable code sample

import sys
import datetime

# This code represents a vulnerable implementation similar to the one
# described in CVE-2026-28505 in Tautulli's notification_handler.py before version 2.17.0.

BANNED_NAMES = (
    '__import__',
    'eval',
    'exec',
    'open',
    'os',
    'system',
    'subprocess',
    'sys',
    'breakpoint',
    'compile',
    'globals',
    'locals'
)

# A simplified set of globals that might be allowed in the template evaluation
ALLOWED_GLOBALS = {
    '__builtins__': {
        'abs': abs,
        'all': all,
        'any': any,
        'bool': bool,
        'str': str,
        'int': int,
        'float': float,
        'len': len,
        'list': list,
        'dict': dict,
        'set': set,
        'tuple': tuple,
        'max': max,
        'min': min,
        'round': round,
        'sum': sum,
    },
    'datetime': datetime,
}


def str_eval(text, eval_globals=None, eval_locals=None):
    """
    A sandboxed eval function for evaluating template strings.
    This version is vulnerable because it only checks the co_names of the top-level
    code object and does not recursively check nested code objects (e.g., from lambdas).
    """
    _globals = ALLOWED_GLOBALS.copy()
    if eval_globals:
        _globals.update(eval_globals)

    if eval_locals is None:
        eval_locals = {}

    try:
        # Compile the expression to inspect it before evaluation.
        code = compile(text, '<string>', 'eval')

        # VULNERABILITY: This check is insufficient.
        # It only inspects the names in the outer code object's namespace.
        # It does not inspect nested code objects, such as those created by a lambda.
        for name in code.co_names:
            if name in BANNED_NAMES:
                raise NameError(f"Use of '{name}' is not allowed.")
            # A real implementation would have more checks here.

        # If the checks pass, the code is evaluated.
        # A malicious lambda will pass the check above and be executed here.
        return eval(code, _globals, eval_locals)

    except Exception as e:
        # In a real application, this would likely log the error.
        return f"Error: {e}"

# Example of how the vulnerability would be exploited.
# This part is for demonstration and would not be part of the original file.
#
# Malicious payload that bypasses the sandbox check.
# The `co_names` for this entire expression is empty `()`.
# The `__import__`, `os`, and `system` names are stored in the nested code
# object of the lambda, which is never inspected by the vulnerable function.
#
# evil_string = "(lambda: __import__('os').system('echo VULNERABLE'))()"
#
# # The function fails to detect the banned names and executes the payload.
# result = str_eval(evil_string)
#
# # This would print "VULNERABLE" to the console, and `result` would be the
# # exit code of the command (e.g., 0).