Made "load key file" protocol independent, fix some error

lib/worker/fake_worker.c

@@ -9,7 +9,7 @@
 #include <toolbox/stream/buffered_file_stream.h>
 
 #define TAG "Fuzzer worker"
-#define TOTAL_PROTOCOL_COUNT COUNT_OF(&fuzzer_proto_items)
+#define TOTAL_PROTOCOL_COUNT fuzzer_proto_get_count_of_protocols()
 
 typedef uint8_t FuzzerWorkerPayload[MAX_PAYLOAD_SIZE];
 
@@ -40,27 +40,53 @@ struct FuzzerWorker {
 };
 
 static bool fuzzer_worker_set_protocol(FuzzerWorker* instance, FuzzerProtocolsID protocol_index) {
-    furi_assert(protocol_index < TOTAL_PROTOCOL_COUNT);
+    if(!(protocol_index < TOTAL_PROTOCOL_COUNT)) {
+        return false;
+    }
 
     instance->protocol = &fuzzer_proto_items[protocol_index];
     return hardware_worker_set_protocol_id_by_name(
         instance->hw_worker, fuzzer_proto_items[protocol_index].name);
 }
 
-// TODO make it protocol independent
-bool fuzzer_worker_load_key_from_file(
+static FuzzerProtocolsID
+    fuzzer_worker_is_protocol_valid(FuzzerWorker* instance, HwProtocolID protocol_id) {
+    for(FuzzerProtocolsID i = 0; i < TOTAL_PROTOCOL_COUNT; i++) {
+        if(protocol_id == instance->suported_proto[i]) {
+            return i;
+        }
+    }
+    return TOTAL_PROTOCOL_COUNT;
+}
+
+FuzzerWorkerLoadKeyState fuzzer_worker_load_key_from_file(
     FuzzerWorker* instance,
-    FuzzerProtocolsID protocol_index,
+    FuzzerProtocolsID* protocol_index,
     const char* filename) {
     furi_assert(instance);
 
-    bool res = false;
-    fuzzer_worker_set_protocol(instance, protocol_index); // TODO add Check
-    if(!hardware_worker_load_key_from_file(instance->hw_worker, protocol_index, filename)) {
+    FuzzerWorkerLoadKeyState res = FuzzerWorkerLoadKeyStateUnsuportedProto;
+    if(!hardware_worker_load_key_from_file(instance->hw_worker, filename)) {
+        FURI_LOG_E(TAG, "Load key file: cant load file");
+        res = FuzzerWorkerLoadKeyStateBadFile;
     } else {
-        hardware_worker_get_protocol_data(
-            instance->hw_worker, &instance->payload[0], MAX_PAYLOAD_SIZE);
-        res = true;
+        FuzzerProtocolsID loaded_id = fuzzer_worker_is_protocol_valid(
+            instance, hardware_worker_get_protocol_id(instance->hw_worker));
+
+        if(!fuzzer_worker_set_protocol(instance, loaded_id)) {
+            FURI_LOG_E(TAG, "Load key file: Unsuported protocol");
+            res = FuzzerWorkerLoadKeyStateUnsuportedProto;
+        } else {
+            if(*protocol_index != loaded_id) {
+                res = FuzzerWorkerLoadKeyStateDifferentProto;
+            } else {
+                res = FuzzerWorkerLoadKeyStateOk;
+            }
+            *protocol_index = loaded_id;
+
+            hardware_worker_get_protocol_data(
+                instance->hw_worker, &instance->payload[0], MAX_PAYLOAD_SIZE);
+        }
     }
 
     return res;
@@ -319,9 +345,10 @@ bool fuzzer_worker_init_attack_bf_byte(
 
     memcpy(instance->payload, new_uid->data, instance->protocol->data_size);
 
-    res = true;
+    hardware_worker_set_protocol_data(
+        instance->hw_worker, &instance->payload[0], instance->protocol->data_size);
 
-    return res;
+    return true;
 }
 
 FuzzerWorker* fuzzer_worker_alloc() {
@@ -334,9 +361,16 @@ FuzzerWorker* fuzzer_worker_alloc() {
         if(!hardware_worker_set_protocol_id_by_name(
                instance->hw_worker, fuzzer_proto_items[i].name)) {
             // Check protocol support
+            FURI_LOG_E(TAG, "Not supported protocol name: %s", fuzzer_proto_items[i].name);
             furi_crash("Not supported protocol name");
         } else {
             instance->suported_proto[i] = hardware_worker_get_protocol_id(instance->hw_worker);
+            FURI_LOG_D(
+                TAG,
+                "%u: %15s Protocol_id: %lu",
+                i + 1,
+                fuzzer_proto_items[i].name,
+                instance->suported_proto[i]);
         }
     }
 

lib/worker/fake_worker.h

@@ -12,13 +12,13 @@ typedef enum {
     FuzzerWorkerAttackTypeMax,
 } FuzzerWorkerAttackType;
 
-// typedef enum {
-//     FuzzerWorkerLoadKeyStateBadFile = -2,
-//     FuzzerWorkerLoadKeyStateUnsuportedProto,
-//     FuzzerWorkerLoadKeyStateOk = 0,
-//     FuzzerWorkerLoadKeyStateDifferentProto,
+typedef enum {
+    FuzzerWorkerLoadKeyStateBadFile = -2,
+    FuzzerWorkerLoadKeyStateUnsuportedProto,
+    FuzzerWorkerLoadKeyStateOk = 0,
+    FuzzerWorkerLoadKeyStateDifferentProto,
 
-// } FuzzerWorkerLoadKeyState;
+} FuzzerWorkerLoadKeyState;
 
 typedef void (*FuzzerWorkerUidChagedCallback)(void* context);
 typedef void (*FuzzerWorkerEndCallback)(void* context);
@@ -121,9 +121,9 @@ bool fuzzer_worker_previous_key(FuzzerWorker* instance);
  * @param filename file path to the key file
  * @return bool True if loading is successful
  */
-bool fuzzer_worker_load_key_from_file(
+FuzzerWorkerLoadKeyState fuzzer_worker_load_key_from_file(
     FuzzerWorker* instance,
-    FuzzerProtocolsID protocol_index,
+    FuzzerProtocolsID* protocol_index,
     const char* filename);
 
 /**

lib/worker/helpers/hardware_worker.c

@@ -22,7 +22,7 @@ struct HardwareWorker {
     ProtocolDict* protocols_items;
 #else
     iButtonWorker* proto_worker;
-    iButtonProtocolId protocol_id; // TODO
+    iButtonProtocolId protocol_id;
     iButtonProtocols* protocols_items;
     iButtonKey* key;
 #endif
@@ -156,11 +156,7 @@ HwProtocolID hardware_worker_get_protocol_id(HardwareWorker* instance) {
     return -1;
 }
 
-// TODO make it protocol independent
-bool hardware_worker_load_key_from_file(
-    HardwareWorker* instance,
-    FuzzerProtocolsID protocol_index,
-    const char* filename) {
+bool hardware_worker_load_key_from_file(HardwareWorker* instance, const char* filename) {
     bool res = false;
 
 #if defined(RFID_125_PROTOCOL)
@@ -169,34 +165,19 @@ bool hardware_worker_load_key_from_file(
         // Err Cant load file
         FURI_LOG_W(TAG, "Cant load file");
     } else {
-        res = true;
-    }
-    if(instance->protocol_id != loaded_proto_id) { // Err wrong protocol
-        FURI_LOG_W(TAG, "Wrong protocol");
-        FURI_LOG_W(
-            TAG,
-            "Selected: %s Loaded: %s",
-            fuzzer_proto_items[protocol_index].name,
-            protocol_dict_get_name(instance->protocols_items, loaded_proto_id));
-    } else {
+        instance->protocol_id = loaded_proto_id;
         res = true;
     }
 #else
+
     if(!ibutton_protocols_load(instance->protocols_items, instance->key, filename)) {
         // Err Cant load file
         FURI_LOG_W(TAG, "Cant load file");
-    } else if(instance->protocol_id != ibutton_key_get_protocol_id(instance->key)) {
-        // Err wrong protocol
-        FURI_LOG_W(TAG, "Wrong protocol");
-        FURI_LOG_W(
-            TAG,
-            "Selected: %s Loaded: %s",
-            fuzzer_proto_items[protocol_index].name,
-            ibutton_protocols_get_name(
-                instance->protocols_items, ibutton_key_get_protocol_id(instance->key)));
     } else {
+        instance->protocol_id = ibutton_key_get_protocol_id(instance->key);
         res = true;
     }
+
 #endif
 
     return res;

lib/worker/helpers/hardware_worker.h

@@ -17,8 +17,6 @@ typedef iButtonProtocolId HwProtocolID;
 
 #endif
 
-#include "../protocol_i.h" // TODO DROP
-
 typedef struct HardwareWorker HardwareWorker;
 
 HardwareWorker* hardware_worker_alloc();
@@ -47,7 +45,4 @@ bool hardware_worker_set_protocol_id_by_name(HardwareWorker* instance, const cha
 
 HwProtocolID hardware_worker_get_protocol_id(HardwareWorker* instance);
 
-bool hardware_worker_load_key_from_file(
-    HardwareWorker* instance,
-    FuzzerProtocolsID protocol_index,
-    const char* filename);
+bool hardware_worker_load_key_from_file(HardwareWorker* instance, const char* filename);

scenes/fuzzer_scene_main.c

@@ -2,6 +2,7 @@
 #include "../helpers/fuzzer_custom_event.h"
 
 #include "../lib/worker/protocol.h"
+#define TAG "Fuzzer main menu"
 
 void fuzzer_scene_main_callback(FuzzerCustomEvent event, void* context) {
     furi_assert(context);
@@ -35,7 +36,7 @@ static bool fuzzer_scene_main_load_custom_dict(void* context) {
     return res;
 }
 
-static bool fuzzer_scene_main_load_key(void* context) {
+static bool fuzzer_scene_main_load_key_dialog(void* context) {
     furi_assert(context);
     PacsFuzzerApp* app = context;
 
@@ -134,22 +135,32 @@ bool fuzzer_scene_main_on_event(void* context, SceneManagerEvent event) {
                 break;
 
             case FuzzerAttackIdLoadFile:
-                if(!fuzzer_scene_main_load_key(app)) {
+                if(!fuzzer_scene_main_load_key_dialog(app)) {
                     break;
                 } else {
-                    if(fuzzer_worker_load_key_from_file(
-                           app->worker,
-                           app->fuzzer_state.proto_index,
-                           furi_string_get_cstr(app->file_path))) {
+                    switch(fuzzer_worker_load_key_from_file(
+                        app->worker,
+                        &app->fuzzer_state.proto_index,
+                        furi_string_get_cstr(app->file_path))) {
+                    case FuzzerWorkerLoadKeyStateOk:
+                    case FuzzerWorkerLoadKeyStateDifferentProto:
                         scene_manager_set_scene_state(
                             app->scene_manager,
                             FuzzerSceneFieldEditor,
                             FuzzerFieldEditorStateEditingOn);
                         scene_manager_next_scene(app->scene_manager, FuzzerSceneFieldEditor);
-                        FURI_LOG_I("Scene", "Load ok");
-                    } else {
-                        fuzzer_scene_main_show_error(app, "Unsupported protocol\nor broken file");
-                        FURI_LOG_W("Scene", "Load err");
+                        FURI_LOG_I(TAG, "Load ok");
+                        break;
+
+                    case FuzzerWorkerLoadKeyStateBadFile:
+                        fuzzer_scene_main_show_error(app, "Cant load\nor broken file");
+                        FURI_LOG_E(TAG, "Cant load or broken file");
+                        break;
+
+                    case FuzzerWorkerLoadKeyStateUnsuportedProto:
+                        fuzzer_scene_main_show_error(app, "Unsupported protocol");
+                        FURI_LOG_E(TAG, "Unsupported protocol");
+                        break;
                     }
                 }
                 break;