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:
- non è cifrato: chiunque sul percorso di rete può leggerlo;
- va a una terza parte: esce dal tuo controllo, e dipendi dalle abitudini di un'altra azienda;
- viene tenuto troppo a lungo: la conservazione manca (per sempre) o supera i 365 giorni;
- 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.
Il codice di partenza contiene FLOWS, la mappa dei dati dell'app di esercitazione plantly.example. Scrivi due funzioni:
risk_reasons(flow)restituisce una lista di stringhe di avvertimento per un flusso. Seflow["personal"]è falso, restituisci una lista vuota. Altrimenti aggiungi, in quest'ordine:"not encrypted"seflow["encrypted"]è falso;"third party"seflow["third_party"]è vero;"kept too long"seretention_daysmanca, èNone, o supera 365;"no purpose"sepurposemanca o è una stringa vuota.
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.
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.
Questo browser blocca i cookie per learn.floati.life, quindi le lezioni che hai finito qui non si possono aprire in ordine. Consenti i cookie per questo sito e ricarica.