moriarty-project 0.1.19__py3-none-any.whl → 0.1.21__py3-none-any.whl

moriarty/__init__.py

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

moriarty/modules/wifippler/__init__.py

@@ -3,6 +3,13 @@ WifiPPLER - Ferramenta Avançada de Análise de Segurança WiFi
 
 Uma ferramenta abrangente de auditoria de segurança WiFi que combina os melhores
 recursos de ferramentas existentes com técnicas modernas e uma interface limpa.
+
+Módulos principais:
+- scanner: Escaneamento de redes WiFi
+- attacks: Implementações de ataques de segurança
+- models: Modelos de dados
+- utils: Funções utilitárias
+- cli: Interface de linha de comando
 """
 
 __version__ = "1.0.0"
@@ -11,6 +18,14 @@ __license__ = "MIT"
 
 # Importações principais
 from .core.scanner import WiFiScanner
+from .core.attacks import (
+    Attack,  # Interface base para ataques
+    register_attack,  # Decorador para registrar novos ataques
+    get_attack,  # Obter um ataque pelo nome
+    list_attacks,  # Listar todos os ataques disponíveis
+)
+
+# Importar ataques padrão para registro
 from .core.attacks import (
     WPSAttack,
     WPAHandshakeAttack,
@@ -20,26 +35,36 @@ from .core.attacks import (
     HandshakeCapture
 )
 
-# Utilitários
+# Utilitários comuns
 from .core.utils import (
     is_root,
     check_dependencies,
     get_network_interfaces,
+    get_wireless_interfaces,
     set_monitor_mode,
     restore_network_interface,
-    get_monitor_interfaces,
     start_monitor_mode,
-    stop_monitor_mode
+    stop_monitor_mode,
+    get_monitor_interfaces,
 )
 
 # Modelos de dados
 from .core.models.network import WiFiNetwork, WiFiClient
 
+# Interface CLI
+from .cli.commands import app as cli_app
+
 __all__ = [
     # Classes principais
     'WiFiScanner',
     
-    # Ataques
+    # Sistema de ataques
+    'Attack',
+    'register_attack',
+    'get_attack',
+    'list_attacks',
+    
+    # Ataques específicos
     'WPSAttack',
     'WPAHandshakeAttack',
     'PMKIDAttack',
@@ -51,13 +76,17 @@ __all__ = [
     'is_root',
     'check_dependencies',
     'get_network_interfaces',
+    'get_wireless_interfaces',
     'set_monitor_mode',
     'restore_network_interface',
-    'get_monitor_interfaces',
     'start_monitor_mode',
     'stop_monitor_mode',
+    'get_monitor_interfaces',
     
     # Modelos
     'WiFiNetwork',
-    'WiFiClient'
+    'WiFiClient',
+    
+    # CLI
+    'cli_app'
 ]

moriarty/modules/wifippler/cli/__init__.py

@@ -0,0 +1,8 @@
+"""
+Módulo CLI do WiFiPPLER.
+
+Fornece a interface de linha de comando para interagir com as funcionalidades do WiFiPPLER.
+"""
+
+# Este arquivo é deixado intencionalmente vazio para marcar o diretório como um pacote Python.
+# A implementação da CLI está em commands.py

moriarty/modules/wifippler/cli/commands.py

@@ -0,0 +1,123 @@
+"""
+Interface de linha de comando (CLI) para o WiFiPPLER.
+
+Utiliza Typer para criar uma interface de linha de comando amigável.
+"""
+import typer
+from typing import Optional, List
+from rich.console import Console
+from rich.table import Table
+
+# Importa o scanner e o registro de ataques
+from ..core.scanner import WiFiScanner
+from ..core.attacks import list_attacks, get_attack, Attack
+
+# Cria a aplicação Typer
+app = typer.Typer(help="WiFiPPLER - Ferramenta Avançada de Análise de Segurança WiFi")
+console = Console()
+
+# Instância do scanner
+scanner = WiFiScanner()
+
+@app.command()
+def list_attacks():
+    """Lista todos os ataques disponíveis."""
+    attacks = scanner.list_attacks()
+    
+    if not attacks:
+        console.print("[yellow]Nenhum ataque registrado.[/yellow]")
+        return
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Nome", style="cyan")
+    table.add_column("Descrição")
+    
+    for name, attack_cls in attacks.items():
+        table.add_row(name, attack_cls.description)
+    
+    console.print("\n[bold]Ataques disponíveis:[/bold]")
+    console.print(table)
+
+@app.command()
+def scan(iface: str = typer.Option(..., "--iface", "-i", help="Interface de rede a ser usada")):
+    """Escaneia redes WiFi próximas."""
+    try:
+        console.print(f"[bold]Escaneando redes na interface {iface}...[/bold]")
+        # Implementar lógica de escaneamento aqui
+        networks = scanner.scan(iface=iface)
+        
+        if not networks:
+            console.print("[yellow]Nenhuma rede encontrada.[/yellow]")
+            return
+        
+        table = Table(show_header=True, header_style="bold green")
+        table.add_column("BSSID", style="cyan")
+        table.add_column("SSID", style="green")
+        table.add_column("Canal")
+        table.add_column("Sinal")
+        table.add_column("Segurança")
+        
+        for net in networks:
+            table.add_row(
+                net.bssid,
+                net.ssid or "[dim](oculto)[/dim]",
+                str(net.channel),
+                f"{net.signal} dBm",
+                ", ".join(net.security) if net.security else "Aberta"
+            )
+        
+        console.print("\n[bold]Redes encontradas:[/bold]")
+        console.print(table)
+        
+    except Exception as e:
+        console.print(f"[red]Erro ao escanear redes: {e}[/red]")
+        raise typer.Exit(1)
+
+@app.command()
+def run(
+    attack: str = typer.Argument(..., help="Nome do ataque a ser executado"),
+    iface: str = typer.Option(..., "--iface", "-i", help="Interface de rede a ser usada"),
+    target: Optional[str] = typer.Option(None, "--target", "-t", help="Alvo do ataque (opcional)"),
+    channel: Optional[int] = typer.Option(None, "--channel", "-c", help="Canal a ser monitorado (opcional)"),
+):
+    """Executa um ataque específico."""
+    try:
+        console.print(f"[bold]Preparando para executar o ataque: {attack}[/bold]")
+        
+        # Verifica se o ataque existe
+        attack_cls = get_attack(attack)
+        if not attack_cls:
+            available = ", ".join(scanner.list_attacks().keys())
+            console.print(f"[red]Ataque '{attack}' não encontrado. Ataques disponíveis: {available}[/red]")
+            raise typer.Exit(1)
+        
+        # Cria e executa o ataque
+        attack_instance = attack_cls()
+        
+        # Configura parâmetros comuns
+        params = {
+            'iface': iface,
+            'target': target
+        }
+        
+        if channel is not None:
+            params['channel'] = channel
+        
+        console.print(f"[bold]Iniciando ataque {attack}...[/]")
+        console.print("[yellow]Pressione Ctrl+C para interromper[/yellow]")
+        
+        # Executa o ataque
+        attack_instance.run(**params)
+        
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Ataque interrompido pelo usuário.[/yellow]")
+        raise typer.Exit(0)
+    except Exception as e:
+        console.print(f"[red]Erro ao executar o ataque: {e}[/red]")
+        if typer.get_app_dir("wifippler").startswith("DEBUG"):
+            import traceback
+            console.print(traceback.format_exc())
+        raise typer.Exit(1)
+
+if __name__ == "__main__":
+    app()

moriarty/modules/wifippler/core/__init__.py

@@ -1,12 +1,21 @@
 """
