Programma Lezione 94 di 156 · Modellare le minacce
Modellare le minacce

Modelli delle minacce di un prodotto

Perché è importante Quando costruisci un'app, i problemi di privacy si nascondono nelle frecce: i momenti in cui i dati si spostano da un posto all'altro. Mettere per iscritto questi spostamenti come dati, e poi lasciare che il codice li controlli, trova quelli rischiosi prima che li trovino i tuoi utenti. È l'abitudine che usano gli ingegneri della privacy sui prodotti veri.

Seguire il pacco

Pensa a ogni dato personale come a un pacco. Un modello delle minacce di un prodotto chiede: dove va ogni pacco, è sigillato lungo la strada, chi lo riceve, e per quanto lo tiene? Un flusso di dati è il viaggio di un pacco.

Un flusso nel prodotto di esercitazione qui sotto è segnato come non personale: il rapporto sui crash, "versione dell'app e stack del crash". Tiene semplice il laboratorio, ma trattalo come un avvertimento, non come una regola: i rapporti sui crash veri spesso portano dati personali (un percorso di file con un nome utente, il testo di un modulo quando l'app è andata in crash, un indirizzo email in una riga di registro), quindi in una revisione vera un rapporto sui crash è personale finché non l'hai controllato.

Flusso di dati: uno spostamento di dati da un posto all'altro, per esempio "l'email dell'iscrizione va dall'app al nostro server" o "le visualizzazioni delle pagine vanno dall'app a un servizio di statistiche".

Terza parte: qualsiasi azienda o servizio che non sei tu o il tuo utente. Un fornitore di statistiche, una rete pubblicitaria, un servizio che invia email.

Conservazione: per quanto tempo i dati vengono tenuti prima di essere cancellati. Anche "per sempre" è un periodo di conservazione, e di solito il peggiore.

I flussi come dati Python

Ogni flusso sta naturalmente in un dizionario. Eccone uno da un'app inventata per la cura delle piante, 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",
}

Uno strumento comodo: flow.get("retention_days") legge una chiave come fa flow["retention_days"], ma restituisce None invece di andare in crash quando la chiave manca. I test usano flussi con chiavi mancanti, quindi ti servirà.

Una lista di questi dizionari è la mappa dei dati di un intero prodotto. Quando è fatta di dati, puoi controllare ogni flusso con le stesse regole, ogni volta che cambia qualcosa.

Quattro segnali d'allarme

Qui contano solo i flussi personali: un flusso che non porta niente su una persona non può far trapelare niente su di lei. Per un flusso personale, segnalalo quando:

  1. non è cifrato: chiunque sul percorso di rete può leggerlo;
  2. va a una terza parte: esce dal tuo controllo, e dipendi dalle abitudini di un'altra azienda;
  3. viene tenuto troppo a lungo: la conservazione manca (per sempre) o supera i 365 giorni;
  4. non ha uno scopo: nessuno ha scritto perché viene raccolto. Se non sai dire perché, probabilmente non dovresti raccoglierlo.

Un flusso segnalato non è automaticamente sbagliato. Inviare email tramite un servizio di email è un flusso verso una terza parte che potresti benissimo tenere. La segnalazione significa "una persona deve guardarlo e decidere", ed è esattamente lo scopo di un modello delle minacce.

Un equivoco comune

"Se è cifrato, è sicuro." La cifratura protegge il viaggio. Non dice niente su chi riceve i dati o per quanto li tiene. Un flusso può essere cifrato ed essere comunque il più rischioso della tua app.

In altri linguaggi

JavaScript: le stesse regole su un array di oggetti.

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: una struct con un puntatore per una conservazione che "potrebbe mancare".

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

Riepilogo

  • Un flusso di dati è uno spostamento di dati; una lista di flussi è la mappa dei dati di un prodotto.
  • Scrivere i flussi come dizionari permette al codice di controllarli tutti con le stesse regole.
  • Segnala i flussi personali che non sono cifrati, vanno a una terza parte, vengono tenuti troppo a lungo o non hanno uno scopo.
  • Una segnalazione significa "decide una persona", e la cifratura da sola non rende sicuro un flusso.
Tocca a te

Il codice di partenza contiene FLOWS, la mappa dei dati dell'app di esercitazione plantly.example. Scrivi due funzioni:

  1. risk_reasons(flow) restituisce una lista di stringhe di avvertimento per un flusso. Se flow["personal"] è falso, restituisci una lista vuota. Altrimenti aggiungi, in quest'ordine:
    • "not encrypted" se flow["encrypted"] è falso;
    • "third party" se flow["third_party"] è vero;
    • "kept too long" se retention_days manca, è None, o supera 365;
    • "no purpose" se purpose manca o è una stringa vuota.
  2. flag_risky(flows) restituisce un dizionario che associa l'"id" di ogni flusso segnalato alla sua lista di motivi. I flussi senza motivi vengono lasciati fuori.
Usa flow.get(...) così una chiave mancante non manda in crash. Infine, stampa ogni id segnalato e i suoi motivi, uno per riga.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.