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

moriarty/modules/port_scanner.py

@@ -2,31 +2,19 @@
 from __future__ import annotations
 
 import asyncio
-import contextlib
 import json
 import re
-import socket
 import ssl
+import contextlib
 from dataclasses import dataclass, field
-from datetime import datetime, timedelta
+from datetime import datetime
+from typing import Dict, List, Optional, Any, Set
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple, Any, Set, Union
-from urllib.parse import urlparse
-import aiofiles
-import yaml
-import requests
-from packaging import version
-
-# Importa a classe ServiceInfo para uso no código
-
-import aiohttp
-import dns.resolver
 import dns.asyncresolver
-import OpenSSL.crypto
 import structlog
 from rich.console import Console
-from rich.json import JSON
-from rich.table import Table
+from rich.progress import track
+from rich.table import Table, box
 
 logger = structlog.get_logger(__name__)
 console = Console()
@@ -182,7 +170,7 @@ class ServiceInfo:
     ssl: bool = False
     ssl_info: Optional[Dict[str, Any]] = None
     banner: Optional[str] = None
-    vulns: List[Dict[str, str]] = field(default_factory=list)
+    vulns: List[str] = field(default_factory=list)  # Alterado para List[str]
     cpe: Optional[str] = None
     extra: Dict[str, Any] = field(default_factory=dict)
     confidence: float = 0.0  # Nível de confiança na identificação (0.0 a 1.0)
@@ -206,7 +194,7 @@ class ServiceInfo:
 class PortScanResult:
     port: int
     protocol: str = "tcp"
-    status: str = "open"
+    status: str = "closed"
     target: Optional[str] = None
     service: Optional[ServiceInfo] = None
     banner: Optional[str] = None
@@ -269,112 +257,197 @@ class PortScanner:
         # Ajusta timeout baseado no nível de stealth
         self.timeout = timeout * (1 + (self.stealth_level * 0.5))
         
-        # Cache para serviços já identificados
-        self.service_cache: Dict[int, ServiceInfo] = {}
-        
         # Resolvedor DNS assíncrono
         self.resolver = dns.asyncresolver.Resolver()
         self.resolver.timeout = 2.0
         self.resolver.lifetime = 2.0
 
     async def scan(self) -> List[PortScanResult]:
-        """Executa a varredura de portas."""
-        console.print(f"[bold]Iniciando varredura em {self.target}[/bold]")
-        console.print(f"Perfil: {self.profile}, Portas: {len(PROFILES[self.profile])}")
+        """Executa a varredura de portas de forma assíncrona."""
+        console.print(f"[bold]🔍 Iniciando varredura em {self.target}[/bold]")
+        ports = sorted(PROFILES[self.profile])
+        total_ports = len(ports)
+        console.print(f"📊 Perfil: [bold]{self.profile}[/bold], Portas a verificar: [bold]{total_ports}[/bold]")
         
-        ports = PROFILES[self.profile]
         if self.stealth_level > 0:
-            # Aleatoriza a ordem das portas para maior discrição
-            random.shuffle(ports)
-            
-        sem = asyncio.Semaphore(self.concurrency)
-        results: List[PortScanResult] = []
+            console.print(f"🔒 Modo furtivo: nível {self.stealth_level}")
         
-        async def worker(port: int):
-            async with sem:
-                result = await self._probe_port(port)
-                if result:
-                    results.append(result)
-                    self._print_result(result)
+        results: List[PortScanResult] = []
+        sem = asyncio.Semaphore(self.concurrency)
         
