Problem - Kevin Tafuro

while (mlen) {
if ((r = read(fd, msg, mlen)) == -1) {
switch (errno) {
case EINTR:
break;
default:
abort();
}
} else {
mlen -= r;
msg += r;
}
}
}
The client is responsible for deallocating the memory for messages.
We recommend securely wiping messages before doing so, as discussed
in Recipe 13.2. In addition, you should securely erase the spc_
ssock_t context when you are done with it.
That’s everything on the client side. Now we can move on to the server. The server
can share the spc_ssock_t type that the client uses, as well as all the helper functions,
such as spc_ssock_read( ) and spc_ssock_write( ). But the API for initialization,
reading, and writing must change.
Here’s the server-side initialization function that should get called once the key
exchange is complete but before the client’s first message is read:
void spc_init_server(spc_ssock_t *ctx, unsigned char *key, size_t klen, int fd) {
if (klen != 16 && klen != 24 && klen != 32) abort();
/* Remember that cwc_init() erases the key we pass in! */
cwc_init(&(ctx->cwc), key, klen * 8);
/* We need to wait for the random portion of the nonce from the client.
* The counter portion we can initialize to zero. We'll set the distinguisher
* to SPC_SERVER_LACKS_NONCE, so that we know to copy in the random portion
* of the nonce when we receive a message.
*/
ctx->nonce[0] = SPC_SERVER_LACKS_NONCE;
memset(ctx->nonce + SPC_CTR_IX, 0, SPC_CTR_LEN);
ctx->fd = fd;
}
The first thing the server does is read data from the client’s socket. In practice, the
following code isn’t designed for a single-threaded server that uses select( ) to determine
which client has data to be read. This is because once we start reading data, we
keep reading until we’ve taken in the entire message, and all the reads are blocking.
The code is not designed to work in a nonblocking environment.
Building an Authenticated Secure Channel Without SSL | 499
This is the Title of the Book, eMatter Edition
Copyright © 2007 O’Reilly & Associates, Inc. All rights reserved.