Load database key in RoomDatabase background thread

1. Load database key in RoomDatabase background thread
2. Add more tests

engine/src/androidTest/java/com/google/android/fhir/db/impl/EncryptedDatabaseErrorTest.kt

@@ -0,0 +1,153 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http:https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.db.impl
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.MediumTest
+import ca.uhn.fhir.context.FhirContext
+import com.google.android.fhir.db.impl.DatabaseImpl.Companion.DATABASE_PASSPHRASE_NAME
+import com.google.android.fhir.search.Order
+import com.google.android.fhir.search.Search
+import com.google.android.fhir.search.getQuery
+import com.google.android.fhir.security.StorageKeyProvider
+import com.google.common.truth.Truth.assertThat
+import java.security.KeyStore
+import kotlinx.coroutines.runBlocking
+import net.sqlcipher.database.SQLiteException
+import org.hl7.fhir.r4.model.Enumerations
+import org.hl7.fhir.r4.model.Patient
+import org.hl7.fhir.r4.model.ResourceType
+import org.junit.After
+import org.junit.Assert.assertThrows
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@MediumTest
+@RunWith(AndroidJUnit4::class)
+class EncryptedDatabaseErrorTest {
+ private val context: Context = ApplicationProvider.getApplicationContext()
+ private val parser = FhirContext.forR4().newJsonParser()
+
+ @After
+ fun tearDown() {
+ context.getDatabasePath("fhirEngine").delete()
+ }
+
+ @Test
+ fun unencryptedDatabase_thenEncryptedDatabase_shouldThrowSQLiteException() {
+ assertThrows(SQLiteException::class.java) {
+ runBlocking {
+ // GIVEN an unencrypted database.
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = false))
+ .let {
+ it.insert(TEST_PATIENT_1)
+ it.db.close()
+ }
+
+ // WHEN requesting an encrypted database.
+ // THEN it should throw SQLiteException
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = true))
+ .let {
+ it.search<Patient>(
+ Search(ResourceType.Patient)
+ .apply {
+ sort(Patient.GIVEN, Order.ASCENDING)
+ count = 100
+ from = 0
+ }
+ .getQuery()
+ )
+ }
+ }
+ }
+ }
+
+ @Test
+ fun encryptedDatabase_thenLostKey_shouldThrowSQLiteException() {
+ assertThrows(SQLiteException::class.java) {
+ runBlocking {
+ // GIVEN an unencrypted database.
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = true))
+ .let {
+ it.insert(TEST_PATIENT_1)
+ it.db.close()
+ }
+
+ // GIVEN the key is lost.
+ val keyStore = KeyStore.getInstance(StorageKeyProvider.ANDROID_KEYSTORE_NAME)
+ keyStore.load(/* param = */ null)
+ keyStore.deleteEntry(DATABASE_PASSPHRASE_NAME)
+
+ // WHEN requesting an encrypted database.
+ // THEN it should throw SQLiteException
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = true))
+ .let {
+ it.search<Patient>(
+ Search(ResourceType.Patient)
+ .apply {
+ sort(Patient.GIVEN, Order.ASCENDING)
+ count = 100
+ from = 0
+ }
+ .getQuery()
+ )
+ }
+ }
+ }
+ }
+
+ @Test
+ fun encryptedDatabase_thenUnencrypted_shouldRecreateDatabase() {
+ runBlocking {
+ // GIVEN an unencrypted database.
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = true)).let {
+ it.insert(TEST_PATIENT_1)
+ it.db.close()
+ }
+
+ // WHEN requesting an encrypted database.
+ // THEN it should recreate database.
+ DatabaseImpl(context, parser, DatabaseConfig(inMemory = false, enableEncryption = false))
+ .let {
+ assertThat(
+ it.search<Patient>(
+ Search(ResourceType.Patient)
+ .apply {
+ sort(Patient.GIVEN, Order.ASCENDING)
+ count = 100
+ from = 0
+ }
+ .getQuery()
+ )
+ )
+ .isEmpty()
+ }
+ }
+ }
+
+ private companion object {
+ const val TEST_PATIENT_1_ID = "patient_1"
+ val TEST_PATIENT_1 = Patient()
+
+ init {
+ TEST_PATIENT_1.id = TEST_PATIENT_1_ID
+ TEST_PATIENT_1.gender = Enumerations.AdministrativeGender.MALE
+ }
+ }
+}

engine/src/androidTest/java/com/google/android/fhir/security/StorageKeyProviderTest.kt

@@ -16,9 +16,7 @@
 
 package com.google.android.fhir.security
 
-import android.os.Build
 import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.filters.SdkSuppress
 import androidx.test.filters.SmallTest
 import com.google.common.truth.Truth.assertThat
 import java.security.KeyStore
@@ -30,7 +28,6 @@ import org.junit.runner.RunWith
 /** Integration test for [StorageKeyProviderTest]. */
 @SmallTest
 @RunWith(AndroidJUnit4::class)
