Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-05-13 08:08:35 -07:00
Code Issues Packages Projects Releases Wiki Activity

Massive overhaul | Part 1

Browse Source
This commit is contained in:
VerstreuteSeele
2022-12-30 05:12:53 +01:00
parent 4a150d3252
commit d279639e53
51 changed files with 100 additions and 3024 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
applications/main/nfc/scenes/nfc_scene_config.h
View File

@@ -14,11 +14,6 @@ ADD_SCENE(nfc, file_select, FileSelect)
ADD_SCENE(nfc, emulate_uid, EmulateUid)
ADD_SCENE(nfc, nfca_read_success, NfcaReadSuccess)
ADD_SCENE(nfc, nfca_menu, NfcaMenu)
ADD_SCENE(nfc, nfcv_menu, NfcVMenu)
ADD_SCENE(nfc, nfcv_unlock_menu, NfcVUnlockMenu)
ADD_SCENE(nfc, nfcv_key_input, NfcVKeyInput)
ADD_SCENE(nfc, nfcv_unlock, NfcVUnlock)
ADD_SCENE(nfc, emulate_nfcv, EmulateNfcV)
ADD_SCENE(nfc, mf_ultralight_read_success, MfUltralightReadSuccess)
ADD_SCENE(nfc, mf_ultralight_data, MfUltralightData)
ADD_SCENE(nfc, mf_ultralight_menu, MfUltralightMenu)
@@ -50,14 +45,6 @@ ADD_SCENE(nfc, mf_classic_update_success, MfClassicUpdateSuccess)
ADD_SCENE(nfc, mf_classic_wrong_card, MfClassicWrongCard)
ADD_SCENE(nfc, emv_read_success, EmvReadSuccess)
ADD_SCENE(nfc, emv_menu, EmvMenu)
ADD_SCENE(nfc, passport_read, PassportReadSuccess)
ADD_SCENE(nfc, passport_read_auth, PassportReadAuthSuccess)
ADD_SCENE(nfc, passport_menu, PassportMenu)
ADD_SCENE(nfc, passport_auth, PassportAuth)
ADD_SCENE(nfc, passport_auth_save_name, PassportAuthSaveName)
ADD_SCENE(nfc, passport_date, PassportDate)
ADD_SCENE(nfc, passport_docnr, PassportDocNr)
ADD_SCENE(nfc, passport_pace_todo, PassportPaceTodo)
ADD_SCENE(nfc, emulate_apdu_sequence, EmulateApduSequence)
ADD_SCENE(nfc, device_info, DeviceInfo)
ADD_SCENE(nfc, delete, Delete)

149
applications/main/nfc/scenes/nfc_scene_emulate_nfcv.c
View File

@@ -1,149 +0,0 @@
#include "../nfc_i.h"
#define NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX (100)
enum {
NfcSceneEmulateNfcVStateWidget,
NfcSceneEmulateNfcVStateTextBox,
};
bool nfc_emulate_nfcv_worker_callback(NfcWorkerEvent event, void* context) {
UNUSED(event);
furi_assert(context);
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventWorkerExit);
return true;
}
void nfc_scene_emulate_nfcv_widget_callback(GuiButtonType result, InputType type, void* context) {
furi_assert(context);
Nfc* nfc = context;
if(type == InputTypeShort) {
view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
}
}
void nfc_emulate_nfcv_textbox_callback(void* context) {
furi_assert(context);
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
}
// Add widget with device name or inform that data received
static void nfc_scene_emulate_nfcv_widget_config(Nfc* nfc, bool data_received) {
FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
Widget* widget = nfc->widget;
widget_reset(widget);
FuriString* info_str;
info_str = furi_string_alloc();
widget_add_icon_element(widget, 0, 3, &I_RFIDDolphinSend_97x61);
widget_add_string_element(
widget, 89, 32, AlignCenter, AlignTop, FontPrimary, "Emulating NfcV");
if(strcmp(nfc->dev->dev_name, "")) {
furi_string_printf(info_str, "%s", nfc->dev->dev_name);
} else {
for(uint8_t i = 0; i < data->uid_len; i++) {
furi_string_cat_printf(info_str, "%02X ", data->uid[i]);
}
}
furi_string_trim(info_str);
widget_add_text_box_element(
widget, 56, 43, 70, 21, AlignCenter, AlignTop, furi_string_get_cstr(info_str), true);
furi_string_free(info_str);
if(data_received) {
widget_add_button_element(
widget, GuiButtonTypeCenter, "Log", nfc_scene_emulate_nfcv_widget_callback, nfc);
}
}
void nfc_scene_emulate_nfcv_on_enter(void* context) {
Nfc* nfc = context;
// Setup Widget
nfc_scene_emulate_nfcv_widget_config(nfc, false);
// Setup TextBox
TextBox* text_box = nfc->text_box;
text_box_set_font(text_box, TextBoxFontHex);
text_box_set_focus(text_box, TextBoxFocusEnd);
furi_string_reset(nfc->text_box_store);
// Set Widget state and view
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
// Start worker
memset(&nfc->dev->dev_data.reader_data, 0, sizeof(NfcReaderRequestData));
nfc_worker_start(
nfc->worker,
NfcWorkerStateNfcVEmulate,
&nfc->dev->dev_data,
nfc_emulate_nfcv_worker_callback,
nfc);
nfc_blink_emulate_start(nfc);
}
bool nfc_scene_emulate_nfcv_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneEmulateNfcV);
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventWorkerExit) {
// Add data button to widget if data is received for the first time
if(!furi_string_size(nfc->text_box_store)) {
nfc_scene_emulate_nfcv_widget_config(nfc, true);
}
if(strlen(nfcv_data->last_command) > 0) {
/* use the last n bytes from the log so there's enough space for the new log entry */
size_t maxSize =
NFC_SCENE_EMULATE_NFCV_LOG_SIZE_MAX - (strlen(nfcv_data->last_command) + 1);
if(furi_string_size(nfc->text_box_store) >= maxSize) {
furi_string_right(nfc->text_box_store, (strlen(nfcv_data->last_command) + 1));
}
furi_string_cat_printf(nfc->text_box_store, "%s", nfcv_data->last_command);
furi_string_push_back(nfc->text_box_store, '\n');
text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
/* clear previously logged command */
strcpy(nfcv_data->last_command, "");
}
consumed = true;
} else if(event.event == GuiButtonTypeCenter && state == NfcSceneEmulateNfcVStateWidget) {
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextBox);
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateTextBox);
consumed = true;
} else if(event.event == NfcCustomEventViewExit && state == NfcSceneEmulateNfcVStateTextBox) {
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
consumed = true;
}
} else if(event.type == SceneManagerEventTypeBack) {
if(state == NfcSceneEmulateNfcVStateTextBox) {
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneEmulateNfcV, NfcSceneEmulateNfcVStateWidget);
consumed = true;
}
}
return consumed;
}
void nfc_scene_emulate_nfcv_on_exit(void* context) {
Nfc* nfc = context;
// Stop worker
nfc_worker_stop(nfc->worker);
// Clear view
widget_reset(nfc->widget);
text_box_reset(nfc->text_box);
furi_string_reset(nfc->text_box_store);
nfc_blink_stop(nfc);
}

10
applications/main/nfc/scenes/nfc_scene_extra_actions.c
View File

@@ -4,7 +4,6 @@ enum SubmenuIndex {
SubmenuIndexReadCardType,
SubmenuIndexMfClassicKeys,
SubmenuIndexMfUltralightUnlock,
SubmenuIndexNfcVUnlock,
};
void nfc_scene_extra_actions_submenu_callback(void* context, uint32_t index) {
@@ -35,12 +34,6 @@ void nfc_scene_extra_actions_on_enter(void* context) {
SubmenuIndexMfUltralightUnlock,
nfc_scene_extra_actions_submenu_callback,
nfc);
submenu_add_item(
submenu,
"Unlock SLIX-L",
SubmenuIndexNfcVUnlock,
nfc_scene_extra_actions_submenu_callback,
nfc);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
}
@@ -63,9 +56,6 @@ bool nfc_scene_extra_actions_on_event(void* context, SceneManagerEvent event) {
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneReadCardType, 0);
scene_manager_next_scene(nfc->scene_manager, NfcSceneReadCardType);
consumed = true;
} else if(event.event == SubmenuIndexNfcVUnlock) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
consumed = true;
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneExtraActions, event.event);
}

6
applications/main/nfc/scenes/nfc_scene_mf_classic_dict_attack.c
View File

