smart generators core settings

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
+int bf_generate_mode_smart(generator_context_t *ctx){
-// 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;
+    int ret;
 
-    // check if we reached max value already
+    while(1){
-    uint8_t i;
-    for (i = 0; i < data_len; i++)
-        if (data[i] < modulo - 1)
-            break;
 
-    if (i == data_len)
+        if (smart_generators[ctx->smart_mode_stage] == NULL)
-        return -1;
+            return BF_GENERATOR_END;
 
-    for (uint8_t pos = data_len - 1;; pos--) {
+        ret = smart_generators[ctx->smart_mode_stage](ctx);
-        prev_value = ++data[pos];
+
-        data[pos] = data[pos] % modulo;
+        switch (ret){
-        if (prev_value == data[pos])
+            case BF_GENERATOR_NEXT:
-            return 0;
+                return ret;
-        else if (pos == 0) {
+            case BF_GENERATOR_ERROR:
-            // we cannot carryover to next byte
+                return ret;
-            // with the max value check in place before, we should not reach this place
+            case BF_GENERATOR_END:
-            return -1;
+                ctx->smart_mode_stage++;
+                continue;
         }
     }
-
-    return 0;
 }
 
-// get current key casted to 32 bit
+
-uint32_t bf_get_key32(generator_context_t *ctx){
+int smart_generator_test1(generator_context_t *ctx){
-    return ctx->current_key & 0xFFFFFFFF;
+    return 0;
-}
+}
+int smart_generator_test2(generator_context_t *ctx){
+    return 0;
+}

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__