moriarty-project 0.1.26__py3-none-any.whl → 0.1.27__py3-none-any.whl

moriarty/cli/domain_cmd.py

@@ -1,19 +1,16 @@
 """Comandos de scanning de domínios/IPs."""
 
-import asyncio
-import json
-from typing import Optional, Dict, List
+from typing import Optional
 
 import typer
-from rich.console import Console
-from rich.panel import Panel
-from rich.table import Table, box
 
 from moriarty.modules.web_crawler import WebCrawler
-from moriarty.modules.port_scanner import PortScanner, PROFILES
+
+from moriarty.modules.port_scanner_nmap import PortScanner, PROFILES
 from moriarty.modules.passive_recon import PassiveRecon
+from rich.console import Console
 
-app = typer.Typer(help="🔍 Ferramentas avançadas de reconhecimento de domínios")
+app = typer.Typer(name="domain", help="🌐 Domain/IP reconnaissance and scanning.")
 console = Console()
 
 
@@ -29,6 +26,7 @@ def scan_full(
     stealth: int = typer.Option(0, "--stealth", "-s", help="Stealth level (0-4)"),
     threads: int = typer.Option(10, "--threads", "-t", help="Threads concorrentes"),
     timeout: int = typer.Option(30, "--timeout", help="Timeout em segundos"),
+    ports: str = typer.Option("quick", "--ports", "-p", help="Perfil de portas: quick, web, db, full, all"),
     output: str = typer.Option(None, "--output", "-o", help="Arquivo de saída"),
     verbose: bool = typer.Option(False, "--verbose", help="Ativar saída detalhada"),
 ):
