Merge pull request #571 from DarkFlippers/nfc_mfclassic_custom_uid

NFC App: Add manual MF Classic custom UID

applications/main/nfc/scenes/nfc_scene_config.h

@@ -3,6 +3,7 @@ ADD_SCENE(nfc, read, Read)
 ADD_SCENE(nfc, saved_menu, SavedMenu)
 ADD_SCENE(nfc, extra_actions, ExtraActions)
 ADD_SCENE(nfc, set_type, SetType)
+ADD_SCENE(nfc, set_type_mf_uid, SetTypeMfUid)
 ADD_SCENE(nfc, set_sak, SetSak)
 ADD_SCENE(nfc, set_atqa, SetAtqa)
 ADD_SCENE(nfc, set_uid, SetUid)

applications/main/nfc/scenes/nfc_scene_set_type.c

@@ -4,6 +4,7 @@
 enum SubmenuIndex {
     SubmenuIndexNFCA4,
     SubmenuIndexNFCA7,
+    SubmenuIndexMFClassicCustomUID,
     SubmenuIndexGeneratorsStart,
 };
 
@@ -23,6 +24,12 @@ void nfc_scene_set_type_on_enter(void* context) {
         submenu, "NFC-A 7-bytes UID", SubmenuIndexNFCA7, nfc_scene_set_type_submenu_callback, nfc);
     submenu_add_item(
         submenu, "NFC-A 4-bytes UID", SubmenuIndexNFCA4, nfc_scene_set_type_submenu_callback, nfc);
+    submenu_add_item(
+        submenu,
+        "Mifare Classic Custom UID",
+        SubmenuIndexMFClassicCustomUID,
+        nfc_scene_set_type_submenu_callback,
+        nfc);
 
     // Generators
     int i = SubmenuIndexGeneratorsStart;
@@ -49,6 +56,10 @@ bool nfc_scene_set_type_on_event(void* context, SceneManagerEvent event) {
             nfc->dev->format = NfcDeviceSaveFormatUid;
             scene_manager_next_scene(nfc->scene_manager, NfcSceneSetSak);
             consumed = true;
+        } else if(event.event == SubmenuIndexMFClassicCustomUID) {
+            nfc->dev->format = NfcDeviceSaveFormatMifareClassic;
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetTypeMfUid);
+            consumed = true;
         } else {
             nfc_device_clear(nfc->dev);
             nfc->generator = nfc_generators[event.event - SubmenuIndexGeneratorsStart];

applications/main/nfc/scenes/nfc_scene_set_type_mf_uid.c

@@ -0,0 +1,103 @@
+#include "../nfc_i.h"
+#include "lib/nfc/helpers/nfc_generators.h"
+
+enum SubmenuIndex {
+    SubmenuIndexMFC1k4b,
+    SubmenuIndexMFC4k4b,
+    SubmenuIndexMFC1k7b,
+    SubmenuIndexMFC4k7b,
+    SubmenuIndexMFCMini,
+};
+
+static const NfcGenerator ganeator_gag = {
+    .name = "Mifare Classic Custom UID",
+    .generator_func = NULL,
+};
+
+void nfc_scene_set_type_mf_uid_submenu_callback(void* context, uint32_t index) {
+    Nfc* nfc = context;
+
+    view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
+}
+
+void nfc_scene_set_type_mf_uid_on_enter(void* context) {
+    Nfc* nfc = context;
+    Submenu* submenu = nfc->submenu;
+
+    submenu_add_item(
+        submenu,
+        "Mifare Classic 1k 4byte UID",
+        SubmenuIndexMFC1k4b,
+        nfc_scene_set_type_mf_uid_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Mifare Classic 4k 4byte UID",
+        SubmenuIndexMFC4k4b,
+        nfc_scene_set_type_mf_uid_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Mifare Classic 1k 7byte UID",
+        SubmenuIndexMFC1k7b,
+        nfc_scene_set_type_mf_uid_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Mifare Classic 4k 7byte UID",
+        SubmenuIndexMFC4k7b,
+        nfc_scene_set_type_mf_uid_submenu_callback,
+        nfc);
+    submenu_add_item(
+        submenu,
+        "Mifare Classic Mini",
+        SubmenuIndexMFCMini,
+        nfc_scene_set_type_mf_uid_submenu_callback,
+        nfc);
+
+    view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
+}
+
+bool nfc_scene_set_type_mf_uid_on_event(void* context, SceneManagerEvent event) {
+    Nfc* nfc = context;
+    bool consumed = false;
+    bool correct_index = false;
+    MfClassicType mf_type = MfClassicType1k;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        if(event.event == SubmenuIndexMFC1k4b) {
+            nfc->dev->dev_data.nfc_data.uid_len = 4;
+            mf_type = MfClassicType1k;
+            correct_index = true;
+        } else if(event.event == SubmenuIndexMFC1k7b) {
+            nfc->dev->dev_data.nfc_data.uid_len = 7;
+            mf_type = MfClassicType1k;
+            correct_index = true;
+        } else if(event.event == SubmenuIndexMFC4k4b) {
+            nfc->dev->dev_data.nfc_data.uid_len = 4;
+            mf_type = MfClassicType4k;
+            correct_index = true;
+        } else if(event.event == SubmenuIndexMFC4k7b) {
+            nfc->dev->dev_data.nfc_data.uid_len = 7;
+            mf_type = MfClassicType4k;
+            correct_index = true;
+        } else if(event.event == SubmenuIndexMFCMini) {
+            nfc->dev->dev_data.nfc_data.uid_len = 4;
+            mf_type = MfClassicTypeMini;
+            correct_index = true;
+        }
+        if(correct_index) {
+            nfc->generator = &ganeator_gag;
+            scene_manager_set_scene_state(nfc->scene_manager, NfcSceneSetTypeMfUid, mf_type);
+            scene_manager_next_scene(nfc->scene_manager, NfcSceneSetUid);
+            consumed = true;
+        }
+    }
+    return consumed;
+}
+
+void nfc_scene_set_type_mf_uid_on_exit(void* context) {
+    Nfc* nfc = context;
+
+    submenu_reset(nfc->submenu);
+}

