Update open database methods

app/src/main/java/com/kunzisoft/keepass/database/action/MergeDatabaseRunnable.kt

@@ -41,7 +41,7 @@ class MergeDatabaseRunnable(private val context: Context,
 
     override fun onActionRun() {
         try {
-            mDatabase.mergeData(mDatabaseToMergeUri, context.contentResolver,
+            mDatabase.mergeData(mDatabaseToMergeUri, null, context.contentResolver,
                     { memoryWanted ->
                         BinaryData.canMemoryBeAllocatedInRAM(context, memoryWanted)
                     },

app/src/main/java/com/kunzisoft/keepass/database/element/Database.kt

@@ -634,9 +634,13 @@ class Database {
                         }
                         DatabaseInputKDB(databaseKDB)
                             .openDatabase(databaseInputStream,
-                                mainCredential.masterPassword,
+                                progressTaskUpdater
-                                keyFileInputStream,
+                            ) {
-                                progressTaskUpdater)
+                                databaseKDB.retrieveMasterKey(
+                                    mainCredential.masterPassword,
+                                    keyFileInputStream
+                                )
+                            }
                         databaseKDB
                     },
                     { databaseInputStream ->
@@ -647,9 +651,12 @@ class Database {
                         DatabaseInputKDBX(databaseKDBX).apply {
                             setMethodToCheckIfRAMIsSufficient(isRAMSufficient)
                             openDatabase(databaseInputStream,
-                                mainCredential.masterPassword,
+                                progressTaskUpdater) {
-                                keyFileInputStream,
+                                databaseKDBX.retrieveMasterKey(
-                                progressTaskUpdater)
+                                    mainCredential.masterPassword,
+                                    keyFileInputStream,
+                                )
+                            }
                         }
                         databaseKDBX
                     }
@@ -672,6 +679,7 @@ class Database {
 
     @Throws(LoadDatabaseException::class)
     fun mergeData(databaseToMergeUri: Uri?,
+                  databaseToMergeMainCredential: MainCredential?,
                   contentResolver: ContentResolver,
                   isRAMSufficient: (memoryWanted: Long) -> Boolean,
                   progressTaskUpdater: ProgressTaskUpdater?) {
@@ -684,26 +692,45 @@ class Database {
         val databaseToMerge = Database()
         databaseToMerge.fileUri = databaseToMergeUri ?: this.fileUri
 
+        // Pass KeyFile Uri as InputStreams
+        var keyFileInputStream: InputStream? = null
         try {
             databaseToMerge.fileUri?.let { databaseUri ->
 
                 val databaseKDB = DatabaseKDB()
                 val databaseKDBX = DatabaseKDBX()
 
+                if (databaseToMergeMainCredential != null) {
+                    // Get keyFile inputStream
+                    databaseToMergeMainCredential.keyFileUri?.let { keyFile ->
+                        keyFileInputStream = UriUtil.getUriInputStream(contentResolver, keyFile)
+                    }
+                }
+
                 databaseToMerge.readDatabaseStream(contentResolver, databaseUri,
                     { databaseInputStream ->
                         DatabaseInputKDB(databaseKDB)
-                            .openDatabase(databaseInputStream,
+                            .openDatabase(databaseInputStream, progressTaskUpdater) {
-                                masterKey,
+                                if (databaseToMergeMainCredential != null) {
-                                progressTaskUpdater)
+                                    databaseKDB.retrieveMasterKey(
+                                        databaseToMergeMainCredential.masterPassword,
+                                        keyFileInputStream,
+                                    )
+                                }
+                            }
                         databaseKDB
                     },
                     { databaseInputStream ->
                         DatabaseInputKDBX(databaseKDBX).apply {
                             setMethodToCheckIfRAMIsSufficient(isRAMSufficient)
-                            openDatabase(databaseInputStream,
+                            openDatabase(databaseInputStream, progressTaskUpdater) {
-                                masterKey,
+                                if (databaseToMergeMainCredential != null) {
-                                progressTaskUpdater)
+                                    databaseKDBX.retrieveMasterKey(
+                                        databaseToMergeMainCredential.masterPassword,
+                                        keyFileInputStream,
+                                    )
+                                }
+                            }
                         }
                         databaseKDBX
                     }
@@ -730,6 +757,7 @@ class Database {
         } catch (e: Exception) {
             throw LoadDatabaseException(e)
         } finally {
+            keyFileInputStream?.close()
             databaseToMerge.clearAndClose()
         }
     }
@@ -749,9 +777,9 @@ class Database {
                             databaseKDB.binaryCache = it.binaryCache
                         }
                         DatabaseInputKDB(databaseKDB)
-                            .openDatabase(databaseInputStream,
+                            .openDatabase(databaseInputStream, progressTaskUpdater) {
-                                masterKey,
+                                databaseKDB.masterKey = masterKey
-                                progressTaskUpdater)
+                            }
                         databaseKDB
                     },
                     { databaseInputStream ->
@@ -761,9 +789,9 @@ class Database {
                         }
                         DatabaseInputKDBX(databaseKDBX).apply {
                             setMethodToCheckIfRAMIsSufficient(isRAMSufficient)
-                            openDatabase(databaseInputStream,
+                            openDatabase(databaseInputStream, progressTaskUpdater) {
-                                masterKey,
+                                databaseKDBX.masterKey = masterKey
-                                progressTaskUpdater)
+                            }
                         }
                         databaseKDBX
                     }

app/src/main/java/com/kunzisoft/keepass/database/file/input/DatabaseInput.kt

@@ -43,15 +43,8 @@ abstract class DatabaseInput<D : DatabaseVersioned<*, *, *, *>> (protected var m
 
     @Throws(LoadDatabaseException::class)
     abstract fun openDatabase(databaseInputStream: InputStream,
-                              password: String?,
+                              progressTaskUpdater: ProgressTaskUpdater?,
-                              keyfileInputStream: InputStream?,
+                              assignMasterKey: (() -> Unit)): D
-                              progressTaskUpdater: ProgressTaskUpdater?): D
-
-
-    @Throws(LoadDatabaseException::class)
-    abstract fun openDatabase(databaseInputStream: InputStream,
-                              masterKey: ByteArray,
-                              progressTaskUpdater: ProgressTaskUpdater?): D
 
     protected fun startKeyTimer(progressTaskUpdater: ProgressTaskUpdater?) {
         progressTaskUpdater?.updateMessage(R.string.retrieving_db_key)

app/src/main/java/com/kunzisoft/keepass/database/file/input/DatabaseInputKDB.kt

@@ -39,7 +39,6 @@ import java.security.MessageDigest
 import java.util.*
 import javax.crypto.Cipher
 import javax.crypto.CipherInputStream
-import kotlin.collections.HashMap
 
 
 /**
@@ -50,27 +49,8 @@ class DatabaseInputKDB(database: DatabaseKDB)
 
     @Throws(LoadDatabaseException::class)
     override fun openDatabase(databaseInputStream: InputStream,
-                              password: String?,
+                              progressTaskUpdater: ProgressTaskUpdater?,
-                              keyfileInputStream: InputStream?,
+                              assignMasterKey: (() -> Unit)): DatabaseKDB {
-                              progressTaskUpdater: ProgressTaskUpdater?): DatabaseKDB {
-        return openDatabase(databaseInputStream, progressTaskUpdater) {
-            mDatabase.retrieveMasterKey(password, keyfileInputStream)
-        }
-    }
-
-    @Throws(LoadDatabaseException::class)
-    override fun openDatabase(databaseInputStream: InputStream,
-                              masterKey: ByteArray,
-                              progressTaskUpdater: ProgressTaskUpdater?): DatabaseKDB {
-        return openDatabase(databaseInputStream, progressTaskUpdater) {
-            mDatabase.masterKey = masterKey
-        }
-    }
-
-    @Throws(LoadDatabaseException::class)
-    private fun openDatabase(databaseInputStream: InputStream,
-                             progressTaskUpdater: ProgressTaskUpdater?,
-                             assignMasterKey: (() -> Unit)? = null): DatabaseKDB {
 
         try {
             startKeyTimer(progressTaskUpdater)
@@ -96,7 +76,7 @@ class DatabaseInputKDB(database: DatabaseKDB)
                 throw VersionDatabaseException()
             }
 
-            assignMasterKey?.invoke()
+            assignMasterKey.invoke()
 
             // Select algorithm
             when {

app/src/main/java/com/kunzisoft/keepass/database/file/input/DatabaseInputKDBX.kt

@@ -101,27 +101,8 @@ class DatabaseInputKDBX(database: DatabaseKDBX)
 
     @Throws(LoadDatabaseException::class)
     override fun openDatabase(databaseInputStream: InputStream,
-                              password: String?,
+                              progressTaskUpdater: ProgressTaskUpdater?,
-                              keyfileInputStream: InputStream?,
+                              assignMasterKey: (() -> Unit)): DatabaseKDBX {
-                              progressTaskUpdater: ProgressTaskUpdater?): DatabaseKDBX {
-        return openDatabase(databaseInputStream, progressTaskUpdater) {
-            mDatabase.retrieveMasterKey(password, keyfileInputStream)
-        }
-    }
-
-    @Throws(LoadDatabaseException::class)
-    override fun openDatabase(databaseInputStream: InputStream,
-                              masterKey: ByteArray,
-                              progressTaskUpdater: ProgressTaskUpdater?): DatabaseKDBX {
-        return openDatabase(databaseInputStream, progressTaskUpdater) {
-            mDatabase.masterKey = masterKey
-        }
-    }
-
-    @Throws(LoadDatabaseException::class)
-    private fun openDatabase(databaseInputStream: InputStream,
-                             progressTaskUpdater: ProgressTaskUpdater?,
-                             assignMasterKey: (() -> Unit)? = null): DatabaseKDBX {
         try {
             startKeyTimer(progressTaskUpdater)
 
@@ -133,7 +114,7 @@ class DatabaseInputKDBX(database: DatabaseKDBX)
             hashOfHeader = headerAndHash.hash
             val pbHeader = headerAndHash.header
 
-            assignMasterKey?.invoke()
+            assignMasterKey.invoke()
             mDatabase.makeFinalKey(header.masterSeed)
 
             stopKeyTimer()