272 lines
12 KiB
Kotlin
272 lines
12 KiB
Kotlin
package sushi.hardcore.droidfs.add_volume
|
|
|
|
import android.annotation.SuppressLint
|
|
import android.os.Build
|
|
import android.os.Bundle
|
|
import android.text.InputType
|
|
import android.view.LayoutInflater
|
|
import android.view.View
|
|
import android.view.ViewGroup
|
|
import android.widget.AdapterView
|
|
import android.widget.ArrayAdapter
|
|
import android.widget.Toast
|
|
import androidx.appcompat.app.AppCompatActivity
|
|
import androidx.fragment.app.Fragment
|
|
import androidx.lifecycle.lifecycleScope
|
|
import sushi.hardcore.droidfs.*
|
|
import sushi.hardcore.droidfs.databinding.FragmentCreateVolumeBinding
|
|
import sushi.hardcore.droidfs.filesystems.CryfsVolume
|
|
import sushi.hardcore.droidfs.filesystems.EncryptedVolume
|
|
import sushi.hardcore.droidfs.filesystems.GocryptfsVolume
|
|
import sushi.hardcore.droidfs.util.Compat
|
|
import sushi.hardcore.droidfs.util.ObjRef
|
|
import sushi.hardcore.droidfs.util.UIUtils
|
|
import sushi.hardcore.droidfs.widgets.CustomAlertDialogBuilder
|
|
import java.io.File
|
|
import java.util.*
|
|
|
|
class CreateVolumeFragment: Fragment() {
|
|
companion object {
|
|
private const val KEY_THEME_VALUE = "theme"
|
|
private const val KEY_VOLUME_PATH = "path"
|
|
private const val KEY_IS_HIDDEN = "hidden"
|
|
private const val KEY_REMEMBER_VOLUME = "remember"
|
|
private const val KEY_PIN_PASSWORDS = Constants.PIN_PASSWORDS_KEY
|
|
private const val KEY_USF_FINGERPRINT = "fingerprint"
|
|
|
|
fun newInstance(
|
|
theme: Theme,
|
|
volumePath: String,
|
|
isHidden: Boolean,
|
|
rememberVolume: Boolean,
|
|
pinPasswords: Boolean,
|
|
usfFingerprint: Boolean,
|
|
): CreateVolumeFragment {
|
|
return CreateVolumeFragment().apply {
|
|
arguments = Bundle().apply {
|
|
putParcelable(KEY_THEME_VALUE, theme)
|
|
putString(KEY_VOLUME_PATH, volumePath)
|
|
putBoolean(KEY_IS_HIDDEN, isHidden)
|
|
putBoolean(KEY_REMEMBER_VOLUME, rememberVolume)
|
|
putBoolean(KEY_PIN_PASSWORDS, pinPasswords)
|
|
putBoolean(KEY_USF_FINGERPRINT, usfFingerprint)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private lateinit var binding: FragmentCreateVolumeBinding
|
|
private lateinit var theme: Theme
|
|
private val volumeTypes = ArrayList<String>(2)
|
|
private lateinit var volumePath: String
|
|
private var isHiddenVolume: Boolean = false
|
|
private var rememberVolume: Boolean = false
|
|
private var usfFingerprint: Boolean = false
|
|
private lateinit var volumeDatabase: VolumeDatabase
|
|
private var fingerprintProtector: FingerprintProtector? = null
|
|
private var hashStorageReset = false
|
|
|
|
override fun onCreateView(
|
|
inflater: LayoutInflater,
|
|
container: ViewGroup?,
|
|
savedInstanceState: Bundle?
|
|
): View {
|
|
binding = FragmentCreateVolumeBinding.inflate(layoutInflater, container, false)
|
|
return binding.root
|
|
}
|
|
|
|
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
|
|
val pinPasswords = requireArguments().let { arguments ->
|
|
theme = Compat.getParcelable(arguments, KEY_THEME_VALUE)!!
|
|
volumePath = arguments.getString(KEY_VOLUME_PATH)!!
|
|
isHiddenVolume = arguments.getBoolean(KEY_IS_HIDDEN)
|
|
rememberVolume = arguments.getBoolean(KEY_REMEMBER_VOLUME)
|
|
usfFingerprint = arguments.getBoolean(KEY_USF_FINGERPRINT)
|
|
arguments.getBoolean(KEY_PIN_PASSWORDS)
|
|
}
|
|
volumeDatabase = VolumeDatabase(requireContext())
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
|
|
fingerprintProtector = FingerprintProtector.new(requireActivity(), theme, volumeDatabase)
|
|
}
|
|
if (!rememberVolume || !usfFingerprint || fingerprintProtector == null) {
|
|
binding.checkboxSavePassword.visibility = View.GONE
|
|
}
|
|
if (!BuildConfig.GOCRYPTFS_DISABLED) {
|
|
volumeTypes.add(resources.getString(R.string.gocryptfs))
|
|
}
|
|
if (!BuildConfig.CRYFS_DISABLED) {
|
|
volumeTypes.add(resources.getString(R.string.cryfs))
|
|
}
|
|
binding.spinnerVolumeType.adapter = ArrayAdapter(
|
|
requireContext(),
|
|
android.R.layout.simple_spinner_item,
|
|
volumeTypes
|
|
).apply {
|
|
setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
|
|
}
|
|
val encryptionCipherAdapter = ArrayAdapter(
|
|
requireContext(),
|
|
android.R.layout.simple_spinner_item,
|
|
resources.getStringArray(R.array.gocryptfs_encryption_ciphers).toMutableList()
|
|
).apply {
|
|
setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
|
|
}
|
|
binding.spinnerVolumeType.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
|
|
override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
|
|
val ciphersArray = if (volumeTypes[position] == resources.getString(R.string.gocryptfs)) {
|
|
R.array.gocryptfs_encryption_ciphers
|
|
} else {
|
|
R.array.cryfs_encryption_ciphers
|
|
}
|
|
with(encryptionCipherAdapter) {
|
|
clear()
|
|
addAll(resources.getStringArray(ciphersArray).asList())
|
|
}
|
|
}
|
|
override fun onNothingSelected(parent: AdapterView<*>?) {}
|
|
}
|
|
binding.spinnerCipher.adapter = encryptionCipherAdapter
|
|
if (pinPasswords) {
|
|
arrayOf(binding.editPassword, binding.editPasswordConfirm).forEach {
|
|
it.inputType = InputType.TYPE_CLASS_NUMBER or InputType.TYPE_NUMBER_VARIATION_PASSWORD
|
|
}
|
|
}
|
|
binding.editPasswordConfirm.setOnEditorActionListener { _, _, _ ->
|
|
createVolume()
|
|
true
|
|
}
|
|
binding.buttonCreate.setOnClickListener {
|
|
createVolume()
|
|
}
|
|
}
|
|
|
|
override fun onViewStateRestored(savedInstanceState: Bundle?) {
|
|
super.onViewStateRestored(savedInstanceState)
|
|
(activity as AddVolumeActivity).onFragmentLoaded(false)
|
|
}
|
|
|
|
private fun createVolume() {
|
|
val password = UIUtils.encodeEditTextContent(binding.editPassword)
|
|
val passwordConfirm = UIUtils.encodeEditTextContent(binding.editPasswordConfirm)
|
|
if (!password.contentEquals(passwordConfirm)) {
|
|
Toast.makeText(requireContext(), R.string.passwords_mismatch, Toast.LENGTH_SHORT).show()
|
|
Arrays.fill(password, 0)
|
|
Arrays.fill(passwordConfirm, 0)
|
|
} else {
|
|
Arrays.fill(passwordConfirm, 0)
|
|
val returnedHash: ObjRef<ByteArray?>? = if (binding.checkboxSavePassword.isChecked) {
|
|
ObjRef(null)
|
|
} else {
|
|
null
|
|
}
|
|
val encryptedVolume = ObjRef<EncryptedVolume?>(null)
|
|
object: LoadingTask<Byte>(requireActivity() as AppCompatActivity, theme, R.string.loading_msg_create) {
|
|
private fun generateResult(success: Boolean, volumeType: Byte): Byte {
|
|
return if (success) {
|
|
volumeType
|
|
} else {
|
|
-1
|
|
}
|
|
}
|
|
|
|
override suspend fun doTask(): Byte {
|
|
val volumeFile = File(volumePath)
|
|
if (!volumeFile.exists())
|
|
volumeFile.mkdirs()
|
|
val result = if (volumeTypes[binding.spinnerVolumeType.selectedItemPosition] == resources.getString(R.string.gocryptfs)) {
|
|
val xchacha = when (binding.spinnerCipher.selectedItemPosition) {
|
|
0 -> 0
|
|
1 -> 1
|
|
else -> -1
|
|
}
|
|
generateResult(GocryptfsVolume.createAndOpenVolume(
|
|
volumePath,
|
|
password,
|
|
false,
|
|
xchacha,
|
|
returnedHash?.apply {
|
|
value = ByteArray(GocryptfsVolume.KeyLen)
|
|
}?.value,
|
|
encryptedVolume,
|
|
), EncryptedVolume.GOCRYPTFS_VOLUME_TYPE)
|
|
} else {
|
|
encryptedVolume.value = CryfsVolume.create(
|
|
volumePath,
|
|
CryfsVolume.getLocalStateDir(activity.filesDir.path),
|
|
password,
|
|
returnedHash,
|
|
resources.getStringArray(R.array.cryfs_encryption_ciphers)[binding.spinnerCipher.selectedItemPosition],
|
|
)
|
|
generateResult(encryptedVolume.value != null, EncryptedVolume.CRYFS_VOLUME_TYPE)
|
|
}
|
|
Arrays.fill(password, 0)
|
|
return result
|
|
}
|
|
}.startTask(lifecycleScope) { result ->
|
|
if (result.compareTo(-1) == 0) {
|
|
CustomAlertDialogBuilder(requireContext(), theme)
|
|
.setTitle(R.string.error)
|
|
.setMessage(R.string.create_volume_failed)
|
|
.setPositiveButton(R.string.ok, null)
|
|
.show()
|
|
} else {
|
|
val volumeName = if (isHiddenVolume) File(volumePath).name else volumePath
|
|
val volume = VolumeData(VolumeData.newUuid(), volumeName, isHiddenVolume, result)
|
|
var isVolumeSaved = false
|
|
volumeDatabase.apply {
|
|
if (isVolumeSaved(volumeName, isHiddenVolume)) // cleaning old saved path
|
|
removeVolume(volume)
|
|
if (rememberVolume) {
|
|
isVolumeSaved = saveVolume(volume)
|
|
}
|
|
}
|
|
val volumeId = encryptedVolume.value?.let {
|
|
(activity?.application as VolumeManagerApp).volumeManager.insert(it, volume)
|
|
}
|
|
@SuppressLint("NewApi") // if fingerprintProtector is null checkboxSavePassword is hidden
|
|
if (isVolumeSaved && binding.checkboxSavePassword.isChecked && returnedHash != null) {
|
|
fingerprintProtector!!.let {
|
|
it.listener = object : FingerprintProtector.Listener {
|
|
override fun onHashStorageReset() {
|
|
hashStorageReset = true
|
|
// retry
|
|
it.savePasswordHash(volume, returnedHash.value!!)
|
|
}
|
|
override fun onPasswordHashDecrypted(hash: ByteArray) {} // shouldn't happen here
|
|
override fun onPasswordHashSaved() {
|
|
Arrays.fill(returnedHash.value!!, 0)
|
|
onVolumeCreated(volumeId, volume.shortName)
|
|
}
|
|
override fun onFailed(pending: Boolean) {
|
|
if (!pending) {
|
|
Arrays.fill(returnedHash.value!!, 0)
|
|
onVolumeCreated(volumeId, volume.shortName)
|
|
}
|
|
}
|
|
}
|
|
it.savePasswordHash(volume, returnedHash.value!!)
|
|
}
|
|
} else {
|
|
onVolumeCreated(volumeId, volume.shortName)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun onVolumeCreated(id: Int?, volumeShortName: String) {
|
|
(activity as AddVolumeActivity).apply {
|
|
if (id == null) {
|
|
finish()
|
|
} else {
|
|
startExplorer(id, volumeShortName)
|
|
}
|
|
}
|
|
}
|
|
|
|
override fun onStop() {
|
|
super.onStop()
|
|
binding.editPassword.text.clear()
|
|
binding.editPasswordConfirm.text.clear()
|
|
}
|
|
} |