Problem - Kevin Tafuro

Once those bindings are made, the Zork CWC implementation has a simple API that
accepts an entire message at once:
int cwc_init(cwc_t ctx[1], u_char key[ ], int keybits);
void cwc_encrypt_message(cwc_t ctx[1], u_char a[ ], u_int32 alen, u_char pt[ ],
u_int32 ptlen, u_char nonce[11], u_char output[ ]);
int cwc_decrypt_message(cwc_t ctx[1], u_char a[ ], u_int32 alen, u_char ct[ ],
u_int32 ctlen, u_char nonce[11], u_char output[ ]);
void cwc_cleanup(cwc_t ctx[1]);
If you have very large messages, this API insists that you buffer them before encrypting
or decrypting. That’s not a fundamental limitation of CWC mode, but only of
this implementation. A future version of the implementation might change that, but
do note that it would require partially decrypting a message before the library could
determine whether the message is authentic. The API above does not decrypt if the
message isn’t authentic.
If you need to operate on very large messages, check out Brian Gladman’s
CWC implementation, which works incrementally.
This API looks slightly different from the all-in-one APIs we’ve presented for other
modes in this chapter. It’s actually closer to the incremental mode. The CWC mode
has a notion of individual messages. It is intended that each message be sent individually.
You’re expected to use a single key for a large number of messages, but each
message gets its own nonce. Generally, each message is expected to be short but can
be multiple gigabytes.
Note that encrypting a message grows the message by 16 bytes. The extra 16 bytes at
the end are used for ensuring the integrity of the message (it is effectively the result of
a message authentication code; see Chapter 6).
The previous API assumes that you have the entire message to encrypt or decrypt at
once. In the following discussion, we’ll talk about the API that allows you to incrementally
process a single message.
The cwc_init( ) function allows us to initialize a CWC context object of type cwc_t
that can be reused across multiple messages. Generally, a single key will be used for
an entire session. The first argument is a pointer to the cwc_t object (the declaration
as an array of one is a specification saying that the pointer is only to a single object
rather than to an array of objects). The second argument is the AES key, which must
be a buffer of 16, 24, or 32 bytes. The third argument specifies the number of bits in
the key (128, 192 or 256). The function fails if keybits is not a correct value.
The cwc_encrypt_message( ) function has the following arguments:
ctx
Pointer to the cwc_t context object.
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.
Using CWC Mode | 203