-        # Executa os workers em paralelo
-        tasks = [worker(port) for port in ports]
-        await asyncio.gather(*tasks)
+        # Barra de progresso
+        with console.status("[bold]Verificando portas...") as status:
+            async def scan_port(port: int) -> PortScanResult:
+                async with sem:
+                    try:
+                        return await self._probe_port(port)
+                    except Exception as e:
+                        logger.debug(f"Erro ao escanear porta {port}: {str(e)}")
+                        return PortScanResult(port=port, status="error", target=self.target)
+            
+            # Executa as tarefas em lote para evitar sobrecarga de memória
+            batch_size = min(100, max(10, self.concurrency * 2))
+            for i in range(0, len(ports), batch_size):
+                batch = ports[i:i + batch_size]
+                tasks = [scan_port(port) for port in batch]
+                batch_results = await asyncio.gather(*tasks)
+                results.extend(batch_results)
+                
+                # Atualiza status
+                open_ports = len([r for r in results if r.status == "open"])
+                status.update(f"[bold]Verificando portas... {min(i + len(batch), total_ports)}/{total_ports} (abertas: {open_ports})")
         
         # Ordena os resultados por número de porta
         results.sort(key=lambda r: r.port)
         
-        return results
-    
-    def _print_result(self, result: PortScanResult):
-        """Exibe o resultado formatado no console."""
-        port_info = f"[bold blue]{result.port:>5}/tcp[/bold blue]"
-        status = "[green]open[/green]" if result.status == "open" else "[yellow]filtered[/yellow]"
+        # Filtra e conta portas por status
+        open_ports = [r for r in results if r.status == "open"]
+        closed_ports = [r for r in results if r.status == "closed"]
+        error_ports = [r for r in results if r.status == "error"]
         
-        service_name = result.service.name if result.service else "unknown"
-        service_info = f"[cyan]{service_name}[/cyan]"
+        # Exibe resultados
+        console.print("\n[bold]📊 Resultados da varredura:[/bold]")
         
-        if result.service and result.service.version:
-            service_info += f" [yellow]{result.service.version}[/yellow]"
+        # Tabela de portas abertas
+        if open_ports:
+            table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+            table.add_column("Porta", style="red", width=10)
+            table.add_column("Status", style="green")
+            table.add_column("Serviço", style="blue")
+            table.add_column("Detalhes", style="yellow")
             
-        if result.service and result.service.ssl:
-            service_info += " [green]🔒[/green]"
+            for result in open_ports:
+                service = result.service.name if result.service else "desconhecido"
+                version = f" {result.service.version}" if result.service and result.service.version else ""
+                ssl = "🔒" if result.service and result.service.ssl else ""
+                vulns = f" [red]({len(result.service.vulns)} vulns)" if result.service and result.service.vulns else ""
+                
+                table.add_row(
+                    f"{result.port}/tcp",
+                    "[green]ABERTA[/green]",
+                    f"[red]{service}{version}[/red] {ssl}",
+                    vulns
+                )
+                
+                # Adiciona banner se disponível
+                if result.banner:
+                    banner = result.banner.split('\n')[0][:80]  # Pega apenas a primeira linha e limita o tamanho
+                    table.add_row("", "", f"[dim]↳ {banner}...[/dim]", "")
             
-        if result.service and result.service.vulns:
-            vuln_count = len(result.service.vulns)
-            service_info += f" [red]({vuln_count} vulns)[/red]"
+            console.print("\n[bold]🚪 Portas abertas:[/bold]")
+            console.print(table)
         
-        console.print(f"{port_info} {status} {service_info}")
+        # Resumo
+        console.print("\n[bold]📋 Resumo:[/bold]")
+        console.print(f"  • [green]Portas abertas:[/green] {len(open_ports)}")
+        console.print(f"  • [red]Portas fechadas:[/red] {len(closed_ports)}")
+        if error_ports:
+            console.print(f"  • [yellow]Erros:[/yellow] {len(error_ports)} porta(s) com erro")
         
-        if result.banner:
-            console.print(f"      [dim]Banner: {result.banner[:100]}{'...' if len(result.banner) > 100 else ''}[/dim]")
+        # Lista de portas abertas resumida
+        if open_ports:
+            open_ports_str = ", ".join(str(r.port) for r in open_ports)
+            if len(open_ports_str) > 80:
+                open_ports_str = open_ports_str[:77] + "..."
+            console.print(f"\n🔍 Portas abertas: {open_ports_str}")
+        
+        return results
     