@@ -58,7 +58,7 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackSt
// If failed to load user dictionary - try the system dictionary
if(!dict) {
FURI_LOG_E(TAG, "User Dictionary Not Found");
FURI_LOG_E(TAG, "User dictionary not found");
state = DictAttackStateFlipperDictInProgress;
}
}
@@ -67,8 +67,8 @@ static void nfc_scene_mf_classic_dict_attack_prepare_view(Nfc* nfc, DictAttackSt
dict_attack_set_header(nfc->dict_attack, "MF Classic System Dictionary");
dict = mf_classic_dict_alloc(MfClassicDictTypeSystem);
if(!dict) {
FURI_LOG_E(TAG, "Flipper Dictionary Not Found");
// Pass through to let worker handle the failure
FURI_LOG_E(TAG, "Flipper dictionary not found");
// Pass through to let the worker handle the failure
}
}
// Free previous dictionary

4
applications/main/nfc/scenes/nfc_scene_mf_classic_keys.c
View File

@@ -28,9 +28,9 @@ void nfc_scene_mf_classic_keys_on_enter(void* context) {
widget_add_string_element(
nfc->widget, 0, 0, AlignLeft, AlignTop, FontPrimary, "MIFARE Classic Keys");
char temp_str[32];
snprintf(temp_str, sizeof(temp_str), "System Dict: %ld", flipper_dict_keys_total);
snprintf(temp_str, sizeof(temp_str), "System dict: %lu", flipper_dict_keys_total);
widget_add_string_element(nfc->widget, 0, 20, AlignLeft, AlignTop, FontSecondary, temp_str);
snprintf(temp_str, sizeof(temp_str), "User Dict: %ld", user_dict_keys_total);
snprintf(temp_str, sizeof(temp_str), "User dict: %lu", user_dict_keys_total);
widget_add_string_element(nfc->widget, 0, 32, AlignLeft, AlignTop, FontSecondary, temp_str);
widget_add_button_element(
nfc->widget, GuiButtonTypeCenter, "Add", nfc_scene_mf_classic_keys_widget_callback, nfc);

115
applications/main/nfc/scenes/nfc_scene_mf_ultralight_emulate.c
View File

@@ -1,103 +1,20 @@
#include "../nfc_i.h"
#include <lib/nfc/protocols/mifare_ultralight.h>
#define NFC_SCENE_MF_ULTRALIGHT_EMULATE_LOG_SIZE_MAX (200)
#define NFC_MF_UL_DATA_NOT_CHANGED (0UL)
#define NFC_MF_UL_DATA_CHANGED (1UL)
enum {
// View states
NfcSceneMfUltralightEmulateStateWidget,
NfcSceneMfUltralightEmulateStateTextBox,
NfcSceneMfUltralightEmulateStateMax = 0xFF,
// State flags
NfcSceneMfUltralightEmulateStateDataChanged = 1 << 8,
NfcSceneMfUltralightEmulateStateAuthAttempted = 1 << 9,
NfcSceneMfUltralightEmulateStateLogButtonShown = 1 << 10,
};
bool nfc_mf_ultralight_emulate_worker_callback(NfcWorkerEvent event, void* context) {
UNUSED(event);
Nfc* nfc = context;
uint32_t state =
scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate);
if(event == NfcWorkerEventSuccess)
state |= NfcSceneMfUltralightEmulateStateDataChanged;
else if(event == NfcWorkerEventMfUltralightPwdAuth) {
// Don't update if we're exiting
if(nfc_worker_get_state(nfc->worker) != NfcWorkerStateStop) {
// Event data is only available for the duration of this callback, so we're updating the
// text box right here
MfUltralightAuth* auth = nfc_worker_get_event_data(nfc->worker);
if(auth != NULL && furi_string_size(nfc->text_box_store) <
NFC_SCENE_MF_ULTRALIGHT_EMULATE_LOG_SIZE_MAX) {
furi_string_cat(nfc->text_box_store, "PWD:");
for(size_t i = 0; i < sizeof(auth->pwd.raw); ++i) {
furi_string_cat_printf(nfc->text_box_store, " %02X", auth->pwd.raw[i]);
}
furi_string_push_back(nfc->text_box_store, '\n');
text_box_set_text(nfc->text_box, furi_string_get_cstr(nfc->text_box_store));
}
state |= NfcSceneMfUltralightEmulateStateAuthAttempted;
}
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate, state);
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventWorkerExit);
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneMfUltralightEmulate, NFC_MF_UL_DATA_CHANGED);
return true;
}
void nfc_scene_mf_ultralight_emulate_widget_callback(
GuiButtonType result,
InputType type,
void* context) {
furi_assert(context);
Nfc* nfc = context;
if(type == InputTypeShort) {
view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
}
}
void nfc_scene_mf_ultralight_emulate_widget_config(Nfc* nfc, bool auth_attempted) {
Widget* widget = nfc->widget;
widget_reset(widget);
FuriString* info_str;
info_str = furi_string_alloc();
widget_add_icon_element(widget, 0, 3, &I_RFIDDolphinSend_97x61);
if(strcmp(nfc->dev->dev_name, "")) {
furi_string_printf(info_str, "Emulating\n%s", nfc->dev->dev_name);
} else {
furi_string_printf(info_str, "Emulating\nMf Ultralight");
}
widget_add_string_multiline_element(
widget, 56, 31, AlignLeft, AlignTop, FontPrimary, furi_string_get_cstr(info_str));
furi_string_free(info_str);
if(auth_attempted) {
widget_add_button_element(
widget,
GuiButtonTypeCenter,
"Log",
nfc_scene_mf_ultralight_emulate_widget_callback,
nfc);
}
}
void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
Nfc* nfc = context;
uint32_t state =
scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate);
// Setup Widget
nfc_scene_mf_ultralight_emulate_widget_config(nfc, false);
state &= ~NfcSceneMfUltralightEmulateStateLogButtonShown;
// Setup TextBox
TextBox* text_box = nfc->text_box;
text_box_set_font(text_box, TextBoxFontHex);
text_box_set_focus(text_box, TextBoxFocusEnd);
furi_string_reset(nfc->text_box_store);
// Setup view
MfUltralightType type = nfc->dev->dev_data.mf_ul_data.type;
bool is_ultralight = (type == MfUltralightTypeUL11) || (type == MfUltralightTypeUL21) ||
@@ -114,12 +31,8 @@ void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
popup_set_icon(popup, 0, 3, &I_NFC_dolphin_emulation_47x61);
popup_set_text(popup, nfc->text_store, 90, 28, AlignCenter, AlignTop);
// Set Widget state and view
state = (state & ~NfcSceneMfUltralightEmulateStateMax) |
NfcSceneMfUltralightEmulateStateWidget;
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate, state);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
// Start worker
// Setup and start worker
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
nfc_worker_start(
nfc->worker,
NfcWorkerStateMfUltralightEmulate,
@@ -131,8 +44,6 @@ void nfc_scene_mf_ultralight_emulate_on_enter(void* context) {
bool nfc_scene_mf_ultralight_emulate_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
uint32_t state =
scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate);
bool consumed = false;
if(event.type == SceneManagerEventTypeBack) {
@@ -148,28 +59,16 @@ bool nfc_scene_mf_ultralight_emulate_on_event(void* context, SceneManagerEvent e
nfc_device_save_shadow(nfc->dev, furi_string_get_cstr(nfc->dev->load_path));
}
}
consumed = false;
}
return consumed;
}
void nfc_scene_mf_ultralight_emulate_on_exit(void* context) {
Nfc* nfc = context;
uint32_t state =
scene_manager_get_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate);
// Stop worker
nfc_worker_stop(nfc->worker);
// Check if data changed and save in shadow file
if(state & NfcSceneMfUltralightEmulateStateDataChanged) {
state &= ~NfcSceneMfUltralightEmulateStateDataChanged;
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneMfUltralightEmulate, state);
nfc_device_save_shadow(nfc->dev, nfc->dev->dev_name);
}
// Clear view
widget_reset(nfc->widget);
text_box_reset(nfc->text_box);
furi_string_reset(nfc->text_box_store);
popup_reset(nfc->popup);
nfc_blink_stop(nfc);
}

2
applications/main/nfc/scenes/nfc_scene_mf_ultralight_key_input.c
View File

