/* Take a chunk of data, encrypt it in the same way OpenSSL would
* (with a default of AES in CBC mode).
*/
size_t
rij_encrypt(unsigned char *in, size_t in_len,
const char *key, const int key_len,
unsigned char *out, int encryption_mode)
{
RIJNDAEL_context ctx;
int i, pad_val;
unsigned char *ondx = out;
rijndael_init(&ctx, key, key_len, NULL, encryption_mode);
/* Prepend the salt to the ciphertext...
*/
memcpy(ondx, "Salted__", SALT_LEN);
ondx+=SALT_LEN;
memcpy(ondx, ctx.salt, SALT_LEN);
ondx+=SALT_LEN;
/* Add padding to the original plaintext to ensure that it is a
* multiple of the Rijndael block size
*/
pad_val = RIJNDAEL_BLOCKSIZE - (in_len % RIJNDAEL_BLOCKSIZE);
for (i = (int)in_len; i < ((int)in_len+pad_val); i++)
in[i] = pad_val;
block_encrypt(&ctx, in, in_len+pad_val, ondx, ctx.iv);
ondx += in_len+pad_val;
zero_buf((char *)ctx.key, RIJNDAEL_MAX_KEYSIZE);
zero_buf((char *)ctx.iv, RIJNDAEL_BLOCKSIZE);
zero_buf((char *)ctx.salt, SALT_LEN);
return(ondx - out);
}
/* Decrypt the given data.
*/
size_t
rij_decrypt(unsigned char *in, size_t in_len,
const char *key, const int key_len,
unsigned char *out, int encryption_mode)
{
RIJNDAEL_context ctx;
int i, pad_val, pad_err = 0;
unsigned char *pad_s;
unsigned char *ondx = out;
if(in == NULL || key == NULL || out == NULL)
return 0;
rijndael_init(&ctx, key, key_len, in, encryption_mode);
/* Remove the first block since it contains the salt (it was consumed
* by the rijndael_init() function above).
*/
in_len -= RIJNDAEL_BLOCKSIZE;
memmove(in, in+RIJNDAEL_BLOCKSIZE, in_len);
block_decrypt(&ctx, in, in_len, out, ctx.iv);
ondx += in_len;
/* Find and remove padding.
*/
pad_val = *(ondx-1);
if(pad_val >= 0 && pad_val <= RIJNDAEL_BLOCKSIZE)
{
pad_s = ondx - pad_val;
for(i=0; i < (ondx-pad_s); i++)
{
if(*(pad_s+i) != pad_val)
pad_err++;
}
if(pad_err == 0)
ondx -= pad_val;
}
*ondx = '\0';
zero_buf((char *)ctx.key, RIJNDAEL_MAX_KEYSIZE);
zero_buf((char *)ctx.iv, RIJNDAEL_BLOCKSIZE);
zero_buf((char *)ctx.salt, SALT_LEN);
return(ondx - out);
}
static void
zero_buf_wrapper(char *buf, int len)
{
if(buf == NULL || len == 0)
return;
if(zero_buf(buf, len) == FKO_ERROR_ZERO_OUT_DATA)
log_msg(LOG_VERBOSITY_ERROR,
"[*] Could not zero out sensitive data buffer.");
return;
}
/* zero out a buffer before free()
*/
int zero_free(char *buf, int len)
{
int res = FKO_SUCCESS;
if(buf == NULL)
return res;
if(len == 0)
{
free(buf); /* always free() if buf != NULL */
return res;
}
res = zero_buf(buf, len);
free(buf);
return res;
}
/* zero out a buffer before free()
*/
int zero_free(char *buf, int len)
{
int res = FKO_SUCCESS;
if(buf == NULL)
return res;
if(len == 0)
{
free(buf); /* always free() if buf != NULL */
return res;
}
res = zero_buf(buf, len);
free(buf);
#if HAVE_LIBFIU
fiu_return_on("zero_free_err", FKO_ERROR_ZERO_OUT_DATA);
#endif
return res;
}
int main(int argc, char **argv)
{
char *trace_file_name;
int trace_view_on = 0;
int branch_prediction_method = 0;
unsigned int cycle_number = 0;
// Parse Inputs
if (argc == 2) {
trace_file_name = argv[1];
trace_view_on = 0;
branch_prediction_method = 0;
} else if (argc == 4) {
trace_file_name = argv[1];
trace_view_on = atoi(argv[2]);
branch_prediction_method = (atoi(argv[3]) == 1) ? 1 : 0;
} else {
fprintf(stdout, "\nUSAGE: tv <trace_file> <switch - any character> <branch_prediction - 0|1>\n");
fprintf(stdout, "\n(switch) to turn on or off individual item view.\n");
fprintf(stdout, "(branch_prediction) sets the branch prediction method as \'assume not taken\' (0), or a 1-bit branch predictor (1)\n\n");
exit(0);
}
// debug - print parsed options
char dbg_msg[200];
sprintf(dbg_msg,
"\n-debug- parsed inputs. file=%s, view_trace=%d, branch_pred=%d\n",
trace_file_name,
(trace_view_on == 0) ? 0 : 1,
(branch_prediction_method == 0) ? 0 : 1
);
debug_print(dbg_msg);
// Open the trace file.
fprintf(stdout, "\n ** opening file %s\n", trace_file_name);
trace_fd = fopen(trace_file_name, "rb");
if (!trace_fd) {
fprintf(stdout, "\ntrace file %s not opened.\n\n", trace_file_name);
exit(0);
}
trace_init();
// store what instruction is in each stage of the pipeline (can be no-ops)
struct trace_item new_instruction;
struct trace_item if_stage;
struct trace_item id_stage;
struct trace_item ex_stage;
struct trace_item mem_stage;
struct trace_item wb_stage;
zero_buf(&new_instruction);
zero_buf(&if_stage);
zero_buf(&id_stage);
zero_buf(&ex_stage);
zero_buf(&mem_stage);
zero_buf(&wb_stage);
memset(&btb_table, 0, sizeof(short) * BTB_ENTRIES);
int instructions_left = 5;
while(instructions_left) {
cycle_number++;
if(trace_view_on) {
print_finished_instruction(&wb_stage, cycle_number);
}
int hazard = 0;
//detection of non-happy
if(branch_prediction_method == 0 && ex_stage.type == ti_BRANCH){
if(ex_stage.PC + 4 != id_stage.PC){
hazard = 2; //incorrect no prediction
debug_print("[HAZARD] Incorrect default (not taken) prediciton\n");
}
}
else if(ex_stage.type == ti_JTYPE|| ex_stage.type == ti_JRTYPE){
hazard = 2; //jump
debug_print("[HAZARD] jump\n");
}
else if(branch_prediction_method == 1 && ex_stage.type == ti_BRANCH){
if(ex_stage.PC +4 == id_stage.PC){ // not taken
if(get_btb_value(ex_stage.PC) == 1){ //predict taken
hazard = 2; //branch
debug_print("[HAZARD] predicted taken when not taken\n");
set_btb_value(ex_stage.PC, 0);
}
}
else{ //taken
if(get_btb_value(ex_stage.PC) == 0){ //predict not taken
hazard = 2; //branch
debug_print("[HAZARD] predicted not taken when taken\n");
set_btb_value(ex_stage.PC, 1);
}
}
}
else if(ex_stage.type == ti_LOAD){
if(ex_stage.dReg == id_stage.sReg_a || ex_stage.dReg == id_stage.sReg_b){
hazard = 1; //forward
debug_print("[HAZARD] forward\n");
}
}
wb_stage = mem_stage;
mem_stage = ex_stage;
switch(hazard) {
case 0: //happy path
ex_stage = id_stage;
id_stage = if_stage;
if(!read_instruction(&if_stage)) {
instructions_left--;
zero_buf(&if_stage);
}
break;
case 1: //forward
zero_buf(&ex_stage);
break;
case 2: //branch resolve/jump resolve
add_queued_instruction(&id_stage);
add_queued_instruction(&if_stage);
zero_buf(&id_stage);
zero_buf(&if_stage);
ex_stage = id_stage;
id_stage = if_stage;
if(!read_instruction(&if_stage)) {
instructions_left--;
zero_buf(&if_stage);
}
break;
default:
printf("f**k.\n");
exit(1);
}
}
printf("+ Simulation terminates at cycle : %u\n", cycle_number);
trace_uninit();
exit(0);
}