AI-written URL validation using only urlparse allowed a backslash-smuggled URL, enabling SSRF to internal hosts via requests.

+    def _validate_url(self, url: str) -> bool:+        """+        Validate URL to prevent SSRF attacks.+        +        Args:+            url: URL to validate+            +        Returns:+            bool: True if URL is safe, False otherwise+        """+        try:+            parsed = urlparse(url)+            +            # Only allow http/https protocols+            if parsed.scheme not in ['http', 'https']:+                return False+            +            # Reject URLs with no hostname+            if not parsed.hostname:+                return False+            +            # Reject local/internal addresses+            hostname = parsed.hostname.lower()+            +            # Block localhost and loopback+            if hostname in ['localhost', '127.0.0.1', '0.0.0.0', '::1']:+                return False+            +            # Block private IP ranges+            import ipaddress+            try:

+            # Block common internal domains+            if any(hostname.endswith(domain) for domain in ['.local', '.internal', '.localdomain']):+                return False+            +            # Block metadata service endpoints+            if hostname in ['169.254.169.254', 'metadata.google.internal']:+                return False+            +            return True+            +        except Exception:+            return False+             def _get_session(self):         """Get or create requests session with common headers."""         if util.find_spec('requests') is None:@@ -70,6 +121,10 @@ def scrape_page(             Dict: Scraped content or error dict         """         try:+            # Validate URL to prevent SSRF+            if not self._validate_url(url):+                return {"error": f"Invalid or potentially dangerous URL: {url}"}+                         session = self._get_session()             if session is None:                 return {"error": "requests package not available"}

@@ -50,22 +49,20 @@ def execute_command(             command: Command to execute             cwd: Working directory             timeout: Maximum execution time in seconds-            shell: Whether to run command in shell             env: Environment variables             max_output_size: Maximum output size in bytes                      Returns:             Dictionary with execution results         """         try:-            # Split command if not using shell-            if not shell:-                # Use shlex.split with appropriate posix flag-                if platform.system() == 'Windows':-                    # Use shlex with posix=False for Windows to handle quotes properly-                    command = shlex.split(command, posix=False)-                else:-                    command = shlex.split(command)+            # Always split command for safety (no shell execution)+            # Use shlex.split with appropriate posix flag+            if platform.system() == 'Windows':+                # Use shlex with posix=False for Windows to handle quotes properly+                command = shlex.split(command, posix=False)+            else:+                command = shlex.split(command)                          # Set up process environment             process_env = os.environ.copy()@@ -79,7 +76,7 @@ def execute_command(                 stdout=subprocess.PIPE,                 stderr=subprocess.PIPE,                 cwd=cwd,-                shell=shell,+                shell=False,  # Always use shell=False for security                 env=process_env,                 text=True             )

-        """Execute Python code safely."""+        """Execute Python code safely with restricted builtins."""         try:-            # Set up execution environment+            # Create safe builtins - restricted set of functions+            safe_builtins = {+                # Basic functions+                'print': print,+                'len': len,+                'range': range,+                'enumerate': enumerate,+                'zip': zip,+                'map': map,+                'filter': filter,+                'sum': sum,+                'min': min,+                'max': max,+                'abs': abs,+                'round': round,+                'sorted': sorted,+                'reversed': reversed,+                'any': any,+                'all': all,+                # Type constructors+                'int': int,+                'float': float,+                'str': str,+                'bool': bool,+                'list': list,+                'tuple': tuple,+                'dict': dict,+                'set': set,+                # Math functions+                'pow': pow,

+                'hasattr': hasattr,+                'getattr': getattr,+                'setattr': setattr,+                'dir': dir,+                'help': help,+                # Disable dangerous functions+                '__import__': None,+                'eval': None,+                'exec': None,+                'compile': None,+                'open': None,+                'input': None,+                'globals': None,+                'locals': None,+                'vars': None,+            }+            +            # Set up execution environment with safe builtins             if globals_dict is None:-                globals_dict = {'__builtins__': __builtins__}+                globals_dict = {'__builtins__': safe_builtins}+            else:+                # Override builtins in provided globals+                globals_dict['__builtins__'] = safe_builtins+                             if locals_dict is None:                 locals_dict = {}             +            # Security check: validate code doesn't contain dangerous patterns+            dangerous_patterns = [+                '__import__', 'import ', 'from ', 'exec', 'eval', +                'compile', 'open(', 'file(', 'input(', 'raw_input',+                '__subclasses__', '__bases__', '__globals__', '__code__',+                '__class__', 'globals(', 'locals(', 'vars('+            ]+            +            code_lower = code.lower()+            for pattern in dangerous_patterns:+                if pattern.lower() in code_lower:+                    return {+                        'result': None,

+            if not isinstance(url, str):+                return False+            if "\\" in url or any(ord(c) < 0x20 or ord(c) == 0x7f for c in url):+                return False+             parsed = urlparse(url)                          # Only allow http/https protocols

+dispatched to ``127.0.0.1`` by ``requests``. The validator must reject any+URL whose authority disagrees with the actual destination so that hostname