DeforaNetworks/hashcat
3
0
Fork 0
Code Releases Activity

minor: some code formatting changes for PKZIP

Browse Source
This commit is contained in:
philsmd
2019-06-07 17:24:13 +02:00
parent 316b2952b5
commit 01a511b9dd
26 changed files with 299 additions and 293 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
src/modules/module_17200.c
View File

@@ -186,91 +186,93 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
char input[line_len + 1];
input[line_len] = '\0';
memcpy(&input, line_buf, line_len);
memcpy (&input, line_buf, line_len);
char *p = strtok(input, "*");
char *p = strtok (input, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
if (strncmp(p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp(p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
if (strncmp (p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp (p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
pkzip->version = 1;
if(strlen(p) == 9) pkzip->version = 2;
if (strlen (p) == 9) pkzip->version = 2;
char sub[2];
sub[0] = p[strlen(p) - 1];
sub[0] = p[strlen (p) - 1];
sub[1] = '\0';
pkzip->hash_count = atoi(sub);
pkzip->hash_count = atoi (sub);
// check here that the hash_count is valid for the attack type
if(pkzip->hash_count != 1) return PARSER_HASH_VALUE;
if (pkzip->hash_count != 1) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->checksum_size = atoi(p);
pkzip->checksum_size = atoi (p);
if (pkzip->checksum_size != 1 && pkzip->checksum_size != 2) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.data_type_enum = atoi(p);
pkzip->hash.data_type_enum = atoi (p);
if (pkzip->hash.data_type_enum > 3) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.magic_type_enum = atoi(p);
pkzip->hash.magic_type_enum = atoi (p);
if(pkzip->hash.data_type_enum > 1)
if (pkzip->hash.data_type_enum > 1)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.compressed_length = strtoul(p, NULL, 16);
pkzip->hash.compressed_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.uncompressed_length = strtoul(p, NULL, 16);
pkzip->hash.uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hash.compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%x", &(pkzip->hash.crc32));
sscanf (p, "%x", &(pkzip->hash.crc32));
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.offset = strtoul(p, NULL, 16);
pkzip->hash.offset = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.additional_offset = strtoul(p, NULL, 16);
pkzip->hash.additional_offset = strtoul (p, NULL, 16);
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.compression_type = atoi(p);
pkzip->hash.compression_type = atoi (p);
if (pkzip->hash.compression_type != 8) return PARSER_PKZIP_CT_UNMATCHED;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.data_length = strtoul(p, NULL, 16);
pkzip->hash.data_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hash.checksum_from_crc));
if(pkzip->version == 2)
sscanf (p, "%hx", &(pkzip->hash.checksum_from_crc));
if (pkzip->version == 2)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hash.checksum_from_timestamp));
sscanf (p, "%hx", &(pkzip->hash.checksum_from_timestamp));
}
else
{
pkzip->hash.checksum_from_timestamp = pkzip->hash.checksum_from_crc;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
hex_to_binary(p, strlen(p), (char *) &(pkzip->hash.data));
hex_to_binary (p, strlen (p), (char *) &(pkzip->hash.data));
// fake salt
u32 *ptr = (u32 *) pkzip->hash.data;

71
src/modules/module_17210.c
View File

@@ -186,91 +186,92 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
char input[line_len + 1];
input[line_len] = '\0';
memcpy(&input, line_buf, line_len);
memcpy (&input, line_buf, line_len);
char *p = strtok(input, "*");
char *p = strtok (input, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
if (strncmp(p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp(p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
if (strncmp (p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp (p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
pkzip->version = 1;
if(strlen(p) == 9) pkzip->version = 2;
if (strlen (p) == 9) pkzip->version = 2;
char sub[2];
sub[0] = p[strlen(p) - 1];
sub[0] = p[strlen (p) - 1];
sub[1] = '\0';
pkzip->hash_count = atoi(sub);
pkzip->hash_count = atoi (sub);
// check here that the hash_count is valid for the attack type
if(pkzip->hash_count != 1) return PARSER_HASH_VALUE;
if (pkzip->hash_count != 1) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->checksum_size = atoi(p);
pkzip->checksum_size = atoi (p);
if (pkzip->checksum_size != 1 && pkzip->checksum_size != 2) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.data_type_enum = atoi(p);
pkzip->hash.data_type_enum = atoi (p);
if (pkzip->hash.data_type_enum > 3) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.magic_type_enum = atoi(p);
pkzip->hash.magic_type_enum = atoi (p);
if(pkzip->hash.data_type_enum > 1)
if (pkzip->hash.data_type_enum > 1)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.compressed_length = strtoul(p, NULL, 16);
pkzip->hash.compressed_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.uncompressed_length = strtoul(p, NULL, 16);
pkzip->hash.uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hash.compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%x", &(pkzip->hash.crc32));
sscanf (p, "%x", & (pkzip->hash.crc32));
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.offset = strtoul(p, NULL, 16);
pkzip->hash.offset = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.additional_offset = strtoul(p, NULL, 16);
pkzip->hash.additional_offset = strtoul (p, NULL, 16);
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.compression_type = atoi(p);
pkzip->hash.compression_type = atoi (p);
if (pkzip->hash.compression_type != 0) return PARSER_PKZIP_CT_UNMATCHED;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hash.data_length = strtoul(p, NULL, 16);
pkzip->hash.data_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hash.checksum_from_crc));
if(pkzip->version == 2)
sscanf (p, "%hx", &(pkzip->hash.checksum_from_crc));
if (pkzip->version == 2)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hash.checksum_from_timestamp));
sscanf (p, "%hx", &(pkzip->hash.checksum_from_timestamp));
}
else
{
pkzip->hash.checksum_from_timestamp = pkzip->hash.checksum_from_crc;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
hex_to_binary(p, strlen(p), (char *) &(pkzip->hash.data));
hex_to_binary (p, strlen (p), (char *) &(pkzip->hash.data));
// fake salt
u32 *ptr = (u32 *) pkzip->hash.data;

73
src/modules/module_17220.c
View File

@@ -186,93 +186,94 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
char input[line_len + 1];
input[line_len] = '\0';
memcpy(&input, line_buf, line_len);
memcpy (&input, line_buf, line_len);
char *p = strtok(input, "*");
char *p = strtok (input, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
if (strncmp(p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp(p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
if (strncmp (p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp (p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
pkzip->version = 1;
if(strlen(p) == 9) pkzip->version = 2;
if (strlen (p) == 9) pkzip->version = 2;
char sub[2];
sub[0] = p[strlen(p) - 1];
sub[0] = p[strlen (p) - 1];
sub[1] = '\0';
pkzip->hash_count = atoi(sub);
pkzip->hash_count = atoi (sub);
// check here that the hash_count is valid for the attack type
if(pkzip->hash_count > 8) return PARSER_HASH_VALUE;
if (pkzip->hash_count > 8) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->checksum_size = atoi(p);
pkzip->checksum_size = atoi (p);
if (pkzip->checksum_size != 1 && pkzip->checksum_size != 2) return PARSER_HASH_LENGTH;
for(int i = 0; i < pkzip->hash_count; i++)
for (int i = 0; i < pkzip->hash_count; i++)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_type_enum = atoi(p);
pkzip->hashes[i].data_type_enum = atoi (p);
if (pkzip->hashes[i].data_type_enum > 3) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].magic_type_enum = atoi(p);
pkzip->hashes[i].magic_type_enum = atoi (p);
if(pkzip->hashes[i].data_type_enum > 1)
if (pkzip->hashes[i].data_type_enum > 1)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].compressed_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].uncompressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hashes[i].compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%x", &(pkzip->hashes[i].crc32));
sscanf (p, "%x", &(pkzip->hashes[i].crc32));
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].offset = strtoul(p, NULL, 16);
pkzip->hashes[i].offset = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].additional_offset = strtoul(p, NULL, 16);
pkzip->hashes[i].additional_offset = strtoul (p, NULL, 16);
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compression_type = atoi(p);
pkzip->hashes[i].compression_type = atoi (p);
if (pkzip->hashes[i].compression_type != 8) return PARSER_PKZIP_CT_UNMATCHED;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_length = strtoul(p, NULL, 16);
pkzip->hashes[i].data_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if(pkzip->version == 2)
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if (pkzip->version == 2)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
}
else
{
pkzip->hashes[i].checksum_from_timestamp = pkzip->hashes[i].checksum_from_crc;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
hex_to_binary(p, strlen(p), (char *) &(pkzip->hashes[i].data));
hex_to_binary (p, strlen (p), (char *) &(pkzip->hashes[i].data));
// fake salt
u32 *ptr = (u32 *) pkzip->hashes[i].data;

73
src/modules/module_17225.c
View File

@@ -186,93 +186,94 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
char input[line_len + 1];
input[line_len] = '\0';
memcpy(&input, line_buf, line_len);
memcpy (&input, line_buf, line_len);
char *p = strtok(input, "*");
char *p = strtok (input, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
if (strncmp(p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp(p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
if (strncmp (p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp (p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
pkzip->version = 1;
if(strlen(p) == 9) pkzip->version = 2;
if (strlen (p) == 9) pkzip->version = 2;
char sub[2];
sub[0] = p[strlen(p) - 1];
sub[0] = p[strlen (p) - 1];
sub[1] = '\0';
pkzip->hash_count = atoi(sub);
pkzip->hash_count = atoi (sub);
// check here that the hash_count is valid for the attack type
if(pkzip->hash_count > 8) return PARSER_HASH_VALUE;
if (pkzip->hash_count > 8) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->checksum_size = atoi(p);
pkzip->checksum_size = atoi (p);
if (pkzip->checksum_size != 1 && pkzip->checksum_size != 2) return PARSER_HASH_LENGTH;
for(int i = 0; i < pkzip->hash_count; i++)
for (int i = 0; i < pkzip->hash_count; i++)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_type_enum = atoi(p);
pkzip->hashes[i].data_type_enum = atoi (p);
if (pkzip->hashes[i].data_type_enum > 3) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].magic_type_enum = atoi(p);
pkzip->hashes[i].magic_type_enum = atoi (p);
if(pkzip->hashes[i].data_type_enum > 1)
if (pkzip->hashes[i].data_type_enum > 1)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].compressed_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].uncompressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hashes[i].compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%x", &(pkzip->hashes[i].crc32));
sscanf (p, "%x", &(pkzip->hashes[i].crc32));
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].offset = strtoul(p, NULL, 16);
pkzip->hashes[i].offset = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].additional_offset = strtoul(p, NULL, 16);
pkzip->hashes[i].additional_offset = strtoul (p, NULL, 16);
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compression_type = atoi(p);
pkzip->hashes[i].compression_type = atoi (p);
if (pkzip->hashes[i].compression_type != 8 && pkzip->hashes[i].compression_type != 0) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_length = strtoul(p, NULL, 16);
pkzip->hashes[i].data_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if(pkzip->version == 2)
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if (pkzip->version == 2)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
}
else
{
pkzip->hashes[i].checksum_from_timestamp = pkzip->hashes[i].checksum_from_crc;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
hex_to_binary(p, strlen(p), (char *) &(pkzip->hashes[i].data));
hex_to_binary (p, strlen (p), (char *) &(pkzip->hashes[i].data));
// fake salt
u32 *ptr = (u32 *) pkzip->hashes[i].data;

75
src/modules/module_17230.c
View File

@@ -186,94 +186,95 @@ int module_hash_decode (MAYBE_UNUSED const hashconfig_t *hashconfig, MAYBE_UNUSE
char input[line_len + 1];
input[line_len] = '\0';
memcpy(&input, line_buf, line_len);
memcpy (&input, line_buf, line_len);
char *p = strtok(input, "*");
char *p = strtok (input, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
if (strncmp(p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp(p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
if (strncmp (p, SIGNATURE_PKZIP_V1, 7) != 0 && strncmp (p, SIGNATURE_PKZIP_V2, 8) != 0) return PARSER_SIGNATURE_UNMATCHED;
pkzip->version = 1;
if(strlen(p) == 9) pkzip->version = 2;
if (strlen (p) == 9) pkzip->version = 2;
char sub[2];
sub[0] = p[strlen(p) - 1];
sub[0] = p[strlen (p) - 1];
sub[1] = '\0';
pkzip->hash_count = atoi(sub);
pkzip->hash_count = atoi (sub);
// check here that the hash_count is valid for the attack type
if(pkzip->hash_count > 8) return PARSER_HASH_VALUE;
if(pkzip->hash_count < 3) return PARSER_HASH_VALUE;
if (pkzip->hash_count > 8) return PARSER_HASH_VALUE;
if (pkzip->hash_count < 3) return PARSER_HASH_VALUE;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->checksum_size = atoi(p);
pkzip->checksum_size = atoi (p);
if (pkzip->checksum_size != 1 && pkzip->checksum_size != 2) return PARSER_HASH_LENGTH;
for(int i = 0; i < pkzip->hash_count; i++)
for (int i = 0; i < pkzip->hash_count; i++)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_type_enum = atoi(p);
pkzip->hashes[i].data_type_enum = atoi (p);
if (pkzip->hashes[i].data_type_enum > 3) return PARSER_HASH_LENGTH;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].magic_type_enum = atoi(p);
pkzip->hashes[i].magic_type_enum = atoi (p);
if(pkzip->hashes[i].data_type_enum > 1)
if (pkzip->hashes[i].data_type_enum > 1)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].compressed_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].uncompressed_length = strtoul(p, NULL, 16);
pkzip->hashes[i].uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hashes[i].compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%x", &(pkzip->hashes[i].crc32));
sscanf (p, "%x", &(pkzip->hashes[i].crc32));
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].offset = strtoul(p, NULL, 16);
pkzip->hashes[i].offset = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].additional_offset = strtoul(p, NULL, 16);
pkzip->hashes[i].additional_offset = strtoul (p, NULL, 16);
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].compression_type = atoi(p);
pkzip->hashes[i].compression_type = atoi (p);
if (pkzip->hashes[i].compression_type != 8 && pkzip->hashes[i].compression_type != 0) return PARSER_PKZIP_CT_UNMATCHED;
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
pkzip->hashes[i].data_length = strtoul(p, NULL, 16);
pkzip->hashes[i].data_length = strtoul (p, NULL, 16);
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if(pkzip->version == 2)
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_crc));
if (pkzip->version == 2)
{
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
sscanf(p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
sscanf (p, "%hx", &(pkzip->hashes[i].checksum_from_timestamp));
}
else
{
pkzip->hashes[i].checksum_from_timestamp = pkzip->hashes[i].checksum_from_crc;
}
p = strtok(NULL, "*");
p = strtok (NULL, "*");
if (p == NULL) return PARSER_HASH_LENGTH;
hex_to_binary(p, strlen(p), (char *) &(pkzip->hashes[i].data));
hex_to_binary (p, strlen (p), (char *) &(pkzip->hashes[i].data));
// fake salt
u32 *ptr = (u32 *) pkzip->hashes[i].data;