Skip to content

🕵️‍♂️ (2-in-1) Email & Username OSINT suite featuring native MCP support for deep data extraction just from a single Email/Username. Analyzes 2720+ actively maintained scan vectors (210+ email / 2510+ username) for security research, investigations, and digital footprinting.

10.9 KB
Raw Blame
import asyncio
import httpx
from pathlib import Path
from types import ModuleType
from typing import Callable, Dict, List, Optional, Set, Union

from colorama import Fore, Style

from user_scanner.core.helpers import (
    ScanConfig,
    find_category,
    get_proxy,
    get_scan_func,
    get_site_name,
    is_loud,
    load_categories,
    load_modules,
    get_global_timeout,
)
from user_scanner.core import limits
from user_scanner.core.result import Result
from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, MofNCompleteColumn

# Monkey-patch httpx clients to automatically use proxies for email scans
_original_async_client_init = httpx.AsyncClient.__init__
_original_client_init = httpx.Client.__init__

def _patched_async_client_init(self, *args, **kwargs):
    if "proxy" not in kwargs and "proxies" not in kwargs:
        proxy = get_proxy()
        if proxy:
            kwargs["proxy"] = proxy
            
    global_timeout = get_global_timeout()
    if global_timeout is not None:
        kwargs["timeout"] = global_timeout
        
    _original_async_client_init(self, *args, **kwargs)

def _patched_client_init(self, *args, **kwargs):
    if "proxy" not in kwargs and "proxies" not in kwargs:
        proxy = get_proxy()
        if proxy:
            kwargs["proxy"] = proxy
            
    global_timeout = get_global_timeout()
    if global_timeout is not None:
        kwargs["timeout"] = global_timeout
        
    _original_client_init(self, *args, **kwargs)

httpx.AsyncClient.__init__ = _patched_async_client_init  # type: ignore[method-assign]
httpx.Client.__init__ = _patched_client_init  # type: ignore[method-assign]


# Concurrency control
MAX_CONCURRENT_REQUESTS = 25

def set_concurrency(val: int):
    val = limits.check_concurrency(val)
    global MAX_CONCURRENT_REQUESTS
    MAX_CONCURRENT_REQUESTS = val

async def _async_worker(
    module: ModuleType,
    email: str,
    sem: asyncio.Semaphore,
    configs: ScanConfig,
    printed_cats: Optional[Set] = None,
    cat_override: Optional[str] = None,
    on_start: Optional[Callable[[str], None]] = None,
) -> Result:
    async with sem:
        site_name = get_site_name(module)
        if on_start:
            on_start(site_name)
        func = get_scan_func(module)
        actual_cat = cat_override or find_category(module) or "Email"

        params = {
            "site_name": site_name.capitalize(),
            "username": email,
            "category": actual_cat,
            "is_email": True,
        }

        if not func:
            return Result.error(
                f"{site_name} has no validate_ function", **params
            )

        if not configs.allow_loud and is_loud(site_name, is_email=True):
            return Result.skipped().update(**params)

        try:
            import inspect
            module_timeout = (get_global_timeout() or 15.0) + 10.0
            # Validators with an optional loud step take the scan policy as an argument
            kwargs = {}
            if "allow_loud" in inspect.signature(func).parameters:
                kwargs["allow_loud"] = configs.allow_loud
            if inspect.iscoroutinefunction(func):
                result = await asyncio.wait_for(func(email, **kwargs), timeout=module_timeout)
            else:
                result = await asyncio.wait_for(asyncio.to_thread(func, email, **kwargs), timeout=module_timeout)
        except asyncio.TimeoutError:
            result = Result.error(f"Module execution timed out after {module_timeout}s")
        except Exception as e:
            result = Result.error(e)

        return result.update(**params)


async def _run_batch(
    modules: List[ModuleType],
    email: str,
    configs: ScanConfig,
    printed_cats: Optional[Set] = None,
    cat_override: Optional[str] = None,
    sem: Optional[asyncio.Semaphore] = None,
) -> List[Result]:
    if not modules:
        return []

    if sem is None:
        sem = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)

    if printed_cats is None:
        printed_cats = set()

    results = []

    category_map: Dict[str, List[ModuleType]] = {}
    for module in modules:
        cat = cat_override or find_category(module) or "Email"
        display_cat = cat.capitalize()
        category_map.setdefault(display_cat, []).append(module)

    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        BarColumn(),
        MofNCompleteColumn(),
        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
        transient=True,
    ) as progress:
        task_id = progress.add_task(f"[cyan]Scanning {email}...", total=len(modules))

        def on_start_cb(site: str):
            progress.update(task_id, description=f"[cyan]Scanning {email}... ({site})")

        # 1. Pre-spawn all tasks for all categories (global concurrency)
        spawned_category_tasks = []
        for cat_name, cat_modules in category_map.items():
            tasks = []
            for module in cat_modules:
                t = asyncio.create_task(
                    _async_worker(
                        module,
                        email,
                        sem,
                        configs,
                        cat_override=cat_name,
                        on_start=on_start_cb,
                    )
                )
                t.add_done_callback(lambda t: progress.advance(task_id))
                tasks.append(t)
            spawned_category_tasks.append((cat_name, tasks))

        # 2. Await tasks category by category to stream grouped output
        for cat_name, tasks in spawned_category_tasks:
            if not tasks:
                continue

            if configs.show_all:
                if cat_name not in printed_cats:
                    print(
                        f"\n{Fore.MAGENTA}== {cat_name.upper()} SITES =={Style.RESET_ALL}"
                    )
                    printed_cats.add(cat_name)

            for coro in asyncio.as_completed(tasks):
                result = await coro
                if configs.show_all or result.is_visible(configs):
                    cat = result.category or cat_name
                    if cat not in printed_cats:
                        print(
                            f"\n{Fore.MAGENTA}== {cat.upper()} SITES =={Style.RESET_ALL}"
                        )
                        printed_cats.add(cat)

                result.show(configs)
                results.append(result)

    return results


