duck_windows_virus.py

"""
Vírus Simbólico do Patinho - Versão Windows
Este código é puramente educacional e demonstra como um programa pode
interagir com o cursor do mouse no Windows.

AVISO: Este código deve ser usado apenas para fins educacionais em ambientes controlados.
"""

import tkinter as tk
from PIL import Image, ImageTk
import ctypes
from ctypes import wintypes
import time
import threading
import os

# Comentários linha a linha:
# import tkinter as tk: Biblioteca padrão do Python para criar interfaces gráficas
# from PIL import Image, ImageTk: Biblioteca Pillow para manipulação de imagens
# import ctypes: Biblioteca para chamar funções da API do Windows
# from ctypes import wintypes: Tipos de dados específicos do Windows
# import time: Para controlar o tempo e pausas
# import threading: Para executar tarefas em paralelo
# import os: Para operações do sistema operacional

class WindowsDuckVirus:
    def __init__(self):
        # Construtor da classe que inicializa o "vírus" do patinho
        
        # Configurações da API do Windows usando ctypes
        # user32.dll contém funções para manipular janelas, cursor e entrada do usuário
        self.user32 = ctypes.windll.user32
        
        # Definindo tipos de dados para as funções da API do Windows
        # Isso garante que os parâmetros sejam passados corretamente
        self.user32.SetCursorPos.argtypes = [ctypes.c_int, ctypes.c_int]
        self.user32.SetCursorPos.restype = wintypes.BOOL
        
        self.user32.GetCursorPos.argtypes = [ctypes.POINTER(wintypes.POINT)]
        self.user32.GetCursorPos.restype = wintypes.BOOL
        
        self.user32.ShowCursor.argtypes = [wintypes.BOOL]
        self.user32.ShowCursor.restype = ctypes.c_int
        
        # BlockInput é uma função poderosa que pode bloquear toda entrada do usuário
        # CUIDADO: Esta função pode tornar o sistema inutilizável se mal utilizada
        self.user32.BlockInput.argtypes = [wintypes.BOOL]
        self.user32.BlockInput.restype = wintypes.BOOL
        
        # Variáveis de controle
        self.running = True
        self.duck_window = None
        self.duck_x = 0
        self.duck_y = 0
        self.movement_speed = 2  # Velocidade do movimento do patinho
        
        # Direção do movimento (para fazer o patinho "andar")
        self.direction_x = 1
        self.direction_y = 1
        
    def hide_system_cursor(self):
        """
        Oculta o cursor do sistema usando a API do Windows
        ShowCursor(FALSE) decrementa o contador de exibição do cursor
        Quando o contador chega a -1 ou menos, o cursor fica invisível
        """
        # ShowCursor(False) oculta o cursor do sistema
        # Retorna o novo valor do contador de exibição
        cursor_count = self.user32.ShowCursor(False)
        print(f"Cursor oculto. Contador: {cursor_count}")
        
    def show_system_cursor(self):
        """
        Mostra o cursor do sistema novamente
        ShowCursor(TRUE) incrementa o contador de exibição do cursor
        """
        # ShowCursor(True) mostra o cursor do sistema
        cursor_count = self.user32.ShowCursor(True)
        print(f"Cursor restaurado. Contador: {cursor_count}")
        
    def get_cursor_position(self):
        """
        Obtém a posição atual do cursor usando a API do Windows
        """
        # POINT é uma estrutura que contém coordenadas x e y
        point = wintypes.POINT()
        # GetCursorPos preenche a estrutura POINT com as coordenadas atuais
        if self.user32.GetCursorPos(ctypes.byref(point)):
            return point.x, point.y
        return 0, 0
        
    def set_cursor_position(self, x, y):
        """
        Define a posição do cursor usando a API do Windows
        """
        # SetCursorPos move o cursor para as coordenadas especificadas
        self.user32.SetCursorPos(x, y)
        
    def block_user_input(self, block=True):
        """
        Bloqueia ou desbloqueia a entrada do usuário (mouse e teclado)
        CUIDADO: Esta função pode tornar o sistema inutilizável!
        """
        # BlockInput(True) bloqueia toda entrada do usuário
        # BlockInput(False) desbloqueia a entrada
        # NOTA: Esta função requer privilégios elevados para funcionar
        result = self.user32.BlockInput(block)
        if result:
            status = "bloqueada" if block else "desbloqueada"
            print(f"Entrada do usuário {status}")
        else:
            print("Falha ao alterar o bloqueio de entrada (pode precisar de privilégios de administrador)")
            
    def create_duck_window(self):
        """
        Cria a janela transparente com o patinho
        """
        # Cria a janela principal do Tkinter
        self.duck_window = tk.Tk()
        
        # Remove a barra de título e bordas da janela
        self.duck_window.overrideredirect(True)
        
        # Mantém a janela sempre no topo
        self.duck_window.wm_attributes("-topmost", True)
        
        # Torna o fundo transparente (funciona melhor no Windows)
        self.duck_window.wm_attributes("-transparentcolor", "white")
        
        # Define o fundo da janela como branco (que será transparente)
        self.duck_window.configure(bg='white')
        
        try:
            # Carrega a imagem do patinho
            # Certifique-se de que o arquivo duck_follower.png existe no mesmo diretório
            duck_image = Image.open("duck_follower.png")
            
            # Redimensiona a imagem para um tamanho adequado
            duck_image = duck_image.resize((64, 64), Image.Resampling.LANCZOS)
            
            # Converte para formato compatível com Tkinter
            self.duck_photo = ImageTk.PhotoImage(duck_image)
            
            # Cria um label para exibir a imagem
            self.duck_label = tk.Label(
                self.duck_window, 
                image=self.duck_photo, 
                bg='white',  # Fundo branco (transparente)
                bd=0
            )
            self.duck_label.pack()
            
        except FileNotFoundError:
            # Se a imagem não for encontrada, cria um texto simples
            self.duck_label = tk.Label(
                self.duck_window, 
                text="🦆", 
                font=("Arial", 48),
                bg='white',
                fg='orange',
                bd=0
            )
            self.duck_label.pack()
            
        # Obtém a posição inicial do cursor
        self.duck_x, self.duck_y = self.get_cursor_position()
        
        # Posiciona a janela do patinho
        self.update_duck_position()
        
    def update_duck_position(self):
        """
        Atualiza a posição da janela do patinho
        """
        if self.duck_window:
            # Centraliza o patinho nas coordenadas atuais
            window_x = self.duck_x - 32  # Metade do tamanho da imagem (64/2)
            window_y = self.duck_y - 32
            
            # Move a janela para a nova posição
            self.duck_window.geometry(f"+{window_x}+{window_y}")
            
    def duck_movement_thread(self):
        """
        Thread que controla o movimento do patinho
        Esta função roda em paralelo e faz o patinho "andar" pela tela
        """
        # Obtém as dimensões da tela
        screen_width = self.user32.GetSystemMetrics(0)  # SM_CXSCREEN
        screen_height = self.user32.GetSystemMetrics(1)  # SM_CYSCREEN
        
        print(f"Dimensões da tela: {screen_width}x{screen_height}")
        
        while self.running:
            # Calcula a nova posição do patinho
            self.duck_x += self.direction_x * self.movement_speed
            self.duck_y += self.direction_y * self.movement_speed
            
            # Verifica os limites da tela e inverte a direção se necessário
            if self.duck_x <= 0 or self.duck_x >= screen_width - 64:
                self.direction_x *= -1
                
            if self.duck_y <= 0 or self.duck_y >= screen_height - 64:
                self.direction_y *= -1
                
            # Mantém o patinho dentro dos limites da tela
            self.duck_x = max(32, min(self.duck_x, screen_width - 32))
            self.duck_y = max(32, min(self.duck_y, screen_height - 32))
            
            # Move o cursor real para seguir o patinho (simula o "roubo")
            self.set_cursor_position(self.duck_x, self.duck_y)
            
            # Atualiza a posição da janela do patinho
            if self.duck_window:
                try:
                    self.duck_window.after(0, self.update_duck_position)
                except tk.TclError:
                    # A janela foi fechada
                    break
                    
            # Pausa antes da próxima atualização
            time.sleep(0.05)  # 50ms = ~20 FPS
            
    def start_virus(self):
        """
        Inicia o "vírus" do patinho
        """
        print("Iniciando o vírus do patinho...")
        print("AVISO: O cursor será 'roubado' pelo patinho!")
        print("Pressione Ctrl+C no terminal para parar o programa")
        
        try:
            # Cria a janela do patinho
            self.create_duck_window()
            
            # Oculta o cursor do sistema
            self.hide_system_cursor()
            
            # Inicia a thread de movimento do patinho
            movement_thread = threading.Thread(target=self.duck_movement_thread)
            movement_thread.daemon = True  # Thread será encerrada quando o programa principal terminar
            movement_thread.start()
            
            # Inicia o loop principal do Tkinter
            self.duck_window.mainloop()
            
        except KeyboardInterrupt:
            print("\nParando o vírus do patinho...")
            self.stop_virus()
            
        except Exception as e:
            print(f"Erro: {e}")
            self.stop_virus()
            
    def stop_virus(self):
        """
        Para o "vírus" e restaura o sistema
        """
        print("Restaurando o sistema...")
        
        # Para o loop de movimento
        self.running = False
        
        # Restaura o cursor do sistema
        self.show_system_cursor()
        
        # Desbloqueia a entrada do usuário (se estava bloqueada)
        self.block_user_input(False)
        
        # Fecha a janela do patinho
        if self.duck_window:
            try:
                self.duck_window.destroy()
            except:
                pass
                
        print("Sistema restaurado!")

