static void init(struct fmt_main *self)
{
#ifdef SIMD_COEF_64
int i;
#endif
#ifdef _OPENMP
int omp_t = omp_get_max_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
#ifdef SIMD_COEF_64
bufsize = sizeof(ARCH_WORD_64) * self->params.max_keys_per_crypt * SHA_BUF_SIZ;
crypt_key = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
ipad = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
opad = mem_calloc_tiny(bufsize, MEM_ALIGN_SIMD);
prep_ipad = mem_calloc_tiny(self->params.max_keys_per_crypt * BINARY_SIZE_512, MEM_ALIGN_SIMD);
prep_opad = mem_calloc_tiny(self->params.max_keys_per_crypt * BINARY_SIZE_512, MEM_ALIGN_SIMD);
for (i = 0; i < self->params.max_keys_per_crypt; ++i) {
crypt_key[GETPOS(BINARY_SIZE, i)] = 0x80;
((ARCH_WORD_64*)crypt_key)[15 * SIMD_COEF_64 + (i & (SIMD_COEF_64-1)) + (i/SIMD_COEF_64) * SHA_BUF_SIZ * SIMD_COEF_64] = (BINARY_SIZE + PAD_SIZE) << 3;
}
clear_keys();
#else
crypt_key = mem_calloc_tiny(sizeof(*crypt_key) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
ipad = mem_calloc_tiny(sizeof(*ipad) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
opad = mem_calloc_tiny(sizeof(*opad) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
ipad_ctx = mem_calloc_tiny(sizeof(*ipad_ctx) * self->params.max_keys_per_crypt, 8);
opad_ctx = mem_calloc_tiny(sizeof(*opad_ctx) * self->params.max_keys_per_crypt, 8);
#endif
saved_plain = mem_calloc_tiny(sizeof(*saved_plain) * self->params.max_keys_per_crypt, MEM_ALIGN_WORD);
}
/*
* Normal exiting
*/
void clean_up_exit (int ret) {
static int depth = 0;
exit_flag = 1;
if (depth++ > 2) {
exit(ret);
}
if (icon_mode) {
clean_icon_mode();
}
/* remove the shm areas: */
clean_shm(0);
stop_stunnel();
if (use_openssl) {
ssl_helper_pid(0, 0); /* killall */
}
if (! dpy) exit(ret); /* raw_rb hack */
/* X keyboard cleanups */
delete_added_keycodes(0);
if (clear_mods == 1) {
clear_modifiers(0);
} else if (clear_mods == 2) {
clear_keys();
}
if (no_autorepeat) {
autorepeat(1, 0);
}
if (use_solid_bg) {
solid_bg(1);
}
X_LOCK;
XTestDiscard_wr(dpy);
#if LIBVNCSERVER_HAVE_LIBXDAMAGE
if (xdamage) {
XDamageDestroy(dpy, xdamage);
}
#endif
#if LIBVNCSERVER_HAVE_LIBXTRAP
if (trap_ctx) {
XEFreeTC(trap_ctx);
}
#endif
/* XXX rdpy_ctrl, etc. cannot close w/o blocking */
XCloseDisplay_wr(dpy);
X_UNLOCK;
fflush(stderr);
exit(ret);
}
int main() {
init();
//blink(1);
while(1) {
//DEBUG("\r\n");
clear_keys();
//debounce(DEBOUNCE_PASSES);
scan_keys();
cool_down_inactive_layers();
pre_invoke_functions();
calculate_presses();
//b();
//clear_screen();
//debug_state();
//debug_layers();
usb_keyboard_send();
};
};
static void init(struct fmt_main *self)
{
#ifdef SIMD_COEF_32
int i;
#endif
#ifdef _OPENMP
int omp_t = omp_get_num_threads();
self->params.min_keys_per_crypt *= omp_t;
omp_t *= OMP_SCALE;
self->params.max_keys_per_crypt *= omp_t;
#endif
#ifdef SIMD_COEF_32
bufsize = sizeof(*opad) * self->params.max_keys_per_crypt * SHA_BUF_SIZ * 4;
crypt_key = mem_calloc_align(1, bufsize, MEM_ALIGN_SIMD);
ipad = mem_calloc_align(1, bufsize, MEM_ALIGN_SIMD);
opad = mem_calloc_align(1, bufsize, MEM_ALIGN_SIMD);
prep_ipad = mem_calloc_align(self->params.max_keys_per_crypt *
BINARY_SIZE,
sizeof(*prep_ipad), MEM_ALIGN_SIMD);
prep_opad = mem_calloc_align(self->params.max_keys_per_crypt *
BINARY_SIZE,
sizeof(*prep_opad), MEM_ALIGN_SIMD);
for (i = 0; i < self->params.max_keys_per_crypt; ++i) {
crypt_key[GETPOS(BINARY_SIZE, i)] = 0x80;
((unsigned int*)crypt_key)[15 * SIMD_COEF_32 + (i&(SIMD_COEF_32-1)) + i/SIMD_COEF_32 * SHA_BUF_SIZ * SIMD_COEF_32] = (BINARY_SIZE + 64) << 3;
}
clear_keys();
#else
crypt_key = mem_calloc(self->params.max_keys_per_crypt,
sizeof(*crypt_key));
ipad = mem_calloc(self->params.max_keys_per_crypt, sizeof(*ipad));
opad = mem_calloc(self->params.max_keys_per_crypt, sizeof(*opad));
ipad_ctx = mem_calloc(self->params.max_keys_per_crypt,
sizeof(*ipad_ctx));
opad_ctx = mem_calloc(self->params.max_keys_per_crypt,
sizeof(*opad_ctx));
#endif
saved_plain = mem_calloc(self->params.max_keys_per_crypt,
sizeof(*saved_plain));
}
void UART0_Handler (void){
uint32_t ul_status;
ul_status = uart_get_status(UART0);
if (ul_status & UART_SR_RXRDY){
uart_read(UART0, &uc_char);
if (cont_char == 0){
clear_keys();
}
//Fim do comando, character "Enter"
if (uc_char == 13){
cont_char = 0;
uc_flag = 1;
}
//Implementando Backspace:
else if ( uc_char == 8 ){
keys[--cont_char] = 0;
}
else {
keys[cont_char++] = uc_char;
}
}
}
int main(int argc, char **argv)
{
bool raw_mode = false;
const char *loopback = NULL;
while(1)
{
static struct option long_options[] =
{
{"help", no_argument, 0, '?'},
{"debug", no_argument, 0, 'd'},
{"add-key", required_argument, 0, 'a'},
{"no-color", no_argument, 0, 'n'},
{"loopback", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "?do:k:zra:nl:", long_options, NULL);
if(c == -1)
break;
switch(c)
{
case -1:
break;
case 'l':
if(loopback)
bug("Only one loopback file can be specified !\n");
loopback = optarg;
break;
case 'n':
enable_color(false);
break;
case 'd':
g_debug = true;
break;
case '?':
usage();
break;
case 'o':
g_out_prefix = optarg;
break;
case 'k':
{
add_keys_from_file(optarg);
break;
}
case 'z':
{
add_keys(&g_zero_key, 1);
break;
}
case 'r':
raw_mode = true;
break;
case 'a':
{
struct crypto_key_t key;
char *s = optarg;
if(!parse_key(&s, &key))
bug("Invalid key specified as argument");
if(*s != 0)
bug("Trailing characters after key specified as argument");
add_keys(&key, 1);
break;
}
default:
abort();
}
}
if(argc - optind != 1)
{
usage();
return 1;
}
const char *sb_filename = argv[optind];
enum sb_error_t err;
struct sb_file_t *file = sb_read_file(sb_filename, raw_mode, NULL, sb_printf, &err);
if(file == NULL)
{
color(OFF);
printf("SB read failed: %d\n", err);
return 1;
}
color(OFF);
if(g_out_prefix)
extract_sb_file(file);
if(g_debug)
{
color(GREY);
printf("[Debug output]\n");
sb_dump(file, NULL, sb_printf);
}
if(loopback)
{
/* sb_read_file will fill real key and IV but we don't want to override
* them when looping back otherwise the output will be inconsistent and
* garbage */
file->override_real_key = false;
file->override_crypto_iv = false;
sb_write_file(file, loopback);
}
sb_free(file);
clear_keys();
return 0;
}
int main(int argc, char **argv)
{
char *cmd_filename = NULL;
char *output_filename = NULL;
struct crypto_key_t real_key;
struct crypto_key_t crypto_iv;
real_key.method = CRYPTO_NONE;
crypto_iv.method = CRYPTO_NONE;
while(1)
{
static struct option long_options[] =
{
{"help", no_argument, 0, '?'},
{"debug", no_argument, 0, 'd'},
{"add-key", required_argument, 0, 'a'},
{"real-key", required_argument, 0, 'r'},
{"crypto-iv", required_argument, 0, 'i'},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "?do:c:k:za:", long_options, NULL);
if(c == -1)
break;
switch(c)
{
case 'd':
g_debug = true;
break;
case '?':
usage();
break;
case 'o':
output_filename = optarg;
break;
case 'c':
cmd_filename = optarg;
break;
case 'k':
{
if(!add_keys_from_file(optarg))
bug("Cannot keys from %s\n", optarg);
break;
}
case 'z':
{
add_keys(&g_zero_key, 1);
break;
}
case 'a':
case 'r':
case 'i':
{
struct crypto_key_t key;
char *s = optarg;
if(!parse_key(&s, &key))
bug("Invalid key/iv specified as argument");
if(*s != 0)
bug("Trailing characters after key/iv specified as argument");
if(c == 'r')
memcpy(&real_key, &key, sizeof(key));
else if(c == 'i')
memcpy(&crypto_iv, &key, sizeof(key));
else
add_keys(&key, 1);
break;
}
default:
abort();
}
}
if(!cmd_filename)
bug("You must specify a command file\n");
if(!output_filename)
bug("You must specify an output file\n");
g_extern = &argv[optind];
g_extern_count = argc - optind;
if(g_debug)
{
printf("key: %d\n", g_nr_keys);
for(int i = 0; i < g_nr_keys; i++)
{
printf(" ");
print_key(&g_key_array[i], true);
}
for(int i = 0; i < g_extern_count; i++)
printf("extern(%d)=%s\n", i, g_extern[i]);
}
struct cmd_file_t *cmd_file = db_parse_file(cmd_filename);
struct sb_file_t *sb_file = apply_cmd_file(cmd_file);
db_free(cmd_file);
if(real_key.method == CRYPTO_KEY)
{
sb_file->override_real_key = true;
memcpy(sb_file->real_key, real_key.u.key, 16);
}
if(crypto_iv.method == CRYPTO_KEY)
{
sb_file->override_crypto_iv = true;
memcpy(sb_file->crypto_iv, crypto_iv.u.key, 16);
}
/* fill with default parameters since there is no command file support for them */
sb_file->drive_tag = 0;
sb_file->first_boot_sec_id = sb_file->sections[0].identifier;
sb_file->flags = 0;
sb_file->minor_version = 1;
sb_write_file(sb_file, output_filename);
sb_free(sb_file);
clear_keys();
return 0;
}
/*
* General problem handler
*/
static void interrupted (int sig) {
exit_sig = sig;
if (exit_flag) {
fprintf(stderr, "extra[%d] signal: %d\n", exit_flag, sig);
exit_flag++;
if (use_threads) {
usleep2(250 * 1000);
} else if (exit_flag <= 2) {
return;
}
if (rm_flagfile) {
unlink(rm_flagfile);
rm_flagfile = NULL;
}
exit(4);
}
exit_flag++;
if (sig == 0) {
fprintf(stderr, "caught X11 error:\n");
if (crash_debug) { crash_shell(); }
} else if (sig == -1) {
fprintf(stderr, "caught XIO error:\n");
} else {
fprintf(stderr, "caught signal: %d\n", sig);
}
if (sig == SIGINT) {
shut_down = 1;
return;
}
if (crash_debug) {
crash_shell();
}
X_UNLOCK;
if (icon_mode) {
clean_icon_mode();
}
/* remove the shm areas with quick=1: */
clean_shm(1);
if (sig == -1) {
/* not worth trying any more cleanup, X server probably gone */
if (rm_flagfile) {
unlink(rm_flagfile);
rm_flagfile = NULL;
}
exit(3);
}
/* X keyboard cleanups */
delete_added_keycodes(0);
if (clear_mods == 1) {
clear_modifiers(0);
} else if (clear_mods == 2) {
clear_keys();
} else if (clear_mods == 3) {
clear_keys();
clear_locks();
}
if (no_autorepeat) {
autorepeat(1, 0);
}
if (use_solid_bg) {
solid_bg(1);
}
if (ncache || ncache0) {
kde_no_animate(1);
}
stop_stunnel();
if (crash_debug) {
crash_shell();
}
if (sig) {
if (rm_flagfile) {
unlink(rm_flagfile);
rm_flagfile = NULL;
}
exit(2);
}
}
/*
* Normal exiting
*/
void clean_up_exit(int ret) {
static int depth = 0;
exit_flag = 1;
if (depth++ > 2) {
exit(ret);
}
if (icon_mode) {
clean_icon_mode();
}
/* remove the shm areas: */
clean_shm(0);
stop_stunnel();
if (use_openssl) {
ssl_helper_pid(0, 0); /* killall */
}
if (ssh_pid > 0) {
kill(ssh_pid, SIGTERM);
ssh_pid = 0;
}
#ifdef MACOSX
if (client_connect_file) {
if (strstr(client_connect_file, "/tmp/x11vnc-macosx-remote")
== client_connect_file) {
unlink(client_connect_file);
}
}
if (macosx_console) {
macosxCG_fini();
}
#endif
if (pipeinput_fh != NULL) {
pclose(pipeinput_fh);
pipeinput_fh = NULL;
}
shutdown_uinput();
if (unix_sock) {
if (unix_sock_fd >= 0) {
rfbLog("deleting unix sock: %s\n", unix_sock);
close(unix_sock_fd);
unix_sock_fd = -1;
unlink(unix_sock);
}
}
if (! dpy) { /* raw_rb hack */
if (rm_flagfile) {
unlink(rm_flagfile);
rm_flagfile = NULL;
}
exit(ret);
}
/* X keyboard cleanups */
delete_added_keycodes(0);
if (clear_mods == 1) {
clear_modifiers(0);
} else if (clear_mods == 2) {
clear_keys();
} else if (clear_mods == 3) {
clear_keys();
clear_locks();
}
if (no_autorepeat) {
autorepeat(1, 0);
}
if (use_solid_bg) {
solid_bg(1);
}
if (ncache || ncache0) {
kde_no_animate(1);
}
X_LOCK;
XTestDiscard_wr(dpy);
#if LIBVNCSERVER_HAVE_LIBXDAMAGE
if (xdamage) {
XDamageDestroy(dpy, xdamage);
}
#endif
#if LIBVNCSERVER_HAVE_LIBXTRAP
if (trap_ctx) {
XEFreeTC(trap_ctx);
}
#endif
/* XXX rdpy_ctrl, etc. cannot close w/o blocking */
XCloseDisplay_wr(dpy);
X_UNLOCK;
fflush(stderr);
if (rm_flagfile) {
unlink(rm_flagfile);
rm_flagfile = NULL;
}
if (avahi) {
avahi_cleanup();
fflush(stderr);
}
exit(ret);
}
int main(int argc, char **argv)
{
bool raw_mode = false;
const char *loopback = NULL;
bool force_sb1 = false;
bool force_sb2 = false;
bool brute_force = false;
while(1)
{
static struct option long_options[] =
{
{"help", no_argument, 0, '?'},
{"debug", no_argument, 0, 'd'},
{"add-key", required_argument, 0, 'a'},
{"no-color", no_argument, 0, 'n'},
{"loopback", required_argument, 0, 'l'},
{"force", no_argument, 0, 'f'},
{"v1", no_argument, 0, '1'},
{"v2", no_argument, 0, '2'},
{"no-simpl", no_argument, 0, 's'},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "?do:k:zra:nl:f12xsb", long_options, NULL);
if(c == -1)
break;
switch(c)
{
case -1:
break;
case 'l':
if(loopback)
bug("Only one loopback file can be specified !\n");
loopback = optarg;
break;
case 'n':
enable_color(false);
break;
case 'd':
g_debug = true;
break;
case '?':
usage();
break;
case 'o':
g_out_prefix = optarg;
break;
case 'f':
g_force = true;
break;
case 'k':
{
if(!add_keys_from_file(optarg))
bug("Cannot add keys from %s\n", optarg);
break;
}
case 'z':
{
struct crypto_key_t g_zero_key;
sb_get_zero_key(&g_zero_key);
add_keys(&g_zero_key, 1);
break;
}
case 'x':
{
struct crypto_key_t key;
sb1_get_default_key(&key);
add_keys(&key, 1);
break;
}
case 'r':
raw_mode = true;
break;
case 'a':
{
struct crypto_key_t key;
char *s = optarg;
if(!parse_key(&s, &key))
bug("Invalid key specified as argument\n");
if(*s != 0)
bug("Trailing characters after key specified as argument\n");
add_keys(&key, 1);
break;
}
case '1':
force_sb1 = true;
break;
case '2':
force_sb2 = true;
break;
case 's':
g_elf_simplify = false;
break;
case 'b':
brute_force = true;
break;
default:
bug("Internal error: unknown option '%c'\n", c);
}
}
if(force_sb1 && force_sb2)
bug("You cannot force both version 1 and 2\n");
if(argc - optind != 1)
{
usage();
return 1;
}
const char *sb_filename = argv[optind];
enum sb_version_guess_t ver = guess_sb_version(sb_filename);
if(ver == SB_VERSION_ERR)
{
printf("Cannot open/read SB file: %m\n");
return 1;
}
if(force_sb2 || ver == SB_VERSION_2)
{
enum sb_error_t err;
struct sb_file_t *file = sb_read_file(sb_filename, raw_mode, NULL, generic_std_printf, &err);
if(file == NULL)
{
color(OFF);
printf("SB read failed: %d\n", err);
return 1;
}
color(OFF);
if(g_out_prefix)
extract_sb_file(file);
if(g_debug)
{
color(GREY);
printf("[Debug output]\n");
sb_dump(file, NULL, generic_std_printf);
}
if(loopback)
{
/* sb_read_file will fill real key and IV but we don't want to override
* them when looping back otherwise the output will be inconsistent and
* garbage */
file->override_real_key = false;
file->override_crypto_iv = false;
sb_write_file(file, loopback, 0, generic_std_printf);
}
sb_free(file);
}
else if(force_sb1 || ver == SB_VERSION_1)
{
if(brute_force)
{
struct crypto_key_t key;
enum sb1_error_t err;
if(!sb1_brute_force(sb_filename, NULL, generic_std_printf, &err, &key))
{
color(OFF);
printf("Brute force failed: %d\n", err);
return 1;
}
color(RED);
printf("Key found:");
color(YELLOW);
for(int i = 0; i < 32; i++)
printf(" %08x", key.u.xor_key[i / 16].k[i % 16]);
color(OFF);
printf("\n");
color(RED);
printf("Key: ");
color(YELLOW);
for(int i = 0; i < 128; i++)
printf("%02x", key.u.xor_key[i / 64].key[i % 64]);
color(OFF);
printf("\n");
add_keys(&key, 1);
}
enum sb1_error_t err;
struct sb1_file_t *file = sb1_read_file(sb_filename, NULL, generic_std_printf, &err);
if(file == NULL)
{
color(OFF);
printf("SB read failed: %d\n", err);
return 1;
}
color(OFF);
if(g_out_prefix)
extract_sb1_file(file);
if(g_debug)
{
color(GREY);
printf("[Debug output]\n");
sb1_dump(file, NULL, generic_std_printf);
}
if(loopback)
sb1_write_file(file, loopback);
sb1_free(file);
}
else
{
color(OFF);
printf("Cannot guess file type, are you sure it's a valid image ?\n");
return 1;
}
clear_keys();
return 0;
}
void run(double *accum, int *cur_loc, mem_array mem) {
int prg_counter = 0, // mem cell location of the command being executed
next_loc = 0, // mem cell location of the next command to be executed
run_flag = CONTINUE; // flag for when to stop the execution of the
// user's program. Values are CONTINUE, STOP
// and RUN_ERR
char cmdtrans[80]; // an English translation of the current command
enum speed run_speed; // the run mode
hidemouse();
// if they want to run
if(get_speed(&run_speed) == CONTINUE) {
// set up screen for running
put_accum(accum);
clear_monitor();
clear_keyboard();
clear_keys();
/* user's program loop */
do {
// execute at the next location
prg_counter = next_loc;
// THF patch, was +2
put_prg_counter(prg_counter + 1);
put_instruct(mem[prg_counter]);
bright_cell(prg_counter, mem[prg_counter]);
// case statement for run mode
switch(run_speed) {
case SLOW:
delay(SLOW_DELAY_TIME);
break;
case FAST:
delay(FAST_DELAY_TIME);
}
/// if there is a command in the cell
if(mem[prg_counter].entry_type == CMD) {
// command type case statement
switch(mem[prg_counter].cmd_type) {
case LDC:
run_flag = ldc(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case ADC:
run_flag = adc(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case LDA:
run_flag = lda(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case STA:
run_flag = sta(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case ADD:
run_flag = add(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case SUB:
run_flag = sub(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case MUL:
run_flag = mul(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case DIV:
run_flag = div(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case INP:
run_flag = inp(mem, cmdtrans, prg_counter, &next_loc);
break;
case OUT:
run_flag = out(mem, cmdtrans, prg_counter, &next_loc);
break;
case BPA:
run_flag = bpa(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case BNA:
run_flag = bna(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case BZA:
run_flag = bza(accum, mem, cmdtrans, prg_counter, &next_loc);
break;
case BRU:
run_flag = bru(mem, cmdtrans, prg_counter, &next_loc);
break;
case STP:
run_flag = stp(cmdtrans, prg_counter, &next_loc);
if(run_speed == CYCLE) {
display_cmdtrans(cmdtrans);
}
break;
default:
run_err_message("ERROR: Unkown command at this location.");
run_flag = RUN_ERR;
break;
}
} else {
run_err_message("ERROR: Unkown command at this location.");
run_flag = RUN_ERR;
}
// check to see if the user wants to stop
if(kbhit()) {
if(getch() == EscKey) {
run_flag = STOP;
}
}
if((run_speed == CYCLE) && (run_flag == CONTINUE)) {
run_flag = display_cmdtrans(cmdtrans);
}
dim_cell(prg_counter, mem[prg_counter]);
} while((run_flag == CONTINUE) && (mem[prg_counter].cmd_type != STP));
// clear the registers when program is done
clear_instruct();
clear_prg_counter();
}
showmouse();
if(run_flag == RUN_ERR) {
*cur_loc = prg_counter;
}
display_keys();
}
int main(int argc, char **argv)
{
char *cmd_filename = NULL;
char *output_filename = NULL;
struct crypto_key_t real_key;
struct crypto_key_t crypto_iv;
memset(&real_key, 0, sizeof(real_key));
memset(&crypto_iv, 0, sizeof(crypto_iv));
real_key.method = CRYPTO_NONE;
crypto_iv.method = CRYPTO_NONE;
if(argc == 1)
usage();
while(1)
{
static struct option long_options[] =
{
{"help", no_argument, 0, 'h'},
{"debug", no_argument, 0, 'd'},
{"add-key", required_argument, 0, 'a'},
{"real-key", required_argument, 0, 'r'},
{"crypto-iv", required_argument, 0, 'i'},
{0, 0, 0, 0}
};
int c = getopt_long(argc, argv, "hdo:c:k:za:", long_options, NULL);
if(c == -1)
break;
switch(c)
{
case 'd':
g_debug = true;
break;
case 'h':
usage();
break;
case 'o':
output_filename = optarg;
break;
case 'c':
cmd_filename = optarg;
break;
case 'k':
{
if(!add_keys_from_file(optarg))
bug("Cannot keys from %s\n", optarg);
break;
}
case 'z':
{
struct crypto_key_t g_zero_key;
sb_get_zero_key(&g_zero_key);
add_keys(&g_zero_key, 1);
break;
}
case 'a':
case 'r':
case 'i':
{
struct crypto_key_t key;
char *s = optarg;
if(!parse_key(&s, &key))
bug("Invalid key/iv specified as argument");
if(*s != 0)
bug("Trailing characters after key/iv specified as argument");
if(c == 'r')
memcpy(&real_key, &key, sizeof(key));
else if(c == 'i')
memcpy(&crypto_iv, &key, sizeof(key));
else
add_keys(&key, 1);
break;
}
default:
bug("Internal error: unknown option '%c'\n", c);
}
}
if(!cmd_filename)
bug("You must specify a command file\n");
if(!output_filename)
bug("You must specify an output file\n");
g_extern = &argv[optind];
g_extern_count = argc - optind;
if(g_debug)
{
printf("key: %d\n", g_nr_keys);
for(int i = 0; i < g_nr_keys; i++)
{
printf(" ");
print_key(NULL, misc_std_printf, &g_key_array[i], true);
}
for(int i = 0; i < g_extern_count; i++)
printf("extern(%d)=%s\n", i, g_extern[i]);
}
struct cmd_file_t *cmd_file = db_parse_file(cmd_filename);
if(cmd_file == NULL)
bug("Error parsing command file\n");
struct sb_file_t *sb_file = apply_cmd_file(cmd_file);
db_free(cmd_file);
if(real_key.method == CRYPTO_KEY)
{
sb_file->override_real_key = true;
memcpy(sb_file->real_key, real_key.u.key, 16);
}
if(crypto_iv.method == CRYPTO_KEY)
{
sb_file->override_crypto_iv = true;
memcpy(sb_file->crypto_iv, crypto_iv.u.key, 16);
}
sb_write_file(sb_file, output_filename, 0, generic_std_printf);
sb_free(sb_file);
clear_keys();
return 0;
}
TEARDOWN()
{
clear_keys();
}
Encryptor::~Encryptor()
{
clear_keys();
}
void Encryptor::set_dictionary(std::string new_dictionary)
{
clear_keys();
_V_dictionary=new_dictionary;
}