WIP Commit while getting new computer setup

Author: mtilbrook-dev

armadillo-datastore/src/androidTest/java/at/favre/lib/armadillo/datastore/UserStore.kt

@@ -6,21 +6,25 @@ import androidx.datastore.createDataStore
 import kotlinx.coroutines.flow.Flow
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.protobuf.ProtoBuf
+import java.io.File
 
 @ExperimentalSerializationApi
-class UserStore(context: Context) {
+class UserStore(private val context: Context) {
+  companion object {
+    private const val fileName = "user"
+  }
   private val serializer = User.serializer()
   private val protobuf = ProtoBuf {}
 
   private val protocol = object : ProtobufProtocol<User> {
 
-    override fun fromBytes(bytes: ByteArray): User =
+    override fun decode(bytes: ByteArray): User =
         protobuf.decodeFromByteArray(serializer, bytes)
 
-    override fun fromNothing(): User =
+    override fun default(): User =
         User(name = "", email = "")
 
-    override fun toBytes(data: User): ByteArray =
+    override fun encode(data: User): ByteArray =
         protobuf.encodeToByteArray(serializer, data)
   }
 
@@ -31,7 +35,7 @@ class UserStore(context: Context) {
       )
 
   private val store: DataStore<User> = context.createDataStore(
-      fileName = "user.pb",
+      fileName = fileName,
       serializer = userSerializer
   )
 
@@ -42,4 +46,13 @@ class UserStore(context: Context) {
   val user: Flow<User>
     get() = store.data
 
+  fun clear() {
+    with(context) {
+      val dataStore = File(this.filesDir, "datastore/$fileName")
+      if(dataStore.exists()) {
+        dataStore.delete()
+      }
+    }
+  }
+
 }

armadillo-datastore/src/androidTest/java/at/favre/lib/armadillo/datastore/UserStoreTest.kt

@@ -5,13 +5,20 @@ import androidx.test.ext.junit.runners.AndroidJUnit4
 import kotlinx.coroutines.flow.first
 import kotlinx.coroutines.runBlocking
 import kotlinx.serialization.ExperimentalSerializationApi
+import org.junit.Before
 import org.junit.Test
 import org.junit.runner.RunWith
 
 @ExperimentalSerializationApi
 @RunWith(AndroidJUnit4::class)
 class UserStoreTest {
 
+  @Before
+  fun setup() {
+    val store = UserStore(ApplicationProvider.getApplicationContext())
+    store.clear()
+  }
+
   @Test
   fun canReadEmptyUserFromStore() {
     val store = UserStore(ApplicationProvider.getApplicationContext())

armadillo-datastore/src/main/java/at/favre/lib/armadillo/datastore/ArmadilloSerializer.kt

@@ -2,7 +2,6 @@ package at.favre.lib.armadillo.datastore
 
 import android.content.Context
 import android.os.Build
-import android.util.Log
 import androidx.datastore.Serializer
 import at.favre.lib.armadillo.*
 import at.favre.lib.armadillo.Armadillo.CONTENT_KEY_OUT_BYTE_LENGTH
@@ -12,15 +11,10 @@ import java.io.OutputStream
 import java.security.Provider
 import java.security.SecureRandom
 
-interface ProtobufProtocol<T> {
-  fun toBytes(data: T): ByteArray
-  fun fromBytes(bytes: ByteArray): T
-  fun fromNothing(): T
-}
-
 class ArmadilloSerializer<T>(
     context: Context,
     private val protocol: ProtobufProtocol<T>,
+    password: CharArray? = null,
     fingerprintData: List<String> = emptyList(),
     secureRandom: SecureRandom = SecureRandom(),
     additionalDecryptionConfigs: List<EncryptionProtocolConfig> = listOf(),
@@ -29,36 +23,38 @@ class ArmadilloSerializer<T>(
     preferencesSalt: ByteArray = BuildConfig.PREF_SALT
 ) : Serializer<T> {
 
-  private val password: ByteArrayRuntimeObfuscator?
+  private val serializerPassword: ByteArrayRuntimeObfuscator?
   private val encryptionProtocol: EncryptionProtocol
   private val fingerprint: EncryptionFingerprint = EncryptionFingerprintFactory.create(
       context,
       buildString { fingerprintData.forEach(::append) }
   )
+  private val defaultConfig = EncryptionProtocolConfig.newDefaultConfig()
+  private val kitKatConfig by lazy {
+    @Suppress("DEPRECATION")
+    EncryptionProtocolConfig.newBuilder(defaultConfig.build())
+        .authenticatedEncryption(AesCbcEncryption(secureRandom, provider))
+        .protocolVersion(Armadillo.KITKAT_PROTOCOL_VERSION)
+        .build()
+  }
 
   init {
-    val defaultConfig = EncryptionProtocolConfig.newDefaultConfig()
 
     val stringMessageDigest = HkdfMessageDigest(
         BuildConfig.PREF_SALT,
         CONTENT_KEY_OUT_BYTE_LENGTH
     )
-    val kitKatConfig = takeIf { enabledKitkatSupport }?.run {
-      @Suppress("DEPRECATION")
-      EncryptionProtocolConfig.newBuilder(defaultConfig.build())
-          .authenticatedEncryption(AesCbcEncryption(secureRandom, provider))
-          .protocolVersion(Armadillo.KITKAT_PROTOCOL_VERSION)
-          .build()
-    }
+
     val config =
-        if (kitKatConfig != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
           kitKatConfig
         } else {
           EncryptionProtocolConfig
               .newBuilder(defaultConfig.build())
               .authenticatedEncryption(AesGcmEncryption(secureRandom, provider))
               .build()
-        }.also { checkKitKatSupport(it.authenticatedEncryption) }
+        }
+    checkKitKatSupport(config.authenticatedEncryption)
 
     val factory = DefaultEncryptionProtocol.Factory(
         config,
@@ -74,7 +70,7 @@ class ArmadilloSerializer<T>(
     )
 
     encryptionProtocol = factory.create(preferencesSalt)
-    password = null // TODO Add password config factory.obfuscatePassword()
+    serializerPassword = password?.let(factory::obfuscatePassword)
   }
 
 
@@ -86,56 +82,45 @@ class ArmadilloSerializer<T>(
   }
 
   companion object {
-    private const val CRYPTO_KEY = "ArmadilloStore"
+    private const val CRYPTO_KEY = "ArmadilloStoreSerializer"
+  }
+
+
+  private fun encrypt(content: ByteArray): ByteArray = with(encryptionProtocol) {
+    encrypt(
+        deriveContentKey(CRYPTO_KEY),
+        deobfuscatePassword(serializerPassword),
+        content
+    )
   }
 
 
-  private fun encrypt(content: ByteArray): ByteArray =
-      try {
+  private fun decrypt(encrypted: ByteArray): ByteArray? =
+      if (encrypted.isEmpty()) {
+        null
+      } else {
         encryptionProtocol
-            .encrypt(
+            .decrypt(
                 encryptionProtocol.deriveContentKey(CRYPTO_KEY),
-                encryptionProtocol.deobfuscatePassword(password),
-                content
+                encryptionProtocol.deobfuscatePassword(serializerPassword),
+                encrypted
             )
-      } catch (e: Throwable) {
-        throw IllegalStateException(e)
       }
 
-
-  private fun decrypt(encrypted: ByteArray): ByteArray? {
-    if (encrypted.isEmpty()) {
-      return null
-    }
-    try {
-      return encryptionProtocol
-          .decrypt(
-              encryptionProtocol.deriveContentKey(CRYPTO_KEY),
-              encryptionProtocol.deobfuscatePassword(password),
-              encrypted
-          )
-    } catch (e: Throwable) {
-      Log.e("DataStrore", "decetyp", e)
-//      recoveryPolicy.handleBrokenConte(e, keyHash, base64Encrypted, password != null, this)
-      // TODO handle this
-    }
-    return null
-  }
-
   override fun readFrom(input: InputStream): T =
       input
           .readBytes()
           .let(::decrypt)
           .let {
             val bytes = it ?: byteArrayOf()
-            if (bytes.isEmpty()) protocol.fromNothing()
-            else protocol.fromBytes(bytes)
+            if (bytes.isEmpty()) protocol.default()
+            else protocol.decode(bytes)
           }
 
 
   override fun writeTo(t: T, output: OutputStream) {
     protocol
-        .toBytes(t)
+        .encode(t)
         .let(::encrypt)
         .also(output::write)
   }

armadillo-datastore/src/main/java/at/favre/lib/armadillo/datastore/ProtobufProtocol.kt

@@ -0,0 +1,27 @@
+package at.favre.lib.armadillo.datastore
+
+/**
+ * The protocol is used to wrap the encoded/decode for any protobuff implementation.
+ *
+ * Datastore requies the type T MUST be immutable. Any mutable types will result in a broken DataStore.
+ *
+ * Datastore will always return an empty
+ */
+interface ProtobufProtocol<T> {
+  /**
+   * un-encrypted proto byte encoding of [T]
+   */
+  fun encode(data: T): ByteArray
+
+  /**
+   * un-encrypted proto bytes to proto class of [T]
+   */
+  fun decode(bytes: ByteArray): T
+
+  /**
+   * Returns a default value when the store is empty. This will
+   * always happen on first read even when writing to the store 
+   * for the first time.
+   */
+  fun default(): T
+}