* License.....: MIT
*/
-#ifdef OSX
+#ifdef __APPLE__
#include <stdio.h>
#endif
+#ifdef __FreeBSD__
+#include <stdio.h>
+#include <pthread_np.h>
+#endif
+
#include <shared.h>
#include <limits.h>
* tty
*/
-#ifdef LINUX
-static struct termio savemodes;
+#ifdef __linux__
+static struct termios savemodes;
static int havemodes = 0;
int tty_break()
{
- struct termio modmodes;
+ struct termios modmodes;
- if (ioctl (fileno (stdin), TCGETA, &savemodes) < 0) return -1;
+ if (tcgetattr (fileno (stdin), &savemodes) < 0) return -1;
havemodes = 1;
modmodes.c_cc[VMIN] = 1;
modmodes.c_cc[VTIME] = 0;
- return ioctl (fileno (stdin), TCSETAW, &modmodes);
+ return tcsetattr (fileno (stdin), TCSANOW, &modmodes);
}
int tty_getchar()
{
if (!havemodes) return 0;
- return ioctl (fileno (stdin), TCSETAW, &savemodes);
+ return tcsetattr (fileno (stdin), TCSADRAIN, &savemodes);
}
#endif
-#ifdef OSX
+#if defined(__APPLE__) || defined(__FreeBSD__)
static struct termios savemodes;
static int havemodes = 0;
{
NvU32 pGpuCount;
- if (hm_NvAPI_EnumPhysicalGPUs (data.hm_nvapi, nvapiGPUHandle, &pGpuCount) != NVAPI_OK) return (0);
+ if (hm_NvAPI_EnumPhysicalGPUs (data.hm_nvapi, nvapiGPUHandle, &pGpuCount) != NVAPI_OK) return 0;
if (pGpuCount == 0)
{
log_info ("WARN: No NvAPI adapters found");
- return (0);
+ return 0;
}
return (pGpuCount);
{
log_info ("WARN: No NVML adapters found");
- return (0);
+ return 0;
}
return (pGpuCount);
if (hm_NVML_nvmlDeviceGetCurrentClocksThrottleReasons (data.hm_nvml, 1, data.hm_device[device_id].nvml, &clocksThrottleReasons) != NVML_SUCCESS) return -1;
if (hm_NVML_nvmlDeviceGetSupportedClocksThrottleReasons (data.hm_nvml, 1, data.hm_device[device_id].nvml, &supportedThrottleReasons) != NVML_SUCCESS) return -1;
- clocksThrottleReasons &= supportedThrottleReasons;
-
+ clocksThrottleReasons &= supportedThrottleReasons;
+ clocksThrottleReasons &= ~nvmlClocksThrottleReasonGpuIdle;
+ clocksThrottleReasons &= ~nvmlClocksThrottleReasonApplicationsClocksSetting;
clocksThrottleReasons &= ~nvmlClocksThrottleReasonUnknown;
- return (clocksThrottleReasons > 0);
+ if (data.kernel_power_final)
+ {
+ clocksThrottleReasons &= ~nvmlClocksThrottleReasonHwSlowdown;
+ }
+
+ return (clocksThrottleReasons != nvmlClocksThrottleReasonNone);
}
return -1;
{
if (data.hm_adl)
{
- if (data.hm_device[device_id].od_version == 5)
+ if (fanpolicy == 1)
{
- ADLFanSpeedValue lpFanSpeedValue;
+ if (data.hm_device[device_id].od_version == 5)
+ {
+ ADLFanSpeedValue lpFanSpeedValue;
- memset (&lpFanSpeedValue, 0, sizeof (lpFanSpeedValue));
+ memset (&lpFanSpeedValue, 0, sizeof (lpFanSpeedValue));
- lpFanSpeedValue.iSize = sizeof (lpFanSpeedValue);
- lpFanSpeedValue.iSpeedType = ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
- lpFanSpeedValue.iFlags = (fanpolicy == 1) ? ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED : 0;
- lpFanSpeedValue.iFanSpeed = fanspeed;
+ lpFanSpeedValue.iSize = sizeof (lpFanSpeedValue);
+ lpFanSpeedValue.iSpeedType = ADL_DL_FANCTRL_SPEED_TYPE_PERCENT;
+ lpFanSpeedValue.iFlags = ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED;
+ lpFanSpeedValue.iFanSpeed = fanspeed;
- if (hm_ADL_Overdrive5_FanSpeed_Set (data.hm_adl, data.hm_device[device_id].adl, 0, &lpFanSpeedValue) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive5_FanSpeed_Set (data.hm_adl, data.hm_device[device_id].adl, 0, &lpFanSpeedValue) != ADL_OK) return -1;
- return 0;
- }
- else // od_version == 6
- {
- ADLOD6FanSpeedValue fan_speed_value;
+ return 0;
+ }
+ else // od_version == 6
+ {
+ ADLOD6FanSpeedValue fan_speed_value;
- memset (&fan_speed_value, 0, sizeof (fan_speed_value));
+ memset (&fan_speed_value, 0, sizeof (fan_speed_value));
- fan_speed_value.iSpeedType = ADL_OD6_FANSPEED_TYPE_PERCENT;
- fan_speed_value.iFanSpeed = fanspeed;
+ fan_speed_value.iSpeedType = ADL_OD6_FANSPEED_TYPE_PERCENT;
+ fan_speed_value.iFanSpeed = fanspeed;
- if (hm_ADL_Overdrive6_FanSpeed_Set (data.hm_adl, data.hm_device[device_id].adl, &fan_speed_value) != ADL_OK) return -1;
+ if (hm_ADL_Overdrive6_FanSpeed_Set (data.hm_adl, data.hm_device[device_id].adl, &fan_speed_value) != ADL_OK) return -1;
- return 0;
+ return 0;
+ }
+ }
+ else
+ {
+ if (data.hm_device[device_id].od_version == 5)
+ {
+ if (hm_ADL_Overdrive5_FanSpeedToDefault_Set (data.hm_adl, data.hm_device[device_id].adl, 0) != ADL_OK) return -1;
+
+ return 0;
+ }
+ else // od_version == 6
+ {
+ if (hm_ADL_Overdrive6_FanSpeed_Reset (data.hm_adl, data.hm_device[device_id].adl) != ADL_OK) return -1;
+
+ return 0;
+ }
}
}
}
{
if (data.hm_nvapi)
{
- NV_GPU_COOLER_LEVELS CoolerLevels = { 0 };
+ if (fanpolicy == 1)
+ {
+ NV_GPU_COOLER_LEVELS CoolerLevels;
- CoolerLevels.Version = GPU_COOLER_LEVELS_VER | sizeof (NV_GPU_COOLER_LEVELS);
+ memset (&CoolerLevels, 0, sizeof (NV_GPU_COOLER_LEVELS));
- CoolerLevels.Levels[0].Level = fanspeed;
- CoolerLevels.Levels[0].Policy = fanpolicy;
+ CoolerLevels.Version = GPU_COOLER_LEVELS_VER | sizeof (NV_GPU_COOLER_LEVELS);
- if (hm_NvAPI_GPU_SetCoolerLevels (data.hm_nvapi, data.hm_device[device_id].nvapi, 0, &CoolerLevels) != NVAPI_OK) return -1;
+ CoolerLevels.Levels[0].Level = fanspeed;
+ CoolerLevels.Levels[0].Policy = 1;
- return 0;
+ if (hm_NvAPI_GPU_SetCoolerLevels (data.hm_nvapi, data.hm_device[device_id].nvapi, 0, &CoolerLevels) != NVAPI_OK) return -1;
+
+ return 0;
+ }
+ else
+ {
+ if (hm_NvAPI_GPU_RestoreCoolerSettings (data.hm_nvapi, data.hm_device[device_id].nvapi, 0) != NVAPI_OK) return -1;
+
+ return 0;
+ }
}
}
char *exec_path = (char *) mymalloc (exec_path_len);
- #ifdef LINUX
+ #ifdef __linux__
char tmp[32] = { 0 };
const int len = GetModuleFileName (NULL, exec_path, exec_path_len - 1);
- #elif OSX
+ #elif __APPLE__
uint size = exec_path_len;
const int len = strlen (exec_path);
+ #elif __FreeBSD__
+
+ #include <sys/sysctl.h>
+
+ int mib[4];
+ mib[0] = CTL_KERN;
+ mib[1] = KERN_PROC;
+ mib[2] = KERN_PROC_PATHNAME;
+ mib[3] = -1;
+
+ char tmp[32] = { 0 };
+
+ size_t size = exec_path_len;
+ sysctl(mib, 4, exec_path, &size, NULL, 0);
+
+ const int len = readlink (tmp, exec_path, exec_path_len - 1);
+
#else
#error Your Operating System is not supported or detected
#endif
myfree (buf);
}
-#ifdef OSX
+#ifdef __APPLE__
int pthread_setaffinity_np (pthread_t thread, size_t cpu_size, cpu_set_t *cpu_set)
{
int core;
{
#ifdef _WIN
DWORD_PTR aff_mask = 0;
+ #elif __FreeBSD__
+ cpuset_t cpuset;
+ CPU_ZERO (&cpuset);
#elif _POSIX
cpu_set_t cpuset;
CPU_ZERO (&cpuset);
}
#ifdef _WIN
- aff_mask |= 1 << (cpu_id - 1);
+ aff_mask |= 1u << (cpu_id - 1);
#elif _POSIX
CPU_SET ((cpu_id - 1), &cpuset);
#endif
#ifdef _WIN
SetProcessAffinityMask (GetCurrentProcess (), aff_mask);
SetThreadAffinityMask (GetCurrentThread (), aff_mask);
+ #elif __FreeBSD__
+ pthread_t thread = pthread_self ();
+ pthread_setaffinity_np (thread, sizeof (cpuset_t), &cpuset);
#elif _POSIX
pthread_t thread = pthread_self ();
pthread_setaffinity_np (thread, sizeof (cpu_set_t), &cpuset);
while (n--)
{
if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
- if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
+ if (s1->salt_buf[n] < s2->salt_buf[n]) return -1;
}
n = 8;
while (n--)
{
if (s1->salt_buf_pc[n] > s2->salt_buf_pc[n]) return ( 1);
- if (s1->salt_buf_pc[n] < s2->salt_buf_pc[n]) return (-1);
+ if (s1->salt_buf_pc[n] < s2->salt_buf_pc[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_salt_buf (const void *v1, const void *v2)
while (n--)
{
if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
- if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
+ if (s1->salt_buf[n] < s2->salt_buf[n]) return -1;
}
return 0;
while (n--)
{
if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
- if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
+ if (s1->salt_buf[n] < s2->salt_buf[n]) return -1;
}
/* original code, seems buggy since salt_len can be very big (had a case with 131 len)
also it thinks salt_buf[x] is a char but its a uint so salt_len should be / 4
if (s1->salt_len > s2->salt_len) return ( 1);
- if (s1->salt_len < s2->salt_len) return (-1);
+ if (s1->salt_len < s2->salt_len) return -1;
uint n = s1->salt_len;
while (n--)
{
if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
- if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
+ if (s1->salt_buf[n] < s2->salt_buf[n]) return -1;
}
*/
const salt_t *s1 = h1->salt;
const salt_t *s2 = h2->salt;
- // 16 - 2 (since last 2 uints contain the digest)
- uint n = 14;
+ // last 2: salt_buf[10] and salt_buf[11] contain the digest (skip them)
+
+ uint n = 9; // 9 * 4 = 36 bytes (max length of ESSID)
while (n--)
{
if (s1->salt_buf[n] > s2->salt_buf[n]) return ( 1);
- if (s1->salt_buf[n] < s2->salt_buf[n]) return (-1);
+ if (s1->salt_buf[n] < s2->salt_buf[n]) return -1;
}
return 0;
dictstat_t *d1 = (dictstat_t *) s1;
dictstat_t *d2 = (dictstat_t *) s2;
- #ifdef _LINUX
+ #ifdef __linux__
d2->stat.st_atim = d1->stat.st_atim;
#else
d2->stat.st_atime = d1->stat.st_atime;
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_4 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_5 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_6 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_8 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_16 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_32 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_4_64 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_8_8 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_8_16 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_8_25 (const void *v1, const void *v2)
while (n--)
{
if (d1[n] > d2[n]) return ( 1);
- if (d1[n] < d2[n]) return (-1);
+ if (d1[n] < d2[n]) return -1;
}
- return (0);
+ return 0;
}
int sort_by_digest_p0p1 (const void *v1, const void *v2)
const uint dgst_pos3 = data.dgst_pos3;
if (d1[dgst_pos3] > d2[dgst_pos3]) return ( 1);
- if (d1[dgst_pos3] < d2[dgst_pos3]) return (-1);
+ if (d1[dgst_pos3] < d2[dgst_pos3]) return -1;
if (d1[dgst_pos2] > d2[dgst_pos2]) return ( 1);
- if (d1[dgst_pos2] < d2[dgst_pos2]) return (-1);
+ if (d1[dgst_pos2] < d2[dgst_pos2]) return -1;
if (d1[dgst_pos1] > d2[dgst_pos1]) return ( 1);
- if (d1[dgst_pos1] < d2[dgst_pos1]) return (-1);
+ if (d1[dgst_pos1] < d2[dgst_pos1]) return -1;
if (d1[dgst_pos0] > d2[dgst_pos0]) return ( 1);
- if (d1[dgst_pos0] < d2[dgst_pos0]) return (-1);
+ if (d1[dgst_pos0] < d2[dgst_pos0]) return -1;
- return (0);
+ return 0;
}
int sort_by_tuning_db_alias (const void *v1, const void *v2)
#endif
}
- fputc ('\n', out_fp);
+ fputs (EOL, out_fp);
}
void handle_show_request (pot_t *pot, uint pot_cnt, char *input_buf, int input_len, hash_t *hashes_buf, int (*sort_by_pot) (const void *, const void *), FILE *out_fp)
exit (-1);
}
- opencl_platforms_filter |= 1 << (platform - 1);
+ opencl_platforms_filter |= 1u << (platform - 1);
} while ((next = strtok (NULL, ",")) != NULL);
exit (-1);
}
- devices_filter |= 1 << (device_id - 1);
+ devices_filter |= 1u << (device_id - 1);
} while ((next = strtok (NULL, ",")) != NULL);
exit (-1);
}
- device_types_filter |= 1 << device_type;
+ device_types_filter |= 1u << device_type;
} while ((next = strtok (NULL, ",")) != NULL);
if ((d = opendir (tmp_path)) != NULL)
{
- #ifdef OSX
+ #ifdef __APPLE__
+
struct dirent e;
- for (;;) {
+ for (;;)
+ {
memset (&e, 0, sizeof (e));
+
struct dirent *de = NULL;
if (readdir_r (d, &e, &de) != 0)
}
if (de == NULL) break;
+
#else
+
struct dirent *de;
while ((de = readdir (d)) != NULL)
{
+
#endif
+
if ((strcmp (de->d_name, ".") == 0) || (strcmp (de->d_name, "..") == 0)) continue;
int path_size = strlen (tmp_path) + 1 + strlen (de->d_name);
case 141: return ((char *) HT_00141); break;
case 150: return ((char *) HT_00150); break;
case 160: return ((char *) HT_00160); break;
- case 190: return ((char *) HT_00190); break;
case 200: return ((char *) HT_00200); break;
case 300: return ((char *) HT_00300); break;
case 400: return ((char *) HT_00400); break;
uint len = 4096;
- uint digest_buf[64] = { 0 };
+ u8 datax[256] = { 0 };
- u64 *digest_buf64 = (u64 *) digest_buf;
+ u64 *digest_buf64 = (u64 *) datax;
+ u32 *digest_buf = (u32 *) datax;
char *digests_buf_ptr = (char *) data.digests_buf;
void SuspendThreads ()
{
- if (data.devices_status == STATUS_RUNNING)
- {
- hc_timer_set (&data.timer_paused);
+ if (data.devices_status != STATUS_RUNNING) return;
- data.devices_status = STATUS_PAUSED;
+ hc_timer_set (&data.timer_paused);
- log_info ("Paused");
- }
+ data.devices_status = STATUS_PAUSED;
+
+ log_info ("Paused");
}
void ResumeThreads ()
{
- if (data.devices_status == STATUS_PAUSED)
- {
- double ms_paused;
+ if (data.devices_status != STATUS_PAUSED) return;
- hc_timer_get (data.timer_paused, ms_paused);
+ double ms_paused;
- data.ms_paused += ms_paused;
+ hc_timer_get (data.timer_paused, ms_paused);
- data.devices_status = STATUS_RUNNING;
+ data.ms_paused += ms_paused;
- log_info ("Resumed");
- }
+ data.devices_status = STATUS_RUNNING;
+
+ log_info ("Resumed");
}
void bypass ()
{
- if (data.devices_status != STATUS_RUNNING) return;
-
data.devices_status = STATUS_BYPASS;
log_info ("Next dictionary / mask in queue selected, bypassing current one");
if (data.restore_disable == 1)
{
- log_info ("WARNING: This feature is disabled when --restore-disable was specified");
+ log_info ("WARNING: This feature is disabled when --restore-disable is specified");
return;
}
void myabort ()
{
- if (data.devices_status == STATUS_INIT) return;
- if (data.devices_status == STATUS_STARTING) return;
-
data.devices_status = STATUS_ABORTED;
}
void myquit ()
{
- if (data.devices_status == STATUS_INIT) return;
- if (data.devices_status == STATUS_STARTING) return;
-
data.devices_status = STATUS_QUIT;
}
+void naive_replace (char *s, const u8 key_char, const u8 replace_char)
+{
+ const size_t len = strlen (s);
+
+ for (size_t in = 0; in < len; in++)
+ {
+ const u8 c = s[in];
+
+ if (c == key_char)
+ {
+ s[in] = replace_char;
+ }
+ }
+}
+
+void naive_escape (char *s, size_t s_max, const u8 key_char, const u8 escape_char)
+{
+ char s_escaped[1024] = { 0 };
+
+ size_t s_escaped_max = sizeof (s_escaped);
+
+ const size_t len = strlen (s);
+
+ for (size_t in = 0, out = 0; in < len; in++, out++)
+ {
+ const u8 c = s[in];
+
+ if (c == key_char)
+ {
+ s_escaped[out] = escape_char;
+
+ out++;
+ }
+
+ if (out == s_escaped_max - 2) break;
+
+ s_escaped[out] = c;
+ }
+
+ strncpy (s, s_escaped, s_max - 1);
+}
+
void load_kernel (const char *kernel_file, int num_devices, size_t *kernel_lengths, const u8 **kernel_sources)
{
FILE *fp = fopen (kernel_file, "rb");
char *iter_pos = input_buf + 4;
- salt->salt_iter = 1 << atoi (iter_pos);
+ salt->salt_iter = 1u << atoi (iter_pos);
char *salt_pos = strchr (iter_pos, '$');
if (salt_len > 36)
{
- log_info ("WARNING: The length of the ESSID is too long. The hccap file may be invalid or corrupted");
+ log_info ("WARNING: The ESSID length is too long, the hccap file may be invalid or corrupted");
return (PARSER_SALT_LENGTH);
}
char *iter_pos = input_buf + 3;
- uint salt_iter = 1 << itoa64_to_int (iter_pos[0]);
+ uint salt_iter = 1u << itoa64_to_int (iter_pos[0]);
if (salt_iter > 0x80000000) return (PARSER_SALT_ITERATION);
return (PARSER_OK);
}
-int sha1linkedin_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
-{
- if ((input_len < DISPLAY_LEN_MIN_100) || (input_len > DISPLAY_LEN_MAX_100)) return (PARSER_GLOBAL_LENGTH);
-
- u32 *digest = (u32 *) hash_buf->digest;
-
- digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]);
- digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
- digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]);
- digest[3] = hex_to_u32 ((const u8 *) &input_buf[24]);
- digest[4] = hex_to_u32 ((const u8 *) &input_buf[32]);
-
- return (PARSER_OK);
-}
-
int sha1axcrypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_13300) || (input_len > DISPLAY_LEN_MAX_13300)) return (PARSER_GLOBAL_LENGTH);
salt->salt_sign[0] = atoi (salt_iter);
- salt->salt_iter = (1 << atoi (salt_iter)) - 1;
+ salt->salt_iter = (1u << atoi (salt_iter)) - 1;
hash_pos++;
salt->salt_sign[0] = atoi (salt_iter);
- salt->salt_iter = (1 << atoi (salt_iter)) - 1;
+ salt->salt_iter = (1u << atoi (salt_iter)) - 1;
hash_pos++;
salt->salt_sign[0] = atoi (salt_iter);
- salt->salt_iter = (1 << atoi (salt_iter)) - 1;
+ salt->salt_iter = (1u << atoi (salt_iter)) - 1;
hash_pos++;
char *iter_pos = input_buf + 3;
- uint salt_iter = 1 << itoa64_to_int (iter_pos[0]);
+ uint salt_iter = 1u << itoa64_to_int (iter_pos[0]);
if (salt_iter > 0x80000000) return (PARSER_SALT_ITERATION);
int enc_md = atoi (enc_md_pos);
- if (enc_md != 1) return (PARSER_SALT_VALUE);
+ if ((enc_md != 0) && (enc_md != 1)) return (PARSER_SALT_VALUE);
const uint id_len = atoi (id_len_pos);
const uint u_len = atoi (u_len_pos);
salt->salt_sign[0] = iter;
- salt->salt_iter = 1 << iter;
+ salt->salt_iter = 1u << iter;
/**
* digest
salt->salt_sign[0] = iterations;
- salt->salt_iter = ((1 << iterations) + 32) - 1;
+ salt->salt_iter = ((1u << iterations) + 32) - 1;
/**
* digest buf
{
case CTRL_CLOSE_EVENT:
- myabort ();
+ myquit ();
SetConsoleCtrlHandler (NULL, TRUE);
void *thread_keypress (void *p)
{
- int benchmark = *((int *) p);
-
uint quiet = data.quiet;
tty_break();
- while ((data.devices_status != STATUS_EXHAUSTED) && (data.devices_status != STATUS_CRACKED) && (data.devices_status != STATUS_ABORTED) && (data.devices_status != STATUS_QUIT))
+ while (data.shutdown_outer == 0)
{
int ch = tty_getchar();
log_info ("");
- if (benchmark == 1) break;
-
stop_at_checkpoint ();
log_info ("");
log_info ("");
- if (benchmark == 1)
- {
- myquit ();
- }
- else
- {
- myabort ();
- }
+ myabort ();
break;
}
break;
case RULE_OP_MANGLE_PURGECHAR:
- return (-1);
+ SET_NAME (rule, rule_buf[rule_pos]);
+ SET_P0 (rule, rule_buf[rule_pos]);
break;
case RULE_OP_MANGLE_TOGGLECASE_REC:
- return (-1);
+ return -1;
break;
case RULE_OP_MANGLE_DUPECHAR_FIRST:
break;
default:
- return (-1);
+ return -1;
break;
}
}
- if (rule_pos < rule_len) return (-1);
+ if (rule_pos < rule_len) return -1;
- return (0);
+ return 0;
}
int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule)
break;
case RULE_OP_MANGLE_PURGECHAR:
- return (-1);
+ rule_buf[rule_pos] = rule_cmd;
+ GET_P0 (rule);
break;
case RULE_OP_MANGLE_TOGGLECASE_REC:
- return (-1);
+ return -1;
break;
case RULE_OP_MANGLE_DUPECHAR_FIRST:
break;
default:
- return (-1);
+ return -1;
break;
}
}
return rule_pos;
}
- return (-1);
+ return -1;
}
/**