Exemple #1
0
/*
 Encrypt and decrypt 'nblocks*loop' blocks of zeroes,
 'nblocks' at a time.
 */
int ccmode_cbc_test_chaining_self(const struct ccmode_cbc *encrypt,
                                  const struct ccmode_cbc *decrypt,
                                  unsigned long nblocks, size_t keylen,
                                  const void *keydata, unsigned long loops)
{
    unsigned char temp[nblocks*encrypt->block_size];
    unsigned char zeroes[nblocks*encrypt->block_size];
    cccbc_ctx_decl(encrypt->size, ekey);
    cccbc_ctx_decl(decrypt->size, dkey);

    /* here we have to use two iv contexts */
    cccbc_iv_decl(encrypt->block_size, eiv);
    cccbc_iv_decl(decrypt->block_size, div);

    cc_zero(nblocks*encrypt->block_size,temp);
    cc_zero(nblocks*encrypt->block_size,zeroes);

    cccbc_init(encrypt, ekey, keylen, keydata);
    cccbc_init(decrypt, dkey, keylen, keydata);

    cccbc_set_iv(encrypt, eiv, NULL);
    cccbc_set_iv(decrypt, div, NULL);

    for (unsigned long i=0; i<loops; i++) {
        cccbc_update(encrypt, ekey, eiv, nblocks, temp, temp);
        cccbc_update(decrypt, dkey, div, nblocks, temp, temp);
    }

    return memcmp(zeroes, temp, sizeof(temp));
}
Exemple #2
0
/* Initialize a block of 'nblocks' of zeroes,
 Does 'loops' consecutive encryption (CBC) in place,
 then 'loops' decryption (CBC) in place,
 using 0 for iv in each loop, result should be zeroes. */
int ccmode_cbc_test_key_self(const struct ccmode_cbc *encrypt,
                             const struct ccmode_cbc *decrypt,
                             unsigned long nblocks, size_t keylen,
                             const void *keydata, unsigned long loops)
{
    unsigned char temp[nblocks*encrypt->block_size];
    unsigned char zeroes[nblocks*encrypt->block_size];
    cccbc_iv_decl(encrypt->block_size, iv); // we can use the same iv context for encrypt and decrypt
                                            // as long as we are not chaining concurrently for both.
    cccbc_ctx_decl(encrypt->size, ekey);
    cccbc_ctx_decl(decrypt->size, dkey);

    cc_zero(nblocks*encrypt->block_size,temp);
    cc_zero(nblocks*encrypt->block_size,zeroes);

    cccbc_init(encrypt, ekey, keylen, keydata);

    for (unsigned long i=0; i<loops; i++) {
        cccbc_set_iv(encrypt, iv, NULL);
        cccbc_update(encrypt, ekey, iv, nblocks, temp, temp);
    }

    cccbc_init(decrypt, dkey, keylen, keydata);

    for (unsigned long i=0; i<loops; i++) {
        cccbc_set_iv(decrypt, iv, NULL);
        cccbc_update(decrypt, dkey, iv, nblocks, temp, temp);
    }

    return memcmp(zeroes, temp, encrypt->block_size*nblocks);
}
Exemple #3
0
aes_rval aes_decrypt_cbc(const unsigned char *in_blk, const unsigned char *in_iv, unsigned int num_blk,
					 	 unsigned char *out_blk, aes_decrypt_ctx cx[1])
{
	const struct ccmode_cbc *cbc = g_crypto_funcs->ccaes_cbc_decrypt;
	cccbc_iv_decl(cbc->block_size, ctx_iv);

	cccbc_set_iv(cbc, ctx_iv, in_iv);
	cccbc_update(cbc, cx[0].ctx, ctx_iv, num_blk, in_blk, out_blk);	//Actually cbc decrypt.

	return aes_good;
}
Exemple #4
0
/* Test one test vector, 1 block at a time */
int ccmode_cbc_test_one_chained(const struct ccmode_cbc *cbc, size_t keylen, const void *keydata,
                                const void *iv, unsigned long nblocks, const void *in, const void *out)
{
    unsigned long i;
    const unsigned char *input=in;
    unsigned char temp[nblocks*cbc->block_size];
    cccbc_ctx_decl(cbc->size, key);
    cccbc_iv_decl(cbc->block_size, iv_ctx);
    cccbc_init(cbc, key, keylen, keydata);
    cccbc_set_iv(cbc, iv_ctx, iv);
    for (i=0; i<nblocks; i++) {
        cccbc_update(cbc, key, iv_ctx, 1, &input[i*cbc->block_size], &temp[i*cbc->block_size]);
    }

    return memcmp(out, temp, cbc->block_size*nblocks);
}
static double perf_cccbc_update(unsigned long loops, unsigned long size, const void *arg)
{
    const struct cccbc_perf_test *test=arg;
    const struct ccmode_cbc *cbc=test->cbc;
    size_t keylen=test->keylen;
    unsigned long nblocks=size/cbc->block_size;

    unsigned char keyd[keylen];
    unsigned char temp[nblocks*cbc->block_size];

    cc_zero(keylen,keyd);
    cccbc_ctx_decl(cbc->size, key);
    cccbc_iv_decl(cbc->block_size, iv);

    cccbc_init(cbc, key, keylen, keyd);
    cccbc_set_iv(cbc, iv, NULL);

    perf_start();
    while(loops--)
        cccbc_update(cbc, key, iv, nblocks, temp, temp);

    return perf_time();
}