ghostnet 1.2.1__py3-none-any.whl

ghostnet/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""GhostNet - Advanced Network Scanner."""
+from .constants import VERSION as __version__
+from .cli import main
+
+__all__ = ["main", "__version__"]

ghostnet/__main__.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+import sys
+import time
+from .cli import main
+from .constants import Colors
+
+
+def _run():
+    exit_code = 0
+    try:
+        exit_code = main()
+    except KeyboardInterrupt:
+        print(f"\n{Colors.BRIGHT_RED}Program terminated by user.{Colors.RESET}")
+        exit_code = 130
+    except Exception as e:
+        print(f"\n{Colors.BRIGHT_RED}An unexpected error occurred: {e}{Colors.RESET}")
+        exit_code = 1
+    finally:
+        if len(sys.argv) <= 1:
+            time.sleep(1.5)
+    sys.exit(exit_code)
+
+
+if __name__ == "__main__":
+    _run()

ghostnet/cli.py

@@ -0,0 +1,415 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import socket
+import ssl
+import re
+import json
+import time
+import random
+import struct
+import uuid
+import copy
+import errno
+import logging
+import threading
+import getpass
+import platform
+import ipaddress
+import asyncio
+import xml.etree.ElementTree as ET
+from datetime import datetime, timedelta
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import urljoin, urlparse
+from typing import List, Dict, Any, Tuple, Optional, Union
+import pytz
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+
+from .constants import *
+import argparse
+from .config import Config
+from .parsing import parse_target_spec, parse_port_spec
+from .engine import Scanner
+from .reporting import Reporter
+from .netmap import NetworkMapper, format_topology
+from .menu import interactive_main
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        prog="ghostnet",
+        description="GhostNet - Advanced Network Scanner",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""\
+examples:
+  ghostnet -t 192.168.1.1                  scan common ports
+  ghostnet -t 192.168.1.0/24 -p-           whole subnet, all 65535 ports
+  ghostnet -t host -A                       aggressive: -sV -O -b
+  ghostnet -t host -sV -T4                  version detection, fast timing
+  ghostnet -t 192.168.1.0/24 -sn            host discovery (ping sweep) only
+  sudo ghostnet -t host --syn-scan          SYN scan (needs scapy/root)
+  ghostnet -t host -oA results              write results.txt/.json/.xml
+  ghostnet --update-db                      refresh the local NVD database
+
+Run with no arguments for an interactive menu.
+""",
+    )
+
+    # Target specification
+    target_group = parser.add_argument_group("Target Selection")
+    target_group.add_argument("-t", "--target", dest="targets", action="append",
+                            help="Target IP address, hostname, or network (CIDR)")
+    target_group.add_argument("-iL", "--input-file", dest="input_file",
+                            help="Input from file containing targets (one per line)")
+
+    # Port specification
+    port_group = parser.add_argument_group("Port Selection")
+    port_group.add_argument("-p", "--ports", dest="ports",
+                        help="Port(s) to scan (e.g., 22,80,443 or 1-1000; '-' for all 65535)")
+    port_group.add_argument("--top-ports", dest="top_ports", type=int,
+                        help="Scan the top N most common ports")
+    
+    # Scan types
+    scan_group = parser.add_argument_group("Scan Techniques")
+    scan_group.add_argument("-sS", "--syn-scan", dest="syn_scan", action="store_true",
+                           help="TCP SYN scan (requires root/admin privileges)")
+    scan_group.add_argument("-sT", "--tcp-scan", dest="tcp_scan", action="store_true",
+                           help="TCP connect scan")
+    scan_group.add_argument("-sU", "--udp-scan", dest="udp_scan", action="store_true",
+                           help="UDP scan")
+    scan_group.add_argument("-sF", "--fast", dest="fast_mode", action="store_true",
+                           help="Fast scan mode")
+    scan_group.add_argument("-sn", "--ping-scan", dest="ping_scan", action="store_true",
+                           help="Host discovery only (ping sweep); no port scan")
+    scan_group.add_argument("-Pn", "--no-ping", dest="no_ping", action="store_true",
+                           help="Skip host discovery; treat all hosts as online "
+                                "(accepted for nmap compatibility)")
+
+    # Service and OS detection
+    service_group = parser.add_argument_group("Service/OS Detection")
+    service_group.add_argument("-sV", "--service-version", dest="service_detection", action="store_true",
+                              help="Probe open ports to determine service/version info")
+    service_group.add_argument("-O", "--os-detection", dest="os_detection", action="store_true",
+                              help="Enable OS detection")
+    service_group.add_argument("-b", "--banner", dest="banner_grabbing", action="store_true",
+                              help="Perform banner grabbing on open ports")
+    service_group.add_argument("-A", "--aggressive", dest="aggressive", action="store_true",
+                              help="Aggressive scan: enable -sV, -O and -b")
+
+    # Timing and performance
+    timing_group = parser.add_argument_group("Timing and Performance")
+    timing_group.add_argument("-T", dest="timing", type=int, choices=range(6),
+                             help="Timing template: -T0 (paranoid) .. -T5 (insane)")
+    timing_group.add_argument("--min-rate", dest="min_rate", type=int,
+                             help="Send packets no slower than <number> per second")
+    timing_group.add_argument("--max-rate", dest="max_rate", type=int,
+                             help="Send packets no faster than <number> per second")
+    timing_group.add_argument("--max-retries", dest="max_retries", type=int, default=1,
+                             help="Maximum number of retries")
+    timing_group.add_argument("--timeout", dest="timeout", type=float, default=None,
+                             help="Set timeout in seconds")
+    timing_group.add_argument("--threads", dest="threads", type=int, default=None,
+                             help="Number of concurrent threads")
+    
+    # Evasion techniques
+    evasion_group = parser.add_argument_group("Evasion and Spoofing")
+    evasion_group.add_argument("--spoof-mac", dest="spoof_mac",
+                              help="Spoof MAC address")
+    evasion_group.add_argument("--spoof-ip", dest="spoof_ip",
+                              help="Spoof source IP address")
+    evasion_group.add_argument("--source-port", dest="source_port", type=int,
+                              help="Use specified source port")
+    evasion_group.add_argument("--data-length", dest="data_length", type=int,
+                              help="Append random data to sent packets")
+    evasion_group.add_argument("--ttl", dest="ttl", type=int,
+                              help="Set IP time-to-live field")
+    evasion_group.add_argument("--randomize", dest="randomize", action="store_true",
+                              help="Randomize target and port order")
+    evasion_group.add_argument("--fragmentation", dest="fragmentation", action="store_true",
+                              help="Fragment IP packets")
+    evasion_group.add_argument("--scan-delay", dest="scan_delay", type=float, default=0,
+                              help="Add delay between packets")
+    
+    # Output options
+    output_group = parser.add_argument_group("Output")
+    output_group.add_argument("-v", "--verbose", dest="verbose", action="store_true",
+                             help="Increase verbosity level")
+    output_group.add_argument("-q", "--quiet", dest="quiet", action="store_true",
+                             help="Quiet mode")
+    output_group.add_argument("-oN", "--output-normal", dest="output_normal",
+                             help="Output in normal format to the given filename")
+    output_group.add_argument("-oX", "--output-xml", dest="output_xml",
+                             help="Output in XML format to the given filename")
+    output_group.add_argument("-oJ", "--output-json", dest="output_json",
+                             help="Output in JSON format to the given filename")
+    output_group.add_argument("-oA", "--output-all", dest="output_all",
+                             help="Write all three formats to BASENAME.txt/.json/.xml")
+    output_group.add_argument("--no-color", dest="no_color", action="store_true",
+                             help="Disable colored output")
+    
+    # Misc options
+    misc_group = parser.add_argument_group("Misc")
+    misc_group.add_argument("--interface", dest="interface",
+                           help="Use specified network interface")
+    misc_group.add_argument("-V", "--version", action="version", version=f"GhostNet {VERSION}")
+    misc_group.add_argument("--vuln-scan", dest="vuln_scan", action="store_true",
+                           help="Perform basic vulnerability checks")
+    misc_group.add_argument("--traceroute", "--map", dest="network_map", action="store_true",
+                           help="Map network topology via traceroute (requires scapy/root)")
+    misc_group.add_argument("--update-db", dest="update_db", action="store_true",
+                           help="Refresh the local NVD vulnerability database and exit "
+                                "(needs an NVD API key; see --help)")
+    misc_group.add_argument("-n", "--no-dns", dest="no_dns", action="store_true",
+                           help="Disable DNS resolution")
+    
+    return parser.parse_args()
+
+
+def configure_from_args(args):
+    """Configure the scanner from command line arguments"""
+    config = Config()
+    
+    # Parse targets
+    if args.targets:
+        for target_spec in args.targets:
+            config.targets.extend(parse_target_spec(target_spec))
+            
+    if args.input_file:
+        try:
+            with open(args.input_file, 'r') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith('#'):
+                        config.targets.extend(parse_target_spec(line))
+        except Exception as e:
+            print(f"Error reading target file: {e}")
+            sys.exit(1)
+    
+    # Parse ports
+    if args.ports:
+        config.ports = parse_port_spec(args.ports)
+    elif args.top_ports:
+        # Take the top N most common ports
+        top_n = min(args.top_ports, len(COMMON_PORTS))
+        config.ports = list(COMMON_PORTS.keys())[:top_n]
+    
+    # Scan type
+    if args.syn_scan:
+        config.scan_type = "tcp_syn"
+    elif args.udp_scan:
+        config.scan_type = "udp"
+    else:
+        config.scan_type = "tcp_connect"  # Default
+    
+    # Timing template (-T0..-T5): a baseline for timeout/threads/scan-delay
+    # that explicit flags below still override.
+    if args.timing is not None:
+        timeout, threads, delay = TIMING_TEMPLATES[args.timing]
+        config.timeout = timeout
+        config.threads = threads
+        config.scan_delay = delay
+
+    # Performance settings (explicit flags win over the timing template).
+    if args.timeout is not None:
+        config.timeout = args.timeout
+    if args.threads is not None:
+        config.threads = args.threads
+    if args.scan_delay:
+        config.scan_delay = args.scan_delay
+    config.min_rate = args.min_rate
+    config.max_rate = args.max_rate
+    if args.max_retries is not None:
+        config.max_retries = args.max_retries
+
+    # Detection features. -A (aggressive) implies -sV, -O and -b.
+    config.service_detection = args.service_detection or args.aggressive
+    config.os_detection = args.os_detection or args.aggressive
+    config.banner_grabbing = args.banner_grabbing or args.aggressive
+    config.vuln_check = args.vuln_scan
+    config.network_map = args.network_map
+
+    # Host discovery.
+    config.ping_scan = args.ping_scan   # -sn: discovery only
+    config.no_ping = args.no_ping       # -Pn: skip discovery
+
+    # Fast mode
+    if args.fast_mode:
+        config.fast_mode = True
+        config.timeout = 0.5
+        config.threads = 100
+    
+    # Evasion techniques
+    if args.spoof_ip:
+        config.source_ip = args.spoof_ip
+    if args.spoof_mac:
+        config.source_mac = args.spoof_mac
+    if args.source_port:
+        config.source_port = args.source_port
+    if args.ttl:
+        config.ttl = args.ttl
+    config.randomize = args.randomize
+    config.fragmentation = args.fragmentation
+    
+    # DNS resolution
+    config.dns_resolution = not args.no_dns
+    
+    # Interface
+    if args.interface:
+        config.interface = args.interface
+    
+    # Output settings
+    config.verbose = args.verbose
+    if args.quiet:
+        config.log_level = logging.ERROR
+    elif args.verbose:
+        config.log_level = logging.DEBUG
+    
+    # Output format and file
+    if args.output_xml:
+        config.output_file = args.output_xml
+        config.output_format = "xml"
+    elif args.output_json:
+        config.output_file = args.output_json
+        config.output_format = "json"
+    elif args.output_normal:
+        config.output_file = args.output_normal
+        config.output_format = "text"
+
+    return config
+
+
+def update_vuln_db():
+    """Refresh the local NVD vulnerability database (wraps vuln.py).
+
+    Returns an exit code. Requires an NVD API key (NVD_API_KEY env var or a
+    .env file); see https://nvd.nist.gov/developers/request-an-api-key.
+    """
+    try:
+        import vuln
+    except Exception as e:
+        print(f"{Colors.BRIGHT_RED}Could not load the NVD updater: {e}{Colors.RESET}",
+              file=sys.stderr)
+        return 1
+
+    print(f"{Colors.BRIGHT_CYAN}Refreshing the NVD vulnerability database...{Colors.RESET}")
+    try:
+        vuln.main()
+    except Exception as e:
+        # NVDVulnerabilityFetcher raises when no API key is configured.
+        print(f"{Colors.BRIGHT_RED}Database update failed: {e}{Colors.RESET}",
+              file=sys.stderr)
+        return 1
+    return 0
+
+
+
+def host_is_up(target, timeout=1.0):
+    """Lightweight TCP host discovery: an open port OR a refused connection
+    means the host is up; only a timeout/unreachable counts as down. Uses
+    connect_ex (which returns an error code rather than raising). No root
+    required."""
+    reachable = {0, errno.ECONNREFUSED, errno.ECONNRESET}
+    for port in (80, 443, 22, 445, 3389):
+        try:
+            with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+                sock.settimeout(timeout)
+                if sock.connect_ex((target, port)) in reachable:
+                    return True
+        except OSError:
+            continue
+    return False
+
+
+
+def discover_hosts(targets, timeout=1.0):
+    """Return the subset of targets that appear to be online."""
+    up = []
+    for target in targets:
+        if host_is_up(target, timeout):
+            up.append(target)
+    return up
+
+
+
+def scan_summary(results, elapsed):
+    """One-line nmap-style summary of a results dict."""
+    hosts = len(results)
+    open_ports = sum(len(d.get("open_ports", {})) for d in results.values())
+    return (f"GhostNet done: {hosts} host(s) scanned, {open_ports} open port(s) "
+            f"in {elapsed:.2f}s")
+
+
+
+def run_cli(args):
+    """Run a scan from parsed command-line arguments. Returns an exit code."""
+    if args.no_color:
+        Colors.disable()
+
+    # Database refresh is a standalone action (no targets needed).
+    if getattr(args, "update_db", False):
+        return update_vuln_db()
+
+    config = configure_from_args(args)
+
+    if not config.targets:
+        print(f"{Colors.BRIGHT_RED}Error: no targets specified. "
+              f"Use -t <target> or -iL <file>.{Colors.RESET}", file=sys.stderr)
+        return 2
+
+    # -sn: host discovery only, then exit.
+    if config.ping_scan:
+        up = discover_hosts(config.targets, config.timeout)
+        print(f"{Colors.BRIGHT_CYAN}Host discovery:{Colors.RESET}")
+        for target in config.targets:
+            status = (f"{Colors.BRIGHT_GREEN}up{Colors.RESET}" if target in up
+                      else f"{Colors.BRIGHT_BLACK}down{Colors.RESET}")
+            print(f"  {target:<18} {status}")
+        print(f"\n{len(up)}/{len(config.targets)} host(s) up")
+        return 0
+
+    # For multi-host scans, skip hosts that are down unless -Pn was given.
+    if not config.no_ping and len(config.targets) > 1:
+        up = discover_hosts(config.targets, config.timeout)
+        if up:
+            config.targets = up
+
+    start = time.time()
+    scanner = Scanner(config)
+    scanner.initialize()
+    results = scanner.run()
+    elapsed = time.time() - start
+
+    reporter = Reporter(config, results)
+    print(reporter.generate_report())
+
+    # Output files: -oA writes all three formats; otherwise the single
+    # configured format.
+    if args.output_all:
+        for fmt, ext in (("text", "txt"), ("json", "json"), ("xml", "xml")):
+            config.output_format = fmt
+            config.output_file = f"{args.output_all}.{ext}"
+            Reporter(config, results).save_report()
+    elif config.output_file:
+        reporter.save_report()
+
+    # Optional network topology mapping (traceroute).
+    if config.network_map:
+        mapper = NetworkMapper(config)
+        topology = mapper.map_network(config.targets)
+        print("\n" + format_topology(topology))
+
+    print(f"\n{Colors.BRIGHT_WHITE}{scan_summary(results, elapsed)}{Colors.RESET}")
+    return 0
+
+# Network Mapper class for network topology mapping
+
+
+def main():
+    """Entry point: dispatch to the CLI when arguments are given, otherwise
+    launch the interactive menu."""
+    if len(sys.argv) > 1:
+        args = parse_args()
+        return run_cli(args)
+    interactive_main()
+    return 0

