Introdução
A modelagem de ameaças é uma forma prática de pensar sobre o que pode dar errado antes que um sistema seja atacado. Em vez de começar pelas ferramentas, você primeiro identifica o que precisa de proteção, onde os dados cruzam limites de confiança, como um invasor poderia se mover pelo sistema e quais controles reduzem o risco.
Neste laboratório, você inspecionará um pequeno serviço de login local e completará um modelo de ameaças estruturado no arquivo security-model.json. O modelo não é um relatório de formato livre: cada etapa adiciona entradas JSON específicas que podem ser verificadas por um script de validação.
Inspecionar o Serviço de Login
Nesta etapa, você inspecionará o pequeno serviço que irá modelar. Um modelo de ameaças começa a partir do comportamento observável do sistema: o que a aplicação faz, quais arquivos utiliza e quais informações podem ser relevantes para um invasor.
Primeiro, entre no diretório do projeto:
cd /home/labex/project
Liste os arquivos preparados:
ls -l
Você deverá ver arquivos como app.py, users.json, sessions.json, security-model.json e o diretório uploads.
Agora, peça à aplicação de demonstração para mostrar suas rotas. Uma rota é um ponto de entrada da aplicação que aceita algum tipo de solicitação:
python3 app.py routes
A saída deve mostrar quatro rotas:
/login - aceita um nome de usuário e senha, então cria um token de sessão
/files - lista arquivos que pertencem ao usuário logado
/download - lê um nome de arquivo solicitado do diretório uploads
/admin - mostra registros de conta apenas para administradores
Por fim, execute o verificador de modelo atual. Ele informará que faltam seções, pois o modelo está intencionalmente vazio:
python3 model-check.py all
Você verá mensagens indicando que cada seção não possui as entradas necessárias. Este é o ponto de partida para o restante do laboratório.
Identificar os Ativos
Nesta etapa, você adicionará ativos ao modelo. Na modelagem de ameaças, um ativo é tudo o que o sistema deve proteger. Para este serviço de login, os ativos importantes não são apenas arquivos; eles também incluem dados de autenticação e o estado da sessão.
Use o comando cat para inspecionar o banco de dados de usuários:
cat users.json
O arquivo contém nomes de usuário, senhas e funções (roles). Isso torna user_credentials e admin_records ativos importantes.
Inspecione o arquivo de sessão e o diretório de uploads:
cat sessions.json
ls -l uploads
O arquivo de sessão pode conter tokens de login, e o diretório uploads contém conteúdo privado do usuário. Eles correspondem a session_tokens e private_uploads.
Agora, atualize o array assets no arquivo security-model.json. O comando abaixo utiliza um here-document do Python. Um here-document envia as linhas entre os marcadores PY para o python3 como um script curto:
python3 - <<'PY'
import json
from pathlib import Path
path = Path("security-model.json")
model = json.loads(path.read_text())
model["assets"] = [
"user_credentials",
"session_tokens",
"private_uploads",
"admin_records",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY
Verifique apenas a seção de ativos:
python3 model-check.py assets
O resultado esperado é:
assets: complete
Mapear Limites de Confiança
Nesta etapa, você adicionará limites de confiança (trust boundaries). Um limite de confiança é um local onde os dados se movem entre áreas com diferentes níveis de controle ou confiança. Os limites são úteis porque muitos ataques ocorrem quando entradas não confiáveis cruzam para códigos, arquivos ou funções privilegiadas.
Observe novamente a lista de rotas:
python3 app.py routes
As rotas /login, /files e /download recebem entrada do lado do usuário e a passam para a lógica do servidor. Esse é o limite browser_to_server neste pequeno modelo.
A rota /download lê nomes da solicitação e então acessa o diretório uploads. Isso cria um limite server_to_filesystem. A rota /admin separa usuários normais de dados exclusivos de administradores, criando assim um limite user_to_admin_area.
Adicione esses limites ao modelo:
python3 - <<'PY'
import json
from pathlib import Path
path = Path("security-model.json")
model = json.loads(path.read_text())
model["trust_boundaries"] = [
"browser_to_server",
"server_to_filesystem",
"user_to_admin_area",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY
Verifique a seção de limites de confiança:
python3 model-check.py trust_boundaries
O resultado esperado é:
trust_boundaries: complete
Adicionar Vetores de Ataque
Nesta etapa, você adicionará vetores de ataque (attack paths). Um vetor de ataque é uma forma concreta pela qual um invasor pode se mover de um ponto de entrada em direção a um ativo. Este é o núcleo da modelagem de ameaças: conectar ativos e limites ao comportamento realista do invasor.
Tente uma tentativa de login com as credenciais de demonstração:
python3 app.py login alice wonderland
A saída é um token de sessão:
session-alice-demo
Este comportamento mostra por que senhas e tokens de sessão são importantes. Uma senha fraca pode permitir credential_guessing (adivinhação de credenciais), e um token roubado pode permitir session_token_theft (roubo de token de sessão).
A rota /download aceita um nome de arquivo solicitado, portanto, uma implementação descuidada pode permitir path_traversal (travessia de diretório). A rota /admin protege registros de administrador, então a falta de verificações de função pode permitir admin_area_abuse (abuso da área administrativa).
Adicione esses vetores de ataque ao modelo:
python3 - <<'PY'
import json
from pathlib import Path
path = Path("security-model.json")
model = json.loads(path.read_text())
model["attack_paths"] = [
"credential_guessing",
"session_token_theft",
"path_traversal",
"admin_area_abuse",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY
Verifique a seção de vetores de ataque:
python3 model-check.py attack_paths
O resultado esperado é:
attack_paths: complete
Escolher Mitigações
Nesta etapa, você finalizará o modelo adicionando mitigações. Uma mitigação é um controle que reduz a probabilidade ou o impacto de um vetor de ataque. Bons modelos de ameaças combinam cada vetor de ataque importante com pelo menos um controle prático.
Use estas combinações para o pequeno serviço de login:
credential_guessingpode ser reduzido porrate_limit_login.session_token_theftpode ser reduzido porprotect_session_tokens.path_traversalpode ser reduzido porvalidate_download_paths.admin_area_abusepode ser reduzido porenforce_admin_authorization.
Adicione as mitigações ao modelo:
python3 - <<'PY'
import json
from pathlib import Path
path = Path("security-model.json")
model = json.loads(path.read_text())
model["mitigations"] = [
"rate_limit_login",
"protect_session_tokens",
"validate_download_paths",
"enforce_admin_authorization",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY
Agora, execute a verificação completa do modelo:
python3 model-check.py all
Cada seção deve estar completa:
assets: complete
trust_boundaries: complete
attack_paths: complete
mitigations: complete
Você também pode visualizar o modelo estruturado final:
cat security-model.json
O resultado importante é que o modelo agora conecta ativos protegidos, limites de confiança, vetores de ataque e mitigações para o mesmo pequeno serviço.
Resumo
Você praticou um fluxo de trabalho prático de modelagem de ameaças em um pequeno serviço de login. Você inspecionou o serviço, identificou ativos, mapeou limites de confiança, adicionou vetores de ataque e combinou esses vetores com mitigações em um modelo JSON estruturado.
Este fluxo de trabalho ajuda a conectar o pensamento de segurança ao comportamento observável do sistema, em vez de tratar a modelagem de ameaças como um relatório escrito separado.
