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

Fix a bunch of cast-qual warnings

Browse Source
pull/1448/head
Rosen Penev 7 years ago
parent 8458f07a57
commit 353d3c3008
12 changed files with 365 additions and 365 deletions
Show Stats Download Patch File Download Diff File

2
include/hlfmt.h
Unescape View File

@ -10,7 +10,7 @@
#define HLFMTS_CNT 11 #define HLFMTS_CNT 11
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, int line_len, char **hashbuf_pos, int *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, int line_len, char **userbuf_pos, int *userbuf_len);

6
include/interface.h
Unescape View File

@ -1876,9 +1876,9 @@ void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf,
* output functions * output functions
*/ */
char *stroptitype (const u32 opti_type); const char *stroptitype (const u32 opti_type);
char *strhashtype (const u32 hash_mode); const char *strhashtype (const u32 hash_mode);
char *strparser (const u32 parser_status); const char *strparser (const u32 parser_status);
int check_old_hccap (const char *hashfile); int check_old_hccap (const char *hashfile);
void to_hccapx_t (hashcat_ctx_t *hashcat_ctx, hccapx_t *hccapx, const u32 salt_pos, const u32 digest_pos); void to_hccapx_t (hashcat_ctx_t *hashcat_ctx, hccapx_t *hccapx, const u32 salt_pos, const u32 digest_pos);

4
include/status.h
Unescape View File

@ -20,7 +20,7 @@ int status_get_device_info_cnt (const hashcat_ctx_t *hashcat_
int status_get_device_info_active (const hashcat_ctx_t *hashcat_ctx); int status_get_device_info_active (const hashcat_ctx_t *hashcat_ctx);
bool status_get_skipped_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); bool status_get_skipped_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
char *status_get_session (const hashcat_ctx_t *hashcat_ctx); char *status_get_session (const hashcat_ctx_t *hashcat_ctx);
char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx); const char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx);
int status_get_status_number (const hashcat_ctx_t *hashcat_ctx); int status_get_status_number (const hashcat_ctx_t *hashcat_ctx);
int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx); int status_get_guess_mode (const hashcat_ctx_t *hashcat_ctx);
char *status_get_guess_base (const hashcat_ctx_t *hashcat_ctx); char *status_get_guess_base (const hashcat_ctx_t *hashcat_ctx);
@ -34,7 +34,7 @@ double status_get_guess_mod_percent (const hashcat_ctx_t *hashcat_
char *status_get_guess_charset (const hashcat_ctx_t *hashcat_ctx); char *status_get_guess_charset (const hashcat_ctx_t *hashcat_ctx);
int status_get_guess_mask_length (const hashcat_ctx_t *hashcat_ctx); int status_get_guess_mask_length (const hashcat_ctx_t *hashcat_ctx);
char *status_get_guess_candidates_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id); char *status_get_guess_candidates_dev (const hashcat_ctx_t *hashcat_ctx, const int device_id);
char *status_get_hash_type (const hashcat_ctx_t *hashcat_ctx); const char *status_get_hash_type (const hashcat_ctx_t *hashcat_ctx);
const char *status_get_hash_target (const hashcat_ctx_t *hashcat_ctx); const char *status_get_hash_target (const hashcat_ctx_t *hashcat_ctx);
int status_get_digests_done (const hashcat_ctx_t *hashcat_ctx); int status_get_digests_done (const hashcat_ctx_t *hashcat_ctx);
int status_get_digests_cnt (const hashcat_ctx_t *hashcat_ctx); int status_get_digests_cnt (const hashcat_ctx_t *hashcat_ctx);

8
include/types.h
Unescape View File

