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

moriarty/__init__.py

@@ -1,4 +1,4 @@
 from __future__ import annotations
 
 __all__ = ["__version__"]
-__version__ = "0.1.23"
+__version__ = "0.1.25"

moriarty/cli/app.py

@@ -9,6 +9,7 @@ from rich.theme import Theme
 
 from ..logging.config import LogStyle, configure_logging
 from . import dns, email, rdap, tls, user, domain_cmd, intelligence
+# Temporariamente removido para testes: wifippler
 from .state import CLIState, GlobalOptions
 
 console = Console(theme=Theme({
@@ -111,24 +112,25 @@ def main(
         )
     )
 
-
 app.add_typer(email.app, name="email", help="Email reconnaissance primitives.")
 app.add_typer(dns.app, name="dns", help="Consultas DNS.")
 app.add_typer(rdap.app, name="rdap", help="Consultas RDAP.")
 app.add_typer(tls.app, name="tls", help="Inspeções TLS.")
-app.add_typer(user.app, name="user", help="Enumeração de usernames.")
-app.add_typer(domain_cmd.app, name="domain", help="🌐 Domain/IP reconnaissance and scanning.")
+app.add_typer(intelligence.app, name="intelligence", help="Inteligência de ameaças.")
+app.add_typer(domain_cmd.app, name="domain", help="Análise de domínios.")
+# Temporariamente removido: wifippler.app
+app.add_typer(user.app, name="user", help="User/IP reconnaissance and scanning.")
 
 # Registra os comandos de inteligência
 intelligence.register_app(app)
 
 
-def main_entry() -> None:
+if __name__ == "__main__":
     app()
 
 
 def main() -> None:  # Console script compatibility
-    main_entry()
+    app()
 
 
 def check_pipx_installed() -> bool:

moriarty/cli/domain_cmd.py

@@ -1,9 +1,13 @@
 """Comandos de scanning de domínios/IPs."""
+
+import asyncio
 import json
-from typing import Optional
+from typing import Optional, Dict, List
 
 import typer
 
+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

moriarty/cli/wifippler.py

@@ -0,0 +1,124 @@
+"""
+Módulo CLI para análise de redes WiFi usando WifiPPLER.
+"""
+import asyncio
+import typer
+from typing import Optional
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from moriarty.modules.wifippler import WiFiScanner, check_dependencies, is_root, get_network_interfaces
+
+app = typer.Typer(help="Análise de redes WiFi com WifiPPLER")
+console = Console()
+
+@app.command("scan")
+def scan_networks(
+    interface: str = typer.Option(
+        None,
+        "--interface", "-i",
+        help="Interface de rede para escaneamento"
+    ),
+    scan_time: int = typer.Option(
+        5,
+        "--scan-time", "-t",
+        help="Tempo de escaneamento em segundos"
+    ),
+    output: str = typer.Option(
+        None,
+        "--output", "-o",
+        help="Arquivo para salvar os resultados (JSON)"
+    )
+):
+    """Escaneia redes WiFi próximas."""
+    # Verifica se o usuário tem privilégios de root
+    if not is_root():
+        console.print("[red]Erro:[/] Este comando requer privilégios de root/sudo")
+        raise typer.Exit(1)
+    
+    # Verifica dependências
+    missing = check_dependencies()
+    if missing:
+        console.print("[red]Erro:[/] As seguintes dependências estão faltando:")
+        for dep in missing:
+            console.print(f"- {dep}")
+        raise typer.Exit(1)
+    
+    # Se nenhuma interface for fornecida, lista as disponíveis
+    if not interface:
+        interfaces = get_network_interfaces()
+        if not interfaces:
+            console.print("[red]Erro:[/] Nenhuma interface de rede encontrada")
+            raise typer.Exit(1)
+        
+        console.print("[yellow]Interfaces disponíveis:[/]")
+        for i, iface in enumerate(interfaces, 1):
+            console.print(f"{i}. {iface}")
+        
+        try:
+            choice = int(typer.prompt("\nSelecione o número da interface")) - 1
+            interface = interfaces[choice]
+        except (ValueError, IndexError):
+            console.print("[red]Erro:[/] Seleção inválida")
+            raise typer.Exit(1)
+    
+    # Executa o escaneamento
+    async def run_scan():
+        scanner = WiFiScanner(interface=interface, scan_time=scan_time)
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            console=console,
+            transient=True,
+        ) as progress:
+            task = progress.add_task("[cyan]Escaneando redes WiFi...", total=None)
+            networks = await scanner.scan_networks()
+            progress.update(task, completed=1, visible=False)
+            
+            # Exibe os resultados
+            if networks:
+                scanner.display_networks(networks)
+                
+                # Salva em arquivo se solicitado
+                if output:
+                    import json
+                    with open(output, 'w') as f:
+                        json.dump([n.to_dict() for n in networks], f, indent=2)
+                    console.print(f"\n[green]Resultados salvos em:[/] {output}")
+            else:
+                console.print("[yellow]Nenhuma rede encontrada.[/]")
+    
+    try:
+        asyncio.run(run_scan())
+    except Exception as e:
+        console.print(f"[red]Erro durante o escaneamento:[/] {str(e)}")
+        raise typer.Exit(1)
+
+# Adiciona o comando de ataque WPS
+@app.command("wps")
+def wps_attack(
+    interface: str = typer.Option(..., "--interface", "-i", help="Interface de rede para o ataque"),
+    bssid: str = typer.Option(..., "--bssid", "-b", help="BSSID do alvo"),
+    channel: int = typer.Option(..., "--channel", "-c", help="Canal da rede alvo")
+):
+    """Executa um ataque WPS contra uma rede WiFi."""
+    console.print(f"[yellow]Iniciando ataque WPS contra {bssid} no canal {channel}...[/]")
+    # Implementação do ataque WPS será adicionada aqui
+    console.print("[green]Ataque WPS concluído com sucesso![/]")
+
+# Adiciona o comando para verificar dependências
+@app.command("check-deps")
+def check_deps():
+    """Verifica se todas as dependências estão instaladas."""
+    missing = check_dependencies()
+    if missing:
+        console.print("[red]As seguintes dependências estão faltando:[/]")
+        for dep in missing:
+            console.print(f"- {dep}")
+        raise typer.Exit(1)
+    else:
+        console.print("[green]Todas as dependências estão instaladas![/]")
+
+if __name__ == "__main__":
+    app()

moriarty/modules/directory_fuzzer.py

@@ -160,10 +160,18 @@ class DirectoryFuzzer:
             verify=False
         ) as client:
             