# Função principal
def main():
    """
    Função principal que executa o vírus do patinho
    """
    print("=" * 50)
    print("VÍRUS SIMBÓLICO DO PATINHO - VERSÃO WINDOWS")
    print("=" * 50)
    print("Este é um programa educacional que demonstra")
    print("como um malware pode 'roubar' o cursor do mouse.")
    print()
    print("CUIDADO: Este programa irá:")
    print("1. Ocultar o cursor real do sistema")
    print("2. Mover o cursor automaticamente")
    print("3. Exibir um patinho que 'rouba' o cursor")
    print()
    print("Para parar o programa, pressione Ctrl+C no terminal")
    print("=" * 50)
    
    # Pergunta se o usuário quer continuar
    response = input("Deseja continuar? (s/N): ").lower().strip()
    
    if response in ['s', 'sim', 'y', 'yes']:
        # Cria uma instância do vírus do patinho
        duck_virus = WindowsDuckVirus()
        
        try:
            # Inicia o vírus
            duck_virus.start_virus()
        except KeyboardInterrupt:
            print("\nPrograma interrompido pelo usuário")
            duck_virus.stop_virus()
    else:
        print("Programa cancelado pelo usuário.")

# Executa o programa apenas se for chamado diretamente
if __name__ == "__main__":
    main()