nfcf.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_F_NFCF_HPP
#define M5_UNIT_UNIFIED_NFC_NFC_F_NFCF_HPP
 
#include "nfc/nfc.hpp"
#include <cstdint>
#include <string>
#include <array>
 
namespace m5 {
namespace nfc {
namespace f {
 
enum class Type : uint8_t {
    Unknown,         
    FeliCaStandard,  
    FeliCaLite,      
    FeliCaLiteS,     
    FeliCaPlug,      
    //    FeliCaLink,      //!< Link
};
 
inline m5::nfc::NFCForumTag get_nfc_forum_tag_type(const Type t)
{
    return (t != Type::Unknown) ? NFCForumTag::Type3 : NFCForumTag::None;
}
 
using Format = uint8_t;
constexpr Format format_nfcip1{0x0001};       
constexpr Format format_lite{0x0002};         
constexpr Format format_private{0x0004};      
constexpr Format format_ndef{0x0008};         
constexpr Format format_shared{0x0010};       
constexpr Format format_secure{0x0020};       
constexpr Format format_felica_plug{0x0040};  
 
enum class CommandCode : uint8_t {
    Polling,
    RequestService         = 0x02,
    RequestResponse        = 0x04,
    ReadWithoutEncryption  = 0x06,
    WriteWithoutEncryption = 0x08,
    RequestSystemCode      = 0x0C,
};
 
enum class ResponseCode : uint8_t {
    Polling                = 0x01,
    RequestService         = 0x03,
    RequestResponse        = 0x05,
    ReadWithoutEncryption  = 0x07,
    WriteWithoutEncryption = 0x09,
    RequestSystemCode      = 0x0D,
};
 
constexpr uint16_t system_code_wildcard{0xFFFF};          
constexpr uint16_t system_code_ndef{0x12FC};              
constexpr uint16_t system_code_felica_secure_id{0x957A};  
constexpr uint16_t system_code_shared{0xFE00};            
constexpr uint16_t system_code_lite{0x88B4};              
constexpr uint16_t system_code_felica_plug{0xFEE1};       
 
enum class RequestCode : uint8_t {
    None,                      
    SystemCode,                
    CommunicationPerformance,  
};
 
enum class TimeSlot : uint8_t { Slot1, Slot2, Slot4 = 0x03, Slot8 = 0x07, Slot16 = 0x0F };
 
inline constexpr uint8_t timeslot_to_slot(const TimeSlot ts)
{
    return (ts == TimeSlot::Slot16)  ? 16
           : (ts == TimeSlot::Slot8) ? 8
           : (ts == TimeSlot::Slot4) ? 4
           : (ts == TimeSlot::Slot2) ? 2
           : (ts == TimeSlot::Slot1) ? 1
                                     : 0;  //    Illegal
}
 
// Random service
constexpr uint16_t service_random_read_write_auth{0x0008};  
constexpr uint16_t service_random_read_write{0x0009};       
constexpr uint16_t service_random_read_auth{0x000A};        
constexpr uint16_t service_random_read{0x000B};             
// Cyclic service
constexpr uint16_t service_cyclic_read_write_auth{0x000C};  
constexpr uint16_t service_cyclic_read_write{0x000D};       
constexpr uint16_t service_cyclic_read_auth{0x000E};        
constexpr uint16_t service_cyclic_read{0x000F};             
// Parse service
constexpr uint16_t service_parse_direct_auth{0x0100};
constexpr uint16_t service_parse_direct{0x0101};
constexpr uint16_t service_parse_cacheback_auth{0x0102};
constexpr uint16_t service_parse_cacheback{0x0103};
constexpr uint16_t service_parse_decrement_auth{0x0104};
constexpr uint16_t service_parse_decrement{0x0105};
constexpr uint16_t service_parse_increment_auth{0x0106};
constexpr uint16_t service_parse_increment{0x0107};
 
struct block_t {
    uint8_t pad{};
    uint8_t header{};   
    uint16_t number{};  
 