@ -1753,7 +1753,7 @@ typedef struct device_info
typedef struct hashcat_status typedef struct hashcat_status
{ {
const char *hash_target; const char *hash_target;
char *hash_type; const char *hash_type;
int guess_mode; int guess_mode;
char *guess_base; char *guess_base;
int guess_base_offset; int guess_base_offset;
@ -1766,7 +1766,7 @@ typedef struct hashcat_status
char *guess_charset; char *guess_charset;
int guess_mask_length; int guess_mask_length;
char *session; char *session;
char *status_string; const char *status_string;
int status_number; int status_number;
char *time_estimated_absolute; char *time_estimated_absolute;
char *time_estimated_relative; char *time_estimated_relative;
@ -1894,7 +1894,7 @@ typedef struct hashcat_user
typedef struct cache_hit typedef struct cache_hit
{ {
char *dictfile; const char *dictfile;
hc_stat_t stat; hc_stat_t stat;
@ -1905,7 +1905,7 @@ typedef struct cache_hit
typedef struct cache_generate typedef struct cache_generate
{ {
char *dictfile; const char *dictfile;
double percent; double percent;

4
src/hashes.c
Unescape View File

@ -1582,7 +1582,7 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
for (int i = 0, j = 0; j < st_hash_len; i += 1, j += 2) for (int i = 0, j = 0; j < st_hash_len; i += 1, j += 2)
{ {
const u8 c = hex_to_u8 ((u8 *) hashconfig->st_hash + j); const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + j);
tmpdata[i] = c; tmpdata[i] = c;
} }
@ -1607,7 +1607,7 @@ int hashes_init_selftest (hashcat_ctx_t *hashcat_ctx)
for (int i = 0; i < st_hash_len; i += 2) for (int i = 0; i < st_hash_len; i += 2)
{ {
const u8 c = hex_to_u8 ((u8 *) hashconfig->st_hash + i); const u8 c = hex_to_u8 ((const u8 *) hashconfig->st_hash + i);
fputc (c, fp); fputc (c, fp);
} }

24
src/hlfmt.c
Unescape View File

@ -292,23 +292,23 @@ static void hlfmt_user_shadow (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, char *li
// hlfmt main // hlfmt main
char *strhlfmt (const u32 hashfile_format) const char *strhlfmt (const u32 hashfile_format)
{ {
switch (hashfile_format) switch (hashfile_format)
{ {
case HLFMT_HASHCAT: return ((char *) HLFMT_TEXT_HASHCAT); case HLFMT_HASHCAT: return HLFMT_TEXT_HASHCAT;
case HLFMT_PWDUMP: return ((char *) HLFMT_TEXT_PWDUMP); case HLFMT_PWDUMP: return HLFMT_TEXT_PWDUMP;
case HLFMT_PASSWD: return ((char *) HLFMT_TEXT_PASSWD); case HLFMT_PASSWD: return HLFMT_TEXT_PASSWD;
case HLFMT_SHADOW: return ((char *) HLFMT_TEXT_SHADOW); case HLFMT_SHADOW: return HLFMT_TEXT_SHADOW;
case HLFMT_DCC: return ((char *) HLFMT_TEXT_DCC); case HLFMT_DCC: return HLFMT_TEXT_DCC;
case HLFMT_DCC2: return ((char *) HLFMT_TEXT_DCC2); case HLFMT_DCC2: return HLFMT_TEXT_DCC2;
case HLFMT_NETNTLM1: return ((char *) HLFMT_TEXT_NETNTLM1); case HLFMT_NETNTLM1: return HLFMT_TEXT_NETNTLM1;
case HLFMT_NETNTLM2: return ((char *) HLFMT_TEXT_NETNTLM2); case HLFMT_NETNTLM2: return HLFMT_TEXT_NETNTLM2;
case HLFMT_NSLDAP: return ((char *) HLFMT_TEXT_NSLDAP); case HLFMT_NSLDAP: return HLFMT_TEXT_NSLDAP;
case HLFMT_NSLDAPS: return ((char *) HLFMT_TEXT_NSLDAPS); case HLFMT_NSLDAPS: return HLFMT_TEXT_NSLDAPS;
} }
return ((char *) "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, int line_len, char **hashbuf_pos, int *hashbuf_len)

600
src/interface.c
Unescape View File

@ -15880,319 +15880,319 @@ void seven_zip_hook_func (hc_device_param_t *device_param, void *hook_salts_buf,
* output * output
*/ */
char *stroptitype (const u32 opti_type) const char *stroptitype (const u32 opti_type)
{ {
switch (opti_type) switch (opti_type)
{ {
case OPTI_TYPE_OPTIMIZED_KERNEL: return ((char *) OPTI_STR_OPTIMIZED_KERNEL); case OPTI_TYPE_OPTIMIZED_KERNEL: return OPTI_STR_OPTIMIZED_KERNEL;
case OPTI_TYPE_ZERO_BYTE: return ((char *) OPTI_STR_ZERO_BYTE); case OPTI_TYPE_ZERO_BYTE: return OPTI_STR_ZERO_BYTE;
case OPTI_TYPE_PRECOMPUTE_INIT: return ((char *) OPTI_STR_PRECOMPUTE_INIT); case OPTI_TYPE_PRECOMPUTE_INIT: return OPTI_STR_PRECOMPUTE_INIT;
case OPTI_TYPE_PRECOMPUTE_MERKLE: return ((char *) OPTI_STR_PRECOMPUTE_MERKLE); case OPTI_TYPE_PRECOMPUTE_MERKLE: return OPTI_STR_PRECOMPUTE_MERKLE;
case OPTI_TYPE_PRECOMPUTE_PERMUT: return ((char *) OPTI_STR_PRECOMPUTE_PERMUT); case OPTI_TYPE_PRECOMPUTE_PERMUT: return OPTI_STR_PRECOMPUTE_PERMUT;
case OPTI_TYPE_MEET_IN_MIDDLE: return ((char *) OPTI_STR_MEET_IN_MIDDLE); case OPTI_TYPE_MEET_IN_MIDDLE: return OPTI_STR_MEET_IN_MIDDLE;
case OPTI_TYPE_EARLY_SKIP: return ((char *) OPTI_STR_EARLY_SKIP); case OPTI_TYPE_EARLY_SKIP: return OPTI_STR_EARLY_SKIP;
case OPTI_TYPE_NOT_SALTED: return ((char *) OPTI_STR_NOT_SALTED); case OPTI_TYPE_NOT_SALTED: return OPTI_STR_NOT_SALTED;
case OPTI_TYPE_NOT_ITERATED: return ((char *) OPTI_STR_NOT_ITERATED); case OPTI_TYPE_NOT_ITERATED: return OPTI_STR_NOT_ITERATED;
case OPTI_TYPE_PREPENDED_SALT: return ((char *) OPTI_STR_PREPENDED_SALT); case OPTI_TYPE_PREPENDED_SALT: return OPTI_STR_PREPENDED_SALT;
case OPTI_TYPE_APPENDED_SALT: return ((char *) OPTI_STR_APPENDED_SALT); case OPTI_TYPE_APPENDED_SALT: return OPTI_STR_APPENDED_SALT;
case OPTI_TYPE_SINGLE_HASH: return ((char *) OPTI_STR_SINGLE_HASH); case OPTI_TYPE_SINGLE_HASH: return OPTI_STR_SINGLE_HASH;
case OPTI_TYPE_SINGLE_SALT: return ((char *) OPTI_STR_SINGLE_SALT); case OPTI_TYPE_SINGLE_SALT: return OPTI_STR_SINGLE_SALT;
case OPTI_TYPE_BRUTE_FORCE: return ((char *) OPTI_STR_BRUTE_FORCE); case OPTI_TYPE_BRUTE_FORCE: return OPTI_STR_BRUTE_FORCE;
case OPTI_TYPE_RAW_HASH: return ((char *) OPTI_STR_RAW_HASH); case OPTI_TYPE_RAW_HASH: return OPTI_STR_RAW_HASH;
case OPTI_TYPE_SLOW_HASH_SIMD_INIT: return ((char *) OPTI_STR_SLOW_HASH_SIMD_INIT); case OPTI_TYPE_SLOW_HASH_SIMD_INIT: return OPTI_STR_SLOW_HASH_SIMD_INIT;
case OPTI_TYPE_SLOW_HASH_SIMD_LOOP: return ((char *) OPTI_STR_SLOW_HASH_SIMD_LOOP); case OPTI_TYPE_SLOW_HASH_SIMD_LOOP: return OPTI_STR_SLOW_HASH_SIMD_LOOP;
case OPTI_TYPE_SLOW_HASH_SIMD_COMP: return ((char *) OPTI_STR_SLOW_HASH_SIMD_COMP); case OPTI_TYPE_SLOW_HASH_SIMD_COMP: return OPTI_STR_SLOW_HASH_SIMD_COMP;
case OPTI_TYPE_USES_BITS_8: return ((char *) OPTI_STR_USES_BITS_8); case OPTI_TYPE_USES_BITS_8: return OPTI_STR_USES_BITS_8;
case OPTI_TYPE_USES_BITS_16: return ((char *) OPTI_STR_USES_BITS_16); case OPTI_TYPE_USES_BITS_16: return OPTI_STR_USES_BITS_16;
case OPTI_TYPE_USES_BITS_32: return ((char *) OPTI_STR_USES_BITS_32); case OPTI_TYPE_USES_BITS_32: return OPTI_STR_USES_BITS_32;
case OPTI_TYPE_USES_BITS_64: return ((char *) OPTI_STR_USES_BITS_64); case OPTI_TYPE_USES_BITS_64: return OPTI_STR_USES_BITS_64;
} }
return (NULL); return NULL;
} }
char *strhashtype (const u32 hash_mode) const char *strhashtype (const u32 hash_mode)
{ {
switch (hash_mode) switch (hash_mode)
{ {
case 0: return ((char *) HT_00000); case 0: return HT_00000;
case 10: return ((char *) HT_00010); case 10: return HT_00010;
case 11: return ((char *) HT_00011); case 11: return HT_00011;
case 12: return ((char *) HT_00012); case 12: return HT_00012;
case 20: return ((char *) HT_00020); case 20: return HT_00020;
case 21: return ((char *) HT_00021); case 21: return HT_00021;
case 22: return ((char *) HT_00022); case 22: return HT_00022;
case 23: return ((char *) HT_00023); case 23: return HT_00023;
case 30: return ((char *) HT_00030); case 30: return HT_00030;
case 40: return ((char *) HT_00040); case 40: return HT_00040;
case 50: return ((char *) HT_00050); case 50: return HT_00050;
case 60: return ((char *) HT_00060); case 60: return HT_00060;
case 100: return ((char *) HT_00100); case 100: return HT_00100;
case 101: return ((char *) HT_00101); case 101: return HT_00101;
case 110: return ((char *) HT_00110); case 110: return HT_00110;
case 111: return ((char *) HT_00111); case 111: return HT_00111;
case 112: return ((char *) HT_00112); case 112: return HT_00112;
case 120: return ((char *) HT_00120); case 120: return HT_00120;
case 121: return ((char *) HT_00121); case 121: return HT_00121;
case 122: return ((char *) HT_00122); case 122: return HT_00122;
case 124: return ((char *) HT_00124); case 124: return HT_00124;
case 125: return ((char *) HT_00125); case 125: return HT_00125;
case 130: return ((char *) HT_00130); case 130: return HT_00130;
case 131: return ((char *) HT_00131); case 131: return HT_00131;
case 132: return ((char *) HT_00132); case 132: return HT_00132;
case 133: return ((char *) HT_00133); case 133: return HT_00133;
case 140: return ((char *) HT_00140); case 140: return HT_00140;
case 141: return ((char *) HT_00141); case 141: return HT_00141;
case 150: return ((char *) HT_00150); case 150: return HT_00150;
case 160: return ((char *) HT_00160); case 160: return HT_00160;
case 200: return ((char *) HT_00200); case 200: return HT_00200;
case 300: return ((char *) HT_00300); case 300: return HT_00300;
case 400: return ((char *) HT_00400); case 400: return HT_00400;
case 500: return ((char *) HT_00500); case 500: return HT_00500;
case 501: return ((char *) HT_00501); case 501: return HT_00501;
case 600: return ((char *) HT_00600); case 600: return HT_00600;
case 900: return ((char *) HT_00900); case 900: return HT_00900;
case 1000: return ((char *) HT_01000); case 1000: return HT_01000;
case 1100: return ((char *) HT_01100); case 1100: return HT_01100;
case 1300: return ((char *) HT_01300); case 1300: return HT_01300;
case 1400: return ((char *) HT_01400); case 1400: return HT_01400;
case 1410: return ((char *) HT_01410); case 1410: return HT_01410;
case 1411: return ((char *) HT_01411); case 1411: return HT_01411;
case 1420: return ((char *) HT_01420); case 1420: return HT_01420;
case 1421: return ((char *) HT_01421); case 1421: return HT_01421;
case 1430: return ((char *) HT_01430); case 1430: return HT_01430;
case 1440: return ((char *) HT_01440); case 1440: return HT_01440;
case 1441: return ((char *) HT_01441); case 1441: return HT_01441;
case 1450: return ((char *) HT_01450); case 1450: return HT_01450;
case 1460: return ((char *) HT_01460); case 1460: return HT_01460;
case 1500: return ((char *) HT_01500); case 1500: return HT_01500;
case 1600: return ((char *) HT_01600); case 1600: return HT_01600;
case 1700: return ((char *) HT_01700); case 1700: return HT_01700;
case 1710: return ((char *) HT_01710); case 1710: return HT_01710;
case 1711: return ((char *) HT_01711); case 1711: return HT_01711;
case 1720: return ((char *) HT_01720); case 1720: return HT_01720;
case 1722: return ((char *) HT_01722); case 1722: return HT_01722;
case 1730: return ((char *) HT_01730); case 1730: return HT_01730;
case 1731: return ((char *) HT_01731); case 1731: return HT_01731;
case 1740: return ((char *) HT_01740); case 1740: return HT_01740;
case 1750: return ((char *) HT_01750); case 1750: return HT_01750;
case 1760: return ((char *) HT_01760); case 1760: return HT_01760;
case 1800: return ((char *) HT_01800); case 1800: return HT_01800;
case 2100: return ((char *) HT_02100); case 2100: return HT_02100;
case 2400: return ((char *) HT_02400); case 2400: return HT_02400;
case 2410: return ((char *) HT_02410); case 2410: return HT_02410;
case 2500: return ((char *) HT_02500); case 2500: return HT_02500;
case 2501: return ((char *) HT_02501); case 2501: return HT_02501;
case 2600: return ((char *) HT_02600); case 2600: return HT_02600;
case 2611: return ((char *) HT_02611); case 2611: return HT_02611;
case 2612: return ((char *) HT_02612); case 2612: return HT_02612;
case 2711: return ((char *) HT_02711); case 2711: return HT_02711;
case 2811: return ((char *) HT_02811); case 2811: return HT_02811;
case 3000: return ((char *) HT_03000); case 3000: return HT_03000;
case 3100: return ((char *) HT_03100); case 3100: return HT_03100;
case 3200: return ((char *) HT_03200); case 3200: return HT_03200;
case 3710: return ((char *) HT_03710); case 3710: return HT_03710;
case 3711: return ((char *) HT_03711); case 3711: return HT_03711;
case 3800: return ((char *) HT_03800); case 3800: return HT_03800;
case 3910: return ((char *) HT_03910); case 3910: return HT_03910;
case 4010: return ((char *) HT_04010); case 4010: return HT_04010;
case 4110: return ((char *) HT_04110); case 4110: return HT_04110;
case 4300: return ((char *) HT_04300); case 4300: return HT_04300;
case 4400: return ((char *) HT_04400); case 4400: return HT_04400;
case 4500: return ((char *) HT_04500); case 4500: return HT_04500;
case 4520: return ((char *) HT_04520); case 4520: return HT_04520;
case 4521: return ((char *) HT_04521); case 4521: return HT_04521;
case 4522: return ((char *) HT_04522); case 4522: return HT_04522;
case 4700: return ((char *) HT_04700); case 4700: return HT_04700;
case 4800: return ((char *) HT_04800); case 4800: return HT_04800;
case 4900: return ((char *) HT_04900); case 4900: return HT_04900;
case 5000: return ((char *) HT_05000); case 5000: return HT_05000;
case 5100: return ((char *) HT_05100); case 5100: return HT_05100;
case 5200: return ((char *) HT_05200); case 5200: return HT_05200;
case 5300: return ((char *) HT_05300); case 5300: return HT_05300;
case 5400: return ((char *) HT_05400); case 5400: return HT_05400;
case 5500: return ((char *) HT_05500); case 5500: return HT_05500;
case 5600: return ((char *) HT_05600); case 5600: return HT_05600;
case 5700: return ((char *) HT_05700); case 5700: return HT_05700;
case 5800: return ((char *) HT_05800); case 5800: return HT_05800;
case 6000: return ((char *) HT_06000); case 6000: return HT_06000;
case 6100: return ((char *) HT_06100); case 6100: return HT_06100;
case 6211: return ((char *) HT_06211); case 6211: return HT_06211;
case 6212: return ((char *) HT_06212); case 6212: return HT_06212;
case 6213: return ((char *) HT_06213); case 6213: return HT_06213;
case 6221: return ((char *) HT_06221); case 6221: return HT_06221;
case 6222: return ((char *) HT_06222); case 6222: return HT_06222;
case 6223: return ((char *) HT_06223); case 6223: return HT_06223;
case 6231: return ((char *) HT_06231); case 6231: return HT_06231;
case 6232: return ((char *) HT_06232); case 6232: return HT_06232;
case 6233: return ((char *) HT_06233); case 6233: return HT_06233;
case 6241: return ((char *) HT_06241); case 6241: return HT_06241;
case 6242: return ((char *) HT_06242); case 6242: return HT_06242;
case 6243: return ((char *) HT_06243); case 6243: return HT_06243;
case 6300: return ((char *) HT_06300); case 6300: return HT_06300;
case 6400: return ((char *) HT_06400); case 6400: return HT_06400;
case 6500: return ((char *) HT_06500); case 6500: return HT_06500;
case 6600: return ((char *) HT_06600); case 6600: return HT_06600;
case 6700: return ((char *) HT_06700); case 6700: return HT_06700;
case 6800: return ((char *) HT_06800); case 6800: return HT_06800;
case 6900: return ((char *) HT_06900); case 6900: return HT_06900;
case 7000: return ((char *) HT_07000); case 7000: return HT_07000;
case 7100: return ((char *) HT_07100); case 7100: return HT_07100;
case 7200: return ((char *) HT_07200); case 7200: return HT_07200;
case 7300: return ((char *) HT_07300); case 7300: return HT_07300;
case 7400: return ((char *) HT_07400); case 7400: return HT_07400;
case 7500: return ((char *) HT_07500); case 7500: return HT_07500;
case 7700: return ((char *) HT_07700); case 7700: return HT_07700;
case 7800: return ((char *) HT_07800); case 7800: return HT_07800;
case 7900: return ((char *) HT_07900); case 7900: return HT_07900;
case 8000: return ((char *) HT_08000); case 8000: return HT_08000;
case 8100: return ((char *) HT_08100); case 8100: return HT_08100;
case 8200: return ((char *) HT_08200); case 8200: return HT_08200;
case 8300: return ((char *) HT_08300); case 8300: return HT_08300;
case 8400: return ((char *) HT_08400); case 8400: return HT_08400;
case 8500: return ((char *) HT_08500); case 8500: return HT_08500;
case 8600: return ((char *) HT_08600); case 8600: return HT_08600;
case 8700: return ((char *) HT_08700); case 8700: return HT_08700;
case 8800: return ((char *) HT_08800); case 8800: return HT_08800;
case 8900: return ((char *) HT_08900); case 8900: return HT_08900;
case 9000: return ((char *) HT_09000); case 9000: return HT_09000;
case 9100: return ((char *) HT_09100); case 9100: return HT_09100;
case 9200: return ((char *) HT_09200); case 9200: return HT_09200;
case 9300: return ((char *) HT_09300); case 9300: return HT_09300;
case 9400: return ((char *) HT_09400); case 9400: return HT_09400;
case 9500: return ((char *) HT_09500); case 9500: return HT_09500;
case 9600: return ((char *) HT_09600); case 9600: return HT_09600;
case 9700: return ((char *) HT_09700); case 9700: return HT_09700;
case 9710: return ((char *) HT_09710); case 9710: return HT_09710;
case 9720: return ((char *) HT_09720); case 9720: return HT_09720;
case 9800: return ((char *) HT_09800); case 9800: return HT_09800;
case 9810: return ((char *) HT_09810); case 9810: return HT_09810;
case 9820: return ((char *) HT_09820); case 9820: return HT_09820;
case 9900: return ((char *) HT_09900); case 9900: return HT_09900;
case 10000: return ((char *) HT_10000); case 10000: return HT_10000;
case 10100: return ((char *) HT_10100); case 10100: return HT_10100;
case 10200: return ((char *) HT_10200); case 10200: return HT_10200;
case 10300: return ((char *) HT_10300); case 10300: return HT_10300;
case 10400: return ((char *) HT_10400); case 10400: return HT_10400;
case 10410: return ((char *) HT_10410); case 10410: return HT_10410;
case 10420: return ((char *) HT_10420); case 10420: return HT_10420;
case 10500: return ((char *) HT_10500); case 10500: return HT_10500;
case 10600: return ((char *) HT_10600); case 10600: return HT_10600;
case 10700: return ((char *) HT_10700); case 10700: return HT_10700;
case 10800: return ((char *) HT_10800); case 10800: return HT_10800;
case 10900: return ((char *) HT_10900); case 10900: return HT_10900;
case 11000: return ((char *) HT_11000); case 11000: return HT_11000;
case 11100: return ((char *) HT_11100); case 11100: return HT_11100;
case 11200: return ((char *) HT_11200); case 11200: return HT_11200;
case 11300: return ((char *) HT_11300); case 11300: return HT_11300;
case 11400: return ((char *) HT_11400); case 11400: return HT_11400;
case 11500: return ((char *) HT_11500); case 11500: return HT_11500;
case 11600: return ((char *) HT_11600); case 11600: return HT_11600;
case 11700: return ((char *) HT_11700); case 11700: return HT_11700;
case 11800: return ((char *) HT_11800); case 11800: return HT_11800;
case 11900: return ((char *) HT_11900); case 11900: return HT_11900;
case 12000: return ((char *) HT_12000); case 12000: return HT_12000;
case 12001: return ((char *) HT_12001); case 12001: return HT_12001;
case 12100: return ((char *) HT_12100); case 12100: return HT_12100;
case 12200: return ((char *) HT_12200); case 12200: return HT_12200;
case 12300: return ((char *) HT_12300); case 12300: return HT_12300;
case 12400: return ((char *) HT_12400); case 12400: return HT_12400;
case 12500: return ((char *) HT_12500); case 12500: return HT_12500;
case 12600: return ((char *) HT_12600); case 12600: return HT_12600;
case 12700: return ((char *) HT_12700); case 12700: return HT_12700;
case 12800: return ((char *) HT_12800); case 12800: return HT_12800;
case 12900: return ((char *) HT_12900); case 12900: return HT_12900;
case 13000: return ((char *) HT_13000); case 13000: return HT_13000;
case 13100: return ((char *) HT_13100); case 13100: return HT_13100;
case 13200: return ((char *) HT_13200); case 13200: return HT_13200;
case 13300: return ((char *) HT_13300); case 13300: return HT_13300;
case 13400: return ((char *) HT_13400); case 13400: return HT_13400;
case 13500: return ((char *) HT_13500); case 13500: return HT_13500;
case 13600: return ((char *) HT_13600); case 13600: return HT_13600;
case 13711: return ((char *) HT_13711); case 13711: return HT_13711;
case 13712: return ((char *) HT_13712); case 13712: return HT_13712;
case 13713: return ((char *) HT_13713); case 13713: return HT_13713;
case 13721: return ((char *) HT_13721); case 13721: return HT_13721;
case 13722: return ((char *) HT_13722); case 13722: return HT_13722;
case 13723: return ((char *) HT_13723); case 13723: return HT_13723;
case 13731: return ((char *) HT_13731); case 13731: return HT_13731;
case 13732: return ((char *) HT_13732); case 13732: return HT_13732;
case 13733: return ((char *) HT_13733); case 13733: return HT_13733;
case 13741: return ((char *) HT_13741); case 13741: return HT_13741;
case 13742: return ((char *) HT_13742); case 13742: return HT_13742;
case 13743: return ((char *) HT_13743); case 13743: return HT_13743;
case 13751: return ((char *) HT_13751); case 13751: return HT_13751;
case 13752: return ((char *) HT_13752); case 13752: return HT_13752;
case 13753: return ((char *) HT_13753); case 13753: return HT_13753;
case 13761: return ((char *) HT_13761); case 13761: return HT_13761;
case 13762: return ((char *) HT_13762); case 13762: return HT_13762;
case 13763: return ((char *) HT_13763); case 13763: return HT_13763;
case 13800: return ((char *) HT_13800); case 13800: return HT_13800;
case 13900: return ((char *) HT_13900); case 13900: return HT_13900;
case 14000: return ((char *) HT_14000); case 14000: return HT_14000;
case 14100: return ((char *) HT_14100); case 14100: return HT_14100;
case 14400: return ((char *) HT_14400); case 14400: return HT_14400;
case 14600: return ((char *) HT_14600); case 14600: return HT_14600;
case 14700: return ((char *) HT_14700); case 14700: return HT_14700;
case 14800: return ((char *) HT_14800); case 14800: return HT_14800;
case 14900: return ((char *) HT_14900); case 14900: return HT_14900;
case 15000: return ((char *) HT_15000); case 15000: return HT_15000;
case 15100: return ((char *) HT_15100); case 15100: return HT_15100;
case 15200: return ((char *) HT_15200); case 15200: return HT_15200;
case 15300: return ((char *) HT_15300); case 15300: return HT_15300;
case 15400: return ((char *) HT_15400); case 15400: return HT_15400;
case 15500: return ((char *) HT_15500); case 15500: return HT_15500;
case 15600: return ((char *) HT_15600); case 15600: return HT_15600;
case 15700: return ((char *) HT_15700); case 15700: return HT_15700;
case 15900: return ((char *) HT_15900); case 15900: return HT_15900;
case 16000: return ((char *) HT_16000); case 16000: return HT_16000;
case 99999: return ((char *) HT_99999); case 99999: return HT_99999;
} }
return ((char *) "Unknown"); return "Unknown";
} }
char *strparser (const u32 parser_status) const char *strparser (const u32 parser_status)
{ {
switch (parser_status) switch (parser_status)
{ {
case PARSER_OK: return ((char *) PA_000); case PARSER_OK: return PA_000;
case PARSER_COMMENT: return ((char *) PA_001); case PARSER_COMMENT: return PA_001;
case PARSER_GLOBAL_ZERO: return ((char *) PA_002); case PARSER_GLOBAL_ZERO: return PA_002;
case PARSER_GLOBAL_LENGTH: return ((char *) PA_003); case PARSER_GLOBAL_LENGTH: return PA_003;
case PARSER_HASH_LENGTH: return ((char *) PA_004); case PARSER_HASH_LENGTH: return PA_004;
case PARSER_HASH_VALUE: return ((char *) PA_005); case PARSER_HASH_VALUE: return PA_005;
case PARSER_SALT_LENGTH: return ((char *) PA_006); case PARSER_SALT_LENGTH: return PA_006;
case PARSER_SALT_VALUE: return ((char *) PA_007); case PARSER_SALT_VALUE: return PA_007;
case PARSER_SALT_ITERATION: return ((char *) PA_008); case PARSER_SALT_ITERATION: return PA_008;
case PARSER_SEPARATOR_UNMATCHED: return ((char *) PA_009); case PARSER_SEPARATOR_UNMATCHED: return PA_009;
case PARSER_SIGNATURE_UNMATCHED: return ((char *) PA_010); case PARSER_SIGNATURE_UNMATCHED: return PA_010;
case PARSER_HCCAPX_FILE_SIZE: return ((char *) PA_011); case PARSER_HCCAPX_FILE_SIZE: return PA_011;
case PARSER_HCCAPX_EAPOL_LEN: return ((char *) PA_012); case PARSER_HCCAPX_EAPOL_LEN: return PA_012;
case PARSER_PSAFE2_FILE_SIZE: return ((char *) PA_013); case PARSER_PSAFE2_FILE_SIZE: return PA_013;
case PARSER_PSAFE3_FILE_SIZE: return ((char *) PA_014); case PARSER_PSAFE3_FILE_SIZE: return PA_014;
case PARSER_TC_FILE_SIZE: return ((char *) PA_015); case PARSER_TC_FILE_SIZE: return PA_015;
case PARSER_VC_FILE_SIZE: return ((char *) PA_016); case PARSER_VC_FILE_SIZE: return PA_016;
case PARSER_SIP_AUTH_DIRECTIVE: return ((char *) PA_017); case PARSER_SIP_AUTH_DIRECTIVE: return PA_017;
case PARSER_HASH_FILE: return ((char *) PA_018); case PARSER_HASH_FILE: return PA_018;
case PARSER_HASH_ENCODING: return ((char *) PA_019); case PARSER_HASH_ENCODING: return PA_019;
case PARSER_SALT_ENCODING: return ((char *) PA_020); case PARSER_SALT_ENCODING: return PA_020;
case PARSER_LUKS_FILE_SIZE: return ((char *) PA_021); case PARSER_LUKS_FILE_SIZE: return PA_021;
case PARSER_LUKS_MAGIC: return ((char *) PA_022); case PARSER_LUKS_MAGIC: return PA_022;
case PARSER_LUKS_VERSION: return ((char *) PA_023); case PARSER_LUKS_VERSION: return PA_023;
case PARSER_LUKS_CIPHER_TYPE: return ((char *) PA_024); case PARSER_LUKS_CIPHER_TYPE: return PA_024;
case PARSER_LUKS_CIPHER_MODE: return ((char *) PA_025); case PARSER_LUKS_CIPHER_MODE: return PA_025;
case PARSER_LUKS_HASH_TYPE: return ((char *) PA_026); case PARSER_LUKS_HASH_TYPE: return PA_026;
case PARSER_LUKS_KEY_SIZE: return ((char *) PA_027); case PARSER_LUKS_KEY_SIZE: return PA_027;
case PARSER_LUKS_KEY_DISABLED: return ((char *) PA_028); case PARSER_LUKS_KEY_DISABLED: return PA_028;
case PARSER_LUKS_KEY_STRIPES: return ((char *) PA_029); case PARSER_LUKS_KEY_STRIPES: return PA_029;
case PARSER_LUKS_HASH_CIPHER: return ((char *) PA_030); case PARSER_LUKS_HASH_CIPHER: return PA_030;
case PARSER_HCCAPX_SIGNATURE: return ((char *) PA_031); case PARSER_HCCAPX_SIGNATURE: return PA_031;
case PARSER_HCCAPX_VERSION: return ((char *) PA_032); case PARSER_HCCAPX_VERSION: return PA_032;
case PARSER_HCCAPX_MESSAGE_PAIR: return ((char *) PA_033); case PARSER_HCCAPX_MESSAGE_PAIR: return PA_033;
} }
return ((char *) PA_255); return PA_255;
} }
int check_old_hccap (const char *hashfile) int check_old_hccap (const char *hashfile)

20
src/main.c
Unescape View File

@ -436,7 +436,7 @@ static void main_outerloop_mainscreen (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx,
{ {
if (user_options->machine_readable == false) if (user_options->machine_readable == false)
{ {
char *hash_type = strhashtype (hashconfig->hash_mode); // not a bug const char *hash_type = strhashtype (hashconfig->hash_mode); // not a bug
event_log_info (hashcat_ctx, "Hashmode: %d - %s", hashconfig->hash_mode, hash_type); event_log_info (hashcat_ctx, "Hashmode: %d - %s", hashconfig->hash_mode, hash_type);
event_log_info (hashcat_ctx, NULL); event_log_info (hashcat_ctx, NULL);
@ -591,7 +591,7 @@ static void main_monitor_throttle1 (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAY
clear_prompt (); clear_prompt ();
} }
u32 *device_id = (u32 *) buf; const u32 *device_id = (const u32 *) buf;
event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1); event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1);
@ -613,7 +613,7 @@ static void main_monitor_throttle2 (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAY
clear_prompt (); clear_prompt ();
} }
u32 *device_id = (u32 *) buf; const u32 *device_id = (const u32 *) buf;
event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1); event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1);
@ -635,7 +635,7 @@ static void main_monitor_throttle3 (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MAY
clear_prompt (); clear_prompt ();
} }
u32 *device_id = (u32 *) buf; const u32 *device_id = (const u32 *) buf;
event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1); event_log_warning (hashcat_ctx, "Driver temperature threshold met on GPU #%u. Expect reduced performance.", *device_id + 1);
event_log_warning (hashcat_ctx, NULL); event_log_warning (hashcat_ctx, NULL);
@ -705,7 +705,7 @@ static void main_monitor_temp_abort (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA
clear_prompt (); clear_prompt ();
} }
u32 *device_id = (u32 *) buf; const u32 *device_id = (const u32 *) buf;
event_log_error (hashcat_ctx, "Temperature limit on GPU #%u reached, aborting...", *device_id + 1); event_log_error (hashcat_ctx, "Temperature limit on GPU #%u reached, aborting...", *device_id + 1);
} }
@ -771,7 +771,7 @@ static void main_wordlist_cache_hit (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, MA
if (user_options->quiet == true) return; if (user_options->quiet == true) return;
cache_hit_t *cache_hit = (cache_hit_t *) buf; const cache_hit_t *cache_hit = (const cache_hit_t *) buf;
event_log_info (hashcat_ctx, "Dictionary cache hit:"); event_log_info (hashcat_ctx, "Dictionary cache hit:");
event_log_info (hashcat_ctx, "* Filename..: %s", cache_hit->dictfile); event_log_info (hashcat_ctx, "* Filename..: %s", cache_hit->dictfile);
@ -787,7 +787,7 @@ static void main_wordlist_cache_generate (MAYBE_UNUSED hashcat_ctx_t *hashcat_ct
if (user_options->quiet == true) return; if (user_options->quiet == true) return;
cache_generate_t *cache_generate = (cache_generate_t *) buf; const cache_generate_t *cache_generate = (const cache_generate_t *) buf;
if (cache_generate->percent < 100) if (cache_generate->percent < 100)
{ {
@ -824,7 +824,7 @@ static void main_hashlist_count_lines_pre (MAYBE_UNUSED hashcat_ctx_t *hashcat_c
if (user_options->quiet == true) return; if (user_options->quiet == true) return;
char *hashfile = (char *) buf; const char *hashfile = (const char *) buf;
event_log_info_nn (hashcat_ctx, "Counting lines in %s...", hashfile); event_log_info_nn (hashcat_ctx, "Counting lines in %s...", hashfile);
} }
@ -835,7 +835,7 @@ static void main_hashlist_count_lines_post (MAYBE_UNUSED hashcat_ctx_t *hashcat_
if (user_options->quiet == true) return; if (user_options->quiet == true) return;
char *hashfile = (char *) buf; const char *hashfile = (const char *) buf;
event_log_info_nn (hashcat_ctx, "Counted lines in %s...", hashfile); event_log_info_nn (hashcat_ctx, "Counted lines in %s...", hashfile);
} }
@ -846,7 +846,7 @@ static void main_hashlist_parse_hash (MAYBE_UNUSED hashcat_ctx_t *hashcat_ctx, M
if (user_options->quiet == true) return; if (user_options->quiet == true) return;
hashlist_parse_t *hashlist_parse = (hashlist_parse_t *) buf; const hashlist_parse_t *hashlist_parse = (const hashlist_parse_t *) buf;
const u32 hashes_cnt = hashlist_parse->hashes_cnt; const u32 hashes_cnt = hashlist_parse->hashes_cnt;
const u32 hashes_avail = hashlist_parse->hashes_avail; const u32 hashes_avail = hashlist_parse->hashes_avail;

4
src/mpsp.c
Unescape View File

@ -23,8 +23,8 @@ static const char *DEF_MASK = "?1?2?2?2?2?2?2?3?3?3?3?d?d?d?d";
static int sp_comp_val (const void *p1, const void *p2) static int sp_comp_val (const void *p1, const void *p2)
{ {
hcstat_table_t *b1 = (hcstat_table_t *) p1; const hcstat_table_t *b1 = (const hcstat_table_t *) p1;
hcstat_table_t *b2 = (hcstat_table_t *) p2; const hcstat_table_t *b2 = (const hcstat_table_t *) p2;
return b2->val - b1->val; return b2->val - b1->val;
} }

2
src/shared.c
Unescape View File

@ -194,7 +194,7 @@ void *hc_bsearch_r (const void *key, const void *base, size_t nmemb, size_t size
const size_t c = l + m; const size_t c = l + m;
const char *next = (char *) base + (c * size); const char *next = (const char *) base + (c * size);
const int cmp = (*compar) (key, next, arg); const int cmp = (*compar) (key, next, arg);

50
src/status.c
Unescape View File

@ -74,35 +74,35 @@ void format_timer_display (struct tm *tm, char *buf, size_t len)
if (tm->tm_year - 70) if (tm->tm_year - 70)
{ {
char *time_entity1 = ((tm->tm_year - 70) == 1) ? (char *) time_entities_s[0] : (char *) time_entities_m[0]; const char *time_entity1 = ((tm->tm_year - 70) == 1) ? time_entities_s[0] : time_entities_m[0];
char *time_entity2 = ( tm->tm_yday == 1) ? (char *) time_entities_s[1] : (char *) time_entities_m[1]; const char *time_entity2 = ( tm->tm_yday == 1) ? time_entities_s[1] : time_entities_m[1];
snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_year - 70, time_entity1, tm->tm_yday, time_entity2); snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_year - 70, time_entity1, tm->tm_yday, time_entity2);
} }
else if (tm->tm_yday) else if (tm->tm_yday)
{ {
char *time_entity1 = (tm->tm_yday == 1) ? (char *) time_entities_s[1] : (char *) time_entities_m[1]; const char *time_entity1 = (tm->tm_yday == 1) ? time_entities_s[1] : time_entities_m[1];
char *time_entity2 = (tm->tm_hour == 1) ? (char *) time_entities_s[2] : (char *) time_entities_m[2]; const char *time_entity2 = (tm->tm_hour == 1) ? time_entities_s[2] : time_entities_m[2];
snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_yday, time_entity1, tm->tm_hour, time_entity2); snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_yday, time_entity1, tm->tm_hour, time_entity2);
} }
else if (tm->tm_hour) else if (tm->tm_hour)
{ {
char *time_entity1 = (tm->tm_hour == 1) ? (char *) time_entities_s[2] : (char *) time_entities_m[2]; const char *time_entity1 = (tm->tm_hour == 1) ? time_entities_s[2] : time_entities_m[2];
char *time_entity2 = (tm->tm_min == 1) ? (char *) time_entities_s[3] : (char *) time_entities_m[3]; const char *time_entity2 = (tm->tm_min == 1) ? time_entities_s[3] : time_entities_m[3];
snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_hour, time_entity1, tm->tm_min, time_entity2); snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_hour, time_entity1, tm->tm_min, time_entity2);
} }
else if (tm->tm_min) else if (tm->tm_min)
{ {
char *time_entity1 = (tm->tm_min == 1) ? (char *) time_entities_s[3] : (char *) time_entities_m[3]; const char *time_entity1 = (tm->tm_min == 1) ? time_entities_s[3] : time_entities_m[3];
char *time_entity2 = (tm->tm_sec == 1) ? (char *) time_entities_s[4] : (char *) time_entities_m[4]; const char *time_entity2 = (tm->tm_sec == 1) ? time_entities_s[4] : time_entities_m[4];
snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_min, time_entity1, tm->tm_sec, time_entity2); snprintf (buf, len - 1, "%d %s, %d %s", tm->tm_min, time_entity1, tm->tm_sec, time_entity2);
} }
else else
{ {
char *time_entity1 = (tm->tm_sec == 1) ? (char *) time_entities_s[4] : (char *) time_entities_m[4]; const char *time_entity1 = (tm->tm_sec == 1) ? time_entities_s[4] : time_entities_m[4];
snprintf (buf, len - 1, "%d %s", tm->tm_sec, time_entity1); snprintf (buf, len - 1, "%d %s", tm->tm_sec, time_entity1);
} }
@ -197,7 +197,7 @@ char *status_get_session (const hashcat_ctx_t *hashcat_ctx)
return strdup (user_options->session); return strdup (user_options->session);
} }
char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx) const char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx)
{ {
const status_ctx_t *status_ctx = hashcat_ctx->status_ctx; const status_ctx_t *status_ctx = hashcat_ctx->status_ctx;
@ -209,27 +209,27 @@ char *status_get_status_string (const hashcat_ctx_t *hashcat_ctx)
{ {
if (status_ctx->checkpoint_shutdown == true) if (status_ctx->checkpoint_shutdown == true)
{ {
return ((char *) ST_0012); return ST_0012;
} }
} }
switch (devices_status) switch (devices_status)
{ {
case STATUS_INIT: return ((char *) ST_0000); case STATUS_INIT: return ST_0000;
case STATUS_AUTOTUNE: return ((char *) ST_0001); case STATUS_AUTOTUNE: return ST_0001;
case STATUS_SELFTEST: return ((char *) ST_0002); case STATUS_SELFTEST: return ST_0002;
case STATUS_RUNNING: return ((char *) ST_0003); case STATUS_RUNNING: return ST_0003;
case STATUS_PAUSED: return ((char *) ST_0004); case STATUS_PAUSED: return ST_0004;
case STATUS_EXHAUSTED: return ((char *) ST_0005); case STATUS_EXHAUSTED: return ST_0005;
case STATUS_CRACKED: return ((char *) ST_0006); case STATUS_CRACKED: return ST_0006;
case STATUS_ABORTED: return ((char *) ST_0007); case STATUS_ABORTED: return ST_0007;
case STATUS_QUIT: return ((char *) ST_0008); case STATUS_QUIT: return ST_0008;
case STATUS_BYPASS: return ((char *) ST_0009); case STATUS_BYPASS: return ST_0009;
case STATUS_ABORTED_CHECKPOINT: return ((char *) ST_0010); case STATUS_ABORTED_CHECKPOINT: return ST_0010;
case STATUS_ABORTED_RUNTIME: return ((char *) ST_0011); case STATUS_ABORTED_RUNTIME: return ST_0011;
} }
return ((char *) ST_9999); return ST_9999;
} }
int status_get_status_number (const hashcat_ctx_t *hashcat_ctx) int status_get_status_number (const hashcat_ctx_t *hashcat_ctx)
@ -239,7 +239,7 @@ int status_get_status_number (const hashcat_ctx_t *hashcat_ctx)
return status_ctx->devices_status; return status_ctx->devices_status;
} }
char *status_get_hash_type (const hashcat_ctx_t *hashcat_ctx) const char *status_get_hash_type (const hashcat_ctx_t *hashcat_ctx)
{ {
const hashconfig_t *hashconfig = hashcat_ctx->hashconfig; const hashconfig_t *hashconfig = hashcat_ctx->hashconfig;

6
src/wordlist.c
Unescape View File

@ -347,7 +347,7 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
cache_hit_t cache_hit; cache_hit_t cache_hit;
cache_hit.dictfile = (char *) dictfile; cache_hit.dictfile = dictfile;
cache_hit.stat.st_size = d.stat.st_size; cache_hit.stat.st_size = d.stat.st_size;
cache_hit.cached_cnt = cached_cnt; cache_hit.cached_cnt = cached_cnt;
cache_hit.keyspace = keyspace; cache_hit.keyspace = keyspace;
@ -461,7 +461,7 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
{ {
cache_generate_t cache_generate; cache_generate_t cache_generate;
cache_generate.dictfile = (char *) dictfile; cache_generate.dictfile = dictfile;
cache_generate.comp = comp; cache_generate.comp = comp;
cache_generate.percent = percent; cache_generate.percent = percent;
cache_generate.cnt = cnt; cache_generate.cnt = cnt;
@ -477,7 +477,7 @@ int count_words (hashcat_ctx_t *hashcat_ctx, FILE *fd, const char *dictfile, u64
cache_generate_t cache_generate; cache_generate_t cache_generate;
cache_generate.dictfile = (char *) dictfile; cache_generate.dictfile = dictfile;
cache_generate.comp = comp; cache_generate.comp = comp;
cache_generate.percent = 100; cache_generate.percent = 100;
cache_generate.cnt = cnt; cache_generate.cnt = cnt;

Write Preview
Loading…
Cancel
Save