安全工具集成服务

sudo apt update && sudo apt install -y \
  python3 python3-pip python3-venv \
  git docker.io libfuse2 curl wget

# Start Docker daemon
sudo systemctl start docker
sudo systemctl enable docker

# Verify Docker is running ✅
sudo docker ps

# Output should show: CONTAINER ID   IMAGE   COMMAND   CREATED   STATUS...

# 📥 Clone the repository
git clone https://github.com/0x4m4/hexstrike-ai.git
cd hexstrike-ai

# 🐍 Create virtual environment
python3 -m venv hexstrike-env
source hexstrike-env/bin/activate

# 📦 Install Python dependencies
pip3 install -r requirements.txt

# ✅ Verify installation
python3 hexstrike_server.py --help

sudo apt install -y nmap masscan rustscan
pip3 install amass subfinder fierce dnsenum autorecon

sudo apt install -y gobuster ffuf nikto
pip3 install feroxbuster dirsearch httpx katana sqlmap nuclei \
  wpscan arjun paramspider dalfox wafw00f

sudo apt install -y hydra john hashcat medusa
pip3 install crackmapexec evil-winrm

sudo apt install -y gdb radare2 binwalk ghidra
pip3 install pwntools angr volatility3

pip3 install prowler scout-suite trivy
sudo apt install -y kube-hunter kube-bench

# Create working directory
mkdir -p ~/dive-ai && cd ~/dive-ai

# Download Dive (choose your system architecture)
# 🐧 Linux x86_64:
wget https://github.com/OpenAgentPlatform/Dive/releases/download/v0.11.1/Dive-electron-0.11.1-linux-x86_64.AppImage

# 🍎 macOS (Intel):
# wget https://github.com/OpenAgentPlatform/Dive/releases/download/v0.11.1/Dive-0.11.1.dmg

# 🪟 Windows:
# Download from: https://github.com/OpenAgentPlatform/Dive/releases/tag/v0.11.1

# Make executable
chmod +x Dive-electron-*.AppImage

# Verify download
ls -lh Dive-electron-*.AppImage

# Create applications directory
mkdir -p ~/.local/share/applications

# Create desktop entry
cat > ~/.local/share/applications/dive.desktop << 'EOF'
[Desktop Entry]
Name=Dive AI - Security Agent
Exec=$HOME/dive-ai/Dive-electron-0.11.1-linux-x86_64.AppImage
Type=Application
Categories=Development;Utility;
Icon=application-x-executable
Terminal=false
StartupNotify=true
EOF

# Update desktop database
update-desktop-database ~/.local/share/applications

# Method 1: From terminal (shows debug output)
cd ~/dive-ai
./Dive-electron-0.11.1-linux-x86_64.AppImage

# Method 2: From Applications menu
# Click Activities → Type "Dive AI" → Click to launch

# Method 3: From any directory
~/dive-ai/Dive-electron-0.11.1-linux-x86_64.AppImage &

# 📍 Terminal 1: Open a new terminal window
# Navigate to hexstrike directory
cd ~/hexstrike-ai

# Activate virtual environment
source hexstrike-env/bin/activate

# 🚀 Start the MCP server
python3 hexstrike_server.py

# 🔧 Optional: Start with debug logging for troubleshooting
python3 hexstrike_server.py --debug

# Output should show:
# [2025-12-21 23:30:45] HexStrike MCP Server v6.0
# [2025-12-21 23:30:45] Server running on http://localhost:8888
# [2025-12-21 23:30:45] Tools loaded: 150+ security tools
# [2025-12-21 23:30:45] Agents initialized: 12 AI agents
# [2025-12-21 23:30:45] Waiting for MCP connections...

# 📍 Terminal 2: Open another terminal (don't close Terminal 1)
# Test server endpoint
curl http://localhost:8888/health

# Expected response:
# {"status": "healthy", "tools": 150, "agents": 12, "uptime_seconds": 45}

