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

moriarty/cli/domain_cmd.py

@@ -5,14 +5,15 @@ import json
 from typing import Optional, Dict, List
 
 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.passive_recon import PassiveRecon
-from rich.console import Console
 
-app = typer.Typer(name="domain", help="🌐 Domain/IP reconnaissance and scanning.")
+app = typer.Typer(help="🔍 Ferramentas avançadas de reconhecimento de domínios")
 console = Console()
 
 
@@ -61,7 +62,7 @@ def scan_full(
     
     if output:
         scanner.export(output)
-        console.print(f"[green]✅[/green] Results saved to: [cyan]{output}[/cyan]\n")
+        console.print(f"[green]✅[/green] Results saved to: [red]{output}[/red]\n")
 
 
 @app.command("subdiscover")
@@ -101,7 +102,7 @@ def subdomain_discovery(
     from moriarty.modules.subdomain_discovery import SubdomainDiscovery
     import asyncio
     
-    console.print(f"[bold cyan]🔍 Descobrindo subdomínios de:[/bold cyan] {domain}\n")
+    console.print(f"[bold red]🔍 Descobrindo subdomínios de:[/bold red] {domain}\n")
     
     discovery = SubdomainDiscovery(
         domain=domain,
@@ -141,7 +142,7 @@ def wayback_urls(
     from moriarty.modules.wayback_discovery import WaybackDiscovery
     import asyncio
     
-    console.print(f"[bold cyan]🕰️ Buscando URLs históricas de:[/bold cyan] {domain}\n")
+    console.print(f"[bold red]🕰️ Buscando URLs históricas de:[/bold red] {domain}\n")
     
     wayback = WaybackDiscovery(
         domain=domain,
@@ -181,7 +182,7 @@ def template_scan(
 
     from moriarty.modules.template_scanner import TemplateScanner
 
-    console.print(f"[bold cyan]📝 Template scan em:[/bold cyan] {target}\n")
+    console.print(f"[bold red]📝 Template scan em:[/bold red] {target}\n")
 
     scanner = TemplateScanner(
         target=target,
@@ -227,7 +228,7 @@ def run_pipeline(
     from moriarty.modules.pipeline_orchestrator import PipelineOrchestrator
     import asyncio
     
-    console.print(f"[bold cyan]🔄 Executando pipeline:[/bold cyan] {pipeline_file}\n")
+    console.print(f"[bold red]🔄 Executando pipeline:[/bold red] {pipeline_file}\n")
     
     orchestrator = PipelineOrchestrator(
         pipeline_file=pipeline_file,
@@ -283,41 +284,7 @@ def stealth_command(
         console.print(f"[red]❌ Ação inválida: {action}[/red]")
 
 
-@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)
+# A função port_scan foi movida para a implementação mais completa abaixo
 
 
 @app.command("waf-detect")
@@ -342,7 +309,7 @@ def waf_detection(
     from moriarty.modules.waf_detector import WAFDetector
     import asyncio
     
-    console.print(f"[bold cyan]🛡️ Detectando WAF em:[/bold cyan] {target}\n")
+    console.print(f"[bold red]🛡️ Detectando WAF em:[/bold red] {target}\n")
     
     detector = WAFDetector(target=target)
     waf_info = asyncio.run(detector.detect())
@@ -352,7 +319,7 @@ def waf_detection(
         console.print(f"[dim]Confidence: {waf_info['confidence']}%[/dim]")
         
         if bypass:
-            console.print("\n[cyan]🔓 Tentando bypass...[/cyan]")
+            console.print("\n[red]🔓 Tentando bypass...[/red]")
             bypass_methods = asyncio.run(detector.attempt_bypass())
             
             for method in bypass_methods:
@@ -393,12 +360,12 @@ def passive_recon(
     console = Console()
     
     # Cabeçalho
-    console.print(f"\n[bold cyan]🌐 Moriarty Passive Recon[/bold cyan]")
+    console.print(f"\n[bold red]🌐 Moriarty Passive Recon[/bold red]")
     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 [cyan]{domain}[/cyan]..."):
+        with console.status(f"[bold green]Coletando informações sobre [red]{domain}[/red]..."):
             recon = PassiveRecon(domain)
             try:
                 return await recon.collect()
@@ -412,15 +379,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"  • [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'])}")
+            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'])}")
             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="cyan")
+            table.add_column("Subdomínio", style="red")
             table.add_column("Fonte", style="green")
             
             for source, subdomains in payload["subdomains"].items():
@@ -432,7 +399,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="cyan")
+            tech_table.add_column("Tecnologia", style="red")
             tech_table.add_column("Confiança", style="green")
             tech_table.add_column("Categoria", style="magenta")
             
@@ -447,7 +414,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="cyan")
+        security_table.add_column("Item", style="red")
         security_table.add_column("Status", style="green")
         
         # Verifica HSTS
@@ -468,7 +435,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="cyan")
+            rep_table.add_column("Fonte", style="red")
             rep_table.add_column("Status", style="green")
             
             for source, data in payload["reputation"].items():
@@ -491,7 +458,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: [cyan]{output}[/cyan]")
+            console.print(f"\n[green]✓[/green] Resultados salvos em: [red]{output}[/red]")
     
     except Exception as e:
         console.print(f"[red]✗ Erro durante o reconhecimento:[/red] {str(e)}")
@@ -501,6 +468,384 @@ 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"),
@@ -558,7 +903,7 @@ def port_scan(
     ),
 ):
     """
-    🔍 Varredura avançada de portas com detecção de serviços e vulnerabilidades.
+    🔍 Varredura avançada de portas com detecção de serviços e vulnerabilidades usando Nmap.
     
     Exemplos:
         moriarty domain ports example.com
@@ -567,84 +912,218 @@ def port_scan(
     """
     import asyncio
     import json
+    import os
+    import sys
     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"):
+    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"):
             console.print("[yellow]Aviso:[/yellow] Extensão de arquivo não suportada. Usando .json")
-            output = output.with_suffix(".json")
-
-    async def _run():
+            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,
-            profile=profile,
-            concurrency=concurrency,
-            timeout=timeout,
+            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()
 
-    # 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}")
+    console.print("🚀 Iniciando varredura de portas...\n")
     
-    try:
-        results = asyncio.run(_run())
+    # Função para salvar resultados em diferentes formatos
+    def save_results(results, output_path, format):
+        output_format = format.lower()
         
-        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:
+        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:
                     f.write(output_text)
-            console.print(f"\n[green]✅ Resultados salvos em:[/green] {output.absolute()}")
+            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)
     
-    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}")
+    # 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)
 
 
 @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."""
+    """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
+    """
     import asyncio
     import json
+    from typing import Dict, Any
+    from pathlib import Path
 
     async def _run():
         crawler = WebCrawler(
@@ -659,15 +1138,46 @@ def crawl(
         finally:
             await crawler.close()
 
-    pages = asyncio.run(_run())
-    summary = {
-        "total_pages": len(pages),
-        "forms": sum(len(page.forms) for page in pages.values()),
-    }
-    console.print_json(data=summary)
+    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']}")
 
-    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}")
+        # 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)