iLocker™ Sichere Notizen
Private Notizen sicher schützen
Bekannt aus:
Notizen. Einfach. Sicher.
Mit der neuen iLocker™ Sichere Notizen App lassen sich ganz einfach und hochsicher private Notizen schreiben und sogar sichere Sprachmemos aufzeichnen.
Alle persönlichen Notizen werden automatisch verschlüsselt, können übersichtlich organisiert und individuellen Kategorien zugeordnet werden. So lässt sich auch farblich die Wichtigkeit einer geschriebenen Notiz schnell erfassen.
-
AES-256
-
Sicheres Diktiergerät
-
Selbstzerstörung
-
Deep Detective™
Mit AES-256 Bit militärisch sicher
iLocker™ Sichere Notizen funktioniert wie ein Safe, der alle Notizen und Sprachmemos sicher aufbewahrt. Mit modernen Sicherheitstechnologien speichert iLocker™ alle Daten verschlüsselt mit dem starken 256-Bit AES (Advanced Encryption Standard) Algorithmus.
Das AES-256 Bit Verschlüsselungsverfahren gehört zu den sichersten der Welt und wird zum Beispiel für das Verschlüsseln streng geheimer Dokumente beim Militär eingesetzt.
Sicheres Diktiergerät:
Wichtige Momente aufzeichnen
Das integrierte Diktiergerät ist der ideale Begleiter, um wichtige Momente sicher festzuhalten. Es kann als reguläres Diktiergerät für die Aufnahme von Sprachnotizen, Memos, Geschäftstreffen, Interviews, uvw. verwendet werden.
Das minimalistische Design erlaubt einfache Bedienung und bietet ein qualitativ hochwertiges Aufnahmeerlebnis.
Im Notfall: Selbstzerstörung
In besonderen Notfällen sind die privaten Notizen und Sprachaufzeichnungen sicher. Sollte das Android Smartphone verloren oder gestohlen werden, werden bei aktivierter Selbstzerstörung nach 5 ungültigen Passworteingaben alle Daten automatisch zerstört.
Dabei wird nicht nur gelöscht, sondern der komplette Notiz-Safe mit zertifizierten Löschverfahren sicher vernichtet. Die Löschtechnologien hierfür stammen von dem mehrfach ausgezeichneten und beliebten iShredder™.
Intelligenter Hackerschutz:
Deep Detective™
Mit dem Deep Detective™ haben wir im Jahr 2016 einen intelligenten Detektiv erschaffen, der alle Zugriffe überwacht - ähnlich einer Firewall - nur viel smarter.
In iLocker™ Sichere Notizen kontrolliert Deep Detective™ permanent welcher Prozess oder App gerade auf die verschlüsselten Daten des Safes zugreifen möchte. Zudem meldet es bekannte - wie auch Dank modernen heuristischen Methoden - unbekannte Angriffsversuche.
Garantiert keine Hintertüren
Die Verschlüsselung der Daten geschieht direkt auf dem Gerät, und symmetrische Kryptografie garantiert, dass nur der Nutzer selbst auf seine Notizen zugreifen kann. Ohne oder vergessenem Kennwort kann nicht mehr auf die Notizen zugegriffen oder die privaten Daten entschlüsselt werden. Zudem wird der Passcode nicht auf dem Gerät gespeichert.
ProtectStar™ garantiert, dass keine Hintertüren oder Masterkennwörter in iLocker™ versteckt sind. Aus Transparenzgründen werden der verwendete symmetrische Verschlüsselungsalgorithmus, zur eigenen Analyse als Download bereitgestellt.
package com.protectstar.ilockersecurenotes.encryption
import com.protectstar.ilockersecurenotes.utils.StringUtils
import java.security.GeneralSecurityException
import java.security.Key
import java.security.SecureRandom
import javax.crypto.Cipher
import javax.crypto.spec.IvParameterSpec
import javax.crypto.spec.SecretKeySpec
class Encrypter(val secretKey: String, seedValue: String) {
@Throws(CryptoException::class)
fun encrypt(data: String): String {
val dataBytes = StringUtils.toBytes(data)
val key = generateKey()
// Create random initialization vector.
val initVector = ByteArray(IV_LENGTH)
_secureRandom.nextBytes(initVector)
val encryptedBytes: ByteArray
try {
val cipher = Cipher.getInstance("AES/CBC/PKCS7Padding")
cipher.init(Cipher.ENCRYPT_MODE, key, IvParameterSpec(initVector))
encryptedBytes = cipher.doFinal(dataBytes)
} catch (ex: GeneralSecurityException) {
throw CryptoException(ex)
}
// result is initVector + encryptedBytes.
val result = ByteArray(initVector.size + encryptedBytes.size)
System.arraycopy(initVector, 0, result, 0, initVector.size)
System.arraycopy(encryptedBytes, 0, result, initVector.size, encryptedBytes.size)
return StringUtils.toBase64(result)
}
@Throws(CryptoException::class)
fun decrypt(data: String): String {
val dataBytes: ByteArray
try {
dataBytes = StringUtils.fromBase64(data)
} catch (ex: IllegalArgumentException) {
throw CryptoException("base64 failed to decode.", ex)
}
if (dataBytes.size < IV_LENGTH) {
throw CryptoException("Value to decrypt is too short.")
}
val key = generateKey()
try {
val cipher = Cipher.getInstance("AES/CBC/PKCS7Padding")
cipher.init(Cipher.DECRYPT_MODE, key, IvParameterSpec(dataBytes, 0, IV_LENGTH))
return StringUtils.toString(
cipher.doFinal(dataBytes, IV_LENGTH, dataBytes.size - IV_LENGTH))
} catch (ex: GeneralSecurityException) {
throw CryptoException(ex)
}
}
@Throws(CryptoException::class)
private fun generateKey(): Key {
return SecretKeySpec(
CryptoUtils.P_SHA256(StringUtils.toBytes(secretKey), StringUtils.toBytes(secretKey),
16), "AES")
}
companion object {
private val IV_LENGTH = 16
private val _secureRandom = SecureRandom()
}
}
package com.protectstar.ilockersecurenotes.encryption
import java.security.InvalidKeyException
import java.security.NoSuchAlgorithmException
import javax.crypto.Mac
import javax.crypto.spec.SecretKeySpec
internal object CryptoUtils {
@Throws(CryptoException::class)
fun P_SHA256(secret: ByteArray, seed: ByteArray, required: Int): ByteArray {
var required = required
val mac: Mac
try {
mac = Mac.getInstance("HmacSHA256")
} catch (ex: NoSuchAlgorithmException) {
val errMessage = "Error in createTokenSecret: " + ex.localizedMessage
throw CryptoException(errMessage, ex)
}
val out = ByteArray(required)
var offset = 0
var tocpy: Int
var A: ByteArray
var tmp: ByteArray
A = seed // A(0)
while (required > 0) {
val key = SecretKeySpec(secret, "HMACSHA256")
try {
mac.init(key)
mac.update(A)
A = mac.doFinal() // A(1)
mac.reset()
mac.init(key)
mac.update(A) // A(1)
mac.update(seed)
tmp = mac.doFinal() // HMAC_SHA-256(secret, A(1) + seed)
tocpy = min(required, tmp.size)
System.arraycopy(tmp, 0, out, offset, tocpy)
offset += tocpy
required -= tocpy
} catch (ex: InvalidKeyException) {
val errMessage = "Error in P_SHA256: " + ex.localizedMessage
throw CryptoException(errMessage, ex)
}
}
return out
}
/**
* @return The minimum of two int values.
*/
private fun min(a: Int, b: Int): Int {
return if (a > b) b else a
}
}
package com.protectstar.ilockersecurenotes.encryption
import android.content.Context
import com.protectstar.ilockersecurenotes.NoteApplication
import com.protectstar.ilockersecurenotes.utils.BitmapUtils
import com.protectstar.ilockersecurenotes.utils.FileUtils
import io.reactivex.BackpressureStrategy
import io.reactivex.Flowable
import java.io.File
import java.io.FileOutputStream
import java.io.FileInputStream
interface MediaEncrypter {
fun encryptImage(filePath: String, reqWidth: Int, reqHeight: Int): Flowable
fun decryptImage(encryptedFilePath: String): Flowable
fun encryptAudio(filePath: String): Flowable
fun decryptAudio(context: Context, filePath: String): Flowable
}
class Base64MediaEncrypter(val encrypter: Encrypter) : MediaEncrypter {
override fun encryptImage(filePath: String, reqWidth: Int, reqHeight: Int): Flowable {
return Flowable.create({ emitter ->
val fileName = "${System.currentTimeMillis()}.enc"
val bitmap = BitmapUtils.loadBitmapFromFile(filePath, reqWidth, reqHeight)
val base64 = BitmapUtils.encodeToBase64(bitmap)
val encrypted = encrypter.encrypt(base64)
val path = writeToFile(NoteApplication.instance, encrypted.toByteArray(), fileName)
emitter.onNext(path)
emitter.onComplete()
}, BackpressureStrategy.BUFFER)
}
override fun decryptImage(encryptedFilePath: String): Flowable {
return Flowable.create({ emitter ->
val fileName = FileUtils.getFileNameWithoutExtension(encryptedFilePath)
val base64 = readFromFile(encryptedFilePath)
val decrypted = encrypter.decrypt(base64)
var result = ""
if (decrypted.isNotEmpty()) {
val bitmap = BitmapUtils.decodeFromBase64(decrypted)
val tempDir = NoteApplication.instance.cacheDir
val outputFile = File.createTempFile("$fileName-", ".png", tempDir)
BitmapUtils.saveBitmap(outputFile, bitmap)
result = outputFile.absolutePath
}
emitter.onNext(result)
emitter.onComplete()
}, BackpressureStrategy.BUFFER)
}
override fun encryptAudio(filePath: String): Flowable {
return Flowable.create({ emitter ->
val fileName = "${System.currentTimeMillis()}.enc"
val base64 = FileUtils.encodeToBase64(filePath)
val encrypted = encrypter.encrypt(base64)
val path = writeToFile(NoteApplication.instance, encrypted.toByteArray(), fileName)
emitter.onNext(path)
emitter.onComplete()
}, BackpressureStrategy.BUFFER)
}
override fun decryptAudio(context: Context, filePath: String): Flowable {
return Flowable.create({ emitter ->
val fileName = FileUtils.getFileNameWithoutExtension(filePath)
val base64 = readFromFile(filePath)
val decrypted = encrypter.decrypt(base64)
var result = ""
if (decrypted.isNotEmpty()) {
val audio = FileUtils.decodeFromBase64(decrypted)
val tempDir = NoteApplication.instance.cacheDir
val outputFile = File.createTempFile("$fileName-", ".m4a", tempDir)
writeToFile(audio, outputFile.absolutePath)
result = outputFile.absolutePath
}
emitter.onNext(result)
emitter.onComplete()
}, BackpressureStrategy.BUFFER)
}
private fun writeToFile(context: Context, data: ByteArray, fileName: String): String {
val path = context.filesDir
val file = File(path, fileName)
if (!file.exists()) {
file.createNewFile()
}
val stream = FileOutputStream(file)
stream.use { it.write(data) }
return file.absolutePath
}
private fun writeToFile(data: ByteArray, filePath: String): String {
val file = File(filePath)
if (!file.exists()) {
file.createNewFile()
}
val stream = FileOutputStream(file)
stream.use { it.write(data) }
return file.absolutePath
}
private fun readFromFile(path: String): String {
val file = File(path)
if (!file.exists()) {
return ""
}
val length = file.length().toInt()
val bytes = ByteArray(length)
val inputStream = FileInputStream(file)
inputStream.use { it.read(bytes) }
return String(bytes)
}
}
Kostenlos verfügbar und mit einem einzigen In-App-Kauf alle Premium Funktionen erhalten.
-
Private Notizen sicher schreiben
-
Sicheres Diktiergerät
-
Notizen & Aufnahmen sind mit AES-256 Bit militärisch sicher verschlüsselt
-
Einfache und übersichtliche Organisation
-
Sortierung nach individuellen Kategorien und Farben
-
Im Notfall: Selbstzerstörung durch sicheres Löschen
-
Garantiert keine Hintertüren: Verschlüsselungsalogrithmus (open source)
-
Automatische Bildschirmsperre
-
24/7 Support per e-Mail
-
PREMIUM: Deep Detective™: Schutz gegen bekannte und unbekannte Angriffsversuche
-
PREMIUM: Erweiterter Einbruchsschutz mit Einbrecher Selfie
-
PREMIUM: Extended Hacker Protection with Intruder Selfie feature
-
PREMIUM: Unlimitiert viele Notizen und Sprachaufnahmen