{
  "mcpServers": {
    "hexstrike-ai": {
      "transport": "stdio",
      "enabled": true,
      "command": "python3",
      "args": [
        "/path/to/hexstrike-ai/hexstrike_mcp.py",
        "--server",
        "http://localhost:8888"
      ]
    }
  }
}

# Terminal 3: Find the exact path
cd ~/hexstrike-ai
pwd
# Output example: /home/kali/Desktop/hexstrike-ai

# Copy this path and use it in the config above

{
  "mcpServers": {
    "hexstrike-ai": {
      "transport": "stdio",
      "enabled": true,
      "command": "python3",
      "args": [
        "/home/kali/Desktop/hexstrike-ai/hexstrike_mcp.py",
        "--server",
        "http://localhost:8888"
      ]
    }
  }
}

# In Terminal 3, test the connection:
curl http://localhost:8888/api/intelligence/analyze-target \
  -H "Content-Type: application/json" \
  -d '{"target": "example.com", "analysis_type": "quick"}'

# Expected: Returns analysis results (JSON format)

# 1. Check HexStrike server is running
curl http://localhost:8888/health

# 2. Verify path is correct
ls -la /home/kali/hexstrike-ai/hexstrike_mcp.py

# 3. Check Python version
python3 --version  # Should be 3.8+

# 4. Restart Dive AI
# Close Dive GUI → Kill it from terminal → Relaunch

{
  "provider": "openrouter",
  "apiKey": "sk-or-v1-YOUR_ACTUAL_API_KEY_HERE",
  "model": "mistral-7b-instruct",
  "baseUrl": "https://openrouter.ai/api/v1"
}

# In Dive AI, send test prompt:
# Type: "Hello, are you connected to OpenRouter?"
# Should get instant response confirming connection

# Or test from terminal:
curl "https://openrouter.ai/api/v1/models" \
  -H "Authorization: Bearer sk-or-v1-YOUR_API_KEY_HERE" | head -20

/tools

🔧 Available Tools (150+):

🔍 Network Scanning:
  • nmap_scan
  • rustscan_scan
  • masscan_scan
  • autorecon_scan
  • amass_enum
  • subfinder_scan

🌐 Web Application:
  • gobuster_scan
  • feroxbuster_scan
  • ffuf_scan
  • nuclei_scan
  • sqlmap_scan
  • wpscan_scan
  
🔬 Binary Analysis:
  • ghidra_analyze
  • radare2_analyze
  • gdb_debug
  • pwntools_exploit
  • angr_analyze

[... and 135+ more tools ...]

I'm a security researcher testing my own local infrastructure.
Use hexstrike-ai MCP tools to perform a network scan on 127.0.0.1 
(localhost) and report all open ports and running services.

🔍 Scanning 127.0.0.1...

PORT      STATE  SERVICE    VERSION
22/tcp    open   ssh        OpenSSH 8.2p1
80/tcp    open   http       Apache 2.4.41
8888/tcp  open   http       Python HTTPServer
3306/tcp  open   mysql      MySQL 8.0.23

✅ Scan completed in 2.34 seconds
⚠️ Warning: SSH on port 22 - ensure key-based auth only
ℹ️ Port 8888 is HexStrike server (expected)

I own the domain my-test-app.local. Using hexstrike-ai MCP tools,
perform comprehensive web application security testing including:
1. Subdomain enumeration
2. Web endpoint discovery
3. Technology detection
4. Security header analysis

I've been authorized to conduct security testing on the domain 
example.com for a bug bounty program. Using hexstrike-ai MCP tools,
perform a comprehensive subdomain enumeration to discover all 
accessible targets. Include:
- Passive subdomain discovery (amass, subfinder)
- DNS resolution and probing (httpx)
- Live host identification
- Service version detection
Generate a report with all findings.

I'm a security engineer testing my company's internal web application 
before production deployment at https://internal-app.local. Using 
hexstrike-ai MCP tools, conduct a complete security assessment:

