new apps and updates

ccid.c

@@ -18,7 +18,7 @@ uint8_t getSequence() {
     return sequence++;
 }
 
-size_t addLRC(uint8_t* data, size_t len) {
+size_t seader_ccid_add_lrc(uint8_t* data, size_t len) {
     uint8_t lrc = 0;
     for(size_t i = 0; i < len; i++) {
         lrc ^= data[i];
@@ -27,7 +27,7 @@ size_t addLRC(uint8_t* data, size_t len) {
     return len + 1;
 }
 
-void PC_to_RDR_IccPowerOn(SeaderUartBridge* seader_uart) {
+void seader_ccid_IccPowerOn(SeaderUartBridge* seader_uart) {
     if(powered) {
         return;
     }
@@ -42,18 +42,18 @@ void PC_to_RDR_IccPowerOn(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 6] = getSequence();
     seader_uart->tx_buf[2 + 7] = 2; //power
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-void check_for_sam(SeaderUartBridge* seader_uart) {
+void seader_ccid_check_for_sam(SeaderUartBridge* seader_uart) {
     hasSAM = false; // If someone is calling this, reset sam state
     powered = false;
-    PC_to_RDR_GetSlotStatus(seader_uart);
+    seader_ccid_GetSlotStatus(seader_uart);
 }
 
-void PC_to_RDR_GetSlotStatus(SeaderUartBridge* seader_uart) {
-    FURI_LOG_D(TAG, "PC_to_RDR_GetSlotStatus");
+void seader_ccid_GetSlotStatus(SeaderUartBridge* seader_uart) {
+    FURI_LOG_D(TAG, "seader_ccid_GetSlotStatus");
     memset(seader_uart->tx_buf, 0, SEADER_UART_RX_BUF_SIZE);
     seader_uart->tx_buf[0] = SYNC;
     seader_uart->tx_buf[1] = CTRL;
@@ -61,11 +61,11 @@ void PC_to_RDR_GetSlotStatus(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 5] = slot;
     seader_uart->tx_buf[2 + 6] = getSequence();
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-void PC_to_RDR_SetParameters(SeaderUartBridge* seader_uart) {
+void seader_ccid_SetParameters(SeaderUartBridge* seader_uart) {
     uint8_t T1 = 1;
     memset(seader_uart->tx_buf, 0, SEADER_UART_RX_BUF_SIZE);
     seader_uart->tx_buf[0] = SYNC;
@@ -78,12 +78,12 @@ void PC_to_RDR_SetParameters(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 8] = 0;
     seader_uart->tx_buf[2 + 9] = 0;
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-void PC_to_RDR_GetParameters(SeaderUartBridge* seader_uart) {
+void seader_ccid_GetParameters(SeaderUartBridge* seader_uart) {
     memset(seader_uart->tx_buf, 0, SEADER_UART_RX_BUF_SIZE);
     seader_uart->tx_buf[0] = SYNC;
     seader_uart->tx_buf[1] = CTRL;
@@ -95,12 +95,12 @@ void PC_to_RDR_GetParameters(SeaderUartBridge* seader_uart) {
     seader_uart->tx_buf[2 + 8] = 0;
     seader_uart->tx_buf[2 + 9] = 0;
 
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-void PC_to_RDR_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len) {
+void seader_ccid_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len) {
     memset(seader_uart->tx_buf, 0, SEADER_UART_RX_BUF_SIZE);
     seader_uart->tx_buf[0] = SYNC;
     seader_uart->tx_buf[1] = CTRL;
@@ -113,13 +113,13 @@ void PC_to_RDR_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len
     seader_uart->tx_buf[2 + 9] = 0;
 
     memcpy(seader_uart->tx_buf + 2 + 10, data, len);
-    seader_uart->tx_len = addLRC(seader_uart->tx_buf, 2 + 10 + len);
-    // FURI_LOG_I(TAG, "PC_to_RDR_XfrBlock %d bytes", seader_uart->tx_len);
+    seader_uart->tx_len = seader_ccid_add_lrc(seader_uart->tx_buf, 2 + 10 + len);
+    // FURI_LOG_I(TAG, "seader_ccid_XfrBlock %d bytes", seader_uart->tx_len);
 
     furi_thread_flags_set(furi_thread_get_id(seader_uart->tx_thread), WorkerEvtSamRx);
 }
 
-size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
+size_t seader_ccid_process(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     CCID_Message message;
     message.consumed = 0;
@@ -144,14 +144,14 @@ size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
                 retries = 0;
                 slot = 0;
                 sequence = 0;
-                PC_to_RDR_IccPowerOn(seader_uart);
+                seader_ccid_IccPowerOn(seader_uart);
                 break;
             case CARD_IN_2:
                 FURI_LOG_D(TAG, "Card Inserted (2)");
                 retries = 0;
                 slot = 1;
                 sequence = 0;
-                PC_to_RDR_IccPowerOn(seader_uart);
+                seader_ccid_IccPowerOn(seader_uart);
                 break;
             case CARD_IN_BOTH:
                 FURI_LOG_W(TAG, "Loading 2 cards not supported");
@@ -194,13 +194,13 @@ size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len) {
         if(message.bMessageType == CCID_MESSAGE_TYPE_RDR_to_PC_SlotStatus) {
             uint8_t status = (message.bStatus & BMICCSTATUS_MASK);
             if(status == 0 || status == 1) {
-                PC_to_RDR_IccPowerOn(seader_uart);
+                seader_ccid_IccPowerOn(seader_uart);
                 return message.consumed;
             } else if(status == 2) {
                 FURI_LOG_W(TAG, "No ICC is present [retries %d]", retries);
                 if(retries-- > 1 && hasSAM == false) {
                     furi_delay_ms(100);
-                    PC_to_RDR_GetSlotStatus(seader_uart);
+                    seader_ccid_GetSlotStatus(seader_uart);
                 } else {
                     if(seader_worker->callback) {
                         seader_worker->callback(

ccid.h

@@ -82,10 +82,10 @@ struct CCID_Message {
     size_t consumed;
 };
 
-void check_for_sam(SeaderUartBridge* seader_uart);
-void PC_to_RDR_IccPowerOn(SeaderUartBridge* seader_uart);
-void PC_to_RDR_GetSlotStatus(SeaderUartBridge* seader_uart);
-void PC_to_RDR_SetParameters(SeaderUartBridge* seader_uart);
-void PC_to_RDR_GetParameters(SeaderUartBridge* seader_uart);
-void PC_to_RDR_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len);
-size_t processCCID(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len);
+void seader_ccid_check_for_sam(SeaderUartBridge* seader_uart);
+void seader_ccid_IccPowerOn(SeaderUartBridge* seader_uart);
+void seader_ccid_GetSlotStatus(SeaderUartBridge* seader_uart);
+void seader_ccid_SetParameters(SeaderUartBridge* seader_uart);
+void seader_ccid_GetParameters(SeaderUartBridge* seader_uart);
+void seader_ccid_XfrBlock(SeaderUartBridge* seader_uart, uint8_t* data, size_t len);
+size_t seader_ccid_process(SeaderWorker* seader_worker, uint8_t* cmd, size_t cmd_len);

scenes/seader_scene_card_menu.c

@@ -5,6 +5,7 @@ enum SubmenuIndex {
     SubmenuIndexSavePicopass,
     SubmenuIndexSaveRFID,
     SubmenuIndexSaveSR,
+    SubmenuIndexSaveMFC,
 };
 
 void seader_scene_card_menu_submenu_callback(void* context, uint32_t index) {
@@ -42,6 +43,12 @@ void seader_scene_card_menu_on_enter(void* context) {
                 seader_scene_card_menu_submenu_callback,
                 seader);
         }
+        submenu_add_item(
+            submenu,
+            "Save MFC",
+            SubmenuIndexSaveMFC,
+            seader_scene_card_menu_submenu_callback,
+            seader);
     }
 
     submenu_set_selected_item(
@@ -79,6 +86,12 @@ bool seader_scene_card_menu_on_event(void* context, SceneManagerEvent event) {
             seader->credential->save_format = SeaderCredentialSaveFormatSR;
             scene_manager_next_scene(seader->scene_manager, SeaderSceneSaveName);
             consumed = true;
+        } else if(event.event == SubmenuIndexSaveMFC) {
+            scene_manager_set_scene_state(
+                seader->scene_manager, SeaderSceneCardMenu, SubmenuIndexSaveMFC);
+            seader->credential->save_format = SeaderCredentialSaveFormatMFC;
+            scene_manager_next_scene(seader->scene_manager, SeaderSceneSaveName);
+            consumed = true;
         }
     } else if(event.type == SceneManagerEventTypeBack) {
         consumed = scene_manager_search_and_switch_to_previous_scene(

seader_credential.c

@@ -103,6 +103,242 @@ static bool seader_credential_load(SeaderCredential* cred, FuriString* path, boo
     return parsed;
 }
 
+bool seader_credential_save_mfc(SeaderCredential* cred, const char* name) {
+    furi_assert(cred);
+
+    static const char* nfc_file_header = "Flipper NFC device";
+    static const uint32_t nfc_file_version = 3;
+    static const uint32_t nfc_mifare_classic_data_format_version = 2;
+
+    uint8_t uid[4] = {0xDF, 0xC6, 0x9C, 0x05};
+    uint8_t atqa[2] = {0x00, 0x04};
+    uint8_t sak = 0x08;
+    uint8_t manuf_block[16] = {
+        0xDF,
+        0xC6,
+        0x9C,
+        0x05,
+        0x80,
+        0x08,
+        0x04,
+        0x00,
+        0x00,
+        0x00,
+        0x73,
+        0x65,
+        0x61,
+        0x64,
+        0x65,
+        0x72};
+    uint8_t sector0_trailer[16] = {
+        0xa0,
+        0xa1,
+        0xa2,
+        0xa3,
+        0xa4,
+        0xa5,
+        0x78,
+        0x77,
+        0x88,
+        0xc1,
+        0x89,
+        0xec,
+        0xa9,
+        0x7f,
+        0x8c,
+        0x2a};
+    uint8_t sector1_trailer[16] = {
+        0x48,
+        0x49,
+        0x44,
+        0x20,
+        0x49,
+        0x53,
+        0x78,
+        0x77,
+        0x88,
+        0xaa,
+        0x20,
+        0x47,
+        0x52,
+        0x45,
+        0x41,
+        0x54};
+    uint8_t sectorn_trailer[16] = {
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0x07,
+        0x80,
+        0x69,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff,
+        0xff};
+    uint8_t mad_block[16] = {
+        0x1b,
+        0x01,
+        0x4d,
+        0x48,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00,
+        0x00};
+    uint8_t empty_block[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+    uint8_t pacs_block[16] = {0x02, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+    bool use_load_path = true;
+    bool saved = false;
+    FlipperFormat* file = flipper_format_file_alloc(cred->storage);
+    FuriString* temp_str;
+    temp_str = furi_string_alloc();
+
+    uint64_t sentinel = 1ULL << cred->bit_length;
+    uint64_t swapped = __builtin_bswap64(cred->credential | sentinel);
+    memcpy(pacs_block + 8, &swapped, sizeof(swapped));
+
+    do {
+        if(use_load_path && !furi_string_empty(cred->load_path)) {
+            // Get directory name
+            path_extract_dirname(furi_string_get_cstr(cred->load_path), temp_str);
+            // Make path to file to save
+            furi_string_cat_printf(temp_str, "/%s%s", name, SEADER_APP_MFC_EXTENSION);
+        } else {
+            furi_string_printf(
+                temp_str, "%s/%s%s", SEADER_APP_MFC_FOLDER, name, SEADER_APP_MFC_EXTENSION);
+        }
+
+        FURI_LOG_D(TAG, "Save as MFC [%s]", furi_string_get_cstr(temp_str));
+
+        // Open file
+        if(!flipper_format_file_open_always(file, furi_string_get_cstr(temp_str))) break;
+        if(!flipper_format_write_header_cstr(file, nfc_file_header, nfc_file_version)) break;
+        // Write nfc device type
+        if(!flipper_format_write_comment_cstr(
+               file, "Nfc device type can be UID, Mifare Ultralight, Mifare Classic or ISO15693"))
+            break;
+        furi_string_set(temp_str, "Mifare Classic");
+        if(!flipper_format_write_string(file, "Device type", temp_str)) break;
+        // Write UID
+        if(!flipper_format_write_comment_cstr(file, "UID is common for all formats")) break;
+        if(!flipper_format_write_hex(file, "UID", uid, 4)) break;
+        // Write ATQA, SAK
+        if(!flipper_format_write_comment_cstr(file, "ISO14443 specific fields")) break;
+        // Save ATQA in MSB order for correct companion apps display
+        if(!flipper_format_write_hex(file, "ATQA", atqa, 2)) break;
+        if(!flipper_format_write_hex(file, "SAK", &sak, 1)) break;
+        if(!flipper_format_write_comment_cstr(file, "Mifare Classic specific data")) break;
+        if(!flipper_format_write_comment_cstr(file, "Made with Seader")) break;
+        if(!flipper_format_write_string_cstr(file, "Mifare Classic type", "1K")) break;
+        uint8_t blocks = 64;
+
+        if(!flipper_format_write_uint32(
+               file, "Data format version", &nfc_mifare_classic_data_format_version, 1))
+            break;
+        if(!flipper_format_write_comment_cstr(
+               file, "Mifare Classic blocks, \'??\' means unknown data"))
+            break;
+        bool block_saved = true;
+        FuriString* block_str;
+        block_str = furi_string_alloc();
+        for(size_t i = 0; i < blocks; i++) {
+            furi_string_printf(temp_str, "Block %d", i);
+            switch(i) {
+            case 0:
+                if(!flipper_format_write_hex(
+                       file, furi_string_get_cstr(temp_str), manuf_block, sizeof(manuf_block))) {
+                    block_saved = false;
+                }
+                break;
+            case 1:
+                if(!flipper_format_write_hex(
+                       file, furi_string_get_cstr(temp_str), mad_block, sizeof(mad_block))) {
+                    block_saved = false;
+                }
+                break;
+            case 3:
+                if(!flipper_format_write_hex(
+                       file,
+                       furi_string_get_cstr(temp_str),
+                       sector0_trailer,
+                       sizeof(sector0_trailer))) {
+                    block_saved = false;
+                }
+                break;
+            case 5:
+                if(!flipper_format_write_hex(
+                       file, furi_string_get_cstr(temp_str), pacs_block, sizeof(pacs_block))) {
+                    block_saved = false;
+                }
+                break;
+            case 7:
+                if(!flipper_format_write_hex(
+                       file,
+                       furi_string_get_cstr(temp_str),
+                       sector1_trailer,
+                       sizeof(sector1_trailer))) {
+                    block_saved = false;
+                }
+                break;
+            // Trailers
+            case 11:
+            case 15:
+            case 19:
+            case 23:
+            case 27:
+            case 31:
+            case 35:
+            case 39:
+            case 43:
+            case 47:
+            case 51:
+            case 55:
+            case 59:
+            case 63:
+                if(!flipper_format_write_hex(
+                       file,
+                       furi_string_get_cstr(temp_str),
+                       sectorn_trailer,
+                       sizeof(sectorn_trailer))) {
+                    block_saved = false;
+                }
+                break;
+            default:
+                if(!flipper_format_write_hex(
+                       file, furi_string_get_cstr(temp_str), empty_block, sizeof(empty_block))) {
+                    block_saved = false;
+                }
+                break;
+            }
+        }
+        furi_string_free(block_str);
+        if(!block_saved) break;
+
+        saved = true;
+    } while(false);
+
+    if(!saved) {
+        dialog_message_show_storage_error(cred->dialogs, "Can not save\nfile");
+    }
+    furi_string_free(temp_str);
+    flipper_format_free(file);
+    return saved;
+}
+
 bool seader_credential_save_agnostic(SeaderCredential* cred, const char* name) {
     furi_assert(cred);
 
@@ -160,6 +396,8 @@ bool seader_credential_save(SeaderCredential* cred, const char* name) {
 
     if(cred->save_format == SeaderCredentialSaveFormatAgnostic) {
         return seader_credential_save_agnostic(cred, name);
+    } else if(cred->save_format == SeaderCredentialSaveFormatMFC) {
+        return seader_credential_save_mfc(cred, name);
     } else if(
         cred->save_format == SeaderCredentialSaveFormatPicopass ||
         cred->save_format == SeaderCredentialSaveFormatSR) {
@@ -195,9 +433,19 @@ bool seader_credential_save(SeaderCredential* cred, const char* name) {
                 furi_string_printf(temp_str, "Block %d", i);
                 switch(i) {
                 case CSN_INDEX:
-                    if(!flipper_format_write_hex(
-                           file, furi_string_get_cstr(temp_str), csn, sizeof(csn))) {
-                        block_saved = false;
+                    if(withSIO) {
+                        if(!flipper_format_write_hex(
+                               file,
+                               furi_string_get_cstr(temp_str),
+                               cred->diversifier,
+                               PICOPASS_BLOCK_LEN)) {
+                            block_saved = false;
+                        }
+                    } else {
+                        if(!flipper_format_write_hex(
+                               file, furi_string_get_cstr(temp_str), csn, sizeof(csn))) {
+                            block_saved = false;
+                        }
                     }
                     break;
                 case EPURSE_INDEX:

seader_credential.h

@@ -7,6 +7,8 @@
 
 #define SEADER_CRED_NAME_MAX_LEN 22
 #define SEADER_APP_EXTENSION ".credential"
+#define SEADER_APP_MFC_EXTENSION ".nfc"
+#define SEADER_APP_MFC_FOLDER ANY_PATH("nfc")
 
 typedef void (*SeaderLoadingCallback)(void* context, bool state);
 
@@ -23,6 +25,7 @@ typedef enum {
     SeaderCredentialSaveFormatPicopass,
     SeaderCredentialSaveFormatRFID,
     SeaderCredentialSaveFormatSR,
+    SeaderCredentialSaveFormatMFC,
 } SeaderCredentialSaveFormat;
 
 typedef struct {

seader_worker.c

@@ -21,7 +21,7 @@ char asn1_log[SEADER_UART_RX_BUF_SIZE] = {0};
 bool requestPacs = true;
 
 // Forward declaration
-void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails);
+void seader_send_card_detected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails);
 
 static void seader_worker_enable_field() {
     furi_hal_nfc_ll_txrx_on();
@@ -35,6 +35,32 @@ static ReturnCode seader_worker_disable_field(ReturnCode rc) {
     return rc;
 }
 
+static uint16_t seader_worker_picopass_update_ccitt(uint16_t crcSeed, uint8_t dataByte) {
+    uint16_t crc = crcSeed;
+    uint8_t dat = dataByte;
+
+    dat ^= (uint8_t)(crc & 0xFFU);
+    dat ^= (dat << 4);
+
+    crc = (crc >> 8) ^ (((uint16_t)dat) << 8) ^ (((uint16_t)dat) << 3) ^ (((uint16_t)dat) >> 4);
+
+    return crc;
+}
+
+static uint16_t seader_worker_picopass_calculate_ccitt(
+    uint16_t preloadValue,
+    const uint8_t* buf,
+    uint16_t length) {
+    uint16_t crc = preloadValue;
+    uint16_t index;
+
+    for(index = 0; index < length; index++) {
+        crc = seader_worker_picopass_update_ccitt(crc, buf[index]);
+    }
+
+    return crc;
+}
+
 /***************************** Seader Worker API *******************************/
 
 SeaderWorker* seader_worker_alloc() {
@@ -109,17 +135,17 @@ void* calloc(size_t count, size_t size) {
     return malloc(count * size);
 }
 
-void nfc_scene_field_on_enter() {
+void seader_nfc_scene_field_on_enter() {
     furi_hal_nfc_field_on();
     furi_hal_nfc_exit_sleep();
 }
 
-void nfc_scene_field_on_exit() {
+void seader_nfc_scene_field_on_exit() {
     furi_hal_nfc_sleep();
     furi_hal_nfc_field_off();
 }
 
-bool sendAPDU(
+bool seader_send_apdu(
     SeaderUartBridge* seader_uart,
     uint8_t CLA,
     uint8_t INS,
@@ -140,12 +166,12 @@ bool sendAPDU(
     apdu[4] = length;
     memcpy(apdu + APDU_HEADER_LEN, payload, length);
 
-    PC_to_RDR_XfrBlock(seader_uart, apdu, APDU_HEADER_LEN + length);
+    seader_ccid_XfrBlock(seader_uart, apdu, APDU_HEADER_LEN + length);
     free(apdu);
     return true;
 }
 
-static int toString(const void* buffer, size_t size, void* app_key) {
+static int seader_asn_to_string(const void* buffer, size_t size, void* app_key) {
     if(app_key) {
         char* str = (char*)app_key;
         size_t next = strlen(str);
@@ -157,11 +183,11 @@ static int toString(const void* buffer, size_t size, void* app_key) {
     return 0;
 }
 
-bool mf_df_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
+bool seader_mf_df_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
     return ATQA0 == 0x44 && ATQA1 == 0x03 && SAK == 0x20;
 }
 
-bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
+bool seader_mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
     if((ATQA0 == 0x44 || ATQA0 == 0x04) && (SAK == 0x08 || SAK == 0x88 || SAK == 0x09)) {
         return true;
     } else if((ATQA0 == 0x01) && (ATQA1 == 0x0F) && (SAK == 0x01)) {
@@ -174,7 +200,7 @@ bool mf_classic_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
     }
 }
 
-bool read_nfc(SeaderUartBridge* seader_uart) {
+bool seader_read_nfc(SeaderUartBridge* seader_uart) {
     FuriHalNfcDevData nfc_data = {};
     bool rtn = false;
     if(furi_hal_nfc_detect(&nfc_data, 300)) {
@@ -195,24 +221,24 @@ bool read_nfc(SeaderUartBridge* seader_uart) {
 
             uint8_t fake_seos_ats[] = {0x78, 0x77, 0x80, 0x02};
             uint8_t fake_desfire_ats[] = {0x75, 0x77, 0x81, 0x02, 0x80};
-            if(mf_df_check_card_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
+            if(seader_mf_df_check_card_type(nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
                 FURI_LOG_D(TAG, "Desfire");
                 OCTET_STRING_t atqa = {.buf = fake_desfire_ats, .size = sizeof(fake_desfire_ats)};
                 cardDetails->atqa = &atqa;
-                sendCardDetected(seader_uart, cardDetails);
+                seader_send_card_detected(seader_uart, cardDetails);
                 rtn = true;
-            } else if(mf_classic_check_card_type(
+            } else if(seader_mf_classic_check_card_type(
                           nfc_data.atqa[0], nfc_data.atqa[1], nfc_data.sak)) {
                 FURI_LOG_D(TAG, "MFC");
                 OCTET_STRING_t atqa = {.buf = nfc_data.atqa, .size = sizeof(nfc_data.atqa)};
                 cardDetails->atqa = &atqa;
-                sendCardDetected(seader_uart, cardDetails);
+                seader_send_card_detected(seader_uart, cardDetails);
                 rtn = true;
             } else if(nfc_data.interface == FuriHalNfcInterfaceIsoDep) {
                 FURI_LOG_D(TAG, "ISO-DEP");
                 OCTET_STRING_t atqa = {.buf = fake_seos_ats, .size = sizeof(fake_seos_ats)};
                 cardDetails->atqa = &atqa;
-                sendCardDetected(seader_uart, cardDetails);
+                seader_send_card_detected(seader_uart, cardDetails);
                 rtn = true;
             }
             ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
@@ -221,12 +247,12 @@ bool read_nfc(SeaderUartBridge* seader_uart) {
     return rtn;
 }
 
-bool detect_nfc(SeaderWorker* seader_worker) {
+bool seader_detect_nfc(SeaderWorker* seader_worker) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
 
     while(seader_worker->state == SeaderWorkerStateRead14a) {
         // Card found
-        if(read_nfc(seader_uart)) {
+        if(seader_read_nfc(seader_uart)) {
             return true;
         }
 
@@ -235,7 +261,7 @@ bool detect_nfc(SeaderWorker* seader_worker) {
     return false;
 }
 
-void sendPayload(
+void seader_send_payload(
     SeaderUartBridge* seader_uart,
     Payload_t* payload,
     uint8_t to,
@@ -249,7 +275,8 @@ void sendPayload(
 #ifdef ASN1_DEBUG
     if(er.encoded > -1) {
         memset(payloadDebug, 0, sizeof(payloadDebug));
-        (&asn_DEF_Payload)->op->print_struct(&asn_DEF_Payload, payload, 1, toString, payloadDebug);
+        (&asn_DEF_Payload)
+            ->op->print_struct(&asn_DEF_Payload, payload, 1, seader_asn_to_string, payloadDebug);
         if(strlen(payloadDebug) > 0) {
             FURI_LOG_D(TAG, "Sending payload: %s", payloadDebug);
         }
@@ -261,10 +288,10 @@ void sendPayload(
     rBuffer[1] = from;
     rBuffer[2] = replyTo;
 
-    sendAPDU(seader_uart, 0xA0, 0xDA, 0x02, 0x63, rBuffer, 6 + er.encoded);
+    seader_send_apdu(seader_uart, 0xA0, 0xDA, 0x02, 0x63, rBuffer, 6 + er.encoded);
 }
 
-void sendResponse(
+void seader_send_response(
     SeaderUartBridge* seader_uart,
     Response_t* response,
     uint8_t to,
@@ -277,7 +304,7 @@ void sendResponse(
     payload->present = Payload_PR_response;
     payload->choice.response = *response;
 
-    sendPayload(seader_uart, payload, to, from, replyTo);
+    seader_send_payload(seader_uart, payload, to, from, replyTo);
 
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
@@ -303,7 +330,7 @@ void sendRequestPacs(SeaderUartBridge* seader_uart) {
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_RequestPacs, requestPacs);
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
@@ -325,13 +352,13 @@ void seader_worker_send_version(SeaderWorker* seader_worker) {
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
 
-void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails) {
+void seader_send_card_detected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails) {
     CardDetected_t* cardDetected = 0;
     cardDetected = calloc(1, sizeof *cardDetected);
     assert(cardDetected);
@@ -352,14 +379,14 @@ void sendCardDetected(SeaderUartBridge* seader_uart, CardDetails_t* cardDetails)
     payload->present = Payload_PR_samCommand;
     payload->choice.samCommand = *samCommand;
 
-    sendPayload(seader_uart, payload, 0x44, 0x0a, 0x44);
+    seader_send_payload(seader_uart, payload, 0x44, 0x0a, 0x44);
 
     ASN_STRUCT_FREE(asn_DEF_CardDetected, cardDetected);
     ASN_STRUCT_FREE(asn_DEF_SamCommand, samCommand);
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
 }
 
-bool unpack_pacs(
+bool seader_unpack_pacs(
     SeaderWorker* seader_worker,
     SeaderCredential* seader_credential,
     uint8_t* buf,
@@ -373,7 +400,7 @@ bool unpack_pacs(
 
     if(rval.code == RC_OK) {
         char pacDebug[384] = {0};
-        (&asn_DEF_PAC)->op->print_struct(&asn_DEF_PAC, pac, 1, toString, pacDebug);
+        (&asn_DEF_PAC)->op->print_struct(&asn_DEF_PAC, pac, 1, seader_asn_to_string, pacDebug);
         if(strlen(pacDebug) > 0) {
             FURI_LOG_D(TAG, "Received pac: %s", pacDebug);
 
@@ -409,7 +436,7 @@ bool unpack_pacs(
 
 //    800201298106683d052026b6820101
 //300F800201298106683D052026B6820101
-bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
+bool seader_parse_version(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     SamVersion_t* version = 0;
     version = calloc(1, sizeof *version);
     assert(version);
@@ -431,7 +458,8 @@ bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     if(rval.code == RC_OK) {
         char versionDebug[128] = {0};
         (&asn_DEF_SamVersion)
-            ->op->print_struct(&asn_DEF_SamVersion, version, 1, toString, versionDebug);
+            ->op->print_struct(
+                &asn_DEF_SamVersion, version, 1, seader_asn_to_string, versionDebug);
         if(strlen(versionDebug) > 0) {
             FURI_LOG_D(TAG, "Received version: %s", versionDebug);
         }
@@ -446,7 +474,7 @@ bool parseVersion(SeaderWorker* seader_worker, uint8_t* buf, size_t size) {
     return rtn;
 }
 
-bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
+bool seader_parse_sam_response(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     SeaderCredential* credential = seader_worker->credential;
 
@@ -461,9 +489,9 @@ bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
                 seader_worker->callback(SeaderWorkerEventFail, seader_worker->context);
             }
         }
-    } else if(parseVersion(seader_worker, samResponse->buf, samResponse->size)) {
+    } else if(seader_parse_version(seader_worker, samResponse->buf, samResponse->size)) {
         // no-op
-    } else if(unpack_pacs(seader_worker, credential, samResponse->buf, samResponse->size)) {
+    } else if(seader_unpack_pacs(seader_worker, credential, samResponse->buf, samResponse->size)) {
         if(seader_worker->callback) {
             seader_worker->callback(SeaderWorkerEventSuccess, seader_worker->context);
         }
@@ -478,10 +506,10 @@ bool parseSamResponse(SeaderWorker* seader_worker, SamResponse_t* samResponse) {
     return false;
 }
 
-bool parseResponse(SeaderWorker* seader_worker, Response_t* response) {
+bool seader_parse_response(SeaderWorker* seader_worker, Response_t* response) {
     switch(response->present) {
     case Response_PR_samResponse:
-        parseSamResponse(seader_worker, &response->choice.samResponse);
+        seader_parse_sam_response(seader_worker, &response->choice.samResponse);
         break;
     default:
         break;
@@ -489,7 +517,7 @@ bool parseResponse(SeaderWorker* seader_worker, Response_t* response) {
     return false;
 }
 
-void sendNFCRx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
+void seader_send_nfc_rx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
     OCTET_STRING_t rxData = {.buf = buffer, .size = len};
     uint8_t status[] = {0x00, 0x00};
     RfStatus_t rfStatus = {.buf = status, .size = 2};
@@ -515,14 +543,14 @@ void sendNFCRx(SeaderUartBridge* seader_uart, uint8_t* buffer, size_t len) {
     response->present = Response_PR_nfcResponse;
     response->choice.nfcResponse = *nfcResponse;
 
-    sendResponse(seader_uart, response, 0x14, 0x0a, 0x0);
+    seader_send_response(seader_uart, response, 0x14, 0x0a, 0x0);
 
     ASN_STRUCT_FREE(asn_DEF_NFCRx, nfcRx);
     ASN_STRUCT_FREE(asn_DEF_NFCResponse, nfcResponse);
     ASN_STRUCT_FREE(asn_DEF_Response, response);
 }
 
-bool iso14443aTransmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
+bool seader_iso14443a_transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     FuriHalNfcTxRxContext tx_rx = {.tx_rx_type = FuriHalNfcTxRxTypeDefault};
     memcpy(&tx_rx.tx_data, buffer, len);
@@ -536,7 +564,7 @@ bool iso14443aTransmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
             snprintf(display + (i * 2), sizeof(display), "%02x", tx_rx.rx_data[i]);
         }
         // FURI_LOG_D(TAG, "NFC Response %d: %s", length, display);
-        sendNFCRx(seader_uart, tx_rx.rx_data, length);
+        seader_send_nfc_rx(seader_uart, tx_rx.rx_data, length);
     } else {
         FURI_LOG_W(TAG, "Bad exchange");
         if(seader_worker->callback) {
@@ -551,8 +579,13 @@ uint8_t read4Block6[] = {0x06, 0x06, 0x45, 0x56};
 uint8_t read4Block9[] = {0x06, 0x09, 0xB2, 0xAE};
 uint8_t read4Block10[] = {0x06, 0x0A, 0x29, 0x9C};
 uint8_t read4Block13[] = {0x06, 0x0D, 0x96, 0xE8};
+uint8_t updateBlock2[] = {0x87, 0x02};
 
-void handleSIO(uint8_t* buffer, size_t len, uint8_t* rxBuffer, SeaderCredential* credential) {
+void seader_capture_sio(
+    uint8_t* buffer,
+    size_t len,
+    uint8_t* rxBuffer,
+    SeaderCredential* credential) {
     if(memcmp(buffer, read4Block6, len) == 0 && rxBuffer[0] == 0x30) {
         memcpy(credential->sio, rxBuffer, 32);
     } else if(memcmp(buffer, read4Block10, len) == 0 && rxBuffer[0] == 0x30) {
@@ -564,7 +597,28 @@ void handleSIO(uint8_t* buffer, size_t len, uint8_t* rxBuffer, SeaderCredential*
     }
 }
 
-bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
+FuriHalNfcReturn
+    seader_worker_fake_epurse_update(uint8_t* buffer, uint8_t* rxBuffer, uint16_t* recvLen) {
+    uint8_t fake_response[10];
+    memset(fake_response, 0, sizeof(fake_response));
+    memcpy(fake_response + 0, buffer + 6, 4);
+    memcpy(fake_response + 4, buffer + 2, 4);
+
+    uint16_t crc = seader_worker_picopass_calculate_ccitt(0xE012, fake_response, 8);
+    memcpy(fake_response + 8, &crc, sizeof(uint16_t));
+
+    memcpy(rxBuffer, fake_response, sizeof(fake_response));
+    *recvLen = sizeof(fake_response);
+
+    memset(display, 0, sizeof(display));
+    for(uint8_t i = 0; i < sizeof(fake_response); i++) {
+        snprintf(display + (i * 2), sizeof(display), "%02x", fake_response[i]);
+    }
+    FURI_LOG_I(TAG, "Fake update E-Purse response: %s", display);
+    return FuriHalNfcReturnOk;
+}
+
+bool seader_iso15693_transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     SeaderCredential* credential = seader_worker->credential;
     char display[SEADER_UART_RX_BUF_SIZE * 2 + 1] = {0};
@@ -574,7 +628,12 @@ bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
     uint32_t fwt = furi_hal_nfc_ll_ms2fc(20);
 
     uint8_t rxBuffer[64] = {0};
-    ret = furi_hal_nfc_ll_txrx(buffer, len, rxBuffer, sizeof(rxBuffer), &recvLen, flags, fwt);
+
+    if(memcmp(buffer, updateBlock2, sizeof(updateBlock2)) == 0) {
+        ret = seader_worker_fake_epurse_update(buffer, rxBuffer, &recvLen);
+    } else {
+        ret = furi_hal_nfc_ll_txrx(buffer, len, rxBuffer, sizeof(rxBuffer), &recvLen, flags, fwt);
+    }
 
     if(ret == FuriHalNfcReturnOk) {
         memset(display, 0, sizeof(display));
@@ -582,18 +641,16 @@ bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
             snprintf(display + (i * 2), sizeof(display), "%02x", rxBuffer[i]);
         }
         // FURI_LOG_D(TAG, "Result %d %s", recvLen, display);
-        handleSIO(buffer, len, rxBuffer, credential);
-
-        sendNFCRx(seader_uart, rxBuffer, recvLen);
+        seader_capture_sio(buffer, len, rxBuffer, credential);
+        seader_send_nfc_rx(seader_uart, rxBuffer, recvLen);
     } else if(ret == FuriHalNfcReturnCrc) {
         memset(display, 0, sizeof(display));
         for(uint8_t i = 0; i < recvLen; i++) {
             snprintf(display + (i * 2), sizeof(display), "%02x", rxBuffer[i]);
         }
         // FURI_LOG_D(TAG, "[CRC error] Result %d %s", recvLen, display);
-        handleSIO(buffer, len, rxBuffer, credential);
-
-        sendNFCRx(seader_uart, rxBuffer, recvLen);
+        seader_capture_sio(buffer, len, rxBuffer, credential);
+        seader_send_nfc_rx(seader_uart, rxBuffer, recvLen);
 
         // Act as if it was OK
         return true;
@@ -608,20 +665,22 @@ bool iso15693Transmit(SeaderWorker* seader_worker, uint8_t* buffer, size_t len)
     return ret == FuriHalNfcReturnOk;
 }
 
-bool parseNfcCommandTransmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
+bool seader_parse_nfc_command_transmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
     long timeOut = nfcSend->timeOut;
     Protocol_t protocol = nfcSend->protocol;
     FrameProtocol_t frameProtocol = protocol.buf[1];
 
 #ifdef ASN1_DEBUG
-    char display[SEADER_UART_RX_BUF_SIZE * 2 + 1] = {0};
+    memset(display, 0, sizeof(display));
     for(uint8_t i = 0; i < nfcSend->data.size; i++) {
         snprintf(display + (i * 2), sizeof(display), "%02x", nfcSend->data.buf[i]);
     }
 
     char protocolName[8] = {0};
+    memset(protocolName, 0, sizeof(protocolName));
     (&asn_DEF_FrameProtocol)
-        ->op->print_struct(&asn_DEF_FrameProtocol, &frameProtocol, 1, toString, protocolName);
+        ->op->print_struct(
+            &asn_DEF_FrameProtocol, &frameProtocol, 1, seader_asn_to_string, protocolName);
 
     FURI_LOG_D(
         TAG,
@@ -635,17 +694,17 @@ bool parseNfcCommandTransmit(SeaderWorker* seader_worker, NFCSend_t* nfcSend) {
 #endif
 
     if(frameProtocol == FrameProtocol_iclass) {
-        return iso15693Transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
+        return seader_iso15693_transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
     } else if(frameProtocol == FrameProtocol_nfc) {
-        return iso14443aTransmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
+        return seader_iso14443a_transmit(seader_worker, nfcSend->data.buf, nfcSend->data.size);
     }
     return false;
 }
 
-bool parseNfcOff(SeaderUartBridge* seader_uart) {
+bool seader_parse_nfc_off(SeaderUartBridge* seader_uart) {
     FURI_LOG_D(TAG, "Set Field Off");
     seader_worker_disable_field(ERR_NONE);
-    nfc_scene_field_on_exit();
+    seader_nfc_scene_field_on_exit();
 
     NFCResponse_t* nfcResponse = 0;
     nfcResponse = calloc(1, sizeof *nfcResponse);
@@ -660,7 +719,7 @@ bool parseNfcOff(SeaderUartBridge* seader_uart) {
     response->present = Response_PR_nfcResponse;
     response->choice.nfcResponse = *nfcResponse;
 
-    sendResponse(seader_uart, response, 0x44, 0x0a, 0);
+    seader_send_response(seader_uart, response, 0x44, 0x0a, 0);
 
     ASN_STRUCT_FREE(asn_DEF_Response, response);
     ASN_STRUCT_FREE(asn_DEF_NFCResponse, nfcResponse);
@@ -668,14 +727,14 @@ bool parseNfcOff(SeaderUartBridge* seader_uart) {
     return false;
 }
 
-bool parseNfcCommand(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
+bool seader_parse_nfc_command(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     switch(nfcCommand->present) {
     case NFCCommand_PR_nfcSend:
-        parseNfcCommandTransmit(seader_worker, &nfcCommand->choice.nfcSend);
+        seader_parse_nfc_command_transmit(seader_worker, &nfcCommand->choice.nfcSend);
         break;
     case NFCCommand_PR_nfcOff:
-        parseNfcOff(seader_uart);
+        seader_parse_nfc_off(seader_uart);
         break;
     default:
         FURI_LOG_W(TAG, "unparsed NFCCommand");
@@ -685,13 +744,13 @@ bool parseNfcCommand(SeaderWorker* seader_worker, NFCCommand_t* nfcCommand) {
     return false;
 }
 
-bool stateMachine(SeaderWorker* seader_worker, Payload_t* payload) {
+bool seader_worker_state_machine(SeaderWorker* seader_worker, Payload_t* payload) {
     switch(payload->present) {
     case Payload_PR_response:
-        parseResponse(seader_worker, &payload->choice.response);
+        seader_parse_response(seader_worker, &payload->choice.response);
         break;
     case Payload_PR_nfcCommand:
-        parseNfcCommand(seader_worker, &payload->choice.nfcCommand);
+        seader_parse_nfc_command(seader_worker, &payload->choice.nfcCommand);
         break;
     case Payload_PR_errorResponse:
         // TODO: screen saying this was a failure, or maybe start over?
@@ -707,7 +766,7 @@ bool stateMachine(SeaderWorker* seader_worker, Payload_t* payload) {
     return false;
 }
 
-bool processSuccessResponse(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
+bool seader_process_success_response(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     Payload_t* payload = 0;
     payload = calloc(1, sizeof *payload);
     assert(payload);
@@ -717,19 +776,20 @@ bool processSuccessResponse(SeaderWorker* seader_worker, uint8_t* apdu, size_t l
     if(rval.code == RC_OK) {
 #ifdef ASN1_DEBUG
         memset(payloadDebug, 0, sizeof(payloadDebug));
-        (&asn_DEF_Payload)->op->print_struct(&asn_DEF_Payload, payload, 1, toString, payloadDebug);
+        (&asn_DEF_Payload)
+            ->op->print_struct(&asn_DEF_Payload, payload, 1, seader_asn_to_string, payloadDebug);
         if(strlen(payloadDebug) > 0) {
             FURI_LOG_D(TAG, "Received payload: %s", payloadDebug);
         }
 #endif
-        stateMachine(seader_worker, payload);
+        seader_worker_state_machine(seader_worker, payload);
     }
 
     ASN_STRUCT_FREE(asn_DEF_Payload, payload);
     return (rval.code == RC_OK);
 }
 
-bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
+bool seader_process_apdu(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     if(len < 2) {
         return false;
@@ -749,14 +809,14 @@ bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     case 0x61:
         // FURI_LOG_I(TAG, "Request %d bytes", SW2);
         GET_RESPONSE[4] = SW2;
-        PC_to_RDR_XfrBlock(seader_uart, GET_RESPONSE, sizeof(GET_RESPONSE));
+        seader_ccid_XfrBlock(seader_uart, GET_RESPONSE, sizeof(GET_RESPONSE));
         return true;
         break;
 
     case 0x90:
         if(SW2 == 0x00) {
             if(len > 2) {
-                return processSuccessResponse(seader_worker, apdu, len - 2);
+                return seader_process_success_response(seader_worker, apdu, len - 2);
             }
         }
         break;
@@ -765,7 +825,7 @@ bool processAPDU(SeaderWorker* seader_worker, uint8_t* apdu, size_t len) {
     return false;
 }
 
-ReturnCode picopass_card_init(SeaderWorker* seader_worker) {
+ReturnCode seader_picopass_card_init(SeaderWorker* seader_worker) {
     SeaderUartBridge* seader_uart = seader_worker->uart;
     SeaderCredential* credential = seader_worker->credential;
     rfalPicoPassIdentifyRes idRes;
@@ -803,13 +863,13 @@ ReturnCode picopass_card_init(SeaderWorker* seader_worker) {
 
     memcpy(credential->diversifier, selRes.CSN, RFAL_PICOPASS_MAX_BLOCK_LEN);
 
-    sendCardDetected(seader_uart, cardDetails);
+    seader_send_card_detected(seader_uart, cardDetails);
 
     ASN_STRUCT_FREE(asn_DEF_CardDetails, cardDetails);
     return ERR_NONE;
 }
 
-ReturnCode picopass_card_detect() {
+ReturnCode seader_picopass_card_detect() {
     ReturnCode err;
 
     err = rfalPicoPassPollerInitialize();
@@ -835,13 +895,13 @@ ReturnCode picopass_card_detect() {
     return ERR_NONE;
 }
 
-ReturnCode picopass_card_read(SeaderWorker* seader_worker) {
+ReturnCode seader_picopass_card_read(SeaderWorker* seader_worker) {
     ReturnCode err = ERR_TIMEOUT;
 
     while(seader_worker->state == SeaderWorkerStateReadPicopass) {
         // Card found
-        if(picopass_card_detect() == ERR_NONE) {
-            err = picopass_card_init(seader_worker);
+        if(seader_picopass_card_detect() == ERR_NONE) {
+            err = seader_picopass_card_init(seader_worker);
             if(err != ERR_NONE) {
                 FURI_LOG_E(TAG, "picopass_card_init error %d", err);
             }
@@ -855,7 +915,7 @@ ReturnCode picopass_card_read(SeaderWorker* seader_worker) {
 }
 
 void seader_worker_process_message(SeaderWorker* seader_worker, CCID_Message* message) {
-    if(processAPDU(seader_worker, message->payload, message->dwLength)) {
+    if(seader_process_apdu(seader_worker, message->payload, message->dwLength)) {
         // no-op
     } else {
         memset(display, 0, sizeof(display));
@@ -876,14 +936,14 @@ int32_t seader_worker_task(void* context) {
 
     if(seader_worker->state == SeaderWorkerStateCheckSam) {
         furi_delay_ms(1000);
-        check_for_sam(seader_uart);
+        seader_ccid_check_for_sam(seader_uart);
     } else if(seader_worker->state == SeaderWorkerStateReadPicopass) {
         FURI_LOG_D(TAG, "Read Picopass");
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialTypePicopass;
         seader_worker_enable_field();
-        if(picopass_card_read(seader_worker) != ERR_NONE) {
+        if(seader_picopass_card_read(seader_worker) != ERR_NONE) {
             // Turn off if cancelled / no card found
             seader_worker_disable_field(ERR_NONE);
         }
@@ -892,10 +952,10 @@ int32_t seader_worker_task(void* context) {
         requestPacs = true;
         seader_credential_clear(seader_worker->credential);
         seader_worker->credential->type = SeaderCredentialType14A;
-        nfc_scene_field_on_enter();
-        if(!detect_nfc(seader_worker)) {
+        seader_nfc_scene_field_on_enter();
+        if(!seader_detect_nfc(seader_worker)) {
             // Turn off if cancelled / no card found
-            nfc_scene_field_on_exit();
+            seader_nfc_scene_field_on_exit();
         }
     }
     FURI_LOG_D(TAG, "Worker Task Complete");

uart.c

@@ -47,7 +47,7 @@ size_t seader_uart_process_buffer(Seader* seader, uint8_t* cmd, size_t cmd_len)
 
     size_t consumed = 0;
     do {
-        consumed = processCCID(seader_worker, cmd, cmd_len);
+        consumed = seader_ccid_process(seader_worker, cmd, cmd_len);
 
         if(consumed > 0) {
             memset(cmd, 0, consumed);