AES CTR mode - encryption\decryption with Crypto++ - am I doing it right? - c++

Question

In my application I need to use encryption algorithm that allows me to decrypt single byte at requested offset in encrypted buffer, without reading surrounding blocks. My choice is AES with CTR mode using Crypto++ library. Since I couldn't find any good example, I have wrote it on my own:
unique_ptr<vector<byte>> GetIV(int counter)
{
byte* counterPtr = (byte*)&counter;
unique_ptr<vector<byte>> iv(new vector<byte>());
for (int j = 0; j < 4; j++)
{
iv->push_back(counterPtr[j]);
}
return move(iv);
}
unique_ptr<vector<uint8_t>> Encrypt(const vector<uint8_t>& plainInput)
{
unique_ptr<vector<uint8_t>> encryptedOutput(new vector<uint8_t>(plainInput.size()));
for (int i = 0; i < plainInput.size(); i++)
{
auto iv = GetIV(i);
CTR_Mode<AES>::Encryption encryptor(_key->data(), _key->size(), iv->data());
byte encryptedValue = encryptor.ProcessByte(plainInput.at(i));
encryptedOutput->at(i) = encryptedValue;
}
return move(encryptedOutput);
}
unique_ptr<vector<uint8_t>> Decrypt(const vector<uint8_t>& encryptedInput, int position)
{
unique_ptr<vector<uint8_t>> decryptedOutput(new vector<uint8_t>(encryptedInput.size()));
for (int i = 0; i < encryptedInput.size(); i++)
{
auto iv = GetIV(position + i);
CTR_Mode<AES>::Decryption decryptor(_key->data(), _key->size(), iv->data());
byte decryptedValue = decryptor.ProcessByte(encryptedInput.at(i));
decryptedOutput->at(i) = decryptedValue;
}
return move(decryptedOutput);
}
As you can see, I iterate through all bytes in my input buffer, and encrypt\decrypt each of them separately, because it is necessary to have unique counter for each block (in CTR mode). Since I need to be able to decrypt random byte, I need to have as much blocks as buffer size is, is that correct? My solution works, but it is very very slow... Am I doing it right? Or maybe there is much more efficient way to do this?

Answer 1

There are several major problems with your code:
You are using unauthenticated encryption, which is insecure in most application domains. Please use AES-GCM instead, which looks a lot like AES-CTR anyway. This is in fact mentioned right on the documentation of Crypto++.
The IV of CTR mode is 16 bytes long, yet you use only 4 bytes. Your codes not only calculate it wrong, but also exhibit undefined behavior.
IV is per message, not per byte.
Because you choose the IV wrong, your algorithm basically reduces to the one-time pad, except not as secure. If you ever encrypt two messages with the same key, the system is broken.
The performance issue is your least concern. This whole implementation is simply incorrect and insecure. You must study cryptography systematically before trying to utilize it, for it is not a field you can learn just by trial and error. It is easy to design a system that passes all the unit tests and looks fine to your own eyes, but completely broken to the trained ones.
I recommend cryptography on coursera.

Answer 2

No, you are not doing this right. You don't need to iterate through the input of the decrypt method at all.
You only have to calculate the right counter for the block that contains the byte to decrypt. Then you can use that counter as IV value. Now you can encrypt or decrypt a block of ciphertext and retrieve the right byte. There is no need to decrypt specific bytes separately.
So if the block size of the cipher is 16, the IV/nonce is F000000000000000F000000000000000h and the offset of the byte is 260 then the counter/IV needs to be advanced with 260 / 16 = 16 = 10h. Then F000000000000000F000000000000000h + 10h = F000000000000000F000000000000010. Then you decrypt the 16th block and take the 4th byte at offset 3 (as 260 % 16 = 4).