Conteúdo do curso Lição 94 de 156 · Modelagem de ameaças
Modelagem de ameaças

Modelos de ameaças de produtos

Por que isso importa Quando você constrói um app, os problemas de privacidade se escondem nas setas: os momentos em que os dados se movem de um lugar para outro. Anotar esses movimentos como dados, e depois deixar o código conferi-los, encontra os arriscados antes que os seus usuários encontrem. É o hábito que engenheiros de privacidade usam em produtos reais.

Seguindo a encomenda

Pense em cada dado pessoal como uma encomenda. Um modelo de ameaças para um produto pergunta: para onde vai cada encomenda, ela vai lacrada no caminho, quem a recebe e por quanto tempo a guarda? Um fluxo de dados é a viagem de uma encomenda.

Um fluxo no produto de prática abaixo está marcado como não pessoal: o relatório de falhas, "versão do app e pilha da falha". Isso deixa o laboratório simples, mas trate-o como um alerta, não como uma regra: relatórios de falhas reais muitas vezes levam dados pessoais (um caminho de arquivo com um nome de usuário, o texto de um formulário quando o app travou, um endereço de e-mail numa linha de log), então numa revisão real um relatório de falhas é pessoal até você conferir.

Fluxo de dados: um movimento de dados de um lugar para outro, por exemplo "o e-mail de cadastro vai do app para o nosso servidor" ou "as visualizações de página vão do app para um serviço de análise".

Terceiro: qualquer empresa ou serviço que não seja você nem o seu usuário. Um provedor de análise, uma rede de anúncios, um serviço de envio de e-mails.

Retenção: por quanto tempo os dados são guardados antes de serem apagados. "Para sempre" também é um período de retenção, e normalmente o pior.

Fluxos como dados em Python

Cada fluxo cabe naturalmente num dicionário. Aqui está um de um app inventado de cuidado com plantas, plantly.example:

flow = {
    "id": "photo-upload",
    "data": "plant photos with location",
    "personal": True,          # does it point to a person?
    "to": "plantly.example",
    "third_party": False,      # is the receiver someone other than us?
    "encrypted": True,         # sent over HTTPS (or similar)?
    "retention_days": 90,      # None means kept forever
    "purpose": "identify plant disease",
}

Uma ferramenta útil: flow.get("retention_days") lê uma chave como flow["retention_days"] faz, mas retorna None em vez de quebrar quando a chave não existe. Os testes usam fluxos com chaves faltando, então você vai precisar disso.

Uma lista desses dicionários é o mapa de dados de um produto inteiro. Quando ele vira dados, você pode conferir cada fluxo com as mesmas regras, toda vez que algo mudar.

Quatro sinais de alerta

Só os fluxos pessoais importam aqui: um fluxo que não leva nada sobre uma pessoa não consegue vazar nada sobre ela. Para um fluxo pessoal, marque-o quando:

  1. não criptografado: qualquer um no caminho da rede consegue lê-lo;
  2. terceiro: ele sai do seu controle, e você depende dos hábitos de outra empresa;
  3. guardado por tempo demais: a retenção não existe (para sempre) ou passa de 365 dias;
  4. sem finalidade: ninguém anotou por que ele é coletado. Se você não consegue dizer por quê, provavelmente não deveria coletá-lo.

Um fluxo marcado não está automaticamente errado. Enviar e-mails por um serviço de e-mail é um fluxo de terceiros que você pode muito bem manter. A marcação significa "uma pessoa precisa olhar isto e decidir", que é exatamente para que serve um modelo de ameaças.

Um equívoco comum

"Se está criptografado, está seguro." A criptografia protege a viagem. Ela não diz nada sobre quem recebe os dados nem por quanto tempo os guarda. Um fluxo pode estar criptografado e ainda ser o mais arriscado do seu app.

Em outras linguagens

JavaScript: as mesmas regras sobre um array de objetos.

function riskReasons(f) {
  if (!f.personal) return [];
  const r = [];
  if (!f.encrypted) r.push("not encrypted");
  if (f.third_party) r.push("third party");
  if (f.retention_days == null || f.retention_days > 365) r.push("kept too long");
  if (!f.purpose) r.push("no purpose");
  return r;
}
const flagged = Object.fromEntries(
  flows.map(f => [f.id, riskReasons(f)]).filter(([, r]) => r.length)
);

Go: uma struct com um ponteiro para a retenção "que pode faltar".

type Flow struct {
    ID, Purpose                     string
    Personal, ThirdParty, Encrypted bool
    RetentionDays                   *int // nil means forever
}

Resumo

  • Um fluxo de dados é um movimento de dados; uma lista de fluxos é o mapa de dados de um produto.
  • Escrever os fluxos como dicionários permite que o código confira cada um com as mesmas regras.
  • Marque os fluxos pessoais que não são criptografados, vão para um terceiro, são guardados por tempo demais ou não têm finalidade.
  • Uma marcação significa "uma pessoa decide", e a criptografia sozinha não torna um fluxo seguro.
Sua vez

O código inicial guarda FLOWS, o mapa de dados do app de prática plantly.example. Escreva duas funções:

  1. risk_reasons(flow) retorna uma lista de strings de alerta para um fluxo. Se flow["personal"] for falso, retorne uma lista vazia. Senão, adicione, nesta ordem:
    • "not encrypted" se flow["encrypted"] for falso;
    • "third party" se flow["third_party"] for verdadeiro;
    • "kept too long" se retention_days estiver faltando, for None ou passar de 365;
    • "no purpose" se purpose estiver faltando ou for uma string vazia.
  2. flag_risky(flows) retorna um dicionário que mapeia o "id" de cada fluxo marcado para a lista de motivos dele. Fluxos sem motivos ficam de fora.
Use flow.get(...) para que uma chave faltando não quebre nada. Por fim, imprima cada id marcado e os motivos dele, um por linha.

Viu um problema nesta lição? Reporte-o · Pergunte sobre esta lição

Este exercício abre em breve

Termine a lição anterior para que esta seja desbloqueada. O curso inteiro é gratuito, não precisa de conta, e você pode ler esta lição agora mesmo.