Buckets:

download
raw
17.3 kB
#!/usr/bin/env python3
"""
SMART Test-Generator für Zen-Ai-Pentest
Erstellt hochwertige Tests mit CommandRunner-Pattern und Golden Files
"""
import ast
import json
import os
import sys
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional
WORKSPACE = "/root/.openclaw/workspace/Zen-Ai-Pentest"
TOOLS_DIR = f"{WORKSPACE}/tools"
FIXTURES_DIR = f"{WORKSPACE}/tests/fixtures"
TESTS_DIR = f"{WORKSPACE}/tests/smart"
STATE_FILE = f"{WORKSPACE}/.smart_test_state.json"
LOG_FILE = f"{WORKSPACE}/.smart_test_generator.log"
def log(msg):
ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
line = f"[{ts}] {msg}"
print(line)
with open(LOG_FILE, "a") as f:
f.write(line + "\n")
def load_state():
if os.path.exists(STATE_FILE):
with open(STATE_FILE) as f:
return json.load(f)
return {"processed_tools": [], "generated_count": 0}
def save_state(state):
with open(STATE_FILE, "w") as f:
json.dump(state, f, indent=2)
def get_tool_modules():
"""Findet alle Tool-Module im tools/-Ordner"""
tools = []
for file in os.listdir(TOOLS_DIR):
if file.endswith("_integration.py") or file.endswith("_detector.py"):
tool_name = file.replace("_integration.py", "").replace("_detector.py", "").replace(".py", "")
tools.append(
{
"file": file,
"name": tool_name,
"path": os.path.join(TOOLS_DIR, file),
}
)
return sorted(tools, key=lambda x: x["name"])
def analyze_tool_module(filepath: str) -> Dict:
"""Analysiert ein Tool-Modul auf Funktionen und Klassen"""
try:
with open(filepath, "r", encoding="utf-8") as f:
content = f.read()
if len(content) > 50000:
return {"error": "File too large"}
tree = ast.parse(content)
info = {
"classes": [],
"functions": [],
"has_subprocess": "subprocess" in content or "os.system" in content,
"imports": [],
}
for node in ast.walk(tree):
if isinstance(node, ast.Import):
for alias in node.names:
info["imports"].append(alias.name)
elif isinstance(node, ast.ImportFrom):
if node.module:
info["imports"].append(node.module)
elif isinstance(node, ast.ClassDef):
methods = []
for item in node.body:
if isinstance(item, ast.FunctionDef):
methods.append(item.name)
info["classes"].append({"name": node.name, "methods": methods})
elif isinstance(node, ast.FunctionDef):
if not node.name.startswith("_"):
info["functions"].append(node.name)
return info
except Exception as e:
return {"error": str(e)}
def generate_tool_fixture(tool_name: str, tool_info: Dict) -> str:
"""Erstellt ein Golden File Fixture für ein Tool"""
fixture_path = os.path.join(FIXTURES_DIR, f"{tool_name}_sample.json")
if os.path.exists(fixture_path):
return fixture_path
# Generiere sinnvolles Mock-Output basierend auf Tool-Typ
mock_data = generate_mock_by_tool_type(tool_name, tool_info)
os.makedirs(FIXTURES_DIR, exist_ok=True)
with open(fixture_path, "w") as f:
json.dump(mock_data, f, indent=2)
log(f" Created fixture: {fixture_path}")
return fixture_path
def generate_mock_by_tool_type(tool_name: str, tool_info: Dict) -> Dict:
"""Generiert realistisches Mock-Output basierend auf Tool-Kategorie"""
# Port Scanner
if any(x in tool_name for x in ["nmap", "masscan", "naabu"]):
return {
"tool": tool_name,
"target": "scanme.nmap.org",
"ports": [
{
"port": 22,
"state": "open",
"service": "ssh",
"version": "OpenSSH 8.9",
},
{
"port": 80,
"state": "open",
"service": "http",
"version": "Apache 2.4",
},
{
"port": 443,
"state": "open",
"service": "https",
"version": "Apache 2.4",
},
],
"os_guess": "Linux 5.x",
"scan_time": "5.23s",
}
# Vulnerability Scanner
if any(x in tool_name for x in ["nuclei", "nikto", "vuln"]):
return {
"tool": tool_name,
"findings": [
{
"id": f"{tool_name.upper()}-001",
"name": "Example Vulnerability",
"severity": "high",
"host": "http://target.com",
"matched": "/api/users",
"description": "Sensitive endpoint exposed",
"remediation": "Add authentication",
}
],
"severity_counts": {
"critical": 1,
"high": 2,
"medium": 3,
"low": 1,
},
}
# Subdomain Scanner
if any(x in tool_name for x in ["subfinder", "amass", "gobuster", "subdomain"]):
return {
"tool": tool_name,
"domain": "target.com",
"subdomains": [
{"name": "api.target.com", "ip": "192.168.1.10"},
{"name": "admin.target.com", "ip": "192.168.1.11"},
{"name": "dev.target.com", "ip": "192.168.1.12"},
],
"count": 3,
}
# SQL Injection
if any(x in tool_name for x in ["sqlmap"]):
return {
"tool": tool_name,
"url": "http://target.com/login",
"parameter": "username",
"technique": "time-based blind",
"dbms": "MySQL",
"tables": ["users", "sessions", "logs"],
"columns": ["id", "username", "password", "email"],
"vulnerable": True,
}
# Fuzzer
if any(x in tool_name for x in ["ffuf", "wfuzz", "feroxbuster"]):
return {
"tool": tool_name,
"target": "http://target.com/FUZZ",
"findings": [
{"path": "/admin", "status": 200, "size": 1024},
{"path": "/api", "status": 401, "size": 256},
{"path": "/.env", "status": 200, "size": 512},
],
}
# Default für andere Tools
return {
"tool": tool_name,
"target": "http://target.com",
"output": "Tool executed successfully",
"findings": [{"type": "info", "message": "Example finding"}],
"status": "success",
"exit_code": 0,
}
def generate_smart_test(tool: Dict, tool_info: Dict, fixture_path: str) -> str:
"""Generiert einen qualitativ hochwertigen Test für ein Tool"""
tool_name = tool["name"]
class_names = [c["name"] for c in tool_info.get("classes", [])]
function_names = tool_info.get("functions", [])
# Hauptklasse finden
main_class = None
for cls in class_names:
if tool_name.replace("_", "").lower() in cls.lower() or "integration" in cls.lower():
main_class = cls
break
if not main_class and class_names:
main_class = class_names[0]
# Test-Funktionen generieren
test_content = f'''"""
SMART Test für {tool_name}
Generated: {datetime.now().isoformat()}
Tool: {tool["file"]}
Uses: CommandRunner Pattern + Golden Files
"""
import pytest
import json
from pathlib import Path
from unittest.mock import MagicMock, patch
# Importiere ToolExecutor für Mocking
from core.tool_executor import ToolExecutor, ToolResult, ToolResultStatus, MockToolExecutor, set_executor, reset_executor
class Test{tool_name.title().replace("_", "")}Integration:
"""
Integration Tests für {tool_name}
Verwendet Golden File: {fixture_path}
"""
@pytest.fixture
def fixture_data(self):
"""Lädt Golden File Fixture"""
fixture_path = Path("{fixture_path}")
with open(fixture_path, 'r') as f:
return json.load(f)
@pytest.fixture(autouse=True)
def reset_executor_after_test(self):
"""Reset Executor nach jedem Test"""
yield
reset_executor()
'''
# Test 1: Tool-Klasse kann importiert werden
test_content += f'''
def test_{tool_name}_importable(self):
"""
Test: Kann die {tool_name} Integration importiert werden?
"""
try:
from tools.{tool["file"].replace(".py", "")} import {main_class or "*"}
assert True
except ImportError as e:
pytest.skip(f"Tool nicht importierbar: {{e}}")
'''
# Test 2: Tool nutzt ToolExecutor (wenn es subprocess nutzt)
if tool_info.get("has_subprocess"):
test_content += f'''
def test_{tool_name}_uses_executor(self, fixture_data):
"""
Test: Nutzt {tool_name} den ToolExecutor statt direktem subprocess?
Dies ist der kritische Test - er verifiziert, dass wir das Tool mocken können.
"""
# Erstelle Mock-Executor mit Fixture-Daten
mock_executor = MockToolExecutor()
mock_executor.add_mock_response(
"{tool_name}",
ToolResult(
status=ToolResultStatus.SUCCESS,
returncode=0,
stdout=json.dumps(fixture_data),
stderr="",
command="{tool_name} target.com"
)
)
# Setze Mock als globalen Executor
set_executor(mock_executor)
# Führe Tool aus
from core.tool_executor import get_executor
executor = get_executor()
result = executor.execute_sync(["{tool_name}", "target.com"])
# Verifiziere
assert result.success, f"Tool sollte erfolgreich sein: {{result.stderr}}"
assert "{tool_name}" in result.command
assert mock_executor.was_called_with("{tool_name}")
# Parse Ergebnis
try:
parsed = json.loads(result.stdout)
assert parsed["tool"] == "{tool_name}"
except json.JSONDecodeError:
pass # Nicht alle Tools geben JSON aus
'''
# Test 3: Fixture enthält sinnvolle Daten
test_content += f'''
def test_fixture_has_valid_structure(self, fixture_data):
"""
Test: Enthält das Golden File valide Daten?
"""
assert "tool" in fixture_data
assert fixture_data["tool"] == "{tool_name}"
assert "target" in fixture_data or "url" in fixture_data or "domain" in fixture_data
'''
# Test 4: Error Handling (wenn Tool nicht installiert)
test_content += f'''
def test_{tool_name}_handles_not_installed(self):
"""
Test: Wie reagiert das Framework wenn {tool_name} nicht installiert ist?
"""
mock_executor = MockToolExecutor()
mock_executor.add_mock_response(
"{tool_name}",
ToolResult(
status=ToolResultStatus.NOT_FOUND,
returncode=-1,
stdout="",
stderr="Command not found: {tool_name}",
command="{tool_name}"
)
)
set_executor(mock_executor)
from core.tool_executor import get_executor
executor = get_executor()
result = executor.execute_sync(["{tool_name}", "target.com"])
assert not result.success
assert result.status == ToolResultStatus.NOT_FOUND
assert "not found" in result.stderr.lower() or result.returncode == -1
'''
# Test 5: Timeout Handling
test_content += f'''
def test_{tool_name}_handles_timeout(self):
"""
Test: Wie reagiert das Framework auf Timeouts?
"""
mock_executor = MockToolExecutor()
mock_executor.add_mock_response(
"{tool_name}",
ToolResult(
status=ToolResultStatus.TIMEOUT,
returncode=-1,
stdout="",
stderr="Command timed out after 300s",
command="{tool_name} target.com",
execution_time_ms=300000
)
)
set_executor(mock_executor)
from core.tool_executor import get_executor
executor = get_executor()
result = executor.execute_sync(["{tool_name}", "target.com"])
assert result.status == ToolResultStatus.TIMEOUT
assert not result.success
'''
# Test 6: Parser-Logik (wenn Klasse existiert)
if main_class:
test_content += f'''
def test_{tool_name}_parser_extracts_findings(self, fixture_data):
"""
Test: Extrahiert der Parser Schwachstellen aus dem Tool-Output?
"""
# Simuliere Tool-Output
mock_output = json.dumps(fixture_data)
# Prüfe ob Parser-Methoden existieren würden
try:
from tools.{tool["file"].replace(".py", "")} import {main_class}
# Wenn die Klasse eine parse-Methode hat, teste sie
if hasattr({main_class}, 'parse') or hasattr({main_class}, 'parse_results'):
assert True, "Parser-Methoden vorhanden"
else:
pytest.skip("Keine Parser-Methoden in Klasse gefunden")
except ImportError:
pytest.skip("Klasse nicht importierbar")
'''
# Test 7: Integration Test
test_content += f'''
@pytest.mark.integration
def test_{tool_name}_end_to_end_mocked(self, fixture_data):
"""
Integration Test: Kompletter Workflow mit gemocktem Tool
"""
mock_executor = MockToolExecutor()
mock_executor.add_mock_response(
"{tool_name}",
ToolResult(
status=ToolResultStatus.SUCCESS,
returncode=0,
stdout=json.dumps(fixture_data),
stderr="",
command="{tool_name} -target target.com",
execution_time_ms=5000
)
)
set_executor(mock_executor)
# Simuliere vollständigen Workflow
from core.tool_executor import get_executor
executor = get_executor()
# 1. Tool ausführen
result = executor.execute_sync(["{tool_name}", "-target", "target.com"])
assert result.success
# 2. Output parsen
try:
parsed = json.loads(result.stdout)
assert "tool" in parsed
# 3. Prüfe auf Findings
if "findings" in parsed:
assert isinstance(parsed["findings"], list)
elif "vulnerable" in parsed:
assert isinstance(parsed["vulnerable"], bool)
elif "ports" in parsed:
assert isinstance(parsed["ports"], list)
elif "subdomains" in parsed:
assert isinstance(parsed["subdomains"], list)
except json.JSONDecodeError:
# Nicht-JSON Output ist auch OK
assert len(result.stdout) > 0
# 4. Verifiziere Aufruf
assert mock_executor.was_called_with("{tool_name}")
calls = mock_executor.get_calls()
assert len(calls) >= 1
'''
return test_content
def main():
log("=" * 60)
log("SMART Test Generator Started")
state = load_state()
tools = get_tool_modules()
processed = set(state.get("processed_tools", []))
# Filtere bereits verarbeitete Tools
pending = [t for t in tools if t["name"] not in processed]
log(f"Total tools: {len(tools)}")
log(f"Pending: {len(pending)}")
log(f"Already processed: {len(processed)}")
if not pending:
log("All tools processed! Generating edge cases...")
# Hier könnten wir Edge-Case-Tests generieren
return 0
# Verarbeite bis zu 5 Tools pro Durchlauf
batch = pending[:5]
for tool in batch:
log(f"Processing: {tool['name']}")
# Analysiere Tool-Modul
tool_info = analyze_tool_module(tool["path"])
if "error" in tool_info:
log(f" Error analyzing: {tool_info['error']}")
continue
# Generiere Fixture
fixture_path = generate_tool_fixture(tool["name"], tool_info)
# Generiere Test
test_content = generate_smart_test(tool, tool_info, fixture_path)
# Speichere Test
os.makedirs(TESTS_DIR, exist_ok=True)
test_file = os.path.join(TESTS_DIR, f"test_{tool['name']}_smart.py")
with open(test_file, "w") as f:
f.write(test_content)
# Zähle Tests im File
test_count = test_content.count("def test_")
state["processed_tools"].append(tool["name"])
state["generated_count"] = state.get("generated_count", 0) + test_count
log(f" → {test_count} tests written to {test_file}")
log(f" → Fixture: {fixture_path}")
save_state(state)
log(f"Batch complete. Total tools processed: {len(state['processed_tools'])}")
log(f"Total tests generated: {state['generated_count']}")
return 0
if __name__ == "__main__":
sys.exit(main())

Xet Storage Details

Size:
17.3 kB
·
Xet hash:
fc8699f53e8c3656837370b49e82e52eb604463e8635a5cc614eeb95c28755f3

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