-@SdkSuppress(minSdkVersion = Build.VERSION_CODES.M)
 class StorageKeyProviderTest {
  @Before fun setup() = deleteTestKeys()
 

engine/src/main/java/com/google/android/fhir/db/impl/DatabaseImpl.kt

@@ -18,7 +18,7 @@ package com.google.android.fhir.db.impl
 
 import android.content.Context
 import android.os.Build
-import android.util.Log
+import androidx.annotation.VisibleForTesting
 import androidx.room.Room
 import androidx.room.withTransaction
 import androidx.sqlite.db.SimpleSQLiteQuery
@@ -33,8 +33,6 @@ import com.google.android.fhir.logicalId
 import com.google.android.fhir.resource.getResourceType
 import com.google.android.fhir.search.SearchQuery
 import com.google.android.fhir.security.StorageKeyProvider
-import java.lang.Exception
-import net.sqlcipher.database.SupportFactory
 import org.hl7.fhir.r4.model.Resource
 import org.hl7.fhir.r4.model.ResourceType
 
@@ -59,16 +57,12 @@ internal class DatabaseImpl(
 
  init {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && databaseConfig.enableEncryption) {
- try {
+ builder.openHelperFactory {
+ SQLCipherSupportHelper(it) {
  StorageKeyProvider.getOrCreatePassphrase(DATABASE_PASSPHRASE_NAME)
- } catch (e: Exception) {
- Log.e(LOG_TAG, "Fail to create / get database encryption key", e)
- throw e
  }
- } else {
- null
  }
-  ?.let { builder.openHelperFactory(SupportFactory(it)) }
+ }
  db = builder.build()
  }
  private val resourceDao by lazy { db.resourceDao().also { it.iParser = iParser } }
@@ -149,7 +143,7 @@ internal class DatabaseImpl(
  companion object {
  private const val LOG_TAG = "Fhir-DatabaseImpl"
  private const val DEFAULT_DATABASE_NAME = "fhirEngine"
- private const val DATABASE_PASSPHRASE_NAME = "fhirEngine_db_passphrase"
+ @VisibleForTesting const val DATABASE_PASSPHRASE_NAME = "fhirEngine_db_passphrase"
  }
 }
 

engine/src/main/java/com/google/android/fhir/db/impl/SQLCipherSupportHelper.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http:https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.android.fhir.db.impl
+
+import androidx.sqlite.db.SupportSQLiteDatabase
+import androidx.sqlite.db.SupportSQLiteOpenHelper
+import net.sqlcipher.database.SQLiteDatabase
+import net.sqlcipher.database.SQLiteDatabaseHook
+import net.sqlcipher.database.SQLiteException
+import net.sqlcipher.database.SQLiteOpenHelper
+
+/** A [SupportSQLiteOpenHelper] which initializes a [SQLiteDatabase] with a passphrase. */
+class SQLCipherSupportHelper(
+ val configuration: SupportSQLiteOpenHelper.Configuration,
+ hook: SQLiteDatabaseHook? = null,
+ val passphraseFetcher: () -> ByteArray,
+) : SupportSQLiteOpenHelper {
+
+ init {
+ SQLiteDatabase.loadLibs(configuration.context)
+ }
+
+ private val standardHelper =
+ object :
+ SQLiteOpenHelper(
+ configuration.context,
+ configuration.name,
+ /* factory= */ null,
+ configuration.callback.version,
+ hook
+ ) {
+ override fun onCreate(db: SQLiteDatabase) {
+ configuration.callback.onCreate(db)
+ }
+
+ override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+ configuration.callback.onUpgrade(db, oldVersion, newVersion)
+ }
+
+ override fun onDowngrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+ configuration.callback.onDowngrade(db, oldVersion, newVersion)
+ }
+
+ override fun onOpen(db: SQLiteDatabase) {
+ configuration.callback.onOpen(db)
+ }
+
+ override fun onConfigure(db: SQLiteDatabase) {
+ configuration.callback.onConfigure(db)
+ }
+ }
+
+ override fun getDatabaseName() = standardHelper.databaseName
+
+ override fun setWriteAheadLoggingEnabled(enabled: Boolean) {
+ standardHelper.setWriteAheadLoggingEnabled(enabled)
+ }
+
+ override fun getWritableDatabase(): SupportSQLiteDatabase? {
+ val result: SQLiteDatabase
+ try {
+ result = standardHelper.getWritableDatabase(passphraseFetcher())
+ } catch (ex: SQLiteException) {
+ throw ex
+ }
+ return result
+ }
+
+ override fun getReadableDatabase() = writableDatabase
+
+ override fun close() {
+ standardHelper.close()
+ }
+}

engine/src/main/java/com/google/android/fhir/security/StorageKeyProvider.kt

@@ -37,7 +37,7 @@ object StorageKeyProvider {
  * [keyLength] and stores the passphrase in an encrypted storage.
  */
  @Synchronized
- fun getOrCreatePassphrase(keyName: String): ByteArray? {
+ fun getOrCreatePassphrase(keyName: String): ByteArray {
  if (!isDatabaseEncryptionSupported()) {
  throw UnsupportedOperationException("Database encryption is not supported on this device.")
  }