|
|
@@ -1,45 +1,38 @@
|
|
|
-#include "nfc_device_i.h"
|
|
|
+#include "nfc_device.h"
|
|
|
|
|
|
-#include <file-worker.h>
|
|
|
#include <lib/toolbox/path.h>
|
|
|
-#include <lib/toolbox/hex.h>
|
|
|
-
|
|
|
-#define NFC_DEVICE_MAX_DATA_LEN 14
|
|
|
+#include <lib/flipper_file/flipper_file.h>
|
|
|
|
|
|
static const char* nfc_app_folder = "/any/nfc";
|
|
|
static const char* nfc_app_extension = ".nfc";
|
|
|
static const char* nfc_app_shadow_extension = ".shd";
|
|
|
+static const char* nfc_file_header = "Flipper NFC device";
|
|
|
+static const uint32_t nfc_file_version = 2;
|
|
|
+
|
|
|
+NfcDevice* nfc_device_alloc() {
|
|
|
+ NfcDevice* nfc_dev = furi_alloc(sizeof(NfcDevice));
|
|
|
+ nfc_dev->storage = furi_record_open("storage");
|
|
|
+ nfc_dev->dialogs = furi_record_open("dialogs");
|
|
|
+ return nfc_dev;
|
|
|
+}
|
|
|
|
|
|
-static bool nfc_device_read_hex(string_t str, uint8_t* buff, uint16_t len, uint8_t delim_len) {
|
|
|
- string_strim(str);
|
|
|
- uint8_t nibble_high = 0;
|
|
|
- uint8_t nibble_low = 0;
|
|
|
- bool parsed = true;
|
|
|
-
|
|
|
- for(uint16_t i = 0; i < len; i++) {
|
|
|
- if(hex_char_to_hex_nibble(string_get_char(str, 0), &nibble_high) &&
|
|
|
- hex_char_to_hex_nibble(string_get_char(str, 1), &nibble_low)) {
|
|
|
- buff[i] = (nibble_high << 4) | nibble_low;
|
|
|
- string_right(str, delim_len + 2);
|
|
|
- } else {
|
|
|
- parsed = false;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- return parsed;
|
|
|
+void nfc_device_free(NfcDevice* nfc_dev) {
|
|
|
+ furi_assert(nfc_dev);
|
|
|
+ furi_record_close("storage");
|
|
|
+ furi_record_close("dialogs");
|
|
|
+ free(nfc_dev);
|
|
|
}
|
|
|
|
|
|
-uint16_t nfc_device_prepare_format_string(NfcDevice* dev, string_t format_string) {
|
|
|
+void nfc_device_prepare_format_string(NfcDevice* dev, string_t format_string) {
|
|
|
if(dev->format == NfcDeviceSaveFormatUid) {
|
|
|
- string_set_str(format_string, "UID\n");
|
|
|
+ string_set_str(format_string, "UID");
|
|
|
} else if(dev->format == NfcDeviceSaveFormatBankCard) {
|
|
|
- string_set_str(format_string, "Bank card\n");
|
|
|
+ string_set_str(format_string, "Bank card");
|
|
|
} else if(dev->format == NfcDeviceSaveFormatMifareUl) {
|
|
|
- string_set_str(format_string, "Mifare Ultralight\n");
|
|
|
+ string_set_str(format_string, "Mifare Ultralight");
|
|
|
} else {
|
|
|
- string_set_str(format_string, "Unknown\n");
|
|
|
+ string_set_str(format_string, "Unknown");
|
|
|
}
|
|
|
- return string_size(format_string);
|
|
|
}
|
|
|
|
|
|
bool nfc_device_parse_format_string(NfcDevice* dev, string_t format_string) {
|
|
|
@@ -59,228 +52,166 @@ bool nfc_device_parse_format_string(NfcDevice* dev, string_t format_string) {
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
-uint16_t nfc_device_prepare_uid_string(NfcDevice* dev, string_t uid_string) {
|
|
|
- NfcDeviceCommonData* uid_data = &dev->dev_data.nfc_data;
|
|
|
- string_printf(uid_string, "UID len: %02X UID: ", dev->dev_data.nfc_data.uid_len);
|
|
|
- for(uint8_t i = 0; i < uid_data->uid_len; i++) {
|
|
|
- string_cat_printf(uid_string, "%02X ", uid_data->uid[i]);
|
|
|
- }
|
|
|
- string_cat_printf(
|
|
|
- uid_string,
|
|
|
- "ATQA: %02X %02X SAK: %02X\n",
|
|
|
- uid_data->atqa[0],
|
|
|
- uid_data->atqa[1],
|
|
|
- uid_data->sak);
|
|
|
- return string_size(uid_string);
|
|
|
-}
|
|
|
-
|
|
|
-bool nfc_device_parse_uid_string(NfcDevice* dev, string_t uid_string) {
|
|
|
- NfcDeviceCommonData* uid_data = &dev->dev_data.nfc_data;
|
|
|
- bool parsed = false;
|
|
|
+static bool nfc_device_save_mifare_ul_data(FlipperFile* file, NfcDevice* dev) {
|
|
|
+ bool saved = false;
|
|
|
+ MifareUlData* data = &dev->dev_data.mf_ul_data;
|
|
|
+ string_t temp_str;
|
|
|
+ string_init(temp_str);
|
|
|
|
|
|
+ // Save Mifare Ultralight specific data
|
|
|
do {
|
|
|
- // strlen("UID len: ") = 9
|
|
|
- string_right(uid_string, 9);
|
|
|
- if(!nfc_device_read_hex(uid_string, &uid_data->uid_len, 1, 1)) {
|
|
|
+ if(!flipper_file_write_comment_cstr(file, "Mifare Ultralight specific data")) break;
|
|
|
+ if(!flipper_file_write_hex(file, "Signature", data->signature, sizeof(data->signature)))
|
|
|
break;
|
|
|
- }
|
|
|
- // strlen("UID: ") = 5
|
|
|
- string_right(uid_string, 5);
|
|
|
- if(!nfc_device_read_hex(uid_string, uid_data->uid, uid_data->uid_len, 1)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- // strlen("ATQA: ") = 6
|
|
|
- string_right(uid_string, 6);
|
|
|
- if(!nfc_device_read_hex(uid_string, uid_data->atqa, 2, 1)) {
|
|
|
+ if(!flipper_file_write_hex(
|
|
|
+ file, "Mifare version", (uint8_t*)&data->version, sizeof(data->version)))
|
|
|
break;
|
|
|
+ // Write conters and tearing flags data
|
|
|
+ bool counters_saved = true;
|
|
|
+ for(uint8_t i = 0; i < 3; i++) {
|
|
|
+ string_printf(temp_str, "Counter %d", i);
|
|
|
+ if(!flipper_file_write_uint32(file, string_get_cstr(temp_str), &data->counter[i], 1)) {
|
|
|
+ counters_saved = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ string_printf(temp_str, "Tearing %d", i);
|
|
|
+ if(!flipper_file_write_hex(file, string_get_cstr(temp_str), &data->tearing[i], 1)) {
|
|
|
+ counters_saved = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
- // strlen("SAK: ") = 5
|
|
|
- string_right(uid_string, 5);
|
|
|
- if(!nfc_device_read_hex(uid_string, &uid_data->sak, 1, 1)) {
|
|
|
- break;
|
|
|
+ if(!counters_saved) break;
|
|
|
+ // Write pages data
|
|
|
+ uint32_t pages_total = data->data_size / 4;
|
|
|
+ if(!flipper_file_write_uint32(file, "Pages total", &pages_total, 1)) break;
|
|
|
+ bool pages_saved = true;
|
|
|
+ for(uint16_t i = 0; i < data->data_size; i += 4) {
|
|
|
+ string_printf(temp_str, "Page %d", i / 4);
|
|
|
+ if(!flipper_file_write_hex(file, string_get_cstr(temp_str), &data->data[i], 4)) {
|
|
|
+ pages_saved = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
}
|
|
|
- parsed = true;
|
|
|
- } while(0);
|
|
|
-
|
|
|
- return parsed;
|
|
|
-}
|
|
|
+ if(!pages_saved) break;
|
|
|
+ saved = true;
|
|
|
+ } while(false);
|
|
|
|
|
|
-uint16_t nfc_device_prepare_mifare_ul_string(NfcDevice* dev, string_t mifare_ul_string) {
|
|
|
- MifareUlData* data = &dev->dev_data.mf_ul_data;
|
|
|
- string_printf(mifare_ul_string, "Signature:");
|
|
|
- for(uint8_t i = 0; i < sizeof(data->signature); i++) {
|
|
|
- string_cat_printf(mifare_ul_string, " %02X", data->signature[i]);
|
|
|
- }
|
|
|
- string_cat_printf(mifare_ul_string, "\nVersion:");
|
|
|
- uint8_t* version = (uint8_t*)&data->version;
|
|
|
- for(uint8_t i = 0; i < sizeof(data->version); i++) {
|
|
|
- string_cat_printf(mifare_ul_string, " %02X", version[i]);
|
|
|
- }
|
|
|
- for(uint8_t i = 0; i < 3; i++) {
|
|
|
- string_cat_printf(
|
|
|
- mifare_ul_string,
|
|
|
- "\nCounter %d: %lu Tearing flag %d: %02X",
|
|
|
- i,
|
|
|
- data->counter[i],
|
|
|
- i,
|
|
|
- data->tearing[i]);
|
|
|
- }
|
|
|
- string_cat_printf(mifare_ul_string, "\nData size: %d\n", data->data_size);
|
|
|
- for(uint16_t i = 0; i < data->data_size; i += 4) {
|
|
|
- string_cat_printf(
|
|
|
- mifare_ul_string,
|
|
|
- "%02X %02X %02X %02X\n",
|
|
|
- data->data[i],
|
|
|
- data->data[i + 1],
|
|
|
- data->data[i + 2],
|
|
|
- data->data[i + 3]);
|
|
|
- }
|
|
|
- return string_size(mifare_ul_string);
|
|
|
+ string_clear(temp_str);
|
|
|
+ return saved;
|
|
|
}
|
|
|
|
|
|
-bool nfc_device_parse_mifare_ul_string(NfcDevice* dev, string_t mifare_ul_string) {
|
|
|
- MifareUlData* data = &dev->dev_data.mf_ul_data;
|
|
|
- uint16_t tearing_tmp = 0;
|
|
|
- uint16_t cnt_num = 0;
|
|
|
- size_t ws = 0;
|
|
|
- int res = 0;
|
|
|
+bool nfc_device_load_mifare_ul_data(FlipperFile* file, NfcDevice* dev) {
|
|
|
bool parsed = false;
|
|
|
+ MifareUlData* data = &dev->dev_data.mf_ul_data;
|
|
|
+ string_t temp_str;
|
|
|
+ string_init(temp_str);
|
|
|
|
|
|
do {
|
|
|
- // strlen("Signature: ") = 11
|
|
|
- string_right(mifare_ul_string, 11);
|
|
|
- if(!nfc_device_read_hex(mifare_ul_string, data->signature, sizeof(data->signature), 1)) {
|
|
|
+ // Read signature
|
|
|
+ if(!flipper_file_read_hex(file, "Signature", data->signature, sizeof(data->signature)))
|
|
|
break;
|
|
|
- }
|
|
|
- // strlen("Version: ") = 9
|
|
|
- string_right(mifare_ul_string, 9);
|
|
|
- if(!nfc_device_read_hex(
|
|
|
- mifare_ul_string, (uint8_t*)&data->version, sizeof(data->version), 1)) {
|
|
|
+ // Read Mifare version
|
|
|
+ if(!flipper_file_read_hex(
|
|
|
+ file, "Mifare version", (uint8_t*)&data->version, sizeof(data->version)))
|
|
|
break;
|
|
|
- }
|
|
|
- string_strim(mifare_ul_string);
|
|
|
// Read counters and tearing flags
|
|
|
+ bool counters_parsed = true;
|
|
|
for(uint8_t i = 0; i < 3; i++) {
|
|
|
- res = sscanf(
|
|
|
- string_get_cstr(mifare_ul_string),
|
|
|
- "Counter %hX: %lu Tearing flag %hX: %02hX",
|
|
|
- &cnt_num,
|
|
|
- &data->counter[i],
|
|
|
- &cnt_num,
|
|
|
- &tearing_tmp);
|
|
|
- if(res != 4) {
|
|
|
+ string_printf(temp_str, "Counter %d", i);
|
|
|
+ if(!flipper_file_read_uint32(file, string_get_cstr(temp_str), &data->counter[i], 1)) {
|
|
|
+ counters_parsed = false;
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ string_printf(temp_str, "Tearing %d", i);
|
|
|
+ if(!flipper_file_read_hex(file, string_get_cstr(temp_str), &data->tearing[i], 1)) {
|
|
|
+ counters_parsed = false;
|
|
|
break;
|
|
|
}
|
|
|
- data->tearing[i] = tearing_tmp;
|
|
|
- ws = string_search_char(mifare_ul_string, '\n');
|
|
|
- string_right(mifare_ul_string, ws + 1);
|
|
|
- }
|
|
|
- // Read data size
|
|
|
- res = sscanf(string_get_cstr(mifare_ul_string), "Data size: %hu", &data->data_size);
|
|
|
- if(res != 1) {
|
|
|
- break;
|
|
|
}
|
|
|
- ws = string_search_char(mifare_ul_string, '\n');
|
|
|
- string_right(mifare_ul_string, ws + 1);
|
|
|
- // Read data
|
|
|
- for(uint16_t i = 0; i < data->data_size; i += 4) {
|
|
|
- if(!nfc_device_read_hex(mifare_ul_string, &data->data[i], 4, 1)) {
|
|
|
+ if(!counters_parsed) break;
|
|
|
+ // Read pages
|
|
|
+ uint32_t pages = 0;
|
|
|
+ if(!flipper_file_read_uint32(file, "Pages total", &pages, 1)) break;
|
|
|
+ data->data_size = pages * 4;
|
|
|
+ bool pages_parsed = true;
|
|
|
+ for(uint16_t i = 0; i < pages; i++) {
|
|
|
+ string_printf(temp_str, "Page %d", i);
|
|
|
+ if(!flipper_file_read_hex(file, string_get_cstr(temp_str), &data->data[i * 4], 4)) {
|
|
|
+ pages_parsed = false;
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
+ if(!pages_parsed) break;
|
|
|
parsed = true;
|
|
|
- } while(0);
|
|
|
+ } while(false);
|
|
|
|
|
|
+ string_clear(temp_str);
|
|
|
return parsed;
|
|
|
}
|
|
|
|
|
|
-uint16_t nfc_device_prepare_bank_card_string(NfcDevice* dev, string_t bank_card_string) {
|
|
|
+static bool nfc_device_save_bank_card_data(FlipperFile* file, NfcDevice* dev) {
|
|
|
+ bool saved = false;
|
|
|
NfcEmvData* data = &dev->dev_data.emv_data;
|
|
|
- string_printf(bank_card_string, "AID len: %d, AID:", data->aid_len);
|
|
|
- for(uint8_t i = 0; i < data->aid_len; i++) {
|
|
|
- string_cat_printf(bank_card_string, " %02X", data->aid[i]);
|
|
|
- }
|
|
|
- string_cat_printf(
|
|
|
- bank_card_string, "\nName: %s\nNumber len: %d\nNumber:", data->name, data->number_len);
|
|
|
- for(uint8_t i = 0; i < data->number_len; i++) {
|
|
|
- string_cat_printf(bank_card_string, " %02X", data->number[i]);
|
|
|
- }
|
|
|
- if(data->exp_mon) {
|
|
|
- string_cat_printf(
|
|
|
- bank_card_string, "\nExp date: %02X/%02X", data->exp_mon, data->exp_year);
|
|
|
- }
|
|
|
- if(data->country_code) {
|
|
|
- string_cat_printf(bank_card_string, "\nCountry code: %04X", data->country_code);
|
|
|
- }
|
|
|
- if(data->currency_code) {
|
|
|
- string_cat_printf(bank_card_string, "\nCurrency code: %04X", data->currency_code);
|
|
|
- }
|
|
|
- return string_size(bank_card_string);
|
|
|
+ uint32_t data_temp = 0;
|
|
|
+
|
|
|
+ do {
|
|
|
+ // Write Bank card specific data
|
|
|
+ if(!flipper_file_write_comment_cstr(file, "Bank card specific data")) break;
|
|
|
+ if(!flipper_file_write_hex(file, "AID", data->aid, data->aid_len)) break;
|
|
|
+ if(!flipper_file_write_string_cstr(file, "Name", data->name)) break;
|
|
|
+ if(!flipper_file_write_hex(file, "Number", data->number, data->number_len)) break;
|
|
|
+ if(data->exp_mon) {
|
|
|
+ uint8_t exp_data[2] = {data->exp_mon, data->exp_year};
|
|
|
+ if(!flipper_file_write_hex(file, "Exp data", exp_data, sizeof(exp_data))) break;
|
|
|
+ }
|
|
|
+ if(data->country_code) {
|
|
|
+ data_temp = data->country_code;
|
|
|
+ if(!flipper_file_write_uint32(file, "Country code", &data_temp, 1)) break;
|
|
|
+ }
|
|
|
+ if(data->currency_code) {
|
|
|
+ data_temp = data->currency_code;
|
|
|
+ if(!flipper_file_write_uint32(file, "Currency code", &data_temp, 1)) break;
|
|
|
+ }
|
|
|
+ saved = true;
|
|
|
+ } while(false);
|
|
|
+
|
|
|
+ return saved;
|
|
|
}
|
|
|
|
|
|
-bool nfc_device_parse_bank_card_string(NfcDevice* dev, string_t bank_card_string) {
|
|
|
- NfcEmvData* data = &dev->dev_data.emv_data;
|
|
|
+bool nfc_device_load_bank_card_data(FlipperFile* file, NfcDevice* dev) {
|
|
|
bool parsed = false;
|
|
|
- int res = 0;
|
|
|
- uint8_t code[2] = {};
|
|
|
+ NfcEmvData* data = &dev->dev_data.emv_data;
|
|
|
memset(data, 0, sizeof(NfcEmvData));
|
|
|
+ uint32_t data_cnt = 0;
|
|
|
+ string_t temp_str;
|
|
|
+ string_init(temp_str);
|
|
|
|
|
|
do {
|
|
|
- res = sscanf(string_get_cstr(bank_card_string), "AID len: %hu", &data->aid_len);
|
|
|
- if(res != 1) {
|
|
|
- break;
|
|
|
- }
|
|
|
- // strlen("AID len: ") = 9
|
|
|
- string_right(bank_card_string, 9);
|
|
|
- size_t ws = string_search_char(bank_card_string, ':');
|
|
|
- string_right(bank_card_string, ws + 1);
|
|
|
- if(!nfc_device_read_hex(bank_card_string, data->aid, data->aid_len, 1)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- res = sscanf(string_get_cstr(bank_card_string), "Name: %s\n", data->name);
|
|
|
- if(res != 1) {
|
|
|
- break;
|
|
|
- }
|
|
|
- ws = string_search_char(bank_card_string, '\n');
|
|
|
- string_right(bank_card_string, ws + 1);
|
|
|
- res = sscanf(string_get_cstr(bank_card_string), "Number len: %hhu", &data->number_len);
|
|
|
- if(res != 1) {
|
|
|
- break;
|
|
|
- }
|
|
|
- ws = string_search_char(bank_card_string, '\n');
|
|
|
- string_right(bank_card_string, ws + 1);
|
|
|
- // strlen("Number: ") = 8
|
|
|
- string_right(bank_card_string, 8);
|
|
|
- if(!nfc_device_read_hex(bank_card_string, data->number, data->number_len, 1)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ // Load essential data
|
|
|
+ if(!flipper_file_get_value_count(file, "AID", &data_cnt)) break;
|
|
|
+ data->aid_len = data_cnt;
|
|
|
+ if(!flipper_file_read_hex(file, "AID", data->aid, data->aid_len)) break;
|
|
|
+ if(!flipper_file_read_string(file, "Name", temp_str)) break;
|
|
|
+ strlcpy(data->name, string_get_cstr(temp_str), sizeof(data->name));
|
|
|
+ if(!flipper_file_get_value_count(file, "Number", &data_cnt)) break;
|
|
|
+ data->number_len = data_cnt;
|
|
|
+ if(!flipper_file_read_hex(file, "Number", data->number, data->number_len)) break;
|
|
|
parsed = true;
|
|
|
- // Check expiration date presence
|
|
|
- ws = string_search_str(bank_card_string, "Exp date: ");
|
|
|
- if(ws != STRING_FAILURE) {
|
|
|
- // strlen("Exp date: ") = 10
|
|
|
- string_right(bank_card_string, 10);
|
|
|
- nfc_device_read_hex(bank_card_string, &data->exp_mon, 1, 1);
|
|
|
- nfc_device_read_hex(bank_card_string, &data->exp_year, 1, 1);
|
|
|
+ // Load optional data
|
|
|
+ uint8_t exp_data[2] = {};
|
|
|
+ if(flipper_file_read_hex(file, "Exp data", exp_data, 2)) {
|
|
|
+ data->exp_mon = exp_data[0];
|
|
|
+ data->exp_year = exp_data[1];
|
|
|
}
|
|
|
- // Check country code presence
|
|
|
- ws = string_search_str(bank_card_string, "Country code: ");
|
|
|
- if(ws != STRING_FAILURE) {
|
|
|
- // strlen("Country code: ") = 14
|
|
|
- string_right(bank_card_string, 14);
|
|
|
- nfc_device_read_hex(bank_card_string, code, 2, 0);
|
|
|
- data->country_code = code[0] << 8 | code[1];
|
|
|
+ if(flipper_file_read_uint32(file, "Country code", &data_cnt, 1)) {
|
|
|
+ data->country_code = data_cnt;
|
|
|
}
|
|
|
- // Check currency code presence
|
|
|
- ws = string_search_str(bank_card_string, "Currency code: ");
|
|
|
- if(ws != STRING_FAILURE) {
|
|
|
- // strlen("Currency code: ") = 15
|
|
|
- string_right(bank_card_string, 15);
|
|
|
- nfc_device_read_hex(bank_card_string, code, 2, 0);
|
|
|
- data->currency_code = code[0] << 8 | code[1];
|
|
|
+ if(flipper_file_read_uint32(file, "Currency code", &data_cnt, 1)) {
|
|
|
+ data->currency_code = data_cnt;
|
|
|
}
|
|
|
- } while(0);
|
|
|
+ } while(false);
|
|
|
|
|
|
+ string_clear(temp_str);
|
|
|
return parsed;
|
|
|
}
|
|
|
|
|
|
@@ -297,58 +228,49 @@ static bool nfc_device_save_file(
|
|
|
const char* extension) {
|
|
|
furi_assert(dev);
|
|
|
|
|
|
- FileWorker* file_worker = file_worker_alloc(false);
|
|
|
- string_t dev_file_name;
|
|
|
- string_init(dev_file_name);
|
|
|
+ bool saved = false;
|
|
|
+ FlipperFile* file = flipper_file_alloc(dev->storage);
|
|
|
+ NfcDeviceCommonData* data = &dev->dev_data.nfc_data;
|
|
|
string_t temp_str;
|
|
|
string_init(temp_str);
|
|
|
- uint16_t string_len = 0;
|
|
|
|
|
|
do {
|
|
|
// Create nfc directory if necessary
|
|
|
- if(!file_worker_mkdir(file_worker, nfc_app_folder)) {
|
|
|
- break;
|
|
|
- };
|
|
|
+ if(!storage_simply_mkdir(dev->storage, nfc_app_folder)) break;
|
|
|
// First remove nfc device file if it was saved
|
|
|
- string_printf(dev_file_name, "%s/%s%s", folder, dev_name, extension);
|
|
|
- if(!file_worker_remove(file_worker, string_get_cstr(dev_file_name))) {
|
|
|
- break;
|
|
|
- };
|
|
|
+ string_printf(temp_str, "%s/%s%s", folder, dev_name, extension);
|
|
|
// Open file
|
|
|
- if(!file_worker_open(
|
|
|
- file_worker, string_get_cstr(dev_file_name), FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- // Prepare and write format name on 1st line
|
|
|
- string_len = nfc_device_prepare_format_string(dev, temp_str);
|
|
|
- if(!file_worker_write(file_worker, string_get_cstr(temp_str), string_len)) {
|
|
|
+ if(!flipper_file_open_always(file, string_get_cstr(temp_str))) break;
|
|
|
+ // Write header
|
|
|
+ if(!flipper_file_write_header_cstr(file, nfc_file_header, nfc_file_version)) break;
|
|
|
+ // Write nfc device type
|
|
|
+ if(!flipper_file_write_comment_cstr(
|
|
|
+ file, "Nfc device type can be UID, Mifare Ultralight, Bank card"))
|
|
|
break;
|
|
|
- }
|
|
|
- // Prepare and write UID data on 2nd line
|
|
|
- string_len = nfc_device_prepare_uid_string(dev, temp_str);
|
|
|
- if(!file_worker_write(file_worker, string_get_cstr(temp_str), string_len)) {
|
|
|
+ nfc_device_prepare_format_string(dev, temp_str);
|
|
|
+ if(!flipper_file_write_string(file, "Device type", temp_str)) break;
|
|
|
+ // Write UID, ATQA, SAK
|
|
|
+ if(!flipper_file_write_comment_cstr(file, "UID, ATQA and SAK are common for all formats"))
|
|
|
break;
|
|
|
- }
|
|
|
+ if(!flipper_file_write_hex(file, "UID", data->uid, data->uid_len)) break;
|
|
|
+ if(!flipper_file_write_hex(file, "ATQA", data->atqa, 2)) break;
|
|
|
+ if(!flipper_file_write_hex(file, "SAK", &data->sak, 1)) break;
|
|
|
// Save more data if necessary
|
|
|
if(dev->format == NfcDeviceSaveFormatMifareUl) {
|
|
|
- string_len = nfc_device_prepare_mifare_ul_string(dev, temp_str);
|
|
|
- if(!file_worker_write(file_worker, string_get_cstr(temp_str), string_len)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!nfc_device_save_mifare_ul_data(file, dev)) break;
|
|
|
} else if(dev->format == NfcDeviceSaveFormatBankCard) {
|
|
|
- string_len = nfc_device_prepare_bank_card_string(dev, temp_str);
|
|
|
- if(!file_worker_write(file_worker, string_get_cstr(temp_str), string_len)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!nfc_device_save_bank_card_data(file, dev)) break;
|
|
|
}
|
|
|
+ saved = true;
|
|
|
} while(0);
|
|
|
|
|
|
+ if(!saved) {
|
|
|
+ dialog_message_show_storage_error(dev->dialogs, "Can not save\nkey file");
|
|
|
+ }
|
|
|
string_clear(temp_str);
|
|
|
- string_clear(dev_file_name);
|
|
|
- file_worker_close(file_worker);
|
|
|
- file_worker_free(file_worker);
|
|
|
-
|
|
|
- return true;
|
|
|
+ flipper_file_close(file);
|
|
|
+ flipper_file_free(file);
|
|
|
+ return saved;
|
|
|
}
|
|
|
|
|
|
bool nfc_device_save(NfcDevice* dev, const char* dev_name) {
|
|
|
@@ -360,73 +282,64 @@ bool nfc_device_save_shadow(NfcDevice* dev, const char* dev_name) {
|
|
|
return nfc_device_save_file(dev, dev_name, nfc_app_folder, nfc_app_shadow_extension);
|
|
|
}
|
|
|
|
|
|
-static bool nfc_device_load_data(FileWorker* file_worker, string_t path, NfcDevice* dev) {
|
|
|
- string_t temp_string;
|
|
|
- string_init(temp_string);
|
|
|
+static bool nfc_device_load_data(NfcDevice* dev, string_t path) {
|
|
|
bool parsed = false;
|
|
|
+ FlipperFile* file = flipper_file_alloc(dev->storage);
|
|
|
+ NfcDeviceCommonData* data = &dev->dev_data.nfc_data;
|
|
|
+ uint32_t data_cnt = 0;
|
|
|
+ string_t temp_str;
|
|
|
+ string_init(temp_str);
|
|
|
+ bool depricated_version = false;
|
|
|
|
|
|
do {
|
|
|
// Check existance of shadow file
|
|
|
size_t ext_start = string_search_str(path, nfc_app_extension);
|
|
|
- string_set_n(temp_string, path, 0, ext_start);
|
|
|
- string_cat_printf(temp_string, "%s", nfc_app_shadow_extension);
|
|
|
- if(!file_worker_is_file_exist(
|
|
|
- file_worker, string_get_cstr(temp_string), &dev->shadow_file_exist)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ string_set_n(temp_str, path, 0, ext_start);
|
|
|
+ string_cat_printf(temp_str, "%s", nfc_app_shadow_extension);
|
|
|
+ dev->shadow_file_exist =
|
|
|
+ storage_common_stat(dev->storage, string_get_cstr(temp_str), NULL) == FSE_OK;
|
|
|
// Open shadow file if it exists. If not - open original
|
|
|
if(dev->shadow_file_exist) {
|
|
|
- if(!file_worker_open(
|
|
|
- file_worker, string_get_cstr(temp_string), FSAM_READ, FSOM_OPEN_EXISTING)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!flipper_file_open_existing(file, string_get_cstr(temp_str))) break;
|
|
|
} else {
|
|
|
- if(!file_worker_open(
|
|
|
- file_worker, string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!flipper_file_open_existing(file, string_get_cstr(path))) break;
|
|
|
}
|
|
|
-
|
|
|
- // Read and parse format from 1st line
|
|
|
- if(!file_worker_read_until(file_worker, temp_string, '\n')) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if(!nfc_device_parse_format_string(dev, temp_string)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- // Read and parse UID data from 2nd line
|
|
|
- if(!file_worker_read_until(file_worker, temp_string, '\n')) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if(!nfc_device_parse_uid_string(dev, temp_string)) {
|
|
|
+ // Read and verify file header
|
|
|
+ uint32_t version = 0;
|
|
|
+ if(!flipper_file_read_header(file, temp_str, &version)) break;
|
|
|
+ if(string_cmp_str(temp_str, nfc_file_header) || (version != nfc_file_version)) {
|
|
|
+ depricated_version = true;
|
|
|
break;
|
|
|
}
|
|
|
+ // Read Nfc device type
|
|
|
+ if(!flipper_file_read_string(file, "Device type", temp_str)) break;
|
|
|
+ if(!nfc_device_parse_format_string(dev, temp_str)) break;
|
|
|
+ // Read and parse UID, ATQA and SAK
|
|
|
+ if(!flipper_file_get_value_count(file, "UID", &data_cnt)) break;
|
|
|
+ data->uid_len = data_cnt;
|
|
|
+ if(!flipper_file_read_hex(file, "UID", data->uid, data->uid_len)) break;
|
|
|
+ if(!flipper_file_read_hex(file, "ATQA", data->atqa, 2)) break;
|
|
|
+ if(!flipper_file_read_hex(file, "SAK", &data->sak, 1)) break;
|
|
|
// Parse other data
|
|
|
if(dev->format == NfcDeviceSaveFormatMifareUl) {
|
|
|
- // Read until EOF
|
|
|
- if(!file_worker_read_until(file_worker, temp_string, 0x05)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if(!nfc_device_parse_mifare_ul_string(dev, temp_string)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!nfc_device_load_mifare_ul_data(file, dev)) break;
|
|
|
} else if(dev->format == NfcDeviceSaveFormatBankCard) {
|
|
|
- // Read until EOF
|
|
|
- if(!file_worker_read_until(file_worker, temp_string, 0x05)) {
|
|
|
- break;
|
|
|
- }
|
|
|
- if(!nfc_device_parse_bank_card_string(dev, temp_string)) {
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!nfc_device_load_bank_card_data(file, dev)) break;
|
|
|
}
|
|
|
parsed = true;
|
|
|
- } while(0);
|
|
|
+ } while(false);
|
|
|
|
|
|
if(!parsed) {
|
|
|
- file_worker_show_error(file_worker, "Can not parse\nfile");
|
|
|
+ if(depricated_version) {
|
|
|
+ dialog_message_show_storage_error(dev->dialogs, "File format depricated");
|
|
|
+ } else {
|
|
|
+ dialog_message_show_storage_error(dev->dialogs, "Can not parse\nfile");
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- string_clear(temp_string);
|
|
|
+ string_clear(temp_str);
|
|
|
+ flipper_file_close(file);
|
|
|
+ flipper_file_free(file);
|
|
|
return parsed;
|
|
|
}
|
|
|
|
|
|
@@ -434,19 +347,16 @@ bool nfc_device_load(NfcDevice* dev, const char* file_path) {
|
|
|
furi_assert(dev);
|
|
|
furi_assert(file_path);
|
|
|
|
|
|
- FileWorker* file_worker = file_worker_alloc(false);
|
|
|
// Load device data
|
|
|
string_t path;
|
|
|
string_init_set_str(path, file_path);
|
|
|
- bool dev_load = nfc_device_load_data(file_worker, path, dev);
|
|
|
+ bool dev_load = nfc_device_load_data(dev, path);
|
|
|
if(dev_load) {
|
|
|
// Set device name
|
|
|
path_extract_filename_no_ext(file_path, path);
|
|
|
nfc_device_set_name(dev, string_get_cstr(path));
|
|
|
}
|
|
|
string_clear(path);
|
|
|
- file_worker_close(file_worker);
|
|
|
- file_worker_free(file_worker);
|
|
|
|
|
|
return dev_load;
|
|
|
}
|
|
|
@@ -454,10 +364,9 @@ bool nfc_device_load(NfcDevice* dev, const char* file_path) {
|
|
|
bool nfc_file_select(NfcDevice* dev) {
|
|
|
furi_assert(dev);
|
|
|
|
|
|
- FileWorker* file_worker = file_worker_alloc(false);
|
|
|
// Input events and views are managed by file_select
|
|
|
- bool res = file_worker_file_select(
|
|
|
- file_worker,
|
|
|
+ bool res = dialog_file_select_show(
|
|
|
+ dev->dialogs,
|
|
|
nfc_app_folder,
|
|
|
nfc_app_extension,
|
|
|
dev->file_name,
|
|
|
@@ -465,18 +374,14 @@ bool nfc_file_select(NfcDevice* dev) {
|
|
|
dev->dev_name);
|
|
|
if(res) {
|
|
|
string_t dev_str;
|
|
|
-
|
|
|
// Get key file path
|
|
|
string_init_printf(dev_str, "%s/%s%s", nfc_app_folder, dev->file_name, nfc_app_extension);
|
|
|
-
|
|
|
- res = nfc_device_load_data(file_worker, dev_str, dev);
|
|
|
+ res = nfc_device_load_data(dev, dev_str);
|
|
|
if(res) {
|
|
|
nfc_device_set_name(dev, dev->file_name);
|
|
|
}
|
|
|
string_clear(dev_str);
|
|
|
}
|
|
|
- file_worker_close(file_worker);
|
|
|
- file_worker_free(file_worker);
|
|
|
|
|
|
return res;
|
|
|
}
|
|
|
@@ -491,61 +396,48 @@ void nfc_device_clear(NfcDevice* dev) {
|
|
|
bool nfc_device_delete(NfcDevice* dev) {
|
|
|
furi_assert(dev);
|
|
|
|
|
|
- bool result = true;
|
|
|
- FileWorker* file_worker = file_worker_alloc(false);
|
|
|
+ bool deleted = false;
|
|
|
string_t file_path;
|
|
|
+ string_init(file_path);
|
|
|
|
|
|
do {
|
|
|
// Delete original file
|
|
|
string_init_printf(file_path, "%s/%s%s", nfc_app_folder, dev->dev_name, nfc_app_extension);
|
|
|
- if(!file_worker_remove(file_worker, string_get_cstr(file_path))) {
|
|
|
- result = false;
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!storage_simply_remove(dev->storage, string_get_cstr(file_path))) break;
|
|
|
// Delete shadow file if it exists
|
|
|
if(dev->shadow_file_exist) {
|
|
|
- string_clean(file_path);
|
|
|
string_printf(
|
|
|
file_path, "%s/%s%s", nfc_app_folder, dev->dev_name, nfc_app_shadow_extension);
|
|
|
- if(!file_worker_remove(file_worker, string_get_cstr(file_path))) {
|
|
|
- result = false;
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!storage_simply_remove(dev->storage, string_get_cstr(file_path))) break;
|
|
|
}
|
|
|
+ deleted = true;
|
|
|
} while(0);
|
|
|
|
|
|
+ if(!deleted) {
|
|
|
+ dialog_message_show_storage_error(dev->dialogs, "Can not remove file");
|
|
|
+ }
|
|
|
+
|
|
|
string_clear(file_path);
|
|
|
- file_worker_close(file_worker);
|
|
|
- file_worker_free(file_worker);
|
|
|
- return result;
|
|
|
+ return deleted;
|
|
|
}
|
|
|
|
|
|
bool nfc_device_restore(NfcDevice* dev) {
|
|
|
furi_assert(dev);
|
|
|
furi_assert(dev->shadow_file_exist);
|
|
|
|
|
|
- bool result = true;
|
|
|
- FileWorker* file_worker = file_worker_alloc(false);
|
|
|
+ bool restored = false;
|
|
|
string_t path;
|
|
|
|
|
|
do {
|
|
|
string_init_printf(
|
|
|
path, "%s/%s%s", nfc_app_folder, dev->dev_name, nfc_app_shadow_extension);
|
|
|
- if(!file_worker_remove(file_worker, string_get_cstr(path))) {
|
|
|
- result = false;
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!storage_simply_remove(dev->storage, string_get_cstr(path))) break;
|
|
|
dev->shadow_file_exist = false;
|
|
|
- string_clean(path);
|
|
|
string_printf(path, "%s/%s%s", nfc_app_folder, dev->dev_name, nfc_app_extension);
|
|
|
- if(!nfc_device_load_data(file_worker, path, dev)) {
|
|
|
- result = false;
|
|
|
- break;
|
|
|
- }
|
|
|
+ if(!nfc_device_load_data(dev, path)) break;
|
|
|
+ restored = true;
|
|
|
} while(0);
|
|
|
|
|
|
string_clear(path);
|
|
|
- file_worker_close(file_worker);
|
|
|
- file_worker_free(file_worker);
|
|
|
- return result;
|
|
|
+ return restored;
|
|
|
}
|
gornekich