@@ -11,7 +11,7 @@ void nfc_scene_mf_ultralight_key_input_on_enter(void* context) {
// Setup view
ByteInput* byte_input = nfc->byte_input;
byte_input_set_header_text(byte_input, "Enter The Password In Hex");
byte_input_set_header_text(byte_input, "Enter the password in hex");
byte_input_set_result_callback(
byte_input,
nfc_scene_mf_ultralight_key_input_byte_input_callback,

18
applications/main/nfc/scenes/nfc_scene_mf_ultralight_menu.c
View File

@@ -2,8 +2,7 @@
#include <dolphin/dolphin.h>
enum SubmenuIndex {
SubmenuIndexUnlockByReader,
SubmenuIndexUnlockByPassword,
SubmenuIndexUnlock,
SubmenuIndexSave,
SubmenuIndexEmulate,
SubmenuIndexInfo,
@@ -23,14 +22,8 @@ void nfc_scene_mf_ultralight_menu_on_enter(void* context) {
if(!mf_ul_is_full_capture(data)) {
submenu_add_item(
submenu,
"Unlock With Reader",
SubmenuIndexUnlockByReader,
nfc_scene_mf_ultralight_menu_submenu_callback,
nfc);
submenu_add_item(
submenu,
"Unlock With Password",
SubmenuIndexUnlockByPassword,
"Unlock",
SubmenuIndexUnlock,
nfc_scene_mf_ultralight_menu_submenu_callback,
nfc);
}
@@ -70,10 +63,7 @@ bool nfc_scene_mf_ultralight_menu_on_event(void* context, SceneManagerEvent even
DOLPHIN_DEED(DolphinDeedNfcEmulate);
}
consumed = true;
} else if(event.event == SubmenuIndexUnlockByReader) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockAuto);
consumed = true;
} else if(event.event == SubmenuIndexUnlockByPassword) {
} else if(event.event == SubmenuIndexUnlock) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightUnlockMenu);
consumed = true;
} else if(event.event == SubmenuIndexInfo) {

9
applications/main/nfc/scenes/nfc_scene_mf_ultralight_read_auth.c
View File

@@ -24,22 +24,21 @@ void nfc_scene_mf_ultralight_read_auth_set_state(Nfc* nfc, NfcSceneMfUlReadState
if(curr_state != state) {
if(state == NfcSceneMfUlReadStateDetecting) {
popup_reset(nfc->popup);
popup_set_text(
nfc->popup, "Apply Card To\nFlipper's Back", 97, 24, AlignCenter, AlignTop);
popup_set_text(nfc->popup, "Apply the\ntarget card", 97, 24, AlignCenter, AlignTop);
popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
nfc_blink_read_start(nfc);
} else if(state == NfcSceneMfUlReadStateReading) {
popup_reset(nfc->popup);
popup_set_header(
nfc->popup, "Reading Card\nDon't Move...", 85, 24, AlignCenter, AlignTop);
nfc->popup, "Reading card\nDon't move...", 85, 24, AlignCenter, AlignTop);
popup_set_icon(nfc->popup, 12, 23, &A_Loading_24);
nfc_blink_detect_start(nfc);
} else if(state == NfcSceneMfUlReadStateNotSupportedCard) {
popup_reset(nfc->popup);
popup_set_header(nfc->popup, "Wrong Type Of Card!", 64, 3, AlignCenter, AlignTop);
popup_set_header(nfc->popup, "Wrong type of card!", 64, 3, AlignCenter, AlignTop);
popup_set_text(
nfc->popup,
"Only MIFARE\nUltralight & NTAG\n Are Supported",
"Only MIFARE\nUltralight & NTAG\nare supported",
4,
22,
AlignLeft,

3
applications/main/nfc/scenes/nfc_scene_mf_ultralight_unlock_auto.c
View File

@@ -31,7 +31,7 @@ void nfc_scene_mf_ultralight_unlock_auto_on_enter(void* context) {
nfc_scene_mf_ultralight_unlock_auto_worker_callback,
nfc);
nfc_blink_emulate_start(nfc);
nfc_blink_read_start(nfc);
}
bool nfc_scene_mf_ultralight_unlock_auto_on_event(void* context, SceneManagerEvent event) {
@@ -58,7 +58,6 @@ void nfc_scene_mf_ultralight_unlock_auto_on_exit(void* context) {
// Stop worker
nfc_worker_stop(nfc->worker);
// Clear view
popup_reset(nfc->popup);
widget_reset(nfc->widget);
nfc_blink_stop(nfc);

170
applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
View File

@@ -7,17 +7,6 @@ void nfc_scene_nfc_data_info_widget_callback(GuiButtonType result, InputType typ
}
}
uint32_t nfc_scene_nfc_data_info_get_key(uint8_t* data) {
uint32_t value = 0;
for(uint32_t pos = 0; pos < 4; pos++) {
value <<= 8;
value |= data[pos];
}
return value;
}
void nfc_scene_nfc_data_info_on_enter(void* context) {
Nfc* nfc = context;
Widget* widget = nfc->widget;
@@ -25,8 +14,7 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
NfcDeviceData* dev_data = &nfc->dev->dev_data;
NfcProtocol protocol = dev_data->protocol;
uint8_t text_scroll_height = 0;
if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl) ||
(protocol == NfcDeviceProtocolNfcV)) {
if((protocol == NfcDeviceProtocolMifareDesfire) || (protocol == NfcDeviceProtocolMifareUl)) {
widget_add_button_element(
widget, GuiButtonTypeRight, "More", nfc_scene_nfc_data_info_widget_callback, nfc);
text_scroll_height = 52;
@@ -44,8 +32,6 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
// Set tag type
if(protocol == NfcDeviceProtocolEMV) {
furi_string_cat_printf(temp_str, "\e#EMV Bank Card\n");
} else if(protocol == NfcDeviceProtocolMRTD) {
furi_string_cat_printf(temp_str, "\e#Passport/ID\n");
} else if(protocol == NfcDeviceProtocolMifareUl) {
furi_string_cat_printf(
temp_str, "\e#%s\n", nfc_mf_ul_type(dev_data->mf_ul_data.type, true));
@@ -54,156 +40,19 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
temp_str, "\e#%s\n", nfc_mf_classic_type(dev_data->mf_classic_data.type));
} else if(protocol == NfcDeviceProtocolMifareDesfire) {
furi_string_cat_printf(temp_str, "\e#MIFARE DESfire\n");
} else if(protocol == NfcDeviceProtocolNfcV) {
switch(dev_data->nfcv_data.sub_type) {
case NfcVTypePlain:
furi_string_cat_printf(temp_str, "\e#ISO15693\n");
break;
case NfcVTypeSlix:
furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX\n");
break;
case NfcVTypeSlixS:
furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-S\n");
break;
case NfcVTypeSlixL:
furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX-L\n");
break;
case NfcVTypeSlix2:
furi_string_cat_printf(temp_str, "\e#ISO15693 SLIX2\n");
break;
default:
furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
break;
}
} else {
furi_string_cat_printf(temp_str, "\e#Unknown ISO tag\n");
}
// Set tag iso data
if(protocol == NfcDeviceProtocolNfcV) {
NfcVData* nfcv_data = &nfc->dev->dev_data.nfcv_data;
furi_string_cat_printf(temp_str, "UID:\n");
for(size_t i = 0; i < nfc_data->uid_len; i++) {
furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
}
furi_string_cat_printf(temp_str, "\n");
furi_string_cat_printf(temp_str, "DSFID: %02X\n", nfcv_data->dsfid);
furi_string_cat_printf(temp_str, "AFI: %02X\n", nfcv_data->afi);
furi_string_cat_printf(temp_str, "IC Ref: %02X\n", nfcv_data->ic_ref);
furi_string_cat_printf(temp_str, "Blocks: %02X\n", nfcv_data->block_num);
furi_string_cat_printf(temp_str, "Blocksize: %02X\n", nfcv_data->block_size);
furi_string_cat_printf(
temp_str, "Data (%d byte)\n", nfcv_data->block_num * nfcv_data->block_size);
int maxBlocks = nfcv_data->block_num;
if(maxBlocks > 32) {
maxBlocks = 32;
furi_string_cat_printf(temp_str, "(truncated to %d blocks)\n", maxBlocks);
}
for(int block = 0; block < maxBlocks; block++) {
for(int pos = 0; pos < nfcv_data->block_size; pos++) {
furi_string_cat_printf(
temp_str, " %02X", nfcv_data->data[block * nfcv_data->block_size + pos]);
}
furi_string_cat_printf(temp_str, "\n");
}
furi_string_cat_printf(temp_str, "\n");
switch(dev_data->nfcv_data.sub_type) {
case NfcVTypePlain:
furi_string_cat_printf(temp_str, "Type: Plain\n");
break;
case NfcVTypeSlix:
furi_string_cat_printf(temp_str, "Type: SLIX\n");
furi_string_cat_printf(temp_str, "Keys:\n");
furi_string_cat_printf(
temp_str,
" EAS %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
break;
case NfcVTypeSlixS:
furi_string_cat_printf(temp_str, "Type: SLIX-S\n");
furi_string_cat_printf(temp_str, "Keys:\n");
furi_string_cat_printf(
temp_str,
" Read %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_read));
furi_string_cat_printf(
temp_str,
" Write %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_write));
furi_string_cat_printf(
temp_str,
" Privacy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
furi_string_cat_printf(
temp_str,
" Destroy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
furi_string_cat_printf(
temp_str,
" EAS %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
break;
case NfcVTypeSlixL:
furi_string_cat_printf(temp_str, "Type: SLIX-L\n");
furi_string_cat_printf(temp_str, "Keys:\n");
furi_string_cat_printf(
temp_str,
" Privacy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
furi_string_cat_printf(
temp_str,
" Destroy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
furi_string_cat_printf(
temp_str,
" EAS %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
break;
case NfcVTypeSlix2:
furi_string_cat_printf(temp_str, "Type: SLIX2\n");
furi_string_cat_printf(temp_str, "Keys:\n");
furi_string_cat_printf(
temp_str,
" Read %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_read));
furi_string_cat_printf(
temp_str,
" Write %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_write));
furi_string_cat_printf(
temp_str,
" Privacy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_privacy));
furi_string_cat_printf(
temp_str,
" Destroy %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_destroy));
furi_string_cat_printf(
temp_str,
" EAS %08lX\n",
nfc_scene_nfc_data_info_get_key(nfcv_data->sub_data.slix.key_eas));
break;
default:
furi_string_cat_printf(temp_str, "\e#ISO15693 (unknown)\n");
break;
}
} else {
char iso_type = FURI_BIT(nfc_data->sak, 5) ? '4' : '3';
furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
furi_string_cat_printf(temp_str, "UID:");
for(size_t i = 0; i < nfc_data->uid_len; i++) {
furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
}
furi_string_cat_printf(
temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
char iso_type = FURI_BIT(nfc_data->sak, 5) ? '4' : '3';
furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-A)\n", iso_type);
furi_string_cat_printf(temp_str, "UID:");
for(size_t i = 0; i < nfc_data->uid_len; i++) {
furi_string_cat_printf(temp_str, " %02X", nfc_data->uid[i]);
}
furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", nfc_data->atqa[1], nfc_data->atqa[0]);
furi_string_cat_printf(temp_str, " SAK: %02X", nfc_data->sak);
// Set application specific data
if(protocol == NfcDeviceProtocolMifareDesfire) {
@@ -287,9 +136,6 @@ bool nfc_scene_nfc_data_info_on_event(void* context, SceneManagerEvent event) {
} else if(protocol == NfcDeviceProtocolMifareUl) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightData);
consumed = true;
} else if(protocol == NfcDeviceProtocolNfcV) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVMenu);
consumed = true;
}
}
}

48
applications/main/nfc/scenes/nfc_scene_nfcv_key_input.c
View File

@@ -1,48 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
void nfc_scene_nfcv_key_input_byte_input_callback(void* context) {
Nfc* nfc = context;
NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
memcpy(data->key_privacy, nfc->byte_input_store, 4);
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventByteInputDone);
}
void nfc_scene_nfcv_key_input_on_enter(void* context) {
Nfc* nfc = context;
// Setup view
ByteInput* byte_input = nfc->byte_input;
byte_input_set_header_text(byte_input, "Enter The Password In Hex");
byte_input_set_result_callback(
byte_input,
nfc_scene_nfcv_key_input_byte_input_callback,
NULL,
nfc,
nfc->byte_input_store,
4);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewByteInput);
}
bool nfc_scene_nfcv_key_input_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventByteInputDone) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlock);
DOLPHIN_DEED(DolphinDeedNfcRead);
consumed = true;
}
}
return consumed;
}
void nfc_scene_nfcv_key_input_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
byte_input_set_result_callback(nfc->byte_input, NULL, NULL, NULL, NULL, 0);
byte_input_set_header_text(nfc->byte_input, "");
}

63
applications/main/nfc/scenes/nfc_scene_nfcv_menu.c
View File

@@ -1,63 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
enum SubmenuIndex {
SubmenuIndexSave,
SubmenuIndexEmulate,
};
void nfc_scene_nfcv_menu_submenu_callback(void* context, uint32_t index) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
}
void nfc_scene_nfcv_menu_on_enter(void* context) {
Nfc* nfc = context;
Submenu* submenu = nfc->submenu;
submenu_add_item(submenu, "Save", SubmenuIndexSave, nfc_scene_nfcv_menu_submenu_callback, nfc);
submenu_add_item(
submenu, "Emulate", SubmenuIndexEmulate, nfc_scene_nfcv_menu_submenu_callback, nfc);
submenu_set_selected_item(
nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVMenu));
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
}
bool nfc_scene_nfcv_menu_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubmenuIndexSave) {
nfc->dev->format = NfcDeviceSaveFormatNfcV;
// Clear device name
nfc_device_set_name(nfc->dev, "");
scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
consumed = true;
} else if(event.event == SubmenuIndexEmulate) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateNfcV);
if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSetType)) {
DOLPHIN_DEED(DolphinDeedNfcAddEmulate);
} else {
DOLPHIN_DEED(DolphinDeedNfcEmulate);
}
consumed = true;
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVMenu, event.event);
} else if(event.type == SceneManagerEventTypeBack) {
consumed = scene_manager_previous_scene(nfc->scene_manager);
}
return consumed;
}
void nfc_scene_nfcv_menu_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
submenu_reset(nfc->submenu);
}

