Upload 5 files

This is a VM security build integrated with an obliterated uncensored local and private AI agent.

README.md

@@ -1,3 +1,53 @@
----
-license: apache-2.0
----
+# Autonomous Security Agent
+
+A self-contained security agent built with Qwen 2.5-7B running locally via LM Studio on Kali Linux. The agent can autonomously execute security tools, analyze results, and take action through an MCP (Model Context Protocol) server.
+
+## Features
+
+- **Local LLM Backend** — Qwen 2.5-7B served via LM Studio at `192.168.0.39:1234`
+- **Autonomous Tool Execution** — Runs security tools (nmap, masscan) through MCP
+- **Agent Loop** — Continuous reasoning and decision-making
+- **MCP Server** — Tool chain execution with `run_masscan`, `run_nmap`, `write_file`, `read_file`
+
+## Components
+
+- `agent_loop.py` — Main agent reasoning loop
+- `mcp_server.py` — Tool execution server
+- `tools_manifest.json` — Tool definitions
+- `request.json` — Sample request format
+
+## Security Setup
+
+### Firewall Configuration
+
+- **Outbound**: All traffic allowed
+- **Inbound**: All traffic blocked (default deny)
+- **IDS**: Suricata for behavioral alerting
+
+### Network Security
+
+- TOR integration for privacy
+- Local-only LLM inference (no external API calls)
+- MCP server bound to localhost only
+
+## Installation & Setup
+
+1. Install Kali Linux with Suricata
+2. Install LM Studio and load Qwen 2.5-7B
+3. Configure firewall rules (see docs/firewall-setup.md)
+4. Clone this repository
+5. Install Python dependencies
+6. Run the agent: `python agent_loop.py`
+
+## Documentation
+
+See the `docs/` folder for:
+
+- Detailed setup instructions
+- Firewall rule examples
+- Suricata configuration
+- MCP server setup
+
+## License
+
+MIT

agent_loop.py

@@ -0,0 +1,61 @@
+import requests
+import json
+
+OLLAMA_URL = "http://192.168.0.39:1234/v1/chat/completions"
+MCP_URL = "http://localhost:8000"
+
+def call_model(goal):
+    payload = {
+        "model": "qwen",
+        "messages": [
+            {
+                "role": "user",
+                "content": (
+                    "Generate ONLY JSON. Valid tools: run_command, run_masscan, run_nmap, write_file, read_file.\n"
+                    "Example: {\"chain\": [{\"tool\": \"run_masscan\", \"target\": \"192.168.1.100\", \"ports\": \"1-443\"}]}\n"
+                    "Goal: " + goal
+                )
+            }
+        ],
+        "temperature": 0.05
+    }
+    
+    try:
+        response = requests.post(OLLAMA_URL, json=payload, timeout=30)
+        content = response.json()["choices"][0]["message"]["content"]
+        content = content.replace("```json", "").replace("```", "").strip()
+        return json.loads(content)
+    except Exception as e:
+        print(f"Error parsing: {e}")
+        return {"chain": []}
+
+def execute_chain(chain):
+    print("\nEXECUTING:\n")
+    for i, step in enumerate(chain, 1):
+        print(f"{i}. {step}")
+        try:
+            result = requests.post(MCP_URL, json=step, timeout=30)
+            print(f"Result: {result.json()}\n")
+        except Exception as e:
+            print(f"Error: {e}\n")
+
+def main():
+    print("INTELLIGENT SECURITY AGENT\n")
+    while True:
+        goal = input("Goal: ").strip()
+        if goal.lower() == "exit":
+            break
+        if not goal:
+            continue
+        
+        data = call_model(goal)
+        chain = data.get("chain", [])
+        
+        if chain:
+            print(f"\nChain: {chain}")
+            execute_chain(chain)
+        else:
+            print("No chain generated")
+
+if __name__ == "__main__":
+    main()

mcp_server.py

