Problem - Kevin Tafuro

If you are using padding and you know the length of the input message in advance,
you can calculate the output length easily. If the message is of a length that is an
exact multiple of the block size, the output message will be a block larger. Otherwise,
the message will get as many bytes added to it as necessary to make the input
length a multiple of the block size. Using integer math, we can calculate the output
length as follows, where il is the input length:
((il / SPC_BLOCK_SZ) * SPC_BLOCK_SZ) + SPC_BLOCK_SZ
If we do not have the entire message at once, when using padding the easiest thing to
do is to assume there may be an additional block of output. That is, if you pass in 7
bytes, allocating 7 + SPC_BLOCK_SZ is safe. If you wish to be a bit more precise, you
can always add SPC_BLOCK_SZ bytes to the input length, then reduce the number to
the next block-aligned size. For example, if we have an 8-byte block, and we call spc_
cbc_encrypt_update( ) with 7 bytes, there is no way to get more than 8 bytes of output,
no matter how much data was buffered internally. Note that if no data was buffered
internally, we won’t get any output!
Of course, you can exactly determine the amount of data to pass in if you are keeping
track of how many bytes are buffered at any given time (which you can do by
looking at ctx->ix). If you do that, add the buffered length to your input length. The
amount of output is always the largest block-aligned value less than or equal to this
total length.
If you’re not using padding, you will get a block of output for every block of input.
To switch off padding, you can call the following function, passing in a 0 for the second
argument:
void spc_cbc_set_padding(SPC_CBC_CTX *ctx, int pad) {
ctx->pad = pad;
}
Here’s our implementation of spc_cbc_encrypt_update( ):
int spc_cbc_encrypt_update(SPC_CBC_CTX *ctx, unsigned char *in, size_t il,
unsigned char *out, size_t *ol) {
/* Keep a ptr to in, which we advance; we calculate ol by subtraction later. */
int i;
unsigned char *start = out;
/* If we have leftovers, but not enough to fill a block, XOR them into the right
* places in the IV slot and return. It's not much stuff, so one byte at a time
* is fine.
*/
if (il < SPC_BLOCK_SZ-ctx->ix) {
while (il--) ctx->iv[ctx->ix++] ^= *in++;
if (ol) *ol = 0;
return 1;
}
/* If we did have leftovers, and we're here, fill up a block then output the
* ciphertext.
Using a Generic CBC Mode Implementation | 181
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.