    inline constexpr block_t() : block_t(0)
    {
    }
 
    // Allow implicit type conversion
    inline constexpr block_t(const uint16_t num, const uint8_t access = 0, const uint8_t order = 0)
        : header{(uint8_t)(((num > 0xFF) ? 0x00 : 0x80) | ((access & 0x07) << 4) | (order & 0x0F))}, number{num}
    {
    }
 
    static block_t from(const uint8_t v[3])
    {
        block_t b{0xFFFFu};
        if (v) {
            b.header = v[0];
            b.number = v[1];
            if (b.is_3byte()) {
                b.number |= (uint16_t)v[2] << 8;
            }
        }
        return b;
    }
 
    inline constexpr bool is_2byte() const
    {
        return (header & 0x80) != 0;
    }
    inline constexpr bool is_3byte() const
    {
        return (header & 0x80) == 0;
    }
    inline constexpr uint8_t access_mode() const
    {
        return (header >> 4) & 0x07;
    }
    inline constexpr uint8_t order() const
    {
        return (header & 0x0F);
    }
    inline constexpr uint16_t block() const
    {
        return number;
    }
 
    inline void block(const uint16_t num)
    {
        number = num;
        header = (header & ~0x80) | (num > 0xFF ? 0x00 : 0x80);
    }
    inline void access_mode(const uint8_t a)
    {
        header = (header & ~(0x07 << 4)) | ((a & 0x07) << 4);
    }
    inline void order(const uint8_t o)
    {
        header = (header & ~0x0F) | (o & 0x0F);
    }
 
    inline operator uint16_t() const
    {
        return block();
    }
 