155
applications/main/nfc/scenes/nfc_scene_nfcv_unlock.c
View File

@@ -1,155 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
typedef enum {
NfcSceneNfcVUnlockStateIdle,
NfcSceneNfcVUnlockStateDetecting,
NfcSceneNfcVUnlockStateUnlocked,
NfcSceneNfcVUnlockStateAlreadyUnlocked,
NfcSceneNfcVUnlockStateNotSupportedCard,
} NfcSceneNfcVUnlockState;
static bool nfc_scene_nfcv_unlock_worker_callback(NfcWorkerEvent event, void* context) {
Nfc* nfc = context;
NfcVSlixData* data = &nfc->dev->dev_data.nfcv_data.sub_data.slix;
if(event == NfcWorkerEventNfcVPassKey) {
memcpy(data->key_privacy, nfc->byte_input_store, 4);
} else {
view_dispatcher_send_custom_event(nfc->view_dispatcher, event);
}
return true;
}
void nfc_scene_nfcv_unlock_popup_callback(void* context) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
}
void nfc_scene_nfcv_unlock_set_state(Nfc* nfc, NfcSceneNfcVUnlockState state) {
FuriHalNfcDevData* nfc_data = &(nfc->dev->dev_data.nfc_data);
NfcVData* nfcv_data = &(nfc->dev->dev_data.nfcv_data);
uint32_t curr_state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock);
if(curr_state != state) {
Popup* popup = nfc->popup;
if(state == NfcSceneNfcVUnlockStateDetecting) {
popup_reset(popup);
popup_set_text(
popup, "Put figurine on\nFlipper's back", 97, 24, AlignCenter, AlignTop);
popup_set_icon(popup, 0, 8, &I_NFC_manual_60x50);
} else if(state == NfcSceneNfcVUnlockStateUnlocked) {
popup_reset(popup);
if(nfc_worker_get_state(nfc->worker) == NfcWorkerStateNfcVUnlockAndSave) {
nfc_text_store_set(
nfc,
"%s/SLIX_%02X%02X%02X%02X%02X%02X%02X%02X%s",
NFC_APP_FOLDER,
nfc_data->uid[0],
nfc_data->uid[1],
nfc_data->uid[2],
nfc_data->uid[3],
nfc_data->uid[4],
nfc_data->uid[5],
nfc_data->uid[6],
nfc_data->uid[7],
NFC_APP_EXTENSION);
nfc->dev->format = NfcDeviceSaveFormatNfcV;
if(nfc_device_save(nfc->dev, nfc->text_store)) {
popup_set_header(popup, "Successfully\nsaved", 94, 3, AlignCenter, AlignTop);
} else {
popup_set_header(
popup, "Unlocked but\nsave failed!", 94, 3, AlignCenter, AlignTop);
}
} else {
popup_set_header(popup, "Successfully\nunlocked", 94, 3, AlignCenter, AlignTop);
}
notification_message(nfc->notifications, &sequence_single_vibro);
//notification_message(nfc->notifications, &sequence_success);
popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
popup_set_context(popup, nfc);
popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
popup_set_timeout(popup, 1500);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
} else if(state == NfcSceneNfcVUnlockStateAlreadyUnlocked) {
popup_reset(popup);
popup_set_header(popup, "Already\nUnlocked!", 94, 3, AlignCenter, AlignTop);
popup_set_icon(popup, 0, 6, &I_RFIDDolphinSuccess_108x57);
popup_set_context(popup, nfc);
popup_set_callback(popup, nfc_scene_nfcv_unlock_popup_callback);
popup_set_timeout(popup, 1500);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
} else if(state == NfcSceneNfcVUnlockStateNotSupportedCard) {
popup_reset(popup);
popup_set_header(popup, "Wrong Type Of Card!", 64, 3, AlignCenter, AlignTop);
popup_set_text(popup, nfcv_data->error, 4, 22, AlignLeft, AlignTop);
popup_set_icon(popup, 73, 20, &I_DolphinCommon_56x48);
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlock, state);
}
}
void nfc_scene_nfcv_unlock_on_enter(void* context) {
Nfc* nfc = context;
nfc_device_clear(nfc->dev);
// Setup view
nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
// Start worker
nfc_worker_start(
nfc->worker,
NfcWorkerStateNfcVUnlockAndSave,
&nfc->dev->dev_data,
nfc_scene_nfcv_unlock_worker_callback,
nfc);
nfc_blink_read_start(nfc);
}
bool nfc_scene_nfcv_unlock_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcWorkerEventCardDetected) {
nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateUnlocked);
consumed = true;
} else if(event.event == NfcWorkerEventAborted) {
nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateAlreadyUnlocked);
consumed = true;
} else if(event.event == NfcWorkerEventNoCardDetected) {
nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateDetecting);
consumed = true;
} else if(event.event == NfcWorkerEventWrongCardDetected) {
nfc_scene_nfcv_unlock_set_state(nfc, NfcSceneNfcVUnlockStateNotSupportedCard);
}
} else if(event.type == SceneManagerEventTypeBack) {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcSceneNfcVUnlockMenu);
}
return consumed;
}
void nfc_scene_nfcv_unlock_on_exit(void* context) {
Nfc* nfc = context;
// Stop worker
nfc_worker_stop(nfc->worker);
// Clear view
popup_reset(nfc->popup);
nfc_blink_stop(nfc);
scene_manager_set_scene_state(
nfc->scene_manager, NfcSceneNfcVUnlock, NfcSceneNfcVUnlockStateIdle);
}

