{
uint cnt = 0;
- char *buf = (char *) mymalloc (BUFSIZ + 1);
+ char *buf = (char *) mymalloc (HCBUFSIZ + 1);
char prev = '\n';
while (!feof (fd))
{
- size_t nread = fread (buf, sizeof (char), BUFSIZ, fd);
+ size_t nread = fread (buf, sizeof (char), HCBUFSIZ, fd);
if (nread < 1) continue;
line_len++;
- if (line_len == BUFSIZ) line_len--;
+ if (line_len == HCBUFSIZ) line_len--;
if (c == '\n') break;
}
case 13100: return ((char *) HT_13100); break;
case 13200: return ((char *) HT_13200); break;
case 13300: return ((char *) HT_13300); break;
+ case 13400: return ((char *) HT_13400); break;
}
return ((char *) "Unknown");
return ((char *) "Unknown");
}
-void ascii_digest (char out_buf[4096], uint salt_pos, uint digest_pos)
+void ascii_digest (char *out_buf, uint salt_pos, uint digest_pos)
{
uint hash_type = data.hash_type;
uint hash_mode = data.hash_mode;
digest_buf[2],
digest_buf[3]);
}
+ else if (hash_mode == 13400)
+ {
+ keepass_t *keepasss = (keepass_t *) data.esalts_buf;
+
+ keepass_t *keepass = &keepasss[salt_pos];
+
+ u32 version = (u32) keepass->version;
+ u32 rounds = salt.salt_iter;
+ u32 algorithm = (u32) keepass->algorithm;
+
+ u32 *ptr_final_random_seed = (u32 *) keepass->final_random_seed ;
+ u32 *ptr_transf_random_seed = (u32 *) keepass->transf_random_seed ;
+ u32 *ptr_enc_iv = (u32 *) keepass->enc_iv ;
+ u32 *ptr_contents_hash = (u32 *) keepass->contents_hash ;
+
+ /* specific to version 1 */
+ u32 contents_len;
+ u32 *ptr_contents;
+
+ /* specific to version 2 */
+ u32 expected_bytes_len;
+ u32 *ptr_expected_bytes;
+
+ u32 final_random_seed_len;
+ u32 transf_random_seed_len;
+ u32 enc_iv_len;
+ u32 contents_hash_len;
+
+ transf_random_seed_len = 8;
+ enc_iv_len = 4;
+ contents_hash_len = 8;
+ final_random_seed_len = 8;
+
+ if (version == 1)
+ final_random_seed_len = 4;
+
+ snprintf (out_buf, len-1, "%s*%d*%d*%d",
+ SIGNATURE_KEEPASS,
+ version,
+ rounds,
+ algorithm);
+
+ char *ptr_data = out_buf;
+
+ ptr_data += strlen(out_buf);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < final_random_seed_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_final_random_seed[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < transf_random_seed_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_transf_random_seed[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < enc_iv_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_enc_iv[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ if (version == 1)
+ {
+ contents_len = (u32) keepass->contents_len;
+ ptr_contents = (u32 *) keepass->contents;
+
+ for (uint i = 0; i < contents_hash_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents_hash[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ /* inline flag */
+ *ptr_data = '1';
+ ptr_data++;
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ char ptr_contents_len[10] = { 0 };
+
+ sprintf ((char*) ptr_contents_len, "%d", contents_len);
+
+ sprintf (ptr_data, "%d", contents_len);
+
+ ptr_data += strlen(ptr_contents_len);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < contents_len / 4; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents[i]);
+ }
+ else if (version == 2)
+ {
+ expected_bytes_len = 8;
+ ptr_expected_bytes = (u32 *) keepass->expected_bytes ;
+
+ for (uint i = 0; i < expected_bytes_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_expected_bytes[i]);
+
+ *ptr_data = '*';
+ ptr_data++;
+
+ for (uint i = 0; i < contents_hash_len; i++, ptr_data += 8)
+ sprintf (ptr_data, "%08x", ptr_contents_hash[i]);
+ }
+ }
else
{
if (hash_type == HASH_TYPE_MD4)
if (rd->pid)
{
- char pidbin[BUFSIZ] = { 0 };
+ char *pidbin = (char *) mymalloc (HCBUFSIZ);
int pidbin_len = -1;
#ifdef _POSIX
- snprintf (pidbin, sizeof (pidbin) - 1, "/proc/%d/cmdline", rd->pid);
+ snprintf (pidbin, HCBUFSIZ - 1, "/proc/%d/cmdline", rd->pid);
FILE *fd = fopen (pidbin, "rb");
if (fd)
{
- pidbin_len = fread (pidbin, 1, BUFSIZ, fd);
+ pidbin_len = fread (pidbin, 1, HCBUFSIZ, fd);
pidbin[pidbin_len] = 0;
#elif _WIN
HANDLE hProcess = OpenProcess (PROCESS_ALL_ACCESS, FALSE, rd->pid);
- char pidbin2[BUFSIZ] = { 0 };
+ char *pidbin2 = (char *) mymalloc (HCBUFSIZ);
int pidbin2_len = -1;
- pidbin_len = GetModuleFileName (NULL, pidbin, BUFSIZ);
- pidbin2_len = GetModuleFileNameEx (hProcess, NULL, pidbin2, BUFSIZ);
+ pidbin_len = GetModuleFileName (NULL, pidbin, HCBUFSIZ);
+ pidbin2_len = GetModuleFileNameEx (hProcess, NULL, pidbin2, HCBUFSIZ);
pidbin[pidbin_len] = 0;
pidbin2[pidbin2_len] = 0;
exit (-1);
}
}
+
+ myfree (pidbin2);
+
#endif
+
+ myfree (pidbin);
}
if (rd->version_bin < RESTORE_MIN)
rd->argv = (char **) mycalloc (rd->argc, sizeof (char *));
+ char *buf = (char *) mymalloc (HCBUFSIZ);
+
for (uint i = 0; i < rd->argc; i++)
{
- char buf[BUFSIZ] = { 0 };
-
- if (fgets (buf, BUFSIZ - 1, fp) == NULL)
+ if (fgets (buf, HCBUFSIZ - 1, fp) == NULL)
{
log_error ("ERROR: cannot read %s", eff_restore_file);
rd->argv[i] = mystrdup (buf);
}
+ myfree (buf);
+
fclose (fp);
char new_cwd[1024] = { 0 };
int line_num = 0;
+ char *buf = (char *) mymalloc (HCBUFSIZ);
+
while (!feof (fp))
{
- char buf[BUFSIZ];
-
- char *line_buf = fgets (buf, sizeof (buf) - 1, fp);
+ char *line_buf = fgets (buf, HCBUFSIZ - 1, fp);
if (line_buf == NULL) break;
}
}
+ myfree (buf);
+
fclose (fp);
// todo: print loaded 'cnt' message
int md5crypt_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
+ if (input_len < DISPLAY_LEN_MIN_500) return (PARSER_GLOBAL_LENGTH);
+
if (memcmp (SIGNATURE_MD5CRYPT, input_buf, 3)) return (PARSER_SIGNATURE_UNMATCHED);
u32 *digest = (u32 *) hash_buf->digest;
salt->salt_iter = ROUNDS_MD5CRYPT;
}
- if ((input_len < DISPLAY_LEN_MIN_500) || (input_len > (DISPLAY_LEN_MAX_500 + iterations_len))) return (PARSER_GLOBAL_LENGTH);
+ if (input_len > (DISPLAY_LEN_MAX_500 + iterations_len)) return (PARSER_GLOBAL_LENGTH);
char *hash_pos = strchr (salt_pos, '$');
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
char *hash_pos = strchr (srvchall_pos, ':');
- if (srvchall_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+ if (hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
uint srvchall_len = hash_pos - srvchall_pos;
if ((input_len < DISPLAY_LEN_MIN_13300) || (input_len > DISPLAY_LEN_MAX_13300)) return (PARSER_GLOBAL_LENGTH);
if (memcmp (SIGNATURE_AXCRYPT_SHA1, input_buf, 13)) return (PARSER_SIGNATURE_UNMATCHED);
-
+
u32 *digest = (u32 *) hash_buf->digest;
input_buf +=14;
-
+
digest[0] = hex_to_u32 ((const u8 *) &input_buf[ 0]);
digest[1] = hex_to_u32 ((const u8 *) &input_buf[ 8]);
digest[2] = hex_to_u32 ((const u8 *) &input_buf[16]);
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 6, input_len - 6, tmp_buf);
+ if (tmp_len < 20) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 20);
- salt->salt_len = tmp_len - 20;
+ int salt_len = tmp_len - 20;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 20, salt->salt_len);
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
in_off[0] = strtok (input_buf, ":");
+ if (in_off[0] == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
in_len[0] = strlen (in_off[0]);
size_t i;
int tmp_len = base64_decode (base64_to_int, (const u8 *) input_buf + 9, input_len - 9, tmp_buf);
+ if (tmp_len < 64) return (PARSER_HASH_LENGTH);
+
memcpy (digest, tmp_buf, 64);
digest[0] = byte_swap_64 (digest[0]);
digest[6] -= SHA512M_G;
digest[7] -= SHA512M_H;
- salt->salt_len = tmp_len - 64;
+ int salt_len = tmp_len - 64;
+
+ if (salt_len < 0) return (PARSER_SALT_LENGTH);
+
+ salt->salt_len = salt_len;
memcpy (salt->salt_buf, tmp_buf + 64, salt->salt_len);
u32 *digest = (u32 *) hash_buf->digest;
+ salt_t *salt = hash_buf->salt;
+
u8 tmp_buf[100] = { 0 };
base64_decode (base64_to_int, (const u8 *) input_buf, input_len, tmp_buf);
digest[3] -= SHA1M_D;
digest[4] -= SHA1M_E;
+ salt->salt_buf[0] = 0x80;
+
+ salt->salt_len = 0;
+
return (PARSER_OK);
}
// base64 decode
+ int salt_len_base64 = hash_pos - saltbuf_pos;
+
+ if (salt_len_base64 > 45) return (PARSER_SALT_LENGTH);
+
u8 tmp_buf[33] = { 0 };
- int tmp_len = base64_decode (base64_to_int, (const u8 *) saltbuf_pos, hash_pos - saltbuf_pos, tmp_buf);
+ int tmp_len = base64_decode (base64_to_int, (const u8 *) saltbuf_pos, salt_len_base64, tmp_buf);
char *salt_buf_ptr = (char *) salt->salt_buf;
char *salt_pos;
char *wrapped_key_pos;
-
+
char *data_pos;
salt->salt_iter = atoi (wrapping_rounds_pos);
-
+
salt_pos = strchr (wrapping_rounds_pos, '*');
if (salt_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
-
+
uint wrapping_rounds_len = salt_pos - wrapping_rounds_pos;
/* Skip '*' */
salt_pos++;
-
+
data_pos = salt_pos;
-
+
wrapped_key_pos = strchr (salt_pos, '*');
if (wrapped_key_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
salt->salt_buf[4] = hex_to_u32 ((const u8 *) &data_pos[ 0]);
salt->salt_buf[5] = hex_to_u32 ((const u8 *) &data_pos[ 8]);
- salt->salt_buf[6] = hex_to_u32 ((const u8 *) &data_pos[16]);
+ salt->salt_buf[6] = hex_to_u32 ((const u8 *) &data_pos[16]);
salt->salt_buf[7] = hex_to_u32 ((const u8 *) &data_pos[24]);
salt->salt_buf[8] = hex_to_u32 ((const u8 *) &data_pos[32]);
salt->salt_buf[9] = hex_to_u32 ((const u8 *) &data_pos[40]);
return (PARSER_OK);
}
+int keepass_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
+{
+ if ((input_len < DISPLAY_LEN_MIN_13400) || (input_len > DISPLAY_LEN_MAX_13400)) return (PARSER_GLOBAL_LENGTH);
+
+ if (memcmp (SIGNATURE_KEEPASS, input_buf, 9)) return (PARSER_SIGNATURE_UNMATCHED);
+
+ u32 *digest = (u32 *) hash_buf->digest;
+
+ salt_t *salt = hash_buf->salt;
+
+ keepass_t *keepass = (keepass_t *) hash_buf->esalt;
+
+ /**
+ * parse line
+ */
+
+ char *version_pos;
+
+ char *rounds_pos;
+
+ char *algorithm_pos;
+
+ char *final_random_seed_pos;
+ u32 final_random_seed_len;
+
+ char *transf_random_seed_pos;
+ u32 transf_random_seed_len;
+
+ char *enc_iv_pos;
+ u32 enc_iv_len;
+
+ /* specific to version 1 */
+ char *contents_len_pos;
+ u32 contents_len;
+ char *contents_pos;
+
+ /* specific to version 2 */
+ char *expected_bytes_pos;
+ u32 expected_bytes_len;
+
+ char *contents_hash_pos;
+ u32 contents_hash_len;
+
+ version_pos = input_buf + 8 + 1 + 1;
+
+ keepass->version = atoi (version_pos);
+
+ rounds_pos = strchr (version_pos, '*');
+ rounds_pos++;
+
+ if (rounds_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ salt->salt_iter = (atoi (rounds_pos));
+
+ algorithm_pos = strchr (rounds_pos, '*');
+ algorithm_pos++;
+
+ if (algorithm_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->algorithm = atoi (algorithm_pos);
+
+ final_random_seed_pos = strchr (algorithm_pos, '*');
+ final_random_seed_pos++;
+
+ if (final_random_seed_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->final_random_seed[0] = hex_to_u32 ((const u8 *) &final_random_seed_pos[ 0]);
+ keepass->final_random_seed[1] = hex_to_u32 ((const u8 *) &final_random_seed_pos[ 8]);
+ keepass->final_random_seed[2] = hex_to_u32 ((const u8 *) &final_random_seed_pos[16]);
+ keepass->final_random_seed[3] = hex_to_u32 ((const u8 *) &final_random_seed_pos[24]);
+
+ if (keepass->version == 2)
+ {
+ keepass->final_random_seed[4] = hex_to_u32 ((const u8 *) &final_random_seed_pos[32]);
+ keepass->final_random_seed[5] = hex_to_u32 ((const u8 *) &final_random_seed_pos[40]);
+ keepass->final_random_seed[6] = hex_to_u32 ((const u8 *) &final_random_seed_pos[48]);
+ keepass->final_random_seed[7] = hex_to_u32 ((const u8 *) &final_random_seed_pos[56]);
+ }
+
+ transf_random_seed_pos = strchr (final_random_seed_pos, '*');
+
+ final_random_seed_len = transf_random_seed_pos - final_random_seed_pos;
+
+ if (keepass->version == 1 && final_random_seed_len != 32) return (PARSER_SALT_LENGTH);
+ if (keepass->version == 2 && final_random_seed_len != 64) return (PARSER_SALT_LENGTH);
+
+ transf_random_seed_pos++;
+
+ if (transf_random_seed_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->transf_random_seed[0] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[ 0]);
+ keepass->transf_random_seed[1] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[ 8]);
+ keepass->transf_random_seed[2] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[16]);
+ keepass->transf_random_seed[3] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[24]);
+ keepass->transf_random_seed[4] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[32]);
+ keepass->transf_random_seed[5] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[40]);
+ keepass->transf_random_seed[6] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[48]);
+ keepass->transf_random_seed[7] = hex_to_u32 ((const u8 *) &transf_random_seed_pos[56]);
+
+ enc_iv_pos = strchr (transf_random_seed_pos, '*');
+
+ transf_random_seed_len = enc_iv_pos - transf_random_seed_pos;
+
+ if (transf_random_seed_len != 64) return (PARSER_SALT_LENGTH);
+
+ enc_iv_pos++;
+
+ if (enc_iv_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->enc_iv[0] = hex_to_u32 ((const u8 *) &enc_iv_pos[ 0]);
+ keepass->enc_iv[1] = hex_to_u32 ((const u8 *) &enc_iv_pos[ 8]);
+ keepass->enc_iv[2] = hex_to_u32 ((const u8 *) &enc_iv_pos[16]);
+ keepass->enc_iv[3] = hex_to_u32 ((const u8 *) &enc_iv_pos[24]);
+
+ if (keepass->version == 1)
+ {
+ contents_hash_pos = strchr (enc_iv_pos, '*');
+
+ enc_iv_len = contents_hash_pos - enc_iv_pos;
+
+ if (enc_iv_len != 32) return (PARSER_SALT_LENGTH);
+
+ contents_hash_pos++;
+
+ if (contents_hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->contents_hash[0] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 0]);
+ keepass->contents_hash[1] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 8]);
+ keepass->contents_hash[2] = hex_to_u32 ((const u8 *) &contents_hash_pos[16]);
+ keepass->contents_hash[3] = hex_to_u32 ((const u8 *) &contents_hash_pos[24]);
+ keepass->contents_hash[4] = hex_to_u32 ((const u8 *) &contents_hash_pos[32]);
+ keepass->contents_hash[5] = hex_to_u32 ((const u8 *) &contents_hash_pos[40]);
+ keepass->contents_hash[6] = hex_to_u32 ((const u8 *) &contents_hash_pos[48]);
+ keepass->contents_hash[7] = hex_to_u32 ((const u8 *) &contents_hash_pos[56]);
+
+ /* get length of contents following */
+ char *inline_flag_pos = strchr (contents_hash_pos, '*');
+
+ contents_hash_len = inline_flag_pos - contents_hash_pos;
+
+ if (contents_hash_len != 64) return (PARSER_SALT_LENGTH);
+
+ inline_flag_pos++;
+
+ u32 inline_flag = atoi (inline_flag_pos);
+
+ if (inline_flag != 1) return (PARSER_SALT_LENGTH);
+
+ contents_len_pos = strchr (inline_flag_pos, '*');
+
+ contents_len_pos++;
+
+ contents_len = atoi (contents_len_pos);
+
+ if (contents_len > 50000) return (PARSER_SALT_LENGTH);
+
+ contents_pos = strchr (contents_len_pos, '*');
+
+ contents_pos++;
+
+ u32 i;
+
+ keepass->contents_len = contents_len;
+
+ contents_len = contents_len / 4;
+
+ u32 real_contents_len = input_len - (contents_pos - input_buf);
+
+ if (real_contents_len != keepass->contents_len * 2) return (PARSER_SALT_LENGTH);
+
+ for (i = 0; i < contents_len; i++)
+ keepass->contents[i] = hex_to_u32 ((const u8 *) &contents_pos[i * 8]);
+ }
+ else if (keepass->version == 2)
+ {
+ expected_bytes_pos = strchr (enc_iv_pos, '*');
+
+ enc_iv_len = expected_bytes_pos - enc_iv_pos;
+
+ if (enc_iv_len != 32) return (PARSER_SALT_LENGTH);
+
+ expected_bytes_pos++;
+
+ if (expected_bytes_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->expected_bytes[0] = hex_to_u32 ((const u8 *) &expected_bytes_pos[ 0]);
+ keepass->expected_bytes[1] = hex_to_u32 ((const u8 *) &expected_bytes_pos[ 8]);
+ keepass->expected_bytes[2] = hex_to_u32 ((const u8 *) &expected_bytes_pos[16]);
+ keepass->expected_bytes[3] = hex_to_u32 ((const u8 *) &expected_bytes_pos[24]);
+ keepass->expected_bytes[4] = hex_to_u32 ((const u8 *) &expected_bytes_pos[32]);
+ keepass->expected_bytes[5] = hex_to_u32 ((const u8 *) &expected_bytes_pos[40]);
+ keepass->expected_bytes[6] = hex_to_u32 ((const u8 *) &expected_bytes_pos[48]);
+ keepass->expected_bytes[7] = hex_to_u32 ((const u8 *) &expected_bytes_pos[56]);
+
+ contents_hash_pos = strchr (expected_bytes_pos, '*');
+
+ expected_bytes_len = contents_hash_pos - expected_bytes_pos;
+
+ if (expected_bytes_len != 64) return (PARSER_SALT_LENGTH);
+
+ contents_hash_pos++;
+
+ if (contents_hash_pos == NULL) return (PARSER_SEPARATOR_UNMATCHED);
+
+ keepass->contents_hash[0] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 0]);
+ keepass->contents_hash[1] = hex_to_u32 ((const u8 *) &contents_hash_pos[ 8]);
+ keepass->contents_hash[2] = hex_to_u32 ((const u8 *) &contents_hash_pos[16]);
+ keepass->contents_hash[3] = hex_to_u32 ((const u8 *) &contents_hash_pos[24]);
+ keepass->contents_hash[4] = hex_to_u32 ((const u8 *) &contents_hash_pos[32]);
+ keepass->contents_hash[5] = hex_to_u32 ((const u8 *) &contents_hash_pos[40]);
+ keepass->contents_hash[6] = hex_to_u32 ((const u8 *) &contents_hash_pos[48]);
+ keepass->contents_hash[7] = hex_to_u32 ((const u8 *) &contents_hash_pos[56]);
+
+ contents_hash_len = input_len - (int) (contents_hash_pos - input_buf);
+
+ if (contents_hash_len != 64) return (PARSER_SALT_LENGTH);
+ }
+
+ digest[0] = keepass->enc_iv[0];
+ digest[1] = keepass->enc_iv[1];
+ digest[2] = keepass->enc_iv[2];
+ digest[3] = keepass->enc_iv[3];
+
+ salt->salt_buf[0] = keepass->transf_random_seed[0];
+ salt->salt_buf[1] = keepass->transf_random_seed[1];
+ salt->salt_buf[2] = keepass->transf_random_seed[2];
+ salt->salt_buf[3] = keepass->transf_random_seed[3];
+ salt->salt_buf[4] = keepass->transf_random_seed[4];
+ salt->salt_buf[5] = keepass->transf_random_seed[5];
+ salt->salt_buf[6] = keepass->transf_random_seed[6];
+ salt->salt_buf[7] = keepass->transf_random_seed[7];
+
+ return (PARSER_OK);
+}
+
int cf10_parse_hash (char *input_buf, uint input_len, hash_t *hash_buf)
{
if ((input_len < DISPLAY_LEN_MIN_12600) || (input_len > DISPLAY_LEN_MAX_12600)) return (PARSER_GLOBAL_LENGTH);
#define GET_P0_CONV(rule) INCR_POS; rule_buf[rule_pos] = 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)
-int cpu_rule_to_kernel_rule (char rule_buf[BUFSIZ], uint rule_len, kernel_rule_t *rule)
+int cpu_rule_to_kernel_rule (char *rule_buf, uint rule_len, kernel_rule_t *rule)
{
uint rule_pos;
uint rule_cnt;
return (0);
}
-int kernel_rule_to_cpu_rule (char rule_buf[BUFSIZ], kernel_rule_t *rule)
+int kernel_rule_to_cpu_rule (char *rule_buf, kernel_rule_t *rule)
{
uint rule_cnt;
uint rule_pos;
- uint rule_len = BUFSIZ - 1; // maximum possible len
+ uint rule_len = HCBUFSIZ - 1; // maximum possible len
char rule_cmd;
projects / hashcat.git / blobdiff