async def _run_email_module_batch_async(
    module: Union[ModuleType, List[ModuleType]], email: str, configs: ScanConfig
) -> List[Result]:
    loop = asyncio.get_running_loop()
    import concurrent.futures
    loop.set_default_executor(concurrent.futures.ThreadPoolExecutor(max_workers=250))
    modules = [module] if isinstance(module, ModuleType) else list(module)
    return await _run_batch(modules, email, configs, printed_cats=set())


def run_email_module_batch(
    module: Union[ModuleType, List[ModuleType]], email: str, configs: ScanConfig
) -> List[Result]:
    return asyncio.run(_run_email_module_batch_async(module, email, configs))


async def _run_email_category_batch_async(
    category_path: Path, email: str, configs: ScanConfig
) -> List[Result]:
    loop = asyncio.get_running_loop()
    import concurrent.futures
    loop.set_default_executor(concurrent.futures.ThreadPoolExecutor(max_workers=250))
    cat_name = category_path.stem.capitalize()
    modules = load_modules(category_path)
    printed_cats = set()

    if configs.show_all:
        print(f"\n{Fore.MAGENTA}== {cat_name.upper()} SITES =={Style.RESET_ALL}")
        printed_cats.add(cat_name)

    return await _run_batch(
        modules,
        email,
        configs,
        printed_cats=printed_cats,
        cat_override=cat_name,
    )

def run_email_category_batch(
    category_path: Path, email: str, configs: ScanConfig
) -> List[Result]:
    return asyncio.run(_run_email_category_batch_async(category_path, email, configs))


async def _run_email_full_batch_async(email: str, configs: ScanConfig) -> List[Result]:
    loop = asyncio.get_running_loop()
    import concurrent.futures
    loop.set_default_executor(concurrent.futures.ThreadPoolExecutor(max_workers=250))
    categories = load_categories(True, configs.no_nsfw)
    all_results = []
    printed_cats: Set[str] = set()

    # 1. Pre-spawn all tasks for all categories (global concurrency)
    category_modules = []
    total_tasks = 0
    sem = asyncio.Semaphore(MAX_CONCURRENT_REQUESTS)
    
    for cat_name, cat_path in categories.items():
        display_name = cat_name.capitalize()
        modules = load_modules(cat_path)
        category_modules.append((display_name, modules))
        total_tasks += len(modules)

    # 2. Await tasks category by category to stream grouped output
    with Progress(
        SpinnerColumn(),
        TextColumn("[progress.description]{task.description}"),
        BarColumn(),
        MofNCompleteColumn(),
        TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
        transient=True,
    ) as progress:
        task_id = progress.add_task(f"[cyan]Scanning {email}...", total=total_tasks)
        
        def on_start_cb(site: str):
            progress.update(task_id, description=f"[cyan]Scanning {email}... ({site})")
            
        spawned_category_tasks = []
        for display_name, modules in category_modules:
            tasks = []
            for module in modules:
                t = asyncio.create_task(
                    _async_worker(
                        module,
                        email,
                        sem,
                        configs,
                        cat_override=display_name,
                        on_start=on_start_cb,
                    )
                )
                t.add_done_callback(lambda t: progress.advance(task_id))
                tasks.append(t)
            spawned_category_tasks.append((display_name, tasks))
                
        for display_name, tasks in spawned_category_tasks:
            if not tasks:
                continue
                
            if configs.show_all:
                if display_name not in printed_cats:
                    print(f"\n{Fore.MAGENTA}== {display_name.upper()} SITES =={Style.RESET_ALL}")
                    printed_cats.add(display_name)
                
            for coro in asyncio.as_completed(tasks):
                result = await coro
                if configs.show_all or result.is_visible(configs):
                    cat = result.category or display_name
                    if cat not in printed_cats:
                        print(
                            f"\n{Fore.MAGENTA}== {cat.upper()} SITES =={Style.RESET_ALL}"
                        )
                        printed_cats.add(cat)

                result.show(configs)
                all_results.append(result)

    return all_results

def run_email_full_batch(email: str, configs: ScanConfig) -> List[Result]:
    return asyncio.run(_run_email_full_batch_async(email, configs))