arno
/
hashcat
mirror of https://github.com/hashcat/hashcat.git
1
0
Fork 0
Code Issues Releases Wiki Activity

fix some datatypes

Browse Source
pull/1518/head
jsteube 6 years ago
parent 98abea9a0f
commit 05a01d3843
43 changed files with 563 additions and 546 deletions
Show Stats Download Patch File Download Diff File

2
OpenCL/inc_types.cl
Unescape View File

@ -1990,7 +1990,7 @@ typedef struct
u32 salt_pos; u32 salt_pos;
u32 digest_pos; u32 digest_pos;
u32 hash_pos; u32 hash_pos;
u32 gidvid; u64 gidvid;
u32 il_pos; u32 il_pos;
} plain_t; } plain_t;

23
include/convert.h
Unescape View File

@ -8,13 +8,13 @@
#include <ctype.h> #include <ctype.h>
bool is_hexify (const u8 *buf, const int len); bool is_hexify (const u8 *buf, const size_t len);
int exec_unhexify (const u8 *in_buf, const int in_len, u8 *out_buf, const int out_sz); size_t exec_unhexify (const u8 *in_buf, const size_t in_len, u8 *out_buf, const size_t out_sz);
bool need_hexify (const u8 *buf, const int len, const char separator, bool always_ascii); bool need_hexify (const u8 *buf, const size_t len, const char separator, bool always_ascii);
void exec_hexify (const u8 *buf, const int len, u8 *out); void exec_hexify (const u8 *buf, const size_t len, u8 *out);
bool is_valid_hex_string (const u8 *s, const int len); bool is_valid_hex_string (const u8 *s, const size_t len);
bool is_valid_hex_char (const u8 c); bool is_valid_hex_char (const u8 c);
u8 hex_convert (const u8 c); u8 hex_convert (const u8 c);
@ -42,13 +42,12 @@ u8 bf64_to_int (const u8 c);
u8 int_to_lotus64 (const u8 c); u8 int_to_lotus64 (const u8 c);
u8 lotus64_to_int (const u8 c); u8 lotus64_to_int (const u8 c);
int base32_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf); size_t base32_decode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf);
int base32_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf); size_t base32_encode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf);
size_t base64_decode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf);
size_t base64_encode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf);
int base64_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf); void lowercase (u8 *buf, const size_t len);
int base64_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf); void uppercase (u8 *buf, const size_t len);
void lowercase (u8 *buf, int len);
void uppercase (u8 *buf, int len);
#endif // _CONVERT_H #endif // _CONVERT_H

4
include/filehandling.h
Unescape View File

@ -12,10 +12,10 @@
u64 count_lines (FILE *fd); u64 count_lines (FILE *fd);
int fgetl (FILE *fp, char *line_buf); size_t fgetl (FILE *fp, char *line_buf);
size_t superchop_with_length (char *buf, const size_t len); size_t superchop_with_length (char *buf, const size_t len);
int in_superchop (char *buf); size_t in_superchop (char *buf);
#endif // _FILEHANDLING_H #endif // _FILEHANDLING_H

4
include/hlfmt.h
Unescape View File

@ -12,8 +12,8 @@
const char *strhlfmt (const u32 hashfile_format); const char *strhlfmt (const u32 hashfile_format);
void hlfmt_hash (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len); void hlfmt_hash (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len);
void hlfmt_user (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len); void hlfmt_user (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len);
u32 hlfmt_detect (hashcat_ctx_t *hashcat_ctx, FILE *fp, u32 max_check); u32 hlfmt_detect (hashcat_ctx_t *hashcat_ctx, FILE *fp, u32 max_check);

2
include/interface.h
Unescape View File

