Security & Privacy
Creare un'app Android crittografata end-to-end conforme al GDPR

52min
Come creare un'app di chat conforme al GDPR
Introduzione
Ahoy comunità di Back4app!
Questo è un tutorial ospite del team di Virgil Security, Inc.: siamo la tecnologia crittografica dietro la messaggistica crittografata end-to-end di Twilio. I nostri amici di Back4app ci hanno chiesto di mostrarti come costruire un'app di chat crittografata end-to-end su Back4app.
In questo post, ti guideremo attraverso i passaggi per rendere un'app di messaggistica Android Back4App crittografata end-to-end! Sei pronto? PS: Se non ti interessano i dettagli, salta semplicemente alla fine del post e scarica il prodotto finale.
Che cos'è la crittografia end-to-end?
Innanzitutto, iniziamo con un rapido ripasso di cosa sia l'E2EE (crittografia end-to-end) e come funzioni. L'E2EE è semplice: quando digiti un messaggio in chat, viene crittografato sul tuo dispositivo mobile (o nel tuo browser) e viene decrittografato solo quando il tuo partner di chat lo riceve e desidera visualizzarlo nella finestra della chat.
﻿
Il messaggio rimane crittografato mentre viaggia su Wi-Fi e Internet, attraverso il cloud / server web, in un database e sulla strada di ritorno al tuo partner di chat. In altre parole, nessuna delle reti o dei server ha idea di cosa stiate chiacchierando.
﻿
Ciò che è difficile nella crittografia end-to-end è il compito di gestire le chiavi di crittografia in modo che solo gli utenti coinvolti nella chat possano accedervi e nessun altro. E quando scrivo “nessun altro”, intendo davvero: anche gli insider del tuo fornitore di cloud o anche tu, lo sviluppatore, sono esclusi; nessun errore accidentale o sguardi legalmente imposti sono possibili. Scrivere crittografia, specialmente per più piattaforme, è difficile: generare numeri casuali veri, scegliere gli algoritmi giusti e scegliere le modalità di crittografia corrette sono solo alcuni esempi che fanno alzare le mani nella disperazione alla maggior parte degli sviluppatori, che alla fine NON lo fanno.
Questo post del blog ti mostrerà come ignorare tutti questi dettagli fastidiosi e crittografare rapidamente e semplicemente End-to-End utilizzando il SDK di Virgil.
Per un'introduzione, ecco come aggiorneremo l'app di messaggistica di Back4app per essere End-to-End Crittografata:
Durante la registrazione: genereremo le chiavi private e pubbliche individuali per i nuovi utenti (ricorda: la chiave pubblica del destinatario crittografa i messaggi e la corrispondente chiave privata del destinatario li decrittografa).
Prima di inviare messaggi, crittograferai i messaggi di chat con la chiave pubblica del destinatario.
Dopo aver ricevuto i messaggi, decrittograferai i messaggi di chat con la chiave privata del destinatario.
﻿
Pubblicheremo le chiavi pubbliche degli utenti nel Servizio di Carte di Virgil in modo che gli utenti della chat possano cercarsi a vicenda e crittografare messaggi l'uno per l'altro. Le chiavi private rimarranno sui dispositivi degli utenti.
Mantienilo semplice
Questa è l'implementazione più semplice possibile di una chat E2EE e funziona perfettamente per semplici app di chat tra 2 utenti
dove le conversazioni sono di breve durata ed è accettabile perdere la cronologia dei messaggi se un dispositivo viene perso con la chiave privata.
OK, basta parlare! Passiamo al codice.
Inizieremo guidandoti attraverso la configurazione dell'app Android,
Poi, aggiungeremo del codice per rendere l'app crittografata end-to-end.
Requisiti
Per completare questo tutorial, hai bisogno di:
Android Studio.
Un'app creata su Back4App.
Segui il tutorial Crea Nuova App per imparare come creare un'app su Back4App.
Registrati per un account Virgil Security (creeremo l'app più tardi).
Impostiamo l'app messenger “pulita” di Back4app
1: Imposta il tuo App Server
Iniziamo con il deploy della funzione cloud. Per questo, avrai bisogno di:
Trova main.js e package.json nella directory scripts;
Apri main.js con il tuo editor preferito.
1.1) Ottieni le credenziali di Back4App
Apri Dashboard della tua app > Impostazioni App > Sicurezza e Chiavi:
﻿
In main.js, sostituisci PARSE_APP_ID con il tuo ID dell'applicazione e PARSE_REST_API_KEY con il tuo chiave API REST:
1   const PARSE_APP_ID = "YOUR_PARSE_APP_ID";
2   const PARSE_REST_API_KEY = "YOUR_PARSE_REST_API_KEY";
1.2) Ottieni le credenziali di Virgil
Crea un'applicazione su Virgil Dashboard﻿
﻿
Apri la tua nuova applicazione Virgil, vai alla sezione E3Kit e genera un .env file sotto la sezione E3Kit nella barra laterale sinistra
﻿
Copia i valori di APP_ID, APP_KEY, e APP_KEY_ID dal .env file
﻿
Sostituisci i valori copiati nel tuo main.js file nei campi corrispondenti (main.js di scripts directory):
1   const APP_ID = "YOUR_VIRGIL_APP_ID";
2   const APP_KEY = "YOUR_VIRGIL_APP_KEY";
3   const APP_KEY_ID = "YOUR_VIRGIL_APP_ID";
1.3) Distribuisci la funzione di codice cloud
Apri il “Dashboard” di Back4App della tua app -> “Core” -> Funzioni di codice cloud;
﻿
Clicca +AGGIUNGI e seleziona il tuo main.js e package.json (dalla directory scripts), dopo di che sposta entrambi nella cartella cloud;
Clicca DISTRIBUISCI.
2: Avvia l'app demo Kotlin Back4app
Non dimenticare di configurare prima la funzione di codice cloud di Back4App. È una parte obbligatoria di questa demo. Dopo di ciò, segui i seguenti passaggi:
2.1) Importa il progetto in Android Studio
Apri Android Studio -> File > Nuovo > Progetto da Controllo Versione > Git﻿
URL del repository Git: https://github.com/VirgilSecurity/chat-back4app-android
Controlla il clean-chat-kt branch
﻿
Importante!
Seleziona il tipo di file “Progetto” dell'albero dei file. Sarà utilizzato per tutto il tutorial:
﻿
2.2) Configura le credenziali di Back4App nel progetto
Apri il “Dashboard” di Back4App della tua app -> “Impostazioni App” -> “Sicurezza e Chiavi”;
﻿
Vai al /app/src/main/res/values/strings.xml file nel tuo progetto android e sostituisci your_back4app_app_id con il tuo Application ID e your_back4app_client_key con il tuo Client Key:
1   <string name="back4app_app_id">your_back4app_app_id</string>
2   <string name="back4app_client_key">your_back4app_client_key</string>
2.3) Configura DB
Apri Back4App “Dashboard” -> “Core” -> “Database Browser” -> “Crea una classe” e crea classi di Custom di tipo chiamato Message e ChatThread;
﻿
2.4) Configura la query live
Torna al tuo account Back4App﻿
Premi il Pannello di controllo del server pulsante sulla tua Applicazione
Trova il blocco “Web Hosting e Live Query”
Apri le Impostazioni della Live Query e controlla l' Attiva Hosting opzione.
Scegli un nome per il tuo sottodominio per attivare la Live Query per le 2 classi che hai creato: Messaggio e ChatThread.
Copia il tuo nuovo nome di sottodominio e clicca sul pulsante SALVA:
﻿
Torna a /app/src/main/res/values/strings.xml e incolla “Nome del sottodominio” che hai inserito sopra nel back4app_live_query_url invece di “yourSubdomainName”:
<string name="back4app_live_query_url">wss://yourSubdomainName.back4app.io/</string>
Dopo questi passaggi sarai in grado di premere il pulsante Esegui in Android Studio e far funzionare il campione. Usa un emulatore o un dispositivo reale per testarlo.
3: Esegui la demo pulita
Per vedere il risultato dell'esecuzione della versione pulita della demo, dovrai:
Registrare 2 utenti;
Avviare una conversazione tra di loro e inviare un paio di messaggi;
﻿
      3. Apri Back4App “Dashboard” -> “Core” -> “Database Browser” -> “Message”.
