static int init_id_key(rc4_key* key,int key_data_len)
{
unsigned char index1;
unsigned char index2;
unsigned char* state;
short counter;
unsigned char *key_data_ptr = 0;
key_data_ptr = calloc(1,key_data_len);
if (!key_data_ptr)
return ARES_ENOMEM;
state = &key->state[0];
for(counter = 0; counter < 256; counter++)
/* unnecessary AND but it keeps some compilers happier */
state[counter] = (unsigned char)(counter & 0xff);
randomize_key(key->state,key_data_len);
key->x = 0;
key->y = 0;
index1 = 0;
index2 = 0;
for(counter = 0; counter < 256; counter++)
{
index2 = (unsigned char)((key_data_ptr[index1] + state[counter] +
index2) % 256);
ARES_SWAP_BYTE(&state[counter], &state[index2]);
index1 = (unsigned char)((index1 + 1) % key_data_len);
}
free(key_data_ptr);
return ARES_SUCCESS;
}
void test_decryption()
{
gf2matrix *mix_columns_mixing_bijection, *inv_mix_columns_mixing_bijection;
tbox_mixing_bijections_t tbox_mixing_bijections, inv_tbox_mixing_bijections;
gf2matrix *initial_encoding, *initial_decoding;
gf2matrix *final_encoding, *final_decoding;
tbox_t tbox;
typeIA_t typeIAs;
typeII_t typeIIs;
typeIII_t typeIIIs;
typeIB_t typeIBs;
typeIV_IA_t typeIV_IAs;
typeIV_IB_t typeIV_IBs;
typeIV_II_round_t typeIV_IIs[NR - 1];
typeIV_III_round_t typeIV_IIIs[NR - 1];
uint32_t mixed_key_schedule[4 * (NR + 1)];
uint8_t key[KEY_SIZE] = {
0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
sboxes_8bit_t typeIA_input_sbox, typeIA_input_sbox_inv;
sboxes_128bit_t typeIA_interim_sbox, typeIA_interim_sbox_inv;
sboxes_8bit_t typeII_input_sbox[NR], typeII_input_sbox_inv[NR];
sboxes_32bit_t typeII_interim_sbox[NR - 1], typeII_interim_sbox_inv[NR - 1];
sboxes_8bit_t typeII_output_sbox[NR - 1], typeII_output_sbox_inv[NR - 1];
sboxes_32bit_t typeIII_interim_sbox[NR - 1], typeIII_interim_sbox_inv[NR
- 1];
sboxes_128bit_t typeIB_interim_sbox, typeIB_interim_sbox_inv;
sboxes_8bit_t typeIB_output_sbox, typeIB_output_sbox_inv;
uint8_t state[4][4];
uint8_t in[16];
uint8_t out[16], out2[16];
_4bit_strip32_t strips32;
_4bit_strip128_t strips128;
int round, row, col, i;
int tries = 3;
for (; tries != 0; --tries) {
randomize_key(key);
make_block_invertible_matrix_pair(&mix_columns_mixing_bijection,
&inv_mix_columns_mixing_bijection, 32);
/* mix_columns_mixing_bijection = make_identity_matrix(32); */
/* inv_mix_columns_mixing_bijection = make_identity_matrix(32); */
make_tbox_mixing_bijections(tbox_mixing_bijections,
inv_tbox_mixing_bijections);
/* make_identity_tbox_mixing_bijections(tbox_mixing_bijections); */
/* make_identity_tbox_mixing_bijections(inv_tbox_mixing_bijections); */
make_block_invertible_matrix_pair(&initial_encoding, &initial_decoding, 128);
/* initial_encoding = make_identity_matrix(128); */
/* initial_decoding = make_identity_matrix(128); */
make_block_invertible_matrix_pair(&final_encoding, &final_decoding, 128);
/* final_encoding = make_identity_matrix(128); */
/* final_decoding = make_identity_matrix(128); */
expand_key(key, SBox, mixed_key_schedule, 4);
mix_expanded_key(mixed_key_schedule);
make_inv_tbox(tbox, ISBox, mixed_key_schedule, tbox_mixing_bijections);
make_sbox_pair_8(typeIA_input_sbox, typeIA_input_sbox_inv);
/* make_identity_sboxes8(typeIA_input_sbox); */
/* make_identity_sboxes8(typeIA_input_sbox_inv); */
make_sbox_pair_128(typeIA_interim_sbox, typeIA_interim_sbox_inv);
/* make_identity_sboxes128(typeIA_interim_sbox); */
/* make_identity_sboxes128(typeIA_interim_sbox_inv); */
make_rounds_sbox_pair_8(typeII_input_sbox, typeII_input_sbox_inv, NR);
/* for(i =0; i < NR; ++i) { */
/* make_identity_sboxes8(typeII_input_sbox[i]); */
/* make_identity_sboxes8(typeII_input_sbox_inv[i]); */
/* } */
make_rounds_sbox_pair_32(typeII_interim_sbox, typeII_interim_sbox_inv,
NR - 1);
/* for(i =0; i < NR-1; ++i) { */
/* make_identity_sboxes32(typeII_interim_sbox[i]); */
/* make_identity_sboxes32(typeII_interim_sbox_inv[i]); */
/* } */
make_rounds_sbox_pair_8(typeII_output_sbox, typeII_output_sbox_inv, NR - 1);
/* for(i =0; i < NR-1; ++i) { */
/* make_identity_sboxes8(typeII_output_sbox[i]); */
/* make_identity_sboxes8(typeII_output_sbox_inv[i]); */
/* } */
make_rounds_sbox_pair_32(typeIII_interim_sbox, typeIII_interim_sbox_inv,
NR - 1);
/* for(i =0; i < NR-1; ++i) { */
/* make_identity_sboxes32(typeIII_interim_sbox[i]); */
/* make_identity_sboxes32(typeIII_interim_sbox_inv[i]); */
/* } */
make_sbox_pair_128(typeIB_interim_sbox, typeIB_interim_sbox_inv);
/* make_identity_sboxes128(typeIB_interim_sbox); */
/* make_identity_sboxes128(typeIB_interim_sbox_inv); */
make_sbox_pair_8(typeIB_output_sbox, typeIB_output_sbox_inv);
/* make_identity_sboxes8(typeIB_output_sbox); */
/* make_identity_sboxes8(typeIB_output_sbox_inv); */
make_typeIA(typeIAs, inv_tbox_mixing_bijections[NR - 1], initial_decoding,
typeIA_input_sbox_inv, typeIA_interim_sbox);
make_typeIV_IA(typeIV_IAs, typeIA_interim_sbox_inv,
typeII_input_sbox[NR - 1], typeII_input_sbox_inv[NR-1]);
make_inv_typeII(typeIIs, tbox, mix_columns_mixing_bijection,
&typeII_input_sbox_inv[1], typeII_interim_sbox);
make_typeIV_II(typeIV_IIs, typeII_interim_sbox_inv, typeII_output_sbox,
typeII_output_sbox_inv);
make_typeIII(typeIIIs, inv_mix_columns_mixing_bijection,
inv_tbox_mixing_bijections, typeII_output_sbox_inv,
typeIII_interim_sbox);
make_typeIV_III(typeIV_IIIs, typeIII_interim_sbox_inv,
typeII_input_sbox, typeII_input_sbox_inv);
make_inv_typeIB(typeIBs, tbox[0], final_encoding,
typeII_input_sbox_inv[0], typeIB_interim_sbox);
make_typeIV_IB(typeIV_IBs, typeIB_interim_sbox_inv, typeIB_output_sbox,
typeIB_output_sbox_inv);
for (i = 0; i < 16; ++i) {
in[i] = rand();
}
dump_hex("input: ", in, 16);
printf("White-box inverse cipher:\n");
do_input(state, in, initial_encoding, typeIA_input_sbox);
dump_state("State before ", state);
do_typeIA(strips128, state, typeIAs);
do_typeIV_IA(state, strips128, typeIV_IAs);
for (round = NR - 2; round != -1; --round) {
printf("round %d: ", round + 2);
dump_state("", state);
inv_shift_rows(state);
do_typeII(strips32, state, typeIIs[round]);
do_typeIV_II(state, strips32, typeIV_IIs[round]);
do_typeIII(strips32, state, typeIIIs[round]);
do_typeIV_III(state, strips32, typeIV_IIIs[round]);
}
inv_shift_rows(state);
dump_state("rounds 1 and 0: ", state);
do_typeIB(strips128, state, typeIBs);
do_typeIV_IB(state, strips128, typeIV_IBs);
do_output(out, state, final_decoding, typeIB_output_sbox_inv);
printf("Original AES Equivalent Inverse Cipher on same input using same key:\n");
eqv_decipher(in, out2, ISBox, mixed_key_schedule);
dump_hex("WB Output ", out, 16);
dump_hex("AES Output ", out2, 16);
ASSERT(memcmp(out, out2, 16) == 0);
free_matrix(mix_columns_mixing_bijection);
free_matrix(inv_mix_columns_mixing_bijection);
free_tbox_mixing_bijections(tbox_mixing_bijections);
free_tbox_mixing_bijections(inv_tbox_mixing_bijections);
free_matrix(final_decoding);
free_matrix(final_encoding);
free_matrix(initial_decoding);
free_matrix(initial_encoding);
}
}