@ -1957,7 +1957,7 @@ int electrum_wallet13_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_bu
* hook functions * hook functions
*/ */
void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u32 pws_cnt); void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u64 pws_cnt);
/** /**
* output functions * output functions

12
include/opencl.h
Unescape View File

@ -29,8 +29,8 @@ int hc_clCreateBuffer (hashcat_ctx_t *hashcat_ctx, cl_context context
int hc_clCreateCommandQueue (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_command_queue *command_queue); int hc_clCreateCommandQueue (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_device_id device, cl_command_queue_properties properties, cl_command_queue *command_queue);
int hc_clCreateContext (hashcat_ctx_t *hashcat_ctx, cl_context_properties *properties, cl_uint num_devices, const cl_device_id *devices, void (CL_CALLBACK *pfn_notify) (const char *, const void *, size_t, void *), void *user_data, cl_context *context); int hc_clCreateContext (hashcat_ctx_t *hashcat_ctx, cl_context_properties *properties, cl_uint num_devices, const cl_device_id *devices, void (CL_CALLBACK *pfn_notify) (const char *, const void *, size_t, void *), void *user_data, cl_context *context);
int hc_clCreateKernel (hashcat_ctx_t *hashcat_ctx, cl_program program, const char *kernel_name, cl_kernel *kernel); int hc_clCreateKernel (hashcat_ctx_t *hashcat_ctx, cl_program program, const char *kernel_name, cl_kernel *kernel);
int hc_clCreateProgramWithBinary (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const size_t *lengths, const unsigned char **binaries, cl_int *binary_status, cl_program *program); int hc_clCreateProgramWithBinary (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const size_t *lengths, unsigned char **binaries, cl_int *binary_status, cl_program *program);
int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint count, const char **strings, const size_t *lengths, cl_program *program); int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint count, char **strings, const size_t *lengths, cl_program *program);
int hc_clEnqueueCopyBuffer (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t cb, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event); int hc_clEnqueueCopyBuffer (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_mem src_buffer, cl_mem dst_buffer, size_t src_offset, size_t dst_offset, size_t cb, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event);
int hc_clEnqueueMapBuffer (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags, size_t offset, size_t cb, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event, void **buf); int hc_clEnqueueMapBuffer (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_map, cl_map_flags map_flags, size_t offset, size_t cb, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event, void **buf);
int hc_clEnqueueNDRangeKernel (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event); int hc_clEnqueueNDRangeKernel (hashcat_ctx_t *hashcat_ctx, cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, const size_t *global_work_offset, const size_t *global_work_size, const size_t *local_work_size, cl_uint num_events_in_wait_list, const cl_event *event_wait_list, cl_event *event);
@ -59,9 +59,9 @@ int hc_clWaitForEvents (hashcat_ctx_t *hashcat_ctx, cl_uint num_events
int gidd_to_pw_t (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 gidd, pw_t *pw); int gidd_to_pw_t (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 gidd, pw_t *pw);
int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 highest_pw_len, const u32 pws_cnt, const u32 fast_iteration, const u32 salt_pos); int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 highest_pw_len, const u64 pws_cnt, const u32 fast_iteration, const u32 salt_pos);
void rebuild_pws_compressed_append (hc_device_param_t *device_param, const u32 pws_cnt, const u8 chr); void rebuild_pws_compressed_append (hc_device_param_t *device_param, const u64 pws_cnt, const u8 chr);
int run_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 kern_run, const u64 num, const u32 event_update, const u32 iteration); int run_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 kern_run, const u64 num, const u32 event_update, const u32 iteration);
int run_kernel_mp (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 kern_run, const u64 num); int run_kernel_mp (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 kern_run, const u64 num);
@ -71,8 +71,8 @@ int run_kernel_atinit (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device
int run_kernel_memset (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, cl_mem buf, const u32 value, const u64 size); int run_kernel_memset (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, cl_mem buf, const u32 value, const u64 size);
int run_kernel_bzero (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, cl_mem buf, const u64 size); int run_kernel_bzero (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, cl_mem buf, const u64 size);
int run_kernel_decompress (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 num); int run_kernel_decompress (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 num);
int run_copy (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt); int run_copy (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt);
int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt); int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt);
void generate_source_kernel_filename (const u32 attack_exec, const u32 attack_kern, const u32 kern_type, const u32 opti_type, char *shared_dir, char *source_file); void generate_source_kernel_filename (const u32 attack_exec, const u32 attack_kern, const u32 kern_type, const u32 opti_type, char *shared_dir, char *source_file);
void generate_cached_kernel_filename (const u32 attack_exec, const u32 attack_kern, const u32 kern_type, const u32 opti_type, char *profile_dir, const char *device_name_chksum, char *cached_file); void generate_cached_kernel_filename (const u32 attack_exec, const u32 attack_kern, const u32 kern_type, const u32 opti_type, char *profile_dir, const char *device_name_chksum, char *cached_file);

3
include/shared.h
Unescape View File

@ -58,4 +58,7 @@ void hc_fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream);
bool hc_same_files (char *file1, char *file2); bool hc_same_files (char *file1, char *file2);
u32 hc_strtoul (const char *nptr, char **endptr, int base);
u64 hc_strtoull (const char *nptr, char **endptr, int base);
#endif // _SHARED_H #endif // _SHARED_H

2
include/status.h
Unescape View File

@ -82,7 +82,7 @@ char *status_get_cpt (const hashcat_ctx_t *hashcat_
char *status_get_hwmon_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); char *status_get_hwmon_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
int status_get_corespeed_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); int status_get_corespeed_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
int status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); u64 status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
double status_get_runtime_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); double status_get_runtime_msec_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
int status_get_kernel_accel_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); int status_get_kernel_accel_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
int status_get_kernel_loops_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); int status_get_kernel_loops_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);

2
include/stdout.h
Unescape View File

@ -20,6 +20,6 @@
#include <pwd.h> #include <pwd.h>
#endif // _POSIX #endif // _POSIX
int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt); int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt);
#endif // _STDOUT_H #endif // _STDOUT_H

47
include/types.h
Unescape View File

@ -892,7 +892,7 @@ typedef struct plain
u32 salt_pos; u32 salt_pos;
u32 digest_pos; u32 digest_pos;
u32 hash_pos; u32 hash_pos;
u32 gidvid; u64 gidvid;
u32 il_pos; u32 il_pos;
} plain_t; } plain_t;
@ -945,18 +945,19 @@ typedef struct hc_device_param
u32 kernel_threads_by_wgs_kernel_atinit; u32 kernel_threads_by_wgs_kernel_atinit;
u32 kernel_threads_by_wgs_kernel_decompress; u32 kernel_threads_by_wgs_kernel_decompress;
u32 kernel_loops;
u32 kernel_accel; u32 kernel_accel;
u32 kernel_loops_prev;
u32 kernel_accel_prev; u32 kernel_accel_prev;
u32 kernel_accel_min;
u32 kernel_accel_max;
u32 kernel_loops;
u32 kernel_loops_prev;
u32 kernel_loops_min; u32 kernel_loops_min;
u32 kernel_loops_max; u32 kernel_loops_max;
u32 kernel_loops_min_sav; // the _sav are required because each -i iteration u32 kernel_loops_min_sav; // the _sav are required because each -i iteration
u32 kernel_loops_max_sav; // needs to recalculate the kernel_loops_min/max based on the current amplifier count u32 kernel_loops_max_sav; // needs to recalculate the kernel_loops_min/max based on the current amplifier count
u32 kernel_accel_min;
u32 kernel_accel_max; u64 kernel_power;
u32 kernel_power; u64 hardware_power;
u32 hardware_power;
size_t size_pws; size_t size_pws;
size_t size_pws_amp; size_t size_pws_amp;
@ -986,17 +987,17 @@ typedef struct hc_device_param
pw_idx_t *pws_idx; pw_idx_t *pws_idx;
u32 *pws_comp; u32 *pws_comp;
u32 pws_cnt; u64 pws_cnt;
u64 words_off; u64 words_off;
u64 words_done; u64 words_done;
u32 outerloop_pos; u64 outerloop_pos;
u32 outerloop_left; u64 outerloop_left;
double outerloop_msec; double outerloop_msec;
u64 innerloop_pos; u32 innerloop_pos;
u64 innerloop_left; u32 innerloop_left;
u32 exec_pos; u32 exec_pos;
double exec_msec[EXEC_CACHE]; double exec_msec[EXEC_CACHE];
@ -1158,7 +1159,7 @@ typedef struct opencl_ctx
u32 hardware_power_all; u32 hardware_power_all;
u32 kernel_power_all; u64 kernel_power_all;
u64 kernel_power_final; // we save that so that all divisions are done from the same base u64 kernel_power_final; // we save that so that all divisions are done from the same base
u32 opencl_platforms_filter; u32 opencl_platforms_filter;
@ -1757,7 +1758,7 @@ typedef struct device_info
int corespeed_dev; int corespeed_dev;
int memoryspeed_dev; int memoryspeed_dev;
double runtime_msec_dev; double runtime_msec_dev;
int progress_dev; u64 progress_dev;
int kernel_accel_dev; int kernel_accel_dev;
int kernel_loops_dev; int kernel_loops_dev;
int kernel_threads_dev; int kernel_threads_dev;
@ -1934,8 +1935,8 @@ typedef struct cache_generate
typedef struct hashlist_parse typedef struct hashlist_parse
{ {
u32 hashes_cnt; u64 hashes_cnt;
u32 hashes_avail; u64 hashes_avail;
} hashlist_parse_t; } hashlist_parse_t;
@ -1943,15 +1944,15 @@ typedef struct hashlist_parse
typedef struct event_ctx typedef struct event_ctx
{ {
char old_buf[MAX_OLD_EVENTS][HCBUFSIZ_TINY]; char old_buf[MAX_OLD_EVENTS][HCBUFSIZ_TINY];
int old_len[MAX_OLD_EVENTS]; size_t old_len[MAX_OLD_EVENTS];
int old_cnt; int old_cnt;
char msg_buf[HCBUFSIZ_TINY]; char msg_buf[HCBUFSIZ_TINY];
int msg_len; size_t msg_len;
bool msg_newline; bool msg_newline;
int prev_len; size_t prev_len;
hc_thread_mutex_t mux_event; hc_thread_mutex_t mux_event;

2
include/wordlist.h
Unescape View File

@ -9,7 +9,7 @@
#include <time.h> #include <time.h>
#include <inttypes.h> #include <inttypes.h>
u32 convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const u32 line_len); size_t convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const size_t line_len);
void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len); void pw_add (hc_device_param_t *device_param, const u8 *pw_buf, const int pw_len);

2
src/affinity.c
Unescape View File

@ -71,7 +71,7 @@ int set_cpu_affinity (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx)
do do
{ {
int cpu_id = strtol (next, NULL, 10); const int cpu_id = (const int) strtol (next, NULL, 10);
if (cpu_id == 0) if (cpu_id == 0)
{ {

4
src/autotune.c
Unescape View File

@ -136,7 +136,7 @@ static int autotune (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
if ((exec_msec * mm) > target_msec) if ((exec_msec * mm) > target_msec)
{ {
const u32 loops_valid = target_msec / exec_msec; const u32 loops_valid = (const u32) (target_msec / exec_msec);
kernel_loops_max_reduced = kernel_loops_min * loops_valid; kernel_loops_max_reduced = kernel_loops_min * loops_valid;
} }
@ -207,7 +207,7 @@ static int autotune (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
double exec_msec_pre_final = try_run (hashcat_ctx, device_param, kernel_accel, kernel_loops); double exec_msec_pre_final = try_run (hashcat_ctx, device_param, kernel_accel, kernel_loops);
const u32 exec_left = target_msec / exec_msec_pre_final; const u32 exec_left = (const u32) (target_msec / exec_msec_pre_final);
const u32 accel_left = kernel_accel_max / kernel_accel; const u32 accel_left = kernel_accel_max / kernel_accel;

2
src/benchmark.c
Unescape View File

@ -8,7 +8,7 @@
#include "interface.h" #include "interface.h"
#include "benchmark.h" #include "benchmark.h"
const unsigned int DEFAULT_BENCHMARK_ALGORITHMS_BUF[] = static const int DEFAULT_BENCHMARK_ALGORITHMS_BUF[] =
{ {
0, 0,
100, 100,

14
src/bitmap.c
Unescape View File

@ -28,7 +28,7 @@ static void selftest_to_bitmap (const u32 dgst_shifts, char *digests_buf_ptr, co
bitmap_d[idx3] |= val3; bitmap_d[idx3] |= val3;
} }
static u32 generate_bitmaps (const u32 digests_cnt, const u32 dgst_size, const u32 dgst_shifts, char *digests_buf_ptr, const u32 dgst_pos0, const u32 dgst_pos1, const u32 dgst_pos2, const u32 dgst_pos3, const u32 bitmap_mask, const u32 bitmap_size, u32 *bitmap_a, u32 *bitmap_b, u32 *bitmap_c, u32 *bitmap_d, const u64 collisions_max) static bool generate_bitmaps (const u32 digests_cnt, const u32 dgst_size, const u32 dgst_shifts, char *digests_buf_ptr, const u32 dgst_pos0, const u32 dgst_pos1, const u32 dgst_pos2, const u32 dgst_pos3, const u32 bitmap_mask, const u32 bitmap_size, u32 *bitmap_a, u32 *bitmap_b, u32 *bitmap_c, u32 *bitmap_d, const u64 collisions_max)
{ {
u64 collisions = 0; u64 collisions = 0;
@ -63,10 +63,10 @@ static u32 generate_bitmaps (const u32 digests_cnt, const u32 dgst_size, const u
bitmap_c[idx2] |= val2; bitmap_c[idx2] |= val2;
bitmap_d[idx3] |= val3; bitmap_d[idx3] |= val3;
if (collisions >= collisions_max) return 0x7fffffff; if (collisions >= collisions_max) return true;
} }
return collisions; return false;
} }
int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx) int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx)
@ -122,8 +122,8 @@ int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx)
if ((hashes->digests_cnt & bitmap_mask) == hashes->digests_cnt) break; if ((hashes->digests_cnt & bitmap_mask) == hashes->digests_cnt) break;
if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == 0x7fffffff) continue; if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == true) continue;
if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == 0x7fffffff) continue; if (generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, hashes->digests_cnt / 2) == true) continue;
break; break;
} }
@ -134,8 +134,8 @@ int bitmap_ctx_init (hashcat_ctx_t *hashcat_ctx)
bitmap_size = bitmap_nums * sizeof (u32); bitmap_size = bitmap_nums * sizeof (u32);
generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1ul); generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift1, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s1_a, bitmap_s1_b, bitmap_s1_c, bitmap_s1_d, -1);
generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1ul); generate_bitmaps (hashes->digests_cnt, hashconfig->dgst_size, bitmap_shift2, (char *) hashes->digests_buf, hashconfig->dgst_pos0, hashconfig->dgst_pos1, hashconfig->dgst_pos2, hashconfig->dgst_pos3, bitmap_mask, bitmap_size, bitmap_s2_a, bitmap_s2_b, bitmap_s2_c, bitmap_s2_d, -1);
if (hashconfig->st_hash != NULL) if (hashconfig->st_hash != NULL)
{ {

3
src/bitops.c
Unescape View File

@ -55,8 +55,7 @@ u64 rotr64 (const u64 a, const u64 n)
u16 byte_swap_16 (const u16 n) u16 byte_swap_16 (const u16 n)
{ {
return (n & 0xff00) >> 8 return (u16) ((n >> 8) | (n << 8));
| (n & 0x00ff) << 8;
} }
u32 byte_swap_32 (const u32 n) u32 byte_swap_32 (const u32 n)

68
src/convert.c
Unescape View File

@ -13,7 +13,7 @@
#define FALLTHROUGH #define FALLTHROUGH
#endif #endif
static bool printable_utf8 (const u8 *buf, const int len) static bool printable_utf8 (const u8 *buf, const size_t len)
{ {
u8 a; u8 a;
int length; int length;
@ -68,9 +68,9 @@ static bool printable_utf8 (const u8 *buf, const int len)
return true; return true;
} }
static bool printable_ascii (const u8 *buf, const int len) static bool printable_ascii (const u8 *buf, const size_t len)
{ {
for (int i = 0; i < len; i++) for (size_t i = 0; i < len; i++)
{ {
const u8 c = buf[i]; const u8 c = buf[i];
@ -81,9 +81,9 @@ static bool printable_ascii (const u8 *buf, const int len)
return true; return true;
} }
static bool matches_separator (const u8 *buf, const int len, const char separator) static bool matches_separator (const u8 *buf, const size_t len, const char separator)
{ {
for (int i = 0; i < len; i++) for (size_t i = 0; i < len; i++)
{ {
const char c = (char) buf[i]; const char c = (char) buf[i];
@ -93,7 +93,7 @@ static bool matches_separator (const u8 *buf, const int len, const char separato
return false; return false;
} }
bool is_hexify (const u8 *buf, const int len) bool is_hexify (const u8 *buf, const size_t len)
{ {
if (len < 6) return false; // $HEX[] = 6 if (len < 6) return false; // $HEX[] = 6
@ -115,9 +115,9 @@ bool is_hexify (const u8 *buf, const int len)
return true; return true;
} }
int exec_unhexify (const u8 *in_buf, const int in_len, u8 *out_buf, const int out_sz) size_t exec_unhexify (const u8 *in_buf, const size_t in_len, u8 *out_buf, const size_t out_sz)
{ {
int i, j; size_t i, j;
for (i = 0, j = 5; j < in_len - 1; i += 1, j += 2) for (i = 0, j = 5; j < in_len - 1; i += 1, j += 2)
{ {
@ -131,7 +131,7 @@ int exec_unhexify (const u8 *in_buf, const int in_len, u8 *out_buf, const int ou
return (i); return (i);
} }
bool need_hexify (const u8 *buf, const int len, const char separator, bool always_ascii) bool need_hexify (const u8 *buf, const size_t len, const char separator, bool always_ascii)
{ {
bool rc = false; bool rc = false;
@ -171,11 +171,11 @@ bool need_hexify (const u8 *buf, const int len, const char separator, bool alway
return rc; return rc;
} }
void exec_hexify (const u8 *buf, const int len, u8 *out) void exec_hexify (const u8 *buf, const size_t len, u8 *out)
{ {
const int max_len = (len >= PW_MAX) ? PW_MAX : len; const size_t max_len = (len >= PW_MAX) ? PW_MAX : len;
for (int i = max_len - 1, j = i * 2; i >= 0; i -= 1, j -= 2) for (int i = (int) max_len - 1, j = i * 2; i >= 0; i -= 1, j -= 2)
{ {
u8_to_hex_lower (buf[i], out + j); u8_to_hex_lower (buf[i], out + j);
} }
@ -183,9 +183,9 @@ void exec_hexify (const u8 *buf, const int len, u8 *out)
out[max_len * 2] = 0; out[max_len * 2] = 0;
} }
bool is_valid_hex_string (const u8 *s, const int len) bool is_valid_hex_string (const u8 *s, const size_t len)
{ {
for (int i = 0; i < len; i++) for (size_t i = 0; i < len; i++)
{ {
const u8 c = s[i]; const u8 c = s[i];
@ -527,13 +527,13 @@ u8 lotus64_to_int (const u8 c)
return 0; return 0;
} }
int base32_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf) size_t base32_decode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf)
{ {
const u8 *in_ptr = in_buf; const u8 *in_ptr = in_buf;
u8 *out_ptr = out_buf; u8 *out_ptr = out_buf;
for (int i = 0; i < in_len; i += 8) for (size_t i = 0; i < in_len; i += 8)
{ {
const u8 out_val0 = f (in_ptr[0] & 0x7f); const u8 out_val0 = f (in_ptr[0] & 0x7f);
const u8 out_val1 = f (in_ptr[1] & 0x7f); const u8 out_val1 = f (in_ptr[1] & 0x7f);
@ -554,25 +554,27 @@ int base32_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf
out_ptr += 5; out_ptr += 5;
} }
for (int i = 0; i < in_len; i++) size_t tmp_len = 0;
for (size_t i = 0; i < in_len; i++, tmp_len++)
{ {
if (in_buf[i] != '=') continue; if (in_buf[i] != '=') continue;
in_len = i; break;
} }
int out_len = (in_len * 5) / 8; size_t out_len = (tmp_len * 5) / 8;
return out_len; return out_len;
} }
int base32_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf) size_t base32_encode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf)
{ {
const u8 *in_ptr = in_buf; const u8 *in_ptr = in_buf;
u8 *out_ptr = out_buf; u8 *out_ptr = out_buf;
for (int i = 0; i < in_len; i += 5) for (size_t i = 0; i < in_len; i += 5)
{ {
const u8 out_val0 = f ( ((in_ptr[0] >> 3) & 0x1f)); const u8 out_val0 = f ( ((in_ptr[0] >> 3) & 0x1f));
const u8 out_val1 = f (((in_ptr[0] << 2) & 0x1c) | ((in_ptr[1] >> 6) & 0x03)); const u8 out_val1 = f (((in_ptr[0] << 2) & 0x1c) | ((in_ptr[1] >> 6) & 0x03));
@ -608,13 +610,13 @@ int base32_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf
return out_len; return out_len;
} }
int base64_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf) size_t base64_decode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf)
{ {
const u8 *in_ptr = in_buf; const u8 *in_ptr = in_buf;
u8 *out_ptr = out_buf; u8 *out_ptr = out_buf;
for (int i = 0; i < in_len; i += 4) for (size_t i = 0; i < in_len; i += 4)
{ {
const u8 out_val0 = f (in_ptr[0] & 0x7f); const u8 out_val0 = f (in_ptr[0] & 0x7f);
const u8 out_val1 = f (in_ptr[1] & 0x7f); const u8 out_val1 = f (in_ptr[1] & 0x7f);
@ -629,25 +631,27 @@ int base64_decode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf
out_ptr += 3; out_ptr += 3;
} }
for (int i = 0; i < in_len; i++) size_t tmp_len = 0;
for (size_t i = 0; i < in_len; i++, tmp_len++)
{ {
if (in_buf[i] != '=') continue; if (in_buf[i] != '=') continue;
in_len = i; break;
} }
int out_len = (in_len * 6) / 8; size_t out_len = (tmp_len * 6) / 8;
return out_len; return out_len;
} }
int base64_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf) size_t base64_encode (u8 (*f) (const u8), const u8 *in_buf, const size_t in_len, u8 *out_buf)
{ {
const u8 *in_ptr = in_buf; const u8 *in_ptr = in_buf;
u8 *out_ptr = out_buf; u8 *out_ptr = out_buf;
for (int i = 0; i < in_len; i += 3) for (size_t i = 0; i < in_len; i += 3)
{ {
const u8 out_val0 = f ( ((in_ptr[0] >> 2) & 0x3f)); const u8 out_val0 = f ( ((in_ptr[0] >> 2) & 0x3f));
const u8 out_val1 = f (((in_ptr[0] << 4) & 0x30) | ((in_ptr[1] >> 4) & 0x0f)); const u8 out_val1 = f (((in_ptr[0] << 4) & 0x30) | ((in_ptr[1] >> 4) & 0x0f));
@ -675,12 +679,12 @@ int base64_encode (u8 (*f) (const u8), const u8 *in_buf, int in_len, u8 *out_buf
return out_len; return out_len;
} }
void lowercase (u8 *buf, int len) void lowercase (u8 *buf, const size_t len)
{ {
for (int i = 0; i < len; i++) buf[i] = tolower (buf[i]); for (size_t i = 0; i < len; i++) buf[i] = (u8) tolower ((int) buf[i]);
} }
void uppercase (u8 *buf, int len) void uppercase (u8 *buf, const size_t len)
{ {
for (int i = 0; i < len; i++) buf[i] = toupper (buf[i]); for (size_t i = 0; i < len; i++) buf[i] = (u8) toupper ((int) buf[i]);
} }

26
src/dictstat.c
Unescape View File

@ -14,14 +14,8 @@
int sort_by_dictstat (const void *s1, const void *s2) int sort_by_dictstat (const void *s1, const void *s2)
{ {
dictstat_t *d1 = (dictstat_t *) s1; const dictstat_t *d1 = (const dictstat_t *) s1;
dictstat_t *d2 = (dictstat_t *) s2; const dictstat_t *d2 = (const dictstat_t *) s2;
d2->stat.st_atime = d1->stat.st_atime;
#if defined (STAT_NANOSECONDS_ACCESS_TIME)
d2->stat.STAT_NANOSECONDS_ACCESS_TIME = d1->stat.STAT_NANOSECONDS_ACCESS_TIME;
#endif
const int rc_from = strcmp (d1->encoding_from, d2->encoding_from); const int rc_from = strcmp (d1->encoding_from, d2->encoding_from);
@ -31,7 +25,21 @@ int sort_by_dictstat (const void *s1, const void *s2)
if (rc_to != 0) return rc_to; if (rc_to != 0) return rc_to;
return memcmp (&d1->stat, &d2->stat, sizeof (struct stat)); struct stat stat1;
struct stat stat2;
memcpy (&stat1, &d1->stat, sizeof (struct stat));
memcpy (&stat2, &d2->stat, sizeof (struct stat));
stat1.st_atime = 0;
stat2.st_atime = 0;
#if defined (STAT_NANOSECONDS_ACCESS_TIME)
stat1.STAT_NANOSECONDS_ACCESS_TIME = 0;
stat2.STAT_NANOSECONDS_ACCESS_TIME = 0;
#endif
return memcmp (&s1, &s2, sizeof (struct stat));
} }
int dictstat_init (hashcat_ctx_t *hashcat_ctx) int dictstat_init (hashcat_ctx_t *hashcat_ctx)

26
src/dispatch.c
Unescape View File

@ -44,7 +44,7 @@ static u64 get_lowest_words_done (const hashcat_ctx_t *hashcat_ctx)
return words_cur; return words_cur;
} }
static int set_kernel_power_final (hashcat_ctx_t *hashcat_ctx, const u32 kernel_power_final) static int set_kernel_power_final (hashcat_ctx_t *hashcat_ctx, const u64 kernel_power_final)
{ {
EVENT (EVENT_SET_KERNEL_POWER_FINAL); EVENT (EVENT_SET_KERNEL_POWER_FINAL);
@ -55,7 +55,7 @@ static int set_kernel_power_final (hashcat_ctx_t *hashcat_ctx, const u32 kernel_
return 0; return 0;
} }
static u32 get_power (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param) static u64 get_power (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param)
{ {
const u64 kernel_power_final = opencl_ctx->kernel_power_final; const u64 kernel_power_final = opencl_ctx->kernel_power_final;
@ -79,7 +79,7 @@ static u32 get_power (opencl_ctx_t *opencl_ctx, hc_device_param_t *device_param)
return device_param->kernel_power; return device_param->kernel_power;
} }
static u32 get_work (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 max) static u64 get_work (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 max)
{ {
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
status_ctx_t *status_ctx = hashcat_ctx->status_ctx; status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
@ -104,9 +104,9 @@ static u32 get_work (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
} }
} }
const u32 kernel_power = get_power (opencl_ctx, device_param); const u64 kernel_power = get_power (opencl_ctx, device_param);
u32 work = MIN (words_left, kernel_power); u64 work = MIN (words_left, kernel_power);
work = MIN (work, max); work = MIN (work, max);
@ -156,7 +156,7 @@ static int calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_par
break; break;
} }
u32 words_extra_total = 0; u64 words_extra_total = 0;
memset (device_param->pws_comp, 0, device_param->size_pws_comp); memset (device_param->pws_comp, 0, device_param->size_pws_comp);
memset (device_param->pws_idx, 0, device_param->size_pws_idx); memset (device_param->pws_idx, 0, device_param->size_pws_idx);
@ -169,7 +169,7 @@ static int calc_stdin (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_par
size_t line_len = in_superchop (line_buf); size_t line_len = in_superchop (line_buf);
line_len = convert_from_hex (hashcat_ctx, line_buf, line_len); line_len = convert_from_hex (hashcat_ctx, line_buf, (u32) line_len);
// do the on-the-fly encoding // do the on-the-fly encoding
@ -342,7 +342,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
while (status_ctx->run_thread_level1 == true) while (status_ctx->run_thread_level1 == true)
{ {
const u32 work = get_work (hashcat_ctx, device_param, -1u); const u64 work = get_work (hashcat_ctx, device_param, -1);
if (work == 0) break; if (work == 0) break;
@ -487,16 +487,16 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
u64 words_off = 0; u64 words_off = 0;
u64 words_fin = 0; u64 words_fin = 0;
u32 words_extra = -1u; u64 words_extra = -1u;
u32 words_extra_total = 0; u64 words_extra_total = 0;
memset (device_param->pws_comp, 0, device_param->size_pws_comp); memset (device_param->pws_comp, 0, device_param->size_pws_comp);
memset (device_param->pws_idx, 0, device_param->size_pws_idx); memset (device_param->pws_idx, 0, device_param->size_pws_idx);
while (words_extra) while (words_extra)
{ {
const u32 work = get_work (hashcat_ctx, device_param, words_extra); const u64 work = get_work (hashcat_ctx, device_param, words_extra);
if (work == 0) break; if (work == 0) break;
@ -516,7 +516,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
{ {
get_next_word (hashcat_ctx_tmp, fd, &line_buf, &line_len); get_next_word (hashcat_ctx_tmp, fd, &line_buf, &line_len);
line_len = convert_from_hex (hashcat_ctx, line_buf, line_len); line_len = (u32) convert_from_hex (hashcat_ctx, line_buf, line_len);
// post-process rule engine // post-process rule engine
@ -591,7 +591,7 @@ static int calc (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param)
// flush // flush
// //
const u32 pws_cnt = device_param->pws_cnt; const u64 pws_cnt = device_param->pws_cnt;
if (pws_cnt) if (pws_cnt)
{ {

4
src/event.c
Unescape View File

@ -45,13 +45,13 @@ void event_call (const u32 id, hashcat_ctx_t *hashcat_ctx, const void *buf, cons
event_ctx->old_len[i] = event_ctx->old_len[i - 1]; event_ctx->old_len[i] = event_ctx->old_len[i - 1];
} }
u32 copy_len = 0; size_t copy_len = 0;
if (buf) if (buf)
{ {
// truncate the whole buffer if needed (such that it fits into the old_buf): // truncate the whole buffer if needed (such that it fits into the old_buf):
const u32 max_buf_len = sizeof (event_ctx->old_buf[0]); const size_t max_buf_len = sizeof (event_ctx->old_buf[0]);
copy_len = MIN (len, max_buf_len - 1); copy_len = MIN (len, max_buf_len - 1);

2
src/ext_lzma.c
Unescape View File

@ -28,7 +28,7 @@ int hc_lzma1_decompress (const unsigned char *in, SizeT *in_len, unsigned char *
// parameters to LzmaDecode (): unsigned char *dest, size_t *destLen, const unsigned char *src, // parameters to LzmaDecode (): unsigned char *dest, size_t *destLen, const unsigned char *src,
// size_t *srcLen, const unsigned char *props, size_t propsSize, ELzmaFinishMode finishMode, ELzmaStatus status, ISzAlloc *alloc // size_t *srcLen, const unsigned char *props, size_t propsSize, ELzmaFinishMode finishMode, ELzmaStatus status, ISzAlloc *alloc
return LzmaDecode (out, out_len, in, in_len, (Byte *) props, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &hc_lzma_mem_alloc); return LzmaDecode (out, out_len, in, in_len, (const Byte *) props, LZMA_PROPS_SIZE, LZMA_FINISH_ANY, &status, &hc_lzma_mem_alloc);
} }
int hc_lzma2_decompress (const unsigned char *in, SizeT *in_len, unsigned char *out, SizeT *out_len, const char *props) int hc_lzma2_decompress (const unsigned char *in, SizeT *in_len, unsigned char *out, SizeT *out_len, const char *props)

6
src/filehandling.c
Unescape View File

@ -38,9 +38,9 @@ u64 count_lines (FILE *fd)
return cnt; return cnt;
} }
int fgetl (FILE *fp, char *line_buf) size_t fgetl (FILE *fp, char *line_buf)
{ {
int line_len = 0; size_t line_len = 0;
while (!feof (fp)) while (!feof (fp))
{ {
@ -113,7 +113,7 @@ size_t superchop_with_length (char *buf, const size_t len)
return new_len; return new_len;
} }
int in_superchop (char *buf) size_t in_superchop (char *buf)
{ {
size_t len = strlen (buf); size_t len = strlen (buf);

42
src/hashes.c
Unescape View File

@ -506,7 +506,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
u32 hashlist_format = HLFMT_HASHCAT; u32 hashlist_format = HLFMT_HASHCAT;
u32 hashes_avail = 0; u64 hashes_avail = 0;
if ((user_options->benchmark == false) && (user_options->stdout_flag == false) && (user_options->keyspace == false)) if ((user_options->benchmark == false) && (user_options->stdout_flag == false) && (user_options->keyspace == false))
{ {
@ -733,10 +733,10 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{ {
char *input_buf = user_options_extra->hc_hash; char *input_buf = user_options_extra->hc_hash;
u32 input_len = strlen (input_buf); size_t input_len = strlen (input_buf);
char *hash_buf = NULL; char *hash_buf = NULL;
int hash_len = 0; size_t hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, input_buf, input_len, &hash_buf, &hash_len); hlfmt_hash (hashcat_ctx, hashlist_format, input_buf, input_len, &hash_buf, &hash_len);
@ -881,7 +881,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig); parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK) if (parser_status == PARSER_OK)
{ {
@ -902,7 +902,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
for (int keyslot_idx = 0; keyslot_idx < LUKS_NUMKEYS; keyslot_idx++) for (int keyslot_idx = 0; keyslot_idx < LUKS_NUMKEYS; keyslot_idx++)
{ {
parser_status = luks_parse_hash ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig, keyslot_idx); parser_status = luks_parse_hash ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig, keyslot_idx);
if (parser_status != PARSER_OK) if (parser_status != PARSER_OK)
{ {
@ -919,7 +919,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig); parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status == PARSER_OK) if (parser_status == PARSER_OK)
{ {
@ -954,7 +954,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
{ {
line_num++; line_num++;
int line_len = fgetl (fp, line_buf); const size_t line_len = fgetl (fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -965,8 +965,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
break; break;
} }
char *hash_buf = NULL; char *hash_buf = NULL;
int hash_len = 0; size_t hash_len = 0;
hlfmt_hash (hashcat_ctx, hashlist_format, line_buf, line_len, &hash_buf, &hash_len); hlfmt_hash (hashcat_ctx, hashlist_format, line_buf, line_len, &hash_buf, &hash_len);
@ -984,8 +984,8 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
if (user_options->username == true) if (user_options->username == true)
{ {
char *user_buf = NULL; char *user_buf = NULL;
int user_len = 0; size_t user_len = 0;
hlfmt_user (hashcat_ctx, hashlist_format, line_buf, line_len, &user_buf, &user_len); hlfmt_user (hashcat_ctx, hashlist_format, line_buf, line_len, &user_buf, &user_len);
@ -1019,7 +1019,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
user_ptr->user_name = hcstrdup (""); user_ptr->user_name = hcstrdup ("");
} }
user_ptr->user_len = user_len; user_ptr->user_len = (u32) user_len;
} }
} }
@ -1095,7 +1095,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig); int parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO) if (parser_status < PARSER_GLOBAL_ZERO)
{ {
@ -1120,7 +1120,7 @@ int hashes_init_stage1 (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
int parser_status = hashconfig->parse_func ((u8 *) hash_buf, hash_len, &hashes_buf[hashes_cnt], hashconfig); int parser_status = hashconfig->parse_func ((u8 *) hash_buf, (u32) hash_len, &hashes_buf[hashes_cnt], hashconfig);
if (parser_status < PARSER_GLOBAL_ZERO) if (parser_status < PARSER_GLOBAL_ZERO)
{ {
@ -1628,9 +1628,9 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
{ {
char *tmpdata = (char *) hcmalloc (sizeof (hccapx_t)); char *tmpdata = (char *) hcmalloc (sizeof (hccapx_t));
const int st_hash_len = strlen (hashconfig->st_hash); const size_t st_hash_len = strlen (hashconfig->st_hash);
for (int i = 0, j = 0; j < st_hash_len; i += 1, j += 2) for (size_t i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{ {
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j); const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
@ -1653,9 +1653,9 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
FILE *fp = fopen (tmpfile_bin, "wb"); FILE *fp = fopen (tmpfile_bin, "wb");
const int st_hash_len = strlen (hashconfig->st_hash); const size_t st_hash_len = strlen (hashconfig->st_hash);
for (int i = 0; i < st_hash_len; i += 2) for (size_t i = 0; i < st_hash_len; i += 2)
{ {
const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i); const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i);
@ -1664,7 +1664,7 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
fclose (fp); fclose (fp);
parser_status = hashconfig->parse_func ((u8 *) tmpfile_bin, strlen (tmpfile_bin), &hash, hashconfig); parser_status = hashconfig->parse_func ((u8 *) tmpfile_bin, (u32) strlen (tmpfile_bin), &hash, hashconfig);
unlink (tmpfile_bin); unlink (tmpfile_bin);
@ -1693,7 +1693,7 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
char *tmpdata = hcstrdup (hashconfig->st_hash); char *tmpdata = hcstrdup (hashconfig->st_hash);
parser_status = hashconfig->parse_func ((u8 *) tmpdata, strlen (hashconfig->st_hash), &hash, hashconfig_st); parser_status = hashconfig->parse_func ((u8 *) tmpdata, (u32) strlen (hashconfig->st_hash), &hash, hashconfig_st);
hcfree (tmpdata); hcfree (tmpdata);

70
src/hlfmt.c
Unescape View File

@ -22,7 +22,7 @@ static const char *HLFMT_TEXT_NSLDAPS = "nsldaps";
// hlfmt hashcat // hlfmt hashcat
static void hlfmt_hash_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len) static void hlfmt_hash_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len)
{ {
const user_options_t *user_options = hashcat_ctx->user_options; const user_options_t *user_options = hashcat_ctx->user_options;
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
@ -34,10 +34,10 @@ static void hlfmt_hash_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *l
} }
else else
{ {
char *pos = line_buf; char *pos = line_buf;
int len = line_len; size_t len = line_len;
for (int i = 0; i < line_len; i++, pos++, len--) for (size_t i = 0; i < line_len; i++, pos++, len--)
{ {
if (line_buf[i] == hashconfig->separator) if (line_buf[i] == hashconfig->separator)
{ {
@ -54,16 +54,16 @@ static void hlfmt_hash_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *l
} }
} }
static void hlfmt_user_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len) static void hlfmt_user_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len)
{ {
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
char *pos = NULL; char *pos = NULL;
int len = 0; size_t len = 0;
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == hashconfig->separator) if (line_buf[i] == hashconfig->separator)
{ {
@ -86,14 +86,14 @@ static void hlfmt_user_hashcat (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *l
// hlfmt pwdump // hlfmt pwdump
static int hlfmt_detect_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, int line_len) static int hlfmt_detect_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, size_t line_len)
{ {
int sep_cnt = 0; int sep_cnt = 0;
int sep2_len = 0; int sep2_len = 0;
int sep3_len = 0; int sep3_len = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -111,16 +111,16 @@ static int hlfmt_detect_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const c
return 0; return 0;
} }
static void hlfmt_hash_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len) static void hlfmt_hash_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len)
{ {
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
char *pos = NULL; char *pos = NULL;
int len = 0; size_t len = 0;
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -153,14 +153,14 @@ static void hlfmt_hash_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *li
*hashbuf_len = len; *hashbuf_len = len;
} }
static void hlfmt_user_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len) static void hlfmt_user_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len)
{ {
char *pos = NULL; char *pos = NULL;
int len = 0; size_t len = 0;
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -183,14 +183,14 @@ static void hlfmt_user_pwdump (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *li
// hlfmt passwd // hlfmt passwd
static int hlfmt_detect_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, int line_len) static int hlfmt_detect_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, size_t line_len)
{ {
int sep_cnt = 0; int sep_cnt = 0;
char sep5_first = 0; char sep5_first = 0;
char sep6_first = 0; char sep6_first = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -208,14 +208,14 @@ static int hlfmt_detect_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const c
return 0; return 0;
} }
static void hlfmt_hash_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len) static void hlfmt_hash_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len)
{ {
char *pos = NULL; char *pos = NULL;
int len = 0; size_t len = 0;
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -236,14 +236,14 @@ static void hlfmt_hash_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *li
*hashbuf_len = len; *hashbuf_len = len;
} }
static void hlfmt_user_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len) static void hlfmt_user_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len)
{ {
char *pos = NULL; char *pos = NULL;
int len = 0; size_t len = 0;
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') if (line_buf[i] == ':')
{ {
@ -266,11 +266,11 @@ static void hlfmt_user_passwd (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *li
// hlfmt shadow // hlfmt shadow
static int hlfmt_detect_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, int line_len) static int hlfmt_detect_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const char *line_buf, size_t line_len)
{ {
int sep_cnt = 0; int sep_cnt = 0;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (line_buf[i] == ':') sep_cnt++; if (line_buf[i] == ':') sep_cnt++;
} }
@ -280,12 +280,12 @@ static int hlfmt_detect_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, const c
return 0; return 0;
} }
static void hlfmt_hash_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len) static void hlfmt_hash_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len)
{ {
hlfmt_hash_passwd (hashcat_ctx, line_buf, line_len, hashbuf_pos, hashbuf_len); hlfmt_hash_passwd (hashcat_ctx, line_buf, line_len, hashbuf_pos, hashbuf_len);
} }
static void hlfmt_user_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len) static void hlfmt_user_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len)
{ {
hlfmt_user_passwd (hashcat_ctx, line_buf, line_len, userbuf_pos, userbuf_len); hlfmt_user_passwd (hashcat_ctx, line_buf, line_len, userbuf_pos, userbuf_len);
} }
@ -311,7 +311,7 @@ const char *strhlfmt (const u32 hashfile_format)
return "Unknown"; return "Unknown";
} }
void hlfmt_hash (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, int line_len, char **hashbuf_pos, int *hashbuf_len) void hlfmt_hash (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, size_t line_len, char **hashbuf_pos, size_t *hashbuf_len)
{ {
switch (hashfile_format) switch (hashfile_format)
{ {
@ -322,7 +322,7 @@ void hlfmt_hash (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf
} }
} }
void hlfmt_user (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, int line_len, char **userbuf_pos, int *userbuf_len) void hlfmt_user (hashcat_ctx_t *hashcat_ctx, u32 hashfile_format, char *line_buf, size_t line_len, char **userbuf_pos, size_t *userbuf_len)
{ {
switch (hashfile_format) switch (hashfile_format)
{ {
@ -350,7 +350,7 @@ u32 hlfmt_detect (hashcat_ctx_t *hashcat_ctx, FILE *fp, u32 max_check)
while (!feof (fp)) while (!feof (fp))
{ {
int line_len = fgetl (fp, line_buf); const size_t line_len = fgetl (fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;

5
src/induct.c
Unescape View File

@ -25,7 +25,10 @@ static int sort_by_mtime (const void *p1, const void *p2)
if (rc1 < rc2) return 1; if (rc1 < rc2) return 1;
if (rc1 > rc2) return -1; if (rc1 > rc2) return -1;
return s2.st_mtime - s1.st_mtime; if (s1.st_mtime < s2.st_mtime) return 1;
if (s1.st_mtime > s2.st_mtime) return -1;
return 0;
} }
int induct_ctx_init (hashcat_ctx_t *hashcat_ctx) int induct_ctx_init (hashcat_ctx_t *hashcat_ctx)

206
src/interface.c
Unescape View File

@ -2606,7 +2606,7 @@ int bcrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
u8 *iter_pos = input_buf + 4; u8 *iter_pos = input_buf + 4;
salt->salt_iter = 1u << strtoul ((const char *) iter_pos, NULL, 10); salt->salt_iter = 1u << hc_strtoul ((const char *) iter_pos, NULL, 10);
u8 *salt_pos = (u8 *) strchr ((const char *) iter_pos, '$'); u8 *salt_pos = (u8 *) strchr ((const char *) iter_pos, '$');
@ -3069,7 +3069,7 @@ int dcc2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
salt_t *salt = hash_buf->salt; salt_t *salt = hash_buf->salt;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) if (iter < 1)
{ {
@ -3205,8 +3205,8 @@ int dpapimk_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
contents_pos++; contents_pos++;
u32 version = strtoul ((const char *) version_pos, NULL, 10); u32 version = hc_strtoul ((const char *) version_pos, NULL, 10);
u32 contents_len = strtoul ((const char *) contents_len_pos, NULL, 10); u32 contents_len = hc_strtoul ((const char *) contents_len_pos, NULL, 10);
if (version == 1 && contents_len != 208) return (PARSER_SALT_LENGTH); if (version == 1 && contents_len != 208) return (PARSER_SALT_LENGTH);
if (version == 2 && contents_len != 288) return (PARSER_SALT_LENGTH); if (version == 2 && contents_len != 288) return (PARSER_SALT_LENGTH);
@ -3219,9 +3219,9 @@ int dpapimk_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
if (effective_contents_len != contents_len) return (PARSER_SALT_LENGTH); if (effective_contents_len != contents_len) return (PARSER_SALT_LENGTH);
dpapimk->context = strtoul ((const char *) context_pos, NULL, 10); dpapimk->context = hc_strtoul ((const char *) context_pos, NULL, 10);
salt->salt_iter = strtoul ((const char *) rounds_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) rounds_pos, NULL, 10) - 1;
dpapimk->iv[0] = hex_to_u32 ((const u8 *) &iv_pos[ 0]); dpapimk->iv[0] = hex_to_u32 ((const u8 *) &iv_pos[ 0]);
dpapimk->iv[1] = hex_to_u32 ((const u8 *) &iv_pos[ 8]); dpapimk->iv[1] = hex_to_u32 ((const u8 *) &iv_pos[ 8]);
@ -3682,7 +3682,7 @@ int md5crypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
salt_pos[0] = 0x0; salt_pos[0] = 0x0;
salt->salt_iter = strtoul ((const char *) (salt_pos - iterations_len), NULL, 10); salt->salt_iter = hc_strtoul ((const char *) (salt_pos - iterations_len), NULL, 10);
salt_pos += 1; salt_pos += 1;
@ -3741,7 +3741,7 @@ int md5apr1_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
salt_pos[0] = 0x0; salt_pos[0] = 0x0;
salt->salt_iter = strtoul ((const char *) (salt_pos - iterations_len), NULL, 10); salt->salt_iter = hc_strtoul ((const char *) (salt_pos - iterations_len), NULL, 10);
salt_pos += 1; salt_pos += 1;
@ -5732,7 +5732,7 @@ int sha512crypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYB
salt_pos[0] = 0x0; salt_pos[0] = 0x0;
salt->salt_iter = strtoul ((const char *) (salt_pos - iterations_len), NULL, 10); salt->salt_iter = hc_strtoul ((const char *) (salt_pos - iterations_len), NULL, 10);
salt_pos += 1; salt_pos += 1;
@ -6494,9 +6494,9 @@ int sha1aix_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
u8 salt_iter[3] = { iter_pos[0], iter_pos[1], 0 }; u8 salt_iter[3] = { iter_pos[0], iter_pos[1], 0 };
salt->salt_sign[0] = strtoul ((const char *) salt_iter, NULL, 10); salt->salt_sign[0] = hc_strtoul ((const char *) salt_iter, NULL, 10);
salt->salt_iter = (1u << strtoul ((const char *) salt_iter, NULL, 10)) - 1; salt->salt_iter = (1u << hc_strtoul ((const char *) salt_iter, NULL, 10)) - 1;
hash_pos++; hash_pos++;
@ -6543,9 +6543,9 @@ int sha256aix_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
char salt_iter[3] = { iter_pos[0], iter_pos[1], 0 }; char salt_iter[3] = { iter_pos[0], iter_pos[1], 0 };
salt->salt_sign[0] = strtoul ((const char *) salt_iter, NULL, 10); salt->salt_sign[0] = hc_strtoul ((const char *) salt_iter, NULL, 10);
salt->salt_iter = (1u << strtoul ((const char *) salt_iter, NULL, 10)) - 1; salt->salt_iter = (1u << hc_strtoul ((const char *) salt_iter, NULL, 10)) - 1;
hash_pos++; hash_pos++;
@ -6595,9 +6595,9 @@ int sha512aix_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
char salt_iter[3] = { iter_pos[0], iter_pos[1], 0 }; char salt_iter[3] = { iter_pos[0], iter_pos[1], 0 };
salt->salt_sign[0] = strtoul ((const char *) salt_iter, NULL, 10); salt->salt_sign[0] = hc_strtoul ((const char *) salt_iter, NULL, 10);
salt->salt_iter = (1u << strtoul ((const char *) salt_iter, NULL, 10)) - 1; salt->salt_iter = (1u << hc_strtoul ((const char *) salt_iter, NULL, 10)) - 1;
hash_pos++; hash_pos++;
@ -6659,7 +6659,7 @@ int agilekey_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
* pbkdf2 iterations * pbkdf2 iterations
*/ */
salt->salt_iter = strtoul ((const char *) iterations_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) iterations_pos, NULL, 10) - 1;
/** /**
* handle salt encoding * handle salt encoding
@ -6769,7 +6769,7 @@ int lastpass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
salt->salt_len = salt_len; salt->salt_len = salt_len;
salt->salt_iter = strtoul ((const char *) iterations_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) iterations_pos, NULL, 10) - 1;
if (is_valid_hex_string (hashbuf_pos, 32) == false) return (PARSER_HASH_ENCODING); if (is_valid_hex_string (hashbuf_pos, 32) == false) return (PARSER_HASH_ENCODING);
@ -6829,7 +6829,7 @@ int sha256crypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYB
salt_pos[0] = 0x0; salt_pos[0] = 0x0;
salt->salt_iter = strtoul ((const char *) (salt_pos - iterations_len), NULL, 10); salt->salt_iter = hc_strtoul ((const char *) (salt_pos - iterations_len), NULL, 10);
salt_pos += 1; salt_pos += 1;
@ -6932,7 +6932,7 @@ int sha512macos_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYB
salt->salt_buf[0] = pbkdf2_sha512->salt_buf[0]; salt->salt_buf[0] = pbkdf2_sha512->salt_buf[0];
salt->salt_iter = strtoul ((const char *) iter_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) iter_pos, NULL, 10) - 1;
return (PARSER_OK); return (PARSER_OK);
} }
@ -7067,7 +7067,7 @@ int sha512grub_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
salt->salt_len = salt_len; salt->salt_len = salt_len;
salt->salt_iter = strtoul ((const char *) iter_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) iter_pos, NULL, 10) - 1;
return (PARSER_OK); return (PARSER_OK);
} }
@ -7958,7 +7958,7 @@ int cloudkey_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
// iteration // iteration
salt->salt_iter = strtoul ((const char *) iteration_pos, NULL, 10) - 1; salt->salt_iter = hc_strtoul ((const char *) iteration_pos, NULL, 10) - 1;
// data // data
@ -8098,7 +8098,7 @@ int nsec3_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUS
// iteration // iteration
salt->salt_iter = strtoul ((const char *) iteration_pos, NULL, 10); salt->salt_iter = hc_strtoul ((const char *) iteration_pos, NULL, 10);
return (PARSER_OK); return (PARSER_OK);
} }
@ -8397,7 +8397,7 @@ int lotus8_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
tmp_iter_buf[10] = 0; tmp_iter_buf[10] = 0;
salt->salt_iter = strtoul ((const char *) tmp_iter_buf, NULL, 10); salt->salt_iter = hc_strtoul ((const char *) tmp_iter_buf, NULL, 10);
if (salt->salt_iter < 1) // well, the limit hopefully is much higher if (salt->salt_iter < 1) // well, the limit hopefully is much higher
{ {
@ -8779,7 +8779,7 @@ int scrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
N_pos++; N_pos++;
salt->scrypt_N = strtoul ((const char *) N_pos, NULL, 10); salt->scrypt_N = hc_strtoul ((const char *) N_pos, NULL, 10);
// r // r
@ -8789,7 +8789,7 @@ int scrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
r_pos++; r_pos++;
salt->scrypt_r = strtoul ((const char *) r_pos, NULL, 10); salt->scrypt_r = hc_strtoul ((const char *) r_pos, NULL, 10);
// p // p
@ -8799,7 +8799,7 @@ int scrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNU
p_pos++; p_pos++;
salt->scrypt_p = strtoul ((const char *) p_pos, NULL, 10); salt->scrypt_p = hc_strtoul ((const char *) p_pos, NULL, 10);
// salt // salt
@ -9089,10 +9089,10 @@ int office2007_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
if (osalt_len != 32) return (PARSER_SALT_LENGTH); if (osalt_len != 32) return (PARSER_SALT_LENGTH);
if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH); if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH);
const u32 version = strtoul ((const char *) version_pos, NULL, 10); const u32 version = hc_strtoul ((const char *) version_pos, NULL, 10);
const u32 verifierHashSize = strtoul ((const char *) verifierHashSize_pos, NULL, 10); const u32 verifierHashSize = hc_strtoul ((const char *) verifierHashSize_pos, NULL, 10);
const u32 keySize = strtoul ((const char *) keySize_pos, NULL, 10); const u32 keySize = hc_strtoul ((const char *) keySize_pos, NULL, 10);
const u32 saltSize = strtoul ((const char *) saltSize_pos, NULL, 10); const u32 saltSize = hc_strtoul ((const char *) saltSize_pos, NULL, 10);
if (version != 2007) return (PARSER_SALT_VALUE); if (version != 2007) return (PARSER_SALT_VALUE);
if (verifierHashSize != 20) return (PARSER_SALT_VALUE); if (verifierHashSize != 20) return (PARSER_SALT_VALUE);
@ -9239,10 +9239,10 @@ int office2010_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
if (osalt_len != 32) return (PARSER_SALT_LENGTH); if (osalt_len != 32) return (PARSER_SALT_LENGTH);
if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH); if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH);
const u32 version = strtoul ((const char *) version_pos, NULL, 10); const u32 version = hc_strtoul ((const char *) version_pos, NULL, 10);
const u32 spinCount = strtoul ((const char *) spinCount_pos, NULL, 10); const u32 spinCount = hc_strtoul ((const char *) spinCount_pos, NULL, 10);
const u32 keySize = strtoul ((const char *) keySize_pos, NULL, 10); const u32 keySize = hc_strtoul ((const char *) keySize_pos, NULL, 10);
const u32 saltSize = strtoul ((const char *) saltSize_pos, NULL, 10); const u32 saltSize = hc_strtoul ((const char *) saltSize_pos, NULL, 10);
if (version != 2010) return (PARSER_SALT_VALUE); if (version != 2010) return (PARSER_SALT_VALUE);
if (spinCount != 100000) return (PARSER_SALT_VALUE); if (spinCount != 100000) return (PARSER_SALT_VALUE);
@ -9393,10 +9393,10 @@ int office2013_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
if (osalt_len != 32) return (PARSER_SALT_LENGTH); if (osalt_len != 32) return (PARSER_SALT_LENGTH);
if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH); if (encryptedVerifier_len != 32) return (PARSER_SALT_LENGTH);
const u32 version = strtoul ((const char *) version_pos, NULL, 10); const u32 version = hc_strtoul ((const char *) version_pos, NULL, 10);
const u32 spinCount = strtoul ((const char *) spinCount_pos, NULL, 10); const u32 spinCount = hc_strtoul ((const char *) spinCount_pos, NULL, 10);
const u32 keySize = strtoul ((const char *) keySize_pos, NULL, 10); const u32 keySize = hc_strtoul ((const char *) keySize_pos, NULL, 10);
const u32 saltSize = strtoul ((const char *) saltSize_pos, NULL, 10); const u32 saltSize = hc_strtoul ((const char *) saltSize_pos, NULL, 10);
if (version != 2013) return (PARSER_SALT_VALUE); if (version != 2013) return (PARSER_SALT_VALUE);
if (spinCount != 100000) return (PARSER_SALT_VALUE); if (spinCount != 100000) return (PARSER_SALT_VALUE);
@ -10311,7 +10311,7 @@ int saph_sha1_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
u8 *iter_pos = input_buf + 10; u8 *iter_pos = input_buf + 10;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) if (iter < 1)
{ {
@ -11255,9 +11255,9 @@ int pdf17l8_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
if ((enc_md != 0) && (enc_md != 1)) return (PARSER_SALT_VALUE); if ((enc_md != 0) && (enc_md != 1)) return (PARSER_SALT_VALUE);
const u32 id_len = strtoul ((const char *) id_len_pos, NULL, 10); const u32 id_len = hc_strtoul ((const char *) id_len_pos, NULL, 10);
const u32 u_len = strtoul ((const char *) u_len_pos, NULL, 10); const u32 u_len = hc_strtoul ((const char *) u_len_pos, NULL, 10);
const u32 o_len = strtoul ((const char *) o_len_pos, NULL, 10); const u32 o_len = hc_strtoul ((const char *) o_len_pos, NULL, 10);
if (V_len > 6) return (PARSER_SALT_LENGTH); if (V_len > 6) return (PARSER_SALT_LENGTH);
if (R_len > 6) return (PARSER_SALT_LENGTH); if (R_len > 6) return (PARSER_SALT_LENGTH);
@ -11321,7 +11321,7 @@ int pbkdf2_sha256_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
u8 *iter_pos = input_buf + 7; u8 *iter_pos = input_buf + 7;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
if (iter > 999999) return (PARSER_SALT_ITERATION); if (iter > 999999) return (PARSER_SALT_ITERATION);
@ -11644,10 +11644,10 @@ int bitcoin_wallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, M
u32 public_key_buf_len = input_len - 1 - 7 - 1 - cry_master_len_len - 1 - cry_master_buf_len - 1 - cry_salt_len_len - 1 - cry_salt_buf_len - 1 - cry_rounds_len - 1 - ckey_len_len - 1 - ckey_buf_len - 1 - public_key_len_len - 1; u32 public_key_buf_len = input_len - 1 - 7 - 1 - cry_master_len_len - 1 - cry_master_buf_len - 1 - cry_salt_len_len - 1 - cry_salt_buf_len - 1 - cry_rounds_len - 1 - ckey_len_len - 1 - ckey_buf_len - 1 - public_key_len_len - 1;
const u32 cry_master_len = strtoul ((const char *) cry_master_len_pos, NULL, 10); const u32 cry_master_len = hc_strtoul ((const char *) cry_master_len_pos, NULL, 10);
const u32 cry_salt_len = strtoul ((const char *) cry_salt_len_pos, NULL, 10); const u32 cry_salt_len = hc_strtoul ((const char *) cry_salt_len_pos, NULL, 10);
const u32 ckey_len = strtoul ((const char *) ckey_len_pos, NULL, 10); const u32 ckey_len = hc_strtoul ((const char *) ckey_len_pos, NULL, 10);
const u32 public_key_len = strtoul ((const char *) public_key_len_pos, NULL, 10); const u32 public_key_len = hc_strtoul ((const char *) public_key_len_pos, NULL, 10);
if (cry_master_buf_len != cry_master_len) return (PARSER_SALT_VALUE); if (cry_master_buf_len != cry_master_len) return (PARSER_SALT_VALUE);
if (cry_salt_buf_len != cry_salt_len) return (PARSER_SALT_VALUE); if (cry_salt_buf_len != cry_salt_len) return (PARSER_SALT_VALUE);
@ -11694,7 +11694,7 @@ int bitcoin_wallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, M
if (cry_rounds_len >= 7) return (PARSER_SALT_VALUE); if (cry_rounds_len >= 7) return (PARSER_SALT_VALUE);
const u32 cry_rounds = strtoul ((const char *) cry_rounds_pos, NULL, 10); const u32 cry_rounds = hc_strtoul ((const char *) cry_rounds_pos, NULL, 10);
salt->salt_iter = cry_rounds - 1; salt->salt_iter = cry_rounds - 1;
@ -11737,7 +11737,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
URI_client_pos[0] = 0; URI_client_pos[0] = 0;
URI_client_pos++; URI_client_pos++;
u32 URI_server_len = strlen ((const char *) URI_server_pos); size_t URI_server_len = strlen ((const char *) URI_server_pos);
if (URI_server_len > 512) return (PARSER_SALT_LENGTH); if (URI_server_len > 512) return (PARSER_SALT_LENGTH);
@ -11750,7 +11750,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
user_pos[0] = 0; user_pos[0] = 0;
user_pos++; user_pos++;
u32 URI_client_len = strlen ((const char *) URI_client_pos); size_t URI_client_len = strlen ((const char *) URI_client_pos);
if (URI_client_len > 512) return (PARSER_SALT_LENGTH); if (URI_client_len > 512) return (PARSER_SALT_LENGTH);
@ -11763,7 +11763,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
realm_pos[0] = 0; realm_pos[0] = 0;
realm_pos++; realm_pos++;
u32 user_len = strlen ((const char *) user_pos); size_t user_len = strlen ((const char *) user_pos);
if (user_len > 116) return (PARSER_SALT_LENGTH); if (user_len > 116) return (PARSER_SALT_LENGTH);
@ -11776,7 +11776,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
method_pos[0] = 0; method_pos[0] = 0;
method_pos++; method_pos++;
u32 realm_len = strlen ((const char *) realm_pos); size_t realm_len = strlen ((const char *) realm_pos);
if (realm_len > 116) return (PARSER_SALT_LENGTH); if (realm_len > 116) return (PARSER_SALT_LENGTH);
@ -11789,7 +11789,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
URI_prefix_pos[0] = 0; URI_prefix_pos[0] = 0;
URI_prefix_pos++; URI_prefix_pos++;
u32 method_len = strlen ((const char *) method_pos); size_t method_len = strlen ((const char *) method_pos);
if (method_len > 246) return (PARSER_SALT_LENGTH); if (method_len > 246) return (PARSER_SALT_LENGTH);
@ -11802,7 +11802,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
URI_resource_pos[0] = 0; URI_resource_pos[0] = 0;
URI_resource_pos++; URI_resource_pos++;
u32 URI_prefix_len = strlen ((const char *) URI_prefix_pos); size_t URI_prefix_len = strlen ((const char *) URI_prefix_pos);
if (URI_prefix_len > 245) return (PARSER_SALT_LENGTH); if (URI_prefix_len > 245) return (PARSER_SALT_LENGTH);
@ -11815,7 +11815,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
URI_suffix_pos[0] = 0; URI_suffix_pos[0] = 0;
URI_suffix_pos++; URI_suffix_pos++;
u32 URI_resource_len = strlen ((const char *) URI_resource_pos); size_t URI_resource_len = strlen ((const char *) URI_resource_pos);
if (URI_resource_len < 1 || URI_resource_len > 246) return (PARSER_SALT_LENGTH); if (URI_resource_len < 1 || URI_resource_len > 246) return (PARSER_SALT_LENGTH);
@ -11828,7 +11828,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
nonce_pos[0] = 0; nonce_pos[0] = 0;
nonce_pos++; nonce_pos++;
u32 URI_suffix_len = strlen ((const char *) URI_suffix_pos); size_t URI_suffix_len = strlen ((const char *) URI_suffix_pos);
if (URI_suffix_len > 245) return (PARSER_SALT_LENGTH); if (URI_suffix_len > 245) return (PARSER_SALT_LENGTH);
@ -11841,7 +11841,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
nonce_client_pos[0] = 0; nonce_client_pos[0] = 0;
nonce_client_pos++; nonce_client_pos++;
u32 nonce_len = strlen ((const char *) nonce_pos); size_t nonce_len = strlen ((const char *) nonce_pos);
if (nonce_len < 1 || nonce_len > 50) return (PARSER_SALT_LENGTH); if (nonce_len < 1 || nonce_len > 50) return (PARSER_SALT_LENGTH);
@ -11854,7 +11854,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
nonce_count_pos[0] = 0; nonce_count_pos[0] = 0;
nonce_count_pos++; nonce_count_pos++;
u32 nonce_client_len = strlen ((const char *) nonce_client_pos); size_t nonce_client_len = strlen ((const char *) nonce_client_pos);
if (nonce_client_len > 50) return (PARSER_SALT_LENGTH); if (nonce_client_len > 50) return (PARSER_SALT_LENGTH);
@ -11867,7 +11867,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
qop_pos[0] = 0; qop_pos[0] = 0;
qop_pos++; qop_pos++;
u32 nonce_count_len = strlen ((const char *) nonce_count_pos); size_t nonce_count_len = strlen ((const char *) nonce_count_pos);
if (nonce_count_len > 50) return (PARSER_SALT_LENGTH); if (nonce_count_len > 50) return (PARSER_SALT_LENGTH);
@ -11880,7 +11880,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
directive_pos[0] = 0; directive_pos[0] = 0;
directive_pos++; directive_pos++;
u32 qop_len = strlen ((const char *) qop_pos); size_t qop_len = strlen ((const char *) qop_pos);
if (qop_len > 50) return (PARSER_SALT_LENGTH); if (qop_len > 50) return (PARSER_SALT_LENGTH);
@ -11893,7 +11893,7 @@ int sip_auth_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
digest_pos[0] = 0; digest_pos[0] = 0;
digest_pos++; digest_pos++;
u32 directive_len = strlen ((const char *) directive_pos); size_t directive_len = strlen ((const char *) directive_pos);
if (directive_len != 3) return (PARSER_SALT_LENGTH); if (directive_len != 3) return (PARSER_SALT_LENGTH);
@ -12239,13 +12239,13 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
data_buf_len = input_len - 1 - 2 - 1 - data_type_len - 1 - NumCyclesPower_len - 1 - salt_len_len - 1 - salt_buf_len - 1 - iv_len_len - 1 - iv_buf_len - 1 - crc_buf_len - 1 - data_len_len - 1 - unpack_size_len - 1; data_buf_len = input_len - 1 - 2 - 1 - data_type_len - 1 - NumCyclesPower_len - 1 - salt_len_len - 1 - salt_buf_len - 1 - iv_len_len - 1 - iv_buf_len - 1 - crc_buf_len - 1 - data_len_len - 1 - unpack_size_len - 1;
} }
const u32 iter = strtoul ((const char *) NumCyclesPower_pos, NULL, 10); const u32 iter = hc_strtoul ((const char *) NumCyclesPower_pos, NULL, 10);
const u32 crc = strtoul ((const char *) crc_buf_pos, NULL, 10); const u32 crc = hc_strtoul ((const char *) crc_buf_pos, NULL, 10);
const u32 data_type = strtoul ((const char *) data_type_pos, NULL, 10); const u32 data_type = hc_strtoul ((const char *) data_type_pos, NULL, 10);
const u32 salt_len = strtoul ((const char *) salt_len_pos, NULL, 10); const u32 salt_len = hc_strtoul ((const char *) salt_len_pos, NULL, 10);
const u32 iv_len = strtoul ((const char *) iv_len_pos, NULL, 10); const u32 iv_len = hc_strtoul ((const char *) iv_len_pos, NULL, 10);
const u32 unpack_size = strtoul ((const char *) unpack_size_pos, NULL, 10); const u32 unpack_size = hc_strtoul ((const char *) unpack_size_pos, NULL, 10);
const u32 data_len = strtoul ((const char *) data_len_pos, NULL, 10); const u32 data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
// if neither uncompressed nor truncated, then we need the length for crc and coder attributes // if neither uncompressed nor truncated, then we need the length for crc and coder attributes
@ -12259,7 +12259,7 @@ int seven_zip_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_
coder_attributes_len = input_len - 1 - 2 - 1 - data_type_len - 1 - NumCyclesPower_len - 1 - salt_len_len - 1 - salt_buf_len - 1 - iv_len_len - 1 - iv_buf_len - 1 - crc_buf_len - 1 - data_len_len - 1 - unpack_size_len - 1 - data_buf_len - 1 - crc_len_len - 1; coder_attributes_len = input_len - 1 - 2 - 1 - data_type_len - 1 - NumCyclesPower_len - 1 - salt_len_len - 1 - salt_buf_len - 1 - iv_len_len - 1 - iv_buf_len - 1 - crc_buf_len - 1 - data_len_len - 1 - unpack_size_len - 1 - data_buf_len - 1 - crc_len_len - 1;
crc_len = strtoul ((const char *) crc_len_pos, NULL, 10); crc_len = hc_strtoul ((const char *) crc_len_pos, NULL, 10);
} }
/** /**
@ -12468,7 +12468,7 @@ int pbkdf2_md5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
u8 *iter_pos = input_buf + 4; u8 *iter_pos = input_buf + 4;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
if (iter > 999999) return (PARSER_SALT_ITERATION); if (iter > 999999) return (PARSER_SALT_ITERATION);
@ -12552,7 +12552,7 @@ int pbkdf2_sha1_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYB
u8 *iter_pos = input_buf + 5; u8 *iter_pos = input_buf + 5;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
if (iter > 999999) return (PARSER_SALT_ITERATION); if (iter > 999999) return (PARSER_SALT_ITERATION);
@ -12641,7 +12641,7 @@ int pbkdf2_sha512_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
u8 *iter_pos = input_buf + 7; u8 *iter_pos = input_buf + 7;
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
if (iter > 999999) return (PARSER_SALT_ITERATION); if (iter > 999999) return (PARSER_SALT_ITERATION);
@ -12968,9 +12968,9 @@ int rar5_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
u8 *iv = param3_pos; u8 *iv = param3_pos;
u8 *pswcheck = param5_pos; u8 *pswcheck = param5_pos;
const u32 salt_len = strtoul ((const char *) param0_pos, NULL, 10); const u32 salt_len = hc_strtoul ((const char *) param0_pos, NULL, 10);
const u32 iterations = strtoul ((const char *) param2_pos, NULL, 10); const u32 iterations = hc_strtoul ((const char *) param2_pos, NULL, 10);
const u32 pswcheck_len = strtoul ((const char *) param4_pos, NULL, 10); const u32 pswcheck_len = hc_strtoul ((const char *) param4_pos, NULL, 10);
/** /**
* verify some data * verify some data
@ -13160,7 +13160,7 @@ int axcrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
u8 *data_pos; u8 *data_pos;
salt->salt_iter = strtoul ((const char *) wrapping_rounds_pos, NULL, 10); salt->salt_iter = hc_strtoul ((const char *) wrapping_rounds_pos, NULL, 10);
salt_pos = (u8 *) strchr ((const char *) wrapping_rounds_pos, '*'); salt_pos = (u8 *) strchr ((const char *) wrapping_rounds_pos, '*');
@ -13268,7 +13268,7 @@ int keepass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
version_pos = input_buf + 8 + 1 + 1; version_pos = input_buf + 8 + 1 + 1;
keepass->version = strtoul ((const char *) version_pos, NULL, 10); keepass->version = hc_strtoul ((const char *) version_pos, NULL, 10);
rounds_pos = (u8 *) strchr ((const char *) version_pos, '*'); rounds_pos = (u8 *) strchr ((const char *) version_pos, '*');
@ -13276,7 +13276,7 @@ int keepass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
rounds_pos++; rounds_pos++;
salt->salt_iter = strtoul ((const char *) rounds_pos, NULL, 10); salt->salt_iter = hc_strtoul ((const char *) rounds_pos, NULL, 10);
algorithm_pos = (u8 *) strchr ((const char *) rounds_pos, '*'); algorithm_pos = (u8 *) strchr ((const char *) rounds_pos, '*');
@ -13284,7 +13284,7 @@ int keepass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
algorithm_pos++; algorithm_pos++;
keepass->algorithm = strtoul ((const char *) algorithm_pos, NULL, 10); keepass->algorithm = hc_strtoul ((const char *) algorithm_pos, NULL, 10);
final_random_seed_pos = (u8 *) strchr ((const char *) algorithm_pos, '*'); final_random_seed_pos = (u8 *) strchr ((const char *) algorithm_pos, '*');
@ -13415,7 +13415,7 @@ int keepass_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
inline_flag_pos++; inline_flag_pos++;
u32 inline_flag = strtoul ((const char *) inline_flag_pos, NULL, 10); u32 inline_flag = hc_strtoul ((const char *) inline_flag_pos, NULL, 10);
if (inline_flag != 1) return (PARSER_SALT_LENGTH); if (inline_flag != 1) return (PARSER_SALT_LENGTH);
@ -13744,7 +13744,7 @@ int mywallet_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_U
if (data_buf_len % 16) return (PARSER_HASH_LENGTH); if (data_buf_len % 16) return (PARSER_HASH_LENGTH);
u32 data_len = strtoul ((const char *) data_len_pos, NULL, 10); u32 data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
if ((data_len * 2) != data_buf_len) return (PARSER_HASH_LENGTH); if ((data_len * 2) != data_buf_len) return (PARSER_HASH_LENGTH);
@ -13838,11 +13838,11 @@ int mywalletv2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE
if (data_buf_len % 16) return (PARSER_HASH_LENGTH); if (data_buf_len % 16) return (PARSER_HASH_LENGTH);
u32 data_len = strtoul ((const char *) data_len_pos, NULL, 10); u32 data_len = hc_strtoul ((const char *) data_len_pos, NULL, 10);
if ((data_len * 2) != data_buf_len) return (PARSER_HASH_LENGTH); if ((data_len * 2) != data_buf_len) return (PARSER_HASH_LENGTH);
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
/** /**
* salt * salt
@ -13943,7 +13943,7 @@ int ms_drsr_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UN
salt->salt_len = salt_len / 2; salt->salt_len = salt_len / 2;
salt->salt_iter = strtoul ((const char *) iter_pos, NULL, 10) - 1ul; salt->salt_iter = hc_strtoul ((const char *) iter_pos, NULL, 10) - 1ul;
/** /**
* digest buf * digest buf
@ -14133,9 +14133,9 @@ int zip2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
u32 param7_len = param8_pos - param7_pos; u32 param7_len = param8_pos - param7_pos;
const u32 type = strtoul ((const char *) param0_pos, NULL, 10); const u32 type = hc_strtoul ((const char *) param0_pos, NULL, 10);
const u32 mode = strtoul ((const char *) param1_pos, NULL, 10); const u32 mode = hc_strtoul ((const char *) param1_pos, NULL, 10);
const u32 magic = strtoul ((const char *) param2_pos, NULL, 10); const u32 magic = hc_strtoul ((const char *) param2_pos, NULL, 10);
u8 *salt_buf = param3_pos; u8 *salt_buf = param3_pos;
@ -14146,7 +14146,7 @@ int zip2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MAYBE_UNUSE
return (PARSER_SALT_VALUE); return (PARSER_SALT_VALUE);
} }
const u32 compress_length = strtoul ((const char *) param5_pos, NULL, 10); const u32 compress_length = hc_strtoul ((const char *) param5_pos, NULL, 10);
u8 *data_buf = param6_pos; u8 *data_buf = param6_pos;
u8 *auth = param7_pos; u8 *auth = param7_pos;
@ -14893,7 +14893,7 @@ int itunes_backup_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
if ((version_len != 1) && (version_len != 2)) return (PARSER_SEPARATOR_UNMATCHED); if ((version_len != 1) && (version_len != 2)) return (PARSER_SEPARATOR_UNMATCHED);
u32 version = strtoul ((const char *) version_pos, NULL, 10); u32 version = hc_strtoul ((const char *) version_pos, NULL, 10);
if (hash_mode == 14700) if (hash_mode == 14700)
{ {
@ -14909,7 +14909,7 @@ int itunes_backup_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
if (iter_len < 1) return (PARSER_SALT_ITERATION); if (iter_len < 1) return (PARSER_SALT_ITERATION);
if (iter_len > 6) return (PARSER_SALT_ITERATION); if (iter_len > 6) return (PARSER_SALT_ITERATION);
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
@ -14930,7 +14930,7 @@ int itunes_backup_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf, MA
if (dpic_len < 1) return (PARSER_SALT_ITERATION); if (dpic_len < 1) return (PARSER_SALT_ITERATION);
if (dpic_len > 9) return (PARSER_SALT_ITERATION); if (dpic_len > 9) return (PARSER_SALT_ITERATION);
dpic = strtoul ((const char *) dpic_pos, NULL, 10); dpic = hc_strtoul ((const char *) dpic_pos, NULL, 10);
if (dpic < 1) return (PARSER_SALT_ITERATION); if (dpic < 1) return (PARSER_SALT_ITERATION);
@ -15275,7 +15275,7 @@ int netbsd_sha1crypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf,
* verify data * verify data
*/ */
u32 iter = strtoul ((const char *) iter_pos, NULL, 10); u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 99) return (PARSER_SALT_ITERATION); // (actually: CRYPT_SHA1_ITERATIONS should be 24680 or more) if (iter < 99) return (PARSER_SALT_ITERATION); // (actually: CRYPT_SHA1_ITERATIONS should be 24680 or more)
@ -15607,7 +15607,7 @@ int ethereum_pbkdf2_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf,
* verify some data * verify some data
*/ */
const u32 iter = strtoul ((const char *) iter_pos, NULL, 10); const u32 iter = hc_strtoul ((const char *) iter_pos, NULL, 10);
if (iter < 1) return (PARSER_SALT_ITERATION); if (iter < 1) return (PARSER_SALT_ITERATION);
@ -15747,9 +15747,9 @@ int ethereum_scrypt_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf,
* verify some data * verify some data
*/ */
const u32 scrypt_N = strtoul ((const char *) scryptN_pos, NULL, 10); const u32 scrypt_N = hc_strtoul ((const char *) scryptN_pos, NULL, 10);
const u32 scrypt_r = strtoul ((const char *) scryptr_pos, NULL, 10); const u32 scrypt_r = hc_strtoul ((const char *) scryptr_pos, NULL, 10);
const u32 scrypt_p = strtoul ((const char *) scryptp_pos, NULL, 10); const u32 scrypt_p = hc_strtoul ((const char *) scryptp_pos, NULL, 10);
if (salt_len != 64) return (PARSER_SALT_LENGTH); if (salt_len != 64) return (PARSER_SALT_LENGTH);
if (ciphertext_len != 64) return (PARSER_SALT_LENGTH); if (ciphertext_len != 64) return (PARSER_SALT_LENGTH);
@ -16000,8 +16000,8 @@ int apple_secure_notes_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_bu
* verify some data * verify some data
*/ */
const u32 Z_PK = strtoul ((const char *) Z_PK_pos, NULL, 10); const u32 Z_PK = hc_strtoul ((const char *) Z_PK_pos, NULL, 10);
const u32 ZCRYPTOITERATIONCOUNT = strtoul ((const char *) ZCRYPTOITERATIONCOUNT_pos, NULL, 10); const u32 ZCRYPTOITERATIONCOUNT = hc_strtoul ((const char *) ZCRYPTOITERATIONCOUNT_pos, NULL, 10);
if (ZCRYPTOSALT_len != 32) return (PARSER_SALT_ENCODING); if (ZCRYPTOSALT_len != 32) return (PARSER_SALT_ENCODING);
if (ZCRYPTOWRAPPEDKEY_len != 48) return (PARSER_SALT_ENCODING); if (ZCRYPTOWRAPPEDKEY_len != 48) return (PARSER_SALT_ENCODING);
@ -16402,7 +16402,7 @@ int electrum_wallet13_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf
* verify some data * verify some data
*/ */
const u32 salt_type = strtoul ((const char *) salt_type_pos, NULL, 10); const u32 salt_type = hc_strtoul ((const char *) salt_type_pos, NULL, 10);
if ((salt_type == 1) || (salt_type == 2) || (salt_type == 3)) if ((salt_type == 1) || (salt_type == 2) || (salt_type == 3))
{ {
@ -16471,7 +16471,7 @@ int electrum_wallet13_parse_hash (u8 *input_buf, u32 input_len, hash_t *hash_buf
* hook functions * hook functions
*/ */
void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u32 pws_cnt) void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf, const u32 salt_pos, const u64 pws_cnt)
{ {
seven_zip_hook_t *hook_items = (seven_zip_hook_t *) device_param->hooks_buf; seven_zip_hook_t *hook_items = (seven_zip_hook_t *) device_param->hooks_buf;
@ -16482,7 +16482,7 @@ void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf,
u32 *data_buf = seven_zip->data_buf; u32 *data_buf = seven_zip->data_buf;
u32 unpack_size = seven_zip->unpack_size; u32 unpack_size = seven_zip->unpack_size;
for (u32 pw_pos = 0; pw_pos < pws_cnt; pw_pos++) for (u64 pw_pos = 0; pw_pos < pws_cnt; pw_pos++)
{ {
// this hook data needs to be updated (the "hook_success" variable): // this hook data needs to be updated (the "hook_success" variable):
@ -26010,12 +26010,12 @@ u32 hashconfig_get_kernel_threads (hashcat_ctx_t *hashcat_ctx, const hc_device_p
if (user_options->workload_profile == 4) if (user_options->workload_profile == 4)
{ {
kernel_threads = device_param->device_maxworkgroup_size; kernel_threads = (u32) device_param->device_maxworkgroup_size;
} }
// and (2) an opencl device can force an lower value (limited resources on device) // and (2) an opencl device can force an lower value (limited resources on device)
kernel_threads = MIN (kernel_threads, device_param->device_maxworkgroup_size); kernel_threads = MIN (kernel_threads, (u32) device_param->device_maxworkgroup_size);
// and (3) if an OpenCL device allows a very high thread count (for example 1024 on nvidia), // and (3) if an OpenCL device allows a very high thread count (for example 1024 on nvidia),
// the host memory required is 32 times as high with 32 (It jumps from 128MB to 4GB device memory requirement). // the host memory required is 32 times as high with 32 (It jumps from 128MB to 4GB device memory requirement).

20
src/main.c
Unescape View File

@ -25,13 +25,13 @@
int _dowildcard = -1; int _dowildcard = -1;
#endif #endif
static void main_log_clear_line (MAYBE_UNUSED const int prev_len, MAYBE_UNUSED FILE *fp) static void main_log_clear_line (MAYBE_UNUSED const size_t prev_len, MAYBE_UNUSED FILE *fp)
{ {
#if defined (_WIN) #if defined (_WIN)
fputc ('\r', fp); fputc ('\r', fp);
for (int i = 0; i < prev_len; i++) for (size_t i = 0; i < prev_len; i++)
{ {
fputc (' ', fp); fputc (' ', fp);
} }
@ -49,13 +49,13 @@ static void main_log (hashcat_ctx_t *hashcat_ctx, FILE *fp, const int loglevel)
{ {
event_ctx_t *event_ctx = hashcat_ctx->event_ctx; event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
const char *msg_buf = event_ctx->msg_buf; const char *msg_buf = event_ctx->msg_buf;
const int msg_len = event_ctx->msg_len; const size_t msg_len = event_ctx->msg_len;
const bool msg_newline = event_ctx->msg_newline; const bool msg_newline = event_ctx->msg_newline;
// handle last_len // handle last_len
const int prev_len = event_ctx->prev_len; const size_t prev_len = event_ctx->prev_len;
if (prev_len) if (prev_len)
{ {
@ -847,16 +847,16 @@ static void main_hashlist_parse_hash (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, M
const hashlist_parse_t *hashlist_parse = (const hashlist_parse_t *) buf; const hashlist_parse_t *hashlist_parse = (const hashlist_parse_t *) buf;
const u32 hashes_cnt = hashlist_parse->hashes_cnt; const u64 hashes_cnt = hashlist_parse->hashes_cnt;
const u32 hashes_avail = hashlist_parse->hashes_avail; const u64 hashes_avail = hashlist_parse->hashes_avail;
if (hashes_cnt < hashes_avail) if (hashes_cnt < hashes_avail)
{ {
event_log_info_nn (hashcat_ctx, "Parsing Hashes: %u/%u (%0.2f%%)...", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100.0); event_log_info_nn (hashcat_ctx, "Parsing Hashes: %" PRIu64 "/%" PRIu64 " (%0.2f%%)...", hashes_cnt, hashes_avail, ((double) hashes_cnt / hashes_avail) * 100.0);
} }
else else
{ {
event_log_info_nn (hashcat_ctx, "Parsed Hashes: %u/%u (%0.2f%%)", hashes_cnt, hashes_avail, 100.0); event_log_info_nn (hashcat_ctx, "Parsed Hashes: %" PRIu64 "/%" PRIu64 " (%0.2f%%)", hashes_cnt, hashes_avail, 100.0);
} }
} }

12
src/monitor.c
Unescape View File

@ -99,10 +99,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
// timer // timer
time_t last_temp_check_time;
time (&last_temp_check_time);
u32 slowdown_warnings = 0; u32 slowdown_warnings = 0;
u32 performance_warnings = 0; u32 performance_warnings = 0;
@ -151,14 +147,6 @@ static int monitor (hashcat_ctx_t *hashcat_ctx)
{ {
hc_thread_mutex_lock (status_ctx->mux_hwmon); hc_thread_mutex_lock (status_ctx->mux_hwmon);
time_t temp_check_time;
time (&temp_check_time);
u32 Ta = temp_check_time - last_temp_check_time; // set Ta = sleep_time; is not good enough (see --remove etc)
if (Ta == 0) Ta = 1;
for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++) for (u32 device_id = 0; device_id < opencl_ctx->devices_cnt; device_id++)
{ {
hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id]; hc_device_param_t *device_param = &opencl_ctx->devices_param[device_id];

30
src/mpsp.c
Unescape View File

@ -26,7 +26,13 @@ static int sp_comp_val (const void *p1, const void *p2)
const hcstat_table_t *b1 = (const hcstat_table_t *) p1; const hcstat_table_t *b1 = (const hcstat_table_t *) p1;
const hcstat_table_t *b2 = (const hcstat_table_t *) p2; const hcstat_table_t *b2 = (const hcstat_table_t *) p2;
return b2->val - b1->val; const u64 v1 = b1->val;
const u64 v2 = b2->val;
if (v1 < v2) return 1;
if (v1 > v2) return -1;
return 0;
} }
static void mp_css_split_cnt (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_orig, u32 css_cnt_lr[2]) static void mp_css_split_cnt (hashcat_ctx_t *hashcat_ctx, const u32 css_cnt_orig, u32 css_cnt_lr[2])
@ -1113,9 +1119,9 @@ u32 mp_get_length (const char *mask)
{ {
u32 len = 0; u32 len = 0;
u32 mask_len = strlen (mask); const size_t mask_len = strlen (mask);
for (u32 i = 0; i < mask_len; i++) for (size_t i = 0; i < mask_len; i++)
{ {
if (mask[i] == '?') i++; if (mask[i] == '?') i++;
@ -1125,13 +1131,13 @@ u32 mp_get_length (const char *mask)
return len; return len;
} }
static char *mask_ctx_parse_maskfile_find_mask (char *line_buf, int line_len) static char *mask_ctx_parse_maskfile_find_mask (char *line_buf, const size_t line_len)
{ {
char *mask_buf = line_buf; char *mask_buf = line_buf;
bool escaped = false; bool escaped = false;
for (int i = 0; i < line_len; i++) for (size_t i = 0; i < line_len; i++)
{ {
if (escaped == true) if (escaped == true)
{ {
@ -1449,7 +1455,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
while (!feof (mask_fp)) while (!feof (mask_fp))
{ {
const int line_len = fgetl (mask_fp, line_buf); const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -1542,7 +1548,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
while (!feof (mask_fp)) while (!feof (mask_fp))
{ {
const int line_len = fgetl (mask_fp, line_buf); const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -1616,7 +1622,7 @@ int mask_ctx_init (hashcat_ctx_t *hashcat_ctx)
while (!feof (mask_fp)) while (!feof (mask_fp))
{ {
const int line_len = fgetl (mask_fp, line_buf); const size_t line_len = fgetl (mask_fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -1713,15 +1719,15 @@ int mask_ctx_parse_maskfile (hashcat_ctx_t *hashcat_ctx)
mfs_buf[3].mf_len = 0; mfs_buf[3].mf_len = 0;
mfs_buf[4].mf_len = 0; mfs_buf[4].mf_len = 0;
int mfs_cnt = 0; size_t mfs_cnt = 0;
char *mask_buf = mask_ctx->mask; char *mask_buf = mask_ctx->mask;
const int mask_len = strlen (mask_buf); const size_t mask_len = strlen (mask_buf);
bool escaped = false; bool escaped = false;
for (int i = 0; i < mask_len; i++) for (size_t i = 0; i < mask_len; i++)
{ {
mf_t *mf = mfs_buf + mfs_cnt; mf_t *mf = mfs_buf + mfs_cnt;
@ -1775,7 +1781,7 @@ int mask_ctx_parse_maskfile (hashcat_ctx_t *hashcat_ctx)
mp_reset_usr (mask_ctx->mp_usr, 2); mp_reset_usr (mask_ctx->mp_usr, 2);
mp_reset_usr (mask_ctx->mp_usr, 3); mp_reset_usr (mask_ctx->mp_usr, 3);
for (int i = 0; i < mfs_cnt; i++) for (size_t i = 0; i < mfs_cnt; i++)
{ {
switch (i) switch (i)
{ {

90
src/opencl.c
Unescape View File

@ -123,7 +123,7 @@ static int setup_opencl_platforms_filter (hashcat_ctx_t *hashcat_ctx, const char
do do
{ {
int platform = strtol (next, NULL, 10); int platform = (int) strtol (next, NULL, 10);
if (platform < 1 || platform > 32) if (platform < 1 || platform > 32)
{ {
@ -166,7 +166,7 @@ static int setup_devices_filter (hashcat_ctx_t *hashcat_ctx, const char *opencl_
do do
{ {
int device_id = strtol (next, NULL, 10); int device_id = (int) strtol (next, NULL, 10);
if (device_id < 1 || device_id > 32) if (device_id < 1 || device_id > 32)
{ {
@ -209,7 +209,7 @@ static int setup_device_types_filter (hashcat_ctx_t *hashcat_ctx, const char *op
do do
{ {
int device_type = strtol (next, NULL, 10); int device_type = (int) strtol (next, NULL, 10);
if (device_type < 1 || device_type > 3) if (device_type < 1 || device_type > 3)
{ {
@ -281,7 +281,7 @@ static int read_kernel_binary (hashcat_ctx_t *hashcat_ctx, const char *kernel_fi
time_t tlog = time (NULL); time_t tlog = time (NULL);
const int extra_len = snprintf (buf + st.st_size, EXTRASZ, "\n//%lu\n", tlog); const int extra_len = snprintf (buf + st.st_size, EXTRASZ, "\n//%u\n", (u32) tlog);
st.st_size += extra_len; st.st_size += extra_len;
} }
@ -830,7 +830,7 @@ int hc_clCreateBuffer (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_mem_fl
return 0; return 0;
} }
int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint count, const char **strings, const size_t *lengths, cl_program *program) int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint count, char **strings, const size_t *lengths, cl_program *program)
{ {
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
@ -838,7 +838,7 @@ int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context
cl_int CL_err; cl_int CL_err;
*program = ocl->clCreateProgramWithSource (context, count, strings, lengths, &CL_err); *program = ocl->clCreateProgramWithSource (context, count, (const char **) strings, lengths, &CL_err);
if (CL_err != CL_SUCCESS) if (CL_err != CL_SUCCESS)
{ {
@ -850,7 +850,7 @@ int hc_clCreateProgramWithSource (hashcat_ctx_t *hashcat_ctx, cl_context context
return 0; return 0;
} }
int hc_clCreateProgramWithBinary (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const size_t *lengths, const unsigned char **binaries, cl_int *binary_status, cl_program *program) int hc_clCreateProgramWithBinary (hashcat_ctx_t *hashcat_ctx, cl_context context, cl_uint num_devices, const cl_device_id *device_list, const size_t *lengths, unsigned char **binaries, cl_int *binary_status, cl_program *program)
{ {
opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;
@ -858,7 +858,7 @@ int hc_clCreateProgramWithBinary (hashcat_ctx_t *hashcat_ctx, cl_context context
cl_int CL_err; cl_int CL_err;
*program = ocl->clCreateProgramWithBinary (context, num_devices, device_list, lengths, binaries, binary_status, &CL_err); *program = ocl->clCreateProgramWithBinary (context, num_devices, device_list, lengths, (const unsigned char **) binaries, binary_status, &CL_err);
if (CL_err != CL_SUCCESS) if (CL_err != CL_SUCCESS)
{ {
@ -1175,7 +1175,7 @@ int gidd_to_pw_t (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, c
return 0; return 0;
} }
int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 highest_pw_len, const u32 pws_cnt, const u32 fast_iteration, const u32 salt_pos) int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 highest_pw_len, const u64 pws_cnt, const u32 fast_iteration, const u32 salt_pos)
{ {
hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
hashes_t *hashes = hashcat_ctx->hashes; hashes_t *hashes = hashcat_ctx->hashes;
@ -1418,7 +1418,7 @@ int choose_kernel (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
return 0; return 0;
} }
void rebuild_pws_compressed_append (hc_device_param_t *device_param, const u32 pws_cnt, const u8 chr) void rebuild_pws_compressed_append (hc_device_param_t *device_param, const u64 pws_cnt, const u8 chr)
{ {
// this function is used if we have to modify the compressed pws buffer in order to // this function is used if we have to modify the compressed pws buffer in order to
// append some data to each password candidate // append some data to each password candidate
@ -1955,7 +1955,7 @@ int run_kernel_bzero (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_para
return run_kernel_memset (hashcat_ctx, device_param, buf, 0, size); return run_kernel_memset (hashcat_ctx, device_param, buf, 0, size);
} }
int run_copy (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt) int run_copy (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt)
{ {
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
@ -2098,7 +2098,7 @@ int run_copy (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const
return 0; return 0;
} }
int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt) int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt)
{ {
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
@ -2167,25 +2167,25 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
// iteration type // iteration type
u64 innerloop_step = 0; u32 innerloop_step = 0;
u64 innerloop_cnt = 0; u32 innerloop_cnt = 0;
if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops; if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) innerloop_step = device_param->kernel_loops;
else innerloop_step = 1; else innerloop_step = 1;
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = straight_ctx->kernel_rules_cnt; if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = (u32) straight_ctx->kernel_rules_cnt;
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = combinator_ctx->combs_cnt; else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = (u32) combinator_ctx->combs_cnt;
else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = mask_ctx->bfs_cnt; else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = (u32) mask_ctx->bfs_cnt;
// innerloops // innerloops
for (u64 innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step) for (u32 innerloop_pos = 0; innerloop_pos < innerloop_cnt; innerloop_pos += innerloop_step)
{ {
while (status_ctx->devices_status == STATUS_PAUSED) sleep (1); while (status_ctx->devices_status == STATUS_PAUSED) sleep (1);
u32 fast_iteration = 0; u32 fast_iteration = 0;
u64 innerloop_left = innerloop_cnt - innerloop_pos; u32 innerloop_left = innerloop_cnt - innerloop_pos;
if (innerloop_left > innerloop_step) if (innerloop_left > innerloop_step)
{ {
@ -2230,13 +2230,13 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
{ {
char *line_buf = combinator_ctx->scratch_buf; char *line_buf = combinator_ctx->scratch_buf;
u64 i = 0; u32 i = 0;
while (i < innerloop_left) while (i < innerloop_left)
{ {
if (feof (combs_fp)) break; if (feof (combs_fp)) break;
int line_len = fgetl (combs_fp, line_buf); size_t line_len = fgetl (combs_fp, line_buf);
line_len = convert_from_hex (hashcat_ctx, line_buf, line_len); line_len = convert_from_hex (hashcat_ctx, line_buf, line_len);
@ -2252,7 +2252,7 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
memset (rule_buf_out, 0, sizeof (rule_buf_out)); memset (rule_buf_out, 0, sizeof (rule_buf_out));
const int rule_len_out = _old_apply_rule (user_options->rule_buf_r, user_options_extra->rule_len_r, line_buf, line_len, rule_buf_out); const int rule_len_out = _old_apply_rule (user_options->rule_buf_r, user_options_extra->rule_len_r, line_buf, (u32) line_len, rule_buf_out);
if (rule_len_out < 0) if (rule_len_out < 0)
{ {
@ -2292,12 +2292,12 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
} }
} }
device_param->combs_buf[i].pw_len = line_len; device_param->combs_buf[i].pw_len = (u32) line_len;
i++; i++;
} }
for (u64 j = i; j < innerloop_left; j++) for (u32 j = i; j < innerloop_left; j++)
{ {
memset (&device_param->combs_buf[j], 0, sizeof (pw_t)); memset (&device_param->combs_buf[j], 0, sizeof (pw_t));
} }
@ -2347,13 +2347,13 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
{ {
char *line_buf = combinator_ctx->scratch_buf; char *line_buf = combinator_ctx->scratch_buf;
u64 i = 0; u32 i = 0;
while (i < innerloop_left) while (i < innerloop_left)
{ {
if (feof (combs_fp)) break; if (feof (combs_fp)) break;
int line_len = fgetl (combs_fp, line_buf); size_t line_len = fgetl (combs_fp, line_buf);
line_len = convert_from_hex (hashcat_ctx, line_buf, line_len); line_len = convert_from_hex (hashcat_ctx, line_buf, line_len);
@ -2369,7 +2369,7 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
memset (rule_buf_out, 0, sizeof (rule_buf_out)); memset (rule_buf_out, 0, sizeof (rule_buf_out));
const int rule_len_out = _old_apply_rule (user_options->rule_buf_r, user_options_extra->rule_len_r, line_buf, line_len, rule_buf_out); const int rule_len_out = _old_apply_rule (user_options->rule_buf_r, user_options_extra->rule_len_r, line_buf, (u32) line_len, rule_buf_out);
if (rule_len_out < 0) if (rule_len_out < 0)
{ {
@ -2411,12 +2411,12 @@ int run_cracker (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, co
} }
*/ */
device_param->combs_buf[i].pw_len = line_len; device_param->combs_buf[i].pw_len = (u32) line_len;
i++; i++;
} }
for (u64 j = i; j < innerloop_left; j++) for (u32 j = i; j < innerloop_left; j++)
{ {
memset (&device_param->combs_buf[j], 0, sizeof (pw_t)); memset (&device_param->combs_buf[j], 0, sizeof (pw_t));
} }
@ -3533,7 +3533,7 @@ int opencl_ctx_devices_init (hashcat_ctx_t *hashcat_ctx, const int comptime)
else else
{ {
// Support for ROCm platform // Support for ROCm platform
if (strtof (device_param->driver_version, NULL) >= 1.1) amd_warn = false; if (strtof (device_param->driver_version, NULL) >= 1.1f) amd_warn = false;
} }
#elif defined (_WIN) #elif defined (_WIN)
// AMD Radeon Software 14.9 and higher, should be updated to 15.12 // AMD Radeon Software 14.9 and higher, should be updated to 15.12
@ -3808,13 +3808,13 @@ void opencl_ctx_devices_kernel_loops (hashcat_ctx_t *hashcat_ctx)
if (device_param->kernel_loops_min < device_param->kernel_loops_max) if (device_param->kernel_loops_min < device_param->kernel_loops_max)
{ {
u64 innerloop_cnt = 0; u32 innerloop_cnt = 0;
if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL) if (hashconfig->attack_exec == ATTACK_EXEC_INSIDE_KERNEL)
{ {
if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = MIN (KERNEL_RULES, straight_ctx->kernel_rules_cnt); if (user_options_extra->attack_kern == ATTACK_KERN_STRAIGHT) innerloop_cnt = MIN (KERNEL_RULES, (u32) straight_ctx->kernel_rules_cnt);
else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = MIN (KERNEL_COMBS, combinator_ctx->combs_cnt); else if (user_options_extra->attack_kern == ATTACK_KERN_COMBI) innerloop_cnt = MIN (KERNEL_COMBS, (u32) combinator_ctx->combs_cnt);
else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = MIN (KERNEL_BFS, mask_ctx->bfs_cnt); else if (user_options_extra->attack_kern == ATTACK_KERN_BF) innerloop_cnt = MIN (KERNEL_BFS, (u32) mask_ctx->bfs_cnt);
} }
else else
{ {
@ -3850,12 +3850,12 @@ static int get_kernel_threads (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *de
if (work_group_size > 0) if (work_group_size > 0)
{ {
kernel_threads = MIN (kernel_threads, work_group_size); kernel_threads = MIN (kernel_threads, (u32) work_group_size);
} }
if (compile_work_group_size[0] > 0) if (compile_work_group_size[0] > 0)
{ {
kernel_threads = MIN (kernel_threads, compile_work_group_size[0]); kernel_threads = MIN (kernel_threads, (u32) compile_work_group_size[0]);
} }
*result = kernel_threads; *result = kernel_threads;
@ -4222,7 +4222,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
tmto_stop = user_options->scrypt_tmto; tmto_stop = user_options->scrypt_tmto;
} }
const u32 kernel_power_max = device_param->hardware_power * device_param->kernel_accel_max; const u64 kernel_power_max = device_param->hardware_power * device_param->kernel_accel_max;
// size_pws // size_pws
@ -4363,7 +4363,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
while (kernel_accel_max >= kernel_accel_min) while (kernel_accel_max >= kernel_accel_min)
{ {
const u32 kernel_power_max = device_param->hardware_power * kernel_accel_max; const u64 kernel_power_max = device_param->hardware_power * kernel_accel_max;
// size_pws // size_pws
@ -4668,7 +4668,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program); CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, kernel_sources, NULL, &device_param->program);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -4732,7 +4732,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL, &device_param->program); CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (unsigned char **) kernel_sources, NULL, &device_param->program);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -4747,7 +4747,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program); CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, kernel_sources, NULL, &device_param->program);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -4871,7 +4871,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_mp); CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, kernel_sources, NULL, &device_param->program_mp);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -4933,7 +4933,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL, &device_param->program_mp); CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (unsigned char **) kernel_sources, NULL, &device_param->program_mp);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -5012,7 +5012,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, (const char **) kernel_sources, NULL, &device_param->program_amp); CL_rc = hc_clCreateProgramWithSource (hashcat_ctx, device_param->context, 1, kernel_sources, NULL, &device_param->program_amp);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;
@ -5074,7 +5074,7 @@ int opencl_session_begin (hashcat_ctx_t *hashcat_ctx)
if (rc_read_kernel == -1) return -1; if (rc_read_kernel == -1) return -1;
CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (const unsigned char **) kernel_sources, NULL, &device_param->program_amp); CL_rc = hc_clCreateProgramWithBinary (hashcat_ctx, device_param->context, 1, &device_param->device, kernel_lengths, (unsigned char **) kernel_sources, NULL, &device_param->program_amp);
if (CL_rc == -1) return -1; if (CL_rc == -1) return -1;

10
src/outfile.c
Unescape View File

@ -28,7 +28,7 @@ int build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
const user_options_t *user_options = hashcat_ctx->user_options; const user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid; const u64 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos; const u32 il_pos = plain->il_pos;
int plain_len = 0; int plain_len = 0;
@ -43,7 +43,7 @@ int build_plain (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, pl
if (rc == -1) return -1; if (rc == -1) return -1;
const u32 off = device_param->innerloop_pos + il_pos; const u64 off = device_param->innerloop_pos + il_pos;
if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL) if (hashconfig->opti_type & OPTI_TYPE_OPTIMIZED_KERNEL)
{ {
@ -240,7 +240,7 @@ int build_crackpos (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
const user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra; const user_options_extra_t *user_options_extra = hashcat_ctx->user_options_extra;
const u32 gidvid = plain->gidvid; const u64 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos; const u32 il_pos = plain->il_pos;
u64 crackpos = device_param->words_off; u64 crackpos = device_param->words_off;
@ -275,7 +275,7 @@ int build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx; const straight_ctx_t *straight_ctx = hashcat_ctx->straight_ctx;
const user_options_t *user_options = hashcat_ctx->user_options; const user_options_t *user_options = hashcat_ctx->user_options;
const u32 gidvid = plain->gidvid; const u64 gidvid = plain->gidvid;
const u32 il_pos = plain->il_pos; const u32 il_pos = plain->il_pos;
if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return 0; if (user_options->attack_mode != ATTACK_MODE_STRAIGHT) return 0;
@ -292,7 +292,7 @@ int build_debugdata (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
int plain_len = (int) pw.pw_len; int plain_len = (int) pw.pw_len;
const u32 off = device_param->innerloop_pos + il_pos; const u64 off = device_param->innerloop_pos + il_pos;
// save rule // save rule
if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4)) if ((debug_mode == 1) || (debug_mode == 3) || (debug_mode == 4))

14
src/outfile_check.c
Unescape View File

@ -26,12 +26,12 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
status_ctx_t *status_ctx = hashcat_ctx->status_ctx; status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
user_options_t *user_options = hashcat_ctx->user_options; user_options_t *user_options = hashcat_ctx->user_options;
u32 dgst_size = hashconfig->dgst_size; size_t dgst_size = hashconfig->dgst_size;
bool is_salted = hashconfig->is_salted; bool is_salted = hashconfig->is_salted;
u32 esalt_size = hashconfig->esalt_size; size_t esalt_size = hashconfig->esalt_size;
u32 hook_salt_size = hashconfig->hook_salt_size; size_t hook_salt_size = hashconfig->hook_salt_size;
u32 hash_mode = hashconfig->hash_mode; u32 hash_mode = hashconfig->hash_mode;
char separator = hashconfig->separator; char separator = hashconfig->separator;
char *root_directory = outcheck_ctx->root_directory; char *root_directory = outcheck_ctx->root_directory;
u32 outfile_check_timer = user_options->outfile_check_timer; u32 outfile_check_timer = user_options->outfile_check_timer;
@ -181,7 +181,7 @@ static int outfile_remove (hashcat_ctx_t *hashcat_ctx)
if ((hash_mode != 2500) && (hash_mode != 2501) && (hash_mode != 6800)) if ((hash_mode != 2500) && (hash_mode != 2501) && (hash_mode != 6800))
{ {
parser_status = hashconfig->parse_func ((u8 *) line_buf, line_len - 1, &hash_buf, hashconfig); parser_status = hashconfig->parse_func ((u8 *) line_buf, (u32) line_len - 1, &hash_buf, hashconfig);
} }
u32 found = 0; u32 found = 0;

26
src/potfile.c
Unescape View File

@ -531,7 +531,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
while (!feof (potfile_ctx->fp)) while (!feof (potfile_ctx->fp))
{ {
int line_len = fgetl (potfile_ctx->fp, line_buf); size_t line_len = fgetl (potfile_ctx->fp, line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -541,11 +541,11 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
char *line_pw_buf = last_separator + 1; char *line_pw_buf = last_separator + 1;
int line_pw_len = line_buf + line_len - line_pw_buf; size_t line_pw_len = line_buf + line_len - line_pw_buf;
char *line_hash_buf = line_buf; char *line_hash_buf = line_buf;
int line_hash_len = last_separator - line_buf; size_t line_hash_len = last_separator - line_buf;
line_hash_buf[line_hash_len] = 0; line_hash_buf[line_hash_len] = 0;
@ -575,7 +575,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
// manipulate salt_buf // manipulate salt_buf
memcpy (hash_buf.salt->salt_buf, line_hash_buf, line_hash_len); memcpy (hash_buf.salt->salt_buf, line_hash_buf, line_hash_len);
hash_buf.salt->salt_len = line_hash_len; hash_buf.salt->salt_len = (u32) line_hash_len;
found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt); found = (hash_t *) bsearch (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash_t_salt);
} }
@ -598,9 +598,9 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
char *essid_pos = sep_pos + 1; char *essid_pos = sep_pos + 1;
int essid_len = (int) strlen (essid_pos); size_t essid_len = strlen (essid_pos);
if (is_hexify ((const u8 *) essid_pos, (const int) essid_len) == true) if (is_hexify ((const u8 *) essid_pos, essid_len) == true)
{ {
essid_len = exec_unhexify ((const u8 *) essid_pos, essid_len, (u8 *) essid_pos, essid_len); essid_len = exec_unhexify ((const u8 *) essid_pos, essid_len, (u8 *) essid_pos, essid_len);
} }
@ -613,7 +613,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
memcpy (hash_buf.salt->salt_buf, essid_pos, essid_len); memcpy (hash_buf.salt->salt_buf, essid_pos, essid_len);
hash_buf.salt->salt_len = essid_len; hash_buf.salt->salt_len = (u32) essid_len;
hash_buf.salt->salt_iter = ROUNDS_WPA - 1; hash_buf.salt->salt_iter = ROUNDS_WPA - 1;
u32 hash[4]; u32 hash[4];
@ -640,13 +640,13 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
int parser_status = hashconfig->parse_func ((u8 *) line_hash_buf, line_hash_len, &hash_buf, hashconfig); int parser_status = hashconfig->parse_func ((u8 *) line_hash_buf, (u32) line_hash_len, &hash_buf, hashconfig);
if (parser_status != PARSER_OK) continue; if (parser_status != PARSER_OK) continue;
if (potfile_ctx->keep_all_hashes == true) if (potfile_ctx->keep_all_hashes == true)
{ {
potfile_update_hashes (hashcat_ctx, &hash_buf, line_pw_buf, line_pw_len, all_hashes_tree); potfile_update_hashes (hashcat_ctx, &hash_buf, line_pw_buf, (u32) line_pw_len, all_hashes_tree);
continue; continue;
} }
@ -654,7 +654,7 @@ int potfile_remove_parse (hashcat_ctx_t *hashcat_ctx)
found = (hash_t *) hc_bsearch_r (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig); found = (hash_t *) hc_bsearch_r (&hash_buf, hashes_buf, hashes_cnt, sizeof (hash_t), sort_by_hash, (void *) hashconfig);
} }
potfile_update_hash (hashcat_ctx, found, line_pw_buf, line_pw_len); potfile_update_hash (hashcat_ctx, found, line_pw_buf, (u32) line_pw_len);
} }
hcfree (line_buf); hcfree (line_buf);
@ -878,11 +878,9 @@ int potfile_handle_show (hashcat_ctx_t *hashcat_ctx)
{ {
u8 pass_unhexified[HCBUFSIZ_TINY] = { 0 }; u8 pass_unhexified[HCBUFSIZ_TINY] = { 0 };
u32 pass_unhexified_len = 0; const size_t pass_unhexified_len = exec_unhexify ((u8 *) hash->pw_buf, hash->pw_len, pass_unhexified, sizeof (pass_unhexified));
pass_unhexified_len = exec_unhexify ((u8 *) hash->pw_buf, hash->pw_len, pass_unhexified, sizeof (pass_unhexified)); tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, pass_unhexified, (u32) pass_unhexified_len, 0, username, user_len, (char *) tmp_buf);
tmp_len = outfile_write (hashcat_ctx, (char *) out_buf, pass_unhexified, pass_unhexified_len, 0, username, user_len, (char *) tmp_buf);
} }
else else
{ {

8
src/rp.c
Unescape View File

@ -225,8 +225,8 @@ int generate_random_rule (char rule_buf[RP_RULE_SIZE], const u32 rp_gen_func_min
#define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8 #define SET_P0_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 8
#define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16 #define SET_P1_CONV(rule,val) INCR_POS; (rule)->cmds[rule_cnt] |= ((conv_ctoi (val)) & 0xff) << 16
#define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff) #define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = (char) conv_itoc (((rule)->cmds[rule_cnt] >> 8) & 0xff)
#define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff) #define GET_P1_CONV(rule) INCR_POS; rule_buf[rule_pos] = (char) conv_itoc (((rule)->cmds[rule_cnt] >> 16) & 0xff)
int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule) int cpu_rule_to_kernel_rule (char *rule_buf, u32 rule_len, kernel_rule_t *rule)
{ {
@ -707,7 +707,7 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
char *rule_buf = (char *) hcmalloc (HCBUFSIZ_LARGE); char *rule_buf = (char *) hcmalloc (HCBUFSIZ_LARGE);
int rule_len = 0; u32 rule_len = 0;
for (u32 i = 0; i < user_options->rp_files_cnt; i++) for (u32 i = 0; i < user_options->rp_files_cnt; i++)
{ {
@ -737,7 +737,7 @@ int kernel_rules_load (hashcat_ctx_t *hashcat_ctx, kernel_rule_t **out_buf, u32
while (!feof (fp)) while (!feof (fp))
{ {
rule_len = fgetl (fp, rule_buf); rule_len = (u32) fgetl (fp, rule_buf);
rule_line++; rule_line++;

4
src/rp_kernel_on_cpu.c
Unescape View File

@ -395,7 +395,7 @@ static int mangle_delete_last (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p
{ {
if (len == 0) return 0; if (len == 0) return 0;
return mangle_delete_at (len - 1, p1, buf, len); return mangle_delete_at ((u8) len - 1, p1, buf, len);
} }
static int mangle_extract (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len) static int mangle_extract (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const u8 p1, u8 *buf, const int len)
@ -651,7 +651,7 @@ static int mangle_dupeblock_first (MAYBE_UNUSED const u8 p0, MAYBE_UNUSED const
if (out_len >= RP_PASSWORD_SIZE) return (len); if (out_len >= RP_PASSWORD_SIZE) return (len);
for (int i = 0; i < p0; i++) for (u8 i = 0; i < p0; i++)
{ {
const u8 c = buf[i * 2]; const u8 c = buf[i * 2];

30
src/selftest.c
Unescape View File

@ -78,11 +78,11 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
char *pw_ptr = (char *) &pw.i; char *pw_ptr = (char *) &pw.i;
int pw_len = strlen (hashconfig->st_pass); const size_t pw_len = strlen (hashconfig->st_pass);
memcpy (pw_ptr, hashconfig->st_pass, pw_len); memcpy (pw_ptr, hashconfig->st_pass, pw_len);
pw.pw_len = pw_len; pw.pw_len = (u32) pw_len;
CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL); CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL);
@ -97,11 +97,11 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
char *pw_ptr = (char *) &pw.i; char *pw_ptr = (char *) &pw.i;
int pw_len = strlen (hashconfig->st_pass); const size_t pw_len = strlen (hashconfig->st_pass);
memcpy (pw_ptr, hashconfig->st_pass, pw_len - 1); memcpy (pw_ptr, hashconfig->st_pass, pw_len - 1);
pw.pw_len = pw_len - 1; pw.pw_len = (u32) pw_len - 1;
pw_t comb; memset (&comb, 0, sizeof (comb)); pw_t comb; memset (&comb, 0, sizeof (comb));
@ -139,7 +139,7 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
char *pw_ptr = (char *) &pw.i; char *pw_ptr = (char *) &pw.i;
int pw_len = strlen (hashconfig->st_pass); const size_t pw_len = strlen (hashconfig->st_pass);
memcpy (pw_ptr, hashconfig->st_pass, pw_len); memcpy (pw_ptr, hashconfig->st_pass, pw_len);
@ -148,7 +148,7 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
uppercase ((u8 *) pw_ptr, pw_len); uppercase ((u8 *) pw_ptr, pw_len);
} }
pw.pw_len = pw_len; pw.pw_len = (u32) pw_len;
CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL); CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL);
@ -201,17 +201,17 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
char *pw_ptr = (char *) &pw.i; char *pw_ptr = (char *) &pw.i;
int pw_len = strlen (hashconfig->st_pass); const size_t pw_len = strlen (hashconfig->st_pass);
memcpy (pw_ptr + 1, hashconfig->st_pass + 1, pw_len - 1); memcpy (pw_ptr + 1, hashconfig->st_pass + 1, pw_len - 1);
int new_pass_len = pw_len; size_t new_pass_len = pw_len;
if (hashconfig->opts_type & OPTS_TYPE_PT_UTF16LE) if (hashconfig->opts_type & OPTS_TYPE_PT_UTF16LE)
{ {
memset (pw_ptr, 0, pw_len); memset (pw_ptr, 0, pw_len);
for (int i = 1, j = 2; i < new_pass_len; i += 1, j += 2) for (size_t i = 1, j = 2; i < new_pass_len; i += 1, j += 2)
{ {
pw_ptr[j + 0] = hashconfig->st_pass[i]; pw_ptr[j + 0] = hashconfig->st_pass[i];
pw_ptr[j + 1] = 0; pw_ptr[j + 1] = 0;
@ -223,7 +223,7 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
{ {
memset (pw_ptr, 0, pw_len); memset (pw_ptr, 0, pw_len);
for (int i = 1, j = 2; i < new_pass_len; i += 1, j += 2) for (size_t i = 1, j = 2; i < new_pass_len; i += 1, j += 2)
{ {
pw_ptr[j + 0] = 0; pw_ptr[j + 0] = 0;
pw_ptr[j + 1] = hashconfig->st_pass[i]; pw_ptr[j + 1] = hashconfig->st_pass[i];
@ -247,7 +247,7 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
} }
} }
pw.pw_len = new_pass_len; pw.pw_len = (u32) new_pass_len;
if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01) if (hashconfig->opts_type & OPTS_TYPE_PT_ADD01)
{ {
@ -261,14 +261,14 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14) if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS14)
{ {
pw.i[14] = new_pass_len * 8; pw.i[14] = (u32) new_pass_len * 8;
pw.i[15] = 0; pw.i[15] = 0;
} }
if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15) if (hashconfig->opts_type & OPTS_TYPE_PT_ADDBITS15)
{ {
pw.i[14] = 0; pw.i[14] = 0;
pw.i[15] = new_pass_len * 8; pw.i[15] = (u32) new_pass_len * 8;
} }
if (hashconfig->opts_type & OPTS_TYPE_PT_GENERATE_BE) if (hashconfig->opts_type & OPTS_TYPE_PT_GENERATE_BE)
@ -290,11 +290,11 @@ static int selftest (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param
char *pw_ptr = (char *) &pw.i; char *pw_ptr = (char *) &pw.i;
int pw_len = strlen (hashconfig->st_pass); const size_t pw_len = strlen (hashconfig->st_pass);
memcpy (pw_ptr, hashconfig->st_pass, pw_len); memcpy (pw_ptr, hashconfig->st_pass, pw_len);
pw.pw_len = pw_len; pw.pw_len = (u32) pw_len;
CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL); CL_err = hc_clEnqueueWriteBuffer (hashcat_ctx, device_param->command_queue, device_param->d_pws_buf, CL_TRUE, 0, 1 * sizeof (pw_t), &pw, 0, NULL, NULL);

16
src/shared.c
Unescape View File

@ -327,11 +327,9 @@ void setup_seeding (const bool rp_gen_seed_chgd, const u32 rp_gen_seed)
} }
else else
{ {
time_t ts; const time_t ts = time (NULL); // don't tell me that this is an insecure seed
time (&ts); srand ((unsigned int) ts);
srand (ts);
} }
} }
@ -498,3 +496,13 @@ bool hc_same_files (char *file1, char *file2)
return false; return false;
} }
u32 hc_strtoul (const char *nptr, char **endptr, int base)
{
return (u32) strtoul (nptr, endptr, base);
}
u64 hc_strtoull (const char *nptr, char **endptr, int base)
{
return (u64) strtoull (nptr, endptr, base);
}

6
src/status.c
Unescape View File

@ -834,8 +834,8 @@ char *status_get_guess_candidates_dev (const hashcat_ctx_t *hashcat_ctx, const i
if ((device_param->outerloop_left == 0) || (device_param->innerloop_left == 0)) return display; if ((device_param->outerloop_left == 0) || (device_param->innerloop_left == 0)) return display;
const u32 outerloop_first = 0; const u64 outerloop_first = 0;
const u32 outerloop_last = device_param->outerloop_left - 1; const u64 outerloop_last = device_param->outerloop_left - 1;
const u32 innerloop_first = 0; const u32 innerloop_first = 0;
const u32 innerloop_last = device_param->innerloop_left - 1; const u32 innerloop_last = device_param->innerloop_left - 1;
@ -1759,7 +1759,7 @@ int status_get_memoryspeed_dev (const hashcat_ctx_t *hashcat_ctx, const int devi
return num_memoryspeed; return num_memoryspeed;
} }
int status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id) u64 status_get_progress_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id)
{ {
const opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx; const opencl_ctx_t *opencl_ctx = hashcat_ctx->opencl_ctx;

12
src/stdout.c
Unescape View File

@ -50,7 +50,7 @@ static void out_push (out_t *out, const u8 *pw_buf, const int pw_len)
} }
} }
int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u32 pws_cnt) int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param, const u64 pws_cnt)
{ {
combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx; combinator_ctx_t *combinator_ctx = hashcat_ctx->combinator_ctx;
hashconfig_t *hashconfig = hashcat_ctx->hashconfig; hashconfig_t *hashconfig = hashcat_ctx->hashconfig;
@ -102,7 +102,7 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
{ {
pw_t pw; pw_t pw;
for (u32 gidvid = 0; gidvid < pws_cnt; gidvid++) for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++)
{ {
const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw);
@ -146,7 +146,7 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
{ {
pw_t pw; pw_t pw;
for (u32 gidvid = 0; gidvid < pws_cnt; gidvid++) for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++)
{ {
const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw);
@ -190,7 +190,7 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
} }
else if (user_options->attack_mode == ATTACK_MODE_BF) else if (user_options->attack_mode == ATTACK_MODE_BF)
{ {
for (u32 gidvid = 0; gidvid < pws_cnt; gidvid++) for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++)
{ {
for (u32 il_pos = 0; il_pos < il_cnt; il_pos++) for (u32 il_pos = 0; il_pos < il_cnt; il_pos++)
{ {
@ -216,7 +216,7 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
{ {
pw_t pw; pw_t pw;
for (u32 gidvid = 0; gidvid < pws_cnt; gidvid++) for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++)
{ {
const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw);
@ -253,7 +253,7 @@ int process_stdout (hashcat_ctx_t *hashcat_ctx, hc_device_param_t *device_param,
{ {
pw_t pw; pw_t pw;
for (u32 gidvid = 0; gidvid < pws_cnt; gidvid++) for (u64 gidvid = 0; gidvid < pws_cnt; gidvid++)
{ {
const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw); const int rc = gidd_to_pw_t (hashcat_ctx, device_param, gidvid, &pw);

6
src/terminal.c
Unescape View File

@ -731,7 +731,7 @@ void opencl_info_compact (hashcat_ctx_t *hashcat_ctx)
if (platform_skipped == false) if (platform_skipped == false)
{ {
const int len = event_log_info (hashcat_ctx, "OpenCL Platform #%u: %s", platforms_idx + 1, platform_vendor); const size_t len = event_log_info (hashcat_ctx, "OpenCL Platform #%u: %s", platforms_idx + 1, platform_vendor);
char line[HCBUFSIZ_TINY]; char line[HCBUFSIZ_TINY];
@ -1482,7 +1482,7 @@ void status_progress_machine_readable (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue; if (device_info->skipped_dev == true) continue;
event_log_info (hashcat_ctx, "%d:%d:%0.2f", device_id + 1, device_info->progress_dev, device_info->runtime_msec_dev); event_log_info (hashcat_ctx, "%d:%" PRIu64 ":%0.2f", device_id + 1, device_info->progress_dev, device_info->runtime_msec_dev);
} }
status_status_destroy (hashcat_ctx, hashcat_status); status_status_destroy (hashcat_ctx, hashcat_status);
@ -1519,7 +1519,7 @@ void status_progress (hashcat_ctx_t *hashcat_ctx)
if (device_info->skipped_dev == true) continue; if (device_info->skipped_dev == true) continue;
event_log_info (hashcat_ctx, event_log_info (hashcat_ctx,
"Progress.Dev.#%d..: %d", device_id + 1, "Progress.Dev.#%d..: %" PRIu64, device_id + 1,
device_info->progress_dev); device_info->progress_dev);
} }

18
src/tuningdb.c
Unescape View File

@ -85,7 +85,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
hcfree (tuning_db_file); hcfree (tuning_db_file);
int num_lines = count_lines (fp); const size_t num_lines = count_lines (fp);
// a bit over-allocated // a bit over-allocated
@ -109,7 +109,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
line_num++; line_num++;
const int line_len = in_superchop (line_buf); const size_t line_len = in_superchop (line_buf);
if (line_len == 0) continue; if (line_len == 0) continue;
@ -179,9 +179,9 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
int kernel_accel = -1; int kernel_accel = -1;
int kernel_loops = -1; int kernel_loops = -1;
if (token_ptr[1][0] != '*') attack_mode = strtol (token_ptr[1], NULL, 10); if (token_ptr[1][0] != '*') attack_mode = (int) strtol (token_ptr[1], NULL, 10);
if (token_ptr[2][0] != '*') hash_type = strtol (token_ptr[2], NULL, 10); if (token_ptr[2][0] != '*') hash_type = (int) strtol (token_ptr[2], NULL, 10);
if (token_ptr[3][0] != 'N') vector_width = strtol (token_ptr[3], NULL, 10); if (token_ptr[3][0] != 'N') vector_width = (int) strtol (token_ptr[3], NULL, 10);
if (token_ptr[4][0] == 'A') if (token_ptr[4][0] == 'A')
{ {
@ -193,7 +193,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
kernel_accel = strtol (token_ptr[4], NULL, 10); kernel_accel = (int) strtol (token_ptr[4], NULL, 10);
if ((kernel_accel < 1) || (kernel_accel > 1024)) if ((kernel_accel < 1) || (kernel_accel > 1024))
{ {
@ -224,7 +224,7 @@ int tuning_db_init (hashcat_ctx_t *hashcat_ctx)
} }
else else
{ {
kernel_loops = strtol (token_ptr[5], NULL, 10); kernel_loops = (int) strtol (token_ptr[5], NULL, 10);
if (kernel_loops < 1) if (kernel_loops < 1)
{ {
@ -327,9 +327,9 @@ tuning_db_entry_t *tuning_db_search (hashcat_ctx_t *hashcat_ctx, const char *dev
char *device_name_nospace = hcstrdup (device_name); char *device_name_nospace = hcstrdup (device_name);
int device_name_length = strlen (device_name_nospace); const size_t device_name_length = strlen (device_name_nospace);
int i; size_t i;
for (i = 0; i < device_name_length; i++) for (i = 0; i < device_name_length; i++)
{ {

210
src/user_options.c
Unescape View File

@ -310,111 +310,111 @@ int user_options_getopt (hashcat_ctx_t *hashcat_ctx, int argc, char **argv)
{ {
switch (c) switch (c)
{ {
case IDX_HELP: user_options->usage = true; break; case IDX_HELP: user_options->usage = true; break;
case IDX_VERSION: user_options->version = true; break; case IDX_VERSION: user_options->version = true; break;
case IDX_RESTORE: user_options->restore = true; break; case IDX_RESTORE: user_options->restore = true; break;
case IDX_QUIET: user_options->quiet = true; break; case IDX_QUIET: user_options->quiet = true; break;
case IDX_SHOW: user_options->show = true; break; case IDX_SHOW: user_options->show = true; break;
case IDX_LEFT: user_options->left = true; break; case IDX_LEFT: user_options->left = true; break;
case IDX_ADVICE_DISABLE: user_options->advice_disable = true; break; case IDX_ADVICE_DISABLE: user_options->advice_disable = true; break;
case IDX_USERNAME: user_options->username = true; break; case IDX_USERNAME: user_options->username = true; break;
case IDX_REMOVE: user_options->remove = true; break; case IDX_REMOVE: user_options->remove = true; break;
case IDX_REMOVE_TIMER: user_options->remove_timer = strtoul (optarg, NULL, 10); case IDX_REMOVE_TIMER: user_options->remove_timer = hc_strtoul (optarg, NULL, 10);
user_options->remove_timer_chgd = true; break; user_options->remove_timer_chgd = true; break;
case IDX_POTFILE_DISABLE: user_options->potfile_disable = true; break; case IDX_POTFILE_DISABLE: user_options->potfile_disable = true; break;
case IDX_POTFILE_PATH: user_options->potfile_path = optarg; break; case IDX_POTFILE_PATH: user_options->potfile_path = optarg; break;
case IDX_DEBUG_MODE: user_options->debug_mode = strtoul (optarg, NULL, 10); break; case IDX_DEBUG_MODE: user_options->debug_mode = hc_strtoul (optarg, NULL, 10); break;
case IDX_DEBUG_FILE: user_options->debug_file = optarg; break; case IDX_DEBUG_FILE: user_options->debug_file = optarg; break;
case IDX_ENCODING_FROM: user_options->encoding_from = optarg; break; case IDX_ENCODING_FROM: user_options->encoding_from = optarg; break;
case IDX_ENCODING_TO: user_options->encoding_to = optarg; break; case IDX_ENCODING_TO: user_options->encoding_to = optarg; break;
case IDX_INDUCTION_DIR: user_options->induction_dir = optarg; break; case IDX_INDUCTION_DIR: user_options->induction_dir = optarg; break;
case IDX_OUTFILE_CHECK_DIR: user_options->outfile_check_dir = optarg; break; case IDX_OUTFILE_CHECK_DIR: user_options->outfile_check_dir = optarg; break;
case IDX_EXAMPLE_HASHES: user_options->example_hashes = true; break; case IDX_EXAMPLE_HASHES: user_options->example_hashes = true; break;
case IDX_FORCE: user_options->force = true; break; case IDX_FORCE: user_options->force = true; break;
case IDX_SELF_TEST_DISABLE: user_options->self_test_disable = true; break; case IDX_SELF_TEST_DISABLE: user_options->self_test_disable = true; break;
case IDX_SKIP: user_options->skip = strtoull (optarg, NULL, 10); break; case IDX_SKIP: user_options->skip = hc_strtoull (optarg, NULL, 10); break;
case IDX_LIMIT: user_options->limit = strtoull (optarg, NULL, 10); break; case IDX_LIMIT: user_options->limit = hc_strtoull (optarg, NULL, 10); break;
case IDX_KEEP_GUESSING: user_options->keep_guessing = true; break; case IDX_KEEP_GUESSING: user_options->keep_guessing = true; break;
case IDX_KEYSPACE: user_options->keyspace = true; break; case IDX_KEYSPACE: user_options->keyspace = true; break;
case IDX_BENCHMARK: user_options->benchmark = true; break; case IDX_BENCHMARK: user_options->benchmark = true; break;
case IDX_BENCHMARK_ALL: user_options->benchmark_all = true; break; case IDX_BENCHMARK_ALL: user_options->benchmark_all = true; break;
case IDX_STDOUT_FLAG: user_options->stdout_flag = true; break; case IDX_STDOUT_FLAG: user_options->stdout_flag = true; break;
case IDX_SPEED_ONLY: user_options->speed_only = true; break; case IDX_SPEED_ONLY: user_options->speed_only = true; break;
case IDX_PROGRESS_ONLY: user_options->progress_only = true; break; case IDX_PROGRESS_ONLY: user_options->progress_only = true; break;
case IDX_RESTORE_DISABLE: user_options->restore_disable = true; break; case IDX_RESTORE_DISABLE: user_options->restore_disable = true; break;
case IDX_RESTORE_FILE_PATH: user_options->restore_file_path = optarg; break; case IDX_RESTORE_FILE_PATH: user_options->restore_file_path = optarg; break;
case IDX_STATUS: user_options->status = true; break; case IDX_STATUS: user_options->status = true; break;
case IDX_STATUS_TIMER: user_options->status_timer = strtoul (optarg, NULL, 10); break; case IDX_STATUS_TIMER: user_options->status_timer = hc_strtoul (optarg, NULL, 10); break;
case IDX_MACHINE_READABLE: user_options->machine_readable = true; break; case IDX_MACHINE_READABLE: user_options->machine_readable = true; break;
case IDX_LOOPBACK: user_options->loopback = true; break; case IDX_LOOPBACK: user_options->loopback = true; break;
case IDX_SESSION: user_options->session = optarg; break; case IDX_SESSION: user_options->session = optarg; break;
case IDX_HASH_MODE: user_options->hash_mode = strtoul (optarg, NULL, 10); case IDX_HASH_MODE: user_options->hash_mode = hc_strtoul (optarg, NULL, 10);
user_options->hash_mode_chgd = true; break; user_options->hash_mode_chgd = true; break;
case IDX_RUNTIME: user_options->runtime = strtoul (optarg, NULL, 10); case IDX_RUNTIME: user_options->runtime = hc_strtoul (optarg, NULL, 10);
user_options->runtime_chgd = true; break; user_options->runtime_chgd = true; break;
case IDX_ATTACK_MODE: user_options->attack_mode = strtoul (optarg, NULL, 10); case IDX_ATTACK_MODE: user_options->attack_mode = hc_strtoul (optarg, NULL, 10);
user_options->attack_mode_chgd = true; break; user_options->attack_mode_chgd = true; break;
case IDX_RP_FILE: user_options->rp_files[user_options->rp_files_cnt++] = optarg; break; case IDX_RP_FILE: user_options->rp_files[user_options->rp_files_cnt++] = optarg; break;
case IDX_RP_GEN: user_options->rp_gen = strtoul (optarg, NULL, 10); break; case IDX_RP_GEN: user_options->rp_gen = hc_strtoul (optarg, NULL, 10); break;
case IDX_RP_GEN_FUNC_MIN: user_options->rp_gen_func_min = strtoul (optarg, NULL, 10); break; case IDX_RP_GEN_FUNC_MIN: user_options->rp_gen_func_min = hc_strtoul (optarg, NULL, 10); break;
case IDX_RP_GEN_FUNC_MAX: user_options->rp_gen_func_max = strtoul (optarg, NULL, 10); break; case IDX_RP_GEN_FUNC_MAX: user_options->rp_gen_func_max = hc_strtoul (optarg, NULL, 10); break;
case IDX_RP_GEN_SEED: user_options->rp_gen_seed = strtoul (optarg, NULL, 10); case IDX_RP_GEN_SEED: user_options->rp_gen_seed = hc_strtoul (optarg, NULL, 10);
user_options->rp_gen_seed_chgd = true; break; user_options->rp_gen_seed_chgd = true; break;
case IDX_RULE_BUF_L: user_options->rule_buf_l = optarg; break; case IDX_RULE_BUF_L: user_options->rule_buf_l = optarg; break;
case IDX_RULE_BUF_R: user_options->rule_buf_r = optarg; break; case IDX_RULE_BUF_R: user_options->rule_buf_r = optarg; break;
case IDX_MARKOV_DISABLE: user_options->markov_disable = true; break; case IDX_MARKOV_DISABLE: user_options->markov_disable = true; break;
case IDX_MARKOV_CLASSIC: user_options->markov_classic = true; break; case IDX_MARKOV_CLASSIC: user_options->markov_classic = true; break;
case IDX_MARKOV_THRESHOLD: user_options->markov_threshold = strtoul (optarg, NULL, 10); break; case IDX_MARKOV_THRESHOLD: user_options->markov_threshold = hc_strtoul (optarg, NULL, 10); break;
case IDX_MARKOV_HCSTAT: user_options->markov_hcstat = optarg; break; case IDX_MARKOV_HCSTAT: user_options->markov_hcstat = optarg; break;
case IDX_OUTFILE: user_options->outfile = optarg; break; case IDX_OUTFILE: user_options->outfile = optarg; break;
case IDX_OUTFILE_FORMAT: user_options->outfile_format = strtoul (optarg, NULL, 10); case IDX_OUTFILE_FORMAT: user_options->outfile_format = hc_strtoul (optarg, NULL, 10);
user_options->outfile_format_chgd = true; break; user_options->outfile_format_chgd = true; break;
case IDX_OUTFILE_AUTOHEX_DISABLE: user_options->outfile_autohex = false; break; case IDX_OUTFILE_AUTOHEX_DISABLE: user_options->outfile_autohex = false; break;
case IDX_OUTFILE_CHECK_TIMER: user_options->outfile_check_timer = strtoul (optarg, NULL, 10); break; case IDX_OUTFILE_CHECK_TIMER: user_options->outfile_check_timer = hc_strtoul (optarg, NULL, 10); break;
case IDX_WORDLIST_AUTOHEX_DISABLE: user_options->wordlist_autohex_disable = true; break; case IDX_WORDLIST_AUTOHEX_DISABLE: user_options->wordlist_autohex_disable = true; break;
case IDX_HEX_CHARSET: user_options->hex_charset = true; break; case IDX_HEX_CHARSET: user_options->hex_charset = true; break;
case IDX_HEX_SALT: user_options->hex_salt = true; break; case IDX_HEX_SALT: user_options->hex_salt = true; break;
case IDX_HEX_WORDLIST: user_options->hex_wordlist = true; break; case IDX_HEX_WORDLIST: user_options->hex_wordlist = true; break;
case IDX_CPU_AFFINITY: user_options->cpu_affinity = optarg; break; case IDX_CPU_AFFINITY: user_options->cpu_affinity = optarg; break;
case IDX_OPENCL_INFO: user_options->opencl_info = true; break; case IDX_OPENCL_INFO: user_options->opencl_info = true; break;
case IDX_OPENCL_DEVICES: user_options->opencl_devices = optarg; break; case IDX_OPENCL_DEVICES: user_options->opencl_devices = optarg; break;
case IDX_OPENCL_PLATFORMS: user_options->opencl_platforms = optarg; break; case IDX_OPENCL_PLATFORMS: user_options->opencl_platforms = optarg; break;
case IDX_OPENCL_DEVICE_TYPES: user_options->opencl_device_types = optarg; break; case IDX_OPENCL_DEVICE_TYPES: user_options->opencl_device_types = optarg; break;
case IDX_OPENCL_VECTOR_WIDTH: user_options->opencl_vector_width = strtoul (optarg, NULL, 10); case IDX_OPENCL_VECTOR_WIDTH: user_options->opencl_vector_width = hc_strtoul (optarg, NULL, 10);
user_options->opencl_vector_width_chgd = true; break; user_options->opencl_vector_width_chgd = true; break;
case IDX_OPTIMIZED_KERNEL_ENABLE: user_options->optimized_kernel_enable = true; break; case IDX_OPTIMIZED_KERNEL_ENABLE: user_options->optimized_kernel_enable = true; break;
case IDX_WORKLOAD_PROFILE: user_options->workload_profile = strtoul (optarg, NULL, 10); case IDX_WORKLOAD_PROFILE: user_options->workload_profile = hc_strtoul (optarg, NULL, 10);
user_options->workload_profile_chgd = true; break; user_options->workload_profile_chgd = true; break;
case IDX_KERNEL_ACCEL: user_options->kernel_accel = strtoul (optarg, NULL, 10); case IDX_KERNEL_ACCEL: user_options->kernel_accel = hc_strtoul (optarg, NULL, 10);
user_options->kernel_accel_chgd = true; break; user_options->kernel_accel_chgd = true; break;
case IDX_KERNEL_LOOPS: user_options->kernel_loops = strtoul (optarg, NULL, 10); case IDX_KERNEL_LOOPS: user_options->kernel_loops = hc_strtoul (optarg, NULL, 10);
user_options->kernel_loops_chgd = true; break; user_options->kernel_loops_chgd = true; break;
case IDX_NVIDIA_SPIN_DAMP: user_options->nvidia_spin_damp = strtoul (optarg, NULL, 10); case IDX_NVIDIA_SPIN_DAMP: user_options->nvidia_spin_damp = hc_strtoul (optarg, NULL, 10);
user_options->nvidia_spin_damp_chgd = true; break; user_options->nvidia_spin_damp_chgd = true; break;
case IDX_GPU_TEMP_DISABLE: user_options->gpu_temp_disable = true; break; case IDX_GPU_TEMP_DISABLE: user_options->gpu_temp_disable = true; break;
case IDX_GPU_TEMP_ABORT: user_options->gpu_temp_abort = strtoul (optarg, NULL, 10); break; case IDX_GPU_TEMP_ABORT: user_options->gpu_temp_abort = hc_strtoul (optarg, NULL, 10); break;
case IDX_LOGFILE_DISABLE: user_options->logfile_disable = true; break; case IDX_LOGFILE_DISABLE: user_options->logfile_disable = true; break;
case IDX_HCCAPX_MESSAGE_PAIR: user_options->hccapx_message_pair = strtoul (optarg, NULL, 10); case IDX_HCCAPX_MESSAGE_PAIR: user_options->hccapx_message_pair = hc_strtoul (optarg, NULL, 10);
user_options->hccapx_message_pair_chgd = true; break; user_options->hccapx_message_pair_chgd = true; break;
case IDX_NONCE_ERROR_CORRECTIONS: user_options->nonce_error_corrections = strtoul (optarg, NULL, 10); break; case IDX_NONCE_ERROR_CORRECTIONS: user_options->nonce_error_corrections = hc_strtoul (optarg, NULL, 10); break;
case IDX_TRUECRYPT_KEYFILES: user_options->truecrypt_keyfiles = optarg; break; case IDX_TRUECRYPT_KEYFILES: user_options->truecrypt_keyfiles = optarg; break;
case IDX_VERACRYPT_KEYFILES: user_options->veracrypt_keyfiles = optarg; break; case IDX_VERACRYPT_KEYFILES: user_options->veracrypt_keyfiles = optarg; break;
case IDX_VERACRYPT_PIM: user_options->veracrypt_pim = strtoul (optarg, NULL, 10); break; case IDX_VERACRYPT_PIM: user_options->veracrypt_pim = hc_strtoul (optarg, NULL, 10); break;
case IDX_SEGMENT_SIZE: user_options->segment_size = strtoul (optarg, NULL, 10); case IDX_SEGMENT_SIZE: user_options->segment_size = hc_strtoul (optarg, NULL, 10);
user_options->segment_size_chgd = true; break; user_options->segment_size_chgd = true; break;
case IDX_SCRYPT_TMTO: user_options->scrypt_tmto = strtoul (optarg, NULL, 10); break; case IDX_SCRYPT_TMTO: user_options->scrypt_tmto = hc_strtoul (optarg, NULL, 10); break;
case IDX_SEPARATOR: user_options->separator = optarg[0]; break; case IDX_SEPARATOR: user_options->separator = optarg[0]; break;
case IDX_BITMAP_MIN: user_options->bitmap_min = strtoul (optarg, NULL, 10); break; case IDX_BITMAP_MIN: user_options->bitmap_min = hc_strtoul (optarg, NULL, 10); break;
case IDX_BITMAP_MAX: user_options->bitmap_max = strtoul (optarg, NULL, 10); break; case IDX_BITMAP_MAX: user_options->bitmap_max = hc_strtoul (optarg, NULL, 10); break;
case IDX_INCREMENT: user_options->increment = true; break; case IDX_INCREMENT: user_options->increment = true; break;
case IDX_INCREMENT_MIN: user_options->increment_min = strtoul (optarg, NULL, 10); case IDX_INCREMENT_MIN: user_options->increment_min = hc_strtoul (optarg, NULL, 10);
user_options->increment_min_chgd = true; break; user_options->increment_min_chgd = true; break;
case IDX_INCREMENT_MAX: user_options->increment_max = strtoul (optarg, NULL, 10); case IDX_INCREMENT_MAX: user_options->increment_max = hc_strtoul (optarg, NULL, 10);
user_options->increment_max_chgd = true; break; user_options->increment_max_chgd = true; break;
case IDX_CUSTOM_CHARSET_1: user_options->custom_charset_1 = optarg; break; case IDX_CUSTOM_CHARSET_1: user_options->custom_charset_1 = optarg; break;
case IDX_CUSTOM_CHARSET_2: user_options->custom_charset_2 = optarg; break; case IDX_CUSTOM_CHARSET_2: user_options->custom_charset_2 = optarg; break;
case IDX_CUSTOM_CHARSET_3: user_options->custom_charset_3 = optarg; break; case IDX_CUSTOM_CHARSET_3: user_options->custom_charset_3 = optarg; break;
case IDX_CUSTOM_CHARSET_4: user_options->custom_charset_4 = optarg; break; case IDX_CUSTOM_CHARSET_4: user_options->custom_charset_4 = optarg; break;
} }
} }

14
src/wordlist.c
Unescape View File

@ -15,7 +15,7 @@
#include "shared.h" #include "shared.h"
#include "wordlist.h" #include "wordlist.h"
u32 convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const u32 line_len) size_t convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const size_t line_len)
{ {
const user_options_t *user_options = hashcat_ctx->user_options; const user_options_t *user_options = hashcat_ctx->user_options;
@ -37,11 +37,11 @@ u32 convert_from_hex (hashcat_ctx_t *hashcat_ctx, char *line_buf, const u32 line
if (user_options->wordlist_autohex_disable == false) if (user_options->wordlist_autohex_disable == false)
{ {
if (is_hexify ((const u8 *) line_buf, (const int) line_len) == true) if (is_hexify ((const u8 *) line_buf, line_len) == true)
{ {
const int new_len = exec_unhexify ((const u8 *) line_buf, (const int) line_len, (u8 *) line_buf, (const int) line_len); const size_t new_len = exec_unhexify ((const u8 *) line_buf, line_len, (u8 *) line_buf, line_len);
return (u32) new_len; return new_len;
} }
} }
@ -213,7 +213,7 @@ void get_next_word (hashcat_ctx_t *hashcat_ctx, FILE *fd, char **out_buf, u32 *o
memset (rule_buf_out, 0, sizeof (rule_buf_out)); memset (rule_buf_out, 0, sizeof (rule_buf_out));
const int rule_len_out = _old_apply_rule (user_options->rule_buf_l, user_options_extra->rule_len_l, ptr, len, rule_buf_out); const int rule_len_out = _old_apply_rule (user_options->rule_buf_l, user_options_extra->rule_len_l, ptr, (u32) len, rule_buf_out);
if (rule_len_out < 0) continue; if (rule_len_out < 0) continue;
} }
@ -221,7 +221,7 @@ void get_next_word (hashcat_ctx_t *hashcat_ctx, FILE *fd, char **out_buf, u32 *o
if (len >= PW_MAX) continue; if (len >= PW_MAX) continue;
*out_buf = ptr; *out_buf = ptr;
*out_len = len; *out_len = (u32) len;
return; return;
} }
@ -425,7 +425,7 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
memset (rule_buf_out, 0, sizeof (rule_buf_out)); memset (rule_buf_out, 0, sizeof (rule_buf_out));
const int rule_len_out = _old_apply_rule (user_options->rule_buf_l, user_options_extra->rule_len_l, ptr, len, rule_buf_out); const int rule_len_out = _old_apply_rule (user_options->rule_buf_l, user_options_extra->rule_len_l, ptr, (u32) len, rule_buf_out);
if (rule_len_out < 0) continue; if (rule_len_out < 0) continue;
} }

Write Preview
Loading…
Cancel
Save