[FL-2369] NFC refactoring (#1095)
* nfc: clean up scenes * nfc worker: remove field on from worker * nfc worker: move full data exchange to furi hal * nfc_device: check UID length * nfc protocol: introduce mifare common API * nfc: move common data to furi hal nfc * nfc: rename emv_decoder -> emv * nfc: move emv data structure to emv lib * nfc: remove deactivate after detection * nfc: rework furi hal nfc detect * nfc: clean up CLI commands and type * nfc: remove unused includes and function * nfc: add TxRxType enum * nfc: read mifare ultralight refactoring * nfc: refactore mifare ultralight start * rfal: fix custom data exchange * nfc: refactor read bank card * nfc: refactor read emv application * nfc: refactor emv test emulation * nfc: refactor uid emulation * nfc: add limit to uid emulation logger * fix source formatting * furi_hal_nfc: fix data exchange full * nfc: fix mifare ultralight type load Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
gornekich
GitHub
@@ -1,6 +1,7 @@
|
||||
#include "mifare_ultralight.h"
|
||||
#include <furi.h>
|
||||
#include <furi_hal_nfc.h>
|
||||
|
||||
#define TAG "MfUltralight"
|
||||
|
||||
bool mf_ul_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
|
||||
if((ATQA0 == 0x44) && (ATQA1 == 0x00) && (SAK == 0x00)) {
|
||||
@@ -9,187 +10,204 @@ bool mf_ul_check_card_type(uint8_t ATQA0, uint8_t ATQA1, uint8_t SAK) {
|
||||
return false;
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_get_version(uint8_t* dest) {
|
||||
dest[0] = MF_UL_GET_VERSION_CMD;
|
||||
return 1;
|
||||
static void mf_ul_set_default_version(MfUltralightReader* reader, MfUltralightData* data) {
|
||||
data->type = MfUltralightTypeUnknown;
|
||||
reader->pages_to_read = 16;
|
||||
reader->support_fast_read = false;
|
||||
}
|
||||
|
||||
void mf_ul_parse_get_version_response(uint8_t* buff, MifareUlDevice* mf_ul_read) {
|
||||
MfUltralightVersion* version = (MfUltralightVersion*)buff;
|
||||
memcpy(&mf_ul_read->data.version, version, sizeof(MfUltralightVersion));
|
||||
if(version->storage_size == 0x0B || version->storage_size == 0x00) {
|
||||
mf_ul_read->data.type = MfUltralightTypeUL11;
|
||||
mf_ul_read->pages_to_read = 20;
|
||||
mf_ul_read->support_fast_read = true;
|
||||
} else if(version->storage_size == 0x0E) {
|
||||
mf_ul_read->data.type = MfUltralightTypeUL21;
|
||||
mf_ul_read->pages_to_read = 41;
|
||||
mf_ul_read->support_fast_read = true;
|
||||
} else if(version->storage_size == 0x0F) {
|
||||
mf_ul_read->data.type = MfUltralightTypeNTAG213;
|
||||
mf_ul_read->pages_to_read = 45;
|
||||
mf_ul_read->support_fast_read = false;
|
||||
} else if(version->storage_size == 0x11) {
|
||||
mf_ul_read->data.type = MfUltralightTypeNTAG215;
|
||||
mf_ul_read->pages_to_read = 135;
|
||||
mf_ul_read->support_fast_read = false;
|
||||
} else if(version->storage_size == 0x13) {
|
||||
mf_ul_read->data.type = MfUltralightTypeNTAG216;
|
||||
mf_ul_read->pages_to_read = 231;
|
||||
mf_ul_read->support_fast_read = false;
|
||||
bool mf_ultralight_read_version(
|
||||
FuriHalNfcTxRxContext* tx_rx,
|
||||
MfUltralightReader* reader,
|
||||
MfUltralightData* data) {
|
||||
bool version_read = false;
|
||||
|
||||
do {
|
||||
FURI_LOG_D(TAG, "Reading version");
|
||||
tx_rx->tx_data[0] = MF_UL_GET_VERSION_CMD;
|
||||
tx_rx->tx_bits = 8;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(!furi_hal_nfc_tx_rx(tx_rx, 4)) {
|
||||
FURI_LOG_D(TAG, "Failed reading version");
|
||||
mf_ul_set_default_version(reader, data);
|
||||
furi_hal_nfc_sleep();
|
||||
furi_hal_nfc_activate_nfca(300, NULL);
|
||||
break;
|
||||
}
|
||||
MfUltralightVersion* version = (MfUltralightVersion*)tx_rx->rx_data;
|
||||
data->version = *version;
|
||||
if(version->storage_size == 0x0B || version->storage_size == 0x00) {
|
||||
data->type = MfUltralightTypeUL11;
|
||||
reader->pages_to_read = 20;
|
||||
reader->support_fast_read = true;
|
||||
} else if(version->storage_size == 0x0E) {
|
||||
data->type = MfUltralightTypeUL21;
|
||||
reader->pages_to_read = 41;
|
||||
reader->support_fast_read = true;
|
||||
} else if(version->storage_size == 0x0F) {
|
||||
data->type = MfUltralightTypeNTAG213;
|
||||
reader->pages_to_read = 45;
|
||||
reader->support_fast_read = false;
|
||||
} else if(version->storage_size == 0x11) {
|
||||
data->type = MfUltralightTypeNTAG215;
|
||||
reader->pages_to_read = 135;
|
||||
reader->support_fast_read = false;
|
||||
} else if(version->storage_size == 0x13) {
|
||||
data->type = MfUltralightTypeNTAG216;
|
||||
reader->pages_to_read = 231;
|
||||
reader->support_fast_read = false;
|
||||
} else {
|
||||
mf_ul_set_default_version(reader, data);
|
||||
break;
|
||||
}
|
||||
version_read = true;
|
||||
} while(false);
|
||||
|
||||
return version_read;
|
||||
}
|
||||
|
||||
bool mf_ultralight_read_pages(
|
||||
FuriHalNfcTxRxContext* tx_rx,
|
||||
MfUltralightReader* reader,
|
||||
MfUltralightData* data) {
|
||||
uint8_t pages_read_cnt = 0;
|
||||
|
||||
for(size_t i = 0; i < reader->pages_to_read; i += 4) {
|
||||
FURI_LOG_D(TAG, "Reading pages %d - %d", i, i + 3);
|
||||
tx_rx->tx_data[0] = MF_UL_READ_CMD;
|
||||
tx_rx->tx_data[1] = i;
|
||||
tx_rx->tx_bits = 16;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(!furi_hal_nfc_tx_rx(tx_rx, 4)) {
|
||||
FURI_LOG_D(TAG, "Failed to read pages %d - %d", i, i + 3);
|
||||
break;
|
||||
}
|
||||
if(i + 4 <= reader->pages_to_read) {
|
||||
pages_read_cnt = 4;
|
||||
} else {
|
||||
pages_read_cnt = reader->pages_to_read - reader->pages_read;
|
||||
}
|
||||
reader->pages_read += pages_read_cnt;
|
||||
data->data_size = reader->pages_read * 4;
|
||||
memcpy(&data->data[i * 4], tx_rx->rx_data, pages_read_cnt * 4);
|
||||
}
|
||||
|
||||
return reader->pages_read == reader->pages_to_read;
|
||||
}
|
||||
|
||||
bool mf_ultralight_fast_read_pages(
|
||||
FuriHalNfcTxRxContext* tx_rx,
|
||||
MfUltralightReader* reader,
|
||||
MfUltralightData* data) {
|
||||
FURI_LOG_D(TAG, "Reading pages 0 - %d", reader->pages_to_read);
|
||||
tx_rx->tx_data[0] = MF_UL_FAST_READ_CMD;
|
||||
tx_rx->tx_data[1] = 0;
|
||||
tx_rx->tx_data[2] = reader->pages_to_read - 1;
|
||||
tx_rx->tx_bits = 24;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(furi_hal_nfc_tx_rx(tx_rx, 20)) {
|
||||
reader->pages_read = reader->pages_to_read;
|
||||
data->data_size = reader->pages_read * 4;
|
||||
memcpy(data->data, tx_rx->rx_data, data->data_size);
|
||||
} else {
|
||||
mf_ul_set_default_version(mf_ul_read);
|
||||
}
|
||||
}
|
||||
|
||||
void mf_ul_set_default_version(MifareUlDevice* mf_ul_read) {
|
||||
mf_ul_read->data.type = MfUltralightTypeUnknown;
|
||||
mf_ul_read->pages_to_read = 16;
|
||||
mf_ul_read->support_fast_read = false;
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_read(uint8_t* dest, uint8_t start_page) {
|
||||
dest[0] = MF_UL_READ_CMD;
|
||||
dest[1] = start_page;
|
||||
return 2;
|
||||
}
|
||||
|
||||
void mf_ul_parse_read_response(uint8_t* buff, uint16_t page_addr, MifareUlDevice* mf_ul_read) {
|
||||
uint8_t pages_read = 4;
|
||||
uint8_t page_read_count = mf_ul_read->pages_read + pages_read;
|
||||
if(page_read_count > mf_ul_read->pages_to_read) {
|
||||
pages_read -= page_read_count - mf_ul_read->pages_to_read;
|
||||
}
|
||||
mf_ul_read->pages_read += pages_read;
|
||||
mf_ul_read->data.data_size = mf_ul_read->pages_read * 4;
|
||||
memcpy(&mf_ul_read->data.data[page_addr * 4], buff, pages_read * 4);
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_fast_read(uint8_t* dest, uint8_t start_page, uint8_t end_page) {
|
||||
dest[0] = MF_UL_FAST_READ_CMD;
|
||||
dest[1] = start_page;
|
||||
dest[2] = end_page;
|
||||
return 3;
|
||||
}
|
||||
|
||||
void mf_ul_parse_fast_read_response(
|
||||
uint8_t* buff,
|
||||
uint8_t start_page,
|
||||
uint8_t end_page,
|
||||
MifareUlDevice* mf_ul_read) {
|
||||
mf_ul_read->pages_read = end_page - start_page + 1;
|
||||
mf_ul_read->data.data_size = mf_ul_read->pages_read * 4;
|
||||
memcpy(mf_ul_read->data.data, buff, mf_ul_read->data.data_size);
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_read_signature(uint8_t* dest) {
|
||||
dest[0] = MF_UL_READ_SIG;
|
||||
dest[1] = 0;
|
||||
return 2;
|
||||
}
|
||||
|
||||
void mf_ul_parse_read_signature_response(uint8_t* buff, MifareUlDevice* mf_ul_read) {
|
||||
memcpy(mf_ul_read->data.signature, buff, sizeof(mf_ul_read->data.signature));
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_read_cnt(uint8_t* dest, uint8_t cnt_index) {
|
||||
if(cnt_index > 2) {
|
||||
return 0;
|
||||
}
|
||||
dest[0] = MF_UL_READ_CNT;
|
||||
dest[1] = cnt_index;
|
||||
return 2;
|
||||
}
|
||||
|
||||
void mf_ul_parse_read_cnt_response(uint8_t* buff, uint8_t cnt_index, MifareUlDevice* mf_ul_read) {
|
||||
// Reverse LSB sequence
|
||||
if(cnt_index < 3) {
|
||||
mf_ul_read->data.counter[cnt_index] = (buff[2] << 16) | (buff[1] << 8) | (buff[0]);
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_inc_cnt(uint8_t* dest, uint8_t cnt_index, uint32_t value) {
|
||||
if(cnt_index > 2) {
|
||||
return 0;
|
||||
}
|
||||
dest[0] = MF_UL_INC_CNT;
|
||||
dest[1] = cnt_index;
|
||||
dest[2] = (uint8_t)value;
|
||||
dest[3] = (uint8_t)(value >> 8);
|
||||
dest[4] = (uint8_t)(value >> 16);
|
||||
dest[5] = 0;
|
||||
return 6;
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_check_tearing(uint8_t* dest, uint8_t cnt_index) {
|
||||
if(cnt_index > 2) {
|
||||
return 0;
|
||||
}
|
||||
dest[0] = MF_UL_CHECK_TEARING;
|
||||
dest[1] = cnt_index;
|
||||
return 2;
|
||||
}
|
||||
|
||||
void mf_ul_parse_check_tearing_response(
|
||||
uint8_t* buff,
|
||||
uint8_t cnt_index,
|
||||
MifareUlDevice* mf_ul_read) {
|
||||
if(cnt_index < 2) {
|
||||
mf_ul_read->data.tearing[cnt_index] = buff[0];
|
||||
}
|
||||
}
|
||||
|
||||
uint16_t mf_ul_prepare_write(uint8_t* dest, uint16_t page_addr, uint32_t data) {
|
||||
if(page_addr < 2) {
|
||||
return 0;
|
||||
}
|
||||
dest[0] = MF_UL_WRITE;
|
||||
dest[1] = page_addr;
|
||||
dest[2] = (uint8_t)(data >> 24);
|
||||
dest[3] = (uint8_t)(data >> 16);
|
||||
dest[4] = (uint8_t)(data >> 8);
|
||||
dest[5] = (uint8_t)data;
|
||||
return 6;
|
||||
}
|
||||
|
||||
void mf_ul_prepare_emulation(MifareUlDevice* mf_ul_emulate, MifareUlData* data) {
|
||||
mf_ul_emulate->data = *data;
|
||||
mf_ul_emulate->auth_data = NULL;
|
||||
mf_ul_emulate->data_changed = false;
|
||||
mf_ul_emulate->comp_write_cmd_started = false;
|
||||
if(data->version.storage_size == 0) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeUnknown;
|
||||
mf_ul_emulate->support_fast_read = false;
|
||||
} else if(data->version.storage_size == 0x0B) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeUL11;
|
||||
mf_ul_emulate->support_fast_read = true;
|
||||
} else if(data->version.storage_size == 0x0E) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeUL21;
|
||||
mf_ul_emulate->support_fast_read = true;
|
||||
} else if(data->version.storage_size == 0x0F) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeNTAG213;
|
||||
mf_ul_emulate->support_fast_read = true;
|
||||
} else if(data->version.storage_size == 0x11) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeNTAG215;
|
||||
mf_ul_emulate->support_fast_read = true;
|
||||
} else if(data->version.storage_size == 0x13) {
|
||||
mf_ul_emulate->data.type = MfUltralightTypeNTAG216;
|
||||
mf_ul_emulate->support_fast_read = true;
|
||||
FURI_LOG_D(TAG, "Failed to read pages 0 - %d", reader->pages_to_read);
|
||||
}
|
||||
|
||||
if(mf_ul_emulate->data.type >= MfUltralightTypeNTAG213) {
|
||||
uint16_t pwd_page = (data->data_size / 4) - 2;
|
||||
mf_ul_emulate->auth_data = (MifareUlAuthData*)&data->data[pwd_page * 4];
|
||||
}
|
||||
return reader->pages_read == reader->pages_to_read;
|
||||
}
|
||||
|
||||
void mf_ul_protect_auth_data_on_read_command(
|
||||
bool mf_ultralight_read_signature(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
|
||||
bool signature_read = false;
|
||||
|
||||
FURI_LOG_D(TAG, "Reading signature");
|
||||
tx_rx->tx_data[0] = MF_UL_READ_SIG;
|
||||
tx_rx->tx_data[1] = 0;
|
||||
tx_rx->tx_bits = 16;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(furi_hal_nfc_tx_rx(tx_rx, 7)) {
|
||||
memcpy(data->signature, tx_rx->rx_data, sizeof(data->signature));
|
||||
signature_read = true;
|
||||
} else {
|
||||
FURI_LOG_D(TAG, "Failed redaing signature");
|
||||
}
|
||||
|
||||
return signature_read;
|
||||
}
|
||||
|
||||
bool mf_ultralight_read_counters(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
|
||||
uint8_t counter_read = 0;
|
||||
|
||||
FURI_LOG_D(TAG, "Reading counters");
|
||||
for(size_t i = 0; i < 3; i++) {
|
||||
tx_rx->tx_data[0] = MF_UL_READ_CNT;
|
||||
tx_rx->rx_data[1] = i;
|
||||
tx_rx->tx_bits = 16;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(!furi_hal_nfc_tx_rx(tx_rx, 4)) {
|
||||
FURI_LOG_D(TAG, "Failed to read %d counter", i);
|
||||
break;
|
||||
}
|
||||
data->counter[i] = (tx_rx->rx_data[2] << 16) | (tx_rx->rx_data[1] << 8) |
|
||||
tx_rx->rx_data[0];
|
||||
counter_read++;
|
||||
}
|
||||
|
||||
return counter_read == 2;
|
||||
}
|
||||
|
||||
bool mf_ultralight_read_tearing_flags(FuriHalNfcTxRxContext* tx_rx, MfUltralightData* data) {
|
||||
uint8_t flag_read = 0;
|
||||
|
||||
FURI_LOG_D(TAG, "Reading tearing flags");
|
||||
for(size_t i = 0; i < 3; i++) {
|
||||
tx_rx->tx_data[0] = MF_UL_CHECK_TEARING;
|
||||
tx_rx->rx_data[1] = i;
|
||||
tx_rx->tx_bits = 16;
|
||||
tx_rx->tx_rx_type = FuriHalNfcTxRxTypeDefault;
|
||||
if(!furi_hal_nfc_tx_rx(tx_rx, 4)) {
|
||||
FURI_LOG_D(TAG, "Failed to read %d tearing flag", i);
|
||||
break;
|
||||
}
|
||||
data->tearing[i] = tx_rx->rx_data[0];
|
||||
flag_read++;
|
||||
}
|
||||
|
||||
return flag_read == 2;
|
||||
}
|
||||
|
||||
bool mf_ul_read_card(
|
||||
FuriHalNfcTxRxContext* tx_rx,
|
||||
MfUltralightReader* reader,
|
||||
MfUltralightData* data) {
|
||||
furi_assert(tx_rx);
|
||||
furi_assert(reader);
|
||||
furi_assert(data);
|
||||
|
||||
bool card_read = false;
|
||||
|
||||
// Read Mifare Ultralight version
|
||||
if(mf_ultralight_read_version(tx_rx, reader, data)) {
|
||||
// Read Signature
|
||||
mf_ultralight_read_signature(tx_rx, data);
|
||||
}
|
||||
// Read data blocks
|
||||
if(reader->support_fast_read) {
|
||||
mf_ultralight_read_counters(tx_rx, data);
|
||||
mf_ultralight_read_tearing_flags(tx_rx, data);
|
||||
}
|
||||
card_read = mf_ultralight_read_pages(tx_rx, reader, data);
|
||||
|
||||
return card_read;
|
||||
}
|
||||
|
||||
// TODO rework
|
||||
static void mf_ul_protect_auth_data_on_read_command(
|
||||
uint8_t* tx_buff,
|
||||
uint8_t start_page,
|
||||
uint8_t end_page,
|
||||
MifareUlDevice* mf_ul_emulate) {
|
||||
if(mf_ul_emulate->data.type >= MfUltralightTypeNTAG213) {
|
||||
uint8_t pwd_page = (mf_ul_emulate->data.data_size / 4) - 2;
|
||||
MfUltralightEmulator* emulator) {
|
||||
if(emulator->data.type >= MfUltralightTypeNTAG213) {
|
||||
uint8_t pwd_page = (emulator->data.data_size / 4) - 2;
|
||||
uint8_t pack_page = pwd_page + 1;
|
||||
if((start_page <= pwd_page) && (end_page >= pwd_page)) {
|
||||
memset(&tx_buff[(pwd_page - start_page) * 4], 0, 4);
|
||||
@@ -200,6 +218,31 @@ void mf_ul_protect_auth_data_on_read_command(
|
||||
}
|
||||
}
|
||||
|
||||
void mf_ul_prepare_emulation(MfUltralightEmulator* emulator, MfUltralightData* data) {
|
||||
emulator->data = *data;
|
||||
emulator->auth_data = NULL;
|
||||
emulator->data_changed = false;
|
||||
emulator->comp_write_cmd_started = false;
|
||||
if(data->type == MfUltralightTypeUnknown) {
|
||||
emulator->support_fast_read = false;
|
||||
} else if(data->type == MfUltralightTypeUL11) {
|
||||
emulator->support_fast_read = true;
|
||||
} else if(data->type == MfUltralightTypeUL21) {
|
||||
emulator->support_fast_read = true;
|
||||
} else if(data->type == MfUltralightTypeNTAG213) {
|
||||
emulator->support_fast_read = false;
|
||||
} else if(data->type == MfUltralightTypeNTAG215) {
|
||||
emulator->support_fast_read = false;
|
||||
} else if(data->type == MfUltralightTypeNTAG216) {
|
||||
emulator->support_fast_read = false;
|
||||
}
|
||||
|
||||
if(data->type >= MfUltralightTypeNTAG213) {
|
||||
uint16_t pwd_page = (data->data_size / 4) - 2;
|
||||
emulator->auth_data = (MfUltralightAuth*)&data->data[pwd_page * 4];
|
||||
}
|
||||
}
|
||||
|
||||
bool mf_ul_prepare_emulation_response(
|
||||
uint8_t* buff_rx,
|
||||
uint16_t buff_rx_len,
|
||||
@@ -208,30 +251,30 @@ bool mf_ul_prepare_emulation_response(
|
||||
uint32_t* data_type,
|
||||
void* context) {
|
||||
furi_assert(context);
|
||||
MifareUlDevice* mf_ul_emulate = context;
|
||||
MfUltralightEmulator* emulator = context;
|
||||
uint8_t cmd = buff_rx[0];
|
||||
uint16_t page_num = mf_ul_emulate->data.data_size / 4;
|
||||
uint16_t page_num = emulator->data.data_size / 4;
|
||||
uint16_t tx_bytes = 0;
|
||||
uint16_t tx_bits = 0;
|
||||
bool command_parsed = false;
|
||||
|
||||
// Check composite commands
|
||||
if(mf_ul_emulate->comp_write_cmd_started) {
|
||||
if(emulator->comp_write_cmd_started) {
|
||||
// Compatibility write is the only one composit command
|
||||
if(buff_rx_len == 16) {
|
||||
memcpy(&mf_ul_emulate->data.data[mf_ul_emulate->comp_write_page_addr * 4], buff_rx, 4);
|
||||
mf_ul_emulate->data_changed = true;
|
||||
memcpy(&emulator->data.data[emulator->comp_write_page_addr * 4], buff_rx, 4);
|
||||
emulator->data_changed = true;
|
||||
// Send ACK message
|
||||
buff_tx[0] = 0x0A;
|
||||
tx_bits = 4;
|
||||
*data_type = FURI_HAL_NFC_TXRX_RAW;
|
||||
command_parsed = true;
|
||||
}
|
||||
mf_ul_emulate->comp_write_cmd_started = false;
|
||||
emulator->comp_write_cmd_started = false;
|
||||
} else if(cmd == MF_UL_GET_VERSION_CMD) {
|
||||
if(mf_ul_emulate->data.type != MfUltralightTypeUnknown) {
|
||||
tx_bytes = sizeof(mf_ul_emulate->data.version);
|
||||
memcpy(buff_tx, &mf_ul_emulate->data.version, tx_bytes);
|
||||
if(emulator->data.type != MfUltralightTypeUnknown) {
|
||||
tx_bytes = sizeof(emulator->data.version);
|
||||
memcpy(buff_tx, &emulator->data.version, tx_bytes);
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
}
|
||||
@@ -242,28 +285,24 @@ bool mf_ul_prepare_emulation_response(
|
||||
if(start_page + 4 > page_num) {
|
||||
// Handle roll-over mechanism
|
||||
uint8_t end_pages_num = page_num - start_page;
|
||||
memcpy(buff_tx, &mf_ul_emulate->data.data[start_page * 4], end_pages_num * 4);
|
||||
memcpy(
|
||||
&buff_tx[end_pages_num * 4],
|
||||
mf_ul_emulate->data.data,
|
||||
(4 - end_pages_num) * 4);
|
||||
memcpy(buff_tx, &emulator->data.data[start_page * 4], end_pages_num * 4);
|
||||
memcpy(&buff_tx[end_pages_num * 4], emulator->data.data, (4 - end_pages_num) * 4);
|
||||
} else {
|
||||
memcpy(buff_tx, &mf_ul_emulate->data.data[start_page * 4], tx_bytes);
|
||||
memcpy(buff_tx, &emulator->data.data[start_page * 4], tx_bytes);
|
||||
}
|
||||
mf_ul_protect_auth_data_on_read_command(
|
||||
buff_tx, start_page, (start_page + 4), mf_ul_emulate);
|
||||
buff_tx, start_page, (start_page + 4), emulator);
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
}
|
||||
} else if(cmd == MF_UL_FAST_READ_CMD) {
|
||||
if(mf_ul_emulate->support_fast_read) {
|
||||
if(emulator->support_fast_read) {
|
||||
uint8_t start_page = buff_rx[1];
|
||||
uint8_t end_page = buff_rx[2];
|
||||
if((start_page < page_num) && (end_page < page_num) && (start_page < (end_page + 1))) {
|
||||
tx_bytes = ((end_page + 1) - start_page) * 4;
|
||||
memcpy(buff_tx, &mf_ul_emulate->data.data[start_page * 4], tx_bytes);
|
||||
mf_ul_protect_auth_data_on_read_command(
|
||||
buff_tx, start_page, end_page, mf_ul_emulate);
|
||||
memcpy(buff_tx, &emulator->data.data[start_page * 4], tx_bytes);
|
||||
mf_ul_protect_auth_data_on_read_command(buff_tx, start_page, end_page, emulator);
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
}
|
||||
@@ -271,8 +310,8 @@ bool mf_ul_prepare_emulation_response(
|
||||
} else if(cmd == MF_UL_WRITE) {
|
||||
uint8_t write_page = buff_rx[1];
|
||||
if((write_page > 1) && (write_page < page_num - 2)) {
|
||||
memcpy(&mf_ul_emulate->data.data[write_page * 4], &buff_rx[2], 4);
|
||||
mf_ul_emulate->data_changed = true;
|
||||
memcpy(&emulator->data.data[write_page * 4], &buff_rx[2], 4);
|
||||
emulator->data_changed = true;
|
||||
// ACK
|
||||
buff_tx[0] = 0x0A;
|
||||
tx_bits = 4;
|
||||
@@ -282,8 +321,8 @@ bool mf_ul_prepare_emulation_response(
|
||||
} else if(cmd == MF_UL_COMP_WRITE) {
|
||||
uint8_t write_page = buff_rx[1];
|
||||
if((write_page > 1) && (write_page < page_num - 2)) {
|
||||
mf_ul_emulate->comp_write_cmd_started = true;
|
||||
mf_ul_emulate->comp_write_page_addr = write_page;
|
||||
emulator->comp_write_cmd_started = true;
|
||||
emulator->comp_write_page_addr = write_page;
|
||||
// ACK
|
||||
buff_tx[0] = 0x0A;
|
||||
tx_bits = 4;
|
||||
@@ -293,9 +332,9 @@ bool mf_ul_prepare_emulation_response(
|
||||
} else if(cmd == MF_UL_READ_CNT) {
|
||||
uint8_t cnt_num = buff_rx[1];
|
||||
if(cnt_num < 3) {
|
||||
buff_tx[0] = mf_ul_emulate->data.counter[cnt_num] >> 16;
|
||||
buff_tx[1] = mf_ul_emulate->data.counter[cnt_num] >> 8;
|
||||
buff_tx[2] = mf_ul_emulate->data.counter[cnt_num];
|
||||
buff_tx[0] = emulator->data.counter[cnt_num] >> 16;
|
||||
buff_tx[1] = emulator->data.counter[cnt_num] >> 8;
|
||||
buff_tx[2] = emulator->data.counter[cnt_num];
|
||||
tx_bytes = 3;
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
@@ -303,9 +342,9 @@ bool mf_ul_prepare_emulation_response(
|
||||
} else if(cmd == MF_UL_INC_CNT) {
|
||||
uint8_t cnt_num = buff_rx[1];
|
||||
uint32_t inc = (buff_rx[2] | (buff_rx[3] << 8) | (buff_rx[4] << 16));
|
||||
if((cnt_num < 3) && (mf_ul_emulate->data.counter[cnt_num] + inc < 0x00FFFFFF)) {
|
||||
mf_ul_emulate->data.counter[cnt_num] += inc;
|
||||
mf_ul_emulate->data_changed = true;
|
||||
if((cnt_num < 3) && (emulator->data.counter[cnt_num] + inc < 0x00FFFFFF)) {
|
||||
emulator->data.counter[cnt_num] += inc;
|
||||
emulator->data_changed = true;
|
||||
// ACK
|
||||
buff_tx[0] = 0x0A;
|
||||
tx_bits = 4;
|
||||
@@ -313,14 +352,14 @@ bool mf_ul_prepare_emulation_response(
|
||||
command_parsed = true;
|
||||
}
|
||||
} else if(cmd == MF_UL_AUTH) {
|
||||
if(mf_ul_emulate->data.type >= MfUltralightTypeNTAG213) {
|
||||
if(memcmp(&buff_rx[1], mf_ul_emulate->auth_data->pwd, 4) == 0) {
|
||||
buff_tx[0] = mf_ul_emulate->auth_data->pack.raw[0];
|
||||
buff_tx[1] = mf_ul_emulate->auth_data->pack.raw[1];
|
||||
if(emulator->data.type >= MfUltralightTypeNTAG213) {
|
||||
if(memcmp(&buff_rx[1], emulator->auth_data->pwd, 4) == 0) {
|
||||
buff_tx[0] = emulator->auth_data->pack.raw[0];
|
||||
buff_tx[1] = emulator->auth_data->pack.raw[1];
|
||||
tx_bytes = 2;
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
} else if(!mf_ul_emulate->auth_data->pack.value) {
|
||||
} else if(!emulator->auth_data->pack.value) {
|
||||
buff_tx[0] = 0x80;
|
||||
buff_tx[1] = 0x80;
|
||||
tx_bytes = 2;
|
||||
@@ -331,15 +370,15 @@ bool mf_ul_prepare_emulation_response(
|
||||
} else if(cmd == MF_UL_READ_SIG) {
|
||||
// Check 2nd byte = 0x00 - RFU
|
||||
if(buff_rx[1] == 0x00) {
|
||||
tx_bytes = sizeof(mf_ul_emulate->data.signature);
|
||||
memcpy(buff_tx, mf_ul_emulate->data.signature, tx_bytes);
|
||||
tx_bytes = sizeof(emulator->data.signature);
|
||||
memcpy(buff_tx, emulator->data.signature, tx_bytes);
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
}
|
||||
} else if(cmd == MF_UL_CHECK_TEARING) {
|
||||
uint8_t cnt_num = buff_rx[1];
|
||||
if(cnt_num < 3) {
|
||||
buff_tx[0] = mf_ul_emulate->data.tearing[cnt_num];
|
||||
buff_tx[0] = emulator->data.tearing[cnt_num];
|
||||
tx_bytes = 1;
|
||||
*data_type = FURI_HAL_NFC_TXRX_DEFAULT;
|
||||
command_parsed = true;
|
||||
|
||||
Reference in New Issue
Block a user