static void encrypt_callback(void *priv, u8 *srcdst, unsigned int nbytes)
{
const unsigned int bsize = CAMELLIA_BLOCK_SIZE;
struct crypt_priv *ctx = priv;
int i;
ctx->fpu_enabled = camellia_fpu_begin(ctx->fpu_enabled, nbytes);
if (nbytes >= CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS * bsize) {
camellia_ecb_enc_32way(ctx->ctx, srcdst, srcdst);
srcdst += bsize * CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS;
nbytes -= bsize * CAMELLIA_AESNI_AVX2_PARALLEL_BLOCKS;
}
if (nbytes >= CAMELLIA_AESNI_PARALLEL_BLOCKS * bsize) {
camellia_ecb_enc_16way(ctx->ctx, srcdst, srcdst);
srcdst += bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;
nbytes -= bsize * CAMELLIA_AESNI_PARALLEL_BLOCKS;
}
while (nbytes >= CAMELLIA_PARALLEL_BLOCKS * bsize) {
camellia_enc_blk_2way(ctx->ctx, srcdst, srcdst);
srcdst += bsize * CAMELLIA_PARALLEL_BLOCKS;
nbytes -= bsize * CAMELLIA_PARALLEL_BLOCKS;
}
for (i = 0; i < nbytes / bsize; i++, srcdst += bsize)
camellia_enc_blk(ctx->ctx, srcdst, srcdst);
}
static void
ecb_enc (unsigned char *out, unsigned char *in, unsigned int len)
{
int i, r;
for (i = 0; i < len; i += 16) {
r = camellia_enc_blk (in + i, out + i, &ctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
}
if (i != len) abort ();
}
static void
cts_enc (unsigned char *out, unsigned char *in, unsigned char *iv,
unsigned int len)
{
int r;
unsigned int len2;
unsigned char pn1[B], pn[B], cn[B], cn1[B];
if (len < B + 1) abort ();
len2 = (len - B - 1) & ~(B-1);
cbc_enc (out, in, iv, len2);
out += len2;
in += len2;
len -= len2;
if (len2)
iv = out - B;
if (len <= B || len > 2 * B)
abort ();
printf ("(did CBC mode for %d)\n", len2);
D(in);
xor (pn1, in, iv);
D(pn1);
r = camellia_enc_blk (pn1, cn, &ctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
D(cn);
memset (pn, 0, sizeof(pn));
memcpy (pn, in+B, len-B);
D(pn);
xor (pn, pn, cn);
D(pn);
r = camellia_enc_blk (pn, cn1, &ctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
D(cn1);
memcpy(out, cn1, B);
memcpy(out+B, cn, len-B);
}
static void
cbc_enc (unsigned char *out, unsigned char *in, unsigned char *iv,
unsigned int len)
{
int i, r;
unsigned char tmp[B];
D(iv);
memcpy (tmp, iv, B);
for (i = 0; i < len; i += B) {
D(in+i);
xor (tmp, tmp, in + i);
D(tmp);
r = camellia_enc_blk (tmp, out + i, &ctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
memcpy (tmp, out + i, B);
D(out+i);
}
if (i != len) abort ();
}
static void fips_test ()
{
static const unsigned char fipskey[16] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
};
static const unsigned char input[16] = {
0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10,
};
static const unsigned char expected[16] = {
0x67,0x67,0x31,0x38,0x54,0x96,0x69,0x73,
0x08,0x57,0x06,0x56,0x48,0xea,0xbe,0x43
};
unsigned char output[16];
unsigned char tmp[16];
camellia_ctx fipsctx;
int r;
printf ("FIPS test:\nkey:");
hexdump (fipskey, 16);
printf ("\ninput:");
hexdump (input, 16);
r = camellia_enc_key (fipskey, sizeof(fipskey), &fipsctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
r = camellia_enc_blk (input, output, &fipsctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
printf ("\noutput:");
hexdump (output, 16);
printf ("\n");
if (memcmp(expected, output, 16))
fprintf(stderr, "wrong results!!!\n"), exit (1);
r = camellia_dec_key (fipskey, sizeof(fipskey), &fipsctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
r = camellia_dec_blk (output, tmp, &fipsctx);
if (!r) fprintf(stderr, "error, line %d\n", __LINE__), exit(1);
if (memcmp(input, tmp, 16))
fprintf(stderr, "decryption failed!!\n"), exit(1);
printf ("ok.\n\n");
}
krb5_error_code
krb5int_camellia_cbc_mac(krb5_key key, const krb5_crypto_iov *data,
size_t num_data, const krb5_data *iv,
krb5_data *output)
{
camellia_ctx ctx;
unsigned char blockY[BLOCK_SIZE];
struct iov_block_state iov_state;
if (output->length < BLOCK_SIZE)
return KRB5_BAD_MSIZE;
if (camellia_enc_key(key->keyblock.contents,
key->keyblock.length, &ctx) != camellia_good)
abort();
if (iv != NULL)
memcpy(blockY, iv->data, BLOCK_SIZE);
else
memset(blockY, 0, BLOCK_SIZE);
IOV_BLOCK_STATE_INIT(&iov_state);
for (;;) {
unsigned char blockB[BLOCK_SIZE];
if (!krb5int_c_iov_get_block(blockB, BLOCK_SIZE, data, num_data,
&iov_state))
break;
xorblock(blockB, blockY);
if (camellia_enc_blk(blockB, blockY, &ctx) != camellia_good)
abort();
}
output->length = BLOCK_SIZE;
memcpy(output->data, blockY, BLOCK_SIZE);
return 0;
}
static inline void
enc(unsigned char *out, const unsigned char *in, camellia_ctx *ctx)
{
if (camellia_enc_blk(in, out, ctx) != camellia_good)
abort();
}
