moriarty-project 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

moriarty/__init__.py

@@ -1,5 +1,4 @@
 from __future__ import annotations
 
 __all__ = ["__version__"]
-
-__version__ = "0.1.0"
+__version__ = "0.1.8"

moriarty/cli/app.py

@@ -24,9 +24,23 @@ app = typer.Typer(
 )
 
 
+def version_callback(value: bool):
+    if value:
+        from .. import __version__
+        console.print(f"Moriarty OSINT Toolkit v{__version__}")
+        raise typer.Exit()
+
 @app.callback()
 def main(
     ctx: typer.Context,
+    version: bool = typer.Option(
+        None, 
+        "--version", 
+        "-v", 
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit.",
+    ),
     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."),
@@ -46,7 +60,7 @@ def main(
     ),
     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."),
+    verbose: bool = typer.Option(False, "--verbose", "-v", 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."),
@@ -117,4 +131,86 @@ def main() -> None:  # Console script compatibility
     main_entry()
 
 
-__all__ = ["app", "main"]
+def check_pipx_installed() -> bool:
+    """Verifica se o pipx está instalado."""
+    try:
+        import subprocess
+        subprocess.run(["pipx", "--version"], capture_output=True, check=True)
+        return True
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return False
+
+
+def self_update():
+    """Atualiza o Moriarty para a versão mais recente."""
+    import subprocess
+    import sys
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich import print
+    
+    console = Console()
+    
+    try:
+        # Verifica se está instalado com pipx
+        if check_pipx_installed():
+            console.print("🔄 Atualizando via pipx...", style="bold blue")
+            result = subprocess.run(
+                ["pipx", "install", "--upgrade", "moriarty-project"],
+                capture_output=True,
+                text=True
+            )
+        else:
+            console.print("🔄 Atualizando via pip...", style="bold blue")
+            result = subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--upgrade", "moriarty-project"],
+                capture_output=True,
+                text=True
+            )
+        
+        if result.returncode == 0:
+            console.print("✅ [bold green]Atualização concluída com sucesso![/]")
+            if result.stdout:
+                console.print(Panel(
+                    result.stdout.strip(),
+                    title="[bold]Saída do comando[/]",
+                    border_style="green"
+                ))
+            console.print("\nReinicie o terminal para aplicar as alterações.", style="yellow")
+        else:
+            console.print("❌ [bold red]Erro durante a atualização:[/]")
+            if result.stderr:
+                console.print(Panel(
+                    result.stderr.strip(),
+                    title="[bold]Mensagem de erro[/]",
+                    border_style="red"
+                ))
+            console.print("\nTente executar manualmente:")
+            if check_pipx_installed():
+                console.print("  [cyan]pipx install --upgrade moriarty-project[/]")
+            else:
+                console.print(f"  [cyan]{sys.executable} -m pip install --upgrade moriarty-project[/]")
+    except Exception as e:
+        console.print(f"❌ [bold red]Erro inesperado:[/] {str(e)}")
+        console.print("\nTente atualizar manualmente usando:")
+        if check_pipx_installed():
+            console.print("  [cyan]pipx install --upgrade moriarty-project[/]")
+        else:
+            console.print(f"  [cyan]{sys.executable} -m pip install --upgrade moriarty-project[/]")
+
+
+# Adiciona o comando self-update
+@app.command("self-update", help="Atualiza o Moriarty para a versão mais recente.")
+def self_update_command():
+    """Atualiza o Moriarty para a versão mais recente."""
+    self_update()
+
+
+# Adiciona um alias mais curto
+@app.command("update", hidden=True)
+def update_alias():
+    """Alias para 'self-update'."""
+    self_update()
+
+
+__all__ = ["app", "main", "self_update"]

moriarty/cli/domain_cmd.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 import typer
 
-from moriarty.modules.port_scanner import PROFILES
+from moriarty.modules.port_scanner import PortScanner, PROFILES
 from moriarty.modules.passive_recon import PassiveRecon
 from rich.console import Console
 
@@ -25,6 +25,7 @@ def scan_full(
     threads: int = typer.Option(10, "--threads", "-t", help="Threads concorrentes"),
     timeout: int = typer.Option(30, "--timeout", help="Timeout em segundos"),
     output: str = typer.Option(None, "--output", "-o", help="Arquivo de saída"),
+    verbose: bool = typer.Option(False, "--verbose", help="Ativar saída detalhada"),
 ):
     """
     🔍 Scan completo de domínio/IP com 14 módulos.
@@ -49,6 +50,7 @@ def scan_full(
         stealth_level=stealth,
         threads=threads,
         timeout=timeout,
+        verbose=verbose,
     )
     
     asyncio.run(scanner.run())
@@ -284,6 +286,7 @@ def port_scan(
     scan_type: str = typer.Option("syn", "--type", "-t", help="Tipo: syn, tcp, udp"),
     stealth: int = typer.Option(0, "--stealth", "-s", help="Stealth level (0-4)"),
     output: str = typer.Option(None, "--output", "-o", help="Arquivo de saída"),
+    verbose: bool = typer.Option(False, "--verbose", help="Ativar saída detalhada"),
 ):
     """
     🔌 Scan avançado de portas.
@@ -496,39 +499,133 @@ def passive_recon(
 
 @app.command("ports")
 def port_scan(
-    domain: str = typer.Argument(..., help="Alvo para o port scan"),
-    profile: str = typer.Option("quick", "--profile", "-p", help=f"Perfil ({', '.join(PROFILES.keys())})"),
-    concurrency: int = typer.Option(200, "--concurrency", help="Conexões simultâneas"),
-    timeout: float = typer.Option(1.5, "--timeout", help="Timeout por porta"),
-    output: Optional[str] = typer.Option(None, "--output", "-o", help="Arquivo de saída JSON"),
+    target: str = typer.Argument(..., help="Domínio ou IP para escanear"),
+    profile: str = typer.Option(
+        "quick", 
+        "--profile", 
+        "-p", 
+        help=f"Perfil de varredura: {', '.join(PROFILES.keys())}"
+    ),
+    stealth: int = typer.Option(
+        0,
+        "--stealth",
+        "-s",
+        min=0,
+        max=5,
+        help="Nível de stealth (0-5, maior = mais lento e discreto)",
+    ),
+    concurrency: int = typer.Option(
+        200, 
+        "--concurrency", 
+        "-c", 
+        help="Número de conexões simultâneas",
+        min=1,
+        max=1000,
+    ),
+    timeout: float = typer.Option(
+        2.0, 
+        "--timeout", 
+        "-t", 
+        help="Timeout por porta em segundos",
+        min=0.5,
+        max=30.0,
+    ),
+    output: Optional[str] = typer.Option(
+        None, 
+        "--output", 
+        "-o", 
+        help="Arquivo de saída (formato: .json, .txt, .md)"
+    ),
+    format: str = typer.Option(
+        "text",
+        "--format",
+        "-f",
+        help="Formato de saída: text, json, markdown",
+    ),
+    resolve_services: bool = typer.Option(
+        True,
+        "--resolve/--no-resolve",
+        help="Tentar identificar serviços nas portas abertas",
+    ),
+    check_vulns: bool = typer.Option(
+        True,
+        "--vulns/--no-vulns",
+        help="Verificar vulnerabilidades conhecidas",
+    ),
 ):
-    """Executa port scan assíncrono com banners."""
+    """
+    🔍 Varredura avançada de portas com detecção de serviços e vulnerabilidades.
+    
+    Exemplos:
+        moriarty domain ports example.com
+        moriarty domain ports 192.168.1.1 --profile full --stealth 3
+        moriarty domain ports target.com -o resultado.json --format json
+    """
     import asyncio
     import json
+    from pathlib import Path
+    from moriarty.modules.port_scanner import format_scan_results
+
+    # Validações
+    if profile not in PROFILES:
+        console.print(f"[red]Erro:[/red] Perfil inválido. Use um destes: {', '.join(PROFILES.keys())}")
+        raise typer.Exit(1)
+
+    if output:
+        output = Path(output)
+        if output.suffix not in (".json", ".txt", ".md"):
+            console.print("[yellow]Aviso:[/yellow] Extensão de arquivo não suportada. Usando .json")
+            output = output.with_suffix(".json")
 
     async def _run():
         scanner = PortScanner(
-            target=domain,
+            target=target,
             profile=profile,
             concurrency=concurrency,
             timeout=timeout,
+            stealth_level=stealth,
+            resolve_services=resolve_services,
+            check_vulns=check_vulns,
         )
         return await scanner.scan()
 
-    results = asyncio.run(_run())
-    if not results:
-        console.print("[yellow]Nenhuma porta aberta detectada[/yellow]")
-    else:
-        table_data = [
-            {"port": r.port, "status": r.status, "banner": r.banner or "-"}
-            for r in results
-        ]
-        console.print_json(data=table_data)
-
-    if output:
-        json_payload = [r.__dict__ for r in results]
-        with open(output, "w", encoding="utf-8") as handle:
-            json.dump(json_payload, handle, indent=2, ensure_ascii=False)
+    # Executa o scanner
+    console.print(f"[bold]🔍 Iniciando varredura em:[/bold] {target}")
+    console.print(f"📊 Perfil: {profile} (portas: {len(PROFILES[profile])})")
+    console.print(f"🕵️  Nível de stealth: {stealth}")
+    
+    try:
+        results = asyncio.run(_run())
+        
+        if not results:
+            console.print("[yellow]⚠️  Nenhuma porta aberta detectada[/yellow]")
+            return
+            
+        # Formata a saída
+        if format.lower() == "json":
+            output_text = json.dumps([r.to_dict() for r in results], indent=2)
+            if not output:
+                console.print_json(data=json.loads(output_text))
+        else:
+            output_text = format_scan_results(results, output_format=format)
+            if not output:
+                console.print(output_text)
+        
+        # Salva em arquivo se especificado
+        if output:
+            output.parent.mkdir(parents=True, exist_ok=True)
+            with open(output, "w", encoding="utf-8") as f:
+                if output.suffix == ".json":
+                    json.dump([r.to_dict() for r in results], f, indent=2, ensure_ascii=False)
+                else:
+                    f.write(output_text)
+            console.print(f"\n[green]✅ Resultados salvos em:[/green] {output.absolute()}")
+    
+    except Exception as e:
+        console.print(f"[red]❌ Erro durante a varredura:[/red] {str(e)}")
+        if "object NoneType can't be used in 'await' expression" in str(e):
+            console.print("[yellow]Dica:[/yellow] Tente aumentar o timeout com --timeout 5.0")
+        raise typer.Exit(1)
         console.print(f"[green]✓ Resultado salvo em[/green] {output}")
 
 

moriarty/modules/domain_scanner.py

@@ -76,17 +76,23 @@ class DomainScanner:
         stealth_level: int = 0,
         threads: int = 10,
         timeout: int = 30,
+        verbose: bool = False,
     ):
         self.target = target
         self.modules = modules or self.DEFAULT_MODULES
         self.stealth_level = stealth_level
         self.threads = threads
         self.timeout = timeout
+        self.verbose = verbose
         self.result = ScanResult(target=target)
         self.stealth = None
+        
+        # Configura o nível de log com base no modo verbose
+        log_level = logging.DEBUG if verbose else logging.INFO
+        logging.basicConfig(level=log_level)
+        
         if self.stealth_level > 0:
             from moriarty.modules.stealth_mode import StealthMode
-
             self.stealth = StealthMode(level=self.stealth_level)
 
         self.tech_profile: Optional[Dict[str, Any]] = None