Problem - Kevin Tafuro

In CBC and ECB modes, the cipher cannot always encrypt all the plaintext you give
it as that plaintext arrives, because it requires block-aligned data to operate. In the
finalization phase, those algorithms add padding if appropriate, then yield the
remaining output. Note that, because of the internal buffering that can happen in
these modes, the output to any single call of EVP_EncryptUpdate( ) or EVP_
EncryptFinal_ex( ) can be about a full block larger or smaller than the actual input. If
you’re encrypting data into a single buffer, you can always avoid overflow if you
make the output buffer an entire block bigger than the input buffer. Remember,
however, that if padding is turned off (as described in Recipe 5.19), the library will
be expecting block-aligned data, and the output will always be the same size as the
input.
In OFB and CFB modes, the call to EVP_EncryptUpdate( ) will always return the
amount of data you passed in, and EVP_EncryptFinal_ex( ) will never return any data.
This is because these modes are stream-based modes that don’t require aligned data
to operate. Therefore, it is sufficient to call only EVP_EncryptUpdate( ), skipping finalization
entirely. Nonetheless, you should always call the finalization function so that
the library has the chance to do any internal cleanup that may be necessary. For
example, if you’re using a cryptographic accelerator, the finalization call essentially
gives the hardware license to free up resources for other operations.
These functions all return 1 on success, and 0 on failure. EVP_EncryptFinal_ex( ) will
fail if padding is turned off and the data is not block-aligned. EVP_DecryptFinal_ex( )
will fail if the decrypted padding is not in the proper format. Additionally, any of
these functions may fail if they are using hardware acceleration and the underlying
hardware throws an error. Beyond those problems, they should not fail. Note again
that when decrypting, this API has no way of determining whether the data
decrypted properly. That is, the data may have been modified in transit; other means
are necessary to ensure integrity (i.e., use a MAC, as we discuss throughout
Chapter 6).
Here’s an example function that, when given an already instantiated cipher context,
encrypts an entire plaintext message 100 bytes at a time into a single heap-allocated
buffer, which is returned at the end of the function. This example demonstrates how
you can perform multiple encryption operations over time and keep encrypting into
a single buffer. This code will work properly with any of the OpenSSL-supported
cipher modes.
#include
#include
/* The integer pointed to by rb receives the number of bytes in the output.
* Note that the malloced buffer can be realloced right before the return.
*/
char *encrypt_example(EVP_CIPHER_CTX *ctx, char *data, int inl, int *rb) {
int i, ol, tmp;
char *ret;
232 | Chapter 5: Symmetric Encryption
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.