cli.ts•16.6 kB
#!/usr/bin/env node
import { Command } from 'commander';
import { ReconTools } from './tools/recon.js';
import { VulnScanTools } from './tools/vulnscan.js';
import { ExploitTools } from './tools/exploit.js';
import { WorkflowEngine } from './engines/workflow.js';
import { ReportTools } from './tools/report.js';
import { ConfigManager } from './config/settings.js';
import { SecurityValidator } from './utils/validation.js';
const program = new Command();
const configManager = new ConfigManager();
const securityValidator = new SecurityValidator(configManager);
// Initialize tools
const reconTools = new ReconTools();
const vulnScanTools = new VulnScanTools();
const exploitTools = new ExploitTools();
const workflowEngine = new WorkflowEngine();
const reportTools = new ReportTools();
program
.name('mcp-pentest-cli')
.description('MCP Pentest Framework - Command Line Interface')
.version('1.0.0');
// Reconnaissance commands
const reconCmd = program
.command('recon')
.description('Reconnaissance and information gathering');
reconCmd
.command('nmap')
.description('Perform Nmap port scan')
.argument('<target>', 'Target IP or domain')
.option('-t, --type <type>', 'Scan type: quick, full, stealth, aggressive', 'quick')
.option('--json', 'Output in JSON format')
.action(async (target, options) => {
try {
console.log(`🔍 Running Nmap scan on ${target}...`);
securityValidator.validatePentestRequest(target);
const result = await reconTools.nmapScan(target, options.type);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Scan Results for ${target}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.open_ports) {
console.log(`\n🔓 Open Ports (${result.results.open_ports.length}):`);
result.results.open_ports.forEach((port: any) => {
console.log(` ${port.port}/${port.protocol} - ${port.service} ${port.version || ''}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
reconCmd
.command('subdomains')
.description('Enumerate subdomains')
.argument('<domain>', 'Target domain')
.option('-w, --wordlist <path>', 'Custom wordlist path')
.option('--json', 'Output in JSON format')
.action(async (domain, options) => {
try {
console.log(`🔍 Enumerating subdomains for ${domain}...`);
securityValidator.validatePentestRequest(domain);
const result = await reconTools.subdomainEnum(domain, options.wordlist);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Subdomain Results for ${domain}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.subdomains) {
console.log(`\n🌐 Found Subdomains (${result.results.subdomains.length}):`);
result.results.subdomains.forEach((subdomain: string) => {
console.log(` ${subdomain}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
reconCmd
.command('tech')
.description('Detect web technologies')
.argument('<url>', 'Target URL')
.option('--json', 'Output in JSON format')
.action(async (url, options) => {
try {
console.log(`🔍 Detecting technologies for ${url}...`);
securityValidator.validatePentestRequest(url);
const result = await reconTools.techDetection(url);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Technology Detection for ${url}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.technologies) {
console.log(`\n🛠️ Detected Technologies (${result.results.technologies.length}):`);
result.results.technologies.forEach((tech: any) => {
console.log(` ${tech.technology} ${tech.version || ''} (${tech.confidence}% confidence)`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Vulnerability scanning commands
const vulnCmd = program
.command('vuln')
.description('Vulnerability scanning and assessment');
vulnCmd
.command('nuclei')
.description('Run Nuclei vulnerability scan')
.argument('<target>', 'Target URL or IP')
.option('-t, --templates <templates...>', 'Specific templates to run')
.option('-s, --severity <level>', 'Minimum severity level')
.option('--json', 'Output in JSON format')
.action(async (target, options) => {
try {
console.log(`🔍 Running Nuclei scan on ${target}...`);
securityValidator.validatePentestRequest(target);
const result = await vulnScanTools.nucleiScan(target, options.templates, options.severity);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Nuclei Scan Results for ${target}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.vulnerabilities) {
console.log(`\n🚨 Vulnerabilities Found (${result.results.vulnerabilities.length}):`);
result.results.vulnerabilities.forEach((vuln: any) => {
console.log(` [${vuln.severity.toUpperCase()}] ${vuln.name}`);
console.log(` ${vuln.description}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
vulnCmd
.command('nikto')
.description('Run Nikto web vulnerability scan')
.argument('<url>', 'Target URL')
.option('-p, --port <port>', 'Target port')
.option('--json', 'Output in JSON format')
.action(async (url, options) => {
try {
console.log(`🔍 Running Nikto scan on ${url}...`);
securityValidator.validatePentestRequest(url);
const result = await vulnScanTools.niktoScan(url, options.port ? parseInt(options.port) : undefined);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Nikto Scan Results for ${url}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.vulnerabilities) {
console.log(`\n🚨 Issues Found (${result.results.vulnerabilities.length}):`);
result.results.vulnerabilities.forEach((vuln: any) => {
console.log(` [${vuln.severity.toUpperCase()}] ${vuln.description}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Exploitation commands
const exploitCmd = program
.command('exploit')
.description('Exploitation and proof-of-concept testing');
exploitCmd
.command('search')
.description('Search for exploits')
.argument('<service>', 'Service name or version')
.option('-p, --platform <platform>', 'Target platform')
.option('--json', 'Output in JSON format')
.action(async (service, options) => {
try {
console.log(`🔍 Searching exploits for ${service}...`);
const result = await exploitTools.metasploitSearch(service, options.platform);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Exploit Search Results for ${service}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.modules) {
console.log(`\n💥 Found Modules (${result.results.modules.length}):`);
result.results.modules.forEach((module: any) => {
console.log(` ${module.name} - ${module.description}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
exploitCmd
.command('attempt')
.description('Attempt exploitation (use with caution)')
.argument('<target>', 'Target IP or URL')
.argument('<vulnerability>', 'Vulnerability to exploit')
.option('-p, --payload <payload>', 'Payload to use')
.option('--json', 'Output in JSON format')
.action(async (target, vulnerability, options) => {
try {
console.log(`⚠️ WARNING: Attempting exploitation on ${target}...`);
console.log(` Vulnerability: ${vulnerability}`);
// Extra confirmation for exploitation
const readline = require('readline').createInterface({
input: process.stdin,
output: process.stdout
});
const answer = await new Promise<string>((resolve) => {
readline.question('Are you sure you want to proceed with exploitation? (yes/no): ', resolve);
});
readline.close();
if (answer.toLowerCase() !== 'yes') {
console.log('Exploitation cancelled.');
return;
}
securityValidator.validatePentestRequest(target);
const result = await exploitTools.exploitAttempt(target, vulnerability, options.payload);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Exploitation Results for ${target}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success' && result.results.exploit_attempts) {
console.log(`\n💥 Exploitation Attempts (${result.results.exploit_attempts.length}):`);
result.results.exploit_attempts.forEach((attempt: any) => {
console.log(` [${attempt.success ? 'SUCCESS' : 'FAILED'}] ${attempt.name}`);
console.log(` ${attempt.evidence}`);
});
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Automated workflow commands
const autoCmd = program
.command('auto')
.description('Automated penetration testing workflows');
autoCmd
.command('pentest')
.description('Run automated penetration test')
.argument('<target>', 'Target IP, domain, or URL')
.option('-s, --scope <scope>', 'Test scope: network, web, full', 'full')
.option('-i, --intensity <level>', 'Test intensity: passive, active, aggressive', 'active')
.option('--json', 'Output in JSON format')
.action(async (target, options) => {
try {
console.log(`🚀 Starting automated pentest for ${target}...`);
console.log(` Scope: ${options.scope}`);
console.log(` Intensity: ${options.intensity}`);
securityValidator.validatePentestRequest(target);
const result = await workflowEngine.autoPentest(target, options.scope, options.intensity);
if (options.json) {
console.log(JSON.stringify(result, null, 2));
} else {
console.log(`\n📊 Automated Pentest Results for ${target}:`);
console.log(`Status: ${result.status}`);
if (result.status === 'success') {
const workflow = result.results.workflow;
console.log(`\n🎯 Assessment Summary:`);
console.log(` Completed Phases: ${result.results.completed_phases}/${result.results.total_phases}`);
console.log(` Risk Score: ${result.results.final_risk_score}/100`);
console.log(` Threat Level: ${result.results.threat_level.toUpperCase()}`);
console.log(`\n📋 Phase Results:`);
workflow.phases.forEach((phase: any) => {
const status = phase.status === 'completed' ? '✅' :
phase.status === 'failed' ? '❌' :
phase.status === 'skipped' ? '⏭️' : '⏸️';
console.log(` ${status} ${phase.name} - ${phase.description}`);
});
if (workflow.results.vulnerabilities.length > 0) {
console.log(`\n🚨 Vulnerabilities Found (${workflow.results.vulnerabilities.length}):`);
workflow.results.vulnerabilities.slice(0, 5).forEach((vuln: any) => {
console.log(` [${vuln.severity.toUpperCase()}] ${vuln.name}`);
});
if (workflow.results.vulnerabilities.length > 5) {
console.log(` ... and ${workflow.results.vulnerabilities.length - 5} more`);
}
}
if (workflow.recommendations.length > 0) {
console.log(`\n💡 Recommendations:`);
workflow.recommendations.forEach((rec: string) => {
console.log(` • ${rec}`);
});
}
}
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Reporting commands
const reportCmd = program
.command('report')
.description('Generate penetration test reports');
reportCmd
.command('generate')
.description('Generate penetration test report')
.argument('<target>', 'Target identifier')
.option('-f, --format <format>', 'Report format: html, pdf, json, markdown', 'html')
.option('-o, --output <file>', 'Output file path')
.action(async (target, options) => {
try {
console.log(`📝 Generating ${options.format.toUpperCase()} report for ${target}...`);
const result = await reportTools.generateReport(target, options.format);
if (result.status === 'success') {
const filename = options.output || result.results.filename;
// Save report to file
const fs = require('fs').promises;
await fs.writeFile(filename, result.results.report_content);
console.log(`✅ Report generated successfully:`);
console.log(` File: ${filename}`);
console.log(` Format: ${options.format.toUpperCase()}`);
console.log(` Target: ${target}`);
if (result.results.report_summary) {
console.log(`\n📊 Report Summary:`);
console.log(` Vulnerabilities: ${result.results.report_summary.total_vulnerabilities}`);
console.log(` Successful Exploits: ${result.results.report_summary.successful_exploits}`);
console.log(` Risk Rating: ${result.results.report_summary.risk_rating}`);
}
} else {
console.error(`❌ Report generation failed: ${result.error}`);
}
} catch (error) {
console.error(`❌ Error: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Configuration commands
const configCmd = program
.command('config')
.description('Configuration management');
configCmd
.command('show')
.description('Show current configuration')
.action(() => {
const config = configManager.getConfig();
console.log('📋 Current Configuration:');
console.log(JSON.stringify(config, null, 2));
});
configCmd
.command('validate')
.description('Validate target for testing')
.argument('<target>', 'Target to validate')
.action((target) => {
try {
securityValidator.validatePentestRequest(target);
console.log(`✅ Target ${target} is valid for testing`);
} catch (error) {
console.error(`❌ Target validation failed: ${error instanceof Error ? error.message : String(error)}`);
process.exit(1);
}
});
// Global options
program
.option('-v, --verbose', 'Enable verbose output')
.option('--no-color', 'Disable colored output')
.hook('preAction', (thisCommand) => {
if (thisCommand.opts().verbose) {
console.log(`🔧 Running: ${thisCommand.name()}`);
console.log(`📋 Arguments: ${JSON.stringify(thisCommand.args)}`);
console.log(`⚙️ Options: ${JSON.stringify(thisCommand.opts())}`);
console.log('');
}
});
// Error handling
program.exitOverride();
try {
program.parse();
} catch (err) {
console.error(`❌ Command failed: ${err instanceof Error ? err.message : String(err)}`);
process.exit(1);
}
// If no command provided, show help
if (!process.argv.slice(2).length) {
program.outputHelp();
}