    uint8_t store(uint8_t buf[3]) const
    {
        uint8_t idx{};
        buf[idx++] = header;
        buf[idx++] = number & 0xFF;
        if (is_3byte()) {
            buf[idx++] = number >> 8;
        }
        return idx;
    }
};
 
namespace standard {
enum class Mode : uint8_t {
    Mode0,  
    Mode1,  
    Mode2,  
    Mode3,  
 
};
}  // namespace standard
 
namespace lite {
 
constexpr block_t S_PAD0{0x00};
constexpr block_t S_PAD1{0x01};
constexpr block_t S_PAD2{0x02};
constexpr block_t S_PAD3{0x03};
constexpr block_t S_PAD4{0x04};
constexpr block_t S_PAD5{0x05};
constexpr block_t S_PAD6{0x06};
constexpr block_t S_PAD7{0x07};
constexpr block_t S_PAD8{0x08};
constexpr block_t S_PAD9{0x09};
constexpr block_t S_PAD10{0x0A};
constexpr block_t S_PAD11{0x0B};
constexpr block_t S_PAD12{0X0C};
constexpr block_t S_PAD13{0x0D};
constexpr block_t REG{0x0E};
constexpr block_t RC{0x80};
constexpr block_t MAC{0x81};
constexpr block_t ID{0x082};
constexpr block_t D_ID{0x83};
constexpr block_t SER_C{0x84};
constexpr block_t SYS_C{0x85};
constexpr block_t CKV{0x86};
constexpr block_t CK{0x87};
constexpr block_t MC{0x88};
 
}  // namespace lite
 
namespace lite_s {
 
enum class Mode : uint8_t {
    Mode00,  
    Mode01,  
    Mode10,  
    Mode11,  
};
 
constexpr block_t S_PAD0{0x00};   // Same as Lite
constexpr block_t S_PAD1{0x01};   // Same as Lite
constexpr block_t S_PAD2{0x02};   // Same as Lite
constexpr block_t S_PAD3{0x03};   // Same as Lite
constexpr block_t S_PAD4{0x04};   // Same as Lite
constexpr block_t S_PAD5{0x05};   // Same as Lite
constexpr block_t S_PAD6{0x06};   // Same as Lite
constexpr block_t S_PAD7{0x07};   // Same as Lite
constexpr block_t S_PAD8{0x08};   // Same as Lite
constexpr block_t S_PAD9{0x09};   // Same as Lite
constexpr block_t S_PAD10{0x0A};  // Same as Lite
constexpr block_t S_PAD11{0x0B};  // Same as Lite
constexpr block_t S_PAD12{0X0C};  // Same as Lite
constexpr block_t S_PAD13{0x0D};  // Same as Lite
constexpr block_t REG{0x0E};      // Same as Lite
constexpr block_t RC{0x80};       // Same as Lite
constexpr block_t MAC{0x81};      // Same as Lite
constexpr block_t ID{0x082};      // Same as Lite
constexpr block_t D_ID{0x83};     // Same as Lite
constexpr block_t SER_C{0x84};    // Same as Lite
constexpr block_t SYS_C{0x85};    // Same as Lite
constexpr block_t CKV{0x86};      // Same as Lite
constexpr block_t CK{0x87};       // Same as Lite
constexpr block_t MC{0x88};       // Same as Lite
constexpr block_t WCNT{0x90};
constexpr block_t MAC_A{0x91};
constexpr block_t STATE{0x92};
constexpr block_t CRC_CHECK{0xA0};
 
}  // namespace lite_s
 
uint16_t get_maximum_block(const Type t);
uint16_t get_number_of_user_blocks(const Type t);
inline uint16_t get_user_area_size(const Type t)
{
    return 16 * get_number_of_user_blocks(t);
}
uint16_t get_first_user_block(const Type t);
uint16_t get_last_user_block(const Type t);
inline bool is_user_block(const Type t, const uint16_t block)
{
    return (block >= get_first_user_block(t)) && (block <= get_last_user_block(t));
}
uint8_t get_maximum_read_blocks(const Type t);
uint8_t get_maximum_write_blocks(const Type t);
 
bool is_read_only_lite(const block_t block);
bool is_read_only_lite_s(const block_t block);
bool can_read_lite(const block_t block);
bool can_read_lite_s(const block_t block);
 
constexpr uint16_t NODE_SYSTEM_KEY{0xFFFF};   
constexpr uint16_t KEY_VERIOSN_NONE{0xFFFF};  
 
constexpr uint8_t FELICA_ID_LENGTH{8};
constexpr uint8_t FELICA_MAX_BLOCKS{8};
constexpr uint16_t FELICA_MAX_PACKET_LENGTH_REQUEST_SERVICE{1 + 8 + 1 + 2 * 255};
constexpr uint16_t FELICA_MAX_PACKET_LENGTH_REQUEST_RESPONSE{1 + 8 + 1};
constexpr uint16_t FELICA_MAX_PACKET_LENGTH_REQUEST_SYSTEM_CODE{1 + 8 + 1 + 2 * 255};
 
struct PICC {
    union {
        uint8_t m[16]{};
        struct {
            uint8_t idm[FELICA_ID_LENGTH];  
            uint8_t pmm[FELICA_ID_LENGTH];  
        };
    };
    uint16_t request_data{};     
    RequestCode request_code{};  
    Type type{};                 
    Format format{};             
    uint8_t _pad{};              // padding
    uint16_t dfc_format{};       
    uint16_t emulation_sc{};     
 
    bool valid() const;
    bool validEmulation() const;
 
    inline uint16_t userAreaSize() const
    {
        return valid() ? get_user_area_size(type) : 0;
    }
    inline uint16_t firstUserBlock() const
    {
        return valid() ? get_first_user_block(type) : 0xFFFF;
    }
    inline uint16_t lastUserBlock() const
    {
        return valid() ? get_last_user_block(type) : 0xFFFF;
    }
    inline bool isUserBlock(const block_t block) const
    {
        return is_user_block(type, block);
    }
 
    inline uint8_t maximumReadBlocks() const
    {
        return get_maximum_read_blocks(type);
    }
    inline uint8_t maximumWriteBlocks() const
    {
        return get_maximum_write_blocks(type);
    }
 