applications/main/nfc/scenes/nfc_scene_set_uid.c

@@ -35,6 +35,21 @@ bool nfc_scene_set_uid_on_event(void* context, SceneManagerEvent event) {
                     scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
                     consumed = true;
                 }
+            } else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetTypeMfUid)) {
+                MfClassicType mf_type =
+                    scene_manager_get_scene_state(nfc->scene_manager, NfcSceneSetTypeMfUid);
+                if(mf_type > MfClassicTypeMini) {
+                    furi_crash("Nfc unknown type");
+                }
+                nfc_generate_mf_classic_ext(
+                    &nfc->dev->dev_data,
+                    nfc->dev_edit_data.uid_len,
+                    mf_type,
+                    false,
+                    nfc->dev_edit_data.uid);
+                scene_manager_next_scene(nfc->scene_manager, NfcSceneGenerateInfo);
+                consumed = true;
+
             } else {
                 scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
                 consumed = true;

firmware/targets/f7/api_symbols.csv

@@ -2151,6 +2151,7 @@ Function,+,nfc_device_set_loading_callback,void,"NfcDevice*, NfcLoadingCallback,
 Function,+,nfc_device_set_name,void,"NfcDevice*, const char*"
 Function,+,nfc_file_select,_Bool,NfcDevice*
 Function,-,nfc_generate_mf_classic,void,"NfcDeviceData*, uint8_t, MfClassicType"
+Function,+,nfc_generate_mf_classic_ext,void,"NfcDeviceData*, uint8_t, MfClassicType, _Bool, uint8_t*"
 Function,+,nfc_get_dev_type,const char*,FuriHalNfcType
 Function,-,nfc_guess_protocol,const char*,NfcProtocol
 Function,+,nfc_mf_classic_type,const char*,MfClassicType

lib/nfc/helpers/nfc_generators.c

@@ -333,14 +333,22 @@ static void nfc_generate_ntag_i2c_plus_2k(NfcDeviceData* data) {
     mful->version.storage_size = 0x15;
 }
 
-void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
+void nfc_generate_mf_classic_ext(
+    NfcDeviceData* data,
+    uint8_t uid_len,
+    MfClassicType type,
+    bool random_uid,
+    uint8_t* uid) {
     nfc_generate_common_start(data);
+    if(random_uid) {
         nfc_generate_mf_classic_uid(data->mf_classic_data.block[0].value, uid_len);
+    } else {
+        memcpy(data->mf_classic_data.block[0].value, uid, uid_len);
+    }
     nfc_generate_mf_classic_common(data, uid_len, type);
 
     // Set the UID
-    data->nfc_data.uid[0] = NXP_MANUFACTURER_ID;
+    for(int i = 0; i < uid_len; i++) {
-    for(int i = 1; i < uid_len; i++) {
         data->nfc_data.uid[i] = data->mf_classic_data.block[0].value[i];
     }
 
@@ -395,6 +403,11 @@ void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType
     mfc->type = type;
 }
 
+void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type) {
+    uint8_t uid = 0;
+    nfc_generate_mf_classic_ext(data, uid_len, type, true, &uid);
+}
+
 static void nfc_generate_mf_mini(NfcDeviceData* data) {
     nfc_generate_mf_classic(data, 4, MfClassicTypeMini);
 }

lib/nfc/helpers/nfc_generators.h

@@ -2,6 +2,10 @@
 
 #include "../nfc_device.h"
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 typedef void (*NfcGeneratorFunc)(NfcDeviceData* data);
 
 typedef struct {
@@ -12,3 +16,14 @@ typedef struct {
 extern const NfcGenerator* const nfc_generators[];
 
 void nfc_generate_mf_classic(NfcDeviceData* data, uint8_t uid_len, MfClassicType type);
+
+void nfc_generate_mf_classic_ext(
+    NfcDeviceData* data,
+    uint8_t uid_len,
+    MfClassicType type,
+    bool random_uid,
+    uint8_t* uid);
+
+#ifdef __cplusplus
+}
+#endif