60
applications/main/nfc/scenes/nfc_scene_nfcv_unlock_menu.c
View File

@@ -1,60 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
enum SubmenuIndex {
SubmenuIndexNfcVUnlockMenuManual,
SubmenuIndexNfcVUnlockMenuTonieBox,
};
void nfc_scene_nfcv_unlock_menu_submenu_callback(void* context, uint32_t index) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
}
void nfc_scene_nfcv_unlock_menu_on_enter(void* context) {
Nfc* nfc = context;
Submenu* submenu = nfc->submenu;
uint32_t state = scene_manager_get_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu);
submenu_add_item(
submenu,
"Enter PWD Manually",
SubmenuIndexNfcVUnlockMenuManual,
nfc_scene_nfcv_unlock_menu_submenu_callback,
nfc);
submenu_add_item(
submenu,
"Auth As TonieBox",
SubmenuIndexNfcVUnlockMenuTonieBox,
nfc_scene_nfcv_unlock_menu_submenu_callback,
nfc);
submenu_set_selected_item(submenu, state);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
}
bool nfc_scene_nfcv_unlock_menu_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubmenuIndexNfcVUnlockMenuManual) {
nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodManual;
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVKeyInput);
consumed = true;
} else if(event.event == SubmenuIndexNfcVUnlockMenuTonieBox) {
nfc->dev->dev_data.nfcv_data.auth_method = NfcVAuthMethodTonieBox;
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcVUnlock);
DOLPHIN_DEED(DolphinDeedNfcRead);
consumed = true;
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneNfcVUnlockMenu, event.event);
}
return consumed;
}
void nfc_scene_nfcv_unlock_menu_on_exit(void* context) {
Nfc* nfc = context;
submenu_reset(nfc->submenu);
}

194
applications/main/nfc/scenes/nfc_scene_passport_auth.c
View File

@@ -1,194 +0,0 @@
#include "../nfc_i.h"
#define TAG "PassportAuth"
#define MRTD_AUTH_METHOD_COUNT 4
// Must match MrtdAuthMethod size (lib/nfc/protocols/mrtd_helpers.h)
typedef enum {
NfcScenePassportAuthSelectDob,
NfcScenePassportAuthSelectDoe,
NfcScenePassportAuthSelectDocNr,
NfcScenePassportAuthSelectMethod,
NfcScenePassportAuthSelectAuth,
NfcScenePassportAuthSelectSave,
NfcScenePassportAuthSelectLoad,
} NfcScenePassportAuthSelect;
void nfc_scene_passport_auth_var_list_enter_callback(void* context, uint32_t index) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
}
void nfc_scene_passport_auth_method_changed(VariableItem* item) {
Nfc* nfc = variable_item_get_context(item);
uint8_t index = variable_item_get_current_value_index(item);
nfc->dev->dev_data.mrtd_data.auth.method = index;
variable_item_set_current_value_text(item, mrtd_auth_method_string(index));
}
bool nfc_scene_passport_auth_load(Nfc* nfc) {
const DialogsFileBrowserOptions browser_options = {
.extension = MRTD_APP_EXTENSION,
.skip_assets = true,
.icon = &I_u2f_10px,
.hide_ext = true,
.item_loader_callback = NULL,
.item_loader_context = NULL,
};
FuriString* mrtd_app_folder;
mrtd_app_folder = furi_string_alloc_set(MRTD_APP_FOLDER);
FuriString* file_path;
file_path = furi_string_alloc();
bool res =
dialog_file_browser_show(nfc->dev->dialogs, file_path, mrtd_app_folder, &browser_options);
furi_string_free(mrtd_app_folder);
if(res) {
mrtd_auth_params_load(
nfc->dev->storage,
nfc->dev->dialogs,
&nfc->dev->dev_data.mrtd_data.auth,
furi_string_get_cstr(file_path),
true);
nfc_scene_passport_auth_on_enter(nfc);
variable_item_list_set_selected_item(
nfc->variable_item_list, NfcScenePassportAuthSelectAuth);
}
return res;
}
void nfc_scene_passport_auth_on_enter(void* context) {
Nfc* nfc = context;
MrtdData* mrtd_data = &nfc->dev->dev_data.mrtd_data;
// By entering the Auth menu, we default to Auth: Any
MrtdAuthMethod* auth_method = &mrtd_data->auth.method;
if(*auth_method == MrtdAuthMethodNone) {
*auth_method = MrtdAuthMethodAny;
}
VariableItemList* variable_item_list = nfc->variable_item_list;
variable_item_list_reset(variable_item_list);
VariableItem* item;
uint8_t value_index;
const size_t temp_str_size = 15;
char temp_str[temp_str_size];
snprintf(
temp_str,
temp_str_size,
"%02u%02u%02u",
mrtd_data->auth.birth_date.year,
mrtd_data->auth.birth_date.month,
mrtd_data->auth.birth_date.day);
item = variable_item_list_add(variable_item_list, "Birth Date", 1, NULL, NULL);
variable_item_set_current_value_text(item, temp_str);
snprintf(
temp_str,
temp_str_size,
"%02u%02u%02u",
mrtd_data->auth.expiry_date.year,
mrtd_data->auth.expiry_date.month,
mrtd_data->auth.expiry_date.day);
item = variable_item_list_add(variable_item_list, "Expiry Date", 1, NULL, NULL);
variable_item_set_current_value_text(item, temp_str);
item = variable_item_list_add(variable_item_list, "Document Nr.", 1, NULL, NULL);
strncpy(temp_str, mrtd_data->auth.doc_number, temp_str_size);
temp_str[temp_str_size] = '\x00';
if(strlen(temp_str) > 8) {
temp_str[8] = '.';
temp_str[9] = '.';
temp_str[10] = '.';
temp_str[11] = '\x00';
}
variable_item_set_current_value_text(item, temp_str);
item = variable_item_list_add(
variable_item_list,
"Method",
MRTD_AUTH_METHOD_COUNT,
nfc_scene_passport_auth_method_changed,
nfc);
value_index = *auth_method;
variable_item_set_current_value_index(item, value_index);
variable_item_set_current_value_text(item, mrtd_auth_method_string(value_index));
variable_item_list_add(variable_item_list, "Authenticate and read", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Save parameters", 1, NULL, NULL);
variable_item_list_add(variable_item_list, "Load parameters", 1, NULL, NULL);
variable_item_list_set_enter_callback(
variable_item_list, nfc_scene_passport_auth_var_list_enter_callback, nfc);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewVarItemList);
}
bool nfc_scene_passport_auth_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
FURI_LOG_D(TAG, "event.event: %ld", event.event);
switch(event.event) {
case NfcScenePassportAuthSelectLoad:
nfc_scene_passport_auth_load(nfc);
consumed = true;
break;
case NfcScenePassportAuthSelectDob:
scene_manager_set_scene_state(nfc->scene_manager, NfcScenePassportDate, 0);
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportDate);
consumed = true;
break;
case NfcScenePassportAuthSelectDoe:
scene_manager_set_scene_state(nfc->scene_manager, NfcScenePassportDate, 1);
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportDate);
consumed = true;
break;
case NfcScenePassportAuthSelectDocNr:
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportDocNr);
consumed = true;
break;
case NfcScenePassportAuthSelectMethod:
consumed = true;
break;
case NfcScenePassportAuthSelectAuth:
if(nfc->dev->dev_data.mrtd_data.auth.method == MrtdAuthMethodPace) {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportPaceTodo);
} else {
nfc_device_clear(nfc->dev);
scene_manager_next_scene(nfc->scene_manager, NfcSceneRead);
}
consumed = true;
break;
case NfcScenePassportAuthSelectSave:
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportAuthSaveName);
consumed = true;
break;
}
} else if(event.type == SceneManagerEventTypeBack) {
consumed = scene_manager_previous_scene(nfc->scene_manager);
}
return consumed;
}
void nfc_scene_passport_auth_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
variable_item_list_reset(nfc->variable_item_list);
}

