From 71c12c18281dbacb21c485afd462b7d06ec310fb Mon Sep 17 00:00:00 2001 From: PhaseLoop Date: Fri, 16 Jun 2023 20:48:57 +0000 Subject: [PATCH] smart generators core settings --- common/bruteforce.c | 98 ++++++++++++++++++++++++++++++++------------- common/bruteforce.h | 24 ++++++++--- 2 files changed, 90 insertions(+), 32 deletions(-) diff --git a/common/bruteforce.c b/common/bruteforce.c index 00d624244..21c7a3daa 100644 --- a/common/bruteforce.c +++ b/common/bruteforce.c @@ -28,6 +28,13 @@ uint8_t charset_uppercase[] = { 'X', 'Y', 'Z' }; +smart_generator_t *smart_generators[] = { + smart_generator_test1, + smart_generator_test2, + NULL +}; + + void bf_generator_init(generator_context_t *ctx, uint8_t mode, uint8_t key_size) { memset(ctx, 0, sizeof(generator_context_t)); ctx->mode = mode; @@ -63,6 +70,48 @@ int bf_generate(generator_context_t *ctx) { return BF_GENERATOR_ERROR; } + +// increments values in array with carryover using modulo limit for each byte +// this is used to iterate each byte in key over charset table +// returns -1 if incrementing reaches its end +int bf_array_increment(uint8_t *data, uint8_t data_len, uint8_t modulo) { + + uint8_t prev_value; + + // check if we reached max value already + uint8_t i; + for (i = 0; i < data_len; i++) + if (data[i] < modulo - 1) + break; + + if (i == data_len) + return -1; + + for (uint8_t pos = data_len - 1;; pos--) { + prev_value = ++data[pos]; + data[pos] = data[pos] % modulo; + if (prev_value == data[pos]) + return 0; + else if (pos == 0) { + // we cannot carryover to next byte + // with the max value check in place before, we should not reach this place + return -1; + } + } + + return 0; +} + +// get current key casted to 32 bit +uint32_t bf_get_key32(generator_context_t *ctx){ + return ctx->current_key & 0xFFFFFFFF; +} + +// get current key casted to 48 bit +uint64_t bf_get_key48(generator_context_t *ctx){ + return ctx->current_key & 0xFFFFFFFFFFFF; +} + int _bf_generate_mode_range(generator_context_t *ctx) { if (ctx->key_length != BF_KEY_SIZE_32 && ctx->key_length != BF_KEY_SIZE_48) @@ -107,38 +156,33 @@ int _bf_generate_mode_charset(generator_context_t *ctx) { return BF_GENERATOR_NEXT; } -// increments values in array with carryover using modulo limit for each byte -// this is used to iterate each byte in key over charset table -// returns -1 if incrementing reaches its end -int bf_array_increment(uint8_t *data, uint8_t data_len, uint8_t modulo) { +int bf_generate_mode_smart(generator_context_t *ctx){ - uint8_t prev_value; + int ret; - // check if we reached max value already - uint8_t i; - for (i = 0; i < data_len; i++) - if (data[i] < modulo - 1) - break; + while(1){ - if (i == data_len) - return -1; + if (smart_generators[ctx->smart_mode_stage] == NULL) + return BF_GENERATOR_END; - for (uint8_t pos = data_len - 1;; pos--) { - prev_value = ++data[pos]; - data[pos] = data[pos] % modulo; - if (prev_value == data[pos]) - return 0; - else if (pos == 0) { - // we cannot carryover to next byte - // with the max value check in place before, we should not reach this place - return -1; + ret = smart_generators[ctx->smart_mode_stage](ctx); + + switch (ret){ + case BF_GENERATOR_NEXT: + return ret; + case BF_GENERATOR_ERROR: + return ret; + case BF_GENERATOR_END: + ctx->smart_mode_stage++; + continue; } } - - return 0; } -// get current key casted to 32 bit -uint32_t bf_get_key32(generator_context_t *ctx){ - return ctx->current_key & 0xFFFFFFFF; -} \ No newline at end of file + +int smart_generator_test1(generator_context_t *ctx){ + return 0; +} +int smart_generator_test2(generator_context_t *ctx){ + return 0; +} diff --git a/common/bruteforce.h b/common/bruteforce.h index 6a482a62b..70dd8a535 100644 --- a/common/bruteforce.h +++ b/common/bruteforce.h @@ -21,8 +21,6 @@ #include "common.h" -typedef uint8_t bruteforce_mode_t; - #define BF_KEY_SIZE_32 4 #define BF_KEY_SIZE_48 6 @@ -37,7 +35,6 @@ typedef uint8_t bruteforce_mode_t; #define BF_MODE_SMART 3 -typedef uint8_t bruteforce_charset_t; // bit flags - can be used together using logical OR #define BF_CHARSET_DIGITS 1 #define BF_CHARSET_UPPERCASE 2 @@ -49,10 +46,12 @@ typedef uint8_t bruteforce_charset_t; #define BF_CHARSET_DIGITS_SIZE 10 #define BF_CHARSET_UPPERCASE_SIZE 25 - extern uint8_t charset_digits[]; extern uint8_t charset_uppercase[]; +typedef uint8_t bruteforce_charset_t; +typedef uint8_t bruteforce_mode_t; + // structure to hold key generator temporary data typedef struct { // position of each of bytes in charset mode - used to iterate over alphabets @@ -71,12 +70,17 @@ typedef struct { uint32_t range_low; uint32_t range_high; + uint16_t smart_mode_stage; // flags to use internally by generators as they wish bool flag1, flag2, flag3; + // counters to use internally by generators as they wish + uint32_t counter1, counter2; } generator_context_t; + void bf_generator_init(generator_context_t *ctx, uint8_t mode, uint8_t key_size); +void bf_generator_clear(generator_context_t *ctx); // clear flags and counters used by generators int bf_generator_set_charset(generator_context_t *ctx, uint8_t charsets); int bf_generate(generator_context_t *ctx); int _bf_generate_mode_range(generator_context_t *ctx); @@ -84,6 +88,16 @@ int _bf_generate_mode_charset(generator_context_t *ctx); int _bf_generate_mode_smart(generator_context_t *ctx); int bf_array_increment(uint8_t *data, uint8_t data_len, uint8_t modulo); uint32_t bf_get_key32(generator_context_t *ctx); -uint32_t bf_get_key48(generator_context_t *ctx); +uint64_t bf_get_key48(generator_context_t *ctx); + +// smart mode +typedef int (smart_generator_t)(generator_context_t *ctx); + +int bf_generate_mode_smart(generator_context_t *ctx); + +int smart_generator_test1(generator_context_t *ctx); +int smart_generator_test2(generator_context_t *ctx); + +extern smart_generator_t *smart_generators[]; // array of smart cracking functions #endif // BRUTEFORCE_H__