@poolzin/pool-bot 2026.3.15 → 2026.3.16

package/extensions/hackingtool/src/index.ts

@@ -0,0 +1,181 @@
+import { HackingToolServerManager } from "./server-manager.js";
+import { HackingToolClient } from "./client.js";
+
+interface HackingToolConfig {
+  port?: number;
+  host?: string;
+  autoStart?: boolean;
+  token?: string;
+  pythonPath?: string;
+}
+
+export default async function createPlugin(
+  ctx: any
+): Promise<any> {
+  const config = ctx.config as HackingToolConfig;
+  const serverManager = new HackingToolServerManager({
+    port: config.port,
+    host: config.host,
+    pythonPath: config.pythonPath,
+  });
+
+  const client = new HackingToolClient({
+    host: config.host,
+    port: config.port,
+    token: config.token,
+  });
+
+  if (config.autoStart !== false) {
+    ctx.logger.info("Starting HackingTool MCP server...");
+    try {
+      await serverManager.start();
+      ctx.logger.info("HackingTool MCP server started successfully");
+    } catch (err) {
+      ctx.logger.error("Failed to start HackingTool MCP server:", err);
+      throw err;
+    }
+  }
+
+  ctx.cli
+    .command("pentest.status")
+    .description("Check HackingTool server status")
+    .action(async () => {
+      try {
+        const health = await client.health();
+        console.log("✅ HackingTool is running");
+        console.log("   Status:", health.status);
+        console.log("   Version:", health.version ?? "unknown");
+        console.log("   Uptime:", health.uptime ? `${Math.floor(health.uptime / 60)}m` : "N/A");
+        console.log("   Tools Available:", health.toolsAvailable);
+        console.log("   Active Scans:", health.activeScans);
+      } catch (err) {
+        console.error("❌ HackingTool is not running");
+        console.error("   Error:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("pentest.tools")
+    .description("List available penetration testing tools")
+    .action(async () => {
+      try {
+        const tools = await client.getTools();
+        console.log("🔧 Available Penetration Testing Tools:\n");
+        
+        for (const [category, toolList] of Object.entries(tools)) {
+          if (Array.isArray(toolList)) {
+            console.log(`📁 ${category.toUpperCase().replace("_", " ")}`);
+            for (const tool of toolList.slice(0, 10)) {
+              console.log(`   • ${tool}`);
+            }
+            if (toolList.length > 10) {
+              console.log(`   ... and ${toolList.length - 10} more`);
+            }
+            console.log();
+          } else {
+            console.log(`📁 ${category.toUpperCase().replace("_", " ")}`);
+            const subCategories = toolList as Record<string, string[]>;
+            for (const [subcat, subtools] of Object.entries(subCategories)) {
+              console.log(`   ${subcat.replace("_", " ")}: ${subtools.slice(0, 5).join(", ")}`);
+              if (subtools.length > 5) {
+                console.log(`      ... and ${subtools.length - 5} more`);
+              }
+            }
+            console.log();
+          }
+        }
+      } catch (err) {
+        console.error("❌ Failed to get tools:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("pentest.scan")
+    .description("Run penetration testing tool")
+    .argument("<category>", "Tool category (e.g., information_gathering, sql_injection, web_attack)")
+    .argument("<tool>", "Tool name (e.g., nmap, sqlmap, dirb)")
+    .argument("[target]", "Target URL or IP (optional)")
+    .option("-o, --output <file>", "Save results to file")
+    .action(async (category: string, tool: string, target?: string, options?: { output?: string }) => {
+      try {
+        console.log(`🚀 Running ${tool} from ${category}...`);
+        if (target) {
+          console.log(`   Target: ${target}`);
+        }
+        
+        const result = await client.runTool(category, tool, target);
+        console.log(`✅ Tool execution ${result.status}`);
+        console.log(`   Scan ID: ${result.scanId}`);
+        
+        if (result.result) {
+          if (result.result.simulated) {
+            console.log(`   ℹ️  ${result.result.message}`);
+          } else if (result.result.stdout) {
+            console.log("\n📊 Output:");
+            console.log(result.result.stdout);
+          } else if (result.result.error) {
+            console.log(`   ❌ Error: ${result.result.error}`);
+          }
+        }
+        
+        if (options?.output && result.result) {
+          const fs = await import("fs");
+          fs.writeFileSync(options.output, JSON.stringify(result.result, null, 2));
+          console.log(`\n💾 Results saved to: ${options.output}`);
+        }
+      } catch (err) {
+        console.error("❌ Scan failed:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("pentest.scans")
+    .description("List active scans")
+    .action(async () => {
+      try {
+        const scans = await client.listScans();
+        if (scans.length === 0) {
+          console.log("ℹ️  No active scans");
+          return;
+        }
+        
+        console.log("🔍 Active Scans:\n");
+        for (const scan of scans) {
+          const statusIcon = scan.status === "running" ? "🔄" : scan.status === "completed" ? "✅" : "❌";
+          console.log(`${statusIcon} ${scan.scanId} - ${scan.tool} (${scan.status})`);
+          if (scan.target) {
+            console.log(`   Target: ${scan.target}`);
+          }
+          console.log(`   Started: ${new Date((scan.startedAt || 0) * 1000).toLocaleString()}`);
+          console.log();
+        }
+      } catch (err) {
+        console.error("❌ Failed to list scans:", err instanceof Error ? err.message : String(err));
+        process.exit(1);
+      }
+    });
+
+  ctx.cli
+    .command("pentest.stop")
+    .description("Stop HackingTool server")
+    .action(async () => {
+      ctx.logger.info("Stopping HackingTool server...");
+      await serverManager.stop();
+      console.log("✅ HackingTool server stopped");
+    });
+
+  return {
+    name: "hackingtool",
+    version: "1.2.0",
+    async onShutdown() {
+      ctx.logger.info("Stopping HackingTool server...");
+      await serverManager.stop();
+    },
+  };
+}
+
+export { HackingToolServerManager, HackingToolClient };
+export type { HackingToolConfig };

package/extensions/hackingtool/src/server/hackingtool_mcp.py

@@ -0,0 +1,454 @@
+#!/usr/bin/env python3
+"""
+HackingTool MCP Server - Security Testing Platform
+Integrates 100+ security tools for penetration testing and security assessment.
+"""
+
+import sys
+import json
+import subprocess
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+import asyncio
+import hashlib
+import time
+
+
+class HackingToolServer:
+    """MCP server for HackingTool security platform."""
+
+    def __init__(self, port: int = 8889, host: str = "127.0.0.1"):
+        self.port = port
+        self.host = host
+        self.start_time = time.time()
+        self.active_scans: Dict[str, Dict[str, Any]] = {}
+        self.tool_categories = {
+            "anonymity": "Anonymously Hiding Tools",
+            "information_gathering": "Information Gathering Tools",
+            "wordlist": "Wordlist Generator",
+            "wireless": "Wireless Attack Tools",
+            "sql_injection": "SQL Injection Tools",
+            "phishing": "Phishing Attack Tools",
+            "web_attack": "Web Attack Tools",
+            "post_exploitation": "Post Exploitation Tools",
+            "forensic": "Forensic Tools",
+            "payload": "Payload Creation Tools",
+            "exploit": "Exploit Framework",
+            "reverse_engineering": "Reverse Engineering Tools",
+            "ddos": "DDOS Attack Tools",
+            "rat": "Remote Administrator Tools",
+            "xss": "XSS Attack Tools",
+            "steganography": "Steganography Tools",
+            "other": "Other Tools",
+        }
+
+    def get_health(self) -> Dict[str, Any]:
+        """Get server health status."""
+        return {
+            "status": "healthy",
+            "version": "1.2.0",
+            "uptime": time.time() - self.start_time,
+            "active_scans": len(self.active_scans),
+            "tools_available": sum(len(tools) for tools in self.get_tools().values()),
+        }
+
+    def get_tools(self) -> Dict[str, List[str]]:
+        """Get available tools by category."""
+        return {
+            "anonymity": ["Anonmously Surf", "Multitor"],
+            "information_gathering": [
+                "nmap",
+                "Dracnmap",
+                "Port Scan",
+                "Host2IP",
+                "Xerosploit",
+                "RED HAWK",
+                "ReconSpider",
+                "IsItDown",
+                "Infoga",
+                "ReconDog",
+                "Striker",
+                "SecretFinder",
+                "Shodanfy",
+                "rang3r",
+                "ranger-reloaded",
+                "Breacher",
+            ],
+            "wordlist": [
+                "Cupp",
+                "WordlistCreator",
+                "Goblin WordGenerator",
+                "Password List",
+            ],
+            "wireless": [
+                "WiFi-Pumpkin",
+                "pixiewps",
+                "Bluepot",
+                "Fluxion",
+                "Wifiphisher",
+                "Wifite",
+                "EvilTwin",
+                "Fastssh",
+                "Howmanypeople",
+            ],
+            "sql_injection": [
+                "Sqlmap",
+                "NoSqlMap",
+                "DSSS",
+                "Explo",
+                "Blisqy",
+                "Leviathan",
+                "SQLScan",
+            ],
+            "phishing": [
+                "Setoolkit",
+                "SocialFish",
+                "HiddenEye",
+                "Evilginx2",
+                "I-See_You",
+                "SayCheese",
+                "QR Code Jacking",
+                "ShellPhish",
+                "BlackPhish",
+            ],
+            "web_attack": [
+                "Web2Attack",
+                "Skipfish",
+                "Sublist3r",
+                "CheckURL",
+                "Blazy",
+                "takeover",
+                "Dirb",
+            ],
+            "post_exploitation": ["Vegile", "HeraKeylogger"],
+            "forensic": [
+                "Autopsy",
+                "Wireshark",
+                "Bulk extractor",
+                "Guymager",
+                "Toolsley",
+                "Volatility3",
+            ],
+            "payload": [
+                "The FatRat",
+                "Brutal",
+                "Stitch",
+                "MSFvenom Payload Creator",
+                "Venom",
+                "Spycam",
+                "Mob-Droid",
+                "Enigma",
+            ],
+            "exploit": ["RouterSploit", "WebSploit", "Commix", "Web2Attack"],
+            "reverse_engineering": ["Androguard", "Apk2Gold", "JadX"],
+            "ddos": ["SlowLoris", "aSYNcrone", "UFOnet", "GoldenEye"],
+            "rat": ["Stitch", "Pyshell"],
+            "xss": [
+                "DalFox",
+                "XSS-LOADER",
+                "extended-xss-search",
+                "XSS-Freak",
+                "XSpear",
+                "XSSCon",
+                "XanXSS",
+                "XSStrike",
+                "RVuln",
+                "Cyclops",
+            ],
+            "steganography": [
+                "SteganoHide",
+                "StegnoCracker",
+                "StegoCracker",
+                "Whitespace",
+            ],
+            "other": {
+                "social_bruteforce": [
+                    "Instagram Attack",
+                    "AllinOne Attack",
+                    "Facebook Attack",
+                    "Application Checker",
+                ],
+                "android_hacking": [
+                    "Keydroid",
+                    "MySMS",
+                    "Lockphish",
+                    "DroidCam",
+                    "EvilApp",
+                    "HatCloud",
+                ],
+                "homograph": ["EvilURL"],
+                "email_verify": ["KnockMail"],
+                "hash_cracking": ["Hash Buster"],
+                "wifi_deauth": ["WifiJammer-NG", "KawaiiDeauther"],
+                "social_finder": [
+                    "Social Mapper",
+                    "finduser",
+                    "Sherlock",
+                    "SocialScan",
+                ],
+                "payload_injector": ["Debinject", "Pixload"],
+                "web_crawling": ["Gospider"],
+                "mix": ["Terminal Multiplexer", "Crivo"],
+            },
+        }
+
+    def run_tool(
+        self,
+        category: str,
+        tool_name: str,
+        target: Optional[str] = None,
+        options: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Execute a security tool."""
+        scan_id = hashlib.md5(
+            f"{category}_{tool_name}_{time.time()}".encode()
+        ).hexdigest()[:12]
+
+        self.active_scans[scan_id] = {
+            "category": category,
+            "tool": tool_name,
+            "target": target,
+            "options": options or {},
+            "status": "running",
+            "started_at": time.time(),
+        }
+
+        try:
+            result = self._execute_tool(category, tool_name, target, options)
+            self.active_scans[scan_id]["status"] = "completed"
+            self.active_scans[scan_id]["completed_at"] = time.time()
+            self.active_scans[scan_id]["result"] = result
+
+            return {"scan_id": scan_id, "status": "completed", "result": result}
+        except Exception as e:
+            self.active_scans[scan_id]["status"] = "failed"
+            self.active_scans[scan_id]["error"] = str(e)
+
+            return {"scan_id": scan_id, "status": "failed", "error": str(e)}
+
+    def _execute_tool(
+        self,
+        category: str,
+        tool_name: str,
+        target: Optional[str],
+        options: Optional[Dict[str, Any]],
+    ) -> Dict[str, Any]:
+        """Execute the actual tool command."""
+        tool_lower = tool_name.lower().replace(" ", "_").replace("-", "_")
+
+        cmd_mapping = {
+            "nmap": lambda t: ["nmap", "-sV", "-sC", t] if t else ["nmap", "--help"],
+            "sqlmap": lambda t: (
+                ["sqlmap", "-u", t, "--batch"] if t else ["sqlmap", "--help"]
+            ),
+            "dirb": lambda t: (
+                ["dirb", t, "/usr/share/wordlists/dirb/common.txt"]
+                if t
+                else ["dirb", "--help"]
+            ),
+            "nikto": lambda t: ["nikto", "-h", t] if t else ["nikto", "--help"],
+            "gobuster": lambda t: (
+                [
+                    "gobuster",
+                    "dir",
+                    "-u",
+                    t,
+                    "-w",
+                    "/usr/share/wordlists/dirb/common.txt",
+                ]
+                if t
+                else ["gobuster", "--help"]
+            ),
+            "wpscan": lambda t: (
+                ["wpscan", "--url", t, "--enumerate", "vp,u"]
+                if t
+                else ["wpscan", "--help"]
+            ),
+            "sublist3r": lambda t: (
+                ["sublist3r", "-d", t] if t else ["sublist3r", "--help"]
+            ),
+            "sherlock": lambda t: ["sherlock", t] if t else ["sherlock", "--help"],
+        }
+
+        cmd_func = cmd_mapping.get(tool_lower)
+
+        if not cmd_func:
+            return {
+                "tool": tool_name,
+                "category": category,
+                "simulated": True,
+                "message": f"Tool {tool_name} would be executed (requires installation)",
+                "target": target,
+                "options": options,
+            }
+
+        cmd = cmd_func(target) if target else cmd_func(None)
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+
+            return {
+                "tool": tool_name,
+                "category": category,
+                "target": target,
+                "stdout": result.stdout,
+                "stderr": result.stderr,
+                "returncode": result.returncode,
+                "execution_time": time.time()
+                - self.active_scans.get(cmd.split()[0], {}).get(
+                    "started_at", time.time()
+                ),
+            }
+        except subprocess.TimeoutExpired:
+            return {"tool": tool_name, "error": "Tool execution timed out (5 minutes)"}
+        except FileNotFoundError:
+            return {
+                "tool": tool_name,
+                "error": f"Tool '{tool_name}' not found. Please install it first.",
+                "installation_hint": f"sudo apt install {tool_lower}",
+            }
+
+    def get_scan_status(self, scan_id: str) -> Dict[str, Any]:
+        """Get status of a scan."""
+        if scan_id not in self.active_scans:
+            return {"error": f"Scan {scan_id} not found"}
+
+        scan = self.active_scans[scan_id]
+        return {
+            "scan_id": scan_id,
+            "status": scan["status"],
+            "category": scan["category"],
+            "tool": scan["tool"],
+            "target": scan.get("target"),
+            "started_at": scan.get("started_at"),
+            "completed_at": scan.get("completed_at"),
+            "duration": (scan.get("completed_at") or time.time())
+            - scan.get("started_at"),
+        }
+
+    def list_scans(self) -> List[Dict[str, Any]]:
+        """List all active scans."""
+        return [
+            {
+                "scan_id": scan_id,
+                "status": scan["status"],
+                "tool": scan["tool"],
+                "target": scan.get("target"),
+                "started_at": scan.get("started_at"),
+            }
+            for scan_id, scan in self.active_scans.items()
+        ]
+
+
+def main():
+    """Main MCP server entry point."""
+    import argparse
+
+    parser = argparse.ArgumentParser(description="HackingTool MCP Server")
+    parser.add_argument("--port", type=int, default=8889, help="Server port")
+    parser.add_argument("--host", type=str, default="127.0.0.1", help="Server host")
+    parser.add_argument("--stdio", action="store_true", help="Use stdio transport")
+
+    args = parser.parse_args()
+
+    server = HackingToolServer(port=args.port, host=args.host)
+
+    if args.stdio:
+        print(
+            json.dumps({"status": "ready", "message": "HackingTool MCP Server ready"}),
+            flush=True,
+        )
+
+        for line in sys.stdin:
+            try:
+                request = json.loads(line.strip())
+                method = request.get("method")
+                params = request.get("params", {})
+
+                if method == "health":
+                    response = server.get_health()
+                elif method == "tools":
+                    response = server.get_tools()
+                elif method == "run_tool":
+                    response = server.run_tool(
+                        params.get("category", "other"),
+                        params.get("tool_name"),
+                        params.get("target"),
+                        params.get("options"),
+                    )
+                elif method == "scan_status":
+                    response = server.get_scan_status(params.get("scan_id"))
+                elif method == "list_scans":
+                    response = server.list_scans()
+                else:
+                    response = {"error": f"Unknown method: {method}"}
+
+                print(json.dumps({"result": response}), flush=True)
+            except Exception as e:
+                print(json.dumps({"error": str(e)}), flush=True)
+    else:
+        from http.server import HTTPServer, BaseHTTPRequestHandler
+
+        class MCPHandler(BaseHTTPRequestHandler):
+            def do_POST(self):
+                content_length = int(self.headers.get("Content-Length", 0))
+                post_data = self.rfile.read(content_length)
+
+                try:
+                    request = json.loads(post_data.decode())
+                    method = request.get("method")
+                    params = request.get("params", {})
+
+                    if method == "health":
+                        response = server.get_health()
+                    elif method == "tools":
+                        response = server.get_tools()
+                    elif method == "run_tool":
+                        response = server.run_tool(
+                            params.get("category", "other"),
+                            params.get("tool_name"),
+                            params.get("target"),
+                            params.get("options"),
+                        )
+                    elif method == "scan_status":
+                        response = server.get_scan_status(params.get("scan_id"))
+                    elif method == "list_scans":
+                        response = server.list_scans()
+                    else:
+                        response = {"error": f"Unknown method: {method}"}
+
+                    self.send_response(200)
+                    self.send_header("Content-Type", "application/json")
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"result": response}).encode())
+                except Exception as e:
+                    self.send_response(500)
+                    self.end_headers()
+                    self.wfile.write(json.dumps({"error": str(e)}).encode())
+
+            def do_GET(self):
+                if self.path == "/health":
+                    response = server.get_health()
+                elif self.path == "/tools":
+                    response = server.get_tools()
+                elif self.path.startswith("/scan/"):
+                    scan_id = self.path.split("/")[2]
+                    response = server.get_scan_status(scan_id)
+                elif self.path == "/scans":
+                    response = server.list_scans()
+                else:
+                    response = {"error": "Not found"}
+
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.end_headers()
+                self.wfile.write(json.dumps(response).encode())
+
+        httpd = HTTPServer((args.host, args.port), MCPHandler)
+        print(f"HackingTool MCP Server running on http://{args.host}:{args.port}")
+        httpd.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

package/extensions/hackingtool/src/server/requirements.txt

@@ -0,0 +1,2 @@
+requests>=2.28.0
+flask>=2.0.0