Claude-bot code checked SSRF targets without DNS resolution, so hostnames resolving to private, loopback, or metadata addresses could bypass the guard.

+        Args:+            url: URL to validate+            +        Returns:+            bool: True if URL is safe, False otherwise+        """+        try:+            parsed = urlparse(url)+            +            # Only allow http/https protocols

+                # Not an IP address, continue with domain validation

+            +        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

             if session is None:                 return {"error": "requests package not available"}

@@ -29,6 +30,25 @@ def __init__(self, database: str = ':memory:'):         """         self.database = database         self._conn = None+    +    def _validate_identifier(self, identifier: str) -> str:+        """Validate and quote a SQL identifier to prevent injection.+        +        Args:+            identifier: Table or column name to validate+            +        Returns:+            Quoted identifier safe for SQL+            +        Raises:+            ValueError: If identifier contains invalid characters+        """+        # Only allow alphanumeric characters, underscores, and dots+        if not re.match(r'^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)?$', identifier):+            raise ValueError(f"Invalid identifier: {identifier}")+        +        # Quote the identifier to handle reserved words+        return f'"{identifier}"'      def _get_duckdb(self) -> Optional['duckdb']:         """Get duckdb module, installing if needed"""@@ -125,39 +145,50 @@ def load_csv(             if conn is None:                 return False -            # Check if table exists-            exists = conn.execute(f"""+            # Check if table exists using parameterized query+            exists = conn.execute("""                 SELECT name FROM sqlite_master -                WHERE type='table' AND name='{table_name}'-            """).fetchone() is not None+                WHERE type='table' AND name=?+            """, [table_name]).fetchone() is not None              if exists:                 if if_exists == 'fail':                     raise ValueError(f"Table {table_name} already exists")                 elif if_exists == 'replace':-                    conn.execute(f"DROP TABLE IF EXISTS {table_name}")+                    # Validate and quote table name to prevent injection+                    safe_table = self._validate_identifier(table_name)+                    conn.execute(f"DROP TABLE IF EXISTS {safe_table}")                 elif if_exists != 'append':                     raise ValueError("if_exists must be 'fail', 'replace', or 'append'")              # Create table if needed             if not exists or if_exists == 'replace':+                safe_table = self._validate_identifier(table_name)                 if schema:-                    # Create table with schema-                    columns = ', '.join(f"{k} {v}" for k, v in schema.items())-                    conn.execute(f"CREATE TABLE {table_name} ({columns})")+                    # Create table with schema - validate column names+                    column_defs = []+                    for col_name, col_type in schema.items():+                        safe_col = self._validate_identifier(col_name)+                        # Validate column type to prevent injection+                        if not re.match(r'^[A-Z][A-Z0-9_]*(\([0-9,]+\))?$', col_type.upper()):+                            raise ValueError(f"Invalid column type: {col_type}")+                        column_defs.append(f"{safe_col} {col_type}")+                    columns = ', '.join(column_defs)+                    conn.execute(f"CREATE TABLE {safe_table} ({columns})")                 else:-                    # Infer schema from CSV+                    # Infer schema from CSV - use parameterized query for filepath                     conn.execute(f"""-                        CREATE TABLE {table_name} AS -                        SELECT * FROM read_csv_auto('{filepath}')+                        CREATE TABLE {safe_table} AS +                        SELECT * FROM read_csv_auto(?)                         WHERE 1=0-                    """)+                    """, [filepath]) -            # Load data+            # Load data - use validated table name and parameterized filepath

+            # 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,+                'divmod': divmod,+                # Exceptions+                'Exception': Exception,+                'ValueError': ValueError,+                'TypeError': TypeError,+                'KeyError': KeyError,+                'IndexError': IndexError,+                'RuntimeError': RuntimeError,+                # Other safe functions+                'isinstance': isinstance,+                'type': type,+                '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,

      return False