void bench_rabbit(void)
{
Rabbit enc;
double start, total, persec;
int i;
RabbitSetKey(&enc, key, iv);
start = current_time();
for(i = 0; i < megs; i++)
RabbitProcess(&enc, cipher, plain, sizeof(plain));
total = current_time() - start;
persec = 1 / total * megs;
printf("RABBIT %d megs took %5.3f seconds, %6.2f MB/s\n", megs, total,
persec);
}
void bench_rabbit(void)
{
Rabbit enc;
double start, total, persec;
int i;
RabbitSetKey(&enc, key, iv);
start = current_time(1);
for(i = 0; i < numBlocks; i++)
RabbitProcess(&enc, cipher, plain, sizeof(plain));
total = current_time(0) - start;
persec = 1 / total * numBlocks;
#ifdef BENCH_EMBEDDED
/* since using kB, convert to MB/s */
persec = persec / 1024;
#endif
printf("RABBIT %d %s took %5.3f seconds, %7.3f MB/s\n", numBlocks,
blockType, total, persec);
}
static int SetKeys(Ciphers* enc, Ciphers* dec, Keys* keys, CipherSpecs* specs,
byte side)
{
#ifdef BUILD_ARC4
word32 sz = specs->key_size;
if (specs->bulk_cipher_algorithm == rc4) {
if (side == CLIENT_END) {
Arc4SetKey(&enc->arc4, keys->client_write_key, sz);
Arc4SetKey(&dec->arc4, keys->server_write_key, sz);
}
else {
Arc4SetKey(&enc->arc4, keys->server_write_key, sz);
Arc4SetKey(&dec->arc4, keys->client_write_key, sz);
}
}
#endif
#ifdef BUILD_HC128
if (specs->bulk_cipher_algorithm == hc128) {
if (side == CLIENT_END) {
Hc128_SetKey(&enc->hc128, keys->client_write_key,
keys->client_write_IV);
Hc128_SetKey(&dec->hc128, keys->server_write_key,
keys->server_write_IV);
}
else {
Hc128_SetKey(&enc->hc128, keys->server_write_key,
keys->server_write_IV);
Hc128_SetKey(&dec->hc128, keys->client_write_key,
keys->client_write_IV);
}
}
#endif
#ifdef BUILD_RABBIT
if (specs->bulk_cipher_algorithm == rabbit) {
if (side == CLIENT_END) {
RabbitSetKey(&enc->rabbit, keys->client_write_key,
keys->client_write_IV);
RabbitSetKey(&dec->rabbit, keys->server_write_key,
keys->server_write_IV);
}
else {
RabbitSetKey(&enc->rabbit, keys->server_write_key,
keys->server_write_IV);
RabbitSetKey(&dec->rabbit, keys->client_write_key,
keys->client_write_IV);
}
}
#endif
#ifdef BUILD_DES3
if (specs->bulk_cipher_algorithm == triple_des) {
if (side == CLIENT_END) {
Des3_SetKey(&enc->des3, keys->client_write_key,
keys->client_write_IV, DES_ENCRYPTION);
Des3_SetKey(&dec->des3, keys->server_write_key,
keys->server_write_IV, DES_DECRYPTION);
}
else {
Des3_SetKey(&enc->des3, keys->server_write_key,
keys->server_write_IV, DES_ENCRYPTION);
Des3_SetKey(&dec->des3, keys->client_write_key,
keys->client_write_IV, DES_DECRYPTION);
}
}
#endif
#ifdef BUILD_AES
if (specs->bulk_cipher_algorithm == aes) {
if (side == CLIENT_END) {
AesSetKey(&enc->aes, keys->client_write_key,
specs->key_size, keys->client_write_IV,
AES_ENCRYPTION);
AesSetKey(&dec->aes, keys->server_write_key,
specs->key_size, keys->server_write_IV,
AES_DECRYPTION);
}
else {
AesSetKey(&enc->aes, keys->server_write_key,
specs->key_size, keys->server_write_IV,
AES_ENCRYPTION);
AesSetKey(&dec->aes, keys->client_write_key,
specs->key_size, keys->client_write_IV,
AES_DECRYPTION);
}
}
#endif
keys->sequence_number = 0;
keys->peer_sequence_number = 0;
keys->encryptionOn = 0;
return 0;
}
int rabbit_test()
{
byte cipher[16];
byte plain[16];
const char* keys[] =
{
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
"\xAC\xC3\x51\xDC\xF1\x62\xFC\x3B\xFE\x36\x3D\x2E\x29\x13\x28\x91"
};
const char* ivs[] =
{
"\x00\x00\x00\x00\x00\x00\x00\x00",
"\x59\x7E\x26\xC1\x75\xF5\x73\xC3",
0
};
testVector a, b, c;
testVector test_rabbit[3];
int times = sizeof(test_rabbit) / sizeof(testVector), i;
a.input = "\x00\x00\x00\x00\x00\x00\x00\x00";
a.output = "\xED\xB7\x05\x67\x37\x5D\xCD\x7C";
a.inLen = strlen(a.input);
a.outLen = strlen(a.output);
b.input = "\x00\x00\x00\x00\x00\x00\x00\x00";
b.output = "\x6D\x7D\x01\x22\x92\xCC\xDC\xE0";
b.inLen = strlen(b.input);
b.outLen = strlen(b.output);
c.input = "\x00\x00\x00\x00\x00\x00\x00\x00";
c.output = "\x9C\x51\xE2\x87\x84\xC3\x7F\xE9";
c.inLen = strlen(c.input);
c.outLen = strlen(c.output);
test_rabbit[0] = a;
test_rabbit[1] = b;
test_rabbit[2] = c;
for (i = 0; i < times; ++i) {
Rabbit enc;
Rabbit dec;
RabbitSetKey(&enc, (byte*)keys[i], (byte*)ivs[i]);
RabbitSetKey(&dec, (byte*)keys[i], (byte*)ivs[i]);
RabbitProcess(&enc, cipher, (byte*)test_rabbit[i].input,
(word32)test_rabbit[i].outLen);
RabbitProcess(&dec, plain, cipher, (word32)test_rabbit[i].outLen);
if (memcmp(plain, test_rabbit[i].input, test_rabbit[i].outLen))
return -130 - i;
if (memcmp(cipher, test_rabbit[i].output, test_rabbit[i].outLen))
return -130 - 5 - i;
}
return 0;
}
/********************* Defination of rabbit_test() ***************************/
int rabbit_test(void)
{
byte cipher[16];
byte plain[16];
const char* keys[] =
{ /* each keys[i] must be 128 bits��16 bytes��*/
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00",
"\xAC\xC3\x51\xDC\xF1\x62\xFC\x3B\xFE\x36\x3D\x2E\x29\x13\x28\x91",
};
const char* ivs[] =
{ /* each iv[i] must be 64 bits��8 bytes��*/
"\x00\x00\x00\x00\x00\x00\x00\x00",
"\x59\x7E\x26\xC1\x75\xF5\x73\xC3",
};
testVector a, b, c;
testVector test_rabbit[3];
int times = sizeof(test_rabbit) / sizeof(testVector);
a.input = "\x00\x00\x00\x00\x00\x00\x00\x00";
a.output = "\xED\xB7\x05\x67\x37\x5D\xCD\x7C";
a.inLen = 8;/* must be the right number of bytes of input*/
a.outLen = 8;/* must be the right number of bytes of output*/
b.input = "\x00\x00\x00\x00\x00\x00\x00\x00\x00";
b.output = "\x6D\x7D\x01\x22\x92\xCC\xDC\xE0\xE2";
b.inLen = 9;
b.outLen = 9;
c.input = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
c.output = "\x04\xCE\xCA\x7A\x1A\x86\x6E\x77\xFC\xCA";
c.inLen = 10;
c.outLen = 10;
test_rabbit[0] = a;
test_rabbit[1] = b;
test_rabbit[2] = c;
for (int i = 0; i < times; ++i)
{
Rabbit enc;
Rabbit dec;
byte* iv;
/* align keys/ivs in plain/cipher buffers */
memcpy(plain, keys[i],16);
/* get 64 bits iv */
if (ivs[i]) {
memcpy(cipher, ivs[i],8);
iv = cipher;
} else
iv = NULL;
RabbitSetKey(&enc, plain, iv);
RabbitSetKey(&dec, plain, iv);
/* align input */
memcpy(plain, test_rabbit[i].input, test_rabbit[i].outLen);
/* Rabbit Encryption process */
RabbitProcess(&enc, cipher, plain, (word32)test_rabbit[i].outLen);
/*Print the cipher text */
printf("The %d's Cipher Text is��",i+1);
for(int j=0;j<test_rabbit[i].outLen;j++)
{
printf("-%x",cipher[j]);
}
printf("\r\n");
printf("\r\n");
/* Rabbit Decryption process */
RabbitProcess(&dec, plain, cipher, (word32)test_rabbit[i].outLen);
/*Print the plain text */
printf("The %d's Plain Text is��",i+1);
for(int j=0;j<test_rabbit[i].outLen;j++)
{
printf("-%x",plain[j]);
}
printf("\r\n");
printf("\r\n");
/* Compare plain text��generated from decryption, with test_rabbit[i].input defined */
if (memcmp(plain, test_rabbit[i].input, test_rabbit[i].outLen))
return i+1;
/* Compare cipher text, generated from encryption, with vtest_rabbit[i].output predefined */
if (memcmp(cipher, test_rabbit[i].output, test_rabbit[i].outLen))
return -(i+1);
}
return 0;
}
static int SetKeys(SSL* ssl)
{
#ifdef BUILD_ARC4
word32 sz = ssl->specs.key_size;
if (ssl->specs.bulk_cipher_algorithm == rc4) {
if (ssl->options.side == CLIENT_END) {
Arc4SetKey(&ssl->encrypt.arc4, ssl->keys.client_write_key, sz);
Arc4SetKey(&ssl->decrypt.arc4, ssl->keys.server_write_key, sz);
}
else {
Arc4SetKey(&ssl->encrypt.arc4, ssl->keys.server_write_key, sz);
Arc4SetKey(&ssl->decrypt.arc4, ssl->keys.client_write_key, sz);
}
}
#endif
#ifdef BUILD_HC128
if (ssl->specs.bulk_cipher_algorithm == hc128) {
if (ssl->options.side == CLIENT_END) {
Hc128_SetKey(&ssl->encrypt.hc128, ssl->keys.client_write_key,
ssl->keys.client_write_IV);
Hc128_SetKey(&ssl->decrypt.hc128, ssl->keys.server_write_key,
ssl->keys.server_write_IV);
}
else {
Hc128_SetKey(&ssl->encrypt.hc128, ssl->keys.server_write_key,
ssl->keys.server_write_IV);
Hc128_SetKey(&ssl->decrypt.hc128, ssl->keys.client_write_key,
ssl->keys.client_write_IV);
}
}
#endif
#ifdef BUILD_RABBIT
if (ssl->specs.bulk_cipher_algorithm == rabbit) {
if (ssl->options.side == CLIENT_END) {
RabbitSetKey(&ssl->encrypt.rabbit, ssl->keys.client_write_key,
ssl->keys.client_write_IV);
RabbitSetKey(&ssl->decrypt.rabbit, ssl->keys.server_write_key,
ssl->keys.server_write_IV);
}
else {
RabbitSetKey(&ssl->encrypt.rabbit, ssl->keys.server_write_key,
ssl->keys.server_write_IV);
RabbitSetKey(&ssl->decrypt.rabbit, ssl->keys.client_write_key,
ssl->keys.client_write_IV);
}
}
#endif
#ifdef BUILD_DES3
if (ssl->specs.bulk_cipher_algorithm == triple_des) {
if (ssl->options.side == CLIENT_END) {
Des3_SetKey(&ssl->encrypt.des3, ssl->keys.client_write_key,
ssl->keys.client_write_IV, DES_ENCRYPTION);
Des3_SetKey(&ssl->decrypt.des3, ssl->keys.server_write_key,
ssl->keys.server_write_IV, DES_DECRYPTION);
}
else {
Des3_SetKey(&ssl->encrypt.des3, ssl->keys.server_write_key,
ssl->keys.server_write_IV, DES_ENCRYPTION);
Des3_SetKey(&ssl->decrypt.des3, ssl->keys.client_write_key,
ssl->keys.client_write_IV, DES_DECRYPTION);
}
}
#endif
#ifdef BUILD_AES
if (ssl->specs.bulk_cipher_algorithm == aes) {
if (ssl->options.side == CLIENT_END) {
AesSetKey(&ssl->encrypt.aes, ssl->keys.client_write_key,
ssl->specs.key_size, ssl->keys.client_write_IV,
AES_ENCRYPTION);
AesSetKey(&ssl->decrypt.aes, ssl->keys.server_write_key,
ssl->specs.key_size, ssl->keys.server_write_IV,
AES_DECRYPTION);
}
else {
AesSetKey(&ssl->encrypt.aes, ssl->keys.server_write_key,
ssl->specs.key_size, ssl->keys.server_write_IV,
AES_ENCRYPTION);
AesSetKey(&ssl->decrypt.aes, ssl->keys.client_write_key,
ssl->specs.key_size, ssl->keys.client_write_IV,
AES_DECRYPTION);
}
}
#endif
ssl->keys.sequence_number = 0;
ssl->keys.peer_sequence_number = 0;
ssl->keys.encryptionOn = 0;
return 0;
}
static int SetKeys(Ciphers* enc, Ciphers* dec, Keys* keys, CipherSpecs* specs,
byte side, void* heap, RNG* rng)
{
#ifdef BUILD_ARC4
word32 sz = specs->key_size;
if (specs->bulk_cipher_algorithm == rc4) {
enc->arc4 = (Arc4*)XMALLOC(sizeof(Arc4), heap, DYNAMIC_TYPE_CIPHER);
if (enc->arc4 == NULL)
return MEMORY_E;
dec->arc4 = (Arc4*)XMALLOC(sizeof(Arc4), heap, DYNAMIC_TYPE_CIPHER);
if (dec->arc4 == NULL)
return MEMORY_E;
if (side == CLIENT_END) {
Arc4SetKey(enc->arc4, keys->client_write_key, sz);
Arc4SetKey(dec->arc4, keys->server_write_key, sz);
}
else {
Arc4SetKey(enc->arc4, keys->server_write_key, sz);
Arc4SetKey(dec->arc4, keys->client_write_key, sz);
}
}
#endif
#ifdef HAVE_HC128
if (specs->bulk_cipher_algorithm == hc128) {
enc->hc128 = (HC128*)XMALLOC(sizeof(HC128), heap, DYNAMIC_TYPE_CIPHER);
if (enc->hc128 == NULL)
return MEMORY_E;
dec->hc128 = (HC128*)XMALLOC(sizeof(HC128), heap, DYNAMIC_TYPE_CIPHER);
if (dec->hc128 == NULL)
return MEMORY_E;
if (side == CLIENT_END) {
Hc128_SetKey(enc->hc128, keys->client_write_key,
keys->client_write_IV);
Hc128_SetKey(dec->hc128, keys->server_write_key,
keys->server_write_IV);
}
else {
Hc128_SetKey(enc->hc128, keys->server_write_key,
keys->server_write_IV);
Hc128_SetKey(dec->hc128, keys->client_write_key,
keys->client_write_IV);
}
}
#endif
#ifdef BUILD_RABBIT
if (specs->bulk_cipher_algorithm == rabbit) {
enc->rabbit = (Rabbit*)XMALLOC(sizeof(Rabbit),heap,DYNAMIC_TYPE_CIPHER);
if (enc->rabbit == NULL)
return MEMORY_E;
dec->rabbit = (Rabbit*)XMALLOC(sizeof(Rabbit),heap,DYNAMIC_TYPE_CIPHER);
if (dec->rabbit == NULL)
return MEMORY_E;
if (side == CLIENT_END) {
RabbitSetKey(enc->rabbit, keys->client_write_key,
keys->client_write_IV);
RabbitSetKey(dec->rabbit, keys->server_write_key,
keys->server_write_IV);
}
else {
RabbitSetKey(enc->rabbit, keys->server_write_key,
keys->server_write_IV);
RabbitSetKey(dec->rabbit, keys->client_write_key,
keys->client_write_IV);
}
}
#endif
#ifdef BUILD_DES3
if (specs->bulk_cipher_algorithm == triple_des) {
enc->des3 = (Des3*)XMALLOC(sizeof(Des3), heap, DYNAMIC_TYPE_CIPHER);
if (enc->des3 == NULL)
return MEMORY_E;
dec->des3 = (Des3*)XMALLOC(sizeof(Des3), heap, DYNAMIC_TYPE_CIPHER);
if (dec->des3 == NULL)
return MEMORY_E;
if (side == CLIENT_END) {
Des3_SetKey(enc->des3, keys->client_write_key,
keys->client_write_IV, DES_ENCRYPTION);
Des3_SetKey(dec->des3, keys->server_write_key,
keys->server_write_IV, DES_DECRYPTION);
}
else {
Des3_SetKey(enc->des3, keys->server_write_key,
keys->server_write_IV, DES_ENCRYPTION);
Des3_SetKey(dec->des3, keys->client_write_key,
keys->client_write_IV, DES_DECRYPTION);
}
}
#endif
#ifdef BUILD_AES
if (specs->bulk_cipher_algorithm == aes) {
enc->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
if (enc->aes == NULL)
return MEMORY_E;
dec->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
if (dec->aes == NULL)
return MEMORY_E;
if (side == CLIENT_END) {
AesSetKey(enc->aes, keys->client_write_key,
specs->key_size, keys->client_write_IV,
AES_ENCRYPTION);
AesSetKey(dec->aes, keys->server_write_key,
specs->key_size, keys->server_write_IV,
AES_DECRYPTION);
}
else {
AesSetKey(enc->aes, keys->server_write_key,
specs->key_size, keys->server_write_IV,
AES_ENCRYPTION);
AesSetKey(dec->aes, keys->client_write_key,
specs->key_size, keys->client_write_IV,
AES_DECRYPTION);
}
}
#endif
#ifdef BUILD_AESGCM
if (specs->bulk_cipher_algorithm == aes_gcm) {
byte iv[AES_GCM_EXP_IV_SZ];
enc->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
if (enc->aes == NULL)
return MEMORY_E;
dec->aes = (Aes*)XMALLOC(sizeof(Aes), heap, DYNAMIC_TYPE_CIPHER);
if (dec->aes == NULL)
return MEMORY_E;
/* Initialize the AES-GCM explicit IV to a random number. */
RNG_GenerateBlock(rng, iv, sizeof(iv));
AesGcmSetExpIV(enc->aes, iv);
if (side == CLIENT_END) {
AesGcmSetKey(enc->aes, keys->client_write_key, specs->key_size,
keys->client_write_IV);
AesGcmSetKey(dec->aes, keys->server_write_key, specs->key_size,
keys->server_write_IV);
}
else {
AesGcmSetKey(enc->aes, keys->server_write_key, specs->key_size,
keys->server_write_IV);
AesGcmSetKey(dec->aes, keys->client_write_key, specs->key_size,
keys->client_write_IV);
}
}
#endif
keys->sequence_number = 0;
keys->peer_sequence_number = 0;
keys->encryptionOn = 0;
(void)rng;
return 0;
}
