Mantenere sicuri i file utente mentre consente a un'applicazione Web di utilizzare i file

1

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:

  1. L'utente crea una coppia di chiavi pubblica / privata (con alcuni strumenti di terze parti)
  2. L'utente carica la chiave pubblica nel sistema
  3. L'utente carica il file (il file rimane in memoria per ora)
  4. Il sistema genera una chiave condivisa per crittografare il file
  5. Il sistema crittografa il file con la chiave condivisa
  6. Il sistema memorizza il file
  7. Il sistema crittografa la chiave condivisa con la chiave pubblica
  8. 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:

  1. L'utente avvia un'attività che richiede un file crittografato
  2. L'utente carica la chiave privata (rimane solo in memoria)
  3. Il sistema decrittografa la chiave condivisa (rimane solo in memoria)
  4. Il sistema cancella la chiave privata dalla memoria
  5. Il sistema decrittografa il file in memoria
  6. Il sistema cancella la chiave condivisa decrittata dalla memoria
  7. Il sistema completa l'attività
  8. Il sistema cancella il file decifrato dalla memoria
  9. 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?

    
posta FableBlaze 14.01.2016 - 23:54
fonte

2 risposte

1

Per la seconda parte, puoi fare sensibilmente meglio:

  1. (La sessione tra Utente e Sistema è crittografata)
  2. L'utente avvia un'attività che richiede un file crittografato
  3. Il sistema invia la chiave condivisa crittografata
  4. L'utente decrittografa localmente la chiave condivisa
  5. L'utente invia la chiave condivisa decodificata (rimane solo in memoria)
  6. Il sistema decrittografa il file in memoria
  7. Il sistema cancella la chiave condivisa decrittata dalla memoria
  8. Il sistema completa l'attività
  9. Il sistema cancella il file decifrato dalla memoria
  10. Il sistema memorizza il risultato dell'attività

Dovresti assicurarti che la memoria della routine che esegue l'attività non sia accessibile da altri thread sul servizio del sistema, se ti capita di servire più client sullo stesso sistema, usando tecniche di compartimentazione come COWL (non sono sicuro del suo stato di implementazione) o forse Capsicum .

Penso strongmente al calcolo sicuro di più parti e crittografia nomomorfa durante la lettura del problema. Non sono esperto, quindi non mi soffermerò su questo. Potrebbero esserci modi, a seconda di cosa è necessario calcolare, per eseguire il calcolo senza dover in realtà decodificare i file. Ciò potrebbe anche essere ottenuto facendo in modo che i client calcolino e caricino le proprietà crittografate sui file anziché sui file stessi.

Ci sono probabilmente un sacco di altri design e, si spera, qualcuno indicherà un approccio migliore.

    
risposta data 15.01.2016 - 00:17
fonte
1

Non caricare la chiave privata sul server.

Invece, invia la chiave condivisa crittografata all'utente. L'utente può quindi decifrare con la chiave privata, che rimane sul sistema dell'utente.

Quindi, l'utente invia la chiave condivisa decodificata al server.

    
risposta data 15.01.2016 - 00:17
fonte

Leggi altre domande sui tag