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

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

@@ -1,182 +0,0 @@
-"""
-Módulo de execução de comandos para o WiFiPPLER.
-
-Fornece funções para execução segura de comandos de sistema.
-"""
-import asyncio
-import shlex
-import logging
-import subprocess
-from typing import List, Optional, Union, Dict, Any, Tuple
-
-logger = logging.getLogger(__name__)
-
-def run_command(
-    cmd: Union[str, List[str]],
-    capture_output: bool = False,
-    check: bool = True,
-    **kwargs
-) -> subprocess.CompletedProcess:
-    """Executa um comando no shell com tratamento de erros.
-    
-    Args:
-        cmd: Comando a ser executado (string ou lista)
-        capture_output: Se deve capturar a saída padrão e de erro
-        check: Se deve lançar uma exceção em caso de código de saída diferente de zero
-        **kwargs: Argumentos adicionais para subprocess.run()
-        
-    Returns:
-        subprocess.CompletedProcess: Resultado da execução do comando
-        
-    Raises:
-        subprocess.CalledProcessError: Se check=True e o comando retornar código de saída não zero
-    """
-    # Configura os argumentos padrão
-    kwargs.setdefault('stdout', subprocess.PIPE if capture_output else None)
-    kwargs.setdefault('stderr', subprocess.PIPE if capture_output else None)
-    kwargs.setdefault('text', True)
-    
-    # Converte o comando para lista se for string
-    if isinstance(cmd, str):
-        cmd = shlex.split(cmd)
-    
-    # Executa o comando
-    try:
-        logger.debug(f"Executando comando: {' '.join(cmd)}")
-        result = subprocess.run(cmd, check=check, **kwargs)
-        return result
-    except subprocess.CalledProcessError as e:
-        logger.error(f"Erro ao executar comando: {e}")
-        if capture_output:
-            logger.error(f"Saída de erro: {e.stderr}")
-        raise
-    except Exception as e:
-        logger.error(f"Erro inesperado ao executar comando: {e}")
-        raise
-
-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
-    """
-    # Converte o comando para lista se for string
-    if isinstance(cmd, str):
-        cmd = shlex.split(cmd)
-    
-    # Configura os argumentos padrão
-    kwargs.setdefault('stdout', subprocess.PIPE)
-    kwargs.setdefault('stderr', subprocess.PIPE)
-    kwargs.setdefault('text', True)
-    
-    logger.debug(f"Executando comando assíncrono: {' '.join(cmd)}")
-    
-    try:
-        # Cria o processo assíncrono
-        process = await asyncio.create_subprocess_exec(
-            cmd[0],
-            *cmd[1:],
-            **kwargs
-        )
-        
-        # Aguarda a conclusão do processo
-        stdout, stderr = await process.communicate()
-        
-        # Cria um objeto CompletedProcess com o resultado
-        return subprocess.CompletedProcess(
-            args=cmd,
-            returncode=process.returncode,
-            stdout=stdout,
-            stderr=stderr
-        )
-    except Exception as e:
-        logger.error(f"Erro ao executar comando assíncrono: {e}")
-        raise
-
-def run_sudo_command(
-    cmd: Union[str, List[str]],
-    password: Optional[str] = None,
-    **kwargs
-) -> subprocess.CompletedProcess:
-    """Executa um comando com privilégios de superusuário.
-    
-    Args:
-        cmd: Comando a ser executado (sem o 'sudo')
-        password: Senha do usuário (opcional, pode ser solicitada interativamente)
-        **kwargs: Argumentos adicionais para run_command()
-        
-    Returns:
-        subprocess.CompletedProcess: Resultado da execução do comando
-    """
-    if isinstance(cmd, str):
-        cmd = shlex.split(cmd)
-    
-    # Adiciona o sudo ao início do comando
-    sudo_cmd = ['sudo']
-    
-    # Se uma senha for fornecida, usa o -S para ler do stdin
-    if password is not None:
-        sudo_cmd.extend(['-S'])
-    
-    sudo_cmd.extend(cmd)
-    
-    # Se uma senha for fornecida, envia pelo stdin
-    if password is not None:
-        kwargs['input'] = f"{password}\n"
-    
-    return run_command(sudo_cmd, **kwargs)
-
-def command_success(cmd: str) -> bool:
-    """Verifica se um comando é executado com sucesso.
-    
-    Args:
-        cmd: Comando a ser verificado
-        
-    Returns:
-        bool: True se o comando for executado com sucesso, False caso contrário
-    """
-    try:
-        run_command(cmd, capture_output=True, check=True)
-        return True
-    except subprocess.CalledProcessError:
-        return False
-
-def get_command_output(cmd: Union[str, List[str]], **kwargs) -> str:
-    """Executa um comando e retorna sua saída padrão.
-    
-    Args:
-        cmd: Comando a ser executado
-        **kwargs: Argumentos adicionais para run_command()
-        
-    Returns:
-        str: Saída padrão do comando
-        
-    Raises:
-        subprocess.CalledProcessError: Se o comando retornar código de saída não zero
-    """
-    kwargs['capture_output'] = True
-    result = run_command(cmd, **kwargs)
-    return result.stdout.strip()
-
-def get_command_output_safe(cmd: Union[str, List[str]], default: str = "", **kwargs) -> str:
-    """Executa um comando e retorna sua saída padrão ou um valor padrão em caso de erro.
-    
-    Args:
-        cmd: Comando a ser executado
-        default: Valor padrão a ser retornado em caso de erro
-        **kwargs: Argumentos adicionais para run_command()
-        
-    Returns:
-        str: Saída padrão do comando ou o valor padrão em caso de erro
-    """
-    try:
-        return get_command_output(cmd, **kwargs)
-    except (subprocess.CalledProcessError, FileNotFoundError):
-        return default

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

@@ -1,262 +0,0 @@
-"""
-Módulo de utilidades de rede para o WiFiPPLER.
-
-Fornece funções para manipulação de interfaces de rede, endereçamento e operações relacionadas.
-"""
-import os
-import re
-import socket
-import fcntl
-import struct
-import array
-import platform
-from typing import Dict, List, Optional, Union, Any
-
-# Constantes para chamadas de sistema
-SIOCGIFHWADDR = 0x8927  # Get hardware address
-SIOCGIFADDR = 0x8915    # Get IP address
-SIOCGIFNETMASK = 0x891B  # Get netmask
-SIOCGIFBRDADDR = 0x8919  # Get broadcast address
-SIOCGIFMTU = 0x8921     # Get MTU
-SIOCGIFINDEX = 0x8933   # Get interface index
-SIOCGIFNAME = 0x8910    # Get interface name
-SIOCGIFFLAGS = 0x8913   # Get interface flags
-SIOCSIFFLAGS = 0x8914   # Set interface flags
-
-# Flags de interface
-IFF_UP = 0x1
-IFF_BROADCAST = 0x2
-IFF_DEBUG = 0x4
-IFF_LOOPBACK = 0x8
-IFF_POINTOPOINT = 0x10
-IFF_NOTRAILERS = 0x20
-IFF_RUNNING = 0x40
-IFF_NOARP = 0x80
-IFF_PROMISC = 0x100
-IFF_ALLMULTI = 0x200
-IFF_MASTER = 0x400
-IFF_SLAVE = 0x800
-IFF_MULTICAST = 0x1000
-IFF_PORTSEL = 0x2000
-IFF_AUTOMEDIA = 0x4000
-IFF_DYNAMIC = 0x8000
-IFF_LOWER_UP = 0x10000
-IFF_DORMANT = 0x20000
-IFF_ECHO = 0x40000
-
-def get_interface_mac(interface: str) -> Optional[str]:
-    """Obtém o endereço MAC de uma interface de rede.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        str: Endereço MAC formatado ou None se não encontrado
-    """
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        info = fcntl.ioctl(s.fileno(), SIOCGIFHWADDR, struct.pack('256s', interface[:15].encode('utf-8')))
-        return ':'.join(f'{b:02x}' for b in info[18:24])
-    except (IOError, OSError):
-        return None
-
-def get_interface_ip(interface: str) -> Optional[str]:
-    """Obtém o endereço IP de uma interface de rede.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        str: Endereço IP ou None se não encontrado
-    """
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        return socket.inet_ntoa(fcntl.ioctl(
-            s.fileno(),
-            SIOCGIFADDR,
-            struct.pack('256s', interface[:15].encode('utf-8'))
-        )[20:24])
-    except (IOError, OSError):
-        return None
-
-def get_interface_netmask(interface: str) -> Optional[str]:
-    """Obtém a máscara de rede de uma interface.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        str: Máscara de rede ou None se não encontrada
-    """
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        return socket.inet_ntoa(fcntl.ioctl(
-            s.fileno(),
-            SIOCGIFNETMASK,
-            struct.pack('256s', interface[:15].encode('utf-8'))
-        )[20:24])
-    except (IOError, OSError):
-        return None
-
-def get_interface_gateway(interface: str) -> Optional[str]:
-    """Obtém o gateway padrão de uma interface.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        str: Endereço do gateway ou None se não encontrado
-    """
-    try:
-        # Lê a tabela de roteamento
-        with open('/proc/net/route') as f:
-            for line in f:
-                fields = line.strip().split()
-                if len(fields) >= 2 and fields[0] == interface and fields[1] == '00000000':
-                    # Converte o endereço hex para IP
-                    return socket.inet_ntoa(struct.pack('<L', int(fields[2], 16)))
-    except (IOError, OSError):
-        pass
-    return None
-
-def is_wireless_interface(interface: str) -> bool:
-    """Verifica se uma interface é sem fio.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        bool: True se for uma interface sem fio, False caso contrário
-    """
-    # Verifica se a interface existe em /sys/class/net/
-    if not os.path.exists(f'/sys/class/net/{interface}'):
-        return False
-    
-    # Verifica se é uma interface wireless
-    wireless_path = f'/sys/class/net/{interface}/wireless'
-    return os.path.exists(wireless_path)
-
-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 dicionários com informações das interfaces
-    """
-    interfaces = []
-    
-    # Lista todos os diretórios em /sys/class/net
-    for iface in os.listdir('/sys/class/net'):
-        if is_wireless_interface(iface):
-            interfaces.append({
-                'name': iface,
-                'mac': get_interface_mac(iface),
-                'ip': get_interface_ip(iface),
-                'wireless': True,
-                'up': is_interface_up(iface),
-                'mtu': get_interface_mtu(iface)
-            })
-    
-    return interfaces
-
-def is_interface_up(interface: str) -> bool:
-    """Verifica se uma interface de rede está ativa.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        bool: True se a interface estiver ativa, False caso contrário
-    """
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        flags = struct.unpack('H', fcntl.ioctl(
-            s.fileno(),
-            SIOCGIFFLAGS,
-            struct.pack('256s', interface[:15].encode('utf-8'))
-        )[16:18])[0]
-        return bool(flags & IFF_UP)
-    except (IOError, OSError):
-        return False
-
-def get_interface_mtu(interface: str) -> int:
-    """Obtém o MTU de uma interface de rede.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        int: Valor do MTU ou 1500 (padrão) se não for possível obter
-    """
-    try:
-        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        ifreq = struct.pack('256s', interface.encode('utf-8')[:15])
-        mtu = fcntl.ioctl(s.fileno(), SIOCGIFMTU, ifreq)
-        return struct.unpack('H', mtu[16:18])[0]
-    except (IOError, OSError, struct.error):
-        return 1500  # Valor padrão para MTU
-
-
-def get_network_interfaces() -> List[Dict[str, Any]]:
-    """Obtém uma lista de todas as interfaces de rede.
-    
-    Returns:
-        List[Dict[str, Any]]: Lista de dicionários com informações das interfaces
-    """
-    interfaces = []
-    
-    try:
-        # Lista todos os diretórios em /sys/class/net
-        for iface in os.listdir('/sys/class/net'):
-            if iface == 'lo':  # Ignora a interface de loopback
-                continue
-                
-            # Verifica se é uma interface wireless
-            is_wireless = is_wireless_interface(iface)
-            
-            interfaces.append({
-                'name': iface,
-                'mac': get_interface_mac(iface),
-                'ip': get_interface_ip(iface),
-                'wireless': is_wireless,
-                'up': is_interface_up(iface),
-                'mtu': get_interface_mtu(iface)
-            })
-    except Exception as e:
-        print(f"Erro ao listar interfaces de rede: {e}")
-    
-    return interfaces
-
-
-def get_monitor_interfaces() -> List[Dict[str, Any]]:
-    """Obtém uma lista de interfaces de rede em modo monitor.
-    
-    Returns:
-        List[Dict[str, Any]]: Lista de dicionários com informações das interfaces em modo monitor
-    """
-    monitor_interfaces = []
-    
-    try:
-        # Obtém todas as interfaces de rede
-        interfaces = get_network_interfaces()
-        
-        # Filtra apenas as interfaces sem fio
-        wireless_interfaces = [iface for iface in interfaces if iface.get('wireless')]
-        
-        # Verifica quais interfaces estão em modo monitor
-        for iface in wireless_interfaces:
-            ifname = iface['name']
-            
-            # Verifica se a interface está em modo monitor
-            try:
-                with open(f'/sys/class/net/{ifname}/type', 'r') as f:
-                    iftype = int(f.read().strip())
-                    # O tipo 803 indica modo monitor (IEEE80211_IF_TYPE_MONITOR)
-                    if iftype == 803:
-                        monitor_interfaces.append(iface)
-            except (IOError, ValueError):
-                continue
-                
-    except Exception as e:
-        print(f"Erro ao listar interfaces em modo monitor: {e}")
-    
-    return monitor_interfaces

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

