DeforaNetworks/hashcat
3
0
Fork 0
Code Releases Activity

Merge pull request #2053 from philsmd/master

Browse Source 
PKZIP: improve decompression and allow up to 320KB data length
This commit is contained in:
Jens Steube
2019-06-15 09:42:18 +02:00
committed by GitHub
parent 33d138098e 98759fba95
commit 0370f73a44
27 changed files with 502 additions and 413 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
src/modules/module_17200.c
View File

@@ -107,8 +107,7 @@ static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "$pkzip2$1*1*2*0*e3*1c5*eda7a8de*0*28*8*e3*eda7*5096*a9fc1f4e951c8fb3031a6f903e5f4e3211c8fdc4671547bf77f6f682afbfcc7475d83898985621a7af9bccd1349d1976500a68c48f630b7f22d7a0955524d768e34868880461335417ddd149c65a917c0eb0a4bf7224e24a1e04cf4ace5eef52205f4452e66ded937db9545f843a68b1e84a2e933cc05fb36d3db90e6c5faf1bee2249fdd06a7307849902a8bb24ec7e8a0886a4544ca47979a9dfeefe034bdfc5bd593904cfe9a5309dd199d337d3183f307c2cb39622549a5b9b8b485b7949a4803f63f67ca427a0640ad3793a519b2476c52198488e3e2e04cac202d624fb7d13c2*$/pkzip2$";
#define MAX_DATA (16 * 1024 * 1024)
#define MAX_LEN (32 * 1024)
#define MAX_DATA (320 * 1024)
// this is required to force mingw to accept the packed attribute
#pragma pack(push,1)
@@ -126,7 +125,7 @@ struct pkzip_hash
u32 data_length;
u16 checksum_from_crc;
u16 checksum_from_timestamp;
u32 data[MAX_DATA];
u32 data[MAX_DATA / 4]; // a quarter because of the u32 type
} __attribute__((packed));
@@ -187,95 +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);
if (pkzip->hash.compressed_length > MAX_DATA * 4)
pkzip->hash.uncompressed_length = strtoul (p, NULL, 16);
if (pkzip->hash.compressed_length > MAX_DATA)
{
return PARSER_TOKEN_LENGTH;
}
if (pkzip->hash.uncompressed_length > MAX_LEN)
{
return PARSER_HASH_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;

77
src/modules/module_17210.c
View File

@@ -107,7 +107,7 @@ static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "$pkzip2$1*1*2*0*1d1*1c5*eda7a8de*0*28*0*1d1*eda7*5096*1dea673da43d9fc7e2be1a1f4f664269fceb6cb88723a97408ae1fe07f774d31d1442ea8485081e63f919851ca0b7588d5e3442317fff19fe547a4ef97492ed75417c427eea3c4e146e16c100a2f8b6abd7e5988dc967e5a0e51f641401605d673630ea52ebb04da4b388489901656532c9aa474ca090dbac7cf8a21428d57b42a71da5f3d83fed927361e5d385ca8e480a6d42dea5b4bf497d3a24e79fc7be37c8d1721238cbe9e1ea3ae1eb91fc02aabdf33070d718d5105b70b3d7f3d2c28b3edd822e89a5abc0c8fee117c7fbfbfd4b4c8e130977b75cb0b1da080bfe1c0859e6483c42f459c8069d45a76220e046e6c2a2417392fd87e4aa4a2559eaab3baf78a77a1b94d8c8af16a977b4bb45e3da211838ad044f209428dba82666bf3d54d4eed82c64a9b3444a44746b9e398d0516a2596d84243b4a1d7e87d9843f38e45b6be67fd980107f3ad7b8453d87300e6c51ac9f5e3f6c3b702654440c543b1d808b62f7a313a83b31a6faaeedc2620de7057cd0df80f70346fe2d4dccc318f0b5ed128bcf0643e63d754bb05f53afb2b0fa90b34b538b2ad3648209dff587df4fa18698e4fa6d858ad44aa55d2bba3b08dfdedd3e28b8b7caf394d5d9d95e452c2ab1c836b9d74538c2f0d24b9b577*$/pkzip2$";
#define MAX_DATA (16 * 1024 * 1024)
#define MAX_DATA (320 * 1024)
// this is required to force mingw to accept the packed attribute
#pragma pack(push,1)
@@ -125,7 +125,7 @@ struct pkzip_hash
u32 data_length;
u16 checksum_from_crc;
u16 checksum_from_timestamp;
u32 data[MAX_DATA];
u32 data[MAX_DATA / 4]; // a quarter because of the u32 type
} __attribute__((packed));
@@ -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);
if (pkzip->hash.uncompressed_length > MAX_DATA * 4)
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;

82
src/modules/module_17220.c
View File