@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+import subprocess, json, sys
+from flask import Flask, request, jsonify
+import logging
+app = Flask(__name__)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+SUPPORTED_TOOLS = ["run_command", "run_masscan", "run_nmap", "run_netstat", "run_sqlmap", "run_nikto", "run_hydra", "run_searchsploit", "run_curl", "run_wget", "write_file", "read_file"]
+PRIVILEGED_TOOLS = {"masscan", "nmap", "arp-scan", "wireshark", "tcpdump", "iptables", "ip6tables", "ufw", "hashcat", "airmon-ng", "aircrack-ng", "hydra", "metasploit", "burpsuite"}
+class ToolExecutor:
+    def __init__(self):
+        self.execution_log = []
+        self.error_recovery_attempts = {}
+    def execute_tool(self, tool, params):
+        if tool == "run_command": return self._run_command(params.get("command", ""))
+        elif tool == "run_masscan": return self._run_masscan(params.get("target", ""), params.get("ports", "1-65535"), params.get("rate", "1000"))
+        elif tool == "run_nmap": return self._run_nmap(params.get("target", ""), params.get("flags", "-sV"))
+        elif tool == "run_netstat": return self._run_netstat(params.get("flags", "-tuln"))
+        elif tool == "write_file": return self._write_file(params.get("filename", ""), params.get("content", ""))
+        elif tool == "read_file": return self._read_file(params.get("filename", ""))
+        return {"status": "error", "error_type": "unsupported_tool", "message": f"Tool '{tool}' not supported"}
+    def _execute_command(self, command, retry_with_sudo=False):
+        if retry_with_sudo and not command.strip().startswith("sudo"): command = f"sudo {command}"
+        try:
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=300)
+            if result.returncode == 0: return {"status": "success", "stdout": result.stdout.strip(), "stderr": result.stderr.strip()}
+            else:
+                stderr = result.stderr.lower()
+                if "permission denied" in stderr or "operation not permitted" in stderr:
+                    if not retry_with_sudo: return self._execute_command(command, retry_with_sudo=True)
+                    return {"status": "error", "error_type": "permission_denied", "message": result.stderr}
+                elif "not found" in stderr: return {"status": "error", "error_type": "command_not_found", "message": result.stderr}
+                else: return {"status": "error", "error_type": "command_failed", "message": result.stderr if result.stderr else result.stdout}
+        except subprocess.TimeoutExpired: return {"status": "error", "error_type": "timeout", "message": "Command timed out"}
+        except Exception as e: return {"status": "error", "error_type": "execution_error", "message": str(e)}
+    def _run_command(self, command):
+        if not command: return {"status": "error", "error_type": "invalid_params", "message": "No command"}
+        result = self._execute_command(command)
+        self.execution_log.append({"tool": "run_command", "result": result})
+        return result
+    def _run_masscan(self, target, ports, rate):
+        if not target: return {"status": "error", "error_type": "invalid_params", "message": "No target"}
+        command = f"masscan {target} -p {ports} --rate {rate}"
+        result = self._execute_command(command)
+        self.execution_log.append({"tool": "run_masscan", "result": result})
+        return result
+    def _run_nmap(self, target, flags):
+        if not target: return {"status": "error", "error_type": "invalid_params", "message": "No target"}
+        command = f"nmap {flags} {target}"
+        result = self._execute_command(command)
+        self.execution_log.append({"tool": "run_nmap", "result": result})
+        return result
+    def _run_netstat(self, flags):
+        command = f"netstat {flags}"
+        result = self._execute_command(command)
+        self.execution_log.append({"tool": "run_netstat", "result": result})
+        return result
+    def _write_file(self, filename, content):
+        if not filename: return {"status": "error", "message": "No filename"}
+        try:
+            with open(filename, 'w') as f: f.write(content)
+            return {"status": "success", "message": f"File written", "filename": filename}
+        except Exception as e: return {"status": "error", "message": str(e)}
+    def _read_file(self, filename):
+        if not filename: return {"status": "error", "message": "No filename"}
+        try:
+            with open(filename, 'r') as f: content = f.read()
+            return {"status": "success", "filename": filename, "content": content}
+        except Exception as e: return {"status": "error", "message": str(e)}
+executor = ToolExecutor()
+@app.route('/', methods=['POST'])
+def execute():
+    try:
+        data = request.get_json()
+        if not data:​​​​​​​​​​​​​​​​
+
+

request.json

@@ -0,0 +1,5 @@
+{
+  "tool": "write_file",
+  "filename": "auto_ai.txt",
+  "content": "This was created automatically"
+}

tools_manifest.json

@@ -0,0 +1,12 @@
+{
+  "tools": [
+    {
+      "name": "write_file",
+      "description": "Writes text content to a file on the local system",
+      "input": {
+        "filename": "string",
+        "content": "string"
+      }
+    }
+  ]
+}