Breve background
Attualmente sto progettando un'applicazione web in cui l'utente carica alcuni file sul server e poi chiede al server di eseguire alcuni calcoli basati su questi file (l'attività può essere accodata se il carico di lavoro corrente è elevato). Quindi il server memorizza il risultato e lo rende disponibile per l'utente da visualizzare.
Questi file possono contenere dati privati e / o sensibili e quindi ho deciso di cercare modi per mantenere sicuri questi file sul lato server.
Ho svolto alcune ricerche su questo argomento ma non ho trovato la soluzione che sto cercando. Ho un'idea generale per il design, ma sento che è difettosa e che potrei reinventare la ruota (senza esperienza in questo campo).
Inizierò con i requisiti di base, quindi presenterò la mia idea e finirò con le domande che ho.
Requisiti di sicurezza
- Il sistema deve crittografare i file prima di archiviarli sul file system
- Gli amministratori di sistema, ecc. non devono essere in grado di decodificare i file proprio (il prossimo requisito ha la priorità su questo requisito)
- Il sistema deve essere in grado di decodificare i file solo se l'utente fornisce l'autenticazione
- Il sistema deve supportare più utenti simultanei con ciascun utente in grado di autenticare la decrittografia solo i file caricati da quell'utente.
Idea attuale
Memorizzare i file in modo tale che la decrittografia sia possibile solo per l'utente sembra abbastanza semplice. Attualmente sto pensando al seguente flusso di lavoro:
- L'utente crea una coppia di chiavi pubblica / privata (con alcuni strumenti di terze parti)
- L'utente carica la chiave pubblica nel sistema
- L'utente carica il file (il file rimane in memoria per ora)
- Il sistema genera una chiave condivisa per crittografare il file
- Il sistema crittografa il file con la chiave condivisa
- Il sistema memorizza il file
- Il sistema crittografa la chiave condivisa con la chiave pubblica
- Il sistema memorizza la chiave condivisa crittografata
Credo che questo approccio sia abbastanza comune e non abbia seri inconvenienti.
Ora la parte problematica. Dal momento che voglio che l'utente sia in grado di consentire al sistema di decodificare il file in alcune situazioni, questo è l'unico flusso di lavoro che ho trovato:
- L'utente avvia un'attività che richiede un file crittografato
- L'utente carica la chiave privata (rimane solo in memoria)
- Il sistema decrittografa la chiave condivisa (rimane solo in memoria)
- Il sistema cancella la chiave privata dalla memoria
- Il sistema decrittografa il file in memoria
- Il sistema cancella la chiave condivisa decrittata dalla memoria
- Il sistema completa l'attività
- Il sistema cancella il file decifrato dalla memoria
- Il sistema memorizza il risultato dell'attività
Domande
Anche se credo che questo approccio sarebbe funzionale, sono ancora preoccupato per un paio di cose:
- Non sono sicuro che il caricamento di una chiave privata come file normale possa essere considerato un'opzione valida? - Se non sbaglio, questo almeno va contro le solite norme.
- La chiave privata può essere trasferita in modo sicuro su Internet? - Sono incline a credere che possa, comunque non ho guardato nel jet esattamente come.
- Anche se il file crittografato (o la chiave privata) viene tenuto in memoria solo per il tempo minimo necessario, potrebbe comunque rappresentare un rischio per la sicurezza? - Sento che è ancora un rischio, ma non serio.
- Questo è già un problema risolto? - Se è così non sono riuscito a trovare le soluzioni
Come ultima osservazione vorrei aggiungere che sono pienamente consapevole che qualsiasi sistema di questo tipo richiederebbe fiducia agli utenti. Principalmente vorrei sapere se questo è possibile, la mia idea è valida e c'è un modo migliore / alternativo?