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)
    }
}