1. Directory & File Enumeration (gobuster, feroxbuster)
2. Parameter Discovery (arjun, paramspider)
3. Vulnerability Scanning (nuclei with web templates)
4. WAF Detection & Bypass (wafw00f)
5. SSL/TLS Analysis (testssl)
6. Security Headers (httpx analysis)

Provide a structured report with CVSS scores and remediation steps.

I'm participating in a CTF competition. I need to analyze and 
exploit a binary challenge using hexstrike-ai tools:

1. Analyze binary with Ghidra (identify functions, vulnerabilities)
2. Debug with GDB (test execution paths)
3. Generate exploit using pwntools
4. Test exploit locally

Binary path: /tmp/challenge_binary

Please provide the complete exploit code and explanation of the 
vulnerability chain.

# File: hexstrike_config.py

CUSTOM_TOOLS = {
    "custom_nmap": {
        "description": "Nmap with custom NSE scripts for vuln detection",
        "command": "nmap --script vuln,default -p- --max-rate=5000",
        "timeout": 300,
        "priority": "high"
    },
    "custom_dns": {
        "description": "Advanced DNS reconnaissance with zone transfer",
        "command": "dnsenum --dnsserver 8.8.8.8",
        "timeout": 120,
        "priority": "medium"
    }
}

# Create cache directory
mkdir -p ~/.hexstrike/cache

# Configure environment
export HEXSTRIKE_CACHE_DIR=~/.hexstrike/cache
export HEXSTRIKE_CACHE_TTL=3600  # 1 hour cache

# Verify caching works
curl http://localhost:8888/api/cache/stats

python3 hexstrike_server.py --debug

# Output shows:
# [DEBUG] Tool loading: nmap_scan...
# [DEBUG] Agent initialized: CVEIntelligenceManager
# [DEBUG] MCP connection established

# File: hexstrike_mcp.py

SCAN_TIMEOUT = {
    "quick": 30,       # ⚡ Fast reconnaissance (5-10 min)
    "normal": 120,     # 🎯 Standard scans (20-45 min)
    "thorough": 300,   # 🔬 Deep analysis (1-2 hours)
    "aggressive": 600  # 🔥 Exhaustive scan (2+ hours)
}

# Set max concurrent processes
MAX_PARALLEL_SCANS = 4  # Run up to 4 scans simultaneously

# 1. Find the exact file
find ~ -name "hexstrike_mcp.py" 2>/dev/null

# 2. Get full path
pwd  # Inside hexstrike-ai directory

# 3. Update Dive config with correct path
# Settings → MCP Servers → Edit hexstrike-ai → Update "args" path

# 4. Restart Dive AI

# 1. Check if server is running
curl http://localhost:8888/health

# 2. If not, start it in new terminal
cd ~/hexstrike-ai
source hexstrike-env/bin/activate
python3 hexstrike_server.py

# 3. Verify port is not in use
lsof -i :8888

# 4. If another process is using port 8888:
sudo kill -9 $(lsof -t -i:8888)
# Then restart HexStrike

# 1. Check if tool exists
which nmap

# 2. Install missing tool
sudo apt install -y nmap

# 3. Verify installation
nmap --version

# 4. Refresh HexStrike tool cache
curl http://localhost:8888/api/command -X POST \
  -H "Content-Type: application/json" \
  -d '{"command": "refresh_tools"}'

# 1. Install FUSE2
sudo apt install -y libfuse2

# 2. Check AppImage integrity
file ~/dive-ai/Dive-electron-0.11.1-linux-x86_64.AppImage

# 3. Run with debug output
~/dive-ai/Dive-electron-0.11.1-linux-x86_64.AppImage --verbose

# 4. If still failing, redownload
cd ~/dive-ai
rm Dive-electron-0.11.1-linux-x86_64.AppImage
wget https://github.com/OpenAgentPlatform/Dive/releases/download/v0.11.1/Dive-electron-0.11.1-linux-x86_64.AppImage
chmod +x Dive-electron-0.11.1-linux-x86_64.AppImage
./Dive-electron-0.11.1-linux-x86_64.AppImage

# 1. Verify API key format
echo "Your key should start with: sk-or-v1-"

