moriarty-project 0.1.6__py3-none-any.whl

moriarty/cli/__init__.py

@@ -0,0 +1,3 @@
+from .app import app, main
+
+__all__ = ["app", "main"]

moriarty/cli/app.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import logging
+from typing import cast
+
+import typer
+from rich.console import Console
+from rich.theme import Theme
+
+from ..logging.config import LogStyle, configure_logging
+from . import dns, email, rdap, tls, user, domain_cmd, intelligence
+from .state import CLIState, GlobalOptions
+
+console = Console(theme=Theme({
+    "info": "cyan",
+    "warning": "yellow",
+    "error": "bold red",
+    "success": "green",
+}))
+
+app = typer.Typer(
+    add_completion=False,
+    help="Moriarty — client-side OSINT investigations."
+)
+
+
+@app.callback()
+def main(
+    ctx: typer.Context,
+    concurrency: int = typer.Option(50, min=1, help="Maximum concurrent tasks."),
+    timeout: float = typer.Option(8.0, min=0.1, help="Per-request timeout in seconds."),
+    proxy: str | None = typer.Option(None, help="HTTP/SOCKS proxy URI."),
+    headless: str = typer.Option(
+        "auto",
+        case_sensitive=False,
+        help="Headless mode: auto, never, or force.",
+    ),
+    allowlist_domain: str | None = typer.Option(
+        None,
+        help="Comma-separated domains allowed for headless browsing.",
+    ),
+    format_: str = typer.Option(
+        "table",
+        "--format",
+        help="Output format: table, json, yaml.",
+    ),
+    output: str | None = typer.Option(None, help="Path to export artifacts."),
+    redact: bool = typer.Option(True, "--redact/--no-redact", help="Redact PII in output."),
+    verbose: bool = typer.Option(False, help="Enable verbose logging."),
+    quiet: bool = typer.Option(False, help="Suppress non-critical output."),
+    professional_mode: bool = typer.Option(False, help="Enable professional mode safeguards."),
+    seed: int | None = typer.Option(None, help="Deterministic seed for planners."),
+    dry_run: bool = typer.Option(False, "--dry-run", help="Execute planning without side-effects."),
+    plan_only: bool = typer.Option(False, help="Emit planned actions without execution."),
+    sign: bool = typer.Option(False, help="Sign artifacts using Sigstore (requires --output)."),
+    resume: str | None = typer.Option(None, help="Resume a stored plan from JSON."),
+    http3: bool = typer.Option(False, help="Enable HTTP/3 (requires aioquic extra)."),
+    doh: str | None = typer.Option(None, help="Use DNS-over-HTTPS with the provided endpoint."),
+    dot: str | None = typer.Option(None, help="Use DNS-over-TLS host:port."),
+    logs: str = typer.Option("structured", help="Logging style: structured or pretty."),
+) -> None:
+    """Configure global CLI options."""
+    if quiet and verbose:
+        raise typer.BadParameter("Use either --verbose or --quiet, not both.")
+
+    log_style_value = logs.lower()
+    if log_style_value not in ("structured", "pretty"):
+        raise typer.BadParameter("Logging style must be 'structured' or 'pretty'.")
+
+    log_style = cast(LogStyle, log_style_value)
+    configure_logging(style=log_style, verbose=verbose)
+    if quiet:
+        logging.getLogger().setLevel(logging.WARNING)
+
+    ctx.obj = CLIState(
+        options=GlobalOptions(
+            concurrency=concurrency,
+            timeout=timeout,
+            proxy=proxy,
+            headless=headless.lower(),
+            allowlist_domain=allowlist_domain,
+            format=format_,
+            output=output,
+            redact=redact,
+            verbose=verbose,
+            quiet=quiet,
+            professional_mode=professional_mode,
+            seed=seed,
+            dry_run=dry_run,
+            plan_only=plan_only,
+            sign=sign,
+            resume_path=resume,
+            http3=http3,
+            doh=doh,
+            dot=dot,
+            logs=log_style,
+        )
+    )
+
+
+app.add_typer(email.app, name="email", help="Email reconnaissance primitives.")
+app.add_typer(dns.app, name="dns", help="Consultas DNS.")
+app.add_typer(rdap.app, name="rdap", help="Consultas RDAP.")
+app.add_typer(tls.app, name="tls", help="Inspeções TLS.")
+app.add_typer(user.app, name="user", help="Enumeração de usernames.")
+app.add_typer(domain_cmd.app, name="domain", help="🌐 Domain/IP reconnaissance and scanning.")
+
+# Registra os comandos de inteligência
+intelligence.register_app(app)
+
+
+def main_entry() -> None:
+    app()
+
+
+def main() -> None:  # Console script compatibility
+    main_entry()
+
+
+__all__ = ["app", "main"]

