void cbc_me(FILE *outf, f_ectx alg[1], const unsigned long blen, const unsigned long klen)
{ unsigned long j, k;
unsigned char ct[64], key[32], dummy;
block_clear(key, klen); // clear key: KEY[0]
block_clear(ct, 2 * blen); // clear ct: PT[0], ct + blen: IV[0]
for(j = 0; j < 400; j++) // 400 Monte Carlo tests
{
block_out(test_no, &dummy, outf, j); // output test number
block_out(key_val, key, outf, klen); // output key
block_out(iv_val, ct + blen, outf, blen); // output initialisation vector
block_out(pt_val, ct, outf, blen); // output plaintext
f_enc_key(alg, key, klen); // set key
for(k = 0; k < 5000; ++k) // 10000 encryptions, two at a time
{
block_xor(ct, ct + blen, blen); // do CBC chaining
do_enc(alg, ct, ct, 1); // do block encryption
block_xor(ct + blen, ct, blen); // do CBC chaining
do_enc(alg, ct + blen, ct + blen, 1);// do block encryption
}
block_out(ct_val, ct + blen, outf, blen); // output ciphertext
// compile next key as defined by NIST
block_xor(key, ct + 2 * blen - klen, klen);
}
}
void ecb_me(FILE *outf, f_ectx alg[1], const unsigned long blen, const unsigned long klen)
{ unsigned long j, k;
unsigned char pt[32], ct[64], key[32], dummy;
block_clear(pt, blen); // clear initial plaintext
block_clear(key, klen); // and key blocks
block_copy(ct + blen, pt, blen); // put plaintext in upper half
// of double length buffer
for(j = 0; j < 400; j++) // 400 Monte Carlo tests
{
block_out(test_no, &dummy, outf, j); // output test number
block_out(key_val, key, outf, klen); // output key
block_out(pt_val, pt, outf, blen); // output plaintext
f_enc_key(alg, key, klen); // set the key
for(k = 0; k < 5000; ++k) // 10000 encryptions alternating
{ // upper and lower blocks in ct
do_enc(alg, ct + blen, ct, 1);
do_enc(alg, ct, ct + blen, 1);
}
// compile next key as defined by NIST
block_xor(key, ct + 2 * blen - klen, klen);
block_out(ct_val, ct + blen, outf, blen); // output ciphertext
block_copy(pt, ct + blen, blen); // copy ciphertext as next plaintext
}
}
local int Encrypt(Player *p, byte *data, int len)
{
EncData *ed, **p_ed = PPDATA(p, enckey);
pthread_mutex_lock(&mtx);
ed = *p_ed;
pthread_mutex_unlock(&mtx);
return ed ? do_enc(ed, data, len) : len;
}
local int ClientEncrypt(ClientEncryptData *ced, byte *d, int n)
{
EncData *ed = (EncData*)ced;
if (d[1] == 0x01 && d[0] == 0x00)
{
/* sending key init */
/* temporarily overload the key field to be what _we_ sent */
ed->key = *(int*)(d+2);
return n;
}
else if (ed->key != BAD_KEY)
return do_enc(ed, d, n);
else
return n;
}
void ecb_vt(FILE *outf, f_ectx alg[1], const unsigned long blen, const unsigned long klen)
{ unsigned long j;
unsigned char pt[32], ct[32], key[32], dummy;
block_clear(key, klen); // all zero key
block_out(key_val, key, outf, klen); // output key value
f_enc_key(alg, key, klen); // set key value
for(j = 0; j <= 8 * blen; ++j) // test vectors include
{ // an all zero one
block_out(test_no, &dummy, outf, j); // output test number
block_clear(pt, blen); // set all zero plain text
if(j) // set bit (j-1) if j <> 0
*(pt + (j - 1) / 8) = 0x80 >> (j - 1) % 8;
block_out(pt_val, pt, outf, blen); // output plaintext
do_enc(alg, pt , ct, 1); // do encryption
block_out(ct_val, ct, outf, blen); // output ciphertext
}
}
void ecb_vk(FILE *outf, f_ectx alg[1], const unsigned long blen, const unsigned long klen)
{ unsigned long j;
unsigned char pt[32], ct[32], key[32], dummy;
block_clear(pt, blen); // all zero plaintext
block_out(pt_val, pt, outf, blen); // output plaintext
for(j = 0; j <= 8 * klen; ++j) // 129, 193 or 257 tests
{
block_out(test_no, &dummy, outf, j); // output test number
block_clear(key, klen); // set all zero key
if(j) // set bit (j-1) if j <> 0
*(key + (j - 1) / 8) = 0x80 >> (j - 1) % 8;
block_out(key_val, key, outf, klen); // output key value
f_enc_key(alg, key, klen); // set key value
do_enc(alg, pt , ct, 1); // alg.encrypt
block_out(ct_val, ct, outf, blen); // output ciphertext
}
}
void ecb_vkn(FILE *outf, f_ectx alg[1], const unsigned long blen, const unsigned long klen)
{ unsigned long j;
unsigned char pt[32], ct[32], key[32], *bp, dummy;
block_clear(pt, blen); // all zero plaintext
block_out(pt_val, pt, outf, blen); // output plaintext
block_clear(key, klen);
for(j = 0; j < 16 * klen; ++j)
{
block_out(test_no, &dummy, outf, j); // output test number
block_out(key_val, key, outf, klen); // output key value
f_enc_key(alg, key, klen); // set key value
do_enc(alg, pt , ct, 1); // alg.encrypt
block_out(ct_val, ct, outf, blen); // output ciphertext
bp = key + klen - 1 - j / 8;
if(j < 8 * klen)
*bp |= (*bp << 1) | 1;
else
*(bp + klen) = *(bp + klen) << 1;
}
}
