Problem - Kevin Tafuro

a key, which may be of a different length than the block size. Sometimes an algorithm
will allow variable-length keys, but the block size is generally fixed.
Setting up a block cipher generally involves turning the raw key into a key schedule.
Basically, the key schedule is just a set of keys derived from the original key in a
cipher-dependent manner. You need to create the key schedule only once; it’s good
for every use of the underlying key because raw encryption always gives the same
result for any {key, input} pair (the same is true for decryption).
Once you have a key schedule, you can generally pass it, along with an input block,
into the cipher encryption function (or the decryption function) to get an output
block.
To keep the example code as simple as possible, we’ve written it assuming you are
going to want to use one and only one cipher with it (though it’s not so difficult to
make the code work with multiple ciphers).
To get the code in this book working, you need to define several macros:
SPC_BLOCK_SZ
Denotes the block size of the cipher in bytes.
SPC_KEY_SCHED
This macro must be an alias for the key schedule type that goes along with your
cipher. This value will be library-specific and can be implemented by typedef
instead of through a macro. Note that the key schedule type should be an array
of bytes of some fixed size, so that we can ask for the size of the key schedule
using sizeof(SPC_KEY_SCHED).
SPC_ENCRYPT_INIT(sched, key, keybytes) and
SPC_DECRYPT_INIT(sched, key, keybytes)
Both of these macros take a pointer to a key schedule to write into, the key used
to derive that schedule, and the number of bytes in that key. If you are using an
algorithm with fixed-size keys, you can ignore the third parameter. Note that
once you’ve built a key schedule, you shouldn’t be able to tell the difference
between different key lengths. In many implementations, initializing for encryption
and initializing for decryption are the same operation.
SPC_DO_ENCRYPT(sched, in, out) and SPC_DO_DECRYPT(sched, in, out)
Both of these macros are expected to take a pointer to a key schedule and two
pointers to memory corresponding to the input block and the output block.
Both blocks are expected to be of size SPC_BLOCK_SZ.
In the following sections, we’ll provide some bindings for these macros for Brian Gladman’s
AES implementation and for the OpenSSLAPI. Unfortunately, we cannot use
Microsoft’s CryptoAPI because it does not allow for exchanging symmetric encryption
keys without encrypting them (see Recipes 5.26 and 5.27 to see how to work
around this limitation)—and that would add significant complexity to what we’re trying
to achieve with this recipe. In addition, AES is only available in the .NET frame-
172 | Chapter 5: Symmetric Encryption
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.