moriarty/cli/async_utils.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import asyncio
+from typing import Any, Awaitable, TypeVar
+
+
+_T = TypeVar("_T")
+
+
+def run_async(awaitable: Awaitable[_T]) -> _T:
+    """Run an awaitable using asyncio, preferring uvloop when available."""
+    try:
+        import uvloop  # type: ignore
+
+        uvloop.install()
+    except ModuleNotFoundError:
+        pass
+
+    return asyncio.run(awaitable)

moriarty/cli/dns.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import typer
+from rich import box
+from rich.table import Table
+
+from .async_utils import run_async
+from .output import console, emit_json, emit_yaml, ensure_state
+from ..modules.dns_scan import DNSScanService
+from ..modules.orchestrator import Orchestrator
+from ..net.dns_client import DNSClient, DNSLookupResult
+
+app = typer.Typer(add_completion=False, help="Consultas de DNS.")
+
+
+@app.command("scan")
+def scan(
+    ctx: typer.Context,
+    domain: str = typer.Option(..., "--domain", "-d", help="Domínio alvo."),
+    json_output: Optional[str] = typer.Option(None, "--json", help="Escreve saída JSON no caminho ou '-'"),
+) -> None:
+    """Executa varredura de registros DNS (A/AAAA/MX/TXT/SPF/DMARC)."""
+    state = ensure_state(ctx)
+    orchestrator: Orchestrator[DNSLookupResult] = Orchestrator(
+        concurrency=state.options.concurrency,
+        timeout=state.options.timeout,
+    )
+    service = DNSScanService(
+        domain=domain,
+        orchestrator=orchestrator,
+        dns_client=DNSClient(timeout=state.options.timeout),
+    )
+
+    result = run_async(service.run())
+
+    payload = _result_to_dict(result.records, domain)
+    output_format = ("json" if json_output else state.options.format).lower()
+
+    if output_format == "json":
+        emit_json(payload, json_output, state.options.output)
+    elif output_format == "yaml":
+        emit_yaml(payload, json_output, state.options.output)
+    else:
+        _render_table(domain, result.records)
+
+
+def _render_table(domain: str, records: DNSLookupResult) -> None:
+    table = Table(title=f"DNS Scan · {domain}", box=box.SIMPLE_HEAVY)
+    table.add_column("Tipo", style="cyan", no_wrap=True)
+    table.add_column("Valores", style="white")
+
+    table.add_row("A", ", ".join(records.a) or "—")
+    table.add_row("AAAA", ", ".join(records.aaaa) or "—")
+    table.add_row("MX", ", ".join(f"{mx.exchange} (prio {mx.priority})" for mx in records.mx) or "—")
+    table.add_row("SPF", "; ".join(records.spf) or "—")
+    table.add_row("DMARC", "; ".join(records.dmarc) or "—")
+    if records.txt:
+        table.add_row("TXT", "\n".join(record.text for record in records.txt))
+
+    console.print(table)
+
+
+def _result_to_dict(records: DNSLookupResult, domain: str) -> Dict[str, Any]:
+    return {
+        "domain": domain,
+        "a": records.a,
+        "aaaa": records.aaaa,
+        "mx": [
+            {
+                "priority": mx.priority,
+                "exchange": mx.exchange,
+            }
+            for mx in records.mx
+        ],
+        "spf": records.spf,
+        "dmarc": records.dmarc,
+        "txt": [record.text for record in records.txt],
+    }
+
+
+__all__ = ["app"]