@@ -49,9 +47,13 @@ def scan_full(
     logging.getLogger("httpcore").setLevel(logging.ERROR)
     logging.getLogger("moriarty").setLevel(logging.ERROR)
     
+    # Converte a string de módulos para lista
+    modules_list = modules.split(",") if modules != "all" else None
+    
     scanner = DomainScanner(
         target=target,
-        modules=modules.split(",") if modules != "all" else None,
+        modules=modules_list,
+        ports_profile=ports,
         stealth_level=stealth,
         threads=threads,
         timeout=timeout,
@@ -62,7 +64,7 @@ def scan_full(
     
     if output:
         scanner.export(output)
-        console.print(f"[green]✅[/green] Results saved to: [red]{output}[/red]\n")
+        console.print(f"[green]✅[/green] Results saved to: [cyan]{output}[/cyan]\n")
 
 
 @app.command("subdiscover")
@@ -102,7 +104,7 @@ def subdomain_discovery(
     from moriarty.modules.subdomain_discovery import SubdomainDiscovery
     import asyncio
     
-    console.print(f"[bold red]🔍 Descobrindo subdomínios de:[/bold red] {domain}\n")
+    console.print(f"[bold cyan]🔍 Descobrindo subdomínios de:[/bold cyan] {domain}\n")
     
     discovery = SubdomainDiscovery(
         domain=domain,
@@ -142,7 +144,7 @@ def wayback_urls(
     from moriarty.modules.wayback_discovery import WaybackDiscovery
     import asyncio
     
-    console.print(f"[bold red]🕰️ Buscando URLs históricas de:[/bold red] {domain}\n")
+    console.print(f"[bold cyan]🕰️ Buscando URLs históricas de:[/bold cyan] {domain}\n")
     
     wayback = WaybackDiscovery(
         domain=domain,
@@ -182,7 +184,7 @@ def template_scan(
 
     from moriarty.modules.template_scanner import TemplateScanner
 
-    console.print(f"[bold red]📝 Template scan em:[/bold red] {target}\n")
+    console.print(f"[bold cyan]📝 Template scan em:[/bold cyan] {target}\n")
 
     scanner = TemplateScanner(
         target=target,
@@ -228,7 +230,7 @@ def run_pipeline(
     from moriarty.modules.pipeline_orchestrator import PipelineOrchestrator
     import asyncio
     
-    console.print(f"[bold red]🔄 Executando pipeline:[/bold red] {pipeline_file}\n")
+    console.print(f"[bold cyan]🔄 Executando pipeline:[/bold cyan] {pipeline_file}\n")
     
     orchestrator = PipelineOrchestrator(
         pipeline_file=pipeline_file,
@@ -284,7 +286,41 @@ def stealth_command(
         console.print(f"[red]❌ Ação inválida: {action}[/red]")
 
 
-# A função port_scan foi movida para a implementação mais completa abaixo
+@app.command("ports")
+def port_scan(
+    target: str = typer.Argument(..., help="IP ou domínio"),
+    ports: str = typer.Option("common", "--ports", "-p", help="Portas: common, all, 1-1000, 80,443"),
+    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.
+    
+    Exemplos:
+        moriarty domain ports 8.8.8.8
+        moriarty domain ports target.com --ports 1-10000
+        moriarty domain ports target.com --type syn --stealth 3
+    """
+    from moriarty.modules.port_scanner import PortScanner
+    import asyncio
+    
+    console.print(f"[bold cyan]🔌 Port scan em:[/bold cyan] {target}\n")
+    
+    scanner = PortScanner(
+        target=target,
+        ports=ports,
+        scan_type=scan_type,
+        stealth_level=stealth,
+    )
+    
+    results = asyncio.run(scanner.scan())
+    
+    console.print(f"\n[green]✅ {len(results)} portas abertas encontradas[/green]")
+    
+    if output:
+        scanner.export(results, output)
 
 
 @app.command("waf-detect")
@@ -309,7 +345,7 @@ def waf_detection(
     from moriarty.modules.waf_detector import WAFDetector
     import asyncio
     
-    console.print(f"[bold red]🛡️ Detectando WAF em:[/bold red] {target}\n")
+    console.print(f"[bold cyan]🛡️ Detectando WAF em:[/bold cyan] {target}\n")
     
     detector = WAFDetector(target=target)
     waf_info = asyncio.run(detector.detect())
@@ -319,7 +355,7 @@ def waf_detection(
         console.print(f"[dim]Confidence: {waf_info['confidence']}%[/dim]")
         
         if bypass:
-            console.print("\n[red]🔓 Tentando bypass...[/red]")
+            console.print("\n[cyan]🔓 Tentando bypass...[/cyan]")
             bypass_methods = asyncio.run(detector.attempt_bypass())
             
             for method in bypass_methods:
@@ -360,12 +396,12 @@ def passive_recon(
     console = Console()
     
     # Cabeçalho
-    console.print(f"\n[bold red]🌐 Moriarty Passive Recon[/bold red]")
+    console.print(f"\n[bold cyan]🌐 Moriarty Passive Recon[/bold cyan]")
     console.print(f"[dim]Alvo:[/dim] {domain}")
     console.print(f"[dim]Data:[/dim] {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
     
     async def _run():
-        with console.status(f"[bold green]Coletando informações sobre [red]{domain}[/red]..."):
+        with console.status(f"[bold green]Coletando informações sobre [cyan]{domain}[/cyan]..."):
             recon = PassiveRecon(domain)
             try:
                 return await recon.collect()
@@ -379,15 +415,15 @@ def passive_recon(
         if status_only:
             sub_count = sum(len(v) for v in payload["subdomains"].values())
             console.print(f"[bold]🔍 Resumo do Reconhecimento[/bold]")
-            console.print(f"  • [red]Subdomínios:[/red] {sub_count} encontrados")
-            console.print(f"  • [red]Fontes:[/red] {', '.join(payload['subdomains'].keys()) or 'nenhuma'}")
-            console.print(f"  • [red]Credenciais vazadas:[/red] {len(payload['leaks'])}")
+            console.print(f"  • [cyan]Subdomínios:[/cyan] {sub_count} encontrados")
+            console.print(f"  • [cyan]Fontes:[/cyan] {', '.join(payload['subdomains'].keys()) or 'nenhuma'}")
+            console.print(f"  • [cyan]Credenciais vazadas:[/cyan] {len(payload['leaks'])}")
             return
             
         # Seção de Subdomínios
         if payload.get("subdomains"):
             table = Table(title="[bold]🌐 Subdomínios Encontrados[/bold]", box=box.ROUNDED)
-            table.add_column("Subdomínio", style="red")
+            table.add_column("Subdomínio", style="cyan")
             table.add_column("Fonte", style="green")
             
             for source, subdomains in payload["subdomains"].items():
@@ -399,7 +435,7 @@ def passive_recon(
         # Seção de Tecnologias
         if payload.get("technologies", {}).get("detections"):
             tech_table = Table(title="[bold]🛠️ Tecnologias Detectadas[/bold]", box=box.ROUNDED)
-            tech_table.add_column("Tecnologia", style="red")
+            tech_table.add_column("Tecnologia", style="cyan")
             tech_table.add_column("Confiança", style="green")
             tech_table.add_column("Categoria", style="magenta")
             
@@ -414,7 +450,7 @@ def passive_recon(
         
         # Seção de Segurança
         security_table = Table(title="[bold]🔒 Análise de Segurança[/bold]", box=box.ROUNDED)
-        security_table.add_column("Item", style="red")
+        security_table.add_column("Item", style="cyan")
         security_table.add_column("Status", style="green")
         
         # Verifica HSTS
@@ -435,7 +471,7 @@ def passive_recon(
         # Seção de Reputação
         if payload.get("reputation"):
             rep_table = Table(title="[bold]📊 Reputação do Domínio[/bold]", box=box.ROUNDED)
-            rep_table.add_column("Fonte", style="red")
+            rep_table.add_column("Fonte", style="cyan")
             rep_table.add_column("Status", style="green")
             
             for source, data in payload["reputation"].items():
@@ -458,7 +494,7 @@ def passive_recon(
         if output:
             with open(output, "w", encoding="utf-8") as handle:
                 json.dump(payload, handle, indent=2, ensure_ascii=False)
-            console.print(f"\n[green]✓[/green] Resultados salvos em: [red]{output}[/red]")
+            console.print(f"\n[green]✓[/green] Resultados salvos em: [cyan]{output}[/cyan]")
     
     except Exception as e:
         console.print(f"[red]✗ Erro durante o reconhecimento:[/red] {str(e)}")
@@ -468,384 +504,6 @@ def passive_recon(
             console.print(f"[yellow]⚠  Log de erro salvo em: {output}[/yellow]")
 
 
-import asyncio
-
-async def _port_scan_async(
-    target: str,
-    profile: str,
-    stealth: int,
-    resolve_services: bool,
-    check_vulns: bool,
-    format: str,
-    output: Optional[str]
-):
-    """Função assíncrona que realiza a varredura de portas."""
-    # Código da função port_scan aqui...
-    console = Console()
-    
-    # Valida os parâmetros
-    def validate_parameters():
-        if stealth < 0 or stealth > 5:
-            console.print("[red]Erro:[/red] O nível de stealth deve estar entre 0 e 5")
-            raise typer.Exit(1)
-            
-        if profile not in PROFILES:
-            console.print(f"[red]Erro:[/red] Perfil inválido. Use um dos seguintes: {', '.join(PROFILES.keys())}")
-            raise typer.Exit(1)
-    
-    # Configura o console do Rich
-    console = Console()
-    
-    # Valida os parâmetros
-    validate_parameters()
-    
-    # Usa o perfil especificado ou o padrão 'quick'
-    ports = PROFILES.get(profile.lower(), PROFILES["quick"])
-    
-    # Configura o arquivo de saída
-    output_path = Path(output) if output else None
-    if output_path:
-        if output_path.suffix not in (".json", ".txt", ".md"):
-            console.print("[yellow]Aviso:[/yellow] Extensão de arquivo não suportada. Usando .json")
-            output_path = output_path.with_suffix(".json")
-    
-    # Configura a barra de progresso
-    progress_columns = [
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(bar_width=None),
-        TaskProgressColumn(),
-        TimeElapsedColumn(),
-    ]
-    
-    # Cabeçalho da varredura
-    console.rule(f"🔍 [bold red]Varredura de Portas[/bold red]")
-    
-    # Tabela de informações
-    info_table = Table.grid(padding=(0, 1))
-    info_table.add_row("🌐 Alvo:", f"[bold]{target}")
-    info_table.add_row("🔢 Portas:", f"[red]{ports}")
-    info_table.add_row("🛡️  Nível de stealth:", f"[yellow]{stealth}")
-    info_table.add_row("🔍 Detecção de serviços:", "[green]Ativada[/green]" if resolve_services else "[red]Desativada[/red]")
-    info_table.add_row("⚠️  Verificação de vulnerabilidades:", "[green]Ativada[/green]" if check_vulns else "[red]Desativada[/red]")
-    
-    console.print(Panel(info_table, title="[bold]Configuração da Varredura[/bold]", border_style="red"))
-    console.print()
-    
-    async def run_scan() -> List[PortScanResult]:
-        """Executa a varredura de portas."""
-        # Usa sempre TCP Connect que não requer privilégios de root
-        console.print("[yellow]Aviso:[/yellow] Usando varredura TCP Connect (não requer privilégios de root).")
-        scan_type = "tcp"
-        
-        # Cria o scanner Nmap
-        scanner = PortScanner(
-            target=target,
-            ports=ports,
-            scan_type=scan_type,
-            stealth_level=stealth,
-            resolve_services=resolve_services,
-            check_vulns=check_vulns,
-        )
-        
-        # Executa o scan e retorna os resultados
-        return await scanner.scan()
-
-    console.print("🚀 Iniciando varredura de portas...\n")
-    
-    # Executa a varredura com barra de progresso
-    with Progress(*progress_columns) as progress:
-        task = progress.add_task("[red]Escaneando portas...", total=100)
-        
-        try:
-            # Executa o scan de forma assíncrona
-            results = await run_scan()
-            progress.update(task, completed=100)
-            
-            if not results:
-                console.print("\n[yellow]⚠️  Nenhuma porta aberta detectada[/yellow]")
-                return
-                
-            output_format = format.lower()
-            
-            if output_format == "json":
-                output_text = json.dumps([r.to_dict() for r in results], indent=2, ensure_ascii=False)
-                if not output_path:
-                    console.print_json(data=json.loads(output_text))
-            elif output_format == "markdown":
-                # Formata a saída em Markdown
-                output_lines = [
-                    f"# Resultados da varredura de portas em {target}\n",
-                    "| Porta | Protocolo | Status | Serviço | Versão | Vulnerabilidades |",
-                    "|-------|-----------|--------|---------|---------|------------------|"
-                ]
-                
-                for result in results:
-                    service = getattr(result, 'service', None)
-                    status = "🟢 ABERTA" if getattr(result, 'status', '') == "open" else "🔴 FECHADA"
-                    service_name = getattr(service, 'name', 'desconhecido') if service else "desconhecido"
-                    version = getattr(service, 'version', '') if service else ""
-                    vulns = ", ".join(service.vulns) if service and hasattr(service, 'vulns') and service.vulns else "-"
-                    
-                    output_lines.append(
-                        f"| {getattr(result, 'port', '')} | "
-                        f"{getattr(result, 'protocol', 'tcp').upper()} | "
-                        f"{status} | "
-                        f"{service_name} | "
-                        f"{version} | "
-                        f"{vulns if vulns and vulns != '[]' else '-'} |"
-                    )
-                
-                # Adiciona resumo
-                open_ports = [r for r in results if getattr(r, 'status', '') == "open"]
-                output_text = "\n".join(output_lines)
-                output_text += f"\n\n✅ **Varredura concluída!** {len(open_ports)} porta(s) aberta(s) encontrada(s)."
-                
-                if not output_path:
-                    console.print(output_text)
-            else:  # Formato de texto simples
-                # Cria tabela de resultados
-                table = Table(
-                    title=f"🔍 Resultados da varredura em {target}",
-                    box=box.ROUNDED,
-                    header_style="bold magenta",
-                    expand=True
-                )
-                
-                # Adiciona colunas
-                table.add_column("Porta", style="red", justify="right")
-                table.add_column("Protocolo", style="magenta")
-                table.add_column("Status", style="green")
-                table.add_column("Serviço", style="yellow")
-                table.add_column("Versão", style="blue")
-                table.add_column("Vulnerabilidades", style="red")
-                
-                # Adiciona linhas com os resultados
-                for result in results:
-                    service = getattr(result, 'service', None)
-                    status = "[green]ABERTA[/green]" if getattr(result, 'status', '') == "open" else "[red]FECHADA[/red]"
-                    service_name = getattr(service, 'name', 'desconhecido') if service else "desconhecido"
-                    version = getattr(service, 'version', '') if service else ""
-                    vulns = ", ".join(service.vulns) if service and hasattr(service, 'vulns') and service.vulns else "-"
-                    
-                    table.add_row(
-                        str(getattr(result, 'port', '')),
-                        getattr(result, 'protocol', 'tcp').upper(),
-                        status,
-                        service_name,
-                        version,
-                        vulns if vulns and vulns != "[]" else "-"
-                    )
-                
-                # Exibe a tabela
-                console.print(table)
-                
-                # Resumo
-                open_ports = [r for r in results if getattr(r, 'status', '') == "open"]
-                console.print(f"\n✅ [bold green]Varredura concluída![/bold green] {len(open_ports)} porta(s) aberta(s) encontrada(s).")
-                
-                # Prepara o texto para salvar em arquivo
-                output_text = str(table)
-        
-            # Salva em arquivo se especificado
-            if output_path:
-                try:
-                    output_path.parent.mkdir(parents=True, exist_ok=True)
-                    with open(output_path, "w", encoding="utf-8") as f:
-                        f.write(output_text)
-                    console.print(f"\n💾 [bold]Resultados salvos em:[/bold] [red]{output_path.absolute()}[/red]")
-                except Exception as e:
-                    console.print(f"\n❌ [bold red]Erro ao salvar arquivo:[/bold red] {str(e)}")
-    
-        except KeyboardInterrupt:
-            console.print("\n❌ [bold red]Varredura cancelada pelo usuário[/bold red]")
-            raise typer.Exit(1)
-        except Exception as e:
-            console.print(f"\n❌ [bold red]Erro durante a varredura:[/bold red] {str(e)}")
-            if "Errno 8" in str(e) or "Name or service not known" in str(e):
-                console.print("💡 [yellow]Dica:[/yellow] Não foi possível resolver o nome do host. Verifique a conexão com a internet ou o nome do domínio.")
-            if "No module named 'nmap'" in str(e):
-                console.print("💡 [yellow]Dica:[/yellow] O módulo 'python-nmap' não está instalado. Instale com: [red]pip install python-nmap[/red]")
-            raise typer.Exit(1)
-
-async def run_port_scan(
-    target: str,
-    profile: str,
-    stealth: int,
-    concurrency: int,
-    timeout: float,
-    output: Optional[str],
-    format: str,
-):
-    """Função assíncrona que executa a varredura de portas."""
-    from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn, TimeElapsedColumn
-    from rich.panel import Panel
-    from rich.table import Table
-    from pathlib import Path
-    import json
-    
-    # Valida os parâmetros
-    if stealth < 0 or stealth > 5:
-        console.print("[red]Erro:[/red] O nível de stealth deve estar entre 0 e 5")
-        raise typer.Exit(1)
-        
-    if profile not in PROFILES:
-        console.print(f"[red]Erro:[/red] Perfil inválido. Use um dos seguintes: {', '.join(PROFILES.keys())}")
-        raise typer.Exit(1)
-    
-    # Usa o perfil especificado ou o padrão 'quick'
-    ports = PROFILES.get(profile.lower(), PROFILES["quick"])
-    
-    # Configura o arquivo de saída
-    output_path = Path(output) if output else None
-    if output_path:
-        if output_path.suffix not in (".json", ".txt", ".md"):
-            console.print("[yellow]Aviso:[/yellow] Extensão de arquivo não suportada. Usando .json")
-            output_path = output_path.with_suffix(".json")
-    
-    # Configura a barra de progresso
-    progress_columns = [
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(bar_width=None),
-        TaskProgressColumn(),
-        TimeElapsedColumn(),
-    ]
-    
-    # Cabeçalho da varredura
-    console.rule(f"🔍 [bold red]Varredura de Portas[/bold red]")
-    
-    # Tabela de informações
-    info_table = Table.grid(padding=(0, 1))
-    info_table.add_row("🌐 Alvo:", f"[bold]{target}")
-    info_table.add_row("🔢 Portas:", f"[red]{ports}")
-    info_table.add_row("🛡️  Nível de stealth:", f"[yellow]{stealth}")
-    info_table.add_row("🔍 Detecção de serviços:", "[green]Ativada[/green]")
-    info_table.add_row("⚠️  Verificação de vulnerabilidades:", "[green]Ativada[/green]")
-    
-    console.print(Panel(info_table, title="[bold]Configuração da Varredura[/bold]", border_style="red"))
-    console.print()
-    
-    # Executa a varredura com barra de progresso
-    with Progress(*progress_columns) as progress:
-        task = progress.add_task("[red]Escaneando portas...", total=100)
-        
-        try:
-            # Cria o scanner Nmap
-            scanner = PortScanner(
-                target=target,
-                ports=ports,
-                scan_type="syn" if stealth < 2 else "tcp",
-                stealth_level=stealth,
-                resolve_services=True,
-                check_vulns=True,
-            )
-            
-            # Executa o scan de forma assíncrona
-            results = await scanner.scan()
-            progress.update(task, completed=100)
-            
-            if not results:
-                console.print("\n[yellow]⚠️  Nenhuma porta aberta detectada[/yellow]")
-                return
-            
-            # Formata a saída
-            output_format = format.lower()
-            
-            if output_format == "json":
-                output_text = json.dumps([r.to_dict() for r in results], indent=2, ensure_ascii=False)
-                if not output_path:
-                    console.print_json(data=json.loads(output_text))
-            elif output_format == "markdown":
-                output_lines = [
-                    f"# Resultados da varredura de portas em {target}\n",
-                    "| Porta | Protocolo | Status | Serviço | Versão |",
-                    "|-------|-----------|--------|---------|---------|"
-                ]
-                
-                for result in results:
-                    service = getattr(result, 'service', None)
-                    status = "🟢 ABERTA" if getattr(result, 'status', '') == "open" else "🔴 FECHADA"
-                    service_name = getattr(service, 'name', 'desconhecido') if service else "desconhecido"
-                    version = getattr(service, 'version', '') if service else ""
-                    
-                    output_lines.append(
-                        f"| {getattr(result, 'port', '')} | "
-                        f"{getattr(result, 'protocol', 'tcp').upper()} | "
-                        f"{status} | "
-                        f"{service_name} | "
-                        f"{version} |"
-                    )
-                
-                # Adiciona resumo
-                open_ports = [r for r in results if getattr(r, 'status', '') == "open"]
-                output_text = "\n".join(output_lines)
-                output_text += f"\n\n✅ **Varredura concluída!** {len(open_ports)} porta(s) aberta(s) encontrada(s)."
-                
-                if not output_path:
-                    console.print(output_text)
-            else:  # Formato de texto simples
-                # Cria tabela de resultados
-                table = Table(
-                    title=f"🔍 Resultados da varredura em {target}",
-                    box=box.ROUNDED,
-                    header_style="bold magenta",
-                    expand=True
-                )
-                
-                # Adiciona colunas
-                table.add_column("Porta", style="red", justify="right")
-                table.add_column("Protocolo", style="magenta")
-                table.add_column("Status", style="green")
-                table.add_column("Serviço", style="yellow")
-                table.add_column("Versão", style="blue")
-                
-                # Adiciona linhas com os resultados
-                for result in results:
-                    service = getattr(result, 'service', None)
-                    status = "[green]ABERTA[/green]" if getattr(result, 'status', '') == "open" else "[red]FECHADA[/red]"
-                    service_name = getattr(service, 'name', 'desconhecido') if service else "desconhecido"
-                    version = getattr(service, 'version', '') if service else ""
-                    
-                    table.add_row(
-                        str(getattr(result, 'port', '')),
-                        getattr(result, 'protocol', 'tcp').upper(),
-                        status,
-                        service_name,
-                        version,
-                    )
-                
-                # Exibe a tabela
-                console.print(table)
-                
-                # Resumo
-                open_ports = [r for r in results if getattr(r, 'status', '') == "open"]
-                console.print(f"\n✅ [bold green]Varredura concluída![/bold green] {len(open_ports)} porta(s) aberta(s) encontrada(s).")
-                
-                # Prepara o texto para salvar em arquivo
-                output_text = str(table)
-    
-            # Salva em arquivo se especificado
-            if output_path:
-                try:
-                    output_path.parent.mkdir(parents=True, exist_ok=True)
-                    with open(output_path, "w", encoding="utf-8") as f:
-                        f.write(output_text)
-                    console.print(f"\n💾 [bold]Resultados salvos em:[/bold] [red]{output_path.absolute()}[/red]")
-                except Exception as e:
-                    console.print(f"\n❌ [bold red]Erro ao salvar arquivo:[/bold red] {str(e)}")
-    
-        except KeyboardInterrupt:
-            console.print("\n❌ [bold red]Varredura cancelada pelo usuário[/bold red]")
-            raise typer.Exit(1)
-        except Exception as e:
-            console.print(f"\n❌ [bold red]Erro durante a varredura:[/bold red] {str(e)}")
-            if "Errno 8" in str(e) or "Name or service not known" in str(e):
-                console.print("💡 [yellow]Dica:[/yellow] Não foi possível resolver o nome do host. Verifique a conexão com a internet ou o nome do domínio.")
-            if "No module named 'nmap'" in str(e):
-                console.print("💡 [yellow]Dica:[/yellow] O módulo 'python-nmap' não está instalado. Instale com: [red]pip install python-nmap[/red]")
-            raise typer.Exit(1)
-
 @app.command("ports")
 def port_scan(
     target: str = typer.Argument(..., help="Domínio ou IP para escanear"),
@@ -903,7 +561,7 @@ def port_scan(
     ),
 ):
     """
-    🔍 Varredura avançada de portas com detecção de serviços e vulnerabilidades usando Nmap.
+    🔍 Varredura avançada de portas com detecção de serviços e vulnerabilidades.
     
     Exemplos:
         moriarty domain ports example.com
@@ -912,218 +570,84 @@ def port_scan(
     """
     import asyncio
     import json
-    import os
-    import sys
     from pathlib import Path
-    from typing import List, Dict, Any, Optional
-    
-    from rich.progress import (
-        Progress,
-        SpinnerColumn,
-        BarColumn,
-        TextColumn,
-        TimeElapsedColumn,
-        TaskProgressColumn,
-    )
-    from rich.panel import Panel
-    from rich.table import Table, box
-    from rich.console import Console
-    
-    from moriarty.modules.port_scanner_nmap import PortScanner, PortScanResult, ServiceInfo
-    
-    # Mapeia os perfis para o formato do Nmap
-    port_profiles = {
-        "quick": "21-23,25,53,80,110,111,135,139,143,389,443,445,465,587,993,995,1433,1521,2049,3306,3389,5432,5900,6379,8080,8443,9000,10000,27017",
-        "web": "80,443,8080,8443,8000,8888,10443,4443",
-        "mail": "25,110,143,465,587,993,995",
-        "db": "1433,1521,27017-27019,28017,3306,5000,5432,5984,6379,8081",
-        "full": "1-1024",
-        "all": "1-65535",
-    }
-    
-    # Verifica se o Nmap está instalado
-    def check_nmap_installed() -> bool:
-        """Verifica se o Nmap está instalado no sistema."""
-        try:
-            import nmap
-            return True
-        except ImportError:
-            return False
-    
-    # Valida os parâmetros de entrada
-    def validate_parameters() -> None:
-        """Valida os parâmetros de entrada."""
-        if not check_nmap_installed():
-            console.print("❌ [bold red]Erro:[/bold red] O módulo 'python-nmap' não está instalado.")
-            console.print("💡 [yellow]Dica:[/yellow] Instale com: pip install python-nmap")
-            raise typer.Exit(1)
-            
-        if stealth < 0 or stealth > 5:
-            console.print("❌ [bold red]Erro:[/bold red] O nível de stealth deve estar entre 0 e 5.")
-            raise typer.Exit(1)
-    
-    # Inicializa o console do Rich
-    console = Console()
-    
-    # Valida os parâmetros
-    validate_parameters()
-    
-    # Usa o perfil especificado ou o padrão 'quick'
-    ports = port_profiles.get(profile.lower(), port_profiles["quick"])
-    
-    # Configura o arquivo de saída
-    output_path = Path(output) if output else None
-    if output_path:
-        if output_path.suffix not in (".json", ".txt", ".md"):
+    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_path = output_path.with_suffix(".json")
-    
-    # Configura a barra de progresso
-    progress_columns = [
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        BarColumn(bar_width=None),
-        TaskProgressColumn(),
-        TimeElapsedColumn(),
-    ]
-    
-    # Cabeçalho da varredura
-    console.rule(f"🔍 [bold red]Varredura de Portas[/bold red]")
-    
-    # Tabela de informações
-    info_table = Table.grid(padding=(0, 1))
-    info_table.add_row("🌐 Alvo:", f"[bold]{target}")
-    info_table.add_row("🔢 Portas:", f"[red]{ports}")
-    info_table.add_row("🛡️  Nível de stealth:", f"[yellow]{stealth}")
-    info_table.add_row("🔍 Detecção de serviços:", "[green]Ativada[/green]" if resolve_services else "[red]Desativada[/red]")
-    info_table.add_row("⚠️  Verificação de vulnerabilidades:", "[green]Ativada[/green]" if check_vulns else "[red]Desativada[/red]")
-    
-    console.print(Panel(info_table, title="[bold]Configuração da Varredura[/bold]", border_style="red"))
-    console.print()
-    
-    async def run_scan() -> List[PortScanResult]:
-        """Executa a varredura de portas."""
-        # Usa sempre TCP Connect que não requer privilégios de root
-        console.print("[yellow]Aviso:[/yellow] Usando varredura TCP Connect (não requer privilégios de root).")
-        scan_type = "tcp"
-        
-        # Cria o scanner Nmap
+            output = output.with_suffix(".json")
+
+    async def _run():
         scanner = PortScanner(
             target=target,
-            ports=ports,
-            scan_type=scan_type,
+            profile=profile,
+            concurrency=concurrency,
+            timeout=timeout,
             stealth_level=stealth,
             resolve_services=resolve_services,
             check_vulns=check_vulns,
         )
-        
-        # Executa o scan e retorna os resultados
         return await scanner.scan()
 
-    console.print("🚀 Iniciando varredura de portas...\n")
+    # 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}")
     
-    # Função para salvar resultados em diferentes formatos
-    def save_results(results, output_path, format):
-        output_format = format.lower()
+    try:
+        results = asyncio.run(_run())
         
-        try:
-            if output_format == "json":
-                output_text = json.dumps([r.to_dict() for r in results], indent=2, ensure_ascii=False)
-                with open(output_path, 'w', encoding='utf-8') as f:
+        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)
-            elif output_format == "markdown":
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    f.write("# Resultados da Varredura de Portas\n\n")
-                    f.write("| Porta | Estado | Serviço | Versão |\n")
-                    f.write("|-------|--------|---------|---------|\n")
-                    for result in results:
-                        if result.state == 'open':
-                            service = result.service or "desconhecido"
-                            version = result.version or ""
-                            f.write(f"| {result.port} | ABERTA | {service} | {version} |\n")
-            else:  # text
-                with open(output_path, 'w', encoding='utf-8') as f:
-                    for result in results:
-                        if result.state == 'open':
-                            service = result.service or "desconhecido"
-                            version = f" ({result.version})" if result.version else ""
-                            f.write(f"Porta {result.port}/tcp: ABERTA - {service}{version}\n")
-        except Exception as e:
-            console.print(f"❌ [bold red]Erro ao salvar o arquivo:[/bold red] {str(e)}")
-            raise typer.Exit(1)
+            console.print(f"\n[green]✅ Resultados salvos em:[/green] {output.absolute()}")
     
-    # Executa o scan de forma assíncrona
-    with Progress(*progress_columns) as progress:
-        task = progress.add_task("[red]Escaneando portas...", total=100)
-        
-        try:
-            # Executa a função assíncrona
-            results = asyncio.run(run_scan())
-            progress.update(task, completed=100)
-            
-            # Exibe os resultados
-            if results:
-                # Cria uma tabela para exibir os resultados
-                table = Table(title="[bold]Resultados da Varredura[/bold]")
-                table.add_column("Porta", style="red", no_wrap=True)
-                table.add_column("Estado", style="green")
-                table.add_column("Serviço", style="yellow")
-                table.add_column("Versão", style="magenta")
-                
-                for result in results:
-                    if result.state == 'open':
-                        service = result.service or "desconhecido"
-                        version = result.version or ""
-                        table.add_row(
-                            str(result.port),
-                            "[green]ABERTA[/green]",
-                            service,
-                            version
-                        )
-                
-                console.print()
-                console.print(table)
-                
-                # Salva os resultados em um arquivo, se solicitado
-                if output_path:
-                    save_results(results, output_path, format)
-                    console.print(f"\n✅ Resultados salvos em: [bold red]{output_path}[/bold red]")
-                
-                # Exibe saída JSON no console se não houver arquivo de saída e o formato for JSON
-                if format.lower() == "json" and not output_path:
-                    output_text = json.dumps([r.to_dict() for r in results], indent=2, ensure_ascii=False)
-                    console.print_json(data=json.loads(output_text))
-                    
-            else:
-                console.print("\n❌ Nenhuma porta aberta encontrada ou ocorreu um erro durante a varredura.")
-                
-        except Exception as e:
-            progress.update(task, completed=100)
-            console.print(f"\n❌ [bold red]Erro durante a varredura:[/bold red] {str(e)}")
-            if "Errno 8" in str(e) or "Name or service not known" in str(e):
-                console.print("💡 [yellow]Dica:[/yellow] Não foi possível resolver o nome do host. Verifique a conexão com a internet ou o nome do domínio.")
-            raise typer.Exit(1)
+    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}")
 
 
 @app.command("crawl")
 def crawl(
     domain: str = typer.Argument(..., help="Alvo base (ex: https://example.com)"),
+    max_pages: int = typer.Option(100, "--max-pages", help="Máximo de páginas"),
     max_depth: int = typer.Option(2, "--max-depth", help="Profundidade máxima"),
-    max_pages: int = typer.Option(100, "--max-pages", help="Número máximo de páginas a serem rastreadas"),
     concurrency: int = typer.Option(10, "--concurrency", help="Workers paralelos"),
     follow_subdomains: bool = typer.Option(False, "--follow-subdomains", help="Seguir subdomínios"),
     output: Optional[str] = typer.Option(None, "--output", "-o", help="Arquivo JSON de saída"),
 ):
-    """Crawler leve para mapear formulários e rotas.
-    
-    Exemplos:
-        moriarty domain crawl https://example.com
-        moriarty domain crawl https://example.com --max-depth 3 --max-pages 50
-    """
+    """Crawler leve para mapear formulários e rotas."""
     import asyncio
     import json
-    from typing import Dict, Any
-    from pathlib import Path
 
     async def _run():
         crawler = WebCrawler(
@@ -1138,46 +662,15 @@ def crawl(
         finally:
             await crawler.close()
 
-    try:
-        console.print(f"🚀 Iniciando crawler em [red]{domain}[/red]...")
-        pages = asyncio.run(_run())
-        
-        # Cria um dicionário seguro para serialização
-        safe_pages = {}
-        for url, page in pages.items():
-            safe_pages[url] = {
-                'url': url,
-                'title': getattr(page, 'title', ''),
-                'forms': [form.__dict__ for form in getattr(page, 'forms', [])],
-                'links': getattr(page, 'links', []),
-                'status_code': getattr(page, 'status_code', 0)
-            }
-        
-        # Exibe resumo
-        summary = {
-            "total_pages": len(pages),
-            "forms": sum(len(page.get('forms', [])) for page in safe_pages.values()),
-            "links_unicos": len({link for page in safe_pages.values() for link in page.get('links', [])})
-        }
-        
-        console.print("\n📊 [bold]Resumo do Crawling:[/bold]")
-        console.print(f"• Páginas processadas: {summary['total_pages']}")
-        console.print(f"• Formulários encontrados: {summary['forms']}")
-        console.print(f"• Links únicos: {summary['links_unicos']}")
+    pages = asyncio.run(_run())
+    summary = {
+        "total_pages": len(pages),
+        "forms": sum(len(page.forms) for page in pages.values()),
+    }
+    console.print_json(data=summary)
 
-        # Salva em arquivo se especificado
-        if output:
-            output_path = Path(output)
-            output_path.parent.mkdir(parents=True, exist_ok=True)
-            with open(output_path, "w", encoding="utf-8") as f:
-                json.dump({
-                    "summary": summary,
-                    "pages": safe_pages
-                }, f, indent=2, ensure_ascii=False)
-            console.print(f"\n💾 [bold]Resultados salvos em:[/bold] [red]{output_path.absolute()}[/red]")
-            
-    except Exception as e:
-        console.print(f"\n❌ [bold red]Erro durante o crawling:[/bold red] {str(e)}")
-        if "Failed to establish a new connection" in str(e):
-            console.print("💡 [yellow]Dica:[/yellow] Verifique sua conexão com a internet ou a URL fornecida.")
-        raise typer.Exit(1)
+    if output:
+        payload = {url: page.__dict__ for url, page in pages.items()}
+        with open(output, "w", encoding="utf-8") as handle:
+            json.dump(payload, handle, indent=2, ensure_ascii=False)
+        console.print(f"[green]✓ Resultado salvo em[/green] {output}")