tempCodeRunnerFile.py

#!/usr/bin/env python3
"""
LoginScout - Advanced Login Page Discovery Tool
A Nessus-inspired tool for discovering authentication endpoints across web targets.
Author: LoginScout Project
License: MIT
"""

import argparse
import asyncio
import json
import logging
from logging import config
import sys
import time
from pathlib import Path
from datetime import datetime
from urllib.parse import urlparse

from loginscout.crawler import LoginScoutCrawler
from loginscout.reporter import ReportGenerator
from loginscout.utils import (
    normalize_url,
    setup_logging,
    validate_target,
    print_banner,
)
from loginscout.config import ScanConfig


def parse_arguments() -> argparse.Namespace:
    """Parse and validate command-line arguments."""
    parser = argparse.ArgumentParser(
        prog="loginscout",
        description=(
            "LoginScout - Discover login and authentication pages across a target website.\n"
            "Supports BFS crawling, subdomain scanning, JS rendering, and rich reporting."
        ),
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python main.py -t example.com
  python main.py -t example.com --depth 5 --threads 20
  python main.py -t 192.168.1.1 --enable-js --output json
  python main.py -t example.com --enable-subdomain-scan --delay 0.5
  python main.py -t example.com --output all --enable-js --depth 4 --verbose
        """,
    )

    # --- Required ---
    parser.add_argument(
        "-t", "--target",
        required=True,
        metavar="TARGET",
        help="Target domain or IP address (e.g. example.com or 192.168.1.1)",
    )

    # --- Crawl options ---
    crawl_group = parser.add_argument_group("Crawl Options")
    crawl_group.add_argument(
        "--depth",
        type=int,
        default=3,
        metavar="N",
        help="Maximum crawl depth (default: 3)",
    )
    crawl_group.add_argument(
        "--threads",
        type=int,
        default=10,
        metavar="N",
        help="Maximum concurrent requests (default: 10)",
    )
    crawl_group.add_argument(
        "--delay",
        type=float,
        default=0.2,
        metavar="SECONDS",
        help="Delay between requests in seconds (default: 0.2)",
    )
    crawl_group.add_argument(
        "--timeout",
        type=int,
        default=15,
        metavar="SECONDS",
        help="Request timeout in seconds (default: 15)",
    )
    crawl_group.add_argument(
        "--max-pages",
        type=int,
        default=500,
        metavar="N",
        help="Maximum number of pages to crawl (default: 500)",
    )
    crawl_group.add_argument(
        "--user-agent",
        default=None,
        metavar="UA",
        help="Custom User-Agent string",
    )
    crawl_group.add_argument(
        "--respect-robots",
        action="store_true",
        default=True,
        help="Respect robots.txt disallow rules (default: True)",
    )
    crawl_group.add_argument(
        "--no-respect-robots",
        action="store_false",
        dest="respect_robots",
        help="Ignore robots.txt restrictions",
    )
    crawl_group.add_argument(
        "--scan-disallowed",
        action="store_true",
        default=False,
        help="Also scan robots.txt disallowed paths (may find hidden endpoints)",
    )

    # --- Feature flags ---
    feature_group = parser.add_argument_group("Feature Flags")
    feature_group.add_argument(
        "--enable-js",
        action="store_true",
        default=False,
        help="Enable JavaScript rendering via Playwright (slower but more thorough)",
    )
    feature_group.add_argument(
        "--enable-subdomain-scan",
        action="store_true",
        default=False,
        help="Discover and scan subdomains via DNS brute force",
    )
    feature_group.add_argument(
        "--subdomain-wordlist",
        default=None,
        metavar="FILE",
        help="Path to custom subdomain wordlist (default: built-in list)",
    )
    feature_group.add_argument(
        "--detect-admin",
        action="store_true",
        default=True,
        help="Separately flag admin panels (default: True)",
    )
    feature_group.add_argument(
        "--check-security",
        action="store_true",
        default=True,
        help="Check for weak security (no HTTPS, missing CSRF tokens)",
    )

    # --- Output options ---
    output_group = parser.add_argument_group("Output Options")
    output_group.add_argument(
        "--output",
        choices=["json", "txt", "html", "all"],
        default="all",
        metavar="FORMAT",
        help="Output format: json, txt, html, all (default: all)",
    )
    output_group.add_argument(
        "--output-dir",
        default="./reports",
        metavar="DIR",
        help="Directory to save reports (default: ./reports)",
    )
    output_group.add_argument(
        "--log-file",
        default=None,
        metavar="FILE",
        help="Save logs to file (default: auto-named in logs/)",
    )
    output_group.add_argument(
        "-v", "--verbose",
        action="store_true",
        default=False,
        help="Enable verbose (DEBUG) logging",
    )
    output_group.add_argument(
        "-q", "--quiet",
        action="store_true",
        default=False,
        help="Suppress all console output except results",
    )

    return parser.parse_args()


async def run_scan(args: argparse.Namespace) -> dict:
    """
    Orchestrate the full scan lifecycle.

    Args:
        args: Parsed CLI arguments.

    Returns:
        dict: Scan results summary.
    """
    logger = logging.getLogger("loginscout.main")

    # Build scan configuration
    config = ScanConfig(
        target=args.target,
        max_depth=args.depth,
        max_concurrent=args.threads,
        request_delay=args.delay,
        timeout=args.timeout,
        max_pages=args.max_pages,
        user_agent=args.user_agent,
        respect_robots=args.respect_robots,
        scan_disallowed=args.scan_disallowed,
        enable_js=args.enable_js,
        enable_subdomain_scan=args.enable_subdomain_scan,
        subdomain_wordlist=args.subdomain_wordlist,
        detect_admin=args.detect_admin,
        check_security=args.check_security,
        output_format=args.output,
        output_dir=args.output_dir,
    )

    logger.info("Starting LoginScout scan")
    logger.info("Target: %s", config.target)
    logger.info("Depth: %d | Threads: %d | JS: %s | Subdomains: %s",
                config.max_depth, config.max_concurrent,
                config.enable_js, config.enable_subdomain_scan)

    start_time = time.time()

    # Initialize and run crawler
    crawler = LoginScoutCrawler(config)
    results = await crawler.run()

    elapsed = time.time() - start_time

    # Generate reports
    output_path = Path(config.output_dir)
    output_path.mkdir(parents=True, exist_ok=True)

    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    from urllib.parse import urlparse

    parsed = urlparse(config.target)
    target_slug = parsed.netloc.replace(".", "_")
    base_name = f"loginscout_{target_slug}_{timestamp}"

    reporter = ReportGenerator(results, config, elapsed)

    saved_files = []
    if config.output_format in ("json", "all"):
        path = output_path / f"{base_name}.json"
        reporter.save_json(path)
        saved_files.append(str(path))
        logger.info("JSON report saved: %s", path)

    if config.output_format in ("txt", "all"):
        path = output_path / f"{base_name}.txt"
        reporter.save_txt(path)
        saved_files.append(str(path))
        logger.info("TXT report saved: %s", path)

    if config.output_format in ("html", "all"):
        path = output_path / f"{base_name}.html"
        reporter.save_html(path)
        saved_files.append(str(path))
        logger.info("HTML report saved: %s", path)

    # Print summary to console
    if not args.quiet:
        reporter.print_summary(elapsed, saved_files)

    return {
        "results": results,
        "elapsed": elapsed,
        "reports": saved_files,
    }


def main():
    """Main entry point."""
    args = parse_arguments()

    # Setup logging first
    log_level = logging.DEBUG if args.verbose else logging.INFO
    if args.quiet:
        log_level = logging.WARNING

    log_dir = Path("./logs")
    log_dir.mkdir(exist_ok=True)
    log_file = args.log_file or str(
        log_dir / f"loginscout_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log"
    )

    setup_logging(log_level, log_file)

    logger = logging.getLogger("loginscout.main")

    # Print banner
    if not args.quiet:
        print_banner()

    # Validate target
    try:
        normalized = validate_target(args.target)
        args.target = normalized
        logger.debug("Normalized target: %s", normalized)
    except ValueError as e:
        logger.error("Invalid target: %s", e)
        sys.exit(1)

    # Run the async scan
    try:
        asyncio.run(run_scan(args))
    except KeyboardInterrupt:
        logger.warning("Scan interrupted by user (Ctrl+C)")
        print("\n[!] Scan interrupted. Partial results may have been saved.")
        sys.exit(0)
    except Exception as e:
        logger.exception("Unhandled exception during scan: %s", e)
        sys.exit(1)


if __name__ == "__main__":
    main()