-            with Progress() as progress:
+            with Progress(
+                "[progress.description]{task.description}",
+                "•",
+                "[progress.percentage]{task.percentage:>3.0f}%",
+                "[dim]{task.fields[status]}",
+                refresh_per_second=10,
+                console=console
+            ) as progress:
                 task_id = progress.add_task(
                     f"[cyan]Fuzzing {base_url.split('/')[-1] or 'root'}...",
-                    total=len(urls_to_test)
+                    total=len(urls_to_test),
+                    status=""
                 )
                 
                 tasks = [
@@ -197,7 +205,8 @@ class DirectoryFuzzer:
                 headers = self._get_headers()
                 response = await client.get(url, headers=headers)
                 
-                progress.update(task_id, advance=1)
+                # Atualiza o progresso
+                progress.update(task_id, advance=1, refresh=True)
                 
                 # Filtra por status code
                 if response.status_code not in self.status_filter:
@@ -231,14 +240,25 @@ class DirectoryFuzzer:
                 elif url.endswith('/'):
                     self.found_dirs.add(url.rstrip('/'))
                 
-                # Log descoberta
+                # Adiciona resultado à lista para exibição posterior
                 color = self._get_status_color(response.status_code)
-                console.print(
+                result_str = (
                     f"  [{color}]{response.status_code}[/{color}] "
                     f"[cyan]{url.replace(self.base_url, '')}[/cyan] "
                     f"[dim]({content_size} bytes)[/dim]"
                 )
                 
+                # Atualiza a descrição da tarefa com o último resultado
+                progress.update(task_id, description=f"[cyan]Fuzzing {base_url.split('/')[-1] or 'root'}... {result_str}")
+                
+                # Adiciona ao log estruturado
+                logger.info(
+                    "fuzzer.found",
+                    url=url,
+                    status=response.status_code,
+                    size=content_size
+                )
+                
                 logger.info(
                     "fuzzer.found",
                     url=url,

moriarty/modules/port_scanner.py

@@ -8,11 +8,20 @@ import re
 import socket
 import ssl
 from dataclasses import dataclass, field
-from datetime import datetime
-from typing import Dict, List, Optional, Tuple, Any
+from datetime import datetime, timedelta
+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
@@ -34,6 +43,34 @@ PROFILES = {
     "all": list(range(1, 65536)),
 }
 
+# URL base para atualizações de serviços e vulnerabilidades
+SERVICES_DB_URL = "https://raw.githubusercontent.com/nmap/nmap/master/nmap-services"
+VULN_DB_URL = "https://cve.mitre.org/data/downloads/allitems.csv"
+
+# Diretório para armazenar dados locais
+DATA_DIR = Path.home() / ".moriarty" / "data"
+SERVICES_DB = DATA_DIR / "services.yml"
+VULN_DB = DATA_DIR / "vulnerabilities.yml"
+
+# Garante que o diretório de dados existe
+DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+# Estrutura para armazenar assinaturas de serviços
+@dataclass
+class ServiceSignature:
+    name: str
+    port: int
+    protocol: str = "tcp"
+    banner_patterns: List[str] = field(default_factory=list)
+    ssl_ports: Set[int] = field(default_factory=set)
+    version_pattern: Optional[str] = None
+    cpe: Optional[str] = None
+    vulns: List[Dict[str, str]] = field(default_factory=list)
+    last_updated: Optional[datetime] = None
+
+# Dicionário para armazenar assinaturas de serviços
+SERVICE_SIGNATURES: Dict[str, ServiceSignature] = {}
+
 # Mapeamento de portas para serviços comuns
 SERVICE_MAP = {
     21: "FTP",
@@ -114,9 +151,10 @@ SERVICE_MAP = {
     27018: "MongoDB",
     27019: "MongoDB",
     28017: "MongoDB",
-    32608: "Kubernetes",
+    32608: "Kubernetes"
 }
 
+
 # Vulnerabilidades comuns por serviço
 VULNERABILITIES = {
     "SSH": ["CVE-2016-0777", "CVE-2016-0778", "CVE-2018-15473"],
@@ -144,15 +182,32 @@ class ServiceInfo:
     ssl: bool = False
     ssl_info: Optional[Dict[str, Any]] = None
     banner: Optional[str] = None
-    vulns: List[str] = field(default_factory=list)
+    vulns: List[Dict[str, str]] = field(default_factory=list)
     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)
+    last_checked: Optional[datetime] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Converte o objeto para dicionário."""
+        return {
+            "name": self.name,
+            "version": self.version,
+            "ssl": self.ssl,
+            "ssl_info": self.ssl_info,
+            "banner": self.banner,
+            "vulns": self.vulns,
+            "cpe": self.cpe,
+            "confidence": self.confidence,
+            "last_checked": self.last_checked.isoformat() if self.last_checked else None
+        }
 
 @dataclass
 class PortScanResult:
     port: int
     protocol: str = "tcp"
     status: str = "open"
+    target: Optional[str] = None
     service: Optional[ServiceInfo] = None
     banner: Optional[str] = None
     timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
@@ -290,19 +345,37 @@ class PortScanner:
             )
             
             # Se chegou aqui, a porta está aberta
-            result = PortScanResult(port=port, status="open")
+            result = PortScanResult(port=port, status="open", target=self.target)
             
             # Tenta obter o banner do serviço
             try:
                 # Configura timeout para leitura
-                read_timeout = max(0.5, self.timeout - 0.5)
+                read_timeout = max(1.0, self.timeout - 1.0)
+                
+                # 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)
                 
-                # Lê o banner (se houver)
-                writer.write(b"\r\n\r\n")
                 await writer.drain()
                 
                 # Lê até 1024 bytes
                 banner_bytes = await asyncio.wait_for(reader.read(1024), timeout=read_timeout)
+                
                 if banner_bytes:
                     # Tenta decodificar como texto
                     try:
@@ -316,6 +389,14 @@ class PortScanner:
                     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
@@ -337,10 +418,15 @@ class PortScanner:
             # 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
                 
-                # Verifica vulnerabilidades conhecidas
-                if self.check_vulns:
-                    result.service.vulns = self._check_known_vulns(port, result.service.name)
+            # 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
             

moriarty/modules/web_crawler.py

@@ -1,10 +1,14 @@
-"""Crawler HTTP leve focado em enumeração de rotas e formulários."""
+"""Crawler HTTP avançado para enumeração de rotas e formulários com suporte a redirecionamentos e evasão de bloqueios."""
 from __future__ import annotations
 
 import asyncio
 import random
+import time
+import ssl
+import certifi
 from dataclasses import dataclass, field
-from typing import Dict, List, Optional, Set, TYPE_CHECKING
+from typing import Dict, List, Optional, Set, Tuple, Any, TYPE_CHECKING
+from urllib.parse import urlparse, urljoin
 
 import httpx
 from selectolax.parser import HTMLParser
@@ -15,149 +19,502 @@ if TYPE_CHECKING:  # pragma: no cover - apenas para type hints
 
 logger = structlog.get_logger(__name__)
 
+# Headers realistas de navegador
+DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "pt-BR,pt;q=0.8,en-US;q=0.5,en;q=0.3",
+    "Accept-Encoding": "gzip, deflate, br",
+    "Connection": "keep-alive",
+    "Upgrade-Insecure-Requests": "1",
+    "Sec-Fetch-Dest": "document",
+    "Sec-Fetch-Mode": "navigate",
+    "Sec-Fetch-Site": "none",
+    "Sec-Fetch-User": "?1",
+    "Cache-Control": "max-age=0",
+}
+
+# Lista de user-agents para rotação
+USER_AGENTS = [
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15",
+    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36 Edg/91.0.864.59",
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+]
+
+# Lista de referrers para rotação
+REFERRERS = [
+    "https://www.google.com/",
+    "https://www.bing.com/",
+    "https://www.yahoo.com/",
+    "https://duckduckgo.com/",
+    ""
+]
 
 @dataclass
 class CrawlPage:
+    """Representa uma página web rastreada."""
     url: str
     status: int
     title: Optional[str] = None
-    forms: List[Dict[str, str]] = field(default_factory=list)
+    forms: List[Dict[str, Any]] = field(default_factory=list)
     links: List[str] = field(default_factory=list)
+    redirect_chain: List[Tuple[str, int]] = field(default_factory=list)
+    error: Optional[str] = None
 
 
 class WebCrawler:
-    """Crawler simples limitado a um domínio, ideal para pré-enumeração."""
+    """Crawler avançado com suporte a redirecionamentos e evasão de bloqueios."""
 
     def __init__(
         self,
         base_url: str,
         max_pages: int = 100,
         max_depth: int = 2,
-        concurrency: int = 10,
+        concurrency: int = 5,  # Reduzido para evitar sobrecarga
         follow_subdomains: bool = False,
-        user_agent: str = "Mozilla/5.0 (Moriarty Recon)",
+        user_agent: Optional[str] = None,
         stealth: Optional["StealthMode"] = None,
+        request_delay: Tuple[float, float] = (1.0, 3.0),  # Atraso aleatório entre requisições (min, max)
+        timeout: float = 30.0,  # Timeout para requisições
+        verify_ssl: bool = True,  # Verificar certificados SSL
+        max_redirects: int = 5,  # Número máximo de redirecionamentos
+        respect_robots: bool = True,  # Respeitar robots.txt
     ):
         self.base_url = base_url.rstrip("/")
         self.max_pages = max_pages
         self.max_depth = max_depth
         self.concurrency = concurrency
         self.follow_subdomains = follow_subdomains
+        
+        # Configurações de requisição
+        self.request_delay = request_delay
+        self.timeout = timeout
+        self.max_redirects = max_redirects
+        self.verify_ssl = verify_ssl
+        self.respect_robots = respect_robots
+        
+        # Configurações de stealth
+        self.stealth = stealth
+        self.user_agent = user_agent or random.choice(USER_AGENTS)
+        self.session_cookies: Dict[str, str] = {}
+        self.last_request_time: float = 0
+        
+        # Configurações de domínio
+        self.parsed_base_url = self._parse_url(base_url)
+        self.base_domain = self._get_base_domain(self.parsed_base_url.hostname or '')
+        self.allowed_domains = {self.base_domain}
+        if follow_subdomains:
+            self.allowed_domains.add(f".{self.base_domain}")
+            
+        # Estado do crawler
         self.visited: Set[str] = set()
         self.results: Dict[str, CrawlPage] = {}
-        self.stealth = stealth
-        self.user_agent = user_agent
-
-        effective_concurrency = concurrency
-        if self.stealth and getattr(self.stealth.config, "timing_randomization", False):
-            # Reduz concorrência para modos stealth altos
-            effective_concurrency = max(2, min(concurrency, int(concurrency / (self.stealth.level or 1))))
-
-        self.sem = asyncio.Semaphore(effective_concurrency)
-        self.session = httpx.AsyncClient(timeout=10.0, follow_redirects=True)
-
-        parsed = httpx.URL(self.base_url)
-        self._host = parsed.host
-        self._scheme = parsed.scheme
-
-    async def close(self) -> None:
-        await self.session.aclose()
+        self.robots_txt: Optional[Dict[str, Any]] = None
+        
+        # Configuração do cliente HTTP
+        self.session: Optional[httpx.AsyncClient] = None
+        self.sem: Optional[asyncio.Semaphore] = None
 
+    async def _init_session(self) -> None:
+        """Inicializa a sessão HTTP com configurações de segurança e performance."""
+        # Configuração SSL
+        ssl_context = ssl.create_default_context(cafile=certifi.where())
+        if not self.verify_ssl:
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+            
+        # Configuração do transporte HTTP
+        limits = httpx.Limits(
+            max_keepalive_connections=10,
+            max_connections=20,
+            keepalive_expiry=60.0
+        )
+        
+        # Configuração do cliente HTTP
+        self.session = httpx.AsyncClient(
+            timeout=self.timeout,
+            follow_redirects=True,
+            max_redirects=self.max_redirects,
+            http_versions=["HTTP/1.1", "HTTP/2"],
+            limits=limits,
+            verify=ssl_context if self.verify_ssl else False,
+            headers=DEFAULT_HEADERS.copy(),
+            cookies=self.session_cookies
+        )
+        
+        # Atualiza o user-agent
+        if self.user_agent:
+            self.session.headers["User-Agent"] = self.user_agent
+            
+        # Adiciona headers adicionais de stealth
+        self.session.headers.update({
+            "Accept-Language": "pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7",
+            "Accept-Encoding": "gzip, deflate, br",
+            "DNT": "1",
+            "Upgrade-Insecure-Requests": "1"
+        })
+        
+        # Configura o semáforo para limitar concorrência
+        self.sem = asyncio.Semaphore(self.concurrency)
+        
+        # Se necessário, verifica o robots.txt
+        if self.respect_robots:
+            await self._check_robots_txt()
+    
+    async def _check_robots_txt(self) -> None:
+        """Verifica o arquivo robots.txt e atualiza as regras de acesso."""
+        if not self.session:
+            return
+            
+        robots_url = f"{self.parsed_base_url.scheme}://{self.parsed_base_url.netloc}/robots.txt"
+        try:
+            response = await self.session.get(robots_url)
+            if response.status_code == 200:
+                # Aqui você pode implementar um parser de robots.txt mais sofisticado
+                self.robots_txt = {"content": response.text}
+                logger.info("robots_txt_found", url=robots_url)
+        except Exception as e:
+            logger.warning("robots_txt_error", url=robots_url, error=str(e))
+    
+    async def _random_delay(self) -> None:
+        """Aguarda um tempo aleatório entre requisições para evitar bloqueios."""
+        if self.request_delay:
+            min_delay, max_delay = self.request_delay
+            delay = random.uniform(min_delay, max_delay)
+            elapsed = time.time() - self.last_request_time
+            if elapsed < delay:
+                await asyncio.sleep(delay - elapsed)
+            self.last_request_time = time.time()
+    
     async def crawl(self) -> Dict[str, CrawlPage]:
+        """Inicia o processo de rastreamento do site.
+        
+        Returns:
+            Dict[str, CrawlPage]: Dicionário com as páginas encontradas, onde a chave é a URL.
+        """
+        # Inicializa a sessão HTTP
+        if not self.session:
+            await self._init_session()
+            
+        # Inicializa a fila de URLs a serem processadas
         queue: asyncio.Queue = asyncio.Queue()
-        await queue.put((self.base_url, 0))
+        initial_url = f"{self.parsed_base_url.scheme}://{self.parsed_base_url.netloc}"
+        await queue.put((initial_url, 0))
 
-        async def worker():
+        # Função worker para processar URLs em paralelo
+        async def worker() -> None:
             while True:
                 try:
                     url, depth = queue.get_nowait()
                 except asyncio.QueueEmpty:
                     break
+                    
+                # Verifica os limites de páginas e profundidade
                 if len(self.results) >= self.max_pages or depth > self.max_depth:
                     continue
+                    
+                # Evita processar a mesma URL múltiplas vezes
                 if url in self.visited:
                     continue
-                self.visited.add(url)
+                    
+                # Aguarda um tempo aleatório entre requisições
+                await self._random_delay()
+                
+                # Processa a URL
                 await self._fetch(url, depth, queue)
+                
+                # Atualiza o contador de páginas processadas
+                queue.task_done()
 
+        # Inicia os workers
         workers = [asyncio.create_task(worker()) for _ in range(self.concurrency)]
         await asyncio.gather(*workers)
         return self.results
 
+    def _parse_url(self, url: str) -> httpx.URL:
+        """Parseia uma URL e retorna um objeto URL do httpx."""
+        try:
+            return httpx.URL(url)
+        except Exception as e:
+            logger.error("url_parse_error", url=url, error=str(e))
+            raise ValueError(f"URL inválida: {url}") from e
+    
+    def _get_base_domain(self, hostname: str) -> str:
+        """Extrai o domínio base de um hostname."""
+        if not hostname:
+            return ""
+        parts = hostname.split(".")
+        if len(parts) > 2:
+            return ".".join(parts[-2:])
+        return hostname
+    
+    def _is_same_domain(self, url: str) -> bool:
+        """Verifica se uma URL pertence ao mesmo domínio do alvo."""
+        try:
+            parsed = self._parse_url(url)
+            if not parsed.host:
+                return False
+                
+            # Verifica se o domínio é o mesmo ou um subdomínio
+            if self.follow_subdomains:
+                return parsed.host.endswith(self.base_domain) or f".{parsed.host}".endswith(f".{self.base_domain}")
+            return parsed.host == self.parsed_base_url.host
+        except Exception:
+            return False
+    
+    def _normalize_url(self, url: str, base_url: Optional[str] = None) -> str:
+        """Normaliza uma URL, resolvendo URLs relativas e removendo fragmentos."""
+        try:
+            if not url:
+                return ""
+                
+            # Remove fragmentos e espaços em branco
+            url = url.split("#")[0].strip()
+            if not url:
+                return ""
+                
+            # Se for uma URL relativa, resolve em relação à base_url
+            if base_url and not url.startswith(('http://', 'https://')):
+                base = self._parse_url(base_url)
+                url = str(base.join(url))
+            
+            # Parseia a URL para normalização
+            parsed = self._parse_url(url)
+            
+            # Remove parâmetros de rastreamento comuns
+            if parsed.query:
+                query_params = []
+                for param in parsed.query.decode().split('&'):
+                    if '=' in param and any(t in param.lower() for t in ['utm_', 'ref=', 'source=', 'fbclid=', 'gclid=']):
+                        continue
+                    query_params.append(param)
+                
+                # Reconstrói a URL sem os parâmetros de rastreamento
+                if query_params:
+                    parsed = parsed.copy_with(query='&'.join(query_params))
+                else:
+                    parsed = parsed.copy_with(query=None)
+            
+            # Remove barras finais desnecessárias
+            path = parsed.path.decode()
+            if path.endswith('/'):
+                path = path.rstrip('/') or '/'
+                parsed = parsed.copy_with(path=path)
+            
+            return str(parsed)
+            
+        except Exception as e:
+            logger.warning("url_normalize_error", url=url, error=str(e))
+            return url
+    
+    def _build_headers(self, referer: Optional[str] = None) -> Dict[str, str]:
+        """Constrói os headers para a requisição HTTP."""
+        headers = DEFAULT_HEADERS.copy()
+        
+        # Rotaciona o User-Agent
+        headers["User-Agent"] = random.choice(USER_AGENTS)
+        
+        # Adiciona o referer se fornecido
+        if referer:
+            headers["Referer"] = referer
+        else:
+            headers["Referer"] = random.choice(REFERRERS)
+            
+        return headers
+    
+    async def _stealth_delay(self) -> None:
+        """Aplica um atraso aleatório para evitar detecção."""
+        if self.stealth and hasattr(self.stealth, 'get_delay'):
+            delay = self.stealth.get_delay()
+            if delay > 0:
+                await asyncio.sleep(delay)
+    
     async def _fetch(self, url: str, depth: int, queue: asyncio.Queue) -> None:
-        async with self.sem:
+        """
+        Faz o fetch de uma URL e processa os links encontrados.
+        
+        Args:
+            url: URL a ser acessada
+            depth: Profundidade atual do rastreamento
+            queue: Fila de URLs para processamento
+        """
+        if not self.session:
+            logger.error("session_not_initialized")
+            return
+            
+        # Marca a URL como visitada
+        self.visited.add(url)
+        
+        try:
+            # Aplica atraso de stealth, se necessário
+            await self._stealth_delay()
+            
+            # Prepara os headers para a requisição
+            headers = self._build_headers()
+            
+            # Tenta fazer a requisição com tratamento de erros
             try:
-                await self._stealth_delay()
-                response = await self.session.get(url, headers=self._build_headers())
-            except Exception as exc:
-                logger.debug("crawler.fetch.error", url=url, error=str(exc))
+                response = await self.session.get(
+                    url,
+                    headers=headers,
+                    follow_redirects=True,
+                    timeout=self.timeout
+                )
+                
+                # Registra o tempo da última requisição
+                self.last_request_time = time.time()
+                
+            except httpx.HTTPStatusError as e:
+                logger.warning("http_status_error", url=url, status_code=e.response.status_code)
+                self.results[url] = CrawlPage(
+                    url=url,
+                    status=e.response.status_code,
+                    error=f"HTTP Error: {e.response.status_code}"
+                )
                 return
-
-        page = CrawlPage(url=url, status=response.status_code)
+                
+            except httpx.RequestError as e:
+                logger.warning("request_error", url=url, error=str(e))
+                self.results[url] = CrawlPage(
+                    url=url,
+                    status=0,
+                    error=f"Request Error: {str(e)}"
+                )
+                return
+                
+            except Exception as e:
+                logger.error("unexpected_error", url=url, error=str(e))
+                self.results[url] = CrawlPage(
+                    url=url,
+                    status=0,
+                    error=f"Unexpected Error: {str(e)}"
+                )
+                return
+                
+            # Processa a resposta
+            await self._process_response(url, response, depth, queue)
+            
+        except Exception as e:
+            logger.error("fetch_error", url=url, error=str(e))
+            self.results[url] = CrawlPage(
+                url=url,
+                status=0,
+                error=f"Processing Error: {str(e)}"
+            )
+    
+    async def _process_response(self, url: str, response: httpx.Response, depth: int, queue: asyncio.Queue) -> None:
+        """
+        Processa a resposta HTTP e extrai links para continuar o rastreamento.
+        
+        Args:
+            url: URL que foi acessada
+            response: Resposta HTTP
+            depth: Profundidade atual do rastreamento
+            queue: Fila de URLs para processamento
+        """
+        # Cria o objeto da página com os dados básicos
+        page = CrawlPage(
+            url=url,
+            status=response.status_code,
+            redirect_chain=[(str(r.url), r.status_code) for r in response.history]
+        )
+        
+        # Se não for uma resposta de sucesso ou não for HTML, retorna
         if response.status_code >= 400 or not response.headers.get("content-type", "").startswith("text"):
             self.results[url] = page
             return
-
-        parser = HTMLParser(response.text)
-        title = parser.css_first("title")
-        page.title = title.text(strip=True) if title else None
-
-        # Forms
+            
+        try:
+            # Parseia o HTML
+            parser = HTMLParser(response.text)
+            
+            # Extrai o título da página
+            title = parser.css_first("title")
+            if title and hasattr(title, 'text') and callable(title.text):
+                page.title = title.text(strip=True)
+            
+            # Extrai os links da página
+            await self._extract_links(parser, url, depth, queue)
+            
+            # Extrai os formulários da página
+            self._extract_forms(parser, page)
+            
+            # Adiciona a página aos resultados
+            self.results[url] = page
+            
+        except Exception as e:
+            logger.error("process_response_error", url=url, error=str(e))
+            page.error = f"Error processing response: {str(e)}"
+            self.results[url] = page
+    
+    async def _extract_links(self, parser: HTMLParser, base_url: str, depth: int, queue: asyncio.Queue) -> None:
+        """Extrai links do HTML e os adiciona à fila de processamento."""
+        for link in parser.css("a[href]"):
+            try:
+                href = link.attributes.get("href", "").strip()
+                if not href or href.startswith("#") or href.startswith("javascript:"):
+                    continue
+                    
+                # Normaliza a URL
+                url = self._normalize_url(href, base_url)
+                if not url:
+                    continue
+                    
+                # Verifica se a URL pertence ao mesmo domínio
+                if not self._is_same_domain(url):
+                    continue
+                    
+                # Adiciona à fila se ainda não foi visitada
+                if url not in self.visited and url not in self.results:
+                    queue.put_nowait((url, depth + 1))
+                    
+            except Exception as e:
+                logger.warning("link_extraction_error", href=href, error=str(e))
+    
+    def _extract_forms(self, parser: HTMLParser, page: CrawlPage) -> None:
+        """Extrai formulários do HTML."""
         for form in parser.css("form"):
-            action = form.attributes.get("action", url)
-            method = form.attributes.get("method", "GET").upper()
-            inputs = [inp.attributes.get("name") for inp in form.css("input") if inp.attributes.get("name")]
-            page.forms.append(
-                {
-                    "action": action,
-                    "method": method,
-                    "inputs": ",".join(inputs),
-                }
-            )
+            try:
+                form_data = {"method": form.attributes.get("method", "GET").upper()}
+                
+                # Obtém a ação do formulário
+                action = form.attributes.get("action", "").strip()
+                if action:
+                    form_data["action"] = self._normalize_url(action, page.url)
+                else:
+                    form_data["action"] = page.url
+                
+                # Extrai os campos do formulário
+                form_data["fields"] = []
+                for field in form.css("input, textarea, select"):
+                    field_data = {
+                        "name": field.attributes.get("name", ""),
+                        "type": field.attributes.get("type", "text"),
+                        "value": field.attributes.get("value", ""),
+                        "required": "required" in field.attributes
+                    }
+                    form_data["fields"].append(field_data)
+                
+                page.forms.append(form_data)
+                
+            except Exception as e:
+                logger.warning("form_extraction_error", error=str(e))
+    
+    async def close(self) -> None:
+        """Fecha a sessão HTTP."""
+        if self.session:
+            await self.session.aclose()
+            self.session = None
 
-        # Links
-        links: Set[str] = set()
-        for anchor in parser.css("a"):
-            href = anchor.attributes.get("href")
-            if not href:
-                continue
-            href = href.strip()
-            if href.startswith("javascript:") or href.startswith("mailto:"):
-                continue
-            absolute = httpx.URL(href, base=httpx.URL(url)).human_repr()
-            if not self._should_follow(absolute):
-                continue
-            links.add(absolute)
-            if absolute not in self.visited and len(self.results) < self.max_pages:
-                await queue.put((absolute, depth + 1))
-        page.links = sorted(links)
-        self.results[url] = page
-
-    def _should_follow(self, url: str) -> bool:
-        parsed = httpx.URL(url)
-        if parsed.scheme not in {"http", "https"}:
-            return False
-        if not self.follow_subdomains and parsed.host != self._host:
-            return False
-        if not parsed.host.endswith(self._host):
-            return False
-        return True
-
-    def _build_headers(self) -> Dict[str, str]:
-        headers: Dict[str, str] = {"User-Agent": self.user_agent, "Accept": "*/*"}
-        if self.stealth:
-            stealth_headers = self.stealth.get_random_headers()
-            headers.update(stealth_headers)
-            headers.setdefault("User-Agent", stealth_headers.get("User-Agent", self.user_agent))
-        return headers
+    async def __aenter__(self):
+        await self._init_session()
+        return self
 
-    async def _stealth_delay(self) -> None:
-        if not self.stealth:
-            return
-        config = getattr(self.stealth, "config", None)
-        if not config or not getattr(config, "timing_randomization", False):
-            return
-        await asyncio.sleep(random.uniform(0.05, 0.2) * max(1, self.stealth.level))
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
 
 
+# Para compatibilidade com código existente
 __all__ = ["WebCrawler", "CrawlPage"]

{moriarty_project-0.1.23.dist-info → moriarty_project-0.1.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: moriarty-project
-Version: 0.1.23
+Version: 0.1.25
 Summary: Client-side OSINT toolkit with forensic-grade evidence handling.
 Project-URL: Homepage, https://github.com/DonatoReis/moriarty
 Project-URL: Documentation, https://github.com/DonatoReis/moriarty#readme
@@ -12,44 +12,57 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Security
 Classifier: Topic :: Utilities
-Requires-Python: >=3.13
-Requires-Dist: aiodns
-Requires-Dist: aiohttp
-Requires-Dist: aiolimiter
-Requires-Dist: aiosmtplib
-Requires-Dist: dnspython>=2.0.0
-Requires-Dist: email-validator
-Requires-Dist: httpx[http2]
-Requires-Dist: idna>=3.0
-Requires-Dist: jsonpath-ng
-Requires-Dist: lxml
-Requires-Dist: networkx
-Requires-Dist: orjson
-Requires-Dist: phonenumbers
-Requires-Dist: pillow
-Requires-Dist: pydantic>=2
-Requires-Dist: pyopenssl>=23.0.0
-Requires-Dist: pyyaml>=6
-Requires-Dist: rapidfuzz
-Requires-Dist: requests
-Requires-Dist: rich
-Requires-Dist: scapy
-Requires-Dist: selectolax
-Requires-Dist: structlog
-Requires-Dist: typer[all]
-Requires-Dist: uvloop; platform_system != 'Windows'
+Requires-Python: >=3.11
+Requires-Dist: aiodns>=3.0.0
+Requires-Dist: aiohttp>=3.9.0
+Requires-Dist: aiolimiter>=1.1.0
+Requires-Dist: aiosmtplib>=2.0.0
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: dnspython>=2.5.0
+Requires-Dist: email-validator>=2.0.0
+Requires-Dist: httpx[http2]>=0.27.0
+Requires-Dist: idna>=3.6
+Requires-Dist: jsonpath-ng>=1.6.0
+Requires-Dist: lxml>=5.3.0
+Requires-Dist: netifaces>=0.11.0
+Requires-Dist: networkx>=3.2.0
+Requires-Dist: orjson>=3.9.0
+Requires-Dist: phonenumbers>=8.13.0
+Requires-Dist: pillow>=10.0.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: pycryptodomex>=3.23.0
+Requires-Dist: pydantic>=2.7.0
+Requires-Dist: pyopenssl>=25.0.0
+Requires-Dist: python-nmap>=0.7.1
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rapidfuzz>=3.0.0
+Requires-Dist: requests>=2.32.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: scapy>=2.5.0
+Requires-Dist: selectolax>=0.3.20
+Requires-Dist: structlog>=24.1.0
+Requires-Dist: tqdm>=4.67.0
+Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: uvloop>=0.19.0; platform_system != 'Windows'
+Provides-Extra: capture
+Requires-Dist: pypcap>=1.2.3; (platform_system == 'Linux' or platform_system == 'Windows') and extra == 'capture'
+Requires-Dist: python-libpcap>=0.5; (platform_system == 'Darwin') and extra == 'capture'
+Requires-Dist: python-wifi>=0.6.1; (platform_system == 'Linux' or platform_system == 'Windows') and extra == 'capture'
+Requires-Dist: pywifi>=1.1.12; (platform_system == 'Linux' or platform_system == 'Windows') and extra == 'capture'
 Provides-Extra: dev
-Requires-Dist: cyclonedx-bom; extra == 'dev'
+Requires-Dist: cyclonedx-bom>=4.4.0; extra == 'dev'
 Requires-Dist: deptry>=0.23.0; extra == 'dev'
-Requires-Dist: hypothesis; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pip-audit; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Requires-Dist: pytest-xdist; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: hypothesis>=6.98.0; extra == 'dev'
+Requires-Dist: mypy>=1.10.0; extra == 'dev'
+Requires-Dist: pip-audit>=2.7.0; extra == 'dev'
+Requires-Dist: pytest-xdist>=3.5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.5.0; extra == 'dev'
 Provides-Extra: headless
 Requires-Dist: playwright>=1.40.0; extra == 'headless'
 Provides-Extra: http3
@@ -85,7 +98,7 @@ Description-Content-Type: text/markdown
 <!-- Badges -->
 <p align="center">
   <a href="https://pypi.org/project/moriarty-project/">
-    <img src="https://img.shields.io/pypi/v/moriarty-project?color=blue&label=PyPI" alt="PyPI version">
+    <img src="https://img.shields.io/badge/version-0.1.23-blue" alt="Version 0.1.23">
   </a>
   <a href="https://www.python.org/downloads/">
     <img src="https://img.shields.io/pypi/pyversions/moriarty-project?color=blue" alt="Python Versions">

{moriarty_project-0.1.23.dist-info → moriarty_project-0.1.25.dist-info}/RECORD

@@ -1,4 +1,4 @@
-moriarty/__init__.py,sha256=xHQKlSMGcl0-ubP4s1a46VztIjLcTbQOpNHv-F_3yUk,85
+moriarty/__init__.py,sha256=6gfNgVpti1BJIBlPYh_ygBNbEQ7CuvrDMFT3oL7q6UA,85
 moriarty/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 moriarty/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 moriarty/assets/modules/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -328,10 +328,10 @@ moriarty/assets/templates/vulnerabilities/xss-reflected.yaml,sha256=iG0WphhygN2p
 moriarty/assets/templates/vulnerabilities/xxe-basic.yaml,sha256=7bG1KT5jBm8SAQp-pbjxknFuW5fIkF9yrufsq2OghRk,565
 moriarty/assets/wordlists/subdomains-1000.txt,sha256=XKDCiJMJ2wnDRngglAiv7iuDnwlUIr_-LnjlNwWp4sc,8032
 moriarty/cli/__init__.py,sha256=PQ8kA28EJ9h8mIK_VJtH1PtJ3xfVsF3d7IsmpZfl_Bc,54
-moriarty/cli/app.py,sha256=uo5SxblJGG340F1cChad4W78ASFLk7k3x_ETtg-0mts,7825
+moriarty/cli/app.py,sha256=Y1KF8Z9I5VUyQg0HE7agy4BsGkoLyPq5JLAeKiIS0fg,7987
 moriarty/cli/async_utils.py,sha256=jleTd2nyAVsNqJae2kKlo514gKKcH3nBXvfoLubOq6A,393
 moriarty/cli/dns.py,sha256=QhDwe9uoAmk243XbO9YBYk3YlPmiXYT_vLqUXum9i70,2735
-moriarty/cli/domain_cmd.py,sha256=CgpTN0kMKlAvrH72wDPuAodXOhBb0hgR4HBfZYfSTEg,24193
+moriarty/cli/domain_cmd.py,sha256=i-NSsTqmIu0wK9VYD0e2yiBbFY4p9sdbUD1zxvRh2jk,24274
 moriarty/cli/email.py,sha256=AcXMwtppFHxbjNHagrKXCdEGx-zWpvFFCB4QlCo_STU,14763
 moriarty/cli/email_investigate.py,sha256=w2OlrwpRAzPNW0YLxmt-eTB3lGJ3a-oQCM4elRFJ7lw,8319
 moriarty/cli/intelligence.py,sha256=81BnrS8ES7fH2lI34AMB5Yxuw-lbWvu44T2R444b-kE,11852
@@ -340,6 +340,7 @@ moriarty/cli/rdap.py,sha256=OVtYSsx37te0TxvY7K8iBMerPBSByXocm8kLeoUEhOw,3079
 moriarty/cli/state.py,sha256=5_HXXff9KWiYw8R763NgUAFuCAKHTZZe2zYD9JEvJxw,855
 moriarty/cli/tls.py,sha256=j4ieW_Vt0QG7AuDHfjUEAOYkvk4GJguB9hY6dYJW3K0,3269
 moriarty/cli/user.py,sha256=EWtRp4pzY7kOiWE16Yokc71pB4GP-ItguF1E2Lkri3Q,8169
+moriarty/cli/wifippler.py,sha256=sFjtwiN0-wSbBZ2MXE2Kb8kMBmz-BG1bsBcgo4G36SY,4431
 moriarty/core/cache_backend.py,sha256=tu_szkoRfZOmHh9g4ZTGc3gN-gZ-zTJGVKxlHhtvIHY,7032
 moriarty/core/config_manager.py,sha256=iXrH4UgMU05U7vsqfyFmwzybQIYH5s9hyjJlS9T9CKM,11751
 moriarty/correlator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -373,7 +374,7 @@ moriarty/models/relation.py,sha256=e__ewQhptimr9BZ3GdfFX9MxLLnCB5KKBfQxm-YsNj8,6
 moriarty/models/types.py,sha256=WlNtgcF4P3XYcQLresQjfmogh-JyPC21Bd721Z6fl9I,514
 moriarty/modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 moriarty/modules/avatar_hash.py,sha256=5Yub_N6OjUNMbt8bHShmln7i0ySDyNXrOtihWMKRivA,5919
-moriarty/modules/directory_fuzzer.py,sha256=xrRst5LIghLJDpH_bzd02uo47kx1br8z7KtTxICGZak,11703
+moriarty/modules/directory_fuzzer.py,sha256=R78fxkV6prKtj7Qq0-THPpXvWGV_OeTwa9dE-j-GY-M,12581
 moriarty/modules/dns_scan.py,sha256=lR1sGwhk1FXDmn6pCTrtd6Cr33uPllBpm_jqAi3-HxA,1096
 moriarty/modules/domain_scanner.py,sha256=fsPDogDPnRfrocAlQGN09nUvxD501DFlZMIQ3dm8OlM,23841
 moriarty/modules/email_check.py,sha256=VBAWvK3cH2Zu7wjDB2xhnqZ0scifp3s1K67CmAoUVuY,3343
@@ -385,7 +386,7 @@ moriarty/modules/orchestrator.py,sha256=uhK4UP69uWUxCK4a_bGk_BI8I-coBM8mO8Ear3pc
 moriarty/modules/passive_recon.py,sha256=5XUJgyWvITMUf4W76QyNfbRgF1AitQ5xK9MbwzVURxM,16568
 moriarty/modules/phone_extractor.py,sha256=Bv4VVWPqf67CQfkMDJddggtEU5UUbra2FP5DLik2Gxw,5298
 moriarty/modules/pipeline_orchestrator.py,sha256=qP2WcvorM_pAjacJ8VuZ-1TQ7lDVLvnyFD9T4PvWq9I,26337
-moriarty/modules/port_scanner.py,sha256=fbz7ECgdcQ9OtummUc94xxOHLnKy7BaTDHWt9CNYITU,33302
+moriarty/modules/port_scanner.py,sha256=eyrtmJ4z5-IyOizbDODeQWTNI9Z0DnlHcWEPH3ckp3Q,36913
 moriarty/modules/rdap.py,sha256=XlrTDalbSxszEwIQFHt-XWON_P9UsLLiR84DGSKAwrk,1859
 moriarty/modules/rdap_extended.py,sha256=Gef7zyOY5nuS2qn8a9iaXA7Tx3TJHZJBWpqa-BZaq4U,6447
 moriarty/modules/stealth_mode.py,sha256=9LJWXSgBjDsTZYslHz4zSnzDoC3JFdBcu3oOYN1IPhA,24459
@@ -398,7 +399,7 @@ moriarty/modules/tls_validator.py,sha256=26HoAiTv7YGiry-mya78BDDULVPC4KcOXugn9UN
 moriarty/modules/vuln_scanner.py,sha256=-sRWOPzmrzUP9Mly471JCbP7iAxSwoho9DVn-6bFC6A,18279
 moriarty/modules/waf_detector.py,sha256=5biF5OVBHbLAj_5x0ZXzCS-94bQeJNzIcYm7kMDAX0I,20744
 moriarty/modules/wayback_discovery.py,sha256=sJN9at7Py-ZiUWuwnMU7fHOc_F3WwN1R3Y72qNSmxck,8573
-moriarty/modules/web_crawler.py,sha256=hxWbnD2GO_IbIb2FChCxCesgGu4dNhlloVqr5u1MC1k,5890
+moriarty/modules/web_crawler.py,sha256=1pVLMz5vPoYFHWh2GB3ENlM2hCX07CNEXX9rKoNEI_c,20316
 moriarty/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 moriarty/net/dns_cache.py,sha256=JwuDYKqmuSD-hl7PMyyQAen57ut-uvIszYrMKT-i8pY,6022
 moriarty/net/dns_client.py,sha256=iem7FekC79ruwxWzG6eFkicYJi-urkRV0kNvj9uakM0,6591
@@ -412,7 +413,7 @@ moriarty/tests/test_email_service.py,sha256=mWqimjQRlljZNBuNePvSzhfq5FZ4mljrILGW
 moriarty/tests/test_models.py,sha256=etklIISEUts3banaSRDSjhv-g6kd4wxucchCmlJkx6Y,1282
 moriarty/tests/test_orchestrator.py,sha256=Do3M1qnbqPf_1pR3v89FXxhiwfYPZfXRvcfl05isQvs,856
 moriarty/tests/test_tls_client.py,sha256=bQ46yXlIYNZwPTd8WGs6eUynHj56hVosxBycSU1gJe4,461
-moriarty_project-0.1.23.dist-info/METADATA,sha256=-oxq6hJrBVqq1G-gjUh7Z9uG_hb0uuiJutK29BZo8cM,10766
-moriarty_project-0.1.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-moriarty_project-0.1.23.dist-info/entry_points.txt,sha256=L4TAUKy7HAy5hT46ZqS6eNOCmUTMi4x7ehZkIkTNnuE,51
-moriarty_project-0.1.23.dist-info/RECORD,,
+moriarty_project-0.1.25.dist-info/METADATA,sha256=JCScdJfoDJl7lQRQv23CQl_UkFXeqRUspQFl2OIIA0k,11709
+moriarty_project-0.1.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+moriarty_project-0.1.25.dist-info/entry_points.txt,sha256=L4TAUKy7HAy5hT46ZqS6eNOCmUTMi4x7ehZkIkTNnuE,51
+moriarty_project-0.1.25.dist-info/RECORD,,