@@ -1,153 +0,0 @@
-"""
-Módulo de utilidades do sistema para o WiFiPPLER.
-
-Fornece funções para verificação de permissões, dependências e outras operações do sistema.
-"""
-import os
-import sys
-import subprocess
-import shutil
-from typing import List, Optional, Union, Dict, Any
-
-def is_root() -> bool:
-    """Verifica se o script está sendo executado como root.
-    
-    Returns:
-        bool: True se for root, False caso contrário
-    """
-    return os.geteuid() == 0
-
-def command_exists(cmd: str) -> bool:
-    """Verifica se um comando existe no sistema.
-    
-    Args:
-        cmd: Nome do comando a ser verificado
-        
-    Returns:
-        bool: True se o comando existir, False caso contrário
-    """
-    return shutil.which(cmd) is not None
-
-def check_dependencies() -> List[str]:
-    """Verifica as dependências necessárias para o funcionamento do WiFiPPLER.
-    
-    Returns:
-        List[str]: Lista de dependências ausentes
-    """
-    required_commands = [
-        'iwconfig',
-        'ifconfig',
-        'iw',
-        'aircrack-ng',
-        'airodump-ng',
-        'aireplay-ng',
-        'airmon-ng',
-        'macchanger'
-    ]
-    
-    missing = []
-    for cmd in required_commands:
-        if not command_exists(cmd):
-            missing.append(cmd)
-    
-    return missing
-
-def get_os_info() -> Dict[str, str]:
-    """Obtém informações sobre o sistema operacional.
-    
-    Returns:
-        Dict[str, str]: Dicionário com informações do sistema
-    """
-    import platform
-    
-    return {
-        'system': platform.system(),
-        'node': platform.node(),
-        'release': platform.release(),
-        'version': platform.version(),
-        'machine': platform.machine(),
-        'processor': platform.processor(),
-        'python_version': platform.python_version()
-    }
-
-def ensure_root() -> None:
-    """Verifica se o script está sendo executado como root.
-    
-    Raises:
-        RuntimeError: Se não estiver sendo executado como root
-    """
-    if not is_root():
-        raise RuntimeError("Este script requer privilégios de superusuário (root). Execute com sudo.")
-
-def ensure_dependencies() -> None:
-    """Verifica se todas as dependências estão instaladas.
-    
-    Raises:
-        RuntimeError: Se alguma dependência estiver faltando
-    """
-    missing = check_dependencies()
-    if missing:
-        raise RuntimeError(
-            f"As seguintes dependências estão faltando: {', '.join(missing)}\n"
-            "Por favor, instale-as antes de continuar."
-        )
-
-def get_available_interfaces() -> List[str]:
-    """Obtém uma lista de interfaces de rede disponíveis.
-    
-    Returns:
-        List[str]: Lista de nomes de interfaces de rede
-    """
-    try:
-        return [
-            iface for iface in os.listdir('/sys/class/net/')
-            if iface != 'lo'  # Ignora interface de loopback
-        ]
-    except (OSError, IOError):
-        return []
-
-def get_wireless_interfaces() -> List[str]:
-    """Obtém uma lista de interfaces de rede sem fio disponíveis.
-    
-    Returns:
-        List[str]: Lista de nomes de interfaces sem fio
-    """
-    try:
-        return [
-            iface for iface in os.listdir('/sys/class/net/')
-            if os.path.exists(f'/sys/class/net/{iface}/wireless')
-        ]
-    except (OSError, IOError):
-        return []
-
-def get_interface_info(interface: str) -> Dict[str, Any]:
-    """Obtém informações detalhadas sobre uma interface de rede.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        Dict[str, Any]: Dicionário com informações da interface
-    """
-    return {
-        'name': interface,
-        'wireless': os.path.exists(f'/sys/class/net/{interface}/wireless'),
-        'state': get_interface_state(interface),
-        'mac_address': get_interface_mac(interface),
-        'ip_address': get_interface_ip(interface)
-    }
-
-def get_interface_state(interface: str) -> str:
-    """Obtém o estado atual de uma interface de rede.
-    
-    Args:
-        interface: Nome da interface de rede
-        
-    Returns:
-        str: Estado da interface (up/down/unknown)
-    """
-    try:
-        with open(f'/sys/class/net/{interface}/operstate', 'r') as f:
-            return f.read().strip()
-    except (OSError, IOError):
-        return 'unknown'