Compare commits
22 Commits
| Author | SHA1 | Date |
|---|---|---|
 Hardcore Sushi
|
e2539a53b9
|
1 month ago |
|
Hardcore Sushi
|
17c32f2144
|
1 month ago |
|
Hardcore Sushi
|
a5b6de1138
|
2 months ago |
|
Hardcore Sushi
|
d1ca164934
|
2 months ago |
|
Hardcore Sushi
|
1a21a43f05
|
2 months ago |
|
Hardcore Sushi
|
4d164944c1
|
2 months ago |
|
Hardcore Sushi
|
8709abd7d7
|
2 months ago |
|
Hardcore Sushi
|
e01932acda
|
2 months ago |
|
Hardcore Sushi
|
cf4927a90b
|
2 months ago |
CyanWolf
|
cb5679515c
|
2 months ago |
|
Muhmmad14333653
|
a728bd8d24
|
2 months ago |
|
Hardcore Sushi
|
83dd759f36
|
3 months ago |
|
Hardcore Sushi
|
5144947a4a
|
3 months ago |
|
Muhmmad14333653
|
6b52eed9d0
|
3 months ago |
|
Muhmmad14333653
|
2a257d91d0
|
3 months ago |
|
Hardcore Sushi
|
f837556af5
|
3 months ago |
|
Hardcore Sushi
|
b7ab267d16
|
3 months ago |
|
Hardcore Sushi
|
5ea0b8ad41
|
4 months ago |
|
Hardcore Sushi
|
ec348383c6
|
4 months ago |
|
Hardcore Sushi
|
c8d266150c
|
4 months ago |
|
CyanWolf
|
4bbc9360b4
|
4 months ago |
|
Hardcore Sushi
|
8aa2be2b05
|
4 months ago |
65 changed files with 2012 additions and 1015 deletions
@ -0,0 +1,108 @@
|
||||
# Introduction |
||||
DroidFS relies on modified versions of the original encrypted filesystems programs to open volumes. [CryFS](https://github.com/cryfs/cryfs) is written in C++ while [gocryptfs](https://github.com/rfjakob/gocryptfs) is written in [Go](https://golang.org). Thus, building DroidFS requires the compilation of native code. However, for the sake of simplicity, the application has been designed in a modular way: you can build a version of DroidFS that supports both Gocryptfs and CryFS, or only one of the two. |
||||
|
||||
Moreover, DroidFS aims to be accessible to as many people as possible. If you encounter any problems or need help with the build, feel free to open an issue, a discussion, or contact me by [email](mailto:hardcore.sushi@disroot.org) or on [Matrix](https://matrix.org): @hardcoresushi:matrix.underworld.fr |
||||
|
||||
# Setup |
||||
Install required packages: |
||||
``` |
||||
$ sudo apt-get install openjdk-11-jdk-headless build-essential pkg-config git gnupg2 wget apksigner |
||||
``` |
||||
You also need to manually install the [Android SDK](https://developer.android.com/studio/index.html#command-tools) and the [Android Native Development Kit (NDK)](https://developer.android.com/ndk/downloads) (r23 versions are recommended). |
||||
|
||||
If you want a support for Gocryptfs volumes, you must install [Go](https://golang.org/doc/install) and libssl: |
||||
``` |
||||
$ sudo apt-get install golang-go libssl-dev |
||||
``` |
||||
The code should be authenticated before being built. To verify the signatures, you will need my PGP key: |
||||
``` |
||||
$ gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys AFE384344A45E13A |
||||
``` |
||||
Fingerprint: `B64E FE86 CEE1 D054 F082 1711 AFE3 8434 4A45 E13A` \ |
||||
Email: `Hardcore Sushi <hardcore.sushi@disroot.org>` |
||||
|
||||
# Download sources |
||||
Download DroidFS source code: |
||||
``` |
||||
$ git clone --depth=1 https://forge.chapril.org/hardcoresushi/DroidFS.git |
||||
``` |
||||
Verify sources: |
||||
``` |
||||
$ cd DroidFS |
||||
$ git verify-commit HEAD |
||||
``` |
||||
__Don't continue if the verification fails!__ |
||||
|
||||
Initialize submodules: |
||||
``` |
||||
$ git submodule update --depth=1 --init |
||||
``` |
||||
[FFmpeg](https://ffmpeg.org) is needed to record encrypted video: |
||||
``` |
||||
$ cd app/ffmpeg |
||||
$ git clone --depth=1 https://git.ffmpeg.org/ffmpeg.git |
||||
``` |
||||
If you want Gocryptfs support, you need to download OpenSSL: |
||||
``` |
||||
$ cd ../libgocryptfs |
||||
$ wget https://www.openssl.org/source/openssl-1.1.1p.tar.gz |
||||
``` |
||||
Verify OpenSSL signature: |
||||
``` |
||||
$ wget https://www.openssl.org/source/openssl-1.1.1p.tar.gz.asc |
||||
$ gpg --verify openssl-1.1.1p.tar.gz.asc openssl-1.1.1p.tar.gz |
||||
``` |
||||
Continue **ONLY** if the signature is **VALID**. |
||||
``` |
||||
$ tar -xzf openssl-1.1.1p.tar.gz |
||||
``` |
||||
If you want CryFS support, initialize libcryfs: |
||||
``` |
||||
$ cd app/libcryfs |
||||
$ git submodule update --depth=1 --init |
||||
``` |
||||
|
||||
# Build |
||||
Retrieve your Android NDK installation path, usually something like `/home/\<user\>/Android/SDK/ndk/\<NDK version\>`. Then, make it available in your shell: |
||||
``` |
||||
$ export ANDROID_NDK_HOME="<your ndk path>" |
||||
``` |
||||
Start by compiling FFmpeg: |
||||
``` |
||||
$ cd app/ffmpeg |
||||
$ ./build.sh ffmpeg |
||||
``` |
||||
## libgocryptfs |
||||
This step is only required if you want Gocryptfs support. |
||||
``` |
||||
$ cd app/libgocryptfs |
||||
$ OPENSSL_PATH="./openssl-1.1.1p" ./build.sh |
||||
``` |
||||
## Compile APKs |
||||
Gradle build libgocryptfs and libcryfs by default. |
||||
|
||||
To build DroidFS without Gocryptfs support, run: |
||||
``` |
||||
$ ./gradlew assembleRelease -PdisableGocryptfs=true |
||||
``` |
||||
To build DroidFS without CryFS support, run: |
||||
``` |
||||
$ ./gradlew assembleRelease -PdisableCryFS=true |
||||
``` |
||||
If you want to build DroidFS with support for both Gocryptfs and CryFS, just run: |
||||
``` |
||||
$ ./gradlew assembleRelease |
||||
``` |
||||
|
||||
# Sign APKs |
||||
If the build succeeds, you will find the unsigned APKs in `app/build/outputs/apk/release/`. These APKs need to be signed in order to be installed on an Android device. |
||||
|
||||
If you don't already have a keystore, you can create a new one by running: |
||||
``` |
||||
$ keytool -genkey -keystore <output file> -alias <key alias> -keyalg EC -validity 10000 |
||||
``` |
||||
Then, sign the APK with: |
||||
``` |
||||
$ apksigner sign --out droidfs.apk -v --ks <keystore> app/build/outputs/apk/release/<unsigned apk file> |
||||
``` |
||||
Now you can install `droidfs.apk` on your device. |
||||
@ -1 +1 @@
|
||||
Subproject commit 985d8523434814cd9cba61b666a1f888bdcbaded |
||||
Subproject commit e6e4c201dbf3834de1a49a8b67b4b54239d24249 |
||||
@ -1,247 +0,0 @@
|
||||
package sushi.hardcore.droidfs |
||||
|
||||
import android.content.Context |
||||
import android.net.Uri |
||||
import sushi.hardcore.droidfs.explorers.ExplorerElement |
||||
import sushi.hardcore.droidfs.util.PathUtils |
||||
import java.io.File |
||||
import java.io.FileOutputStream |
||||
import java.io.InputStream |
||||
import java.io.OutputStream |
||||
|
||||
class GocryptfsVolume(val applicationContext: Context, var sessionID: Int) { |
||||
private external fun native_close(sessionID: Int) |
||||
private external fun native_is_closed(sessionID: Int): Boolean |
||||
private external fun native_list_dir(sessionID: Int, dir_path: String): MutableList<ExplorerElement> |
||||
private external fun native_open_read_mode(sessionID: Int, file_path: String): Int |
||||
private external fun native_open_write_mode(sessionID: Int, file_path: String, mode: Int): Int |
||||
private external fun native_read_file(sessionID: Int, handleID: Int, offset: Long, buff: ByteArray): Int |
||||
private external fun native_write_file(sessionID: Int, handleID: Int, offset: Long, buff: ByteArray, buff_size: Int): Int |
||||
private external fun native_truncate(sessionID: Int, handleID: Int, offset: Long): Boolean |
||||
private external fun native_path_exists(sessionID: Int, file_path: String): Boolean |
||||
private external fun native_get_size(sessionID: Int, file_path: String): Long |
||||
private external fun native_close_file(sessionID: Int, handleID: Int) |
||||
private external fun native_remove_file(sessionID: Int, file_path: String): Boolean |
||||
private external fun native_mkdir(sessionID: Int, dir_path: String, mode: Int): Boolean |
||||
private external fun native_rmdir(sessionID: Int, dir_path: String): Boolean |
||||
private external fun native_rename(sessionID: Int, old_path: String, new_path: String): Boolean |
||||
|
||||
companion object { |
||||
const val KeyLen = 32 |
||||
const val ScryptDefaultLogN = 16 |
||||
const val DefaultBS = 4096 |
||||
const val CONFIG_FILE_NAME = "gocryptfs.conf" |
||||
external fun createVolume(root_cipher_dir: String, password: CharArray, plainTextNames: Boolean, xchacha: Int, logN: Int, creator: String, returnedHash: ByteArray?): Boolean |
||||
external fun init(root_cipher_dir: String, password: CharArray?, givenHash: ByteArray?, returnedHash: ByteArray?): Int |
||||
external fun changePassword(root_cipher_dir: String, old_password: CharArray?, givenHash: ByteArray?, new_password: CharArray, returnedHash: ByteArray?): Boolean |
||||
|
||||
fun isGocryptfsVolume(path: File): Boolean { |
||||
if (path.isDirectory){ |
||||
return File(path, CONFIG_FILE_NAME).isFile |
||||
} |
||||
return false |
||||
} |
||||
|
||||
init { |
||||
System.loadLibrary("gocryptfs_jni") |
||||
} |
||||
} |
||||
|
||||
fun close() { |
||||
native_close(sessionID) |
||||
} |
||||
|
||||
fun isClosed(): Boolean { |
||||
return native_is_closed(sessionID) |
||||
} |
||||
|
||||
fun listDir(dir_path: String): MutableList<ExplorerElement> { |
||||
return native_list_dir(sessionID, dir_path) |
||||
} |
||||
|
||||
fun mkdir(dir_path: String): Boolean { |
||||
return native_mkdir(sessionID, dir_path, ConstValues.DIRECTORY_MODE) |
||||
} |
||||
|
||||
fun rmdir(dir_path: String): Boolean { |
||||
return native_rmdir(sessionID, dir_path) |
||||
} |
||||
|
||||
fun removeFile(file_path: String): Boolean { |
||||
return native_remove_file(sessionID, file_path) |
||||
} |
||||
|
||||
fun pathExists(file_path: String): Boolean { |
||||
return native_path_exists(sessionID, file_path) |
||||
} |
||||
|
||||
fun getSize(file_path: String): Long { |
||||
return native_get_size(sessionID, file_path) |
||||
} |
||||
|
||||
fun closeFile(handleID: Int) { |
||||
native_close_file(sessionID, handleID) |
||||
} |
||||
|
||||
fun openReadMode(file_path: String): Int { |
||||
return native_open_read_mode(sessionID, file_path) |
||||
} |
||||
|
||||
fun openWriteMode(file_path: String): Int { |
||||
return native_open_write_mode(sessionID, file_path, ConstValues.FILE_MODE) |
||||
} |
||||
|
||||
fun readFile(handleID: Int, offset: Long, buff: ByteArray): Int { |
||||
return native_read_file(sessionID, handleID, offset, buff) |
||||
} |
||||
|
||||
fun writeFile(handleID: Int, offset: Long, buff: ByteArray, buff_size: Int): Int { |
||||
return native_write_file(sessionID, handleID, offset, buff, buff_size) |
||||
} |
||||
|
||||
fun truncate(handleID: Int, offset: Long): Boolean { |
||||
return native_truncate(sessionID, handleID, offset) |
||||
} |
||||
|
||||
fun rename(old_path: String, new_path: String): Boolean { |
||||
return native_rename(sessionID, old_path, new_path) |
||||
} |
||||
|
||||
fun exportFile(handleID: Int, os: OutputStream): Boolean { |
||||
var offset: Long = 0 |
||||
val ioBuffer = ByteArray(DefaultBS) |
||||
var length: Int |
||||
while (readFile(handleID, offset, ioBuffer).also { length = it } > 0){ |
||||
os.write(ioBuffer, 0, length) |
||||
offset += length.toLong() |
||||
} |
||||
os.close() |
||||
return true |
||||
} |
||||
|
||||
fun exportFile(src_path: String, os: OutputStream): Boolean { |
||||
var success = false |
||||
val srcHandleId = openReadMode(src_path) |
||||
if (srcHandleId != -1) { |
||||
success = exportFile(srcHandleId, os) |
||||
closeFile(srcHandleId) |
||||
} |
||||
return success |
||||
} |
||||
|
||||
fun exportFile(src_path: String, dst_path: String): Boolean { |
||||
return exportFile(src_path, FileOutputStream(dst_path)) |
||||
} |
||||
|
||||
fun exportFile(context: Context, src_path: String, output_path: Uri): Boolean { |
||||
val os = context.contentResolver.openOutputStream(output_path) |
||||
if (os != null){ |
||||
return exportFile(src_path, os) |
||||
} |
||||
return false |
||||
} |
||||
|
||||
fun importFile(inputStream: InputStream, handleID: Int): Boolean { |
||||
var offset: Long = 0 |
||||
val ioBuffer = ByteArray(DefaultBS) |
||||
var length: Int |
||||
while (inputStream.read(ioBuffer).also { length = it } > 0) { |
||||
val written = writeFile(handleID, offset, ioBuffer, length).toLong() |
||||
if (written == length.toLong()) { |
||||
offset += written |
||||
} else { |
||||
inputStream.close() |
||||
return false |
||||
} |
||||
} |
||||
closeFile(handleID) |
||||
inputStream.close() |
||||
return true |
||||
} |
||||
|
||||
fun importFile(inputStream: InputStream, dst_path: String): Boolean { |
||||
var success = false |
||||
val dstHandleId = openWriteMode(dst_path) |
||||
if (dstHandleId != -1) { |
||||
success = importFile(inputStream, dstHandleId) |
||||
closeFile(dstHandleId) |
||||
} |
||||
return success |
||||
} |
||||
|
||||
fun importFile(context: Context, src_uri: Uri, dst_path: String): Boolean { |
||||
val inputStream = context.contentResolver.openInputStream(src_uri) |
||||
if (inputStream != null){ |
||||
return importFile(inputStream, dst_path) |
||||
} |
||||
return false |
||||
} |
||||
|
||||
fun recursiveMapFiles(rootPath: String): MutableList<ExplorerElement> { |
||||
val result = mutableListOf<ExplorerElement>() |
||||
val explorerElements = listDir(rootPath) |
||||
result.addAll(explorerElements) |
||||
for (e in explorerElements){ |
||||
if (e.isDirectory){ |
||||
result.addAll(recursiveMapFiles(e.fullPath)) |
||||
} |
||||
} |
||||
return result |
||||
} |
||||
|
||||
fun recursiveRemoveDirectory(plain_directory_path: String): String? { |
||||
val explorerElements = listDir(plain_directory_path) |
||||
for (e in explorerElements) { |
||||
val fullPath = PathUtils.pathJoin(plain_directory_path, e.name) |
||||
if (e.isDirectory) { |
||||
val result = recursiveRemoveDirectory(fullPath) |
||||
result?.let { return it } |
||||
} else { |
||||
if (!removeFile(fullPath)) { |
||||
return fullPath |
||||
} |
||||
} |
||||
} |
||||
return if (!rmdir(plain_directory_path)) { |
||||
plain_directory_path |
||||
} else { |
||||
null |
||||
} |
||||
} |
||||
|
||||
fun loadWholeFile(fullPath: String, size: Long? = null, maxSize: Long? = null): Pair<ByteArray?, Int> { |
||||
val fileSize = size ?: getSize(fullPath) |
||||
return if (fileSize >= 0) { |
||||
maxSize?.let { |
||||
if (fileSize > it) { |
||||
return Pair(null, 0) |
||||
} |
||||
} |
||||
try { |
||||
val fileBuff = ByteArray(fileSize.toInt()) |
||||
val handleID = openReadMode(fullPath) |
||||
if (handleID == -1) { |
||||
Pair(null, 3) |
||||
} else { |
||||
var offset: Long = 0 |
||||
val ioBuffer = ByteArray(DefaultBS) |
||||
var length: Int |
||||
while (readFile(handleID, offset, ioBuffer).also { length = it } > 0) { |
||||
System.arraycopy(ioBuffer, 0, fileBuff, offset.toInt(), length) |
||||
offset += length.toLong() |
||||
} |
||||
closeFile(handleID) |
||||
if (offset == fileBuff.size.toLong()) { |
||||
Pair(fileBuff, 0) |
||||
} else { |
||||
Pair(null, 4) |
||||
} |
||||
} |
||||
} catch (e: OutOfMemoryError) { |
||||
Pair(null, 2) |
||||
} |
||||
} else { |
||||
Pair(null, 1) |
||||
} |
||||
} |
||||
} |
||||