-    async def _probe_port(self, port: int) -> Optional[PortScanResult]:
+    def _print_result(self, result: PortScanResult):
+        """Método mantido para compatibilidade, mas não é mais usado internamente."""
+        pass    
+    async def _probe_port(self, port: int) -> PortScanResult:
         """Verifica se uma porta está aberta e coleta informações do serviço."""
+        result = PortScanResult(port=port, status="closed", target=self.target)
+        
         # Atraso aleatório para evitar detecção
         if self.stealth_level > 0:
+            import random
             await asyncio.sleep(random.uniform(0.01, 0.5) * self.stealth_level)
         
-        # Tenta conexão TCP
+        # Portas que devem ser verificadas com TLS primeiro
+        ssl_ports = {
+            # HTTPS
+            443,  # HTTPS padrão
+            8443,  # HTTPS alternativo
+            10443,  # HTTPS alternativo
+            4443,   # HTTPS alternativo
+            1443,   # HTTPS alternativo
+            9443,   # Nginx Admin / HTTPS alternativo
+            # Email seguro
+            465,    # SMTPS
+            993,    # IMAPS
+            995,    # POP3S
+            # Outros serviços seguros
+            636,    # LDAPS
+            853,    # DNS sobre TLS
+            989,    # FTPS Data
+            990,    # FTPS Control
+            992,    # Telnet sobre TLS
+            994,    # IRCS
+            # Adicionais comuns
+            5061,   # SIP-TLS
+            5062,   # SIP-TLS
+            5989,   # CIM XML sobre HTTPS
+            832,    # NETCONF sobre TLS
+            6514,   # Syslog sobre TLS
+            5684,   # CoAP sobre DTLS
+            8883,   # MQTT sobre SSL
+            8884,   # MQTT sobre WebSocket
+            8888,   # HTTP alternativo com SSL
+            10000,  # Webmin
+            10001,  # Webmin alternativo
+            20000   # Usermin (Webmin para usuários)
+        }
+        
+        # Portas que devem tentar obter banner via TLS
+        http_ports_with_tls = {443, 8443, 10443, 4443, 9443, 10000, 10001, 20000}
+
+        
         try:
-            # Usa um timeout menor para a conexão inicial
-            conn_timeout = min(1.0, self.timeout)
+            # Para portas SSL conhecidas, tenta TLS primeiro
+            if port in ssl_ports:
+                ssl_info = await self._check_ssl(port)
+                if ssl_info:
+                    result.status = "open"
+                    service_name = self._identify_ssl_service(port, ssl_info)
+                    result.service = ServiceInfo(name=service_name, ssl=True, ssl_info=ssl_info)
+                    
+                    # Tenta obter banner apenas para portas HTTP/HTTPS conhecidas
+                    if port in http_ports_with_tls:
+                        try:
+                            banner = await self._get_ssl_banner(port)
+                            if banner:
+                                result.banner = banner
+                                # Atualiza informações do serviço com base no banner
+                                service_info = await self._identify_service(port, banner)
+                                if service_info:
+                                    result.service.name = service_info.name
+                                    result.service.version = service_info.version
+                                    result.service.cpe = service_info.cpe
+                        except Exception as e:
+                            logger.debug(f"Erro ao obter banner SSL da porta {port}: {str(e)}")
+                    
+                    return result
+
+            
+            # Se não for porta SSL ou falhar, tenta conexão TCP normal
             reader, writer = await asyncio.wait_for(
                 asyncio.open_connection(self.target, port),
-                timeout=conn_timeout
+                timeout=self.timeout
             )
             
-            # Se chegou aqui, a porta está aberta
-            result = PortScanResult(port=port, status="open", target=self.target)
-            
-            # Tenta obter o banner do serviço
+            # Se chegou aqui, a conexão TCP foi estabelecida, mas ainda não sabemos se a porta está realmente aberta
+            # Vamos tentar ler o banner para confirmar
             try:
-                # Configura timeout para leitura
-                read_timeout = max(1.0, self.timeout - 1.0)
+                # Lê o banner inicial (até 1024 bytes)
+                banner_bytes = await asyncio.wait_for(
+                    reader.read(1024),
+                    timeout=self.timeout
+                )
                 