@@ -107,8 +107,7 @@ static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "$pkzip2$3*1*1*0*8*24*a425*8827*d1730095cd829e245df04ebba6c52c0573d49d3bbeab6cb385b7fa8a28dcccd3098bfdd7*1*0*8*24*2a74*882a*51281ac874a60baedc375ca645888d29780e20d4076edd1e7154a99bde982152a736311f*2*0*e3*1c5*eda7a8de*0*29*8*e3*eda7*5096*1455781b59707f5151139e018bdcfeebfc89bc37e372883a7ec0670a5eafc622feb338f9b021b6601a674094898a91beac70e41e675f77702834ca6156111a1bf7361bc9f3715d77dfcdd626634c68354c6f2e5e0a7b1e1ce84a44e632d0f6e36019feeab92fb7eac9dda8df436e287aafece95d042059a1b27d533c5eab62c1c559af220dc432f2eb1a38a70f29e8f3cb5a207704274d1e305d7402180fd47e026522792f5113c52a116d5bb25b67074ffd6f4926b221555234aabddc69775335d592d5c7d22462b75de1259e8342a9ba71cb06223d13c7f51f13be2ad76352c3b8ed*$/pkzip2$";
#define MAX_DATA (16 * 1024 * 1024)
#define MAX_LEN (32 * 1024)
#define MAX_DATA (320 * 1024)
// this is required to force mingw to accept the packed attribute
#pragma pack(push,1)
@@ -126,7 +125,7 @@ struct pkzip_hash
u32 data_length;
u16 checksum_from_crc;
u16 checksum_from_timestamp;
u32 data[MAX_DATA];
u32 data[MAX_DATA / 4]; // a quarter because of the u32 type
} __attribute__((packed));
@@ -187,97 +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;
}
if (pkzip->hashes[i].uncompressed_length > MAX_LEN)
{
return PARSER_HASH_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;

82
src/modules/module_17225.c
View File

@@ -107,8 +107,7 @@ static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "$pkzip2$3*1*1*0*0*24*3e2c*3ef8*0619e9d17ff3f994065b99b1fa8aef41c056edf9fa4540919c109742dcb32f797fc90ce0*1*0*8*24*431a*3f26*18e2461c0dbad89bd9cc763067a020c89b5e16195b1ac5fa7fb13bd246d000b6833a2988*2*0*23*17*1e3c1a16*2e4*2f*0*23*1e3c*3f2d*54ea4dbc711026561485bbd191bf300ae24fa0997f3779b688cdad323985f8d3bb8b0c*$/pkzip2$";
#define MAX_DATA (16 * 1024 * 1024)
#define MAX_LEN (32 * 1024)
#define MAX_DATA (320 * 1024)
// this is required to force mingw to accept the packed attribute
#pragma pack(push,1)
@@ -126,7 +125,7 @@ struct pkzip_hash
u32 data_length;
u16 checksum_from_crc;
u16 checksum_from_timestamp;
u32 data[MAX_DATA];
u32 data[MAX_DATA / 4]; // a quarter because of the u32 type
} __attribute__((packed));
@@ -187,97 +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;
}
if (pkzip->hashes[i].uncompressed_length > MAX_LEN)
{
return PARSER_HASH_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;

81
src/modules/module_17230.c
View File

@@ -107,7 +107,7 @@ static const u32 SALT_TYPE = SALT_TYPE_EMBEDDED;
static const char *ST_PASS = "hashcat";
static const char *ST_HASH = "$pkzip2$8*1*1*0*8*24*a425*8827*3bd479d541019c2f32395046b8fbca7e1dca218b9b5414975be49942c3536298e9cc939e*1*0*8*24*2a74*882a*537af57c30fd9fd4b3eefa9ce55b6bff3bbfada237a7c1dace8ebf3bb0de107426211da3*1*0*8*24*2a74*882a*5f406b4858d3489fd4a6a6788798ac9b924b5d0ca8b8e5a6371739c9edcfd28c82f75316*1*0*8*24*2a74*882a*1843aca546b2ea68bd844d1e99d4f74d86417248eb48dd5e956270e42a331c18ea13f5ed*1*0*8*24*2a74*882a*aca3d16543bbfb2e5d2659f63802e0fa5b33e0a1f8ae47334019b4f0b6045d3d8eda3af1*1*0*8*24*2a74*882a*fbe0efc9e10ae1fc9b169bd060470bf3e39f09f8d83bebecd5216de02b81e35fe7e7b2f2*1*0*8*24*2a74*882a*537886dbabffbb7cac77deb01dc84760894524e6966183b4478a4ef56f0c657375a235a1*1*0*8*24*eda7*5096*40eb30ef1ddd9b77b894ed46abf199b480f1e5614fde510855f92ae7b8026a11f80e4d5f*$/pkzip2$";
#define MAX_DATA (16 * 1024 * 1024)
#define MAX_DATA (320 * 1024)
// this is required to force mingw to accept the packed attribute
#pragma pack(push,1)
@@ -125,7 +125,7 @@ struct pkzip_hash
u32 data_length;
u16 checksum_from_crc;
u16 checksum_from_timestamp;
u32 data[MAX_DATA];
u32 data[MAX_DATA / 4]; // a quarter because of the u32 type
} __attribute__((packed));
@@ -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);
if (pkzip->hashes[i].compressed_length > MAX_DATA * 4)
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;