1
0
mirror of https://github.com/hashcat/hashcat.git synced 2024-10-31 20:48:57 +00:00
hashcat/src/thread.c

285 lines
6.3 KiB
C
Raw Permalink Normal View History

2016-09-11 09:42:19 +00:00
/**
* Author......: See docs/credits.txt
2016-09-11 09:42:19 +00:00
* License.....: MIT
*/
#include "common.h"
2016-09-12 10:59:40 +00:00
#include "types.h"
#include "event.h"
2016-09-30 10:46:33 +00:00
#include "timer.h"
#include "thread.h"
2016-09-12 10:59:40 +00:00
/*
2016-09-12 10:59:40 +00:00
#if defined (_WIN)
BOOL WINAPI sigHandler_default (DWORD sig)
{
switch (sig)
{
case CTRL_CLOSE_EVENT:
*
2016-09-12 10:59:40 +00:00
* special case see: https://stackoverflow.com/questions/3640633/c-setconsolectrlhandler-routine-issue/5610042#5610042
* if the user interacts w/ the user-interface (GUI/cmd), we need to do the finalization job within this signal handler
* function otherwise it is too late (e.g. after returning from this function)
*
2016-09-12 10:59:40 +00:00
myabort (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
SetConsoleCtrlHandler (NULL, TRUE);
sleep (10);
2016-09-12 10:59:40 +00:00
return TRUE;
case CTRL_C_EVENT:
case CTRL_LOGOFF_EVENT:
case CTRL_SHUTDOWN_EVENT:
myabort (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
SetConsoleCtrlHandler (NULL, TRUE);
return TRUE;
}
return FALSE;
}
BOOL WINAPI sigHandler_benchmark (DWORD sig)
{
switch (sig)
{
case CTRL_CLOSE_EVENT:
myquit (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
SetConsoleCtrlHandler (NULL, TRUE);
sleep (10);
2016-09-12 10:59:40 +00:00
return TRUE;
case CTRL_C_EVENT:
case CTRL_LOGOFF_EVENT:
case CTRL_SHUTDOWN_EVENT:
myquit (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
SetConsoleCtrlHandler (NULL, TRUE);
return TRUE;
}
return FALSE;
}
void hc_signal (BOOL WINAPI (callback) (DWORD))
{
if (callback == NULL)
{
SetConsoleCtrlHandler ((PHANDLER_ROUTINE) callback, FALSE);
}
else
{
SetConsoleCtrlHandler ((PHANDLER_ROUTINE) callback, TRUE);
}
}
#else
void sigHandler_default (int sig)
{
myabort (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
signal (sig, NULL);
}
void sigHandler_benchmark (int sig)
{
myquit (hashcat_ctx->status_ctx);
2016-09-12 10:59:40 +00:00
signal (sig, NULL);
}
void hc_signal (void (callback) (int))
{
if (callback == NULL) callback = SIG_DFL;
signal (SIGINT, callback);
signal (SIGTERM, callback);
signal (SIGABRT, callback);
}
#endif
*/
2016-09-12 10:59:40 +00:00
2016-10-16 17:32:43 +00:00
int mycracked (hashcat_ctx_t *hashcat_ctx)
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_CRACKED;
status_ctx->run_main_level1 = false;
2016-09-29 21:25:29 +00:00
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
2016-10-16 17:32:43 +00:00
return 0;
}
int myabort_checkpoint (hashcat_ctx_t *hashcat_ctx)
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
status_ctx->devices_status = STATUS_ABORTED_CHECKPOINT;
status_ctx->run_main_level1 = false;
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
return 0;
}
int myabort_runtime (hashcat_ctx_t *hashcat_ctx)
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
status_ctx->devices_status = STATUS_ABORTED_RUNTIME;
status_ctx->run_main_level1 = false;
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
return 0;
}
2016-10-16 17:32:43 +00:00
int myabort (hashcat_ctx_t *hashcat_ctx)
2016-09-12 10:59:40 +00:00
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-09-30 11:40:43 +00:00
//those checks create problems in benchmark mode, it's simply too short of a timeframe where it's running as STATUS_RUNNING
2016-10-16 17:32:43 +00:00
// not sure if this is still valid, but abort is also called by gpu temp monitor
2016-09-30 11:40:43 +00:00
//if (status_ctx->devices_status != STATUS_RUNNING) return;
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_ABORTED;
status_ctx->run_main_level1 = false;
2016-09-29 21:25:29 +00:00
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
2016-10-16 17:32:43 +00:00
return 0;
2016-09-12 10:59:40 +00:00
}
2016-10-16 17:32:43 +00:00
int myquit (hashcat_ctx_t *hashcat_ctx)
2016-09-12 10:59:40 +00:00
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-10-30 15:05:00 +00:00
if (status_ctx->devices_status != STATUS_RUNNING && status_ctx->devices_status != STATUS_PAUSED) return -1;
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_QUIT;
status_ctx->run_main_level1 = false;
2016-09-29 21:25:29 +00:00
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
2016-10-16 17:32:43 +00:00
return 0;
}
2016-10-16 17:32:43 +00:00
int bypass (hashcat_ctx_t *hashcat_ctx)
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-10-16 17:32:43 +00:00
if (status_ctx->devices_status != STATUS_RUNNING) return -1;
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_BYPASS;
status_ctx->run_main_level1 = true;
2016-09-29 21:25:29 +00:00
status_ctx->run_main_level2 = true;
status_ctx->run_main_level3 = true;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = false;
2016-10-16 17:32:43 +00:00
return 0;
2016-09-12 10:59:40 +00:00
}
2016-09-14 18:22:38 +00:00
2016-10-16 17:32:43 +00:00
int SuspendThreads (hashcat_ctx_t *hashcat_ctx)
2016-09-14 18:22:38 +00:00
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-10-16 17:32:43 +00:00
if (status_ctx->devices_status != STATUS_RUNNING) return -1;
2016-09-14 18:22:38 +00:00
2016-09-29 21:49:33 +00:00
hc_timer_set (&status_ctx->timer_paused);
2016-09-14 18:22:38 +00:00
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_PAUSED;
2016-10-16 17:32:43 +00:00
return 0;
2016-09-14 18:22:38 +00:00
}
2016-10-16 17:32:43 +00:00
int ResumeThreads (hashcat_ctx_t *hashcat_ctx)
2016-09-14 18:22:38 +00:00
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
2016-10-16 17:32:43 +00:00
if (status_ctx->devices_status != STATUS_PAUSED) return -1;
2016-09-14 18:22:38 +00:00
const double msec_paused = hc_timer_get (status_ctx->timer_paused);
2016-09-14 18:22:38 +00:00
status_ctx->msec_paused += msec_paused;
2016-09-14 18:22:38 +00:00
2016-09-29 21:25:29 +00:00
status_ctx->devices_status = STATUS_RUNNING;
2016-10-16 17:32:43 +00:00
return 0;
}
int stop_at_checkpoint (hashcat_ctx_t *hashcat_ctx)
{
status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
if (status_ctx->devices_status != STATUS_RUNNING) return -1;
// this feature only makes sense if --restore-disable was not specified
restore_ctx_t *restore_ctx = hashcat_ctx->restore_ctx;
if (restore_ctx->enabled == false)
{
2017-04-02 07:50:06 +00:00
event_log_warning (hashcat_ctx, "This feature is disabled when --restore-disable is specified.");
2016-10-16 17:32:43 +00:00
return -1;
}
// Enable or Disable
2016-10-23 11:38:41 +00:00
if (status_ctx->checkpoint_shutdown == false)
2016-10-16 17:32:43 +00:00
{
2016-10-23 11:38:41 +00:00
status_ctx->checkpoint_shutdown = true;
2016-10-16 17:32:43 +00:00
status_ctx->run_main_level1 = false;
status_ctx->run_main_level2 = false;
status_ctx->run_main_level3 = false;
status_ctx->run_thread_level1 = false;
status_ctx->run_thread_level2 = true;
}
else
{
2016-10-23 11:38:41 +00:00
status_ctx->checkpoint_shutdown = false;
2016-10-16 17:32:43 +00:00
status_ctx->run_main_level1 = true;
status_ctx->run_main_level2 = true;
status_ctx->run_main_level3 = true;
status_ctx->run_thread_level1 = true;
status_ctx->run_thread_level2 = true;
}
return 0;
2016-09-14 18:22:38 +00:00
}