Se tutto ha funzionato, dovresti vedere l'app di messaggistica chat apparire. Registrati due utenti e invia alcuni messaggi l'uno all'altro: dovresti vedere nuovi dati apparire nella Message classe.
Nota che puoi vedere sul server di cosa stanno chiacchierando i tuoi utenti:
﻿
Prossimo: Chiudi la tua interfaccia di chat e passa al passaggio successivo – aggiungere la crittografia E2EE.
Ora, crittografiamo End-to-End quei messaggi!
Entro la fine di questa parte, i tuoi messaggi di chat appariranno così sul server: riesci a notare la differenza?
﻿
Come ci arriviamo? Ovviamente, dobbiamo implementare la crittografia end-to-end, il che significa che la nostra app deve:
Generare la coppia di chiavi private e pubbliche come parte della registrazione
Memorizzare la chiave privata nello storage delle chiavi sul dispositivo dell'utente
Pubblicare la chiave pubblica nel Servizio Card di Virgil come una “Virgil Card” per altri utenti da scaricare e crittografare messaggi con essa
Crittografare i messaggi con la chiave pubblica e firmare con la chiave privata; decrittografare i messaggi con la chiave privata e verificare con la chiave pubblica
Per questo, dovremo aggiungere E3Kit alla nostra applicazione demo pulita e un po' di codice in più per implementare tutto ciò che è stato descritto sopra.
Ma prima di iniziare, chiariremo due termini importanti per te: cos'è una Virgil Card e una chiave privata?
Virgil Card - Le Virgil Cards contengono le chiavi private degli utenti. Le Virgil Cards sono pubblicate nel Servizio Card di Virgil (immagina che questo servizio sia come un elenco telefonico) affinché altri utenti possano recuperarle: Alice deve recuperare la chiave pubblica di Bob per crittografare un messaggio per Bob utilizzando quella chiave.
Chiave privata - una parte privata della chiave di crittografia. Ricorda, le chiavi private possono decrittografare i dati che sono stati crittografati utilizzando la chiave pubblica corrispondente.
1: Aggiungi E3Kit alla pulita Demo Kotlin di E3Kit Back4App
Nell'app-level (Modulo: app) gradle a /app/build.gradle aggiungi (ma non sincronizzare ancora gli script gradle):
implementazione "com.virgilsecurity:ethree:$rootProject.ext.ethree"
Aggiungi quanto segue alla fine del tuo progetto-level /build.gradle (Progetto: chat-back4app-android):
1   ext {
2   ethree = "2.0.5"
3   }
Ora puoi sincronizzare gli script gradle;
Aggiorna la tua AppVirgil classe aggiungendo nuovi campi:
1   companion oggetto {
2     lateinit var eThree: EThree
3     fun isEthreeInitialized() = ::eThree.isInitialized
4   }
Premi Alt+ Enter per importare le librerie necessarie nella classe.
2: Autenticare gli utenti con Back4App Cloud Code
Nella ../virgilsecurity/virgilback4app/model/ directory, crea le classi dati AuthenticateResponse e VirgilJwtResponse che rappresentano le risposte dalle funzioni Cloud Code:
1    classe dati AuthenticateResponse(val authToken: String)
2
3    classe dati VirgilJwtResponse(val virgilToken: String)
Nella ../virgilsecurity/virgilback4app/util/ crea un AuthRx oggetto che implementa le chiamate alle funzioni Cloud Code (non dimenticare di importare tutte le librerie necessarie dopo):
JS
1   object AuthRx {
2
3       /**
4        * You can call it only after successful [authenticate]
5        */
6       fun virgilJwt(sessionToken: String) = Single.create<String> { emitter ->
7           val requestParams = mutableMapOf<String, String>().apply {
8               put("sessionToken", sessionToken)
9           }
10
11          ParseCloud.callFunctionInBackground<Map<String, Any>>(
12              KEY_VIRGIL_JWT,
13              requestParams
14          ) { virgilJwt, exception ->
15              if (exception == null)
16                  emitter.onSuccess(virgilJwt[KEY_TOKEN].toString())
17              else
18                  emitter.onError(exception)
19
20          }
21      }
22
23      private const val KEY_VIRGIL_JWT = "virgil-jwt"
24      private const val KEY_TOKEN = "token"
25  }
1   object AuthRx {
2
3       /**
4        * You can call it only after successful [authenticate]
5        */
6       fun virgilJwt(sessionToken: String) = Single.create<String> { emitter ->
7           val requestParams = mutableMapOf<String, String>().apply {
8               put("sessionToken", sessionToken)
9           }
10
11          ParseCloud.callFunctionInBackground<Map<String, Any>>(
12              KEY_VIRGIL_JWT,
13              requestParams
14          ) { virgilJwt, exception ->
15              if (exception == null)
16                  emitter.onSuccess(virgilJwt[KEY_TOKEN].toString())
17              else
18                  emitter.onError(exception)
19
20          }
21      }
22
23      private const val KEY_VIRGIL_JWT = "virgil-jwt"
24      private const val KEY_TOKEN = "token"
25  }
﻿
3: Memorizza il Virgil JWT localmente
Il token Virgil ricevuto dalle funzioni Cloud Code deve essere memorizzato localmente. Aggiorniamo la Preferences classe in ../virgilsecurity/virgilback4app/util/:﻿
Definisci la costante:
1   private const val KEY_VIRGIL_TOKEN = "KEY_VIRGIL_TOKEN"
﻿
Aggiungi le funzioni setVirgilToken, virgilToken e clearVirgilToken:
~~~kotlin
fun setVirgilToken(virgilToken: String) {
with(sharedPreferences.edit()) {
putString(KEY_VIRGIL_TOKEN, virgilToken)
apply()
}
}