-Core functionality for the WifiPPLER module.
+Módulo principal do WiFiPPLER.
 
-This module provides the core functionality for the WifiPPLER tool,
-including network scanning, packet analysis, and attack modules.
+Este pacote contém a funcionalidade central da ferramenta WiFiPPLER,
+incluindo escaneamento de rede, análise de pacotes e módulos de ataque.
 """
 
+# Importações principais
 from .scanner import WiFiScanner
+
+# Sistema de registro de ataques
 from .attacks import (
+    Attack,
+    register_attack,
+    get_attack,
+    list_attacks,
+    
+    # Ataques padrão
     WPSAttack,
     WPAHandshakeAttack,
     PMKIDAttack,
@@ -15,47 +24,60 @@ from .attacks import (
     HandshakeCapture
 )
 
-# Import utility functions
+# Importar apenas o necessário do módulo utils
 from .utils import (
+    # Funções básicas
     is_root,
-    get_wireless_interfaces,
     check_dependencies,
+    
+    # Funções de rede
     get_network_interfaces,
+    get_wireless_interfaces,
     get_monitor_interfaces,
+    
+    # Controle de modo monitor
     set_monitor_mode,
     restore_network_interface,
     start_monitor_mode,
     stop_monitor_mode,
-    run_command_async,
-    randomize_mac,
+    
+    # Funções de interface
     get_interface_mac,
     get_interface_ip,
     get_interface_netmask,
     get_interface_gateway,
     is_wireless_interface,
-    get_interface_signal,
-    get_interface_ssid,
-    get_interface_channel,
-    get_interface_bitrate,
-    create_deauth_packet,
-    parse_airodump_csv,
-    parse_airodump_stations,
+    
+    # Utilitários de linha de comando
     run_command,
-    command_exists
+    run_command_async,
+    command_exists,
 )
 
+# Exportar apenas a API pública
 __all__ = [
+    # Scanner
     'WiFiScanner',
+    
+    # Sistema de ataques
+    'Attack',
+    'register_attack',
+    'get_attack',
+    'list_attacks',
+    
+    # Ataques
     'WPSAttack',
     'WPAHandshakeAttack',
     'PMKIDAttack',
     'WEPAttack',
     'DeauthAttack',
     'HandshakeCapture',
+    
+    # Funções de utilidade
     'is_root',
     'check_dependencies',
-    'command_exists',
     'get_network_interfaces',
+    'get_wireless_interfaces',
     'get_monitor_interfaces',
     'set_monitor_mode',
     'restore_network_interface',
@@ -66,15 +88,7 @@ __all__ = [
     'get_interface_netmask',
     'get_interface_gateway',
     'is_wireless_interface',
-    'get_interface_signal',
-    'get_interface_ssid',
-    'get_interface_channel',
-    'get_interface_bitrate',
-    'create_deauth_packet',
-    'parse_airodump_csv',
-    'parse_airodump_stations',
     'run_command',
     'run_command_async',
-    'randomize_mac',
-    'get_wireless_interfaces'
+    'command_exists',
 ]

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

@@ -1,19 +1,146 @@
 """