82
applications/main/nfc/scenes/nfc_scene_passport_auth_save_name.c
View File

@@ -1,82 +0,0 @@
#include "../nfc_i.h"
#include <lib/toolbox/random_name.h>
#include <gui/modules/validators.h>
#include <toolbox/path.h>
void nfc_scene_passport_auth_save_name_text_input_callback(void* context) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventTextInputDone);
}
void nfc_scene_passport_auth_save_name_on_enter(void* context) {
Nfc* nfc = context;
MrtdData* mrtd_data = &nfc->dev->dev_data.mrtd_data;
// Setup view
TextInput* text_input = nfc->text_input;
bool docnr_empty = false;
if(!strcmp(mrtd_data->auth.doc_number, "")) {
set_random_name(nfc->text_store, sizeof(nfc->text_store));
docnr_empty = true;
} else {
nfc_text_store_set(nfc, mrtd_data->auth.doc_number);
}
text_input_set_header_text(text_input, "Name the parameters");
text_input_set_result_callback(
text_input,
nfc_scene_passport_auth_save_name_text_input_callback,
nfc,
nfc->text_store,
NFC_DEV_NAME_MAX_LEN,
docnr_empty);
FuriString* folder_path;
folder_path = furi_string_alloc();
if(furi_string_end_with(nfc->dev->load_path, NFC_APP_EXTENSION)) {
path_extract_dirname(furi_string_get_cstr(nfc->dev->load_path), folder_path);
} else {
furi_string_set(folder_path, NFC_APP_FOLDER);
}
ValidatorIsFile* validator_is_file =
validator_is_file_alloc_init(furi_string_get_cstr(folder_path), NFC_APP_EXTENSION, NULL);
text_input_set_validator(text_input, validator_is_file_callback, validator_is_file);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
furi_string_free(folder_path);
}
bool nfc_scene_passport_auth_save_name_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
MrtdData* mrtd_data = &nfc->dev->dev_data.mrtd_data;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventTextInputDone) {
if(mrtd_auth_params_save(
nfc->dev->storage, nfc->dev->dialogs, &mrtd_data->auth, nfc->text_store)) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveSuccess);
consumed = true;
} else {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcSceneStart);
}
}
}
return consumed;
}
void nfc_scene_passport_auth_save_name_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
void* validator_context = text_input_get_validator_callback_context(nfc->text_input);
text_input_set_validator(nfc->text_input, NULL, NULL);
validator_is_file_free(validator_context);
text_input_reset(nfc->text_input);
}

120
applications/main/nfc/scenes/nfc_scene_passport_date.c
View File

@@ -1,120 +0,0 @@
#include "../nfc_i.h"
#include "m-string.h"
#include <gui/modules/validators.h>
#define TAG "PassportDate"
#define DATE_LENGTH 6
//TODO: use types in .h file? also in nfc_scene_passport_bac.c
#define NFC_PASSPORT_DATE_BIRTH 0
#define NFC_PASSPORT_DATE_EXPIRY 1
void nfc_scene_passport_date_text_input_callback(void* context) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventTextInputDone);
}
void nfc_scene_passport_date_on_enter(void* context) {
Nfc* nfc = context;
MrtdDate date_value;
uint32_t date_type = scene_manager_get_scene_state(nfc->scene_manager, NfcScenePassportDate);
//TODO: numbers only
TextInput* text_input = nfc->text_input;
switch(date_type) {
case NFC_PASSPORT_DATE_BIRTH:
text_input_set_header_text(text_input, "Birth Date");
date_value = nfc->dev->dev_data.mrtd_data.auth.birth_date;
break;
case NFC_PASSPORT_DATE_EXPIRY:
text_input_set_header_text(text_input, "Expiry Date");
date_value = nfc->dev->dev_data.mrtd_data.auth.expiry_date;
break;
}
bool date_empty = false;
if(date_value.year == 0 || date_value.month == 0 || date_value.day == 0 ||
date_value.year > 100 || date_value.month > 13 || date_value.day > 31) {
nfc_text_store_set(nfc, "YYMMDD");
date_empty = true;
} else {
char temp_str[10];
snprintf(temp_str, 10, "%02u%02u%02u", date_value.year, date_value.month, date_value.day);
memcpy(nfc->text_store, temp_str, DATE_LENGTH);
nfc->text_store[DATE_LENGTH] = '\x00';
}
text_input_set_result_callback(
text_input,
nfc_scene_passport_date_text_input_callback,
nfc,
nfc->text_store,
DATE_LENGTH + 1, // incl. '\x00'
date_empty); // Use as template
//TODO: add validator for valid date (YYMMDD)
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
}
bool nfc_scene_passport_date_save(Nfc* nfc) {
int year;
int month;
int day;
int ret = sscanf(nfc->text_store, "%02d%02d%02d", &year, &month, &day);
if(ret != 3) {
FURI_LOG_E(TAG, "Invalid date entered (YYMMDD): %s", nfc->text_store);
return false;
}
MrtdDate date_value;
date_value.year = year;
date_value.month = month;
date_value.day = day;
uint32_t date_type = scene_manager_get_scene_state(nfc->scene_manager, NfcScenePassportDate);
//TODO: use types in .h file? also in nfc_scene_passport_bac.c
switch(date_type) {
case NFC_PASSPORT_DATE_BIRTH:
nfc->dev->dev_data.mrtd_data.auth.birth_date = date_value;
break;
case NFC_PASSPORT_DATE_EXPIRY:
nfc->dev->dev_data.mrtd_data.auth.expiry_date = date_value;
break;
}
return true;
}
bool nfc_scene_passport_date_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventTextInputDone) {
nfc_scene_passport_date_save(nfc);
//TODO: handle invalid date (returned false)
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcScenePassportAuth);
}
}
return consumed;
}
void nfc_scene_passport_date_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
// TODO: clear validator
text_input_reset(nfc->text_input);
}

67
applications/main/nfc/scenes/nfc_scene_passport_docnr.c
View File

