background_scanner.py

#!/usr/bin/env python3
"""
Background Scanner - Runs network scans in the background and notifies when complete
"""

import argparse
import subprocess
import os
import sys
import time
import json
from datetime import datetime
from colorama import Fore, Style, init
from table_formatter import format_scan_results, save_formatted_results

# Initialize colorama
init()

def run_background_scan(target, ports=None, scan_type="-sV", output_file=None, check_exploits=True, no_table=False, format_output=None, table_style="fancy_grid"):
    """
    Run a network scan in the background
    
    Args:
        target (str): Target IP address or network range
        ports (str): Ports to scan
        scan_type (str): Type of scan to perform
        output_file (str): Output file for scan results
        check_exploits (bool): Whether to check for exploits
        no_table (bool): Whether to disable tabular output format
        format_output (str): Output file for formatted results
        table_style (str): Table style for formatted output
    """
    # Generate a timestamp for the output file if not provided
    if not output_file:
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        output_file = f"scan_results_{timestamp}.json"
    
    # Build the command
    cmd = [sys.executable, "network_scanner.py", "-t", target]
    
    if ports:
        cmd.extend(["-p", ports])
    
    if scan_type:
        cmd.extend(["-s", scan_type])
    
    cmd.extend(["-o", output_file])
    
    if check_exploits:
        cmd.append("-e")
    
    if no_table:
        cmd.append("--no-table")
    
    if table_style:
        cmd.extend(["--table-style", table_style])
    
    if format_output:
        cmd.extend(["--format-output", format_output])
    
    print(f"{Fore.BLUE}[*] Starting background scan on {target}{Style.RESET_ALL}")
    print(f"{Fore.BLUE}[*] Command: {' '.join(cmd)}{Style.RESET_ALL}")
    
    try:
        # Start the process
        if os.name == 'nt':  # Windows
            process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                creationflags=subprocess.CREATE_NEW_CONSOLE
            )
        else:  # Unix/Linux
            process = subprocess.Popen(
                cmd,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
                text=True,
                start_new_session=True
            )
        
        print(f"{Fore.GREEN}[+] Scan started with PID: {process.pid}{Style.RESET_ALL}")
        print(f"{Fore.GREEN}[+] Results will be saved to: {output_file}{Style.RESET_ALL}")
        
        if format_output:
            print(f"{Fore.GREEN}[+] Formatted results will be saved to: {format_output}{Style.RESET_ALL}")
        
        return process.pid, output_file
        
    except Exception as e:
        print(f"{Fore.RED}[!] Error starting background scan: {str(e)}{Style.RESET_ALL}")
        return None, None

def check_scan_status(pid):
    """
    Check if a scan is still running
    
    Args:
        pid (int): Process ID of the scan
        
    Returns:
        bool: True if the scan is still running, False otherwise
    """
    try:
        if os.name == 'nt':  # Windows
            output = subprocess.check_output(f"tasklist /FI \"PID eq {pid}\"", shell=True, text=True)
            return str(pid) in output
        else:  # Unix/Linux
            os.kill(pid, 0)  # This will raise an exception if the process is not running
            return True
    except:
        return False

def load_scan_results(output_file):
    """
    Load scan results from a file
    
    Args:
        output_file (str): Path to the scan results file
        
    Returns:
        dict: Scan results
    """
    try:
        if not os.path.exists(output_file):
            print(f"{Fore.RED}[!] Results file not found: {output_file}{Style.RESET_ALL}")
            return None
        
        with open(output_file, 'r') as f:
            return json.load(f)
    except Exception as e:
        print(f"{Fore.RED}[!] Error loading scan results: {str(e)}{Style.RESET_ALL}")
        return None

def main():
    parser = argparse.ArgumentParser(description="Background Network Scanner")
    parser.add_argument("-t", "--target", required=True, help="Target IP address or network range (e.g., 192.168.1.1 or 192.168.1.0/24)")
    parser.add_argument("-p", "--ports", default="1-1000", help="Ports to scan (e.g., '22,80,443' or '1-1000')")
    parser.add_argument("-s", "--scan-type", default="-sV", help="Type of scan to perform")
    parser.add_argument("-o", "--output", help="Output file for scan results")
    parser.add_argument("-e", "--exploits", action="store_true", default=True, help="Check for exploits after scanning")
    parser.add_argument("-w", "--wait", action="store_true", help="Wait for the scan to complete and show results")
    parser.add_argument("-f", "--format", action="store_true", help="Format results in a tabular format (deprecated, now always on)")
    parser.add_argument("--no-table", action="store_true", help="Disable tabular output format")
    parser.add_argument("--format-output", help="Output file for formatted results")
    parser.add_argument("--table-style", default="fancy_grid", help="Table style for formatted output (e.g., 'fancy_grid', 'grid', 'simple')")
    
    args = parser.parse_args()
    
    pid, output_file = run_background_scan(
        args.target, 
        args.ports, 
        args.scan_type, 
        args.output, 
        args.exploits,
        args.no_table,
        args.format_output,
        args.table_style
    )
    
    if pid and args.wait:
        print(f"{Fore.BLUE}[*] Waiting for scan to complete...{Style.RESET_ALL}")
        
        while check_scan_status(pid):
            time.sleep(5)
        
        print(f"{Fore.GREEN}[+] Scan complete!{Style.RESET_ALL}")
        
        # Load and display results
        results = load_scan_results(output_file)
        if results:
            if not args.no_table:
                print(f"\n{Fore.CYAN}=== Scan Results Summary ==={Style.RESET_ALL}")
                format_scan_results(output_file, args.table_style)
            else:
                print(f"{Fore.GREEN}[+] Scan results:{Style.RESET_ALL}")
                for host, host_data in results.items():
                    if host_data["status"] == "up":
                        print(f"{Fore.GREEN}[+] Host {host} is up{Style.RESET_ALL}")
                        
                        for port, port_data in host_data["ports"].items():
                            service = port_data["service"]
                            version = port_data["version"]
                            print(f"{Fore.YELLOW}[+] Port {port} - {service} {version}{Style.RESET_ALL}")

if __name__ == "__main__":
    main()