Patched code sample

import ast

def safe_eval_filter(filter_expression, msg):
    """
    Safely evaluates a filter expression against a message object.

    This function mitigates CVE-2024-41921 by parsing the user-provided
    expression into an Abstract Syntax Tree (AST) and validating that it
    only contains a restricted, safe subset of Python's grammar before
    evaluation. This prevents the execution of arbitrary code.

    Args:
        filter_expression (str): The user-provided Python expression.
        msg (object): The ROS message instance to be evaluated against. The
                      expression can refer to this object as 'm'.

    Returns:
        bool: The result of the expression.

    Raises:
        ValueError: If the expression contains disallowed constructs.
    """
    if not filter_expression:
        return True

    # 1. Parse the expression into an AST. mode='eval' ensures it's an expression.
    try:
        tree = ast.parse(filter_expression, mode='eval')
    except (SyntaxError, TypeError) as e:
        raise ValueError(f"Invalid filter expression: {e}")

    # 2. Define a whitelist of safe AST node types.
    # This allows for comparisons, attribute access, boolean logic, and literals,
    # but explicitly disallows calls, imports, comprehensions, etc.
    allowed_node_types = {
        ast.Expression,    # The top-level node
        ast.Compare,       # Comparisons (e.g., m.data > 10)
        ast.Attribute,     # Attribute access (e.g., m.data)
        ast.Name,          # Variable names (e.g., 'm')
        ast.Load,          # Context for loading variables
        ast.Constant,      # Literals (Python 3.8+)
        ast.BoolOp,        # Boolean operators (and, or)
        ast.And,
        ast.Or,
        ast.UnaryOp,       # Unary operators (not)
        ast.Not,
        ast.BinOp,         # Binary operators (+, -, *, /)
        ast.Add, ast.Sub, ast.Mult, ast.Div,
        
        # For older Python compatibility (pre-3.8)
        ast.NameConstant,  # True, False, None
        ast.Num,           # Numbers
        ast.Str,           # Strings
    }

    # 3. Walk the entire AST and validate every node against the whitelist.
    for node in ast.walk(tree):
        if type(node) not in allowed_node_types:
            raise ValueError(
                f"Disallowed expression construct '{type(node).__name__}' found. "
                "Execution of arbitrary code is blocked."
            )
        # 4. Additionally, prevent access to "private" or "magic" attributes.
        if isinstance(node, ast.Attribute) and node.attr.startswith('_'):
            raise ValueError(
                "Access to private or magic attributes (starting with '_') is not permitted."
            )
        # 5. Ensure the only allowed variable name is 'm'.
        if isinstance(node, ast.Name) and node.id != 'm':
            raise ValueError(f"Unknown variable '{node.id}' found. Only 'm' is allowed.")

    # 6. If validation passes, compile and evaluate the expression in a
    #    restricted environment.
    #    The 'globals' dictionary is restricted to prevent access to built-ins.
    #    The 'locals' dictionary only exposes the message object as 'm'.
    code = compile(tree, '<string>', 'eval')
    return eval(code, {"__builtins__": {}}, {'m': msg})