Encrypt with Node.Js Crypto Module and Decrypt with Java (In Android App)

Encrypt with Node.js Crypto module and decrypt with Java (in Android app)

Apparently if you pass a passphrase to crypto.createCipher() it uses OpenSSL's EVP_BytesToKey() to derive the key. You can either pass a raw byte buffer and use the same to initialize Java's SecretKey, or emulate EVP_BytesToKey() in your Java code. Use $ man EVP_BytesToKey for more details, but essentially it hashes the passphrase multiple times with MD5 and concatenates a salt.

As for using a raw key, something like this should let you use a raw key:

var c = crypto.createCipheriv("aes-128-ecb", new Buffer("00010203050607080a0b0c0d0f101112", "hex").toString("binary"), "");

Note that since you are using CBC, you need to use the same IV for encryption and decryption (you might want to append it to your message, etc.)

Mandatory warning: implementing a crypto protocol yourself is rarely a good idea. Even if you get this to work, are you going to use the same key for all messages? For how long? If you decide to rotate the key, how to you manage this. Etc, .etc.

Encrypting in NodeJs and Decrypting in Android

the problem was the conversion of hex String to bytes, the iv string, the encrypted CipherText as well as the key string weren't converted properly to bytes.
In addition to the PKCS5Padding that must be applied in the Kotlin code.
here is the functions used to get the original key and iv of encryption :

fun toByte(hexString: String): ByteArray? {
    val len = hexString.length / 2
    val result = ByteArray(len)
    for (i in 0 until len) result[i] = 
    Integer.valueOf(hexString.substring(2 * i, 2 * i + 2), 16).toByte()
    return result
}

fun setKey(myKey: String):SecretKeySpec {
    try {
        var key = toByte(myKey)
        key = Arrays.copyOf(key, 32)
        var secretKey = SecretKeySpec(key, "AES")
        return secretKey
    } catch (e: java.lang.Exception) {
        throw e
    }
}

//finally Decryption 

fun decrypt(cipherText: String, key: String, IV: String): String? {
    try {
        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
        val keySpec = setKey(key)
        val iv = toByte(IV)
        val ivSpec = IvParameterSpec(iv)
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivSpec)
        val text = toByte(cipherText)
        val decryptedText = cipher.doFinal(text)

        return String(decryptedText)
    } catch (e: java.lang.Exception) {
        e.printStackTrace()
    }
    return null
}

For the NodeJs server, everything stay the same.

How to encrypt data in node.js using node-rsa and decrypt encrypted data in android?

In the NodeJS code the cipher text is hex encoded and in the Java code it is Base64 decoded. This must be made consistent, either Base64 or hex encoding on both sides.

Also, in the Java code, when instantiating the cipher, only the algorithm is specified. This results in a default padding being used, which e.g. on my machine (API 28, Android 9 Pie) corresponds to RSA/ECB/NoPadding. This is not compatible with the NodeJS side, which uses PKCS#1 v1.5 padding (besides that RSA without padding, so called textbook RSA, is insecure). Therefore, padding must also be specified in the cipher instantiation with RSA/ECB/PKCS1Padding.

Using a private key in PKCS#8 format and an own implementation of readPrivateKeyFromPem_PKCS8() both codes work on my machine if the two bugs mentioned above are fixed. However, the methods not posted could also contain flaws.

---

Related Topics