Patched code sample

# This is a hypothetical fix as the exact fix for CVE-2025-5321 is not publicly available.
# This example demonstrates a strengthened validation and sanitization of the query string
# to prevent code injection within the RestrictedPython environment.

import ast
import restrictedpython

def safe_eval(query):
  """
  Safely evaluates a query string using RestrictedPython with enhanced validation.

  Args:
    query: The query string to evaluate.

  Returns:
    The result of the evaluation, or None if the query is invalid.
  """

  # 1. Validate the query syntax using ast.parse to prevent injection of arbitrary code structures.
  try:
    tree = ast.parse(query)

    # Check for potentially dangerous AST nodes. This is just an example, you might need
    # a more comprehensive check depending on the specifics of the RestrictedPython usage.
    for node in ast.walk(tree):
        if isinstance(node, (ast.Import, ast.ImportFrom, ast.Call)):
            raise ValueError("Invalid query: Imports and function calls are not allowed.") # or log, or handle it differently

  except SyntaxError as e:
    print(f"Syntax error in query: {e}")
    return None
  except ValueError as e:
    print(f"Invalid query: {e}")
    return None


  # 2. Sanitize the query string (Example: Allow only specific characters/patterns)
  #    This is highly dependent on the expected structure of the query.  Adapt as needed.
  allowed_chars = "0123456789.+-*/()x" # Example: Allow numbers, operators, 'x' (variable)
  sanitized_query = "".join(c for c in query if c in allowed_chars)

  if sanitized_query != query:
    print("Query sanitized: Removed disallowed characters.")
    # Decide whether to proceed with the sanitized query or reject it.
    #  For increased security, it's often safer to reject if sanitization was needed.
    # For this example, we will proceed using the sanitized query.
    query = sanitized_query



  # 3. Execute the sanitized and validated query within the RestrictedPython environment.
  #    (RestrictedPython setup is not shown, assume it is configured elsewhere)
  #    Assume `safe_globals` is defined and contains the allowed variables and functions.
  safe_globals = {'x': 10} # Example: Allow only variable 'x'
  safe_locals = {}

  try:
      compiled_code = compile(sanitized_query, '<string>', 'eval')
      result = eval(compiled_code, safe_globals, safe_locals)  #Use built-in eval in RestrictedPython
      return result
  except Exception as e:
      print(f"Error during evaluation: {e}")
      return None


def RestrictedPythonQuery(Query):
  """
  The function that uses safe_eval to process user queries.
  """

  result = safe_eval(Query)
  return result

# Example Usage:

#Potentially dangerous query
#print(RestrictedPythonQuery("__import__('os').system('rm -rf /')"))  # This should be blocked by the validation.


#Safe Query
print(RestrictedPythonQuery("x + 5"))

#Query with not allowed characters (will be sanitized)
print(RestrictedPythonQuery("x + 5;import os"))