fun virgilToken(): String? {
with(sharedPreferences) {
return getString(KEY_VIRGIL_TOKEN, null)
}
}
fun clearVirgilToken() {
with(sharedPreferences.edit()) {
remove(KEY_VIRGIL_TOKEN)
apply()
}
}
Kotlin
1   Virgil token should be reset on logout. Let's add `Preferences.instance(this).clearVirgilToken()` line into `initDrawer` function of `ThreadsListActivity` class  (in `../virgilsecurity/virgilback4app/chat/contactsList/`):
2   ~~~kotlin
3   private fun initDrawer() {
4       ...
5       nvNavigation.setNavigationItemSelectedListener { item ->
6           R.id.itemLogOut -> {
7               dlDrawer.closeDrawer(GravityCompat.START)
8               presenter.disposeAll()
9               showBaseLoading(true)
10              // New code >>
11              Preferences.instance(this).clearVirgilToken()
12              // << New code
13              ...
14          }
15      }
16  }
1   Virgil token should be reset on logout. Let's add `Preferences.instance(this).clearVirgilToken()` line into `initDrawer` function of `ThreadsListActivity` class  (in `../virgilsecurity/virgilback4app/chat/contactsList/`):
2   ~~~kotlin
3   private fun initDrawer() {
4       ...
5       nvNavigation.setNavigationItemSelectedListener { item ->
6           R.id.itemLogOut -> {
7               dlDrawer.closeDrawer(GravityCompat.START)
8               presenter.disposeAll()
9               showBaseLoading(true)
10              // New code >>
11              Preferences.instance(this).clearVirgilToken()
12              // << New code
13              ...
14          }
15      }
16  }
﻿
4: Modifica della registrazione dell'utente
E3Kit si occupa delle tue chiavi private e pubbliche. Per generarle durante il processo di registrazione, dovremo fare quanto segue:
In ../virgilsecurity/virgilback4app/util/crea RxEthree classe:
1   classe RxEthree(val contesto: Context) {
2
3       privato val preferenze = Preferences.istanza(contesto)
4   }
Ora, aggiungi initEthree funzione che inizializza l'istanza di E3Kit in RxEthree classe:
Text
1      import com.virgilsecurity.android.common.model.EThreeParams
2      import com.virgilsecurity.android.ethree.interaction.EThree
3
4
5      fun initEthree(identity: String, verifyPrivateKey: Boolean = false): 6Single<EThree> = Single.create { e ->
6       val params = EThreeParams(identity, {preferences.virgilToken()!!}, context)
7       val ethree = EThree(params)
8       if (verifyPrivateKey) {
9           if (ethree.hasLocalPrivateKey()) {
10              e.onSuccess(ethree)
11          } else {
12              e.onError(KeyEntryNotFoundException())
13          }
14      } else {
15          e.onSuccess(ethree)
16      }
17  }
1      import com.virgilsecurity.android.common.model.EThreeParams
2      import com.virgilsecurity.android.ethree.interaction.EThree
3
4
5      fun initEthree(identity: String, verifyPrivateKey: Boolean = false): 6Single<EThree> = Single.create { e ->
6       val params = EThreeParams(identity, {preferences.virgilToken()!!}, context)
7       val ethree = EThree(params)
8       if (verifyPrivateKey) {
9           if (ethree.hasLocalPrivateKey()) {
10              e.onSuccess(ethree)
11          } else {
12              e.onError(KeyEntryNotFoundException())
13          }
14      } else {
15          e.onSuccess(ethree)
16      }
17  }
﻿
Aggiungi registerEthree funzione che registra un nuovo utente in RxEthree classe.
E3Kit genera una coppia di chiavi durante la registrazione. La chiave privata generata viene quindi memorizzata nello storage locale, e la chiave pubblica viene pubblicata ai servizi Virgil come una Virgil Card.
Text
1   import com.android.virgilsecurity.virgilback4app.AppVirgil
2   import com.virgilsecurity.common.callback.OnCompleteListener
3   import io.reactivex.Completable
4
5
6   fun registerEthree(): Completable = Completable.create { e ->
7       AppVirgil.eThree.register().addCallback(object : OnCompleteListener {
8           override fun onError(throwable: Throwable) {
9               e.onError(throwable)
10          }
11
12          override fun onSuccess() {
13              e.onComplete()
14          }
15
16      })
17  }
1   import com.android.virgilsecurity.virgilback4app.AppVirgil
2   import com.virgilsecurity.common.callback.OnCompleteListener
3   import io.reactivex.Completable
4
5
6   fun registerEthree(): Completable = Completable.create { e ->
7       AppVirgil.eThree.register().addCallback(object : OnCompleteListener {
8           override fun onError(throwable: Throwable) {
9               e.onError(throwable)
10          }
11
12          override fun onSuccess() {
13              e.onComplete()
14          }
15
16      })
17  }
﻿
Facciamo alcune modifiche a LogInPresenter classe (in ../virgilsecurity/virgilback4app/auth/).
Aggiungi rxEthree campo:
Text
1   private val rxEthree = RxEthree(context)
1   private val rxEthree = RxEthree(context)
﻿
Aggiorna il requestSignUp funzione per eseguire la registrazione con E3Kit
JS
1   fun requestSignUp(identity: String, onSuccess: () -> Unit, onError: (Throwable) -> Unit) {
2     val password = generatePassword(identity.toByteArray())
3
4     val disposable = RxParse.signUp(identity, password)
5             .subscribeOn(Schedulers.io())
6             .observeOn(Schedulers.io())
7             // New code >>
8             .toSingle { ParseUser.getCurrentUser() }
9             .flatMap { AuthRx.virgilJwt(it.sessionToken) }
10            .map { preferences.setVirgilToken(it) }
11            .flatMap { rxEthree.initEthree(identity) }
12            .map { AppVirgil.eThree = it }
13            .flatMap { rxEthree.registerEthree().toSingle { Unit } }
14            // << New code
15            .observeOn(AndroidSchedulers.mainThread())
16            // Updated code >>
17            .subscribeBy(
18                onSuccess = {
19                    onSuccess()
20                },
21                onError = {
22                    onError(it)
23                }
24            )
25            // << Updated code
26
27    compositeDisposable += disposable
28  }
1   fun requestSignUp(identity: String, onSuccess: () -> Unit, onError: (Throwable) -> Unit) {
2     val password = generatePassword(identity.toByteArray())
3
4     val disposable = RxParse.signUp(identity, password)
5             .subscribeOn(Schedulers.io())
6             .observeOn(Schedulers.io())
7             // New code >>
8             .toSingle { ParseUser.getCurrentUser() }
9             .flatMap { AuthRx.virgilJwt(it.sessionToken) }
10            .map { preferences.setVirgilToken(it) }
11            .flatMap { rxEthree.initEthree(identity) }
12            .map { AppVirgil.eThree = it }
13            .flatMap { rxEthree.registerEthree().toSingle { Unit } }
14            // << New code
15            .observeOn(AndroidSchedulers.mainThread())
16            // Updated code >>
17            .subscribeBy(
18                onSuccess = {
19                    onSuccess()
20                },
21                onError = {
22                    onError(it)
23                }
24            )
25            // << Updated code
26
27    compositeDisposable += disposable
28  }
﻿
5: Modifica le funzioni di accesso
Ora, apportiamo modifiche al requestSignIn metodo di LogInPresenter classe (in ../virgilsecurity/virgilback4app/auth/):
JS
1      fun requestSignIn(identity: String,
2                     onSuccess: () -> Unit,
3                     onError: (Throwable) -> Unit) {
4
5       val password = generatePassword(identity.toByteArray())
6
7       val disposable = RxParse.logIn(identity, password)
8               .subscribeOn(Schedulers.io())
9               .observeOn(Schedulers.io())
10              // New code >>
11              .flatMap { AuthRx.virgilJwt(it.sessionToken) }
12              .map { preferences.setVirgilToken(it) }
13              .flatMap { rxEthree.initEthree(identity, true) }
14              .map { AppVirgil.eThree = it }
15              // << New code
16              .observeOn(AndroidSchedulers.mainThread())
17              // Updated code >>
18              .subscribeBy(
19                  onSuccess = {
20                      onSuccess()
21                  },
22                  onError = {
23                      onError(it)
24                  }
25              )
26              // << Updated code
27
28      compositeDisposable += disposable
29  }
1      fun requestSignIn(identity: String,
2                     onSuccess: () -> Unit,
3                     onError: (Throwable) -> Unit) {
4
5       val password = generatePassword(identity.toByteArray())
6
7       val disposable = RxParse.logIn(identity, password)
8               .subscribeOn(Schedulers.io())
9               .observeOn(Schedulers.io())
10              // New code >>
11              .flatMap { AuthRx.virgilJwt(it.sessionToken) }
12              .map { preferences.setVirgilToken(it) }
13              .flatMap { rxEthree.initEthree(identity, true) }
14              .map { AppVirgil.eThree = it }
15              // << New code
16              .observeOn(AndroidSchedulers.mainThread())
17              // Updated code >>
18              .subscribeBy(
19                  onSuccess = {
20                      onSuccess()
21                  },
22                  onError = {
23                      onError(it)
24                  }
25              )
26              // << Updated code
27
28      compositeDisposable += disposable
29  }
﻿
6: Ottieni l'elenco delle chat esistenti
Successivamente, aggiungi funzioni che gestiscono l'inizializzazione di E3Kit nella ThreadsListFragment classe (in ../virgilsecurity/virgilback4app/chat/contactsList/):
JS
1   private fun onInitEthreeSuccess() {
2       presenter.requestThreads(ParseUser.getCurrentUser(),
3                                20,
4                                page,
5                                Const.TableNames.CREATED_AT_CRITERIA,
6                                ::onGetThreadsSuccess,
7                                ::onGetThreadsError)
8   }
9
10  private fun onInitEthreeError(throwable: Throwable) {
11      showProgress(false)
12      if (adapter.itemCount == 0)
13          tvError.visibility = View.VISIBLE
14
15      Utils.toast(activity, Utils.resolveError(throwable))
16  }
1   private fun onInitEthreeSuccess() {
2       presenter.requestThreads(ParseUser.getCurrentUser(),
3                                20,
4                                page,
5                                Const.TableNames.CREATED_AT_CRITERIA,
6                                ::onGetThreadsSuccess,
7                                ::onGetThreadsError)
8   }
9
10  private fun onInitEthreeError(throwable: Throwable) {
11      showProgress(false)
12      if (adapter.itemCount == 0)
13          tvError.visibility = View.VISIBLE
14
15      Utils.toast(activity, Utils.resolveError(throwable))
16  }
﻿
Aggiorna postCreateInit funzione per inizializzare E3Kit:
JS
1   override fun postCreateInit() {
2       ...
3       presenter = ThreadsListFragmentPresenter(activity)
4
5       showProgress(true)
6       // Updated code >>
7       if (AppVirgil.isEthreeInitialized()) {
8           presenter.requestThreads(ParseUser.getCurrentUser(),
9                                    20,
10                                   page,
11                                   Const.TableNames.CREATED_AT_CRITERIA,
12                                   ::onGetThreadsSuccess,
13                                   ::onGetThreadsError)
14      } else {
15          presenter.requestEthreeInit(ParseUser.getCurrentUser(), ::onInitEthreeSuccess, ::onInitEthreeError)
16      }
17      // << Updated code
18  }
1   override fun postCreateInit() {
2       ...
3       presenter = ThreadsListFragmentPresenter(activity)
4
5       showProgress(true)
6       // Updated code >>
7       if (AppVirgil.isEthreeInitialized()) {
8           presenter.requestThreads(ParseUser.getCurrentUser(),
9                                    20,
10                                   page,
11                                   Const.TableNames.CREATED_AT_CRITERIA,
12                                   ::onGetThreadsSuccess,
13                                   ::onGetThreadsError)
14      } else {
15          presenter.requestEthreeInit(ParseUser.getCurrentUser(), ::onInitEthreeSuccess, ::onInitEthreeError)
16      }
17      // << Updated code
18  }
﻿
E aggiungi il seguente codice nella ThreadsListFragmentPresenter classe in virgilsecurity.virgilback4app.chat.contactsList/:
Aggiungi campo:
JS
1   private val rxEthree = RxEthree(context)
1   private val rxEthree = RxEthree(context)
﻿
e funzione
JS
1   fun requestEthreeInit(currentUser: ParseUser, onSuccess: () -> Unit, onError: (Throwable) -> Unit) {
2     val disposable = rxEthree.initEthree(currentUser.username)
3             .subscribeOn(Schedulers.io())
4             .observeOn(AndroidSchedulers.mainThread())
5             .subscribeBy(
6                 onSuccess = {
7                     AppVirgil.eThree = it
8                     onSuccess()
9                 },
10                onError = {
11                    onError(it)
12                }
13            )
14
15    compositeDisposable += disposable
16  }
1   fun requestEthreeInit(currentUser: ParseUser, onSuccess: () -> Unit, onError: (Throwable) -> Unit) {
2     val disposable = rxEthree.initEthree(currentUser.username)
3             .subscribeOn(Schedulers.io())
4             .observeOn(AndroidSchedulers.mainThread())
5             .subscribeBy(
6                 onSuccess = {
7                     AppVirgil.eThree = it
8                     onSuccess()
9                 },
10                onError = {
11                    onError(it)
12                }
13            )
14
15    compositeDisposable += disposable
16  }
﻿
A questo punto siamo in grado di registrare/accesso a un utente e creare una nuova chat con un altro utente.
Ora aggiungiamo la crittografia per i nostri messaggi.
7: Crittografia e decrittografia dei messaggi
Aggiungiamo findCard funzione a RxEthree classe (in ../virgilsecurity/virgilback4app/util/) che ci aiuterà a ottenere l'ultima Virgil Card per nome utente:
JS
1   fun findCard(identity: String): Single<Card> = Single.create { e ->
2       AppVirgil.eThree.findUser(identity).addCallback(object : OnResultListener<Card> {
3           override fun onError(throwable: Throwable) {
4                e.onError(throwable)
5           }
6
7           override fun onSuccess(result: Card) {
8               e.onSuccess(result)
9           }
10
11      })
12  }
1   fun findCard(identity: String): Single<Card> = Single.create { e ->
2       AppVirgil.eThree.findUser(identity).addCallback(object : OnResultListener<Card> {
3           override fun onError(throwable: Throwable) {
4                e.onError(throwable)
5           }
6
7           override fun onSuccess(result: Card) {
8               e.onSuccess(result)
9           }
10
11      })
12  }
﻿
Quando viene aperta una chat, dovremmo ottenere la Virgil Card del destinatario. Modifica postCreateInit di ChatThreadFragment classe (in ../virgilsecurity/virgilback4app/chat/thread/) sostituendo
JS
1   presenter.requestMessages(thread,
2                             50,
3                             page,
4                             Const.TableNames.CREATED_AT_CRITERIA,
5                             ::onGetMessagesSuccess,
6                             ::onGetMessagesError)
1   presenter.requestMessages(thread,
2                             50,
3                             page,
4                             Const.TableNames.CREATED_AT_CRITERIA,
5                             ::onGetMessagesSuccess,
6                             ::onGetMessagesError)
﻿
codice con uno nuovo
JS
1   presenter.requestCard(recipientId,
2                                      ::onGetCardSuccess,
3                                      ::onGetCardError)
1   presenter.requestCard(recipientId,
2                                      ::onGetCardSuccess,
3                                      ::onGetCardError)
﻿
E aggiungi due funzioni:
JS
1   private fun onGetCardSuccess(card: Card) {
2       showProgress(false)
3       adapter.interlocutorCard = card
4       presenter.requestMessages(thread,
5                                 50,
6                                 page,
7                                 Const.TableNames.CREATED_AT_CRITERIA,
8                                 ::onGetMessagesSuccess,
9                                 ::onGetMessagesError)
10  }
11
12  private fun onGetCardError(t: Throwable) {
13      if (t is VirgilCardIsNotFoundException || t is VirgilCardServiceException) {
14          Utils.toast(this,
15                      "Virgil Card is not found.\nYou can not chat with user without Virgil Card")
16          activity.onBackPressed()
17      }
18      showProgress(false)
19      srlRefresh.isRefreshing = false
20      lockSendUi(lock = false, lockInput = false)
21
22      Utils.toast(this, Utils.resolveError(t))
23  }
1   private fun onGetCardSuccess(card: Card) {
2       showProgress(false)
3       adapter.interlocutorCard = card
4       presenter.requestMessages(thread,
5                                 50,
6                                 page,
7                                 Const.TableNames.CREATED_AT_CRITERIA,
8                                 ::onGetMessagesSuccess,
9                                 ::onGetMessagesError)
10  }
11
12  private fun onGetCardError(t: Throwable) {
13      if (t is VirgilCardIsNotFoundException || t is VirgilCardServiceException) {
14          Utils.toast(this,
15                      "Virgil Card is not found.\nYou can not chat with user without Virgil Card")
16          activity.onBackPressed()
17      }
18      showProgress(false)
19      srlRefresh.isRefreshing = false
20      lockSendUi(lock = false, lockInput = false)
21
22      Utils.toast(this, Utils.resolveError(t))
23  }
﻿
Ora cambiamo ChatThreadPresenter:
Aggiungi campi:
JS
1   private val eThree = AppVirgil.eThree
2   private lateinit var userCard: Card
3   private val rxEthree = RxEthree(context)
1   private val eThree = AppVirgil.eThree
2   private lateinit var userCard: Card
3   private val rxEthree = RxEthree(context)
﻿
Aggiungi una funzione che ottiene una Virgil Card del destinatario:
JS
1   fun requestCard(identity: String,
2                 onSuccess: (Card) -> Unit,
3                 onError: (Throwable) -> Unit) {
4
5     val disposable = rxEthree.findCard(identity)
6             .subscribeOn(Schedulers.io())
7             .observeOn(AndroidSchedulers.mainThread())
8             .subscribeBy(
9                 onSuccess = {
10                    userCard = it
11                    onSuccess(it)
12                },
13                onError = {
14                    onError(it)
15                }
16            )
17
18    compositeDisposable += disposable
19  }
1   fun requestCard(identity: String,
2                 onSuccess: (Card) -> Unit,
3                 onError: (Throwable) -> Unit) {
4
5     val disposable = rxEthree.findCard(identity)
6             .subscribeOn(Schedulers.io())
7             .observeOn(AndroidSchedulers.mainThread())
8             .subscribeBy(
9                 onSuccess = {
10                    userCard = it
11                    onSuccess(it)
12                },
13                onError = {
14                    onError(it)
15                }
16            )
17
18    compositeDisposable += disposable
19  }
﻿
Aggiungi la crittografia dei messaggi in uscita in requestSendMessage funzione:
JS
1   fun requestSendMessage(text: String,
2                        thread: ChatThread,
3                        onSuccess: () -> Unit,
4                        onError: (Throwable) -> Unit) {
5
6     val encryptedText = eThree.authEncrypt(text, userCard)
7     val disposable = RxParse.sendMessage(encryptedText, thread)
8     ...
9   }
1   fun requestSendMessage(text: String,
2                        thread: ChatThread,
3                        onSuccess: () -> Unit,
4                        onError: (Throwable) -> Unit) {
5
6     val encryptedText = eThree.authEncrypt(text, userCard)
7     val disposable = RxParse.sendMessage(encryptedText, thread)
8     ...
9   }
﻿
Aggiungi la decrittografia di tutti i messaggi in arrivo in ChatThreadRVAdapter classe (in ../virgilsecurity/virgilback4app/chat/thread/):
Aggiungi campi:
JS
1   private var eThree: EThree = AppVirgil.eThree
2   lateinit var interlocutorCard: Card
1   private var eThree: EThree = AppVirgil.eThree
2   lateinit var interlocutorCard: Card
﻿

