oxidiert/Questionnaire-App
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added super simple token system

Browse Source
This commit is contained in:
oxidiert
2025-08-11 15:44:11 +02:00
parent 0052d1908a
commit a074146eb9
2 changed files with 13 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
app/src/main/java/com/dano/test1/DatabaseDownloader.kt
View File

@ -13,7 +13,8 @@ import java.io.FileOutputStream
object DatabaseDownloader {
private const val DB_NAME = "questionnaire_database"
private const val SERVER_DOWNLOAD_URL = "http://49.13.157.44/uploads/exported_encrypted_database.db"
private const val API_TOKEN = "MEIN_SUPER_GEHEIMES_TOKEN_12345"
private const val SERVER_DOWNLOAD_URL = "http://49.13.157.44/download.php?token=$API_TOKEN"
private val client = OkHttpClient()
@ -32,7 +33,6 @@ object DatabaseDownloader {
return@launch
}
// Temporäre verschlüsselte Datei speichern
val encryptedFile = File(context.cacheDir, "downloaded_encrypted_database.db")
response.body?.byteStream()?.use { input ->
FileOutputStream(encryptedFile).use { output ->
@ -41,53 +41,18 @@ object DatabaseDownloader {
}
Log.d("DOWNLOAD", "Verschlüsselte Datei gespeichert: ${encryptedFile.absolutePath}")
// Datei entschlüsseln (hier deine echte Entschlüsselungslogik einfügen)
val decryptedFile = File(context.cacheDir, "decrypted_database.db")
decryptDatabase(encryptedFile, decryptedFile)
Log.d("DOWNLOAD", "Datei entschlüsselt: ${decryptedFile.absolutePath}")
AES256Helper.decryptFile(encryptedFile, decryptedFile)
// Alte DB ersetzen
val dbFile = context.getDatabasePath(DB_NAME)
if (dbFile.exists()) {
if (dbFile.delete()) {
Log.d("DOWNLOAD", "Alte Datenbank gelöscht.")
} else {
Log.e("DOWNLOAD", "Löschen der alten Datenbank fehlgeschlagen!")
return@launch
}
}
if (dbFile.exists()) dbFile.delete()
decryptedFile.copyTo(dbFile, overwrite = true)
Log.d("DOWNLOAD", "Neue Datenbank erfolgreich eingesetzt")
// Datenbankinhalt nach Download ausgeben (Hex-String)
logFileContentAsHex(dbFile, "DOWNLOAD")
Log.d("DOWNLOAD", "Neue DB erfolgreich eingesetzt")
} catch (e: Exception) {
Log.e("DOWNLOAD", "Fehler beim Download oder Ersetzen der DB", e)
}
}
}
private fun decryptDatabase(encryptedFile: File, outputFile: File) {
AES256Helper.decryptFile(encryptedFile, outputFile)
}
private fun logFileContentAsHex(file: File, tag: String) {
try {
val bytes = file.readBytes()
// Zum Loggen den Hex-String in Blöcke teilen, max 4000 Zeichen pro Log (Android Logcat Limit)
val hexString = bytes.joinToString(separator = "") { "%02X".format(it) }
val chunkSize = 4000
var start = 0
while (start < hexString.length) {
val end = (start + chunkSize).coerceAtMost(hexString.length)
Log.d(tag, "DB HEX Content: ${hexString.substring(start, end)}")
start = end
}
} catch (e: Exception) {
Log.e(tag, "Fehler beim Lesen der Datei zum Loggen", e)
}
}
}

38
app/src/main/java/com/dano/test1/DatabaseUploader.kt
View File

@ -6,17 +6,18 @@ import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import okhttp3.*
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.RequestBody.Companion.asRequestBody
import java.io.File
import java.io.IOException
import kotlin.system.exitProcess
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.RequestBody.Companion.asRequestBody
object DatabaseUploader {
private const val DB_NAME = "questionnaire_database"
private const val ENCRYPTED_FILE_NAME = "exported_encrypted_database.db"
private const val SERVER_UPLOAD_URL = "http://49.13.157.44/upload.php"
private const val API_TOKEN = "MEIN_SUPER_GEHEIMES_TOKEN_12345"
private val client = OkHttpClient()
@ -26,13 +27,12 @@ object DatabaseUploader {
val dbFile = context.getDatabasePath(DB_NAME)
if (!dbFile.exists()) return@launch
// Verschlüsselte Datei erstellen
val encryptedFile = File(context.cacheDir, ENCRYPTED_FILE_NAME)
AES256Helper.encryptFile(dbFile, encryptedFile)
Log.d("UPLOAD", "Datei verschlüsselt: ${encryptedFile.absolutePath}")
uploadFile(context, encryptedFile, dbFile)
uploadFile(encryptedFile, dbFile)
} catch (e: Exception) {
Log.e("UPLOAD", "Fehler beim Hochladen der DB", e)
@ -40,14 +40,14 @@ object DatabaseUploader {
}
}
private fun uploadFile(context: Context, file: File, originalDbFile: File) {
private fun uploadFile(file: File, originalDbFile: File) {
val requestBody = MultipartBody.Builder()
.setType(MultipartBody.FORM)
.addFormDataPart(
"file", file.name,
file.asRequestBody("application/octet-stream".toMediaTypeOrNull())
)
.addFormDataPart("token", API_TOKEN)
.build()
val request = Request.Builder()
@ -63,16 +63,11 @@ object DatabaseUploader {
override fun onResponse(call: Call, response: Response) {
if (response.isSuccessful) {
Log.d("UPLOAD", "Upload erfolgreich: ${response.message}")
// Lokale DB-Datei löschen
if (originalDbFile.delete()) {
Log.d("UPLOAD", "Lokale Datenbank erfolgreich gelöscht.")
// App schließen
Log.d("UPLOAD", "App wird beendet.")
Log.d("UPLOAD", "Lokale DB gelöscht.")
exitProcess(0)
} else {
Log.e("UPLOAD", "Löschen der lokalen Datenbank fehlgeschlagen.")
Log.e("UPLOAD", "Löschen der lokalen DB fehlgeschlagen.")
}
} else {
Log.e("UPLOAD", "Upload fehlgeschlagen: ${response.code} ${response.message}")
@ -80,21 +75,4 @@ object DatabaseUploader {
}
})
}
private fun logFileContentAsHex(file: File, tag: String) {
try {
val bytes = file.readBytes()
// Zum Loggen den Hex-String in Blöcke teilen, max 4000 Zeichen pro Log (Android Logcat Limit)
val hexString = bytes.joinToString(separator = "") { "%02X".format(it) }
val chunkSize = 4000
var start = 0
while (start < hexString.length) {
val end = (start + chunkSize).coerceAtMost(hexString.length)
Log.d(tag, "DB HEX Content: ${hexString.substring(start, end)}")
start = end
}
} catch (e: Exception) {
Log.e(tag, "Fehler beim Lesen der Datei zum Loggen", e)
}
}
}