From d47bbfeef3a2c2c0d598f1f2c042557a9003ec36 Mon Sep 17 00:00:00 2001 From: 47LeCoste <82815207+grugnoymeme@users.noreply.github.com> Date: Sat, 9 Dec 2023 13:32:16 +0100 Subject: [PATCH 1/4] Add files via upload --- .../nfc/plugins/supported_cards/microel.c | 241 ++++++++++++++++++ .../main/nfc/plugins/supported_cards/mizip.c | 205 +++++++++++++++ 2 files changed, 446 insertions(+) create mode 100644 applications/main/nfc/plugins/supported_cards/microel.c create mode 100644 applications/main/nfc/plugins/supported_cards/mizip.c diff --git a/applications/main/nfc/plugins/supported_cards/microel.c b/applications/main/nfc/plugins/supported_cards/microel.c new file mode 100644 index 0000000000..7cad11bc65 --- /dev/null +++ b/applications/main/nfc/plugins/supported_cards/microel.c @@ -0,0 +1,241 @@ +#include "nfc_supported_card_plugin.h" +#include +#include +#include +#include +#include + +#define TAG "Microel" +#define KEY_LENGTH 6 +#define UID_LENGTH 4 + +typedef struct { + uint64_t a; + uint64_t b; +} MfClassicKeyPair; + +static MfClassicKeyPair microel_1k_keys[] = { + {.a = 0x000000000000, .b = 0x000000000000}, // 000 + {.a = 0x000000000000, .b = 0x000000000000}, // 001 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 002 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 003 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 004 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 005 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 006 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 007 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 008 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 009 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 010 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 011 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 012 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 013 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 014 + {.a = 0xffffffffffff, .b = 0xffffffffffff}, // 015 +}; + +const uint8_t verify_sector = 1; + +void calcolaSommaHex(const uint8_t *uid, size_t uidSize, uint8_t sommaHex[]) { + const uint8_t xorKey[] = { 0x01, 0x92, 0xA7, 0x75, 0x2B, 0xF9 }; + int somma = 0; + + for (size_t i = 0; i < uidSize; i++) { + somma += uid[i]; + } + + int sommaDueNumeri = somma % 256; + + for (size_t i = 0; i < sizeof(xorKey); i++) { + sommaHex[i] = sommaDueNumeri ^ xorKey[i]; + } +} + +void generateKeyA(const uint8_t *uid, uint8_t uidSize, uint8_t keyA[]) { + uint8_t sommaHex[6]; + calcolaSommaHex(uid, uidSize, sommaHex); + uint8_t primoCarattere = (sommaHex[0] >> 4) & 0xF; + + if (primoCarattere == 0x2 || primoCarattere == 0x3 || primoCarattere == 0xA || primoCarattere == 0xB) { + // XOR WITH 0x40 + for (size_t i = 0; i < sizeof(sommaHex); i++) { + keyA[i] = 0x40 ^ sommaHex[i]; + } + } else if (primoCarattere == 0x6 || primoCarattere == 0x7 || primoCarattere == 0xE || primoCarattere == 0xF) { + // XOR WITH 0xC0 + for (size_t i = 0; i < sizeof(sommaHex); i++) { + keyA[i] = 0xC0 ^ sommaHex[i]; + } + } +} + +void generateKeyB(uint8_t keyA[], size_t keyASize, uint8_t keyB[]) { + for (size_t i = 0; i < keyASize; i++) { + keyB[i] = 0xFF ^ keyA[i]; + } +} + +/*static bool microel_verify(Nfc* nfc) { + furi_assert(nfc); + + bool verified = false; + + do { + uint8_t block_num = mf_classic_get_first_block_num_of_sector(verify_sector); + FURI_LOG_D(TAG, "Verifying sector %u", verify_sector); + + uint8_t uid[UID_LENGTH] = {0xd4, 0x23, 0xb7, 0x34}; + + size_t uid_len; + const uint8_t* uidn = mf_classic_get_uid(data, &uid_len); + FURI_LOG_D(TAG, "Microel provadiocane: UID identified: %02X%02X%02X%02X", uidn[0], uidn[1], uidn[2], uidn[3]); + if(uid_len != UID_LENGTH) break; + size_t uid_len = 0; + const uint8_t* originalUid = mf_classic_get_uid(data, &uid_len); + uint8_t uid[UID_LENGTH]; // Sostituisci UID_LENGTH con la lunghezza effettiva dell'UID + memcpy(uid, originalUid, UID_LENGTH); + FURI_LOG_D(TAG, "UID: %02X %02X %02X %02X", uid[0],uid[1],uid[2],uid[3]); + FURI_LOG_D(TAG, "UID GET: %02X %02X %02X %02X", originalUid[0],originalUid[1],originalUid[2],originalUid[3]); + //memcpy(uid, data->iso14443_3a_data->uid, UID_LENGTH); + + // Generate key from uid + uint8_t keyA[KEY_LENGTH]; + generateKeyA(uid, UID_LENGTH, keyA); + + MfClassicKey key = {}; + memcpy(key.data, keyA, KEY_LENGTH); + + MfClassicAuthContext auth_ctx = {}; + MfClassicError error = + mf_classic_poller_sync_auth(nfc, block_num, &key, MfClassicKeyTypeA, &auth_ctx); + if(error != MfClassicErrorNone) { + verified = false; + FURI_LOG_D(TAG, "Failed to read block %u: %d", block_num, error); + break; + } + + verified = true; + } while(false); + + return verified; +}*/ + +static bool microel_read(Nfc* nfc, NfcDevice* device) { + FURI_LOG_D(TAG, "Entering Microel KDF"); + + furi_assert(nfc); + furi_assert(device); + + bool is_read = false; + + MfClassicData* data = mf_classic_alloc(); + nfc_device_copy_data(device, NfcProtocolMfClassic, data); + + do { + MfClassicType type = MfClassicType1k; + MfClassicError error = mf_classic_poller_sync_detect_type(nfc, &type); + if(error != MfClassicErrorNone) break; + + size_t uid_len; + const uint8_t* uid = mf_classic_get_uid(data, &uid_len); + FURI_LOG_D(TAG, "UID identified: %02X%02X%02X%02X", uid[0], uid[1], uid[2], uid[3]); + if(uid_len != UID_LENGTH) break; + + uint8_t keyA[KEY_LENGTH]; + uint8_t keyB[KEY_LENGTH]; + generateKeyA(uid, UID_LENGTH, keyA); + generateKeyB(keyA, KEY_LENGTH, keyB); + + for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) { + if(microel_1k_keys[i].a == 0x000000000000) { + microel_1k_keys[i].a = nfc_util_bytes2num(keyA, KEY_LENGTH); + } + if(microel_1k_keys[i].b == 0x000000000000) { + microel_1k_keys[i].b = nfc_util_bytes2num(keyB, KEY_LENGTH); + } + } + + MfClassicDeviceKeys keys = {}; + for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) { + nfc_util_num2bytes(microel_1k_keys[i].a, sizeof(MfClassicKey), keys.key_a[i].data); + FURI_BIT_SET(keys.key_a_mask, i); + nfc_util_num2bytes(microel_1k_keys[i].b, sizeof(MfClassicKey), keys.key_b[i].data); + FURI_BIT_SET(keys.key_b_mask, i); + } + + error = mf_classic_poller_sync_read(nfc, &keys, data); + if(error != MfClassicErrorNone) { + FURI_LOG_W(TAG, "Failed to read data"); + break; + } + + nfc_device_set_data(device, NfcProtocolMfClassic, data); + + is_read = true; + } while(false); + + mf_classic_free(data); + + return is_read; +} + +static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { + furi_assert(device); + furi_assert(parsed_data); + + const MfClassicData* data = nfc_device_get_data(device, NfcProtocolMfClassic); + + bool parsed = false; + + do { + //Get UID + size_t uid_len; + const uint8_t* uid = mf_classic_get_uid(data, &uid_len); + if(uid_len != UID_LENGTH) break; + + // Generate key from uid + uint8_t keyA[KEY_LENGTH]; + generateKeyA(uid, UID_LENGTH, keyA); + + // Verify key + MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, verify_sector); + uint64_t key = nfc_util_bytes2num(sec_tr->key_a.data, 6); + uint64_t key_for_check_from_array = nfc_util_bytes2num(keyA, KEY_LENGTH); + if(key != key_for_check_from_array) return false; + + //Get credit in block number 8 + const uint8_t* temp_ptr = data->block[4].data; + uint16_t balance = (temp_ptr[6] << 8) | (temp_ptr[5]); + uint16_t previus_balance = (data->block[5].data[6] << 8) | (data->block[5].data[5]); + furi_string_cat_printf(parsed_data, "\e#Microel Card\n"); + furi_string_cat_printf(parsed_data, "UID:"); + for(size_t i = 0; i < UID_LENGTH; i++) { + furi_string_cat_printf(parsed_data, " %02X", uid[i]); + } + furi_string_cat_printf(parsed_data, "\nCurrent Credit: %d.%02d E \n", balance / 100, balance % 100); + furi_string_cat_printf(parsed_data, "Previus Credit: %d.%02d E \n", previus_balance / 100, previus_balance % 100); + + parsed = true; + } while(false); + + return parsed; +} + +/* Actual implementation of app<>plugin interface */ +static const NfcSupportedCardsPlugin microel_plugin = { + .protocol = NfcProtocolMfClassic, + .verify = NULL, // the verification I need is based on verifying the keys generated via uid and try to authenticate not like on mizip that there is default b0 + .read = microel_read, + .parse = microel_parse, +}; + +/* Plugin descriptor to comply with basic plugin specification */ +static const FlipperAppPluginDescriptor microel_plugin_descriptor = { + .appid = NFC_SUPPORTED_CARD_PLUGIN_APP_ID, + .ep_api_version = NFC_SUPPORTED_CARD_PLUGIN_API_VERSION, + .entry_point = µel_plugin, +}; + +/* Plugin entry point - must return a pointer to const descriptor */ +const FlipperAppPluginDescriptor* microel_plugin_ep() { + return µel_plugin_descriptor; +} \ No newline at end of file diff --git a/applications/main/nfc/plugins/supported_cards/mizip.c b/applications/main/nfc/plugins/supported_cards/mizip.c new file mode 100644 index 0000000000..aef3cb39d3 --- /dev/null +++ b/applications/main/nfc/plugins/supported_cards/mizip.c @@ -0,0 +1,205 @@ +#include "nfc_supported_card_plugin.h" +#include +#include +#include +#include +#include + +#define TAG "MiZIP" +#define KEY_LENGTH 6 +#define UID_LENGTH 4 + +typedef struct { + uint64_t a; + uint64_t b; +} MfClassicKeyPair; + +static MfClassicKeyPair mizip_1k_keys[] = { + {.a = 0xa0a1a2a3a4a5, .b = 0xb4c132439eef}, // 000 + {.a = 0x000000000000, .b = 0x000000000000}, // 001 + {.a = 0x000000000000, .b = 0x000000000000}, // 002 + {.a = 0x000000000000, .b = 0x000000000000}, // 003 + {.a = 0x000000000000, .b = 0x000000000000}, // 004 +}; + +const uint8_t verify_sector = 0; + +//KDF +void mizip_generate_key(uint8_t* uid, uint8_t keyA[4][KEY_LENGTH], uint8_t keyB[4][KEY_LENGTH]) { + // Static XOR table for key generation + static const uint8_t xor_table_keyA[4][6] = { + {0x09, 0x12, 0x5A, 0x25, 0x89, 0xE5}, + {0xAB, 0x75, 0xC9, 0x37, 0x92, 0x2F}, + {0xE2, 0x72, 0x41, 0xAF, 0x2C, 0x09}, + {0x31, 0x7A, 0xB7, 0x2F, 0x44, 0x90}}; + + static const uint8_t xor_table_keyB[4][6] = { + {0xF1, 0x2C, 0x84, 0x53, 0xD8, 0x21}, + {0x73, 0xE7, 0x99, 0xFE, 0x32, 0x41}, + {0xAA, 0x4D, 0x13, 0x76, 0x56, 0xAE}, + {0xB0, 0x13, 0x27, 0x27, 0x2D, 0xFD}}; + + // Permutation table for rearranging elements in uid + static const uint8_t xorOrderA[6] = {0, 1, 2, 3, 0, 1}; + static const uint8_t xorOrderB[6] = {2, 3, 0, 1, 2, 3}; + + // Generate key based on uid and XOR table + for(uint8_t j = 1; j < 5; j++) { + for(uint8_t i = 0; i < 6; i++) { + keyA[j][i] = uid[xorOrderA[i]] ^ xor_table_keyA[j - 1][i]; + keyB[j][i] = uid[xorOrderB[i]] ^ xor_table_keyB[j - 1][i]; + } + } +} + +//Fix get uid +static bool mizip_verify(Nfc* nfc) { + bool verified = false; + + do { + const uint8_t block_num = mf_classic_get_first_block_num_of_sector(verify_sector); + FURI_LOG_D(TAG, "Verifying sector %i", verify_sector); + + MfClassicKey key = {0}; + nfc_util_num2bytes(mizip_1k_keys[verify_sector].b, COUNT_OF(key.data), key.data); + + MfClassicAuthContext auth_context; + MfClassicError error = + mf_classic_poller_sync_auth(nfc, block_num, &key, MfClassicKeyTypeB, &auth_context); + if(error != MfClassicErrorNone) { + FURI_LOG_D(TAG, "Failed to read block %u: %d, this is not a MiZIP card", block_num, error); + break; + } + FURI_LOG_D(TAG, "Found a MiZIP Card"); + verified = true; + } while(false); + + return verified; +} + +static bool mizip_read(Nfc* nfc, NfcDevice* device) { + FURI_LOG_D(TAG, "Entering MiZIP KDF"); + furi_assert(nfc); + furi_assert(device); + + bool is_read = false; + + MfClassicData* data = mf_classic_alloc(); + nfc_device_copy_data(device, NfcProtocolMfClassic, data); + + do { + MfClassicType type = MfClassicTypeMini; + MfClassicError error = mf_classic_poller_sync_detect_type(nfc, &type); + if(error != MfClassicErrorNone) break; + + //temp fix but fix mf_classic_poller_sync_detect_type because view type mfclassic1k and not verify mfmini + data->type = MfClassicTypeMini; + + uint8_t uid[UID_LENGTH]; + memcpy(uid, data->iso14443_3a_data->uid, UID_LENGTH); + + uint8_t keyA[4][KEY_LENGTH]; + uint8_t keyB[4][KEY_LENGTH]; + mizip_generate_key(uid, keyA, keyB); + + for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) { + if(mizip_1k_keys[i].a == 0x000000000000 && mizip_1k_keys[i].b == 0x000000000000) { + mizip_1k_keys[i].a = nfc_util_bytes2num(keyA[i], KEY_LENGTH); + mizip_1k_keys[i].b = nfc_util_bytes2num(keyB[i], KEY_LENGTH); + } + } + + MfClassicDeviceKeys keys = {}; + for(size_t i = 0; i < mf_classic_get_total_sectors_num(data->type); i++) { + nfc_util_num2bytes(mizip_1k_keys[i].a, sizeof(MfClassicKey), keys.key_a[i].data); + FURI_BIT_SET(keys.key_a_mask, i); + nfc_util_num2bytes(mizip_1k_keys[i].b, sizeof(MfClassicKey), keys.key_b[i].data); + FURI_BIT_SET(keys.key_b_mask, i); + } + + error = mf_classic_poller_sync_read(nfc, &keys, data); + if(error != MfClassicErrorNone) { + FURI_LOG_W(TAG, "Failed to read data"); + break; + } + + nfc_device_set_data(device, NfcProtocolMfClassic, data); + + is_read = true; + } while(false); + + mf_classic_free(data); + + return is_read; +} + +static bool mizip_parse(const NfcDevice* device, FuriString* parsed_data) { + furi_assert(device); + furi_assert(parsed_data); + + const MfClassicData* data = nfc_device_get_data(device, NfcProtocolMfClassic); + + bool parsed = false; + + do { + // Verify key + MfClassicSectorTrailer* sec_tr = + mf_classic_get_sector_trailer_by_sector(data, verify_sector); + uint64_t key = nfc_util_bytes2num(sec_tr->key_b.data, 6); + if(key != mizip_1k_keys[verify_sector].b) return false; + + //Get UID + uint8_t uid[UID_LENGTH]; + memcpy(uid, data->iso14443_3a_data->uid, UID_LENGTH); + + //Get credit + uint8_t credit_pointer = 0x08; + uint8_t previus_credit_pointer = 0x09; + if(data->block[10].data[0] == 0x55) { + credit_pointer = 0x09; + previus_credit_pointer = 0x08; + } + uint16_t balance = (data->block[credit_pointer].data[2] << 8) | + (data->block[credit_pointer].data[1]); + uint16_t previus_balance = (data->block[previus_credit_pointer].data[2] << 8) | + (data->block[previus_credit_pointer].data[1]); + + //parse data + furi_string_cat_printf(parsed_data, "\e#MiZIP Card\n"); + furi_string_cat_printf(parsed_data, "UID:"); + for(size_t i = 0; i < UID_LENGTH; i++) { + furi_string_cat_printf(parsed_data, " %02X", uid[i]); + } + furi_string_cat_printf( + parsed_data, "\nCurrent Credit: %d.%02d E \n", balance / 100, balance % 100); + furi_string_cat_printf( + parsed_data, + "Previus Credit: %d.%02d E \n", + previus_balance / 100, + previus_balance % 100); + + parsed = true; + } while(false); + + return parsed; +} + +/* Actual implementation of app<>plugin interface */ +static const NfcSupportedCardsPlugin mizip_plugin = { + .protocol = NfcProtocolMfClassic, + .verify = mizip_verify, + .read = mizip_read, + .parse = mizip_parse, +}; + +/* Plugin descriptor to comply with basic plugin specification */ +static const FlipperAppPluginDescriptor mizip_plugin_descriptor = { + .appid = NFC_SUPPORTED_CARD_PLUGIN_APP_ID, + .ep_api_version = NFC_SUPPORTED_CARD_PLUGIN_API_VERSION, + .entry_point = &mizip_plugin, +}; + +/* Plugin entry point - must return a pointer to const descriptor */ +const FlipperAppPluginDescriptor* mizip_plugin_ep() { + return &mizip_plugin_descriptor; +} From de2a5d77cfaffdae05129a202bdc71951186d01f Mon Sep 17 00:00:00 2001 From: 47LeCoste <82815207+grugnoymeme@users.noreply.github.com> Date: Sat, 9 Dec 2023 13:37:18 +0100 Subject: [PATCH 2/4] Update application.fam --- applications/main/nfc/application.fam | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/applications/main/nfc/application.fam b/applications/main/nfc/application.fam index b5f4036447..12a28b6046 100644 --- a/applications/main/nfc/application.fam +++ b/applications/main/nfc/application.fam @@ -146,6 +146,24 @@ App( sources=["plugins/supported_cards/sonicare.c"], ) +App( + appid="mizip_parser", + apptype=FlipperAppType.PLUGIN, + entry_point="mizip_plugin_ep", + targets=["f7"], + requires=["nfc"], + sources=["plugins/supported_cards/mizip.c"], +) + +App( + appid="microel_parser", + apptype=FlipperAppType.PLUGIN, + entry_point="microel_plugin_ep", + targets=["f7"], + requires=["nfc"], + sources=["plugins/supported_cards/microel.c"], +) + App( appid="nfc_start", targets=["f7"], From 4c6eb896ed8c60e5e4ec21c4641a5e7819a10257 Mon Sep 17 00:00:00 2001 From: Willy-JL <49810075+Willy-JL@users.noreply.github.com> Date: Wed, 13 Dec 2023 01:33:08 +0000 Subject: [PATCH 3/4] Format --- .../nfc/plugins/supported_cards/microel.c | 76 +++++++++++-------- .../main/nfc/plugins/supported_cards/mizip.c | 3 +- 2 files changed, 45 insertions(+), 34 deletions(-) diff --git a/applications/main/nfc/plugins/supported_cards/microel.c b/applications/main/nfc/plugins/supported_cards/microel.c index 7cad11bc65..ef12c6e348 100644 --- a/applications/main/nfc/plugins/supported_cards/microel.c +++ b/applications/main/nfc/plugins/supported_cards/microel.c @@ -35,43 +35,46 @@ static MfClassicKeyPair microel_1k_keys[] = { const uint8_t verify_sector = 1; -void calcolaSommaHex(const uint8_t *uid, size_t uidSize, uint8_t sommaHex[]) { - const uint8_t xorKey[] = { 0x01, 0x92, 0xA7, 0x75, 0x2B, 0xF9 }; - int somma = 0; +void calcolaSommaHex(const uint8_t* uid, size_t uidSize, uint8_t sommaHex[]) { + const uint8_t xorKey[] = {0x01, 0x92, 0xA7, 0x75, 0x2B, 0xF9}; + int somma = 0; - for (size_t i = 0; i < uidSize; i++) { - somma += uid[i]; - } + for(size_t i = 0; i < uidSize; i++) { + somma += uid[i]; + } - int sommaDueNumeri = somma % 256; + int sommaDueNumeri = somma % 256; - for (size_t i = 0; i < sizeof(xorKey); i++) { - sommaHex[i] = sommaDueNumeri ^ xorKey[i]; - } + for(size_t i = 0; i < sizeof(xorKey); i++) { + sommaHex[i] = sommaDueNumeri ^ xorKey[i]; + } } -void generateKeyA(const uint8_t *uid, uint8_t uidSize, uint8_t keyA[]) { - uint8_t sommaHex[6]; - calcolaSommaHex(uid, uidSize, sommaHex); - uint8_t primoCarattere = (sommaHex[0] >> 4) & 0xF; +void generateKeyA(const uint8_t* uid, uint8_t uidSize, uint8_t keyA[]) { + uint8_t sommaHex[6]; + calcolaSommaHex(uid, uidSize, sommaHex); + uint8_t primoCarattere = (sommaHex[0] >> 4) & 0xF; - if (primoCarattere == 0x2 || primoCarattere == 0x3 || primoCarattere == 0xA || primoCarattere == 0xB) { - // XOR WITH 0x40 - for (size_t i = 0; i < sizeof(sommaHex); i++) { - keyA[i] = 0x40 ^ sommaHex[i]; - } - } else if (primoCarattere == 0x6 || primoCarattere == 0x7 || primoCarattere == 0xE || primoCarattere == 0xF) { - // XOR WITH 0xC0 - for (size_t i = 0; i < sizeof(sommaHex); i++) { - keyA[i] = 0xC0 ^ sommaHex[i]; + if(primoCarattere == 0x2 || primoCarattere == 0x3 || primoCarattere == 0xA || + primoCarattere == 0xB) { + // XOR WITH 0x40 + for(size_t i = 0; i < sizeof(sommaHex); i++) { + keyA[i] = 0x40 ^ sommaHex[i]; + } + } else if( + primoCarattere == 0x6 || primoCarattere == 0x7 || primoCarattere == 0xE || + primoCarattere == 0xF) { + // XOR WITH 0xC0 + for(size_t i = 0; i < sizeof(sommaHex); i++) { + keyA[i] = 0xC0 ^ sommaHex[i]; + } } - } } void generateKeyB(uint8_t keyA[], size_t keyASize, uint8_t keyB[]) { - for (size_t i = 0; i < keyASize; i++) { - keyB[i] = 0xFF ^ keyA[i]; - } + for(size_t i = 0; i < keyASize; i++) { + keyB[i] = 0xFF ^ keyA[i]; + } } /*static bool microel_verify(Nfc* nfc) { @@ -182,7 +185,7 @@ static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { furi_assert(device); furi_assert(parsed_data); - const MfClassicData* data = nfc_device_get_data(device, NfcProtocolMfClassic); + const MfClassicData* data = nfc_device_get_data(device, NfcProtocolMfClassic); bool parsed = false; @@ -197,7 +200,8 @@ static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { generateKeyA(uid, UID_LENGTH, keyA); // Verify key - MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, verify_sector); + MfClassicSectorTrailer* sec_tr = + mf_classic_get_sector_trailer_by_sector(data, verify_sector); uint64_t key = nfc_util_bytes2num(sec_tr->key_a.data, 6); uint64_t key_for_check_from_array = nfc_util_bytes2num(keyA, KEY_LENGTH); if(key != key_for_check_from_array) return false; @@ -211,9 +215,14 @@ static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { for(size_t i = 0; i < UID_LENGTH; i++) { furi_string_cat_printf(parsed_data, " %02X", uid[i]); } - furi_string_cat_printf(parsed_data, "\nCurrent Credit: %d.%02d E \n", balance / 100, balance % 100); - furi_string_cat_printf(parsed_data, "Previus Credit: %d.%02d E \n", previus_balance / 100, previus_balance % 100); - + furi_string_cat_printf( + parsed_data, "\nCurrent Credit: %d.%02d E \n", balance / 100, balance % 100); + furi_string_cat_printf( + parsed_data, + "Previus Credit: %d.%02d E \n", + previus_balance / 100, + previus_balance % 100); + parsed = true; } while(false); @@ -223,7 +232,8 @@ static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { /* Actual implementation of app<>plugin interface */ static const NfcSupportedCardsPlugin microel_plugin = { .protocol = NfcProtocolMfClassic, - .verify = NULL, // the verification I need is based on verifying the keys generated via uid and try to authenticate not like on mizip that there is default b0 + .verify = + NULL, // the verification I need is based on verifying the keys generated via uid and try to authenticate not like on mizip that there is default b0 .read = microel_read, .parse = microel_parse, }; diff --git a/applications/main/nfc/plugins/supported_cards/mizip.c b/applications/main/nfc/plugins/supported_cards/mizip.c index aef3cb39d3..e256454531 100644 --- a/applications/main/nfc/plugins/supported_cards/mizip.c +++ b/applications/main/nfc/plugins/supported_cards/mizip.c @@ -67,7 +67,8 @@ static bool mizip_verify(Nfc* nfc) { MfClassicError error = mf_classic_poller_sync_auth(nfc, block_num, &key, MfClassicKeyTypeB, &auth_context); if(error != MfClassicErrorNone) { - FURI_LOG_D(TAG, "Failed to read block %u: %d, this is not a MiZIP card", block_num, error); + FURI_LOG_D( + TAG, "Failed to read block %u: %d, this is not a MiZIP card", block_num, error); break; } FURI_LOG_D(TAG, "Found a MiZIP Card"); From a6a749b76fa56e9846e390fc819e553be032e58b Mon Sep 17 00:00:00 2001 From: Willy-JL <49810075+Willy-JL@users.noreply.github.com> Date: Wed, 13 Dec 2023 01:36:19 +0000 Subject: [PATCH 4/4] Consistency with do..while blocks usage --- applications/main/nfc/plugins/supported_cards/microel.c | 2 +- applications/main/nfc/plugins/supported_cards/mizip.c | 2 +- applications/main/nfc/plugins/supported_cards/two_cities.c | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/applications/main/nfc/plugins/supported_cards/microel.c b/applications/main/nfc/plugins/supported_cards/microel.c index ef12c6e348..c627be4613 100644 --- a/applications/main/nfc/plugins/supported_cards/microel.c +++ b/applications/main/nfc/plugins/supported_cards/microel.c @@ -204,7 +204,7 @@ static bool microel_parse(const NfcDevice* device, FuriString* parsed_data) { mf_classic_get_sector_trailer_by_sector(data, verify_sector); uint64_t key = nfc_util_bytes2num(sec_tr->key_a.data, 6); uint64_t key_for_check_from_array = nfc_util_bytes2num(keyA, KEY_LENGTH); - if(key != key_for_check_from_array) return false; + if(key != key_for_check_from_array) break; //Get credit in block number 8 const uint8_t* temp_ptr = data->block[4].data; diff --git a/applications/main/nfc/plugins/supported_cards/mizip.c b/applications/main/nfc/plugins/supported_cards/mizip.c index e256454531..c22a7f26de 100644 --- a/applications/main/nfc/plugins/supported_cards/mizip.c +++ b/applications/main/nfc/plugins/supported_cards/mizip.c @@ -147,7 +147,7 @@ static bool mizip_parse(const NfcDevice* device, FuriString* parsed_data) { MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, verify_sector); uint64_t key = nfc_util_bytes2num(sec_tr->key_b.data, 6); - if(key != mizip_1k_keys[verify_sector].b) return false; + if(key != mizip_1k_keys[verify_sector].b) break; //Get UID uint8_t uid[UID_LENGTH]; diff --git a/applications/main/nfc/plugins/supported_cards/two_cities.c b/applications/main/nfc/plugins/supported_cards/two_cities.c index 1748d372d2..a0f6e2fa48 100644 --- a/applications/main/nfc/plugins/supported_cards/two_cities.c +++ b/applications/main/nfc/plugins/supported_cards/two_cities.c @@ -111,7 +111,7 @@ static bool two_cities_parse(const NfcDevice* device, FuriString* parsed_data) { // Verify key MfClassicSectorTrailer* sec_tr = mf_classic_get_sector_trailer_by_sector(data, 4); uint64_t key = nfc_util_bytes2num(sec_tr->key_a.data, 6); - if(key != two_cities_4k_keys[4].a) return false; + if(key != two_cities_4k_keys[4].a) break; // ===== // PLANTAIN