int decrypt(WORDSIZE* data, WORDSIZE* decryption_iv, WORDSIZE* keym,
WORDSIZE* extra_data, WORDSIZE* tag,
unsigned long data_size, unsigned long extra_data_size){
REGISTER a, b, c, d, t;
unsigned long index;
load_register(d, decryption_iv, 4);
load_register(c, decryption_iv, 0);
load_register(t, keym, 4);
d ^= t;
load_register(t, keym, 0);
c ^= t;
unsigned long block_number = data_size / 8;
while (block_number-- > 0){
load_register(a, data, (block_number * 8));
load_register(b, data, (block_number * 8) + 4);
inverse_permutation(a, b, c, d);
store_register(a, data, (block_number * 8));
store_register(b, data, (block_number * 8) + 4);}
WORDSIZE _tag[8], keyr[8];
store_register(c, keyr, 0);
store_register(d, keyr, 4);
keyed_hash_function(keyr, extra_data, extra_data_size, _tag);
REGISTER tag_a, tag_b, _tag_a, _tag_b, valid;
load_register(tag_a, tag, 0); load_register(tag_b, tag, 4);
load_register(_tag_a, _tag, 0); load_register(_tag_b, tag, 4);
valid[0] = 0xFFFFFFFF; valid[1] = 0xFFFFFFFF; valid[2] = 0xFFFFFFFF; valid[3] = 0xFFFFFFFF;
valid = (_tag_a ^ tag_a ^ 0xFFFFFFFF) & valid;
valid = (_tag_b ^ tag_b ^ 0xFFFFFFFF) & valid;
return valid[0] & valid[1] & valid[2] & valid[3];}
void permutation(WORDSIZE* state){
REGISTER t, a, b, c, d;
load_register(a, state, 0); load_register(b, state, 4);
load_register(c, state, 8); load_register(d, state, 12);
int index;
WORDSIZE round_constants[4] = {1, 0, 0, 0};
for (index = 1; index < ROUNDS + 1; index++){
add_constant(a);
mix_slice(a, b, c, d);
shift_sections(b, c, d);}
store_register(a, state, 0); store_register(b, state, 4);
store_register(c, state, 8); store_register(d, state, 12);}
/* Libera el registro AL ocupado usando la variable parametro y lo retorna */
Element *free_AL(Element *variable) {
Stack *pila_aux = (Stack *)0;
Element *elem_aux = (Element *)malloc(sizeof(Element));
Element *ret = (Element *)malloc(sizeof(Element));
/* Busco el registro AL ocupado para liberarlo */
spop(&pila, (void *)&elem_aux);
while (elem_aux->code != REGISTRO || (elem_aux->code == REGISTRO && elem_aux->value != 0)) {
spush(&pila_aux, (void *)elem_aux);
spop(&pila, (void *)&elem_aux);
}
/* Vuelco el contenido del registro a liberar en la variable parametro */
fprintf(output_fd, "\t\tMOV\t_%s, %s\n", variable->name, elem_aux->name);
/* Apilo la variable en lugar del registro y *
* guardo en la variable el registro a retornar */
spush(&pila, (void *)variable);
ret = load_register(0);
/* Apilo nuevamente los demas operandos sacados de la pila */
while (pila_aux != (Stack *)0) {
spop(&pila_aux, (void *)&elem_aux);
spush(&pila, (void *)elem_aux);
}
return ret;
}
/* Libera el registro AL y lo retorna */
Element *get_free_AL() {
Element *ret = (Element *)malloc(sizeof(Element));
if (state[0] != 0) {
Element *aux = (Element *)malloc(sizeof(Element));
aux = new_variable();
free_AL(aux);
state[1] = 0;
}
ret = load_register(0);
return ret;
}
/* Libera un registro que no sea AH o AL y lo retorna *
* Siempre se retorna un registro, haya o no uno libre *
* El registro quedara marcado como libre */
Element *get_free_notA() {
int i = N - 1;
Element *ret = (Element *)malloc(sizeof(Element));
while (i > 1 && state[i] == 1) i--;
if (i > 1) {
/* Hay un registro libre, se lo retorna */
ret = load_register(i);
} else {
/* No hay registros libres, dar de alta una nueva variable en la tabla de simbolos
* y liberar un registro. */
ret = free_any_notA(new_variable());
state[ret->value] = 0;
}
return ret;
}
void encrypt(WORDSIZE* data, WORDSIZE* keyr, WORDSIZE* keym,
WORDSIZE* extra_data, WORDSIZE* tag, WORDSIZE* decryption_iv,
unsigned long data_size, unsigned long extra_data_size){
REGISTER a, b, c, d, t;
unsigned long index;
keyed_hash_function(keyr, extra_data, extra_data_size, tag);
load_register(c, keyr, 0); load_register(d, keyr, 4);
unsigned long block_number;
for (block_number = 0; block_number < data_size / 8; block_number++){
load_register(a, data, (block_number * 8));
load_register(b, data, ((block_number * 8) + 4));
permutation(a, b, c, d);
store_register(a, data, (block_number * 8));
store_register(b, data, ((block_number * 8) + 4));}
load_register(t, keym, 0);
c ^= t;
load_register(t, keym, 4);
d ^= t;
store_register(c, decryption_iv, 0);
store_register(d, decryption_iv, 4);}
static void __init init_rd(void)
{
load_register(&tiff1_loader);
load_register(&tiff2_loader);
}
static void __init init_rd(void)
{
load_register(&sane_loader);
}