-                # Envia uma requisição específica baseada no serviço comum da porta
-                banner_bytes = b""
-                if port in [80, 8080, 8000, 8008, 8081, 8443, 443]:
-                    # HTTP/HTTPS - envia um HEAD / HTTP/1.0
-                    writer.write(b"HEAD / HTTP/1.0\r\nHost: " + self.target.encode() + b"\r\n\r\n")
-                elif port == 21:
-                    # FTP - envia um comando USER anonymous
-                    writer.write(b"USER anonymous\r\n")
-                elif port == 22:
-                    # SSH - apenas lê a versão do servidor
-                    pass
-                elif port == 25 or port == 587 or port == 465:
-                    # SMTP - envia EHLO
-                    writer.write(b"EHLO moriarty-scanner\r\n")
-                elif port == 53:
-                    # DNS - envia uma query DNS padrão
-                    query = b'\x00\x01\x01\x00\x00\x01\x00\x00\x00\x00\x00\x01\x07version\x04bind\x00\x00\x10\x00\x03'
-                    writer.write(query)
-                
-                await writer.drain()
-                
-                # Lê até 1024 bytes
-                banner_bytes = await asyncio.wait_for(reader.read(1024), timeout=read_timeout)
+                # Se chegou aqui sem exceção, a porta está realmente aberta
+                result.status = "open"
                 
                 if banner_bytes:
                     # Tenta decodificar como texto
@@ -382,70 +455,74 @@ class PortScanner:
                         banner = banner_bytes.decode('utf-8', errors='replace').strip()
                         result.banner = banner
                         
-                        # Tenta identificar o serviço pelo banner
+                        # Identifica o serviço baseado no banner
                         service_info = await self._identify_service(port, banner)
                         if service_info:
                             result.service = service_info
+                            
                     except UnicodeDecodeError:
-                        # Se não for texto, mostra como hexdump
-                        result.banner = banner_bytes.hex(' ', 1)
-                else:
-                    # Se não recebeu banner, verifica se a porta é conhecida
-                    if port in SERVICE_MAP:
-                        result.service = ServiceInfo(name=SERVICE_MAP[port])
-                    else:
-                        # Se não recebeu resposta, marca como filtrada
-                        result.status = "filtered"
-                        return result
-            except (asyncio.TimeoutError, ConnectionResetError, OSError):
-                # Ignora erros de leitura do banner
-                pass
-            
-            # Verifica se é um serviço SSL/TLS
-            if port in [443, 465, 636, 993, 995, 8443] or (result.service and result.service.ssl):
-                ssl_info = await self._check_ssl(port)
-                if ssl_info:
-                    if not result.service:
-                        result.service = ServiceInfo(name="ssl")
-                    result.service.ssl = True
-                    result.service.ssl_info = ssl_info
-                    
-                    # Tenta identificar o serviço SSL
-                    if not result.service.name or result.service.name == "ssl":
-                        service_name = self._identify_ssl_service(port, ssl_info)
-                        result.service.name = service_name
-            
-            # Se não identificou o serviço, tenta pelo número da porta
-            if not result.service and port in SERVICE_MAP:
-                result.service = ServiceInfo(name=SERVICE_MAP[port])
-            
-            # Se ainda não identificou o serviço e não recebeu banner, marca como filtrada
-            if not result.service and not result.banner:
-                result.status = "filtered"
-                return result
+                        # Se não for texto, exibe como hex
+                        result.banner = f"[binary data] {banner_bytes.hex()[:100]}..."
                 
