Picopass: rename RFAL_PICOPASS_BLOCK_LEN (#63)

Co-authored-by: hedger <hedger@users.noreply.github.com>

picopass_device.c

@@ -43,7 +43,7 @@ static bool picopass_device_save_file_lfrfid(PicopassDevice* dev, FuriString* fi
     bool result = false;
     uint64_t target = 0;
     uint64_t sentinel = 1ULL << pacs->bitLength;
-    memcpy(&target, pacs->credential, RFAL_PICOPASS_BLOCK_LEN);
+    memcpy(&target, pacs->credential, PICOPASS_BLOCK_LEN);
     target = __builtin_bswap64(target);
     FURI_LOG_D(TAG, "Original (%d): %016llx", pacs->bitLength, target);
 
@@ -132,8 +132,7 @@ static bool picopass_device_save_file(
             // Write header
             if(!flipper_format_write_header_cstr(file, picopass_file_header, picopass_file_version))
                 break;
-            if(!flipper_format_write_hex(
-                   file, "Credential", pacs->credential, RFAL_PICOPASS_BLOCK_LEN))
+            if(!flipper_format_write_hex(file, "Credential", pacs->credential, PICOPASS_BLOCK_LEN))
                 break;
 
             // TODO: Add elite
@@ -146,10 +145,7 @@ static bool picopass_device_save_file(
             for(size_t i = 0; i < app_limit; i++) {
                 furi_string_printf(temp_str, "Block %d", i);
                 if(!flipper_format_write_hex(
-                       file,
-                       furi_string_get_cstr(temp_str),
-                       AA1[i].data,
-                       RFAL_PICOPASS_BLOCK_LEN)) {
+                       file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                     block_saved = false;
                     break;
                 }
@@ -210,7 +206,7 @@ static bool picopass_device_load_data(PicopassDevice* dev, FuriString* path, boo
         for(size_t i = 0; i < 6; i++) {
             furi_string_printf(temp_str, "Block %d", i);
             if(!flipper_format_read_hex(
-                   file, furi_string_get_cstr(temp_str), AA1[i].data, RFAL_PICOPASS_BLOCK_LEN)) {
+                   file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                 block_read = false;
                 break;
             }
@@ -222,7 +218,7 @@ static bool picopass_device_load_data(PicopassDevice* dev, FuriString* path, boo
         for(size_t i = 6; i < app_limit; i++) {
             furi_string_printf(temp_str, "Block %d", i);
             if(!flipper_format_read_hex(
-                   file, furi_string_get_cstr(temp_str), AA1[i].data, RFAL_PICOPASS_BLOCK_LEN)) {
+                   file, furi_string_get_cstr(temp_str), AA1[i].data, PICOPASS_BLOCK_LEN)) {
                 block_read = false;
                 break;
             }
@@ -386,9 +382,9 @@ ReturnCode picopass_device_parse_credential(PicopassBlock* AA1, PicopassPacs* pa
         }
     } else if(pacs->encryption == PicopassDeviceEncryptionNone) {
         FURI_LOG_D(TAG, "No Encryption");
-        memcpy(pacs->credential, AA1[7].data, RFAL_PICOPASS_BLOCK_LEN);
-        memcpy(pacs->pin0, AA1[8].data, RFAL_PICOPASS_BLOCK_LEN);
-        memcpy(pacs->pin1, AA1[9].data, RFAL_PICOPASS_BLOCK_LEN);
+        memcpy(pacs->credential, AA1[7].data, PICOPASS_BLOCK_LEN);
+        memcpy(pacs->pin0, AA1[8].data, PICOPASS_BLOCK_LEN);
+        memcpy(pacs->pin1, AA1[9].data, PICOPASS_BLOCK_LEN);
     } else if(pacs->encryption == PicopassDeviceEncryptionDES) {
         FURI_LOG_D(TAG, "DES Encrypted");
     } else {

picopass_device.h

@@ -96,7 +96,7 @@ typedef struct {
 } PicopassPacs;
 
 typedef struct {
-    uint8_t data[RFAL_PICOPASS_BLOCK_LEN];
+    uint8_t data[PICOPASS_BLOCK_LEN];
 } PicopassBlock;
 
 typedef struct {

picopass_i.h

@@ -57,7 +57,7 @@ struct Picopass {
 
     char text_store[PICOPASS_TEXT_STORE_SIZE + 1];
     FuriString* text_box_store;
-    uint8_t byte_input_store[RFAL_PICOPASS_BLOCK_LEN];
+    uint8_t byte_input_store[PICOPASS_BLOCK_LEN];
 
     // Common Views
     Submenu* submenu;

picopass_keys.h

@@ -2,9 +2,9 @@
 
 #include "picopass_device.h"
 
-extern const uint8_t picopass_iclass_key[RFAL_PICOPASS_BLOCK_LEN];
-extern const uint8_t picopass_factory_credit_key[RFAL_PICOPASS_BLOCK_LEN];
-extern const uint8_t picopass_factory_debit_key[RFAL_PICOPASS_BLOCK_LEN];
-extern const uint8_t picopass_xice_key[RFAL_PICOPASS_BLOCK_LEN];
-extern const uint8_t picopass_xicl_key[RFAL_PICOPASS_BLOCK_LEN];
-extern const uint8_t picopass_xics_key[RFAL_PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_iclass_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_factory_credit_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_factory_debit_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xice_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xicl_key[PICOPASS_BLOCK_LEN];
+extern const uint8_t picopass_xics_key[PICOPASS_BLOCK_LEN];

picopass_worker.c

@@ -8,7 +8,7 @@
 #define HAS_MASK(x, b) ((x & b) == b)
 
 // CSNs from Proxmark3 repo
-static const uint8_t loclass_csns[LOCLASS_NUM_CSNS][RFAL_PICOPASS_BLOCK_LEN] = {
+static const uint8_t loclass_csns[LOCLASS_NUM_CSNS][PICOPASS_BLOCK_LEN] = {
     {0x01, 0x0A, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0},
     {0x0C, 0x06, 0x0C, 0xFE, 0xF7, 0xFF, 0x12, 0xE0},
     {0x10, 0x97, 0x83, 0x7B, 0xF7, 0xFF, 0x12, 0xE0},
@@ -220,7 +220,7 @@ static ReturnCode
     uint8_t ccnr[12] = {0};
 
     size_t index = 0;
-    uint8_t key[RFAL_PICOPASS_BLOCK_LEN] = {0};
+    uint8_t key[PICOPASS_BLOCK_LEN] = {0};
 
     if(!iclass_elite_dict_check_presence(dict_type)) {
         FURI_LOG_E(TAG, "Dictionary not found");
@@ -261,7 +261,7 @@ static ReturnCode
 
         err = rfalPicoPassPollerCheck(mac, &chkRes);
         if(err == ERR_NONE) {
-            memcpy(pacs->key, key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(pacs->key, key, PICOPASS_BLOCK_LEN);
             break;
         }
 
@@ -379,7 +379,7 @@ ReturnCode picopass_write_card(PicopassBlock* AA1) {
         FURI_LOG_D(TAG, "rfalPicoPassPollerWriteBlock %d", i);
         uint8_t data[9] = {0};
         data[0] = i;
-        memcpy(data + 1, AA1[i].data, RFAL_PICOPASS_BLOCK_LEN);
+        memcpy(data + 1, AA1[i].data, PICOPASS_BLOCK_LEN);
         loclass_doMAC_N(data, sizeof(data), div_key, mac);
         FURI_LOG_D(
             TAG,
@@ -438,7 +438,7 @@ ReturnCode picopass_write_block(PicopassBlock* AA1, uint8_t blockNo, uint8_t* ne
     }
     memcpy(ccnr, rcRes.CCNR, sizeof(rcRes.CCNR)); // last 4 bytes left 0
 
-    if(memcmp(selRes.CSN, AA1[PICOPASS_CSN_BLOCK_INDEX].data, RFAL_PICOPASS_BLOCK_LEN) != 0) {
+    if(memcmp(selRes.CSN, AA1[PICOPASS_CSN_BLOCK_INDEX].data, PICOPASS_BLOCK_LEN) != 0) {
         FURI_LOG_E(TAG, "Wrong CSN for write");
         return ERR_REQUEST;
     }
@@ -514,7 +514,7 @@ void picopass_worker_elite_dict_attack(PicopassWorker* picopass_worker) {
     uint8_t ccnr[12] = {0};
 
     size_t index = 0;
-    uint8_t key[RFAL_PICOPASS_BLOCK_LEN] = {0};
+    uint8_t key[PICOPASS_BLOCK_LEN] = {0};
 
     // Load dictionary
     IclassEliteDict* dict = dict_attack_data->dict;
@@ -590,7 +590,7 @@ void picopass_worker_elite_dict_attack(PicopassWorker* picopass_worker) {
                 key[6],
                 key[7]);
 
-            memcpy(pacs->key, key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(pacs->key, key, PICOPASS_BLOCK_LEN);
             pacs->elite_kdf = elite;
             err = picopass_read_card(AA1);
             if(err != ERR_NONE) {
@@ -768,7 +768,7 @@ void picopass_worker_write_key(PicopassWorker* picopass_worker) {
     uint8_t fuses = configBlock[7];
     uint8_t* oldKey = AA1[PICOPASS_SECURE_KD_BLOCK_INDEX].data;
 
-    uint8_t newKey[RFAL_PICOPASS_BLOCK_LEN] = {0};
+    uint8_t newKey[PICOPASS_BLOCK_LEN] = {0};
     loclass_iclass_calc_div_key(csn, pacs->key, newKey, pacs->elite_kdf);
 
     if((fuses & 0x80) == 0x80) {
@@ -776,7 +776,7 @@ void picopass_worker_write_key(PicopassWorker* picopass_worker) {
     } else {
         FURI_LOG_D(TAG, "XOR write for application mode key change");
         // XOR when in application mode
-        for(size_t i = 0; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+        for(size_t i = 0; i < PICOPASS_BLOCK_LEN; i++) {
             newKey[i] ^= oldKey[i];
         }
     }
@@ -819,9 +819,7 @@ static inline void picopass_emu_read_blocks(
     uint8_t block_num,
     uint8_t block_count) {
     memcpy(
-        buf,
-        nfcv_data->data + (block_num * RFAL_PICOPASS_BLOCK_LEN),
-        block_count * RFAL_PICOPASS_BLOCK_LEN);
+        buf, nfcv_data->data + (block_num * PICOPASS_BLOCK_LEN), block_count * PICOPASS_BLOCK_LEN);
 }
 
 static inline void picopass_emu_write_blocks(
@@ -830,23 +828,21 @@ static inline void picopass_emu_write_blocks(
     uint8_t block_num,
     uint8_t block_count) {
     memcpy(
-        nfcv_data->data + (block_num * RFAL_PICOPASS_BLOCK_LEN),
-        buf,
-        block_count * RFAL_PICOPASS_BLOCK_LEN);
+        nfcv_data->data + (block_num * PICOPASS_BLOCK_LEN), buf, block_count * PICOPASS_BLOCK_LEN);
 }
 
 static void picopass_init_cipher_state_key(
     NfcVData* nfcv_data,
     PicopassEmulatorCtx* ctx,
-    const uint8_t key[RFAL_PICOPASS_BLOCK_LEN]) {
-    uint8_t cc[RFAL_PICOPASS_BLOCK_LEN];
+    const uint8_t key[PICOPASS_BLOCK_LEN]) {
+    uint8_t cc[PICOPASS_BLOCK_LEN];
     picopass_emu_read_blocks(nfcv_data, cc, PICOPASS_SECURE_EPURSE_BLOCK_INDEX, 1);
 
     ctx->cipher_state = loclass_opt_doTagMAC_1(cc, key);
 }
 
 static void picopass_init_cipher_state(NfcVData* nfcv_data, PicopassEmulatorCtx* ctx) {
-    uint8_t key[RFAL_PICOPASS_BLOCK_LEN];
+    uint8_t key[PICOPASS_BLOCK_LEN];
 
     picopass_emu_read_blocks(nfcv_data, key, ctx->key_block_num, 1);
 
@@ -858,10 +854,10 @@ static void
     // collect LOCLASS_NUM_PER_CSN nonces in a row for each CSN
     const uint8_t* csn =
         loclass_csns[(ctx->key_block_num / LOCLASS_NUM_PER_CSN) % LOCLASS_NUM_CSNS];
-    memcpy(nfc_data->uid, csn, RFAL_PICOPASS_BLOCK_LEN);
+    memcpy(nfc_data->uid, csn, PICOPASS_BLOCK_LEN);
     picopass_emu_write_blocks(nfcv_data, csn, PICOPASS_CSN_BLOCK_INDEX, 1);
 
-    uint8_t key[RFAL_PICOPASS_BLOCK_LEN];
+    uint8_t key[PICOPASS_BLOCK_LEN];
     loclass_iclass_calc_div_key(csn, picopass_iclass_key, key, false);
     picopass_emu_write_blocks(nfcv_data, key, PICOPASS_SECURE_KD_BLOCK_INDEX, 1);
 
@@ -918,8 +914,8 @@ static void picopass_emu_handle_packet(
            ctx->state == PicopassEmulatorStateActive) { // PICOPASS_CMD_IDENTIFY
             // ASNB(8) CRC16(2)
             picopass_anticoll_csn(response, nfc_data->uid);
-            picopass_append_crc(response, RFAL_PICOPASS_BLOCK_LEN);
-            response_length = RFAL_PICOPASS_BLOCK_LEN + 2;
+            picopass_append_crc(response, PICOPASS_BLOCK_LEN);
+            response_length = PICOPASS_BLOCK_LEN + 2;
             break;
         } else if(
             nfcv_data->frame_length == 4 &&
@@ -935,12 +931,12 @@ static void picopass_emu_handle_packet(
             if(nfcv_data->frame[1] == PICOPASS_SECURE_KD_BLOCK_INDEX ||
                nfcv_data->frame[1] == PICOPASS_SECURE_KC_BLOCK_INDEX) {
                 // Reading Kd or Kc blocks always returns FF's
-                memcpy(response, block_ff, RFAL_PICOPASS_BLOCK_LEN);
+                memcpy(response, block_ff, PICOPASS_BLOCK_LEN);
             } else {
                 picopass_emu_read_blocks(nfcv_data, response, nfcv_data->frame[1], 1);
             }
-            picopass_append_crc(response, RFAL_PICOPASS_BLOCK_LEN);
-            response_length = RFAL_PICOPASS_BLOCK_LEN + 2;
+            picopass_append_crc(response, PICOPASS_BLOCK_LEN);
+            response_length = PICOPASS_BLOCK_LEN + 2;
             break;
         }
 
@@ -960,32 +956,32 @@ static void picopass_emu_handle_packet(
         picopass_emu_read_blocks(nfcv_data, response, blockNum, 4);
         if(blockNum == 4) {
             // Kc is block 4, so just redact first block of response
-            memcpy(response, block_ff, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(response, block_ff, PICOPASS_BLOCK_LEN);
         } else if(blockNum < 4) {
             // Kd is block 3
-            uint8_t* kdOffset = response + ((3 - blockNum) * RFAL_PICOPASS_BLOCK_LEN);
-            memcpy(kdOffset, block_ff, RFAL_PICOPASS_BLOCK_LEN);
+            uint8_t* kdOffset = response + ((3 - blockNum) * PICOPASS_BLOCK_LEN);
+            memcpy(kdOffset, block_ff, PICOPASS_BLOCK_LEN);
             if(blockNum != 0) {
                 // Redact Kc
-                memcpy(kdOffset + RFAL_PICOPASS_BLOCK_LEN, block_ff, RFAL_PICOPASS_BLOCK_LEN);
+                memcpy(kdOffset + PICOPASS_BLOCK_LEN, block_ff, PICOPASS_BLOCK_LEN);
             }
         }
-        picopass_append_crc(response, RFAL_PICOPASS_BLOCK_LEN * 4);
-        response_length = (RFAL_PICOPASS_BLOCK_LEN * 4) + 2;
+        picopass_append_crc(response, PICOPASS_BLOCK_LEN * 4);
+        response_length = (PICOPASS_BLOCK_LEN * 4) + 2;
         break;
     case RFAL_PICOPASS_CMD_SELECT: // ASNB(8)|SERIALNB(8)
         if(nfcv_data->frame_length != 9) {
             return;
         }
 
-        uint8_t select_csn[RFAL_PICOPASS_BLOCK_LEN];
+        uint8_t select_csn[PICOPASS_BLOCK_LEN];
         if(ctx->state == PicopassEmulatorStateHalt || ctx->state == PicopassEmulatorStateIdle) {
-            memcpy(select_csn, nfc_data->uid, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(select_csn, nfc_data->uid, PICOPASS_BLOCK_LEN);
         } else {
             picopass_anticoll_csn(select_csn, nfc_data->uid);
         }
 
-        if(memcmp(nfcv_data->frame + 1, select_csn, RFAL_PICOPASS_BLOCK_LEN)) {
+        if(memcmp(nfcv_data->frame + 1, select_csn, PICOPASS_BLOCK_LEN)) {
             if(ctx->state == PicopassEmulatorStateActive) {
                 ctx->state = PicopassEmulatorStateIdle;
             } else if(ctx->state == PicopassEmulatorStateSelected) {
@@ -999,10 +995,10 @@ static void picopass_emu_handle_packet(
         ctx->state = PicopassEmulatorStateSelected;
 
         // SERIALNB(8) CRC16(2)
-        memcpy(response, nfc_data->uid, RFAL_PICOPASS_BLOCK_LEN);
-        picopass_append_crc(response, RFAL_PICOPASS_BLOCK_LEN);
+        memcpy(response, nfc_data->uid, PICOPASS_BLOCK_LEN);
+        picopass_append_crc(response, PICOPASS_BLOCK_LEN);
 
-        response_length = RFAL_PICOPASS_BLOCK_LEN + 2;
+        response_length = PICOPASS_BLOCK_LEN + 2;
         break;
     case RFAL_PICOPASS_CMD_READCHECK_KC: // ADDRESS(1)
         key_block_num = PICOPASS_SECURE_KC_BLOCK_INDEX;
@@ -1023,7 +1019,7 @@ static void picopass_emu_handle_packet(
 
         // DATA(8)
         picopass_emu_read_blocks(nfcv_data, response, nfcv_data->frame[1], 1);
-        response_length = RFAL_PICOPASS_BLOCK_LEN;
+        response_length = PICOPASS_BLOCK_LEN;
         break;
     case RFAL_PICOPASS_CMD_CHECK: // CHALLENGE(4) READERSIGNATURE(4)
         if(nfcv_data->frame_length != 9 || ctx->state != PicopassEmulatorStateSelected) {
@@ -1034,11 +1030,11 @@ static void picopass_emu_handle_packet(
             // LOCLASS Reader attack mode
 
             // Copy EPURSE
-            uint8_t cc[RFAL_PICOPASS_BLOCK_LEN];
+            uint8_t cc[PICOPASS_BLOCK_LEN];
             picopass_emu_read_blocks(nfcv_data, cc, PICOPASS_SECURE_EPURSE_BLOCK_INDEX, 1);
 
 #ifndef PICOPASS_DEBUG_IGNORE_LOCLASS_STD_KEY
-            uint8_t key[RFAL_PICOPASS_BLOCK_LEN];
+            uint8_t key[PICOPASS_BLOCK_LEN];
             // loclass mode stores the derived standard debit key in Kd to check
             picopass_emu_read_blocks(nfcv_data, key, PICOPASS_SECURE_KD_BLOCK_INDEX, 1);
 
@@ -1071,7 +1067,7 @@ static void picopass_emu_handle_packet(
             // CSN changed
             if(ctx->key_block_num % LOCLASS_NUM_PER_CSN == 0) {
                 // Flush NR-MACs for this CSN to SD card
-                uint8_t cc[RFAL_PICOPASS_BLOCK_LEN];
+                uint8_t cc[PICOPASS_BLOCK_LEN];
                 picopass_emu_read_blocks(nfcv_data, cc, PICOPASS_SECURE_EPURSE_BLOCK_INDEX, 1);
 
                 for(int i = 0; i < LOCLASS_NUM_PER_CSN; i++) {
@@ -1096,7 +1092,7 @@ static void picopass_emu_handle_packet(
             return;
         }
 
-        uint8_t key[RFAL_PICOPASS_BLOCK_LEN];
+        uint8_t key[PICOPASS_BLOCK_LEN];
         picopass_emu_read_blocks(nfcv_data, key, ctx->key_block_num, 1);
 
         uint8_t rmac[4];
@@ -1125,7 +1121,7 @@ static void picopass_emu_handle_packet(
             return;
         }
 
-        uint8_t cfgBlock[RFAL_PICOPASS_BLOCK_LEN];
+        uint8_t cfgBlock[PICOPASS_BLOCK_LEN];
         picopass_emu_read_blocks(nfcv_data, cfgBlock, PICOPASS_CONFIG_BLOCK_INDEX, 1);
         bool persMode = HAS_MASK(cfgBlock[7], PICOPASS_FUSE_PERS);
 
@@ -1160,7 +1156,7 @@ static void picopass_emu_handle_packet(
         // -> must auth with that key to change it
 
         uint8_t blockOffset = nfcv_data->frame[1];
-        uint8_t block[RFAL_PICOPASS_BLOCK_LEN];
+        uint8_t block[PICOPASS_BLOCK_LEN];
         switch(nfcv_data->frame[1]) {
         case PICOPASS_CONFIG_BLOCK_INDEX:
             block[0] = cfgBlock[0]; // Applications Limit
@@ -1193,14 +1189,14 @@ static void picopass_emu_handle_packet(
         case PICOPASS_SECURE_KC_BLOCK_INDEX:
             if(!persMode) {
                 picopass_emu_read_blocks(nfcv_data, block, blockOffset, 1);
-                for(uint8_t i = 0; i < sizeof(RFAL_PICOPASS_BLOCK_LEN); i++)
+                for(uint8_t i = 0; i < sizeof(PICOPASS_BLOCK_LEN); i++)
                     block[i] ^= nfcv_data->frame[i + 2];
                 break;
             }
             // Use default case when in personalisation mode
             // fallthrough
         default:
-            memcpy(block, nfcv_data->frame + 2, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(block, nfcv_data->frame + 2, PICOPASS_BLOCK_LEN);
             break;
         }
 
@@ -1215,12 +1211,12 @@ static void picopass_emu_handle_packet(
         if(nfcv_data->frame[1] == PICOPASS_SECURE_KD_BLOCK_INDEX ||
            nfcv_data->frame[1] == PICOPASS_SECURE_KD_BLOCK_INDEX) {
             // Key updates always return FF's
-            memcpy(response, block_ff, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(response, block_ff, PICOPASS_BLOCK_LEN);
         } else {
-            memcpy(response, block, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(response, block, PICOPASS_BLOCK_LEN);
         }
-        picopass_append_crc(response, RFAL_PICOPASS_BLOCK_LEN);
-        response_length = RFAL_PICOPASS_BLOCK_LEN + 2;
+        picopass_append_crc(response, PICOPASS_BLOCK_LEN);
+        response_length = PICOPASS_BLOCK_LEN + 2;
         break;
     case RFAL_PICOPASS_CMD_PAGESEL: // PAGE(1) CRC16(2)
         // Chips with a single page do not answer to this command
@@ -1262,7 +1258,7 @@ void picopass_worker_emulate(PicopassWorker* picopass_worker, bool loclass_mode)
         .uid_len = RFAL_PICOPASS_UID_LEN,
     };
     NfcVData* nfcv_data = malloc(sizeof(NfcVData));
-    nfcv_data->block_size = RFAL_PICOPASS_BLOCK_LEN;
+    nfcv_data->block_size = PICOPASS_BLOCK_LEN;
     nfcv_data->emu_protocol_ctx = &emu_ctx;
     nfcv_data->emu_protocol_handler = &picopass_emu_handle_packet;
 
@@ -1300,7 +1296,7 @@ void picopass_worker_emulate(PicopassWorker* picopass_worker, bool loclass_mode)
 
         loclass_writer_write_start_stop(emu_ctx.loclass_writer, true);
     } else {
-        memcpy(nfc_data.uid, blocks[PICOPASS_CSN_BLOCK_INDEX].data, RFAL_PICOPASS_BLOCK_LEN);
+        memcpy(nfc_data.uid, blocks[PICOPASS_CSN_BLOCK_INDEX].data, PICOPASS_BLOCK_LEN);
         memcpy(nfcv_data->data, blocks, sizeof(dev_data->AA1));
         picopass_init_cipher_state(nfcv_data, &emu_ctx);
     }

rfal_picopass.c

@@ -194,7 +194,7 @@ FuriHalNfcReturn rfalPicoPassPollerWriteBlock(uint8_t blockNum, uint8_t data[8],
     FuriHalNfcReturn ret;
 
     uint8_t txBuf[14] = {RFAL_PICOPASS_CMD_UPDATE, blockNum, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
-    memcpy(txBuf + 2, data, RFAL_PICOPASS_BLOCK_LEN);
+    memcpy(txBuf + 2, data, PICOPASS_BLOCK_LEN);
     memcpy(txBuf + 10, mac, 4);
 
     uint16_t recvLen = 0;

rfal_picopass.h

@@ -3,7 +3,7 @@
 #include <furi_hal_nfc.h>
 
 #define RFAL_PICOPASS_UID_LEN 8
-#define RFAL_PICOPASS_BLOCK_LEN 8
+#define PICOPASS_BLOCK_LEN 8
 
 enum {
     // PicoPass command bytes:
@@ -59,7 +59,7 @@ typedef struct {
 } rfalPicoPassCheckRes;
 
 typedef struct {
-    uint8_t data[RFAL_PICOPASS_BLOCK_LEN];
+    uint8_t data[PICOPASS_BLOCK_LEN];
     uint8_t crc[2];
 } rfalPicoPassReadBlockRes;
 

scenes/picopass_scene_device_info.c

@@ -25,9 +25,9 @@ void picopass_scene_device_info_on_enter(void* context) {
     PicopassPacs* pacs = &picopass->dev->dev_data.pacs;
     Widget* widget = picopass->widget;
 
-    uint8_t csn[RFAL_PICOPASS_BLOCK_LEN] = {0};
-    memcpy(csn, AA1[PICOPASS_CSN_BLOCK_INDEX].data, RFAL_PICOPASS_BLOCK_LEN);
-    for(uint8_t i = 0; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+    uint8_t csn[PICOPASS_BLOCK_LEN] = {0};
+    memcpy(csn, AA1[PICOPASS_CSN_BLOCK_INDEX].data, PICOPASS_BLOCK_LEN);
+    for(uint8_t i = 0; i < PICOPASS_BLOCK_LEN; i++) {
         furi_string_cat_printf(csn_str, "%02X ", csn[i]);
     }
 
@@ -41,7 +41,7 @@ void picopass_scene_device_info_on_enter(void* context) {
             bytesLength++;
         }
         furi_string_set(credential_str, "");
-        for(uint8_t i = RFAL_PICOPASS_BLOCK_LEN - bytesLength; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+        for(uint8_t i = PICOPASS_BLOCK_LEN - bytesLength; i < PICOPASS_BLOCK_LEN; i++) {
             furi_string_cat_printf(credential_str, "%02X", pacs->credential[i]);
         }
         furi_string_cat_printf(wiegand_str, "%d bits", pacs->bitLength);

scenes/picopass_scene_key_input.c

@@ -7,7 +7,7 @@ void picopass_scene_key_input_text_input_callback(void* context) {
     Picopass* picopass = context;
 
     picopass->dev->dev_data.pacs.elite_kdf = true;
-    memcpy(picopass->dev->dev_data.pacs.key, picopass->byte_input_store, RFAL_PICOPASS_BLOCK_LEN);
+    memcpy(picopass->dev->dev_data.pacs.key, picopass->byte_input_store, PICOPASS_BLOCK_LEN);
     view_dispatcher_send_custom_event(picopass->view_dispatcher, PicopassCustomEventByteInputDone);
 }
 
@@ -22,7 +22,7 @@ void picopass_scene_key_input_on_enter(void* context) {
         NULL,
         picopass,
         picopass->byte_input_store,
-        RFAL_PICOPASS_BLOCK_LEN);
+        PICOPASS_BLOCK_LEN);
     view_dispatcher_switch_to_view(picopass->view_dispatcher, PicopassViewByteInput);
 }
 

scenes/picopass_scene_key_menu.c

@@ -65,28 +65,28 @@ bool picopass_scene_key_menu_on_event(void* context, SceneManagerEvent event) {
         if(event.event == SubmenuIndexWriteStandard) {
             scene_manager_set_scene_state(
                 picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteStandard);
-            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, PICOPASS_BLOCK_LEN);
             picopass->dev->dev_data.pacs.elite_kdf = false;
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;
         } else if(event.event == SubmenuIndexWriteiCE) {
             scene_manager_set_scene_state(
                 picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCE);
-            memcpy(picopass->dev->dev_data.pacs.key, picopass_xice_key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xice_key, PICOPASS_BLOCK_LEN);
             picopass->dev->dev_data.pacs.elite_kdf = true;
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;
         } else if(event.event == SubmenuIndexWriteiCL) {
             scene_manager_set_scene_state(
                 picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCL);
-            memcpy(picopass->dev->dev_data.pacs.key, picopass_xicl_key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xicl_key, PICOPASS_BLOCK_LEN);
             picopass->dev->dev_data.pacs.elite_kdf = false;
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;
         } else if(event.event == SubmenuIndexWriteiCS) {
             scene_manager_set_scene_state(
                 picopass->scene_manager, PicopassSceneKeyMenu, SubmenuIndexWriteiCS);
-            memcpy(picopass->dev->dev_data.pacs.key, picopass_xics_key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_xics_key, PICOPASS_BLOCK_LEN);
             picopass->dev->dev_data.pacs.elite_kdf = false;
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;

scenes/picopass_scene_read_card.c

@@ -38,7 +38,7 @@ bool picopass_scene_read_card_on_event(void* context, SceneManagerEvent event) {
             if(memcmp(
                    picopass->dev->dev_data.pacs.key,
                    picopass_factory_debit_key,
-                   RFAL_PICOPASS_BLOCK_LEN) == 0) {
+                   PICOPASS_BLOCK_LEN) == 0) {
                 scene_manager_next_scene(picopass->scene_manager, PicopassSceneReadFactorySuccess);
             } else {
                 scene_manager_next_scene(picopass->scene_manager, PicopassSceneReadCardSuccess);

scenes/picopass_scene_read_card_success.c

@@ -31,17 +31,17 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     PicopassPacs* pacs = &picopass->dev->dev_data.pacs;
     Widget* widget = picopass->widget;
 
-    uint8_t csn[RFAL_PICOPASS_BLOCK_LEN] = {0};
-    memcpy(csn, AA1[PICOPASS_CSN_BLOCK_INDEX].data, RFAL_PICOPASS_BLOCK_LEN);
-    for(uint8_t i = 0; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+    uint8_t csn[PICOPASS_BLOCK_LEN] = {0};
+    memcpy(csn, AA1[PICOPASS_CSN_BLOCK_INDEX].data, PICOPASS_BLOCK_LEN);
+    for(uint8_t i = 0; i < PICOPASS_BLOCK_LEN; i++) {
         furi_string_cat_printf(csn_str, "%02X", csn[i]);
     }
 
     // We can't test the pacs->key in case it is intentionally all 0's and we can't test the key block since it is populated with the diversified key before each key test, so we approximate with the PACS config block being blank.
     bool no_key = picopass_is_memset(
-        AA1[PICOPASS_ICLASS_PACS_CFG_BLOCK_INDEX].data, 0x00, RFAL_PICOPASS_BLOCK_LEN);
+        AA1[PICOPASS_ICLASS_PACS_CFG_BLOCK_INDEX].data, 0x00, PICOPASS_BLOCK_LEN);
     bool empty = picopass_is_memset(
-        AA1[PICOPASS_ICLASS_PACS_CFG_BLOCK_INDEX].data, 0xFF, RFAL_PICOPASS_BLOCK_LEN);
+        AA1[PICOPASS_ICLASS_PACS_CFG_BLOCK_INDEX].data, 0xFF, PICOPASS_BLOCK_LEN);
 
     if(no_key) {
         furi_string_cat_printf(wiegand_str, "Read Failed");
@@ -83,7 +83,7 @@ void picopass_scene_read_card_success_on_enter(void* context) {
     } else {
         size_t bytesLength = 1 + pacs->bitLength / 8;
         furi_string_set(credential_str, "");
-        for(uint8_t i = RFAL_PICOPASS_BLOCK_LEN - bytesLength; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+        for(uint8_t i = PICOPASS_BLOCK_LEN - bytesLength; i < PICOPASS_BLOCK_LEN; i++) {
             furi_string_cat_printf(credential_str, "%02X", pacs->credential[i]);
         }
         furi_string_cat_printf(wiegand_str, "%d bits", pacs->bitLength);
@@ -94,12 +94,12 @@ void picopass_scene_read_card_success_on_enter(void* context) {
 
         if(pacs->key) {
             furi_string_cat_printf(key_str, "Key: ");
-            uint8_t key[RFAL_PICOPASS_BLOCK_LEN];
-            memcpy(key, &pacs->key, RFAL_PICOPASS_BLOCK_LEN);
+            uint8_t key[PICOPASS_BLOCK_LEN];
+            memcpy(key, &pacs->key, PICOPASS_BLOCK_LEN);
 
             bool standard_key = true;
             // Handle DES key being 56bits with parity in LSB
-            for(uint8_t i = 0; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+            for(uint8_t i = 0; i < PICOPASS_BLOCK_LEN; i++) {
                 if((key[i] & 0xFE) != (picopass_iclass_key[i] & 0xFE)) {
                     standard_key = false;
                     break;
@@ -109,7 +109,7 @@ void picopass_scene_read_card_success_on_enter(void* context) {
             if(standard_key) {
                 furi_string_cat_printf(key_str, "Standard");
             } else {
-                for(uint8_t i = 0; i < RFAL_PICOPASS_BLOCK_LEN; i++) {
+                for(uint8_t i = 0; i < PICOPASS_BLOCK_LEN; i++) {
                     furi_string_cat_printf(key_str, "%02X", key[i]);
                 }
             }

scenes/picopass_scene_read_factory_success.c

@@ -64,7 +64,7 @@ bool picopass_scene_read_factory_success_on_event(void* context, SceneManagerEve
         if(event.event == GuiButtonTypeLeft) {
             consumed = scene_manager_previous_scene(picopass->scene_manager);
         } else if(event.event == GuiButtonTypeCenter) {
-            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, RFAL_PICOPASS_BLOCK_LEN);
+            memcpy(picopass->dev->dev_data.pacs.key, picopass_iclass_key, PICOPASS_BLOCK_LEN);
             scene_manager_next_scene(picopass->scene_manager, PicopassSceneWriteKey);
             consumed = true;
         }