39

If I encrypt some data with a randomly generated Key and Initialization Vector, then store all three pieces of information in the same table row; is it necessary to encrypt the IV as well as the Key?

Simplified table structure:

  • Encrypted data
  • Key (encrypted using a second method)
  • IV (encrypted?)

Please assume that the architecture and method are necessary: The explanation behind it is lengthy and dull.

  • 3
    Is there a reason why you store the IV separately at all? You can just concatenate the IV with the data, encrypt, and store the whole blob. Later, when decrypting and using the data, you simply ignore the first length_of_iv bytes. I could see how it would make sense to store them separately if you wanted to add an index on the data to be able to search for it, but encrypted data is (hopefully!) unreadable and pseudo-random, so that's pretty useless. – Damon Mar 3 '14 at 13:28
  • @Damon: Encrypting and decrypting takes processing time. In the end there was only a single key, so there would be more than one IV per key (as originally intended by the Key/IV combination). – Stu Pegg Mar 3 '14 at 14:17
  • 3
    But that is not how an IV works. It's fine to have a single key, or many keys, this makes no difference. It is the IV that must be different (and strong random / unpredictable if you have any means) for every message. That ensures that a) two identical messages encode different, i.e. you cannot tell that two messages are the same and b) it is very hard to derive information from the plaintext or run known-plaintext attacks at all, since the beginning of the plaintext (the IV) is random garbage. You can't analyze an awful lot because one unknown random garbage looks like the other. – Damon Mar 3 '14 at 14:29
  • For that, it is necessary to initialize the cipher "in some way" with the IV. The easiest way is to simply concatenate the IV with the actual data. You don't need to remember it otherwise, because it's not good for anything! Once encrypted, it is all the same random garbage, and once decrypted, you simply ignore the IV, since you know that it isn't good for anything. Storing the IV might actually make a known-plaintext attack feasible. But as long as it's an unknown random sequence, all the attacker really knows is "random garbage in, random garbage out". – Damon Mar 3 '14 at 14:31
  • 1
    @robert: You only need to know the key. Instead of Message, you encrypt e.g. lkjoiukqMessage, or ylmqtclrMessage on another day. Even though Message is the same on both days, the random-looking output of the cipher will be different, there is no way of knowing it's the same, nor is there a way of guessing the key from the fact that the input to the cipher is the known plaintext Message (because it isn't). When you decrypt <random gargbage>, you get back xxxxxxxxMessage where xxxxxxxx is something that you simply ignore, knowing that it's just meaningless random. – Damon Aug 23 '15 at 10:33
46

From Wikipedia:

An initialization vector has different security requirements than a key, so the IV usually does not need to be secret. However, in most cases, it is important that an initialization vector is never reused under the same key. For CBC and CFB, reusing an IV leaks some information about the first block of plaintext, and about any common prefix shared by the two messages.

You don't need to keep the IV secret, but it must be random and unique.

  • 5
    +1 I feel a bit silly for not checking Wikipedia now. – Stu Pegg Jul 10 '12 at 16:10
  • 1
    If you had to keep the IV secret, it would be part of the key. The "key" (unless qualified as a "public key") is, by definition, whatever you have to keep secret. – David Schwartz Jul 11 '12 at 5:48
  • @DavidSchwartz Not always: there are nonces that are not called keys (but they wouldn't be called IV either) and that must be kept secret. The k parameter in DSA, for example. – Gilles Jul 11 '12 at 9:21
  • 2
    @StuartPegg, actually, for CBC mode, it needs to be not only unique but also truly random. (A counter would not be a good choice of IV, for CBC mode.) – D.W. Nov 1 '12 at 21:11
  • 2
    @Kao Each bit has an equal probability of being either 1 or 0, independent of the value of any other bit. – Polynomial Nov 2 '12 at 13:25
8

Although in your case the IV should be okay in plaintext in the DB, there is a severe vulnerability if you allow the user to control the IV.

The IV in decryption is used (and only used) to XOR the first block into the final plaintext - so if an attacker can control the IV they can arbitrarily control the first block of data, and the rest of the plaintext will survive without modification.

enter image description here

If the attacker knows the original plaintext of the first block, then the problem is magnified again as the attacker can choose arbitrary data for the first block without trial and error.

This is particularly important in the case where encrypted data is being transmitted through untrusted channels with the IV, maybe into a browser or an app etc.

  • wait, what? you're saying that if the attacker knows the IV, he can decrypt first block of the cyphertext? – nicks Nov 3 '16 at 8:16
  • 1
    Notice how the first block has to go through the key first before it is XORd with the IV. So... Regarding second paragraph - if the attacker changes the IV, the first block comes out garbled. Regarding the third paragraph - if the attacker already knows the plaintext of the first block (say it's a common header text), and also has the IV, he has a better shot at figuring out the key if he can reverse the decryption process, giving him the ability to decrypt the other blocks. – Bondolin Nov 8 '16 at 21:04
  • MAC (which you should do) mitigates this kind of attack. – rustyx Apr 23 '18 at 6:19

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.