-            # Verifica vulnerabilidades conhecidas para portas abertas
-            if result.status == "open" and self.check_vulns and result.service:
-                result.service.vulns = self._check_known_vulns(port, result.service.name)
-            
-            return result
+                # Se a porta está aberta, verifica SSL/TLS em portas comuns (apenas se ainda não verificou)
+                if result.status == "open" and port in ssl_ports and (result.service is None or not result.service.ssl):
+                    try:
+                        ssl_info = await self._check_ssl(port)
+                        if ssl_info:
+                            if result.service is None:
+                                result.service = ServiceInfo(name=SERVICE_MAP.get(port, "unknown"))
+                            result.service.ssl = True
+                            result.service.ssl_info = ssl_info
+                            # Atualiza o nome do serviço com base nas informações SSL
+                            ssl_service = self._identify_ssl_service(port, ssl_info)
+                            if ssl_service:
+                                result.service.name = ssl_service
+                    except Exception as e:
+                        logger.debug(f"Erro ao verificar SSL na porta {port}: {str(e)}")
+                        # Se falhar ao verificar SSL, mantém a porta como aberta mas sem informações SSL
             
+            except (asyncio.TimeoutError, ConnectionResetError, OSError) as e:
+                logger.debug(f"Erro ao ler banner da porta {port}: {str(e)}")
+                
+            finally:
+                # Fecha a conexão
+                writer.close()
+                try:
+                    await writer.wait_closed()
+                except Exception as e:
+                    logger.debug(f"Erro ao fechar conexão: {str(e)}")
+                    
         except (asyncio.TimeoutError, ConnectionRefusedError, OSError):
             # Porta fechada ou inacessível
-            return None
+            result.status = "closed"
             
         except Exception as e:
-            logger.error(f"Erro ao verificar porta {port}: {str(e)}")
-            return None
+            logger.error(f"Erro inesperado ao verificar porta {port}: {str(e)}")
+            result.status = "error"
         
-        finally:
-            # Fecha a conexão se ainda estiver aberta
-            if 'writer' in locals():
-                writer.close()
-                try:
-                    await writer.wait_closed()
-                except:
-                    pass
+        # Se a porta está aberta, tenta identificar o serviço se ainda não identificado
+        if result.status == "open":
+            try:
+                # Se tem serviço SSL mas não foi identificado corretamente
+                if result.service and (not result.service.name or result.service.name == "ssl"):
+                    if 'ssl_info' in locals() and ssl_info:
+                        service_name = self._identify_ssl_service(port, ssl_info)
+                        if service_name:
+                            result.service.name = service_name
+                
+                # Se ainda não identificou o serviço, tenta pelo número da porta
+                if not result.service and port in SERVICE_MAP:
+                    result.service = ServiceInfo(name=SERVICE_MAP[port])
+                
+                # Verifica vulnerabilidades conhecidas para portas abertas
+                if self.check_vulns and result.service:
+                    result.service.vulns = self._check_known_vulns(port, result.service.name)
+            except Exception as e:
+                logger.error(f"Erro ao processar informações da porta {port}: {str(e)}")
+                # Em caso de erro, mantém a porta como aberta mas sem informações adicionais
+
+        
+        return result
     
     async def _identify_service(self, port: int, banner: str) -> Optional[ServiceInfo]:
         """Tenta identificar o serviço rodando na porta com base no banner."""
@@ -834,6 +911,27 @@ class PortScanner:
                     await writer.wait_closed()
                 except:
                     pass
+
+    async def _get_ssl_banner(self, port: int) -> Optional[str]:
+        try:
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+            reader, writer = await asyncio.wait_for(
+                asyncio.open_connection(self.target, port, ssl=ssl_context, server_hostname=self.target),
+                timeout=self.timeout
+            )
+            req = f"HEAD / HTTP/1.0\r\nHost: {self.target}\r\nUser-Agent: moriarty/1.0\r\nConnection: close\r\n\r\n"
+            writer.write(req.encode("ascii"))
+            await writer.drain()
+            data = await asyncio.wait_for(reader.read(2048), timeout=self.timeout)
+            writer.close()
+            with contextlib.suppress(Exception):
+                await writer.wait_closed()
+            return data.decode("utf-8", errors="replace").strip()
+        except Exception:
+            return None
+
     
     def _check_known_vulns(self, port: int, service_name: str) -> List[str]:
         """Verifica vulnerabilidades conhecidas para o serviço na porta."""