-Attack modules for WifiPPLER.
+Módulo de Ataques do WiFiPPLER.
+
+Implementa um sistema de registro de ataques para permitir descoberta dinâmica
+e execução de diferentes tipos de ataques de segurança WiFi.
+
+Este módulo utiliza o padrão de registro para permitir que novos ataques sejam
+facilmente adicionados ao sistema sem modificar o código existente.
+
+Exemplo de uso:
+    >>> # Registrar um novo tipo de ataque
+    >>> @register_attack
+    >>> class MeuAtaque:
+    ...     name = "meu_ataque"
+    ...     description = "Descrição do meu ataque personalizado"
+    ...     
+    ...     def run(self, *, iface: str, target: Optional[str] = None, **kwargs):
+    ...         # Implementação do ataque
+    ...         pass
+    
+    >>> # Obter um ataque pelo nome
+    >>> ataque_cls = get_attack("meu_ataque")
+    >>> if ataque_cls:
+    ...     ataque = ataque_cls()
+    ...     ataque.run(iface="wlan0", target="00:11:22:33:44:55")
 """
+from typing import Dict, Type, Protocol, Optional, Any, TypeVar
 
-from .wps import WPSAttack
-from .wpa import WPAHandshakeAttack
-from .pmkid import PMKIDAttack
-from .wep import WEPAttack
+# Tipo genérico para a classe Attack
+T = TypeVar('T', bound='Attack')
+
+class Attack(Protocol):
+    """Protocolo que define a interface para todos os ataques.
+    
+    Para criar um novo ataque, crie uma classe que implemente este protocolo
+    e use o decorador @register_attack para registrá-lo.
+    """
+    # Nome único do ataque (deve ser um identificador em minúsculas com underscores)
+    name: str
+    
+    # Descrição do ataque (aparecerá na lista de ataques disponíveis)
+    description: str = ""
+    
+    def run(self, *, iface: str, target: Optional[str] = None, **kwargs: Any) -> None:
+        """Executa o ataque.
+        
+        Args:
+            iface: Interface de rede a ser usada (ex: 'wlan0')
+            target: Alvo do ataque (opcional, pode ser um endereço MAC, BSSID, etc.)
+            **kwargs: Argumentos adicionais específicos do ataque
+            
+        Raises:
+            Exception: Se ocorrer um erro durante a execução do ataque
+        """
+        ...
+
+# Registro global de ataques
+REGISTRY: Dict[str, Type[Attack]] = {}
+
+def register_attack(attack_cls: Type[T]) -> Type[T]:
+    """Decorador para registrar uma classe de ataque.
+    
+    Exemplo:
+        >>> @register_attack
+        >>> class MeuAtaque:
+        ...     name = "meu_ataque"
+        ...     description = "Descrição do meu ataque"
+        ...     def run(self, *, iface: str, **kwargs):
+        ...         pass
+    
+    Args:
+        attack_cls: Classe de ataque a ser registrada. Deve implementar o protocolo Attack.
+        
+    Returns:
+        A própria classe de ataque, permitindo uso como decorador
+        
+    Raises:
+        ValueError: Se o nome do ataque já estiver registrado
+    """
+    if not hasattr(attack_cls, 'name') or not attack_cls.name:
+        raise ValueError(f"A classe {attack_cls.__name__} deve definir um atributo 'name'")
+        
+    if attack_cls.name in REGISTRY:
+        raise ValueError(f"Já existe um ataque registrado com o nome '{attack_cls.name}'")
+        
+    REGISTRY[attack_cls.name] = attack_cls
+    return attack_cls
+
+def get_attack(name: str) -> Optional[Type[Attack]]:
+    """Obtém uma classe de ataque pelo nome.
+    
+    Args:
+        name: Nome do ataque a ser recuperado (case-sensitive)
+        
+    Returns:
+        A classe de ataque correspondente ou None se não encontrado
+        
+    Example:
+        >>> ataque_cls = get_attack("deauth")
+        >>> if ataque_cls:
+        ...     ataque = ataque_cls()
+        ...     ataque.run(iface="wlan0", target="00:11:22:33:44:55")
+    """
+    return REGISTRY.get(name)
+
+def list_attacks() -> Dict[str, str]:
+    """Lista todos os ataques registrados.
+    
+    Returns:
+        Dicionário onde as chaves são os nomes dos ataques e os valores são suas descrições
+        
+    Example:
+        >>> for nome, descricao in list_attacks().items():
+        ...     print(f"{nome}: {descricao}")
+    """
+    return {name: cls.description for name, cls in REGISTRY.items()}
+
+# Importa os módulos de ataque para registrar as classes automaticamente
+# A ordem de importação é importante para evitar importações circulares
 from .deauth import DeauthAttack
 from .handshake import HandshakeCapture
+from .pmkid import PMKIDAttack
+from .wep import WEPAttack
+from .wpa import WPAHandshakeAttack
+from .wps import WPSAttack
 
+# Exporta a API pública
 __all__ = [
-    'WPSAttack',
-    'WPAHandshakeAttack',
+    # Interface e registro
+    'Attack',
+    'register_attack',  # Alias para register para melhor clareza
+    'get_attack',
+    'list_attacks',
+    'register',         # Mantido para compatibilidade
+    
+    # Ataques específicos
+    'DeauthAttack',
+    'HandshakeCapture',
     'PMKIDAttack',
     'WEPAttack',
-    'DeauthAttack',
-    'HandshakeCapture'
+    'WPAHandshakeAttack',
+    'WPSAttack',
+    
+    # Registro interno (exposto apenas para testes)
+    'REGISTRY',
 ]