esp32-off-Line-tools/components/rfid_rc522/src/picc/rc522_nxp.c

619 lines
20 KiB
C

#include <esp_system.h>
#include <esp_check.h>
#include <string.h>
#include "rc522_picc.h"
#include "rc522_types_internal.h"
#include "rc522_pcd_internal.h"
#include "rc522_picc_internal.h"
#include "picc/rc522_nxp.h"
#include "picc/rc522_mifare.h"
RC522_LOG_DEFINE_BASE();
const uint8_t RC522_NXP_DEFAULT_PWD[RC522_NXP_PWD_SIZE] = { 0xFF, 0xFF, 0xFF, 0xFF };
const uint8_t RC522_NXP_DEFAULT_PACK[RC522_NXP_PACK_SIZE] = { 0x00 };
// Helper to check if the card responded with a NACK
inline esp_err_t rc522_nxp_check_for_nak(rc522_picc_transaction_result_t *result)
{
if (result->bytes.length == 1 && result->valid_bits == 4 && result->bytes.ptr[0] != RC522_MIFARE_ACK) {
return RC522_ERR_NXP_NACK;
}
return ESP_OK;
}
// WRITE supported? (not classic write - see COMPAT_WRITE)
inline bool rc522_nxp_type_has_write(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_:
case RC522_PICC_TYPE_MIFARE_UL_C:
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_MIFARE_UL_NANO:
case RC522_PICC_TYPE_MIFARE_UL_AES:
case RC522_PICC_TYPE_NTAG2xx:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return true;
default:
return false;
}
}
// FAST_READ supported?
inline bool rc522_nxp_type_has_fast_read(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_MIFARE_UL_AES:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return true;
default:
return false;
}
}
// READ_CNT supported?
inline bool rc522_nxp_type_has_read_cnt(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_MIFARE_UL_AES:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return true;
default:
return false;
}
}
// PWD_AUTH supported?
inline bool rc522_nxp_type_has_pwd_auth(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return true;
default:
return false;
}
}
// Get originality signature size, or 0 if not supported
inline uint8_t rc522_nxp_type_sig_size(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_AES:
return 48;
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_MIFARE_UL_NANO:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return 32;
default:
return 0;
}
}
// Convert GET_VERSION response to type
static rc522_picc_type_t rc522_nxp_type_from_version(rc522_nxp_picc_version_t *version)
{
rc522_nxp_product_type_t type = version->product_type;
rc522_nxp_major_version_t major_version = version->major_version;
uint8_t size = version->storage_size;
if (type == RC522_NXP_PRODUCT_TYPE_NTAG) {
if (major_version != RC522_NXP_MAJ_VER_NTAG21) { // Not an NTAG21x
RC522_LOGW("Unknown NTAG product version: %02" RC522_X, major_version);
}
else if (size == 0x0F) { // 0x0F => between 128 and 256 user bytes
return RC522_PICC_TYPE_NTAG213;
}
else if (size == 0x11) { // 0x11 => between 256 and 512 user bytes
return RC522_PICC_TYPE_NTAG215;
}
else if (size == 0x13) { // 0x13 => between 512 and 1024 user byets
return RC522_PICC_TYPE_NTAG216;
}
else { // Unknown size?
RC522_LOGW("Unknown NTAG size: %02" RC522_X, size);
}
}
else if (type == RC522_NXP_PRODUCT_TYPE_UL) {
if (major_version == RC522_NXP_MAJ_VER_UL_EV1) {
if (size == 0x0B) { // 0x0B => between 32 and 64 user bytes
return RC522_PICC_TYPE_MIFARE_UL_EV1_1;
}
else if (size == 0x0E) { // 0x0E => 128 user bytes
return RC522_PICC_TYPE_MIFARE_UL_EV1_2;
}
}
else if (major_version == RC522_NXP_MAJ_VER_UL_NANO) {
return RC522_PICC_TYPE_MIFARE_UL_NANO;
}
else if (major_version == RC522_NXP_MAJ_VER_UL_AES) {
return RC522_PICC_TYPE_MIFARE_UL_AES;
}
else {
RC522_LOGW("Unknown UL product version: %02" RC522_X, major_version);
}
}
else {
RC522_LOGE("Unknown product type: %02" RC522_X, type);
}
return RC522_PICC_TYPE_UNKNOWN;
}
uint8_t rc522_nxp_get_user_page_count(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_:
return 12;
case RC522_PICC_TYPE_MIFARE_UL_C:
return 36;
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
return 12;
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
return 32;
case RC522_PICC_TYPE_MIFARE_UL_NANO:
return 10;
case RC522_PICC_TYPE_MIFARE_UL_AES:
return 36;
case RC522_PICC_TYPE_NTAG213:
return 36;
case RC522_PICC_TYPE_NTAG215:
return 126;
case RC522_PICC_TYPE_NTAG216:
return 222;
default:
return 0;
}
}
uint8_t rc522_nxp_get_user_mem_start(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_:
case RC522_PICC_TYPE_MIFARE_UL_C:
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
case RC522_PICC_TYPE_MIFARE_UL_NANO:
case RC522_PICC_TYPE_MIFARE_UL_AES:
case RC522_PICC_TYPE_NTAG2xx:
case RC522_PICC_TYPE_NTAG213:
case RC522_PICC_TYPE_NTAG215:
case RC522_PICC_TYPE_NTAG216:
return 0x04;
default:
return 0;
}
}
uint8_t rc522_nxp_get_user_mem_end(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_:
return 0x0F;
case RC522_PICC_TYPE_MIFARE_UL_C:
return 0x27;
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
return 0x0F;
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
return 0x23;
case RC522_PICC_TYPE_MIFARE_UL_NANO:
return 0x0D;
case RC522_PICC_TYPE_MIFARE_UL_AES:
return 0x27;
case RC522_PICC_TYPE_NTAG213:
return 0x27;
case RC522_PICC_TYPE_NTAG215:
return 0x81;
case RC522_PICC_TYPE_NTAG216:
return 0xE1;
default:
return 0;
}
}
uint8_t rc522_nxp_get_page_count(rc522_picc_type_t type)
{
switch (type) {
case RC522_PICC_TYPE_MIFARE_UL_:
return 16;
case RC522_PICC_TYPE_MIFARE_UL_C:
return 48;
case RC522_PICC_TYPE_MIFARE_UL_EV1_1:
return 20;
case RC522_PICC_TYPE_MIFARE_UL_EV1_2:
return 41;
case RC522_PICC_TYPE_MIFARE_UL_NANO:
return 14;
case RC522_PICC_TYPE_MIFARE_UL_AES:
return 60;
case RC522_PICC_TYPE_NTAG213:
return 45;
case RC522_PICC_TYPE_NTAG215:
return 135;
case RC522_PICC_TYPE_NTAG216:
return 231;
default:
return 0;
}
}
esp_err_t rc522_nxp_keyauth_supported(const rc522_handle_t rc522, const rc522_picc_t *picc)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_LOGD("AUTHENTICATE (support check)");
uint8_t buffer[11] = { 0 }; // combined send(4)/recv(11) buffer
buffer[0] = RC522_PICC_CMD_UL_AUTH;
// buffer[1] is argument; 0x00 is fine for support check
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522, &(rc522_bytes_t) { .ptr = buffer, .length = 2 }, &crc));
buffer[2] = crc.lsb;
buffer[3] = crc.msb;
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = buffer, .length = 4 },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = buffer, .length = sizeof(buffer) },
};
esp_err_t ret = rc522_picc_transceive(rc522, &transaction, &result);
if (ret == ESP_OK && buffer[0] != 0xAF) {
return RC522_ERR_NXP_NACK;
}
return ret;
}
esp_err_t rc522_nxp_get_type(const rc522_handle_t rc522, const rc522_picc_t *picc, rc522_picc_type_t *out_type)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(out_type == NULL);
RC522_CHECK(picc->type != RC522_PICC_TYPE_MIFARE_UL);
RC522_LOGD("Attempting to get NXP PICC type");
RC522_LOGD("Checking for GET_VERSION support...");
// In case of early exit due to errors
rc522_picc_type_t type = RC522_PICC_TYPE_MIFARE_UL;
rc522_nxp_picc_version_t version_info = { 0 };
esp_err_t ret = rc522_nxp_get_version(rc522, picc, &version_info);
if (ret == ESP_OK) { // GET_VERSION supported
type = rc522_nxp_type_from_version(&version_info);
}
else if (ret == RC522_ERR_RX_TIMER_TIMEOUT) { // No GET_VERSION
// Failure probably resulted in a HALT, so make sure we can still connect
RC522_LOGD("No L3 GET_VERSION; reselecting");
rc522_picc_uid_t uid;
uint8_t sak;
rc522_picc_heartbeat(rc522, picc, &uid, &sak);
// Fall back to checking for authentication availability (C)
RC522_LOGD("Checking for authentication support...");
ret = rc522_nxp_keyauth_supported(rc522, picc);
if (ret == ESP_OK) {
// Chip supports authentication
// TODO: Do we need to complete authentication, or can we leave it here?
// Note datasheet also mentions a "MIFARE Hospitality" here, but there
// doesn't seem to be any more information about it
type = RC522_PICC_TYPE_MIFARE_UL_C;
}
else if (ret == RC522_ERR_RX_TIMER_TIMEOUT || ret == RC522_ERR_MIFARE_NACK) { // Not supported
// Only Ultralight without auth is the original
type = RC522_PICC_TYPE_MIFARE_UL_;
}
else { // Some other error in AUTHENTICATE
RC522_RETURN_ON_ERROR(ret);
}
rc522_picc_heartbeat(rc522, picc, &uid, &sak);
}
else { // A different error occured in GET_VERSION
RC522_RETURN_ON_ERROR(ret);
}
RC522_LOGD("Found %s", rc522_picc_type_name(type));
*out_type = type;
return ESP_OK;
}
esp_err_t rc522_nxp_get_version(
const rc522_handle_t rc522, const rc522_picc_t *picc, rc522_nxp_picc_version_t *out_version)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(out_version == NULL);
RC522_LOGD("GET_VERSION");
uint8_t buffer[10]; // Combined buffer; response is 8-byte data + 2-byte CRC
buffer[0] = RC522_PICC_CMD_GETV;
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522, &(rc522_bytes_t) { .ptr = buffer, .length = 1 }, &crc));
buffer[1] = crc.lsb;
buffer[2] = crc.msb;
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = buffer, .length = 3 },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = buffer, .length = sizeof(buffer) },
};
RC522_RETURN_ON_ERROR(rc522_picc_transceive(rc522, &transaction, &result));
RC522_RETURN_ON_ERROR(rc522_nxp_check_for_nak(&result));
memcpy(out_version, buffer, sizeof(rc522_nxp_picc_version_t));
return ESP_OK;
}
esp_err_t rc522_nxp_read(
const rc522_handle_t rc522, const rc522_picc_t *picc, uint8_t address, uint8_t out_buffer[RC522_NXP_PAGE_SIZE * 4])
{
// Same protocol as MIFARE cards, so defer
return rc522_mifare_read(rc522, picc, address, out_buffer);
}
esp_err_t rc522_nxp_fast_read(const rc522_handle_t rc522, const rc522_picc_t *picc, uint8_t start_page,
uint8_t end_page, rc522_nxp_fast_read_data_t *out_buffer)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(out_buffer == NULL);
RC522_CHECK(!rc522_nxp_type_has_fast_read(picc->type));
// some sanity checks - valid range, output buffer sufficiently large
RC522_CHECK(start_page > end_page);
RC522_CHECK(out_buffer->buffer_size < (end_page - start_page + 1) * 4);
RC522_LOGD("NXP FAST_READ (start=%02" RC522_X ", end=%02" RC522_X ")", start_page, end_page);
uint8_t cmd_buffer[5] = { RC522_NXP_FAST_READ, start_page, end_page, 0, 0 };
uint8_t byte_count = (end_page - start_page + 1) * 4;
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522,
&(rc522_bytes_t) {
.ptr = cmd_buffer,
.length = 3,
},
&crc));
cmd_buffer[3] = crc.lsb;
cmd_buffer[4] = crc.msb;
// I'd rather not malloc() here, but we need extra space for the CRC which
// we're not guaranteed to have in out_buffer
// TODO: Allow for separate CRC fetch and processing to avoid this?
uint8_t *recv_buffer = malloc(byte_count + 2); // Allow for CRC_A
RC522_CHECK_AND_RETURN(recv_buffer == NULL, ESP_ERR_NO_MEM);
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
.check_crc = true,
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = recv_buffer, .length = byte_count + 2 },
};
// Bunch of manual handling here to make sure free() is called
esp_err_t ret = rc522_picc_transceive(rc522, &transaction, &result);
if (ret != ESP_OK) {
free(recv_buffer);
return ret;
}
else if ((result.bytes.length - 2) != byte_count) {
free(recv_buffer);
return ESP_FAIL;
}
memcpy(out_buffer->bytes, recv_buffer, byte_count);
out_buffer->read_size = byte_count;
free(recv_buffer);
return ESP_OK;
}
esp_err_t rc522_nxp_write(
const rc522_handle_t rc522, const rc522_picc_t *picc, uint8_t address, const uint8_t buffer[RC522_NXP_PAGE_SIZE])
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(buffer == NULL);
RC522_CHECK(!rc522_nxp_type_has_write(picc->type));
RC522_LOGD("NXP WRITE (address=%02" RC522_X ")", address);
uint8_t cmd_buffer[RC522_NXP_PAGE_SIZE + 4] = { 0 };
cmd_buffer[0] = RC522_NXP_WRITE;
cmd_buffer[1] = address;
memcpy(&cmd_buffer[2], buffer, RC522_NXP_PAGE_SIZE);
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522,
&(rc522_bytes_t) {
.ptr = cmd_buffer,
.length = sizeof(cmd_buffer) - 2,
},
&crc));
cmd_buffer[2 + RC522_NXP_PAGE_SIZE] = crc.lsb;
cmd_buffer[2 + RC522_NXP_PAGE_SIZE + 1] = crc.msb;
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
RC522_RETURN_ON_ERROR(rc522_picc_transceive(rc522, &transaction, &result));
return rc522_nxp_check_for_nak(&result);
}
esp_err_t rc522_nxp_read_cnt(
const rc522_handle_t rc522, const rc522_picc_t *picc, uint8_t counter_no, uint32_t *out_count)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(out_count == NULL);
RC522_CHECK(!rc522_nxp_type_has_read_cnt(picc->type));
RC522_LOGD("NXP READ_CNT (counter=%02" RC522_X ")", counter_no);
uint8_t cmd_buffer[5] = {
// send(4)/recv(5) buffer
RC522_NXP_READ_CNT,
counter_no,
0,
0, // CRC
0 // Space for reply (3 bytes + CRC)
};
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522,
&(rc522_bytes_t) {
.ptr = cmd_buffer,
.length = sizeof(cmd_buffer) - 2,
},
&crc));
cmd_buffer[2] = crc.lsb;
cmd_buffer[3] = crc.msb;
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = cmd_buffer, .length = 4 },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
RC522_RETURN_ON_ERROR(rc522_picc_transceive(rc522, &transaction, &result));
RC522_RETURN_ON_ERROR(rc522_nxp_check_for_nak(&result));
// TODO: Verify this counter is correct
*out_count = (cmd_buffer[2] << 16) | (cmd_buffer[1] << 8) | cmd_buffer[0];
return ESP_OK;
}
esp_err_t rc522_nxp_pwd_auth(const rc522_handle_t rc522, const rc522_picc_t *picc,
const uint8_t pwd[RC522_NXP_PWD_SIZE], const uint8_t pack[RC522_NXP_PACK_SIZE], rc522_picc_state_t *out_state)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(pwd == NULL);
RC522_CHECK(pack == NULL);
RC522_CHECK(!rc522_nxp_type_has_pwd_auth(picc->type));
RC522_LOGD("NXP PWD_AUTH");
uint8_t cmd_buffer[RC522_NXP_PWD_SIZE + 3] = { 0 }; // send(11)/recv(4) buffer
cmd_buffer[0] = RC522_NXP_PWD_AUTH;
memcpy(&cmd_buffer[1], pwd, RC522_NXP_PWD_SIZE);
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522,
&(rc522_bytes_t) {
.ptr = cmd_buffer,
.length = sizeof(cmd_buffer) - 2,
},
&crc));
cmd_buffer[1 + RC522_NXP_PWD_SIZE] = crc.lsb;
cmd_buffer[1 + RC522_NXP_PWD_SIZE + 1] = crc.msb;
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
// If authentication fails (timeout or NAK), the card will HALT, so assume
// it has until we know otherwise
*out_state = RC522_PICC_STATE_HALT;
RC522_RETURN_ON_ERROR(rc522_picc_transceive(rc522, &transaction, &result));
RC522_RETURN_ON_ERROR(rc522_nxp_check_for_nak(&result));
// Successful authentication, set state
*out_state = RC522_PICC_STATE_AUTHENTICATED;
// Validate the PACK - not critical to authenticate the card, but good
// practice to verify
RC522_CHECK_AND_RETURN(memcmp(pack, cmd_buffer, RC522_NXP_PACK_SIZE) != 0, RC522_ERR_NXP_PACK_MISMATCH);
*out_state = RC522_PICC_STATE_AUTHENTICATED;
return ESP_OK;
}
esp_err_t rc522_nxp_read_sig(const rc522_handle_t rc522, const rc522_picc_t *picc, rc522_nxp_sig_t *out_sig)
{
RC522_CHECK(rc522 == NULL);
RC522_CHECK(picc == NULL);
RC522_CHECK(out_sig == NULL);
uint8_t sig_size = rc522_nxp_type_sig_size(picc->type);
RC522_CHECK(sig_size == 0);
RC522_CHECK(out_sig->buffer_size < sig_size);
RC522_LOGD("NXP READ_SIG (size=%d)", sig_size);
uint8_t cmd_buffer[4] = {
RC522_NXP_READ_SIG,
0,
0,
0 // CRC
};
rc522_pcd_crc_t crc = { 0 };
RC522_RETURN_ON_ERROR(rc522_pcd_calculate_crc(rc522,
&(rc522_bytes_t) {
.ptr = cmd_buffer,
.length = sizeof(cmd_buffer) - 2,
},
&crc));
cmd_buffer[2] = crc.lsb;
cmd_buffer[3] = crc.msb;
// TODO: Combine to single malloc() for both buffers?
// Again, I'd rather not do a large malloc() here, but we need the space for
// CRC. See TODO in FAST_READ
uint8_t *recv_buffer = malloc(sig_size + 2); // +2 for CRC
RC522_CHECK_AND_RETURN(recv_buffer == NULL, ESP_ERR_NO_MEM);
rc522_picc_transaction_t transaction = {
.bytes = { .ptr = cmd_buffer, .length = sizeof(cmd_buffer) },
};
rc522_picc_transaction_result_t result = {
.bytes = { .ptr = recv_buffer, .length = sig_size + 2 },
};
esp_err_t ret = rc522_picc_transceive(rc522, &transaction, &result);
if (ret != ESP_OK) {
free(recv_buffer);
return ret;
}
ret = rc522_nxp_check_for_nak(&result);
if (ret != ESP_OK) {
free(recv_buffer);
return ret;
}
memcpy(out_sig->bytes, recv_buffer, sig_size);
out_sig->sig_size = sig_size;
free(recv_buffer);
return ESP_OK;
}