@@ -844,29 +942,35 @@ class PortScanner:
             if service.lower() in service_name.lower():
                 vulns.extend(cves)
         
-        # Verifica vulnerabilidades específicas da porta
+        # Verifica vulnerabilidades específicas da porta (apenas como informação, não como confirmação)
         if port == 22:  # SSH
-            vulns.extend(["CVE-2016-0777", "CVE-2016-0778", "CVE-2018-15473"])
+            vulns.extend(["CVE-2016-0777 (verificar versão)", "CVE-2016-0778 (verificar versão)", "CVE-2018-15473 (verificar versão)"])
         elif port == 445:  # SMB
-            vulns.extend(["EternalBlue", "SMBGhost", "EternalRomance", "SambaCry"])
+            vulns.extend(["Possível vulnerabilidade SMB - requer verificação de versão"])
         elif port == 3389:  # RDP
-            vulns.extend(["BlueKeep", "CVE-2019-0708", "CVE-2019-1181", "CVE-2019-1182"])
+            vulns.extend(["Possível vulnerabilidade RDP - requer verificação de versão"])
         elif port == 27017:  # MongoDB
-            vulns.extend(["Unauthenticated Access", "CVE-2016-6494"])
+            vulns.extend(["Acesso não autenticado (se sem senha)"])
         elif port == 9200:  # Elasticsearch
-            vulns.extend(["CVE-2015-1427", "CVE-2015-3337", "CVE-2015-5531"])
+            vulns.extend(["Possível exposição indevida - verificar configurações"])
         elif port == 11211:  # Memcached
-            vulns.extend(["DRDoS Amplification", "CVE-2016-8704", "CVE-2016-8705"])
+            vulns.extend(["Possível amplificação DRDoS - verificar configuração"])
         elif port == 2375:  # Docker
-            vulns.extend(["CVE-2019-5736", "CVE-2019-13139", "CVE-2019-14271"])
+            vulns.extend(["API Docker exposta - verificar autenticação"])
         elif port == 10250:  # Kubelet
-            vulns.extend(["CVE-2018-1002105", "CVE-2019-11253", "CVE-2019-11255"])
+            vulns.extend(["Kubelet exposto - verificar autenticação"])
         
         return list(set(vulns))  # Remove duplicatas
 
 
-def format_scan_results(results: List[PortScanResult], output_format: str = "text") -> str:
-    """Formata os resultados da varredura no formato solicitado."""
+def format_scan_results(results: List[PortScanResult], output_format: str = "text", total_ports: Optional[int] = None) -> str:
+    """Formata os resultados da varredura no formato solicitado.
+    
+    Args:
+        results: Lista de resultados da varredura
+        output_format: Formato de saída ('text' ou 'json')
+        total_ports: Número total de portas verificadas (opcional)
+    """
     if output_format.lower() == "json":
         return json.dumps([r.to_dict() for r in results], indent=2)
     
@@ -875,7 +979,7 @@ def format_scan_results(results: List[PortScanResult], output_format: str = "tex
     output.append("")
     output.append(f"[bold]Resultado da varredura de portas[/bold]")
     output.append(f"Alvo: {results[0].target if results else 'N/A'}")
-    output.append(f"Portas verificadas: {len(results)}")
+    output.append(f"Portas verificadas: {total_ports if total_ports is not None else len([r for r in results if r.status != 'error'])}")
     output.append("-" * 80)
     
     # Cabeçalho da tabela
@@ -889,9 +993,13 @@ def format_scan_results(results: List[PortScanResult], output_format: str = "tex
         if result.status == "open":
             port = f"[green]{result.port}[/green]"
             status = "[green]ABERTA[/green]"
+        elif result.status == "closed":
+            port = f"[red]{result.port}[/red]"
+            status = "[red]FECHADA[/red]"
         else:
             port = f"[yellow]{result.port}[/yellow]"
-            status = "[yellow]FILTRADA[/yellow]"
+            status = "[yellow]ERRO[/yellow]"
+
             
         service = result.service.name if result.service else "desconhecido"
         version = f" {result.service.version}" if result.service and result.service.version else ""