Implementa la decrittazione dei messaggi in onBindViewHolder funzione
JS
1   override fun onBindViewHolder(viewHolder: RecyclerView.ViewHolder, position: Int) {
2     when (viewHolder) {
3         is HolderMessageMe -> {
4             val decryptedText = eThree.authDecrypt(items[position].body)
5             viewHolder.bind(decryptedText)
6         }
7         is HolderMessageYou -> {
8             val decryptedText = eThree.authDecrypt(items[position].body, interlocutorCard)
9             viewHolder.bind(decryptedText)
10        }
11    }
12  }
1   override fun onBindViewHolder(viewHolder: RecyclerView.ViewHolder, position: Int) {
2     when (viewHolder) {
3         is HolderMessageMe -> {
4             val decryptedText = eThree.authDecrypt(items[position].body)
5             viewHolder.bind(decryptedText)
6         }
7         is HolderMessageYou -> {
8             val decryptedText = eThree.authDecrypt(items[position].body, interlocutorCard)
9             viewHolder.bind(decryptedText)
10        }
11    }
12  }
﻿
8: Esegui la demo completa end-to-end crittografata
Ora per vedere il risultato della nostra demo completamente crittografata end-to-end, segui di nuovo questi passaggi:
Disconnetti l'utente precedente
Registrati 2 nuovi utenti;
Inizia una conversazione tra di loro e invia un paio di messaggi;
Apri Back4App “Dashboard” -> “Core” -> “Database Browser” -> “Message”.
Importante! Devi Disconnettere l'utente attuale e registrare due nuovi utenti, dopodiché puoi iniziare una chat E2EE con questi due nuovi utenti. Il motivo è che i tuoi primi due utenti non hanno Virgil Card’s, quindi non puoi usare crittografia\decrittografia per loro.{: .blockquote-tip}
Fatto! Ora puoi vedere che i messaggi degli utenti sono crittografati e possono essere accessibili solo nell'app dagli utenti stessi.
Conformità a HIPAA e GDPR:
La crittografia end-to-end è un modo per soddisfare i requisiti tecnici per HIPAA (l'Atto di Portabilità e Responsabilità dell'Assicurazione Sanitaria degli Stati Uniti del 1996) e GDPR (il Regolamento Generale sulla Protezione dei Dati dell'Unione Europea). Se hai bisogno di ulteriori dettagli, registrati per un account Virgil, unisciti alla nostra comunità Slack e contattaci lì: siamo felici di discutere le tue circostanze di privacy e aiutarti a capire cosa è necessario per soddisfare i requisiti tecnici di HIPAA e GDPR.
Dove andare da qui?
﻿Progetto finale. Se ti sei perso pezzi del puzzle, apri il ramo del progetto E2EE. Puoi inserire le credenziali della tua applicazione in questo codice (come hai fatto durante l'articolo) e costruire il progetto.
Puoi trovare ulteriori informazioni su cosa puoi costruire con Virgil Security qui.
Guida tecnica per App conformi al GDPR su Back4App
AVANTI IL PROSSIMO
Sicurezza delle App: Configurazione Sicura con Parse e Back4App