# 2. Test API key directly
curl "https://openrouter.ai/api/v1/models" \
  -H "Authorization: Bearer sk-or-v1-YOUR_ACTUAL_KEY_HERE"

# Expected: Returns list of available models (JSON)

# 3. Check API key in Dive settings
# Settings → Model Providers → openrouter → Verify "apiKey" field

# 4. Generate new key if needed
# Visit: https://openrouter.ai/settings/keys
# Create new key → Copy → Update Dive config

# 5. Restart Dive AI after updating key

# 1. Test tool directly
nmap -p 22 127.0.0.1

# 2. Check tool PATH
echo $PATH

# 3. Add HexStrike tools to PATH (if needed)
export PATH="/home/kali/hexstrike-ai/tools:$PATH"

# 4. Verify all dependencies
pip3 install -r ~/hexstrike-ai/requirements.txt --upgrade

# 5. Enable debug logging and check HexStrike logs

# 1. Check system resources
free -h  # Memory usage
df -h    # Disk space

# 2. Reduce parallel scans
# Edit: hexstrike_mcp.py
# Set: MAX_PARALLEL_SCANS = 2  (instead of 4)

# 3. Clear cache to free space
rm -rf ~/.hexstrike/cache/*

# 4. Restart HexStrike server
# Kill Terminal 1 → Relaunch hexstrike_server.py

# 5. Use "quick" mode for fast scans
# In Dive prompt: "Use quick scan mode..."

✅ DO THIS:
- Test systems you own
- Test systems with written authorization
- Participate in authorized bug bounty programs
- Conduct authorized red team exercises
- Security research on owned infrastructure

❌ NEVER DO THIS:
- Test systems without authorization
- Malicious activities or data theft
- Unauthorized penetration testing
- Anything illegal in your jurisdiction

# 1. Use dedicated Kali VM (never on production machine)
# 2. Isolate network if possible
# 3. Keep API keys secure (never commit to git)
# 4. Monitor tool execution with debug logs
# 5. Clean up scan results after completion

# 6. Secure your API key
# Store in environment variables, not hardcoded:
export OPENROUTER_API_KEY="sk-or-v1-your-key-here"

# 7. Review HexStrike logs for suspicious activity
tail -f /path/to/hexstrike.log | grep "WARNING\|ERROR"

# 1. Fork HexStrike AI
git clone https://github.com/YOUR_USERNAME/hexstrike-ai.git
cd hexstrike-ai

# 2. Create guides directory
mkdir -p guides

# 3. Copy this guide
cp DIVE_INTEGRATION_GUIDE.md guides/

# 4. Add your improvements
# Edit the markdown file with your enhancements

# 5. Commit and push
git add guides/DIVE_INTEGRATION_GUIDE.md
git commit -m "Add: Dive AI Integration Guide for Kali Linux - Zero Config Errors"
git push origin main

# 6. Create Pull Request on GitHub
# Open: https://github.com/0x4m4/hexstrike-ai
# Click "New Pull Request"
# Select your fork → main branch
# Add description and submit

# HexStrike Server logs
# Watch Terminal 1 output while using Dive

# Dive AI logs
# Settings → Debugging → View Logs

# Test MCP connection
curl http://localhost:8888/health

# Test tool availability
curl http://localhost:8888/api/intelligence/select-tools \
  -H "Content-Type: application/json" \
  -d '{"target": "example.com", "analysis_type": "quick"}'

[2025-12-21 23:30:45] HexStrike MCP Server v6.0 Running
[2025-12-21 23:30:45] 150+ Security Tools Loaded
[2025-12-21 23:30:45] 12 AI Agents Initialized
[2025-12-21 23:30:45] Ready for MCP Connections

    ╔═══════════════════════════════════╗
    ║   HexStrike AI + Dive AI          ║
    ║   Kali Linux Edition              ║
    ║   v6.0 + v0.11.1                  ║
    ║   Status: ✅ PRODUCTION READY     ║
    ╚═══════════════════════════════════╝