Invalid length key or iv in node.js crypto

user_10077312 0
Viewed 691

I know this topic have a couple answer, but I have problem about details key length.

I would like to encryption data in AES algorithm with CTR. The encryption will have length of 256 bits.

If I do encryption data by key length 256 and IV length 16, I get a error Invalid key length. I thought IV must be the same key length. I change length of IV to 256, but I get an error Invalid iv length. I found out IV must be 16 bits long.

My code works only if my key is 16 bits and my IV is 16 bits long. So my code didn't encrypt with length of 256 bits.

My code

const crypto = require('crypto');
let key = crypto.randomBytes(16).toString('hex'); // Key is static
let iv = crypto.randomBytes(16);

let cipher = crypto.createCipheriv('aes-256-ctr', process.env.KEY, iv);
let encrypte = cipher.update("Example_data", 'utf-8', 'hex');
encrypte += cipher.final('hex');

What should I do to encrypt data with a key length of 256 bits?

cryptojs node.js cryptography encryption
1 Answers

First of all: AES uses a 16 bytes IV (corresponding to the AES block size) and a 16, 24 or 32 bytes key. In the posted code aes-256-ctr is specified, so a 256 bits = 32 bytes key is needed.

And this is exactly the size of the key applied, not 16 bytes as you assume, which is why the code is executed in the first place (at least if the undefined process.env.KEY is replaced by key): crypto.randomBytes(16) creates a 16 bytes buffer and toString('hex') converts it to a hex string, doubling the size to 32 bytes (since 1 byte in the buffer is represented by 2 characters (and thus 2 bytes) in the string). So technically, with UTF-8 encoding (the default for crypto.createCipheriv()), this results in a 32 bytes key which can be used for aes-256-ctr. However, each byte in this key can only take 16 values (corresponding to the digits 0-9 and a-f), which corresponds to 1632 = 25616 = 2128 possible values and thus not 256, but only 128 bit security strength.

You prevent the reduction of the security strength by using directly the binary data for the key, so crypto.randomBytes(32). Here each byte can take 256 different values, which corresponds for a 32 bytes key to 25632 = 2256 possible values and thus a 256 bit security strength. If the key is hex encoded, it must not be UTF8 encoded, but hex decoded.

If the key is derived e.g. using a key derivation function, the hex encoding can cause another problem across platforms. If one platform applies uppercase letters for hex encoding and the other lowercase letters, different keys will result.

Long story short: Avoid using the UTF8 encoded data of a hex string for a key (or at least be aware of the implications).

user_90140970
Related