pynetworkintel 0.2.0__py3-none-any.whl

pynetworkintel/cli.py

@@ -0,0 +1,353 @@
+"""Command-line interface for PyNetworkIntel."""
+
+import argparse
+import json
+import sys
+import logging
+import os
+from typing import Optional
+
+from pynetworkintel import Scanner, Analyzer
+from pynetworkintel.core import Pipeline
+from pynetworkintel.config import ConfigManager
+from pynetworkintel.progress import ProgressIndicator, OutputFormatter
+
+logger = logging.getLogger(__name__)
+
+# Progress indicator (global)
+progress = ProgressIndicator()
+formatter = OutputFormatter()
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="AI-powered network intelligence and vulnerability discovery",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Scan a subnet
+  pynetworkintel scan 192.168.1.0/24
+
+  # Scan with config grabbing (requires SSH access)
+  pynetworkintel scan 192.168.1.0/24 --ssh-user admin --ssh-key ~/.ssh/id_rsa
+
+  # Run full pipeline with LLM summary
+  pynetworkintel analyze 192.168.1.0/24 --summarize
+
+  # Get findings in JSON format
+  pynetworkintel scan 192.168.1.0/24 --output json
+
+  # Save results to file
+  pynetworkintel analyze 192.168.1.0/24 --output-file results.json
+
+  # Use custom config file
+  pynetworkintel scan 192.168.1.0/24 --config ~/.pynetworkintel/config.yaml
+
+  # Initialize default config
+  pynetworkintel init-config
+""",
+    )
+
+    # Global options
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s 0.2.0",
+    )
+    parser.add_argument(
+        "--verbose",
+        action="store_true",
+        help="Enable verbose logging",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    parser.add_argument(
+        "--config",
+        help="Path to config file (default: ~/.pynetworkintel/config.yaml)",
+    )
+    parser.add_argument(
+        "--no-color",
+        action="store_true",
+        help="Disable colored output",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Init config command
+    init_parser = subparsers.add_parser("init-config", help="Initialize default config")
+    init_parser.set_defaults(func=handle_init_config)
+
+    # Scan command
+    scan_parser = subparsers.add_parser("scan", help="Scan network for devices")
+    scan_parser.add_argument("target", help="Target IP, CIDR range, or hostname")
+    scan_parser.add_argument(
+        "--no-config-grab",
+        action="store_true",
+        help="Skip SSH config grabbing",
+    )
+    scan_parser.add_argument(
+        "--ssh-user",
+        default="root",
+        help="SSH username for config grabbing (default: root)",
+    )
+    scan_parser.add_argument(
+        "--ssh-key",
+        help="SSH private key path for authentication",
+    )
+    scan_parser.add_argument(
+        "--ssh-password",
+        help="SSH password (if not using key-based auth)",
+    )
+    scan_parser.add_argument(
+        "--output",
+        choices=["text", "json"],
+        default="text",
+        help="Output format",
+    )
+    scan_parser.add_argument(
+        "--output-file",
+        help="Save results to file (auto-detect format from extension)",
+    )
+    scan_parser.set_defaults(func=handle_scan)
+
+    # Analyze command
+    analyze_parser = subparsers.add_parser(
+        "analyze", help="Scan and perform full analysis"
+    )
+    analyze_parser.add_argument("target", help="Target IP, CIDR range, or hostname")
+    analyze_parser.add_argument(
+        "--ssh-user",
+        default="root",
+        help="SSH username (default: root)",
+    )
+    analyze_parser.add_argument(
+        "--ssh-key",
+        help="SSH private key path",
+    )
+    analyze_parser.add_argument(
+        "--ssh-password",
+        help="SSH password",
+    )
+    analyze_parser.add_argument(
+        "--summarize",
+        action="store_true",
+        help="Generate AI-powered summary of findings",
+    )
+    analyze_parser.add_argument(
+        "--output",
+        choices=["text", "json"],
+        default="text",
+        help="Output format",
+    )
+    analyze_parser.add_argument(
+        "--api-key",
+        help="Anthropic API key for AI summaries (or set ANTHROPIC_API_KEY env var)",
+    )
+    analyze_parser.add_argument(
+        "--output-file",
+        help="Save results to file",
+    )
+    analyze_parser.set_defaults(func=handle_analyze)
+
+    args = parser.parse_args()
+
+    # Setup logging
+    if args.debug:
+        logging.basicConfig(level=logging.DEBUG)
+    elif args.verbose:
+        logging.basicConfig(level=logging.INFO)
+    else:
+        logging.basicConfig(level=logging.WARNING)
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    try:
+        return args.func(args)
+    except KeyboardInterrupt:
+        progress.error("Scanning interrupted by user")
+        return 1
+    except Exception as e:
+        progress.error(f"{e}")
+        logger.exception("Unhandled error")
+        return 1
+
+
+def handle_init_config(args) -> int:
+    """Handle init-config command."""
+    config_manager = ConfigManager()
+    config_manager.create_default_config()
+    progress.success(f"Config created at {config_manager.config_file}")
+    return 0
+
+
+def handle_scan(args) -> int:
+    """Handle scan command."""
+    progress.section(f"Scanning {args.target}")
+
+    scanner = Scanner(
+        ssh_username=args.ssh_user,
+        ssh_key_path=args.ssh_key,
+        ssh_password=args.ssh_password,
+    )
+
+    progress.status(f"Starting scan of {args.target}...")
+
+    scan_result = scanner.scan(
+        args.target,
+        grab_configs=not args.no_config_grab,
+    )
+
+    progress.success(f"Discovered {len(scan_result.devices)} devices in {scan_result.scan_duration_seconds:.1f}s")
+
+    if args.output == "json":
+        output = scan_result.to_dict()
+        result_str = json.dumps(output, indent=2, default=str)
+    else:
+        result_str = format_scan_output(scan_result)
+
+    if args.output_file:
+        with open(args.output_file, "w") as f:
+            f.write(result_str)
+        progress.success(f"Results saved to {args.output_file}")
+    else:
+        print(result_str)
+
+    return 0
+
+
+def handle_analyze(args) -> int:
+    """Handle analyze command."""
+    api_key = getattr(args, 'api_key', None) or os.getenv("ANTHROPIC_API_KEY")
+
+    progress.section(f"Analyzing {args.target}")
+
+    pipeline = Pipeline(
+        ssh_username=args.ssh_user,
+        ssh_key_path=args.ssh_key,
+        ssh_password=args.ssh_password,
+        anthropic_api_key=api_key,
+    )
+
+    progress.status(f"Scanning network {args.target}...")
+
+    result = pipeline.run(
+        args.target,
+        grab_configs=True,
+        summarize=args.summarize,
+    )
+
+    if args.output == "json":
+        result_str = json.dumps(result, indent=2, default=str)
+    else:
+        result_str = format_analysis_output(result, args.summarize)
+
+    if args.output_file:
+        with open(args.output_file, "w") as f:
+            f.write(result_str)
+        progress.success(f"Results saved to {args.output_file}")
+    else:
+        print(result_str)
+
+    return 0
+
+
+def format_scan_output(scan_result) -> str:
+    """Format scan results in human-readable format."""
+    output = []
+    output.append("="*60)
+    output.append("NETWORK SCAN RESULTS")
+    output.append("="*60)
+    output.append("")
+
+    output.append(f"Devices Found: {len(scan_result.devices)}")
+    output.append(f"Online Devices: {sum(1 for d in scan_result.devices if d.is_online)}")
+    output.append(f"Scan Duration: {scan_result.scan_duration_seconds:.1f}s")
+    output.append("")
+
+    if scan_result.devices:
+        output.append("Discovered Devices:")
+        output.append("-" * 60)
+        for device in scan_result.devices:
+            status = "✓ ONLINE" if device.is_online else "✗ OFFLINE"
+            hostname = device.hostname or "unknown"
+            os_info = device.os or "unknown"
+
+            output.append(f"\n{device.ip} ({hostname})")
+            output.append(f"  Status: {status}")
+            output.append(f"  OS: {os_info}")
+
+            if device.services:
+                output.append(f"  Services:")
+                for service in device.services:
+                    version = f" {service.version}" if service.version else ""
+                    output.append(f"    - Port {service.port}: {service.name}{version}")
+
+            if device.configs:
+                output.append(f"  Configs: {len(device.configs)} files grabbed")
+
+    return "\n".join(output)
+
+
+def format_analysis_output(result: dict, show_summary: bool = False) -> str:
+    """Format analysis results in human-readable format."""
+    output = []
+    output.append("="*60)
+    output.append("NETWORK ANALYSIS RESULTS")
+    output.append("="*60)
+    output.append("")
+
+    summary = result.get("summary", {})
+    output.append(f"Devices Found: {summary.get('total_devices', 0)}")
+    output.append(f"Online: {summary.get('online_devices', 0)}")
+    output.append(f"Critical Findings: {summary.get('critical_findings', 0)}")
+    output.append(f"High Priority Findings: {summary.get('high_findings', 0)}")
+    output.append(f"Total Issues: {summary.get('total_findings', 0)}")
+    output.append("")
+
+    findings = result.get("findings", [])
+    if findings:
+        output.append("Security Findings (ordered by severity):")
+        output.append("-" * 60)
+
+        # Sort by severity
+        severity_order = {"critical": 0, "high": 1, "medium": 2, "low": 3, "info": 4}
+        sorted_findings = sorted(
+            findings, key=lambda f: severity_order.get(f.get("severity"), 5)
+        )
+
+        for i, finding in enumerate(sorted_findings[:10], 1):
+            severity = finding.get("severity", "unknown").upper()
+            title = finding.get("title", "Unknown")
+            device = finding.get("device", "unknown")
+            impact = finding.get("business_impact", "")
+            rec = finding.get("recommendation", "")
+
+            output.append(f"\n{i}. [{severity}] {title}")
+            output.append(f"   Device: {device}")
+            output.append(f"   Impact: {impact}")
+            output.append(f"   Fix: {rec}")
+
+        if len(findings) > 10:
+            output.append(f"\n... and {len(findings) - 10} more findings")
+    else:
+        output.append("✓ No security issues found!")
+
+    if show_summary and "ai_summary" in result:
+        output.append("")
+        output.append("="*60)
+        output.append("AI ANALYSIS SUMMARY")
+        output.append("="*60)
+        output.append("")
+        output.append(result["ai_summary"])
+
+    return "\n".join(output)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pynetworkintel/config.py

@@ -0,0 +1,191 @@
+"""Configuration management for PyNetworkIntel."""
+
+import os
+import yaml
+import logging
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+
+logger = logging.getLogger(__name__)
+
+CONFIG_DIR = Path.home() / ".pynetworkintel"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+@dataclass
+class SSHConfig:
+    username: str = "root"
+    key_path: Optional[str] = None
+    password: Optional[str] = None
+    timeout: int = 10
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "username": self.username,
+            "key_path": self.key_path,
+            "password": self.password,
+            "timeout": self.timeout,
+        }
+
+
+@dataclass
+class ScanConfig:
+    timeout: int = 300
+    nmap_args: str = "-sV"
+    grab_configs: bool = True
+    retry_count: int = 1
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "timeout": self.timeout,
+            "nmap_args": self.nmap_args,
+            "grab_configs": self.grab_configs,
+            "retry_count": self.retry_count,
+        }
+
+
+@dataclass
+class AnalysisConfig:
+    enable_cve_check: bool = True
+    enable_llm_summary: bool = True
+    cve_cache_ttl: int = 86400  # 1 day
+    llm_model: str = "claude-3-5-sonnet-20241022"
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "enable_cve_check": self.enable_cve_check,
+            "enable_llm_summary": self.enable_llm_summary,
+            "cve_cache_ttl": self.cve_cache_ttl,
+            "llm_model": self.llm_model,
+        }
+
+
+@dataclass
+class OutputConfig:
+    format: str = "text"  # text, json, csv
+    verbose: bool = False
+    color: bool = True
+    output_file: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "format": self.format,
+            "verbose": self.verbose,
+            "color": self.color,
+            "output_file": self.output_file,
+        }
+
+
+@dataclass
+class AppConfig:
+    ssh: SSHConfig = field(default_factory=SSHConfig)
+    scan: ScanConfig = field(default_factory=ScanConfig)
+    analysis: AnalysisConfig = field(default_factory=AnalysisConfig)
+    output: OutputConfig = field(default_factory=OutputConfig)
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "ssh": self.ssh.to_dict(),
+            "scan": self.scan.to_dict(),
+            "analysis": self.analysis.to_dict(),
+            "output": self.output.to_dict(),
+        }
+
+
+class ConfigManager:
+    """Manage PyNetworkIntel configuration."""
+
+    def __init__(self):
+        self.config_dir = CONFIG_DIR
+        self.config_file = CONFIG_FILE
+        self.config = self._load_config()
+
+    def _load_config(self) -> AppConfig:
+        """Load configuration from file or use defaults."""
+        if self.config_file.exists():
+            try:
+                with open(self.config_file, "r") as f:
+                    data = yaml.safe_load(f) or {}
+                return self._parse_config(data)
+            except Exception as e:
+                logger.warning(f"Failed to load config file: {e}, using defaults")
+
+        return AppConfig()
+
+    def _parse_config(self, data: Dict[str, Any]) -> AppConfig:
+        """Parse YAML config data into AppConfig."""
+        config = AppConfig()
+
+        if "ssh" in data:
+            ssh_data = data["ssh"]
+            config.ssh = SSHConfig(
+                username=ssh_data.get("username", config.ssh.username),
+                key_path=ssh_data.get("key_path"),
+                password=ssh_data.get("password"),
+                timeout=ssh_data.get("timeout", config.ssh.timeout),
+            )
+
+        if "scan" in data:
+            scan_data = data["scan"]
+            config.scan = ScanConfig(
+                timeout=scan_data.get("timeout", config.scan.timeout),
+                nmap_args=scan_data.get("nmap_args", config.scan.nmap_args),
+                grab_configs=scan_data.get("grab_configs", config.scan.grab_configs),
+                retry_count=scan_data.get("retry_count", config.scan.retry_count),
+            )
+
+        if "analysis" in data:
+            analysis_data = data["analysis"]
+            config.analysis = AnalysisConfig(
+                enable_cve_check=analysis_data.get("enable_cve_check", config.analysis.enable_cve_check),
+                enable_llm_summary=analysis_data.get("enable_llm_summary", config.analysis.enable_llm_summary),
+                cve_cache_ttl=analysis_data.get("cve_cache_ttl", config.analysis.cve_cache_ttl),
+                llm_model=analysis_data.get("llm_model", config.analysis.llm_model),
+            )
+
+        if "output" in data:
+            output_data = data["output"]
+            config.output = OutputConfig(
+                format=output_data.get("format", config.output.format),
+                verbose=output_data.get("verbose", config.output.verbose),
+                color=output_data.get("color", config.output.color),
+                output_file=output_data.get("output_file"),
+            )
+
+        return config
+
+    def save_config(self, config: AppConfig):
+        """Save configuration to file."""
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+
+        with open(self.config_file, "w") as f:
+            yaml.dump(config.to_dict(), f, default_flow_style=False)
+
+        logger.info(f"Config saved to {self.config_file}")
+
+    def create_default_config(self):
+        """Create default configuration file."""
+        config = AppConfig()
+        self.save_config(config)
+        logger.info(f"Created default config at {self.config_file}")
+
+    def update_from_env(self):
+        """Update configuration from environment variables."""
+        if api_key := os.getenv("ANTHROPIC_API_KEY"):
+            # API key is handled separately
+            pass
+
+        if ssh_user := os.getenv("PYNETWORKINTEL_SSH_USER"):
+            self.config.ssh.username = ssh_user
+
+        if ssh_key := os.getenv("PYNETWORKINTEL_SSH_KEY"):
+            self.config.ssh.key_path = ssh_key
+
+        if ssh_pass := os.getenv("PYNETWORKINTEL_SSH_PASSWORD"):
+            self.config.ssh.password = ssh_pass
+
+    @staticmethod
+    def get_default_config() -> AppConfig:
+        """Get default configuration."""
+        return AppConfig()