ghostnet/config.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+import os
+import sys
+import socket
+import ssl
+import re
+import json
+import time
+import random
+import struct
+import uuid
+import copy
+import errno
+import logging
+import threading
+import getpass
+import platform
+import ipaddress
+import asyncio
+import xml.etree.ElementTree as ET
+from datetime import datetime, timedelta
+from concurrent.futures import ThreadPoolExecutor
+from urllib.parse import urljoin, urlparse
+from typing import List, Dict, Any, Tuple, Optional, Union
+import pytz
+import requests
+import urllib3
+from bs4 import BeautifulSoup
+
+from .constants import *
+
+class Config:
+    def __init__(self):
+        self.scan_type = "tcp_syn"  # Default scan type
+        self.ports = []
+        self.targets = []
+        self.timeout = 1.0
+        self.threads = 50
+        self.verbose = False
+        self.output_file = None
+        self.output_format = "text"
+        self.randomize = False
+        self.scan_delay = 0
+        self.service_detection = False
+        self.os_detection = False
+        self.banner_grabbing = False
+        self.evasion_level = 0
+        self.interface = None
+        self.source_port = None
+        self.ttl = None
+        self.source_ip = None
+        self.source_mac = None
+        self.fragmentation = False
+        self.log_level = logging.INFO
+        self.vuln_check = False
+        self.dns_resolution = True
+        self.scan_id = datetime.now().strftime("%Y%m%d%H%M%S")
+        self.fast_mode = False
+        self.network_map = False
+        self.min_rate = None      # packets/sec floor (raises the max cap)
+        self.max_rate = None      # packets/sec cap (None = unlimited)
+        self.max_retries = 1      # retries for lossy scans (UDP / SYN)
+        self.ping_scan = False    # -sn: host discovery only
+        self.no_ping = False      # -Pn: skip host discovery
+
+# CVE intergration using NVD API

