Fuzzer worker refactoring

lib/worker/fake_worker.c

@@ -1,4 +1,5 @@
 #include "fake_worker.h"
+#include "helpers/hardware_worker.h"
 #include "protocol_i.h"
 
 #include <timer.h>
@@ -8,37 +9,16 @@
 #include <toolbox/stream/buffered_file_stream.h>
 
 #define TAG "Fuzzer worker"
-
-#if defined(RFID_125_PROTOCOL)
-
-#include <lib/lfrfid/lfrfid_dict_file.h>
-#include <lib/lfrfid/lfrfid_worker.h>
-#include <lfrfid/protocols/lfrfid_protocols.h>
-
-#else
-
-#include <lib/ibutton/ibutton_worker.h>
-#include <lib/ibutton/ibutton_key.h>
-
-#endif
-
-#include <toolbox/stream/stream.h>
+#define TOTAL_PROTOCOL_COUNT COUNT_OF(&fuzzer_proto_items)
 
 typedef uint8_t FuzzerWorkerPayload[MAX_PAYLOAD_SIZE];
 
 struct FuzzerWorker {
-#if defined(RFID_125_PROTOCOL)
-    LFRFIDWorker* proto_worker;
-    ProtocolId protocol_id;
-    ProtocolDict* protocols_items;
-#else
-    iButtonWorker* proto_worker;
-    iButtonProtocolId protocol_id; // TODO
-    iButtonProtocols* protocols_items;
-    iButtonKey* key;
-#endif
+    HardwareWorker* hw_worker;
 
     const FuzzerProtocol* protocol;
+    HwProtocolID* suported_proto;
+
     FuzzerWorkerPayload payload;
 
     FuzzerWorkerAttackType attack_type;
@@ -59,95 +39,12 @@ struct FuzzerWorker {
     void* end_context;
 };
 
-static void hardware_worker_alloc_init(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    instance->protocols_items = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
-
-    instance->proto_worker = lfrfid_worker_alloc(instance->protocols_items);
-#else
-    instance->protocols_items = ibutton_protocols_alloc();
-    instance->key =
-        ibutton_key_alloc(ibutton_protocols_get_max_data_size(instance->protocols_items));
-
-    instance->proto_worker = ibutton_worker_alloc(instance->protocols_items);
-#endif
-}
-
-static void hardware_worker_free(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    lfrfid_worker_free(instance->proto_worker);
+static bool fuzzer_worker_set_protocol(FuzzerWorker* instance, FuzzerProtocolsID protocol_index) {
+    furi_assert(protocol_index < TOTAL_PROTOCOL_COUNT);
 
-    protocol_dict_free(instance->protocols_items);
-#else
-    ibutton_worker_free(instance->proto_worker);
-
-    ibutton_key_free(instance->key);
-    ibutton_protocols_free(instance->protocols_items);
-#endif
-}
-
-static void hardware_worker_start_thread(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    lfrfid_worker_start_thread(instance->proto_worker);
-#else
-    ibutton_worker_start_thread(instance->proto_worker);
-#endif
-}
-
-static void hardware_worker_stop_thread(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    lfrfid_worker_stop(instance->proto_worker);
-    lfrfid_worker_stop_thread(instance->proto_worker);
-#else
-    ibutton_worker_stop(instance->proto_worker);
-    ibutton_worker_stop_thread(instance->proto_worker);
-#endif
-}
-
-static void hardware_worker_emulate_start(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    lfrfid_worker_emulate_start(instance->proto_worker, instance->protocol_id);
-#else
-    ibutton_worker_emulate_start(instance->proto_worker, instance->key);
-#endif
-}
-
-static void hardware_worker_stop(FuzzerWorker* instance) {
-#if defined(RFID_125_PROTOCOL)
-    lfrfid_worker_stop(instance->proto_worker);
-#else
-    ibutton_worker_stop(instance->proto_worker);
-#endif
-}
-
-static void
-    hardware_worker_set_protocol_data(FuzzerWorker* instance, FuzzerWorkerPayload payload) {
-#if defined(RFID_125_PROTOCOL)
-    protocol_dict_set_data(
-        instance->protocols_items, instance->protocol_id, payload, MAX_PAYLOAD_SIZE);
-#else
-    ibutton_key_set_protocol_id(instance->key, instance->protocol_id);
-    iButtonEditableData data;
-    ibutton_protocols_get_editable_data(instance->protocols_items, instance->key, &data);
-
-    //  TODO  check data.size logic
-    data.size = MAX_PAYLOAD_SIZE;
-    memcpy(data.ptr, payload, MAX_PAYLOAD_SIZE); // data.size);
-#endif
-}
-
-static void
-    hardware_worker_set_protocol(FuzzerWorker* instance, FuzzerProtocolsID protocol_index) {
     instance->protocol = &fuzzer_proto_items[protocol_index];
-
-#if defined(RFID_125_PROTOCOL)
-    instance->protocol_id =
-        protocol_dict_get_protocol_by_name(instance->protocols_items, instance->protocol->name);
-#else
-    // TODO iButtonProtocolIdInvalid check
-    instance->protocol_id =
-        ibutton_protocols_get_id_by_name(instance->protocols_items, instance->protocol->name);
-#endif
+    return hardware_worker_set_protocol_id_by_name(
+        instance->hw_worker, fuzzer_proto_items[protocol_index].name);
 }
 
 // TODO make it protocol independent
@@ -158,47 +55,13 @@ bool fuzzer_worker_load_key_from_file(
     furi_assert(instance);
 
     bool res = false;
-    hardware_worker_set_protocol(instance, protocol_index);
-
-#if defined(RFID_125_PROTOCOL)
-    ProtocolId loaded_proto_id = lfrfid_dict_file_load(instance->protocols_items, filename);
-    if(loaded_proto_id == PROTOCOL_NO) {
-        // Err Cant load file
-        FURI_LOG_W(TAG, "Cant load file");
-    } else if(instance->protocol_id != loaded_proto_id) { // Err wrong protocol
-        FURI_LOG_W(TAG, "Wrong protocol");
-        FURI_LOG_W(
-            TAG,
-            "Selected: %s Loaded: %s",
-            instance->protocol->name,
-            protocol_dict_get_name(instance->protocols_items, loaded_proto_id));
+    fuzzer_worker_set_protocol(instance, protocol_index); // TODO add Check
+    if(!hardware_worker_load_key_from_file(instance->hw_worker, protocol_index, filename)) {
     } else {
-        protocol_dict_get_data(
-            instance->protocols_items, instance->protocol_id, instance->payload, MAX_PAYLOAD_SIZE);
+        hardware_worker_get_protocol_data(
+            instance->hw_worker, &instance->payload[0], MAX_PAYLOAD_SIZE);
         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",
-                instance->protocol->name,
-                ibutton_protocols_get_name(
-                    instance->protocols_items, ibutton_key_get_protocol_id(instance->key)));
-        } else {
-            iButtonEditableData data;
-            ibutton_protocols_get_editable_data(instance->protocols_items, instance->key, &data);
-            memcpy(instance->payload, data.ptr, data.size);
-            res = true;
-        }
-    }
-#endif
 
     return res;
 }
@@ -280,7 +143,8 @@ static bool fuzzer_worker_load_key(FuzzerWorker* instance, bool next) {
     }
 
     if(res) {
-        hardware_worker_set_protocol_data(instance, instance->payload);
+        hardware_worker_set_protocol_data(
+            instance->hw_worker, &instance->payload[0], protocol->data_size);
     }
 
     return res;
@@ -318,7 +182,8 @@ static bool fuzzer_worker_load_previous_key(FuzzerWorker* instance) {
     }
 
     if(res) {
-        hardware_worker_set_protocol_data(instance, instance->payload);
+        hardware_worker_set_protocol_data(
+            instance->hw_worker, &instance->payload[0], protocol->data_size);
     }
 
     return res;
@@ -331,7 +196,7 @@ static void fuzzer_worker_on_tick_callback(void* context) {
 
     if(instance->in_emu_phase) {
         if(instance->treead_running) {
-            hardware_worker_stop(instance);
+            hardware_worker_stop(instance->hw_worker);
         }
         instance->in_emu_phase = false;
         furi_timer_start(instance->timer, furi_ms_to_ticks(instance->timer_idle_time_ms));
@@ -343,7 +208,7 @@ static void fuzzer_worker_on_tick_callback(void* context) {
             }
         } else {
             if(instance->treead_running) {
-                hardware_worker_emulate_start(instance);
+                hardware_worker_emulate_start(instance->hw_worker);
             }
             instance->in_emu_phase = true;
             furi_timer_start(instance->timer, furi_ms_to_ticks(instance->timer_emu_time_ms));
@@ -381,7 +246,11 @@ bool fuzzer_worker_init_attack_dict(FuzzerWorker* instance, FuzzerProtocolsID pr
     furi_assert(instance);
 
     bool res = false;
-    hardware_worker_set_protocol(instance, protocol_index);
+
+    if(!fuzzer_worker_set_protocol(instance, protocol_index)) {
+        instance->attack_type = FuzzerWorkerAttackTypeMax;
+        return res;
+    }
 
     instance->attack_type = FuzzerWorkerAttackTypeDefaultDict;
     instance->index = 0;
@@ -403,7 +272,11 @@ bool fuzzer_worker_init_attack_file_dict(
     furi_assert(file_path);
 
     bool res = false;
-    hardware_worker_set_protocol(instance, protocol_index);
+
+    if(!fuzzer_worker_set_protocol(instance, protocol_index)) {
+        instance->attack_type = FuzzerWorkerAttackTypeMax;
+        return res;
+    }
 
     Storage* storage = furi_record_open(RECORD_STORAGE);
     instance->uids_stream = buffered_file_stream_alloc(storage);
@@ -436,7 +309,10 @@ bool fuzzer_worker_init_attack_bf_byte(
     furi_assert(instance);
 
     bool res = false;
-    hardware_worker_set_protocol(instance, protocol_index);
+    if(!fuzzer_worker_set_protocol(instance, protocol_index)) {
+        instance->attack_type = FuzzerWorkerAttackTypeMax;
+        return res;
+    }
 
     instance->attack_type = FuzzerWorkerAttackTypeLoadFile;
     instance->index = chusen;
@@ -451,7 +327,18 @@ bool fuzzer_worker_init_attack_bf_byte(
 FuzzerWorker* fuzzer_worker_alloc() {
     FuzzerWorker* instance = malloc(sizeof(FuzzerWorker));
 
-    hardware_worker_alloc_init(instance);
+    instance->hw_worker = hardware_worker_alloc();
+    instance->suported_proto = malloc(sizeof(HwProtocolID) * TOTAL_PROTOCOL_COUNT);
+
+    for(uint8_t i = 0; i < TOTAL_PROTOCOL_COUNT; i++) {
+        if(!hardware_worker_set_protocol_id_by_name(
+               instance->hw_worker, fuzzer_proto_items[i].name)) {
+            // Check protocol support
+            furi_crash("Not supported protocol name");
+        } else {
+            instance->suported_proto[i] = hardware_worker_get_protocol_id(instance->hw_worker);
+        }
+    }
 
     instance->attack_type = FuzzerWorkerAttackTypeMax;
     instance->index = 0;
@@ -476,7 +363,8 @@ void fuzzer_worker_free(FuzzerWorker* instance) {
 
     furi_timer_free(instance->timer);
 
-    hardware_worker_free(instance);
+    free(instance->suported_proto);
+    hardware_worker_free(instance->hw_worker);
 
     free(instance);
 }
@@ -503,7 +391,7 @@ bool fuzzer_worker_start(FuzzerWorker* instance, uint8_t idle_time, uint8_t emu_
             instance->timer_idle_time_ms);
 
         if(!instance->treead_running) {
-            hardware_worker_start_thread(instance);
+            hardware_worker_start_thread(instance->hw_worker);
 
             FURI_LOG_D(TAG, "Worker Starting");
             instance->treead_running = true;
@@ -511,7 +399,7 @@ bool fuzzer_worker_start(FuzzerWorker* instance, uint8_t idle_time, uint8_t emu_
             FURI_LOG_D(TAG, "Worker UnPaused");
         }
 
-        hardware_worker_emulate_start(instance);
+        hardware_worker_emulate_start(instance->hw_worker);
 
         instance->in_emu_phase = true;
         furi_timer_start(instance->timer, furi_ms_to_ticks(instance->timer_emu_time_ms));
@@ -524,7 +412,7 @@ void fuzzer_worker_start_emulate(FuzzerWorker* instance) {
     furi_assert(instance);
 
     if(!instance->treead_running) {
-        hardware_worker_start_thread(instance);
+        hardware_worker_start_thread(instance->hw_worker);
 
         FURI_LOG_D(TAG, "Worker Starting");
         instance->treead_running = true;
@@ -532,7 +420,7 @@ void fuzzer_worker_start_emulate(FuzzerWorker* instance) {
         FURI_LOG_D(TAG, "Worker UnPaused");
     }
 
-    hardware_worker_emulate_start(instance);
+    hardware_worker_emulate_start(instance->hw_worker);
 }
 
 void fuzzer_worker_pause(FuzzerWorker* instance) {
@@ -541,7 +429,7 @@ void fuzzer_worker_pause(FuzzerWorker* instance) {
     furi_timer_stop(instance->timer);
 
     if(instance->treead_running) {
-        hardware_worker_stop(instance);
+        hardware_worker_stop(instance->hw_worker);
 
         FURI_LOG_D(TAG, "Worker Paused");
     }
@@ -553,7 +441,7 @@ void fuzzer_worker_stop(FuzzerWorker* instance) {
     furi_timer_stop(instance->timer);
 
     if(instance->treead_running) {
-        hardware_worker_stop_thread(instance);
+        hardware_worker_stop_thread(instance->hw_worker);
 
         FURI_LOG_D(TAG, "Worker Stopping");
         instance->treead_running = false;

lib/worker/fake_worker.h

@@ -12,6 +12,14 @@ typedef enum {
     FuzzerWorkerAttackTypeMax,
 } FuzzerWorkerAttackType;
 
+// typedef enum {
+//     FuzzerWorkerLoadKeyStateBadFile = -2,
+//     FuzzerWorkerLoadKeyStateUnsuportedProto,
+//     FuzzerWorkerLoadKeyStateOk = 0,
+//     FuzzerWorkerLoadKeyStateDifferentProto,
+
+// } FuzzerWorkerLoadKeyState;
+
 typedef void (*FuzzerWorkerUidChagedCallback)(void* context);
 typedef void (*FuzzerWorkerEndCallback)(void* context);
 

lib/worker/helpers/hardware_worker.c

@@ -0,0 +1,203 @@
+#include "hardware_worker.h"
+#include "furi.h"
+
+#if defined(RFID_125_PROTOCOL)
+
+#include <lib/lfrfid/lfrfid_dict_file.h>
+#include <lib/lfrfid/lfrfid_worker.h>
+
+#else
+
+#include <lib/ibutton/ibutton_worker.h>
+#include <lib/ibutton/ibutton_key.h>
+
+#endif
+
+#define TAG "Fuzzer HW worker"
+
+struct HardwareWorker {
+#if defined(RFID_125_PROTOCOL)
+    LFRFIDWorker* proto_worker;
+    ProtocolId protocol_id;
+    ProtocolDict* protocols_items;
+#else
+    iButtonWorker* proto_worker;
+    iButtonProtocolId protocol_id; // TODO
+    iButtonProtocols* protocols_items;
+    iButtonKey* key;
+#endif
+};
+
+HardwareWorker* hardware_worker_alloc() {
+    HardwareWorker* instance = malloc(sizeof(HardwareWorker));
+#if defined(RFID_125_PROTOCOL)
+    instance->protocols_items = protocol_dict_alloc(lfrfid_protocols, LFRFIDProtocolMax);
+
+    instance->proto_worker = lfrfid_worker_alloc(instance->protocols_items);
+#else
+    instance->protocols_items = ibutton_protocols_alloc();
+    instance->key =
+        ibutton_key_alloc(ibutton_protocols_get_max_data_size(instance->protocols_items));
+
+    instance->proto_worker = ibutton_worker_alloc(instance->protocols_items);
+#endif
+    return instance;
+}
+
+void hardware_worker_free(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    lfrfid_worker_free(instance->proto_worker);
+
+    protocol_dict_free(instance->protocols_items);
+#else
+    ibutton_worker_free(instance->proto_worker);
+
+    ibutton_key_free(instance->key);
+    ibutton_protocols_free(instance->protocols_items);
+#endif
+    free(instance);
+}
+
+void hardware_worker_start_thread(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    lfrfid_worker_start_thread(instance->proto_worker);
+#else
+    ibutton_worker_start_thread(instance->proto_worker);
+#endif
+}
+
+void hardware_worker_stop_thread(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    lfrfid_worker_stop(instance->proto_worker);
+    lfrfid_worker_stop_thread(instance->proto_worker);
+#else
+    ibutton_worker_stop(instance->proto_worker);
+    ibutton_worker_stop_thread(instance->proto_worker);
+#endif
+}
+
+void hardware_worker_emulate_start(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    lfrfid_worker_emulate_start(instance->proto_worker, instance->protocol_id);
+#else
+    ibutton_worker_emulate_start(instance->proto_worker, instance->key);
+#endif
+}
+
+void hardware_worker_stop(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    lfrfid_worker_stop(instance->proto_worker);
+#else
+    ibutton_worker_stop(instance->proto_worker);
+#endif
+}
+
+void hardware_worker_set_protocol_data(
+    HardwareWorker* instance,
+    uint8_t* payload,
+    uint8_t payload_size) {
+#if defined(RFID_125_PROTOCOL)
+    protocol_dict_set_data(
+        instance->protocols_items, instance->protocol_id, payload, payload_size);
+#else
+    ibutton_key_set_protocol_id(instance->key, instance->protocol_id);
+    iButtonEditableData data;
+    ibutton_protocols_get_editable_data(instance->protocols_items, instance->key, &data);
+
+    furi_check(payload_size >= data.size);
+    memcpy(data.ptr, payload, data.size);
+#endif
+}
+
+void hardware_worker_get_protocol_data(
+    HardwareWorker* instance,
+    uint8_t* payload,
+    uint8_t payload_size) {
+#if defined(RFID_125_PROTOCOL)
+    protocol_dict_get_data(
+        instance->protocols_items, instance->protocol_id, payload, payload_size);
+#else
+    iButtonEditableData data;
+    ibutton_protocols_get_editable_data(instance->protocols_items, instance->key, &data);
+    furi_check(payload_size >= data.size);
+    memcpy(payload, data.ptr, data.size);
+#endif
+}
+
+static bool hardware_worker_protocol_is_valid(HardwareWorker* instance) {
+#if defined(RFID_125_PROTOCOL)
+    if(instance->protocol_id != PROTOCOL_NO) {
+        return true;
+    }
+#else
+    if(instance->protocol_id != iButtonProtocolIdInvalid) {
+        return true;
+    }
+#endif
+    return false;
+}
+
+bool hardware_worker_set_protocol_id_by_name(HardwareWorker* instance, const char* protocol_name) {
+#if defined(RFID_125_PROTOCOL)
+    instance->protocol_id =
+        protocol_dict_get_protocol_by_name(instance->protocols_items, protocol_name);
+    return (instance->protocol_id != PROTOCOL_NO);
+#else
+    instance->protocol_id =
+        ibutton_protocols_get_id_by_name(instance->protocols_items, protocol_name);
+    return (instance->protocol_id != iButtonProtocolIdInvalid);
+#endif
+}
+
+HwProtocolID hardware_worker_get_protocol_id(HardwareWorker* instance) {
+    if(hardware_worker_protocol_is_valid(instance)) {
+        return instance->protocol_id;
+    }
+    return -1;
+}
+
+// TODO make it protocol independent
+bool hardware_worker_load_key_from_file(
+    HardwareWorker* instance,
+    FuzzerProtocolsID protocol_index,
+    const char* filename) {
+    bool res = false;
+
+#if defined(RFID_125_PROTOCOL)
+    ProtocolId loaded_proto_id = lfrfid_dict_file_load(instance->protocols_items, filename);
+    if(loaded_proto_id == PROTOCOL_NO) {
+        // 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 {
+        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 {
+        res = true;
+    }
+#endif
+
+    return res;
+}

lib/worker/helpers/hardware_worker.h

@@ -0,0 +1,53 @@
+#pragma once
+
+// typedef HwProtocolID HwProtocolID;
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#if defined(RFID_125_PROTOCOL)
+
+#include <lib/lfrfid/lfrfid_dict_file.h>
+typedef ProtocolId HwProtocolID;
+
+#else
+
+#include <lib/ibutton/protocols/protocol_common.h>
+typedef iButtonProtocolId HwProtocolID;
+
+#endif
+
+#include "../protocol_i.h" // TODO DROP
+
+typedef struct HardwareWorker HardwareWorker;
+
+HardwareWorker* hardware_worker_alloc();
+
+void hardware_worker_free(HardwareWorker* instance);
+
+void hardware_worker_start_thread(HardwareWorker* instance);
+
+void hardware_worker_stop_thread(HardwareWorker* instance);
+
+void hardware_worker_emulate_start(HardwareWorker* instance);
+
+void hardware_worker_stop(HardwareWorker* instance);
+
+void hardware_worker_set_protocol_data(
+    HardwareWorker* instance,
+    uint8_t* payload,
+    uint8_t payload_size);
+
+void hardware_worker_get_protocol_data(
+    HardwareWorker* instance,
+    uint8_t* payload,
+    uint8_t payload_size);
+
+bool hardware_worker_set_protocol_id_by_name(HardwareWorker* instance, const char* protocol_name);
+
+HwProtocolID hardware_worker_get_protocol_id(HardwareWorker* instance);
+
+bool hardware_worker_load_key_from_file(
+    HardwareWorker* instance,
+    FuzzerProtocolsID protocol_index,
+    const char* filename);

lib/worker/protocol.c

@@ -152,79 +152,79 @@ const uint8_t uid_list_h10301[][H10301_DATA_SIZE] = {
 
 #if defined(RFID_125_PROTOCOL)
 const FuzzerProtocol fuzzer_proto_items[] = {
-    [EM4100] =
-        {
-            .name = "EM4100",
-            .data_size = EM4100_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_em4100,
-                    .len = COUNT_OF(uid_list_em4100),
-                },
-        },
-    [HIDProx] =
-        {
-            .name = "HIDProx",
-            .data_size = HIDProx_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_hid,
-                    .len = COUNT_OF(uid_list_hid),
-                },
-        },
-    [PAC] =
-        {
-            .name = "PAC/Stanley",
-            .data_size = PAC_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_pac,
-                    .len = COUNT_OF(uid_list_pac),
-                },
-        },
-    [H10301] =
-        {
-            .name = "H10301",
-            .data_size = H10301_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_h10301,
-                    .len = COUNT_OF(uid_list_h10301),
-                },
-        },
+    // EM4100
+    {
+        .name = "EM4100",
+        .data_size = EM4100_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_em4100,
+                .len = COUNT_OF(uid_list_em4100),
+            },
+    },
+    // HIDProx
+    {
+        .name = "HIDProx",
+        .data_size = HIDProx_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_hid,
+                .len = COUNT_OF(uid_list_hid),
+            },
+    },
+    // PAC
+    {
+        .name = "PAC/Stanley",
+        .data_size = PAC_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_pac,
+                .len = COUNT_OF(uid_list_pac),
+            },
+    },
+    // H10301
+    {
+        .name = "H10301",
+        .data_size = H10301_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_h10301,
+                .len = COUNT_OF(uid_list_h10301),
+            },
+    },
 };
 #else
 const FuzzerProtocol fuzzer_proto_items[] = {
-    [DS1990] =
-        {
-            .name = "DS1990",
-            .data_size = DS1990_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_ds1990,
-                    .len = COUNT_OF(uid_list_ds1990),
-                },
-        },
-    [Metakom] =
-        {
-            .name = "Metakom",
-            .data_size = Metakom_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_metakom,
-                    .len = COUNT_OF(uid_list_metakom),
-                },
-        },
-    [Cyfral] =
-        {
-            .name = "Cyfral",
-            .data_size = Cyfral_DATA_SIZE,
-            .dict =
-                {
-                    .val = (const uint8_t*)&uid_list_cyfral,
-                    .len = COUNT_OF(uid_list_cyfral),
-                },
-        },
+    // DS1990
+    {
+        .name = "DS1990",
+        .data_size = DS1990_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_ds1990,
+                .len = COUNT_OF(uid_list_ds1990),
+            },
+    },
+    // Metakom
+    {
+        .name = "Metakom",
+        .data_size = Metakom_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_metakom,
+                .len = COUNT_OF(uid_list_metakom),
+            },
+    },
+    // Cyfral
+    {
+        .name = "Cyfral",
+        .data_size = Cyfral_DATA_SIZE,
+        .dict =
+            {
+                .val = (const uint8_t*)&uid_list_cyfral,
+                .len = COUNT_OF(uid_list_cyfral),
+            },
+    },
 };
 #endif
 

lib/worker/protocol.h

@@ -6,18 +6,7 @@
 
 typedef struct FuzzerPayload FuzzerPayload;
 
-typedef enum {
-#if defined(RFID_125_PROTOCOL)
-    EM4100,
-    HIDProx,
-    PAC,
-    H10301,
-#else
-    DS1990,
-    Metakom,
-    Cyfral,
-#endif
-} FuzzerProtocolsID;
+typedef uint8_t FuzzerProtocolsID;
 
 typedef enum {
     FuzzerAttackIdDefaultValues = 0,