mifare.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_UNIFIED_NFC_NFC_A_MIFARE_HPP
#define M5_UNIT_UNIFIED_NFC_NFC_A_MIFARE_HPP
 
#include <cstdint>
#include <array>
 
namespace m5 {
namespace nfc {
namespace a {
namespace mifare {
 
constexpr std::array<uint8_t, 7> historical_bytes_mifare_plus_s    = {0xC1, 0x05, 0x2F, 0x2F, 0x00, 0x35, 0xC7};
constexpr std::array<uint8_t, 7> historical_bytes_mifare_plus_x_ev = {0xC1, 0x05, 0x2F, 0x2F, 0x01, 0xBC, 0xD6};
constexpr std::array<uint8_t, 7> historical_bytes_mifare_plus_se0  = {0xC1, 0x05, 0x21, 0x30, 0x00, 0xF6, 0xD1};
constexpr std::array<uint8_t, 7> historical_bytes_mifare_plus_se1  = {0xC1, 0x05, 0x21, 0x30, 0x10, 0xF6, 0xD1};
constexpr std::array<uint8_t, 7> historical_bytes_mifare_plus_se2  = {0xC1, 0x05, 0x21, 0x30, 0x00, 0x77, 0xC1};
 
namespace classic {
 
constexpr uint16_t MIFARE_CLASSIC_MAX_TX_LEN{32};
constexpr uint16_t MIFARE_CLASSIC_MAX_RX_LEN{32};
constexpr uint16_t MIFARE_CLASSIC_MAX_TX_WITH_CRC{MIFARE_CLASSIC_MAX_TX_LEN + 2};
constexpr uint16_t MIFARE_CLASSIC_MAX_RX_WITH_CRC{MIFARE_CLASSIC_MAX_RX_LEN + 2};
constexpr uint16_t MIFARE_CLASSIC_MAX_BITSTREAM_LEN{(9 * MIFARE_CLASSIC_MAX_TX_WITH_CRC + 7) / 8};
 
using Key = std::array<uint8_t, 6>;
 
constexpr Key DEFAULT_KEY{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
constexpr uint8_t READ_WRITE_BLOCK{0x00};              
constexpr uint8_t VALUE_BLOCK_NON_RECHARGEABLE{0x01};  
constexpr uint8_t VALUE_BLOCK_RECHARGEABLE{0x06};      
 
inline constexpr bool can_value_block_permission(const uint8_t permission)
{
    return (permission == 0x00) ||  // transport configuration
           (permission == 0x01) ||  // value block (Only read and decrement)
           (permission == 0x06);    // value block (Full operation)
}
 
inline constexpr bool is_sector_trailer_block(const uint16_t block)
{
    return (block < 128) ? (block & 0x03) == 0x03 : ((block - 128) & 0x0F) == 0x0F;
}
 
inline constexpr uint16_t get_sector_trailer_block(const uint16_t block)
{
    return (block < 128) ? (block | 0x03) : (block | 0x0F);
}
 
inline constexpr uint16_t get_sector(const uint16_t block)
{
    return (block < 128) ? (block >> 2) : 32 + ((block - 128) >> 4);
}
 
inline constexpr uint8_t get_permission_offset(const uint16_t block)
{
    return ((block < 128) ? (block & 0x03) : ((block - 128) & 0x0F) / 5) & 0x03;
}
 
inline constexpr uint16_t get_sector_trailer_block_from_sector(const uint16_t sector)
{
    return (sector < 32) ? (sector * 4U + 3U) : (128U + (sector - 32) * 16U + 15U);
}
 
bool decode_value_block(int32_t& value, uint8_t& addr, const uint8_t buf[16]);
const uint8_t* encode_value_block(uint8_t buf[16], const int32_t value, const uint8_t addr);
 
bool encode_access_bits(uint8_t abits[3], const uint8_t p0, const uint8_t p1, const uint8_t p2, const uint8_t p3);
inline bool encode_access_bits(uint8_t abits[3], const uint8_t permissions[4])
{
    return encode_access_bits(abits, permissions[0], permissions[1], permissions[2], permissions[3]);
}
bool decode_access_bits(uint8_t permissions[4], const uint8_t ab0, const uint8_t ab1, const uint8_t ab2);
inline bool decode_access_bits(uint8_t permissions[4], const uint8_t abits[3])
{
    return decode_access_bits(permissions, abits[0], abits[1], abits[2]);
}
 
}  // namespace classic
 
namespace desfire {
 
constexpr uint32_t DESFIRE_NDEF_APP_ID{0x000001};           
constexpr uint8_t DESFIRE_CC_FILE_NO{0x01};                 
constexpr uint8_t DESFIRE_NDEF_FILE_NO{0x02};               
constexpr uint8_t DESFIRE_NDEF_AID[] = {0x00, 0x00, 0x01};  
 
constexpr uint8_t DESFIRE_LIGHT_DF_NAME[] = {  
    0xA0, 0x00, 0x00, 0x03, 0x96, 0x56, 0x43, 0x41, 0x03, 0xF0, 0x15, 0x40, 0x00, 0x00, 0x00, 0x0B};
constexpr uint16_t DESFIRE_LIGHT_DF_FID{0xDF01};        
constexpr uint8_t DESFIRE_LIGHT_CC_FILE_NO{0x00};       
constexpr uint8_t DESFIRE_LIGHT_NDEF_FILE_NO{0x04};     
constexpr uint16_t DESFIRE_LIGHT_CC_FILE_ID{0xEF00};    
constexpr uint16_t DESFIRE_LIGHT_NDEF_FILE_ID{0xEF04};  
constexpr uint16_t DESFIRE_LIGHT_NDEF_FILE_SIZE{256};   
 
constexpr uint8_t DESFIRE_DEFAULT_KEY[16]{};  
 
constexpr int8_t access_denied{-1};
constexpr int8_t access_free{-2};
inline int8_t required_read_key_no_from_access_rights(const uint16_t access_rights)
{
    const uint8_t read_key = (access_rights >> 12) & 0x0F;
    const uint8_t rw_key   = (access_rights >> 4) & 0x0F;
    if (read_key == 0x0E) {
        return access_free;
    }
    if (read_key != 0x0F) {
        return read_key;
    }
    if (rw_key == 0x0E) {
        return access_free;
    }
    if (rw_key != 0x0F) {
        return rw_key;
    }
    return access_denied;
}
inline int8_t required_write_key_no_from_access_rights(const uint16_t access_rights)
{
    const uint8_t write_key = (access_rights >> 8) & 0x0F;  // Write
    const uint8_t rw_key    = (access_rights >> 4) & 0x0F;  // Read/Write
    if (write_key == 0x0E) {
        return access_free;
    }
    if (write_key != 0x0F) {
        return write_key;
    }
    if (rw_key == 0x0E) {
        return access_free;
    }
    if (rw_key != 0x0F) {
        return rw_key;
    }
    return access_denied;
}
 
}  // namespace desfire
 
namespace plus {
 
using AESKey = std::array<uint8_t, 16>;
constexpr AESKey DEFAULT_KEY{};  // All 0x00
constexpr AESKey DEFAULT_FF_KEY = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                                   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
}  // namespace plus
 
}  // namespace mifare
}  // namespace a
}  // namespace nfc
}  // namespace m5
#endif