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); }