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

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

@@ -0,0 +1,612 @@
+"""
+Utilitários para o módulo WiFiPPLER.
+"""
+import os
+import sys
+import re
+import subprocess
+import shlex
+import logging
+import socket
+import fcntl
+import struct
+import array
+import platform
+import asyncio
+from typing import List, Dict, Tuple, Optional, Set, Any, Union
+from dataclasses import asdict
+
+import netifaces
+import psutil
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from ..models.network import WiFiNetwork, WiFiClient, WiFiSecurityType, WiFiCipherType, WiFiAuthType
+
+# Configuração de logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+console = Console()
+
+# Constantes
+WIRELESS_EXT = "SIOCGIWNAME"
+SIOCGIFHWADDR = 0x8927
+SIOCGIFADDR = 0x8915
+SIOCGIFNETMASK = 0x891B
+SIOCGIFBRDADDR = 0x8919
+SIOCGIFMTU = 0x8921
+SIOCGIFINDEX = 0x8933
+SIOCGIFNAME = 0x8910
+SIOCGIFFLAGS = 0x8913
+SIOCSIFFLAGS = 0x8914
+
+# Mapeamento de códigos de segurança
+SECURITY_MAP = {
+    'WPA2': WiFiSecurityType.WPA2,
+    'WPA3': WiFiSecurityType.WPA3,
+    'WPA2-EAP': WiFiSecurityType.WPA2_ENTERPRISE,
+    'WPA3-EAP': WiFiSecurityType.WPA3_ENTERPRISE,
+    'WEP': WiFiSecurityType.WEP,
+    'OPEN': WiFiSecurityType.NONE,
+    'NONE': WiFiSecurityType.NONE,
+    'WPA': WiFiSecurityType.WPA,
+    'WPA2-PSK': WiFiSecurityType.WPA2,
+    'WPA3-PSK': WiFiSecurityType.WPA3,
+    'WPA2-PSK-CCMP': WiFiSecurityType.WPA2,
+    'WPA2-PSK-TKIP': WiFiSecurityType.WPA2,
+    'WPA-PSK': WiFiSecurityType.WPA,
+    'WPA-PSK-CCMP': WiFiSecurityType.WPA,
+    'WPA-PSK-TKIP': WiFiSecurityType.WPA,
+}
+
+# Mapeamento de cifras
+CIPHER_MAP = {
+    'CCMP': WiFiCipherType.CCMP,
+    'TKIP': WiFiCipherType.TKIP,
+    'WEP': WiFiCipherType.WEP_40,  # Usando WEP_40 como padrão para WEP
+    'WEP-40': WiFiCipherType.WEP_40,
+    'WEP-104': WiFiCipherType.WEP_104,
+    'WEP-128': WiFiCipherType.WEP_104,  # WEP-128 não está definido, usando WEP_104 como alternativa
+    'NONE': WiFiCipherType.NONE,
+    'GCMP': WiFiCipherType.GCMP
+}
+
+# Mapeamento de autenticação
+AUTH_MAP = {
+    'PSK': WiFiAuthType.WPA_PSK,  # Usando WPA_PSK para PSK
+    'WPA-PSK': WiFiAuthType.WPA_PSK,
+    'WPA2-PSK': WiFiAuthType.WPA2_PSK,
+    'WPA3-SAE': WiFiAuthType.WPA3_SAE,
+    'EAP': WiFiAuthType.WPA_EAP,  # Usando WPA_EAP para EAP
+    'WPA-EAP': WiFiAuthType.WPA_EAP,
+    'WPA2-EAP': WiFiAuthType.WPA2_EAP,
+    'WPA3-EAP': WiFiAuthType.WPA3_EAP,
+    'OPEN': WiFiAuthType.OPEN,
+    'SHARED': WiFiAuthType.SHARED,
+    'OWE': WiFiAuthType.OWE,
+    'NONE': WiFiAuthType.OPEN,
+}
+
+def is_root() -> bool:
+    """Verifica se o script está sendo executado como root."""
+    return os.geteuid() == 0
+
+def check_dependencies() -> List[str]:
+    """Verifica as dependências necessárias."""
+    required = ['iwconfig', 'iwlist', 'aircrack-ng', 'airodump-ng', 'aireplay-ng', 'airmon-ng']
+    missing = []
+    
+    for dep in required:
+        if not command_exists(dep):
+            missing.append(dep)
+    
+    return missing
+
+def command_exists(cmd: str) -> bool:
+    """Verifica se um comando existe no sistema."""
+    return shutil.which(cmd) is not None
+
+def get_network_interfaces() -> List[str]:
+    """Retorna a lista de interfaces de rede sem fio disponíveis."""
+    interfaces = []
+    
+    try:
+        for interface in netifaces.interfaces():
+            if interface.startswith(('wlan', 'wlp', 'wlo', 'wlp')):
+                interfaces.append(interface)
+    except Exception as e:
+        logger.error(f"Erro ao obter interfaces de rede: {e}")
+    
+    return interfaces
+
+def get_monitor_interfaces() -> List[str]:
+    """Retorna a lista de interfaces em modo monitor."""
+    monitor_ifaces = []
+    
+    try:
+        for interface in netifaces.interfaces():
+            if interface.endswith('mon'):
+                monitor_ifaces.append(interface)
+            else:
+                try:
+                    with open(f"/sys/class/net/{interface}/type", 'r') as f:
+                        if f.read().strip() == '803':  # ARPHRD_IEEE80211_RADIOTAP
+                            monitor_ifaces.append(interface)
+                except (IOError, FileNotFoundError):
+                    continue
+    except Exception as e:
+        logger.error(f"Erro ao obter interfaces em modo monitor: {e}")
+    
+    return monitor_ifaces
+
+def set_monitor_mode(interface: str, channel: int = None) -> bool:
+    """Ativa o modo monitor em uma interface."""
+    if not is_root():
+        logger.error("Privilégios de root são necessários para ativar o modo monitor")
+        return False
+    
+    try:
+        # Para processos que podem interferir
+        subprocess.run(['airmon-ng', 'check', 'kill'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE)
+        
+        # Ativa o modo monitor
+        cmd = ['airmon-ng', 'start', interface]
+        if channel:
+            cmd.extend(['-c', str(channel)])
+            
+        result = subprocess.run(cmd, 
+                              stdout=subprocess.PIPE, 
+                              stderr=subprocess.PIPE,
+                              text=True)
+        
+        if result.returncode != 0:
+            logger.error(f"Falha ao ativar o modo monitor: {result.stderr}")
+            return False
+            
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Erro ao executar airmon-ng: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Erro inesperado: {e}")
+        return False
+
+def restore_network_interface(interface: str) -> bool:
+    """Restaura a interface para o modo gerenciado."""
+    if not is_root():
+        logger.error("Privilégios de root são necessários para restaurar a interface")
+        return False
+    
+    try:
+        # Para o modo monitor
+        subprocess.run(['airmon-ng', 'stop', interface], check=True)
+        
+        # Reinicia o gerenciador de rede
+        if command_exists('systemctl'):
+            subprocess.run(['systemctl', 'restart', 'NetworkManager'], check=False)
+        elif command_exists('service'):
+            subprocess.run(['service', 'network-manager', 'restart'], check=False)
+        
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Erro ao parar o modo monitor: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Erro inesperado: {e}")
+        return False
+
+def start_monitor_mode(interface: str, channel: int = None) -> Optional[str]:
+    """Inicia o modo monitor em uma interface usando airmon-ng."""
+    if not is_root():
+        logger.error("Privilégios de root são necessários para iniciar o modo monitor")
+        return None
+    
+    try:
+        # Para processos que podem interferir
+        subprocess.run(['airmon-ng', 'check', 'kill'], 
+                      stdout=subprocess.PIPE, 
+                      stderr=subprocess.PIPE)
+        
+        # Inicia o modo monitor
+        cmd = ['airmon-ng', 'start', interface]
+        if channel:
+            cmd.extend(['-c', str(channel)])
+            
+        result = subprocess.run(cmd, 
+                              stdout=subprocess.PIPE, 
+                              stderr=subprocess.PIPE,
+                              text=True)
+        
+        if result.returncode != 0:
+            logger.error(f"Falha ao iniciar o modo monitor: {result.stderr}")
+            return None
+            
+        # Obtém o nome da interface em modo monitor (pode mudar, ex: wlan0 -> wlan0mon)
+        for line in result.stdout.split('\n'):
+            if 'monitor mode' in line and 'enabled' in line:
+                parts = line.split()
+                if len(parts) > 0:
+                    return parts[0].strip('()')
+                    
+        return f"{interface}mon"  # Padrão comum
+        
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Erro ao executar airmon-ng: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Erro inesperado: {e}")
+        return None
+
+def stop_monitor_mode(interface: str) -> bool:
+    """Para o modo monitor em uma interface usando airmon-ng."""
+    if not is_root():
+        logger.error("Privilégios de root são necessários para parar o modo monitor")
+        return False
+    
+    try:
+        # Para o modo monitor
+        subprocess.run(['airmon-ng', 'stop', interface], check=True)
+        
+        # Reinicia o gerenciador de rede
+        if command_exists('systemctl'):
+            subprocess.run(['systemctl', 'restart', 'NetworkManager'], check=False)
+        elif command_exists('service'):
+            subprocess.run(['service', 'network-manager', 'restart'], check=False)
+        
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Erro ao parar modo monitor: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Erro inesperado: {e}")
+        return False
+
+def get_interface_mac(interface: str) -> Optional[str]:
+    """Obtém o endereço MAC de uma interface de rede."""
+    try:
+        with open(f"/sys/class/net/{interface}/address") as f:
+            return f.read().strip()
+    except (IOError, FileNotFoundError):
+        return None
+
+def get_interface_ip(interface: str) -> Optional[str]:
+    """Obtém o endereço IP de uma interface de rede."""
+    try:
+        return netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['addr']
+    except (KeyError, IndexError):
+        return None
+
+def get_interface_netmask(interface: str) -> Optional[str]:
+    """Obtém a máscara de rede de uma interface de rede."""
+    try:
+        return netifaces.ifaddresses(interface)[netifaces.AF_INET][0]['netmask']
+    except (KeyError, IndexError):
+        return None
+
+def get_interface_gateway(interface: str) -> Optional[str]:
+    """Obtém o gateway padrão de uma interface de rede."""
+    try:
+        gateways = netifaces.gateways()
+        return gateways['default'][netifaces.AF_INET][0]
+    except (KeyError, IndexError):
+        return None
+
+def is_wireless_interface(interface: str) -> bool:
+    """Verifica se uma interface é sem fio."""
+    try:
+        with open(f"/sys/class/net/{interface}/wireless/uevent", 'r') as f:
+            return True
+    except (IOError, FileNotFoundError):
+        return False
+
+def get_interface_signal(interface: str) -> Optional[int]:
+    """Obtém a intensidade do sinal de uma interface sem fio em dBm."""
+    try:
+        result = subprocess.run(
+            ['iwconfig', interface],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        match = re.search(r'Signal level=(-?\d+) dBm', result.stdout)
+        if match:
+            return int(match.group(1))
+        return None
+    except (subprocess.SubprocessError, ValueError):
+        return None
+
+def get_interface_ssid(interface: str) -> Optional[str]:
+    """Obtém o SSID ao qual a interface está conectada."""
+    try:
+        result = subprocess.run(
+            ['iwgetid', '-r', interface],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        if result.returncode == 0 and result.stdout.strip():
+            return result.stdout.strip()
+        return None
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+
+def get_interface_channel(interface: str) -> Optional[int]:
+    """Obtém o canal em que a interface está operando."""
+    try:
+        result = subprocess.run(
+            ['iwlist', interface, 'channel'],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        match = re.search(r'Channel (\d+)', result.stdout)
+        if match:
+            return int(match.group(1))
+        return None
+    except (subprocess.SubprocessError, ValueError):
+        return None
+
+def get_interface_bitrate(interface: str) -> Optional[float]:
+    """Obtém a taxa de transmissão da interface em Mbps."""
+    try:
+        result = subprocess.run(
+            ['iwconfig', interface],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        
+        if result.returncode != 0:
+            return None
+            
+        match = re.search(r'Bit Rate[:=]([\d.]+) (\w+)', result.stdout)
+        if match:
+            rate, unit = match.groups()
+            rate = float(rate)
+            if unit == 'Mb/s':
+                return rate
+            elif unit == 'Kb/s':
+                return rate / 1000
+        return None
+    except (subprocess.SubprocessError, ValueError):
+        return None
+
+# Funções para manipulação de pacotes
+def create_deauth_packet(bssid: str, client: str, reason: int = 7, count: int = 1) -> bytes:
+    """Cria um pacote de desautenticação."""
+    # Cabeçalho do pacote 802.11
+    frame = [
+        0x00, 0x00, 0x0c, 0x00,  # Radiotap header (versão, pad, len, presente)
+        0x04, 0x80, 0x00, 0x00,   # Presente flags
+        0x00, 0x00, 0x00, 0x00,   # Timestamp
+        0x00, 0x00, 0x00, 0x00,   # Flags e taxa de dados
+        0x00, 0x00,               # Canal, sinal, ruído, etc.
+        0x00, 0x00, 0x00, 0x00,   # MCS conhecido, flags, mcs
+        0x00, 0x00, 0x00, 0x00,   # A-MPDU
+        
+        # Cabeçalho 802.11 (tipo Management, subtipo Deauthentication)
+        0x00, 0x00, 0x0c, 0x00,  # Controle de versão, tipo, subtipo, etc.
+        0x00, 0x00,               # Duração
+    ]
+    
+    # Endereço de destino (broadcast ou cliente específico)
+    dest = [int(x, 16) for x in client.split(':')]
+    frame.extend(dest)
+    
+    # Endereço de origem (BSSID)
+    src = [int(x, 16) for x in bssid.split(':')]
+    frame.extend(src)
+    
+    # BSSID (mesmo que origem para redes de infraestrutura)
+    frame.extend(src)
+    
+    # Número de sequência
+    frame.extend([0x00, 0x00])
+    
+    # Código de motivo (2 bytes, little-endian)
+    frame.extend([reason, 0x00])
+    
+    return bytes(frame) * count
+
+# Funções para execução de comandos
+async def run_command_async(cmd: Union[str, List[str]], **kwargs) -> subprocess.CompletedProcess:
+    """
+    Executa um comando de forma assíncrona.
+    
+    Args:
+        cmd: Comando a ser executado (string ou lista)
+        **kwargs: Argumentos adicionais para asyncio.create_subprocess_exec()
+        
+    Returns:
+        subprocess.CompletedProcess: Resultado da execução do comando
+    """
+    if isinstance(cmd, str):
+        cmd = cmd.split()
+    
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        **kwargs
+    )
+    
+    stdout, stderr = await process.communicate()
+    
+    return subprocess.CompletedProcess(
+        args=cmd,
+        returncode=process.returncode,
+        stdout=stdout,
+        stderr=stderr
+    )
+
+# Funções para processamento de saída
+def parse_airodump_csv(csv_file: str) -> List[WiFiNetwork]:
+    """Analisa o arquivo CSV gerado pelo airodump-ng."""
+    networks = []
+    
+    try:
+        with open(csv_file, 'r') as f:
+            lines = f.readlines()
+        
+        # Encontra o início dos dados das redes
+        start_idx = 0
+        for i, line in enumerate(lines):
+            if line.startswith('BSSID, First time seen,'):
+                start_idx = i + 1
+                break
+        
+        # Processa as redes
+        for line in lines[start_idx:]:
+            line = line.strip()
+            if not line or line.startswith('Station'):
+                break
+                
+            # Extrai os campos da linha
+            parts = [p.strip() for p in line.split(',')]
+            if len(parts) < 14:  # Número mínimo de campos esperados
+                continue
+                
+            bssid = parts[0].strip()
+            first_seen = parts[1].strip()
+            last_seen = parts[2].strip()
+            channel = int(parts[3].strip())
+            speed = parts[4].strip()
+            privacy = parts[5].strip()
+            cipher = parts[6].strip()
+            auth = parts[7].strip()
+            power = int(parts[8].strip())
+            beacons = int(parts[9].strip())
+            iv = int(parts[10].strip())
+            ip = parts[11].strip()
+            id_len = int(parts[12].strip())
+            essid = parts[13].strip()
+            
+            # Cria o objeto da rede
+            network = WiFiNetwork(
+                bssid=bssid,
+                ssid=essid,
+                channel=channel,
+                signal=power,
+                encryption=privacy,
+                cipher=cipher,
+                authentication=auth,
+                first_seen=first_seen,
+                last_seen=last_seen,
+                speed=speed,
+                beacons=beacons,
+                iv=iv,
+                ip=ip if ip != '0.0.0.0' else None
+            )
+            
+            networks.append(network)
+            
+    except Exception as e:
+        logger.error(f"Erro ao analisar arquivo CSV: {e}")
+    
+    return networks
+
+def parse_airodump_stations(csv_file: str) -> List[WiFiClient]:
+    """Analisa a seção de estações do arquivo CSV do airodump-ng."""
+    clients = []
+    
+    try:
+        with open(csv_file, 'r') as f:
+            lines = f.readlines()
+        
+        # Encontra o início da seção de estações
+        start_idx = 0
+        for i, line in enumerate(lines):
+            if line.startswith('Station MAC,'):
+                start_idx = i + 1
+                break
+        
+        # Processa as estações
+        for line in lines[start_idx:]:
+            line = line.strip()
+            if not line:
+                continue
+                
+            # Extrai os campos da linha
+            parts = [p.strip() for p in line.split(',')]
+            if len(parts) < 6:  # Número mínimo de campos esperados
+                continue
+                
+            mac = parts[0].strip()
+            first_seen = parts[1].strip()
+            last_seen = parts[2].strip()
+            power = int(parts[3].strip())
+            packets = int(parts[4].strip())
+            bssid = parts[5].strip()
+            
+            # Cria o objeto do cliente
+            client = WiFiClient(
+                mac=mac,
+                bssid=bssid,
+                signal=power,
+                packets=packets,
+                first_seen=first_seen,
+                last_seen=last_seen
+            )
+            
+            clients.append(client)
+            
+    except Exception as e:
+        logger.error(f"Erro ao analisar estações do arquivo CSV: {e}")
+    
+    return clients
+
+def randomize_mac(interface: str) -> bool:
+    """
+    Aleatoriza o endereço MAC de uma interface de rede.
+    
+    Args:
+        interface: Nome da interface de rede
+        
+    Returns:
+        bool: True se bem-sucedido, False caso contrário
+    """
+    if not is_root():
+        logger.error("Privilégios de root são necessários para alterar o endereço MAC")
+        return False
+    
+    try:
+        # Gera um endereço MAC aleatório
+        import random
+        new_mac = ':'.join(['%02x' % random.randint(0x00, 0xff) for _ in range(6)])
+        
+        # Desativa a interface
+        subprocess.run(['ip', 'link', 'set', interface, 'down'], check=True)
+        
+        # Define o novo endereço MAC
+        subprocess.run(['ip', 'link', 'set', 'dev', interface, 'address', new_mac], check=True)
+        
+        # Reativa a interface
+        subprocess.run(['ip', 'link', 'set', interface, 'up'], check=True)
+        
+        logger.info(f"Endereço MAC da interface {interface} alterado para {new_mac}")
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Falha ao aleatorizar o endereço MAC: {e}")
+        return False
+
+def get_wireless_interfaces() -> List[Dict[str, Any]]:
+    """
+    Obtém uma lista de interfaces de rede sem fio.
+    
+    Returns:
+        List[Dict[str, Any]]: Lista de interfaces sem fio com suas propriedades
+    """
+    return [iface for iface in get_network_interfaces() 
+            if iface.get('wireless', False)]