ghostnet/constants.py

@@ -0,0 +1,167 @@
+# -*- coding: utf-8 -*-
+"""Shared constants, feature flags, and optional-dependency symbols.
+
+scapy/impacket symbols are defined as None when the libraries are absent so
+that `from .constants import *` always resolves in every submodule; the
+HAS_SCAPY / HAS_IMPACKET guards ensure the None values are never called.
+"""
+import sys
+import os
+
+# UTF-8 on the Windows console.
+if os.name == 'nt':
+    import codecs
+    sys.stdout = codecs.getwriter('utf-8')(sys.stdout.detach())
+    sys.stderr = codecs.getwriter('utf-8')(sys.stderr.detach())
+
+try:
+    from impacket import smb, smb3, nmb, nt_errors
+    from impacket.smbconnection import SMBConnection
+    HAS_IMPACKET = True
+except ImportError:
+    HAS_IMPACKET = False
+    smb = smb3 = nmb = nt_errors = None
+    SMBConnection = None
+    print("[!] impacket not available - SMB features disabled "
+          "(pipx inject ghostnet impacket, or pip install impacket)",
+          file=sys.stderr)
+
+try:
+    from scapy.all import (
+        IP, TCP, UDP, ICMP, Ether, sr1, srp1, send, sendp, conf,
+        sniff, rdpcap, wrpcap, RandShort,
+    )
+    HAS_SCAPY = True
+except ImportError:
+    HAS_SCAPY = False
+    IP = TCP = UDP = ICMP = Ether = sr1 = srp1 = send = sendp = conf = None
+    sniff = rdpcap = wrpcap = RandShort = None
+    print("[!] scapy not available - SYN/OS/traceroute disabled "
+          "(pipx inject ghostnet scapy, or pip install scapy)",
+          file=sys.stderr)
+
+
+class Colors:
+    RESET = "\033[0m"
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    BRIGHT_BLACK = "\033[90m"
+    BRIGHT_RED = "\033[91m"
+    BRIGHT_GREEN = "\033[92m"
+    BRIGHT_YELLOW = "\033[93m"
+    BRIGHT_BLUE = "\033[94m"
+    BRIGHT_MAGENTA = "\033[95m"
+    BRIGHT_CYAN = "\033[96m"
+    BRIGHT_WHITE = "\033[97m"
+    RESET = "\033[0m"
+    BLACK = "\033[30m"
+    RED = "\033[31m"
+    GREEN = "\033[32m"
+    YELLOW = "\033[33m"
+    BLUE = "\033[34m"
+    MAGENTA = "\033[35m"
+    CYAN = "\033[36m"
+    WHITE = "\033[37m"
+    BOLD = "\033[1m"
+    UNDERLINE = "\033[4m"
+
+    @classmethod
+    def disable(cls):
+        """Blank out every ANSI code (used by --no-color)."""
+        for name in list(vars(cls)):
+            value = getattr(cls, name)
+            if isinstance(value, str) and value.startswith("\033"):
+                setattr(cls, name, "")
+
+# Constants
+
+VERSION = "1.2.1"
+BANNER = f"""{Colors.BRIGHT_CYAN}
+    ╔═══════════════════════════════════════════════════════════╗
+    ║                                                           ║
+    ║   ░██████╗░██╗░░██╗░█████╗░░██████╗████████╗              ║
+    ║   ██╔════╝░██║░░██║██╔══██╗██╔════╝╚══██╔══╝              ║
+    ║   ██║░░██╗░███████║██║░░██║╚█████╗░░░░██║░░░              ║
+    ║   ██║░░╚██╗██╔══██║██║░░██║░╚═══██╗░░░██║░░░              ║
+    ║   ╚██████╔╝██║░░██║╚█████╔╝██████╔╝░░░██║░░░              ║
+    ║   ░╚═════╝░╚═╝░░╚═╝░╚════╝░╚═════╝░░░░╚═╝░░░              ║
+    ║                                                           ║
+    ║   ███╗░░██╗███████╗████████╗                              ║
+    ║   ████╗░██║██╔════╝╚══██╔══╝                              ║
+    ║   ██╔██╗██║█████╗░░░░░██║░░░                              ║
+    ║   ██║╚████║██╔══╝░░░░░██║░░░                              ║
+    ║   ██║░╚███║███████╗░░░██║░░░                              ║
+    ║   ╚═╝░░╚══╝╚══════╝░░░╚═╝░░░                              ║
+    ║                                                           ║
+    ╚═══════════════════════════════════════════════════════════╝{Colors.RESET}
+
+    {Colors.BRIGHT_WHITE}Advanced Network Scanner v{VERSION}
+    {Colors.BRIGHT_GREEN}» Welcome to Ghost Net >==< «{Colors.RESET}"""
+
+# Common ports to scan by default
+COMMON_PORTS = {
+    21: "FTP",
+    22: "SSH",
+    23: "Telnet",
+    25: "SMTP",
+    53: "DNS",
+    80: "HTTP",
+    110: "POP3",
+    111: "RPC",
+    135: "MSRPC",
+    139: "NetBIOS",
+    143: "IMAP",
+    443: "HTTPS",
+    445: "SMB",
+    993: "IMAPS",
+    995: "POP3S",
+    1433: "MSSQL",
+    1521: "Oracle",
+    3306: "MySQL",
+    3389: "RDP",
+    5432: "PostgreSQL",
+    5900: "VNC",
+    8080: "HTTP-Proxy",
+    8443: "HTTPS-Alt"
+}
+
+# Common service fingerprints for basic service detection
+SERVICE_FINGERPRINTS = {
+    b"SSH-": "SSH",
+    b"HTTP/": "HTTP",
+    b"220 ": "FTP",
+    b"SMTP": "SMTP",
+    b"POP3": "POP3",
+    b"IMAP": "IMAP",
+    b"RFB ": "VNC",
+    b"Microsoft SQL Server": "MSSQL",
+    b"MySQL": "MySQL",
+    b"5432": "PostgreSQL",
+}
+
+# OS fingerprinting signatures based on TTL values (simplified)
+OS_FINGERPRINTS = {
+    64: "Linux/Unix",
+    128: "Windows",
+    255: "Cisco/Network Device",
+    254: "Solaris/AIX"
+}
+
+# Configuration
+
+TIMING_TEMPLATES = {
+    0: (5.0, 1, 5.0),     # paranoid
+    1: (5.0, 1, 1.0),     # sneaky
+    2: (3.0, 10, 0.4),    # polite
+    3: (1.0, 50, 0.0),    # normal (defaults)
+    4: (0.5, 100, 0.0),   # aggressive
+    5: (0.3, 200, 0.0),   # insane
+}
+
+