@@ -1,67 +0,0 @@
#include "../nfc_i.h"
#include "m-string.h"
#include <gui/modules/validators.h>
#define TAG "PassportDocnr"
void nfc_scene_passport_docnr_text_input_callback(void* context) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventTextInputDone);
}
void nfc_scene_passport_docnr_on_enter(void* context) {
Nfc* nfc = context;
TextInput* text_input = nfc->text_input;
text_input_set_header_text(text_input, "Document Nr.");
char* docnr = nfc->dev->dev_data.mrtd_data.auth.doc_number;
bool docnr_empty = false;
if(*docnr) {
nfc_text_store_set(nfc, docnr);
docnr_empty = false;
} else {
nfc_text_store_set(nfc, "PA7HJ34M8");
docnr_empty = true;
}
text_input_set_result_callback(
text_input,
nfc_scene_passport_docnr_text_input_callback,
nfc,
nfc->text_store,
MRTD_DOCNR_MAX_LENGTH, // incl. '\x00'
docnr_empty); // Use as template
//TODO: add validator?
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewTextInput);
}
bool nfc_scene_passport_docnr_save(Nfc* nfc) {
strncpy(nfc->dev->dev_data.mrtd_data.auth.doc_number, nfc->text_store, MRTD_DOCNR_MAX_LENGTH);
return true;
}
bool nfc_scene_passport_docnr_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventTextInputDone) {
nfc_scene_passport_docnr_save(nfc);
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcScenePassportAuth);
}
}
return consumed;
}
void nfc_scene_passport_docnr_on_exit(void* context) {
Nfc* nfc = context;
text_input_reset(nfc->text_input);
}

57
applications/main/nfc/scenes/nfc_scene_passport_menu.c
View File

@@ -1,57 +0,0 @@
#include "../nfc_i.h"
enum SubmenuIndex {
SubmenuIndexSave,
SubmenuIndexInfo,
};
void nfc_scene_passport_menu_submenu_callback(void* context, uint32_t index) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, index);
}
void nfc_scene_passport_menu_on_enter(void* context) {
Nfc* nfc = context;
Submenu* submenu = nfc->submenu;
submenu_add_item(
submenu, "Save", SubmenuIndexSave, nfc_scene_passport_menu_submenu_callback, nfc);
submenu_add_item(
submenu, "Info", SubmenuIndexInfo, nfc_scene_passport_menu_submenu_callback, nfc);
submenu_set_selected_item(
nfc->submenu, scene_manager_get_scene_state(nfc->scene_manager, NfcScenePassportMenu));
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewMenu);
}
bool nfc_scene_passport_menu_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubmenuIndexSave) {
//TODO: save more than just UID
nfc->dev->format = NfcDeviceSaveFormatUid;
// Clear device name
nfc_device_set_name(nfc->dev, "");
scene_manager_next_scene(nfc->scene_manager, NfcSceneSaveName);
consumed = true;
} else if(event.event == SubmenuIndexInfo) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
consumed = true;
}
scene_manager_set_scene_state(nfc->scene_manager, NfcScenePassportMenu, event.event);
} else if(event.type == SceneManagerEventTypeBack) {
consumed = scene_manager_previous_scene(nfc->scene_manager);
}
return consumed;
}
void nfc_scene_passport_menu_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
submenu_reset(nfc->submenu);
}

40
applications/main/nfc/scenes/nfc_scene_passport_pace_todo.c
View File

@@ -1,40 +0,0 @@
#include "../nfc_i.h"
void nfc_scene_passport_pace_todo_popup_callback(void* context) {
Nfc* nfc = context;
view_dispatcher_send_custom_event(nfc->view_dispatcher, NfcCustomEventViewExit);
}
void nfc_scene_passport_pace_todo_on_enter(void* context) {
Nfc* nfc = context;
// Setup view
Popup* popup = nfc->popup;
popup_set_icon(popup, 64, 16, &I_DolphinCommon_56x48);
popup_set_header(popup, "PACE not yet implemented", 4, 4, AlignLeft, AlignTop);
popup_set_timeout(popup, 2000);
popup_set_context(popup, nfc);
popup_set_callback(popup, nfc_scene_passport_pace_todo_popup_callback);
popup_enable_timeout(popup);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewPopup);
}
bool nfc_scene_passport_pace_todo_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == NfcCustomEventViewExit) {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcScenePassportAuth);
}
}
return consumed;
}
void nfc_scene_passport_pace_todo_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
popup_reset(nfc->popup);
}

90
applications/main/nfc/scenes/nfc_scene_passport_read.c
View File

@@ -1,90 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
void nfc_scene_passport_read_widget_callback(GuiButtonType result, InputType type, void* context) {
Nfc* nfc = context;
if(type == InputTypeShort) {
view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
}
}
void nfc_scene_passport_read_on_enter(void* context) {
Nfc* nfc = context;
FuriHalNfcDevData* data = &nfc->dev->dev_data.nfc_data;
MrtdData* mrtd_data = &nfc->dev->dev_data.mrtd_data;
DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
Widget* widget = nfc->widget;
// Setup Custom Widget view
FuriString* temp_str;
temp_str = furi_string_alloc();
furi_string_set(temp_str, "\e#Passport\n");
char iso_type = FURI_BIT(data->sak, 5) ? '4' : '3';
char nfc_type;
switch(data->type) {
case FuriHalNfcTypeA:
nfc_type = 'A';
break;
case FuriHalNfcTypeB:
nfc_type = 'B';
break;
default:
nfc_type = '?';
break;
}
furi_string_cat_printf(temp_str, "ISO 14443-%c (NFC-%c)\n", iso_type, nfc_type);
furi_string_cat_printf(temp_str, "UID:");
for(size_t i = 0; i < data->uid_len; i++) {
furi_string_cat_printf(temp_str, " %02X", data->uid[i]);
}
furi_string_cat_printf(temp_str, "\nATQA: %02X %02X ", data->atqa[1], data->atqa[0]);
furi_string_cat_printf(temp_str, " SAK: %02X\n", data->sak);
if(mrtd_data->auth.method != MrtdAuthMethodNone && !mrtd_data->auth_success) {
furi_string_cat_printf(temp_str, "Auth failed. Wrong params?");
}
widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
furi_string_free(temp_str);
widget_add_button_element(
nfc->widget, GuiButtonTypeLeft, "Retry", nfc_scene_passport_read_widget_callback, nfc);
widget_add_button_element(
nfc->widget, GuiButtonTypeCenter, "Auth", nfc_scene_passport_read_widget_callback, nfc);
widget_add_button_element(
nfc->widget, GuiButtonTypeRight, "More", nfc_scene_passport_read_widget_callback, nfc);
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
}
bool nfc_scene_passport_read_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == GuiButtonTypeLeft) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
consumed = true;
} else if(event.event == GuiButtonTypeCenter) {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportAuth);
consumed = true;
} else if(event.event == GuiButtonTypeRight) {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportMenu);
consumed = true;
}
} else if(event.type == SceneManagerEventTypeBack) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
consumed = true;
}
return consumed;
}
void nfc_scene_passport_read_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
widget_reset(nfc->widget);
}

142
applications/main/nfc/scenes/nfc_scene_passport_read_auth.c
View File

