iLocker™ Android
Bloquea tus notas y protege tus aplicaciones.
Featured in:
Escribe notas de forma segura y con facilidad
La nueva aplicación iLocker™ Secure Notes, lo hace fácil e implementa el más alto nivel de seguridad para escribir notas privadas, e incluso grabar notas de voz.
Todas las notas personales son encriptadas automáticamente, pueden ser organizadas claramente, y asignadas a categorías individuales. De esta manera, la importancia de una nota escrita puede ser distinguida rápidamente por el color
AES-256
Maquina de Dictado
Autodestrucción
Deep Detective™
Encriptación AES-256 bits. Al estilo militar.
iLocker™ Secure Notes es una poderosa aplicación de encriptación, que encripta tus notas usando el algoritmo AES (Estándar de Encriptación Avanzado) de 256 bits. Esta tecnología de encriptación es una de las más inexpugnables disponibles en la actualidad y es usada para encriptar documentos gubernamentales, industriales y militares de alto secreto
El proceso de encriptación es llevado a cabo directamente en tu dispositivo, y su criptografía simétrica garantiza que solo tú puedas acceder a tus notas.
Máquina de dictado segura:
Graba momentos importantes
La máquina de dictado integrada es el compañero ideal para grabar de manera segura momentos importantes. Puede ser usada como un grabador de voz normal para grabar notas de voz, reuniones de negocios, entrevistas, lecturas y más
El diseño minimalista permite una fácil accesibilidad, y permite una experiencia de grabación de alta calidad
En caso de emergencia: autodestrucción
Incluso en una emergencia, tus notas privadas y grabaciones de voz están a salvo. Si el dispositivo Android es robado o se pierde, toda la información será destruida automáticamente luego de 5 intentos de contraseña inválidos.
Esto no solo elimina la información, pero también elimina de forma segura toda la caja fuerte de notas utilizando algoritmos de eliminación certificados. Las tecnologías de extinción para esta función provienen de la galardonada y popular iShredder™.
Una protección inteligente contra hackers:
Deep Detective™
En 2016, con Deep Detective™ hemos creado un detective inteligente, el cual monitorea todo acceso – similar a un firewall - solo mas inteligente.
En iLocker™ Secure Notes, el módulo de protección de Deep Detective™ controla permanentemente cual proceso está accediendo actualmente a los datos encriptados de tu caja fuerte de notas. También reporta acerca de ataques conocidos (y gracias a sus modernos métodos heurísticos) también reporta acerca de los ataques desconocidos-
AppLocker
Bloquear aplicaciones con huella digital, PIN o código de acceso
Bloquee sus aplicaciones y proteja su privacidad añadiendo una capa de seguridad con la función AppLocker. Utiliza tu huella digital, una contraseña segura o un PIN para mantener tus aplicaciones seguras y privadas.
Elige qué aplicaciones quieres proteger. AppLocker puede bloquear todo tipo de aplicaciones, como Galería fotográfica, Contactos, Configuración, Navegador Web, Aplicaciones de medios sociales, Aplicaciones de mensajería y más.
Video Presentación
Garantizado: Sin puertas traseras.
Los datos son encriptados directamente en el dispositivo, y la criptografía simétrica garantiza que solo el usuario pueda acceder a sus notas.
Sin la contraseña o si esta se olvidó, las notas no pueden ser accedidas o la información pueda ser descifrada. Además, la contraseña no se almacena en el dispositivo.
Protectstar™ garantiza que no se oculten puertas traseras o contraseñas maestras en iLocker™. Por razones de transparencia, el algoritmo de cifrado simétrico utilizado se proporciona como una descarga para su propio análisis.
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)
}
}
La aplicación es gratuita y con una compra dentro de la aplicación puedes obtener todas las características premium
-
Escribe notas privadas con el más alto nivel de seguridad
Grabador (dictado) de voz integrado
Las notas de texto y de voz están encriptadas con la increíble encriptación AES de 265 bits
Increíble organización y orden de notas
La importancia de una nota escrito también puede ser identificada rápidamente con color
En caso de emergencia: autodestrucción automática luego de 5 intentos fallidos de contraseña
¡Garantizado: sin puertas traseras o contraseñas maestras! Código abierto del algoritmo de cifrado simétrico es proporcionado como descarga
Protección automática de pantalla
Soporte 24/7 a través de correo electrónico por parte de nuestros Héroes de Soporte
PREMIUM: El módulo de protección Deep Detective™ detecta ataques desconocidos, incluso dentro de la bóveda de notas
PREMIUM: Protección extendida contra hackers con la característica Selfie de Intrusos
PREMIUM: Almacena notas de texto y de voz ilimitadas