Buckets:

download
raw
17.2 kB
"""
Static code validators for pre-execution screening.
This module analyzes code before execution and flags patterns known to be
dangerous (shell-out, network, filesystem, dynamic import/exec). The checks are
a static AST/regex screen, not an operating-system boundary: code that builds a
forbidden name or import at run time can pass them, so they narrow the attack
surface but do not by themselves make execution safe. Combine them with the
container or namespace isolation described in ``effgen/execution/sandbox.py``.
"""
from __future__ import annotations
import ast
import re
from dataclasses import dataclass
from enum import Enum
class ValidationSeverity(Enum):
"""Severity levels for validation issues."""
INFO = "info"
WARNING = "warning"
ERROR = "error"
CRITICAL = "critical"
@dataclass
class ValidationIssue:
"""Represents a security or safety issue in code."""
severity: ValidationSeverity
message: str
line_number: int | None = None
code_snippet: str | None = None
rule: str | None = None
@dataclass
class ValidationResult:
"""Result of code validation."""
is_safe: bool
issues: list[ValidationIssue]
language: str
@property
def has_critical(self) -> bool:
"""Check if there are critical issues."""
return any(issue.severity == ValidationSeverity.CRITICAL for issue in self.issues)
@property
def has_errors(self) -> bool:
"""Check if there are error-level issues."""
return any(issue.severity == ValidationSeverity.ERROR for issue in self.issues)
class PythonValidator:
"""Validator for Python code security."""
# Dangerous imports that should be blocked
DANGEROUS_IMPORTS = {
'os.system', 'subprocess', 'eval', 'exec', 'compile',
'__import__', 'importlib', 'socket', 'urllib', 'requests',
'http', 'ftplib', 'telnetlib', 'smtplib', 'pickle',
'shelve', 'marshal', 'ctypes', 'cffi', 'multiprocessing'
}
# Dangerous function calls
DANGEROUS_FUNCTIONS = {
'eval', 'exec', 'compile', '__import__', 'open',
'input', 'raw_input', 'execfile', 'reload'
}
# Dangerous attributes
DANGEROUS_ATTRIBUTES = {
'__globals__', '__builtins__', '__dict__', '__class__',
'__bases__', '__subclasses__', '__code__', '__closure__'
}
def __init__(self,
allow_imports: set[str] | None = None,
allow_file_ops: bool = False,
allow_network: bool = False) -> None:
"""
Initialize Python validator.
Args:
allow_imports: Set of allowed import modules
allow_file_ops: Whether to allow file operations
allow_network: Whether to allow network operations
"""
self.allow_imports = allow_imports or {'math', 'random', 'datetime', 'json', 're'}
self.allow_file_ops = allow_file_ops
self.allow_network = allow_network
def validate(self, code: str) -> ValidationResult:
"""
Validate Python code for security issues.
Args:
code: Python code to validate
Returns:
ValidationResult with detected issues
"""
issues: list[ValidationIssue] = []
# Check for syntax errors
try:
tree = ast.parse(code)
except SyntaxError as e:
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Syntax error: {e.msg}",
line_number=e.lineno,
rule="syntax_error"
))
return ValidationResult(is_safe=False, issues=issues, language="python")
# Perform AST-based validation
issues.extend(self._check_imports(tree))
issues.extend(self._check_function_calls(tree))
issues.extend(self._check_attributes(tree))
issues.extend(self._check_file_operations(tree))
issues.extend(self._check_dangerous_patterns(code))
# Determine if code is safe
is_safe = not any(
issue.severity in {ValidationSeverity.CRITICAL, ValidationSeverity.ERROR}
for issue in issues
)
return ValidationResult(is_safe=is_safe, issues=issues, language="python")
def _check_imports(self, tree: ast.AST) -> list[ValidationIssue]:
"""Check for dangerous imports."""
issues = []
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
if alias.name not in self.allow_imports:
if alias.name in self.DANGEROUS_IMPORTS:
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous import blocked: {alias.name}",
line_number=node.lineno,
rule="dangerous_import"
))
else:
issues.append(ValidationIssue(
severity=ValidationSeverity.WARNING,
message=f"Import not in whitelist: {alias.name}",
line_number=node.lineno,
rule="unapproved_import"
))
elif isinstance(node, ast.ImportFrom):
module = node.module or ""
if module not in self.allow_imports:
if any(danger in module for danger in self.DANGEROUS_IMPORTS):
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous import blocked: from {module}",
line_number=node.lineno,
rule="dangerous_import"
))
else:
issues.append(ValidationIssue(
severity=ValidationSeverity.WARNING,
message=f"Import not in whitelist: from {module}",
line_number=node.lineno,
rule="unapproved_import"
))
return issues
def _check_function_calls(self, tree: ast.AST) -> list[ValidationIssue]:
"""Check for dangerous function calls."""
issues = []
for node in ast.walk(tree):
if isinstance(node, ast.Call):
func_name = None
if isinstance(node.func, ast.Name):
func_name = node.func.id
elif isinstance(node.func, ast.Attribute):
func_name = node.func.attr
if func_name in self.DANGEROUS_FUNCTIONS:
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous function call blocked: {func_name}()",
line_number=node.lineno,
rule="dangerous_function"
))
return issues
def _check_attributes(self, tree: ast.AST) -> list[ValidationIssue]:
"""Check for dangerous attribute access."""
issues = []
for node in ast.walk(tree):
if isinstance(node, ast.Attribute):
if node.attr in self.DANGEROUS_ATTRIBUTES:
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous attribute access blocked: {node.attr}",
line_number=node.lineno,
rule="dangerous_attribute"
))
return issues
def _check_file_operations(self, tree: ast.AST) -> list[ValidationIssue]:
"""Check for file operations."""
issues = []
if not self.allow_file_ops:
for node in ast.walk(tree):
if isinstance(node, ast.Call):
if isinstance(node.func, ast.Name) and node.func.id == 'open':
issues.append(ValidationIssue(
severity=ValidationSeverity.ERROR,
message="File operations not allowed",
line_number=node.lineno,
rule="file_operation_blocked"
))
return issues
def _check_dangerous_patterns(self, code: str) -> list[ValidationIssue]:
"""Check for dangerous patterns using regex."""
issues = []
# Check for shell commands
if re.search(r'os\.system|subprocess\.', code):
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message="Shell command execution detected",
rule="shell_command"
))
# Check for code injection
if re.search(r'eval\s*\(|exec\s*\(', code):
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message="Code injection pattern detected",
rule="code_injection"
))
# Check for infinite loops (basic check)
if re.search(r'while\s+True\s*:', code) and 'break' not in code:
issues.append(ValidationIssue(
severity=ValidationSeverity.WARNING,
message="Potential infinite loop detected",
rule="infinite_loop"
))
return issues
class JavaScriptValidator:
"""Validator for JavaScript code security."""
DANGEROUS_PATTERNS = [
r'eval\s*\(',
r'Function\s*\(',
r'require\s*\([\'"]child_process',
r'require\s*\([\'"]fs',
r'require\s*\([\'"]net',
r'require\s*\([\'"]http',
r'process\.exit',
r'process\.kill',
r'__dirname',
r'__filename',
]
def __init__(self, allow_network: bool = False, allow_file_ops: bool = False) -> None:
"""
Initialize JavaScript validator.
Args:
allow_network: Whether to allow network operations
allow_file_ops: Whether to allow file operations
"""
self.allow_network = allow_network
self.allow_file_ops = allow_file_ops
def validate(self, code: str) -> ValidationResult:
"""
Validate JavaScript code for security issues.
Args:
code: JavaScript code to validate
Returns:
ValidationResult with detected issues
"""
issues: list[ValidationIssue] = []
# Check for dangerous patterns
for pattern in self.DANGEROUS_PATTERNS:
if re.search(pattern, code):
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous pattern detected: {pattern}",
rule="dangerous_pattern"
))
# Check for network operations
if not self.allow_network:
if re.search(r'fetch\s*\(|axios\.|http\.|net\.', code):
issues.append(ValidationIssue(
severity=ValidationSeverity.ERROR,
message="Network operations not allowed",
rule="network_blocked"
))
# Check for file operations
if not self.allow_file_ops:
if re.search(r'fs\.|readFile|writeFile', code):
issues.append(ValidationIssue(
severity=ValidationSeverity.ERROR,
message="File operations not allowed",
rule="file_operation_blocked"
))
is_safe = not any(
issue.severity in {ValidationSeverity.CRITICAL, ValidationSeverity.ERROR}
for issue in issues
)
return ValidationResult(is_safe=is_safe, issues=issues, language="javascript")
class BashValidator:
"""Validator for Bash/Shell script security."""
DANGEROUS_COMMANDS = {
'rm', 'dd', 'mkfs', 'fdisk', 'format',
'shutdown', 'reboot', 'halt', 'poweroff',
'sudo', 'su', 'chmod', 'chown', 'chgrp',
'curl', 'wget', 'nc', 'netcat', 'telnet',
'ssh', 'scp', 'ftp', 'rsync'
}
def __init__(self, allow_network: bool = False) -> None:
"""
Initialize Bash validator.
Args:
allow_network: Whether to allow network operations
"""
self.allow_network = allow_network
def validate(self, code: str) -> ValidationResult:
"""
Validate Bash code for security issues.
Args:
code: Bash script to validate
Returns:
ValidationResult with detected issues
"""
issues: list[ValidationIssue] = []
# Split into lines and check each command
lines = code.split('\n')
for line_num, line in enumerate(lines, 1):
line = line.strip()
# Skip comments and empty lines
if not line or line.startswith('#'):
continue
# Extract command (first word)
command = line.split()[0] if line.split() else ""
# Check for dangerous commands
if command in self.DANGEROUS_COMMANDS:
if command in {'curl', 'wget', 'nc', 'netcat', 'telnet', 'ssh', 'scp', 'ftp'}:
if not self.allow_network:
issues.append(ValidationIssue(
severity=ValidationSeverity.ERROR,
message=f"Network command not allowed: {command}",
line_number=line_num,
rule="network_blocked"
))
else:
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message=f"Dangerous command blocked: {command}",
line_number=line_num,
rule="dangerous_command"
))
# Check for command substitution with dangerous patterns
if re.search(r'\$\(.*rm.*\)|\$\(.*dd.*\)', line):
issues.append(ValidationIssue(
severity=ValidationSeverity.CRITICAL,
message="Dangerous command substitution detected",
line_number=line_num,
rule="dangerous_substitution"
))
is_safe = not any(
issue.severity in {ValidationSeverity.CRITICAL, ValidationSeverity.ERROR}
for issue in issues
)
return ValidationResult(is_safe=is_safe, issues=issues, language="bash")
class CodeValidator:
"""
Main code validator that dispatches to language-specific validators.
"""
def __init__(self,
allow_network: bool = False,
allow_file_ops: bool = False,
custom_allow_imports: set[str] | None = None) -> None:
"""
Initialize code validator.
Args:
allow_network: Whether to allow network operations
allow_file_ops: Whether to allow file operations
custom_allow_imports: Custom set of allowed Python imports
"""
self.python_validator = PythonValidator(
allow_imports=custom_allow_imports,
allow_file_ops=allow_file_ops,
allow_network=allow_network
)
self.javascript_validator = JavaScriptValidator(
allow_network=allow_network,
allow_file_ops=allow_file_ops
)
self.bash_validator = BashValidator(allow_network=allow_network)
def validate(self, code: str, language: str) -> ValidationResult:
"""
Validate code based on language.
Args:
code: Code to validate
language: Programming language (python, javascript, bash)
Returns:
ValidationResult with detected issues
Raises:
ValueError: If language is not supported
"""
language = language.lower()
if language in {'python', 'py'}:
return self.python_validator.validate(code)
elif language in {'javascript', 'js', 'node'}:
return self.javascript_validator.validate(code)
elif language in {'bash', 'sh', 'shell'}:
return self.bash_validator.validate(code)
else:
raise ValueError(f"Unsupported language: {language}")
def is_safe(self, code: str, language: str) -> bool:
"""
Quick check if code is safe to execute.
Args:
code: Code to check
language: Programming language
Returns:
True if code is safe, False otherwise
"""
try:
result = self.validate(code, language)
return result.is_safe
except Exception:
return False

Xet Storage Details

Size:
17.2 kB
·
Xet hash:
6f88b28effe7630021a95676dbad8b29cdcd8ade473b6170b3b96da8b2efbc20

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.