@@ -1,142 +0,0 @@
#include "../nfc_i.h"
#include <dolphin/dolphin.h>
const char months[13][4] = {
"---",
"JAN",
"FEB",
"MAR",
"APR",
"MAY",
"JUN",
"JUL",
"AUG",
"SEP",
"OCT",
"NOV",
"DEC",
};
void nfc_scene_passport_read_auth_widget_callback(
GuiButtonType result,
InputType type,
void* context) {
Nfc* nfc = context;
if(type == InputTypeShort) {
view_dispatcher_send_custom_event(nfc->view_dispatcher, result);
}
}
void nfc_scene_passport_read_auth_on_enter(void* context) {
Nfc* nfc = context;
MrtdData* mrtd_data = &nfc->dev->dev_data.mrtd_data;
Widget* widget = nfc->widget;
// Setup Custom Widget view
FuriString* temp_str;
temp_str = furi_string_alloc();
furi_string_set(temp_str, "\e#Passport\n");
furi_string_cat_printf(
temp_str, "Auth.method: %s\n", mrtd_auth_method_string(mrtd_data->auth_method_used));
// TODO: indicate BAC / PACE used
uint16_t lds_version = mrtd_data->files.EF_COM.lds_version;
furi_string_cat_printf(temp_str, "LDS version: %d.%d\n", lds_version / 100, lds_version % 100);
uint32_t unicode_version = mrtd_data->files.EF_COM.unicode_version;
furi_string_cat_printf(
temp_str,
"Unicode version: %d.%d.%d\n",
(uint8_t)(unicode_version / 10000),
(uint8_t)(unicode_version / 100 % 100),
(uint8_t)(unicode_version % 100));
furi_string_cat_printf(temp_str, "Avail.files: ");
for(size_t i = 0; i < MAX_EFCOM_TAGS; ++i) {
uint8_t tag = mrtd_data->files.EF_COM.tag_list[i];
const EFFile* file = mrtd_tag_to_file(tag);
if(file->tag) {
if(i > 0) furi_string_cat_printf(temp_str, ", ");
furi_string_cat_printf(temp_str, "%s", file->name);
}
}
furi_string_cat_printf(temp_str, "\n");
EF_DIR_contents* EF_DIR = &mrtd_data->files.EF_DIR;
if(EF_DIR->applications_count > 0) {
furi_string_cat_printf(temp_str, "Apps:\n");
for(uint8_t i = 0; i < EF_DIR->applications_count; ++i) {
for(uint8_t n = 0; n < sizeof(AIDValue); ++n) {
furi_string_cat_printf(temp_str, "%02X ", EF_DIR->applications[i][n]);
}
furi_string_cat_printf(temp_str, "\n");
}
}
EF_DG1_contents* DG1 = &mrtd_data->files.DG1;
furi_string_cat_printf(temp_str, "\e#DG1\n");
furi_string_cat_printf(temp_str, "Doc Type: %s\n", DG1->doctype);
furi_string_cat_printf(temp_str, "Issuing State: %s\n", DG1->issuing_state);
furi_string_cat_printf(temp_str, "Name: %s\n", DG1->name);
furi_string_cat_printf(temp_str, "DocNr: %s\n", DG1->docnr);
furi_string_cat_printf(temp_str, "Nationality: %s\n", DG1->nationality);
furi_string_cat_printf(
temp_str,
"Birth Date: %02d %s %02d\n",
DG1->birth_date.day,
months[DG1->birth_date.month],
DG1->birth_date.year);
furi_string_cat_printf(temp_str, "Sex: %s\n", DG1->sex);
furi_string_cat_printf(
temp_str,
"Expiry Date: %02d %s %02d\n",
DG1->expiry_date.day,
months[DG1->expiry_date.month],
DG1->expiry_date.year);
widget_add_text_scroll_element(widget, 0, 0, 128, 52, furi_string_get_cstr(temp_str));
furi_string_free(temp_str);
widget_add_button_element(
nfc->widget, GuiButtonTypeLeft, "Retry", nfc_scene_passport_read_auth_widget_callback, nfc);
/*
widget_add_button_element(
nfc->widget, GuiButtonTypeCenter, "Auth", nfc_scene_passport_read_auth_widget_callback, nfc);
widget_add_button_element(
nfc->widget, GuiButtonTypeRight, "More", nfc_scene_passport_read_auth_widget_callback, nfc);
*/
view_dispatcher_switch_to_view(nfc->view_dispatcher, NfcViewWidget);
}
bool nfc_scene_passport_read_auth_on_event(void* context, SceneManagerEvent event) {
Nfc* nfc = context;
bool consumed = false;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == GuiButtonTypeLeft) {
nfc->dev->dev_data.mrtd_data.auth_success = false;
nfc->dev->dev_data.mrtd_data.auth.method = MrtdAuthMethodNone;
scene_manager_next_scene(nfc->scene_manager, NfcSceneRetryConfirm);
consumed = true;
} else if(event.event == GuiButtonTypeCenter) {
//scene_manager_next_scene(nfc->scene_manager, NfcScenePassportAuth);
//consumed = true;
} else if(event.event == GuiButtonTypeRight) {
//scene_manager_next_scene(nfc->scene_manager, NfcScenePassportMenu);
//consumed = true;
}
} else if(event.type == SceneManagerEventTypeBack) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneExitConfirm);
consumed = true;
}
return consumed;
}
void nfc_scene_passport_read_auth_on_exit(void* context) {
Nfc* nfc = context;
// Clear view
widget_reset(nfc->widget);
}

22
applications/main/nfc/scenes/nfc_scene_read.c
View File

@@ -25,12 +25,12 @@ void nfc_scene_read_set_state(Nfc* nfc, NfcSceneReadState state) {
if(state == NfcSceneReadStateDetecting) {
popup_reset(nfc->popup);
popup_set_text(
nfc->popup, "Apply Card To\nFlipper's Back", 97, 24, AlignCenter, AlignTop);
nfc->popup, "Apply card to\nFlipper's back", 97, 24, AlignCenter, AlignTop);
popup_set_icon(nfc->popup, 0, 8, &I_NFC_manual_60x50);
} else if(state == NfcSceneReadStateReading) {
popup_reset(nfc->popup);
popup_set_header(
nfc->popup, "Reading Card\nDon't Move...", 85, 24, AlignCenter, AlignTop);
nfc->popup, "Reading card\nDon't move...", 85, 24, AlignCenter, AlignTop);
popup_set_icon(nfc->popup, 12, 23, &A_Loading_24);
}
scene_manager_set_scene_state(nfc->scene_manager, NfcSceneRead, state);
@@ -68,11 +68,6 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcaReadSuccess);
DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
consumed = true;
} else if(event.event == NfcWorkerEventReadNfcV) {
notification_message(nfc->notifications, &sequence_success);
scene_manager_next_scene(nfc->scene_manager, NfcSceneNfcDataInfo);
DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
consumed = true;
} else if(event.event == NfcWorkerEventReadMfUltralight) {
notification_message(nfc->notifications, &sequence_success);
// Set unlock password input to 0xFFFFFFFF only on fresh read
@@ -95,19 +90,6 @@ bool nfc_scene_read_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneEmvReadSuccess);
DOLPHIN_DEED(DolphinDeedNfcReadSuccess);
consumed = true;
} else if(event.event == NfcWorkerEventReadPassport) {
notification_message(nfc->notifications, &sequence_success);
FURI_LOG_D(
"NFC",
"Read passport, auth: %d, success: %d",
nfc->dev->dev_data.mrtd_data.auth.method,
nfc->dev->dev_data.mrtd_data.auth_success);
if(nfc->dev->dev_data.mrtd_data.auth_success) {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportReadAuthSuccess);
} else {
scene_manager_next_scene(nfc->scene_manager, NfcScenePassportReadSuccess);
}
consumed = true;
} else if(event.event == NfcWorkerEventReadMfClassicDictAttackRequired) {
if(mf_classic_dict_check_presence(MfClassicDictTypeSystem)) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicDictAttack);

7
applications/main/nfc/scenes/nfc_scene_rpc.c
View File

@@ -55,13 +55,6 @@ bool nfc_scene_rpc_on_event(void* context, SceneManagerEvent event) {
&nfc->dev->dev_data,
nfc_scene_rpc_emulate_callback,
nfc);
} else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
nfc_worker_start(
nfc->worker,
NfcWorkerStateNfcVEmulate,
&nfc->dev->dev_data,
nfc_scene_rpc_emulate_callback,
nfc);
} else {
nfc_worker_start(
nfc->worker, NfcWorkerStateUidEmulate, &nfc->dev->dev_data, NULL, nfc);

2
applications/main/nfc/scenes/nfc_scene_save_name.c
View File

@@ -22,7 +22,7 @@ void nfc_scene_save_name_on_enter(void* context) {
} else {
nfc_text_store_set(nfc, nfc->dev->dev_name);
}
text_input_set_header_text(text_input, "Name The Card");
text_input_set_header_text(text_input, "Name the card");
text_input_set_result_callback(
text_input,
nfc_scene_save_name_text_input_callback,

6
applications/main/nfc/scenes/nfc_scene_save_success.c
View File

@@ -31,12 +31,6 @@ bool nfc_scene_save_success_on_event(void* context, SceneManagerEvent event) {
} else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneSavedMenu)) {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcSceneSavedMenu);
} else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcScenePassportAuth)) {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcScenePassportAuth);
} else if(scene_manager_has_previous_scene(nfc->scene_manager, NfcSceneNfcDataInfo)) {
consumed = scene_manager_search_and_switch_to_previous_scene(
nfc->scene_manager, NfcSceneNfcDataInfo);
} else {
consumed = scene_manager_search_and_switch_to_another_scene(
nfc->scene_manager, NfcSceneFileSelect);

2
applications/main/nfc/scenes/nfc_scene_saved_menu.c
View File

@@ -117,8 +117,6 @@ bool nfc_scene_saved_menu_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfUltralightEmulate);
} else if(nfc->dev->format == NfcDeviceSaveFormatMifareClassic) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneMfClassicEmulate);
} else if(nfc->dev->format == NfcDeviceSaveFormatNfcV) {
scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateNfcV);
} else {
scene_manager_next_scene(nfc->scene_manager, NfcSceneEmulateUid);
}