    inline bool checkFormat(const Format f) const
    {
        return (format & f) != 0;
    }
    inline bool supportsNDEF() const
    {
        return checkFormat(format_ndef);
    }
 
    inline NFCForumTag nfcForumTagType() const
    {
        return get_nfc_forum_tag_type(type);
    }
 
    bool emulate(const Type t, const uint8_t idm[FELICA_ID_LENGTH], const uint8_t pmm[FELICA_ID_LENGTH],
                 const uint16_t sc = 0);
 
    std::string idmAsString() const;
    std::string pmmAsString() const;
    std::string typeAsString() const;
};
 
bool operator==(const PICC& a, const PICC& b);
inline bool operator!=(const PICC& a, const PICC& b)
{
    return !(a == b);
}
 
// constexpr uint32_t TIMEOUT_POLLING{3};
constexpr uint32_t TIMEOUT_POLLING{5};
constexpr uint32_t TIMEOUT_POLLING_PICC{2};  // 2 ms per PICC
 
union REG {
    uint8_t reg[16]{};
    struct {
        uint8_t reg_a[4];  // RegA (LE)
        uint8_t reg_b[4];  // RegB (LE)
        uint8_t reg_c[8];  // RegC (BE)
    } __attribute__((packed));
 
    REG()
    {
    }
 
    inline uint32_t regA() const
    {
        return ((uint32_t)reg_a[3] << 24) | ((uint32_t)reg_a[2] << 16) | ((uint32_t)reg_a[1] << 8) |
               ((uint32_t)reg_a[0]);
    }
    inline uint32_t regB() const
    {
        return ((uint32_t)reg_b[3] << 24) | ((uint32_t)reg_b[2] << 16) | ((uint32_t)reg_b[1] << 8) |
               ((uint32_t)reg_b[0]);
    }
    inline uint64_t regC() const
    {
        return ((uint64_t)reg_c[0] << 56) | ((uint64_t)reg_c[1] << 48) | ((uint64_t)reg_c[2] << 40) |
               ((uint64_t)reg_c[3] << 32) | ((uint64_t)reg_c[4] << 24) | ((uint64_t)reg_c[5] << 16) |
               ((uint64_t)reg_c[6] << 8) | ((uint64_t)reg_c[7]);
    }
    void regA(const uint32_t v)
    {
        reg_a[0] = v & 0xFF;
        reg_a[1] = v >> 8;
        reg_a[2] = v >> 16;
        reg_a[3] = v >> 24;
    }
    void regB(const uint32_t v)
    {
        reg_b[0] = v & 0xFF;
        reg_b[1] = v >> 8;
        reg_b[2] = v >> 16;
        reg_b[3] = v >> 24;
    }
    void regC(const uint64_t v)
    {
        reg_c[7] = v & 0xFF;
        reg_c[6] = v >> 8;
        reg_c[5] = v >> 16;
        reg_c[4] = v >> 24;
        reg_c[3] = v >> 32;
        reg_c[2] = v >> 40;
        reg_c[1] = v >> 48;
        reg_c[0] = v >> 56;
    }
 
    inline operator const uint8_t*() const
    {
        return reg;
    }
    inline operator uint8_t*()
    {
        return reg;
    }
} __attribute__((packed));
 
inline bool can_write_reg(const REG& o, const REG& n)
{
    return (o.regA() >= n.regA()) && (o.regB() >= n.regB());
}
 
 
bool make_session_key(uint8_t sk[16], const uint8_t ck[16], const uint8_t rc[16]);
 
bool generate_mac(uint8_t mac[8], const uint8_t* plain, uint32_t plain_len, const uint8_t* block_data,
                  uint32_t block_len, const uint8_t sk1[8], const uint8_t sk2[8], const uint8_t rc[16]);
 
bool make_personalized_card_key_lite_s(uint8_t card_key[16], const uint8_t master_key[24], const uint8_t id_block[16]);
 
 
}  // namespace f
}  // namespace nfc
}  // namespace m5
#endif