ntag.h

Go to the documentation of this file.

#pragma once
#include <wut.h>
#include <nfc/nfc.h>
#include <nn/ffl/miidata.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef int32_t NTAGError;
typedef struct NTAGFormatSettings NTAGFormatSettings;
typedef struct NTAGNoftHeader NTAGNoftHeader;
typedef struct NTAGInfoHeader NTAGInfoHeader;
typedef struct NTAGAreaHeader NTAGAreaHeader;
typedef struct NTAGAreaInfo NTAGAreaInfo;
typedef struct NTAGData NTAGData;
typedef struct NTAGInfoT2T NTAGInfoT2T;
typedef struct NTAGApplicationDataT2T NTAGApplicationDataT2T;
typedef struct NTAGRawDataT2T NTAGRawDataT2T;
typedef struct NTAGRawDataContainerT2T NTAGRawDataContainerT2T;
typedef struct NTAGDataT2T NTAGDataT2T;
 
struct NTAGFormatSettings
{
   uint8_t version;
   WUT_PADDING_BYTES(0x3);
   uint32_t makerCode;
   uint32_t identifyCode;
   WUT_PADDING_BYTES(0x1C);
};
WUT_CHECK_OFFSET(NTAGFormatSettings, 0x0, version);
WUT_CHECK_OFFSET(NTAGFormatSettings, 0x4, makerCode);
WUT_CHECK_OFFSET(NTAGFormatSettings, 0x8, identifyCode);
WUT_CHECK_SIZE(NTAGFormatSettings, 0x28);
 
struct WUT_PACKED NTAGNoftHeader
{
   uint32_t magic;
   uint8_t version;
   uint16_t writeCount;
   uint8_t unknown;
};
WUT_CHECK_OFFSET(NTAGNoftHeader, 0x0, magic);
WUT_CHECK_OFFSET(NTAGNoftHeader, 0x4, version);
WUT_CHECK_OFFSET(NTAGNoftHeader, 0x5, writeCount);
WUT_CHECK_OFFSET(NTAGNoftHeader, 0x7, unknown);
WUT_CHECK_SIZE(NTAGNoftHeader, 0x8);
 
struct NTAGInfoHeader
{
   uint16_t rwHeaderOffset;
   uint16_t rwSize;
   uint16_t roHeaderOffset;
   uint16_t roSize;
   NFCUid uid;
   uint8_t formatVersion;
};
WUT_CHECK_OFFSET(NTAGInfoHeader, 0x0, rwHeaderOffset);
WUT_CHECK_OFFSET(NTAGInfoHeader, 0x2, rwSize);
WUT_CHECK_OFFSET(NTAGInfoHeader, 0x4, roHeaderOffset);
WUT_CHECK_OFFSET(NTAGInfoHeader, 0x6, roSize);
WUT_CHECK_OFFSET(NTAGInfoHeader, 0x8, uid);
WUT_CHECK_OFFSET(NTAGInfoHeader, 0xF, formatVersion);
WUT_CHECK_SIZE(NTAGInfoHeader, 0x10);
 
struct NTAGAreaHeader
{
   uint16_t magic;
   uint16_t offset;
   uint16_t size;
   WUT_PADDING_BYTES(0x2);
   uint32_t makerCode;
   uint32_t identifyCode;
};
WUT_CHECK_OFFSET(NTAGAreaHeader, 0x0, magic);
WUT_CHECK_OFFSET(NTAGAreaHeader, 0x2, offset);
WUT_CHECK_OFFSET(NTAGAreaHeader, 0x4, size);
WUT_CHECK_OFFSET(NTAGAreaHeader, 0x8, makerCode);
WUT_CHECK_OFFSET(NTAGAreaHeader, 0xC, identifyCode);
WUT_CHECK_SIZE(NTAGAreaHeader, 0x10);
 
struct NTAGAreaInfo
{
   void *data;
   uint16_t size;
   WUT_PADDING_BYTES(0x2);
   uint32_t makerCode;
   uint32_t identifyCode;
   WUT_PADDING_BYTES(0x20);
};
WUT_CHECK_OFFSET(NTAGAreaInfo, 0x0, data);
WUT_CHECK_OFFSET(NTAGAreaInfo, 0x4, size);
WUT_CHECK_OFFSET(NTAGAreaInfo, 0x8, makerCode);
WUT_CHECK_OFFSET(NTAGAreaInfo, 0xC, identifyCode);
WUT_CHECK_SIZE(NTAGAreaInfo, 0x30);
 
struct NTAGData
{
   NFCUid uid;
   uint8_t readOnly;
   uint8_t formatVersion;
   WUT_PADDING_BYTES(0x3);
   NTAGAreaInfo rwInfo;
   NTAGAreaInfo roInfo;
   WUT_PADDING_BYTES(0x20);
};
WUT_CHECK_OFFSET(NTAGData, 0x00, uid);
WUT_CHECK_OFFSET(NTAGData, 0x07, readOnly);
WUT_CHECK_OFFSET(NTAGData, 0x08, formatVersion);
WUT_CHECK_OFFSET(NTAGData, 0x0C, rwInfo);
WUT_CHECK_OFFSET(NTAGData, 0x3C, roInfo);
WUT_CHECK_SIZE(NTAGData, 0x8C);
 
struct WUT_PACKED NTAGInfoT2T
{
   uint8_t magic;
   uint16_t writes;
   uint8_t figureVersion;
   uint8_t flags;
   uint8_t characterID[3];
   uint16_t numberingID;
   uint8_t figureType;
   uint8_t seriesID;
   uint32_t unknown;
   uint16_t applicationAreaWrites;
   uint16_t crcCounter;
   uint32_t crc;
   uint8_t fontRegion;
   uint16_t name[10];
   FFLStoreData mii;
   uint8_t country;
   uint16_t setupDate;
   uint16_t lastWriteDate;
   uint32_t accessID;
   uint64_t titleID;
   uint8_t reserved[0x1FC];
};
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x00, magic);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x01, writes);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x03, figureVersion);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x04, flags);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x05, characterID);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x08, numberingID);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0A, figureType);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0B, seriesID);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x0C, unknown);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x10, applicationAreaWrites);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x12, crcCounter);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x14, crc);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x18, fontRegion);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x19, name);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x2D, mii);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x8D, country);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x8E, setupDate);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x90, lastWriteDate);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x92, accessID);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x96, titleID);
WUT_CHECK_OFFSET(NTAGInfoT2T, 0x9E, reserved);
WUT_CHECK_SIZE(NTAGInfoT2T, 0x29a);
 
struct NTAGApplicationDataT2T
{
   uint16_t size;
   uint8_t data[0xD8];
};
WUT_CHECK_OFFSET(NTAGApplicationDataT2T, 0x00, size);
WUT_CHECK_OFFSET(NTAGApplicationDataT2T, 0x02, data);
WUT_CHECK_SIZE(NTAGApplicationDataT2T, 0xDA);
 
struct NTAGRawDataT2T
{
   uint8_t uid[9];
   uint8_t internal;
   uint8_t lockBytes[2];
   uint8_t capabilityContainer[4];
   struct WUT_PACKED {
      uint8_t magic;
      uint16_t writes;
      uint8_t figureVersion;
      uint8_t flags;
      uint8_t country;
      uint16_t crcCounter;
      uint16_t setupDate;
      uint16_t lastWriteDate;
      uint32_t crc;
      uint16_t name[10];
   } section0;
   struct WUT_PACKED {
      uint8_t tagHmac[0x20];
      uint8_t characterID[3];
      uint8_t figureType;
      uint16_t numberingID;
      uint8_t seriesID;
      uint8_t formatVersion;
      uint32_t unknown;
      uint8_t keygenSalt[0x20];
      uint8_t dataHmac[0x20];
   } section1;
   struct WUT_PACKED {
      FFLStoreData mii;
      uint64_t titleID;
      uint16_t applicationAreaWrites;
      uint32_t accessID;
      uint8_t reserved[0x22];
   } section2;
   uint8_t applicationData[0xD8];
   uint8_t dynamicLock[3];
   uint8_t reserved0;
   uint8_t cfg0[4];
   uint8_t cfg1[4];
   uint8_t pwd[4];
   uint8_t pack[2];
   uint8_t reserved1[2];
};
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x000, uid);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x009, internal);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x00A, lockBytes);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x00C, capabilityContainer);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x010, section0.magic);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x011, section0.writes);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x013, section0.figureVersion);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x014, section0.flags);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x015, section0.country);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x016, section0.crcCounter);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x018, section0.setupDate);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x01A, section0.lastWriteDate);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x01C, section0.crc);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x020, section0.name);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x034, section1.tagHmac);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x054, section1.characterID);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x057, section1.figureType);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x058, section1.numberingID);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05A, section1.seriesID);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05B, section1.formatVersion);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x05C, section1.unknown);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x060, section1.keygenSalt);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x080, section1.dataHmac);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x0A0, section2.mii);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x100, section2.titleID);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x108, section2.applicationAreaWrites);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x10A, section2.accessID);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x10E, section2.reserved);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x130, applicationData);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x208, dynamicLock);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x20B, reserved0);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x20C, cfg0);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x210, cfg1);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x214, pwd);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x218, pack);
WUT_CHECK_OFFSET(NTAGRawDataT2T, 0x21A, reserved1);
WUT_CHECK_SIZE(NTAGRawDataT2T, 0x21C);
 
struct NTAGRawDataContainerT2T
{
   uint16_t size;
   NTAGRawDataT2T data;
};
WUT_CHECK_OFFSET(NTAGRawDataContainerT2T, 0x00, size);
WUT_CHECK_OFFSET(NTAGRawDataContainerT2T, 0x02, data);
WUT_CHECK_SIZE(NTAGRawDataContainerT2T, 0x21E);
 
struct NTAGDataT2T
{
   NFCTagInfo tagInfo;
   uint8_t formatVersion;
   NTAGInfoT2T info;
   NTAGApplicationDataT2T appData;
   NTAGRawDataContainerT2T raw;
   WUT_PADDING_BYTES(0x20);
};
WUT_CHECK_OFFSET(NTAGDataT2T, 0x000, tagInfo);
WUT_CHECK_OFFSET(NTAGDataT2T, 0x02D, formatVersion);
WUT_CHECK_OFFSET(NTAGDataT2T, 0x02E, info);
WUT_CHECK_OFFSET(NTAGDataT2T, 0x2C8, appData);
WUT_CHECK_OFFSET(NTAGDataT2T, 0x3A2, raw);
WUT_CHECK_SIZE(NTAGDataT2T, 0x5E0);
 
typedef void
(*NTAGCallbackFn)(VPADChan chan,
                  NTAGError error,
                  void *userContext);
 
typedef void
(*NTAGReadCallbackFn)(VPADChan chan,
                      NTAGError error,
                      NTAGData *data,
                      void *userContext);
 
typedef void
(*NTAGReadT2TCallbackFn)(VPADChan chan,
                         NTAGError error,
                         NTAGDataT2T *data,
                         void *userContext);
 
typedef void
(*NTAGReadT2TRawDataCallbackFn)(VPADChan chan,
                                NTAGError error,
                                NFCTagInfo *tagInfo,
                                NTAGRawDataContainerT2T *rawData,
                                void *userContext);
 
NTAGError
NTAGInit(VPADChan chan);
 
NTAGError
NTAGInitEx(VPADChan chan);
 
BOOL
NTAGIsInit(VPADChan chan);
 
void
NTAGProc(VPADChan chan);
 
NTAGError
NTAGShutdown(VPADChan chan);
 
NTAGError
NTAGAbort(VPADChan chan,
          NTAGCallbackFn callback,
          void *userContext);
 
static inline NFCError
NTAGDetect(VPADChan chan,
           uint32_t timeout,
           NFCDetectCallbackFn callback,
           void *userContext)
{
   return NFCDetect(chan, timeout, callback, userContext);
}
// NTAGError
// NTAGDetect(VPADChan chan,
//            uint32_t timeout,
//            NTAGDetectCallbackFn callback,
//            void *userContext);
 
NTAGError
NTAGFormat(VPADChan chan,
           uint32_t timeout,
           NFCUid *uid,
           uint32_t rwSize,
           void *rwData,
           NTAGCallbackFn callback,
           void *userContext);
 
NTAGError
NTAGSetReadOnly(VPADChan chan,
                uint32_t timeout,
                NFCUid *uid,
                NFCUid *uidMask,
                BOOL readOnly,
                NTAGCallbackFn callback,
                void *userContext);
 
void
NTAGSetTagDetectCallback(VPADChan chan,
                         NFCTagDetectCallbackFn callback,
                         void *userContext);
 
void
NTAGSetFormatSettings(NTAGFormatSettings *settings);
 
NTAGError
NTAGRead(VPADChan chan,
         uint32_t timeout,
         NFCUid *uid,
         NFCUid *uidMask,
         NTAGReadCallbackFn callback,
         void *userContext);
 
NTAGError
NTAGReadT2T(VPADChan chan,
            uint32_t timeout,
            NFCUid *uid,
            NFCUid *uidMask,
            NTAGReadT2TCallbackFn callback,
            void *userContext);
 
NTAGError
NTAGReadT2TRawData(VPADChan chan,
                   uint32_t timeout,
                   NFCUid *uid,
                   NFCUid *uidMask,
                   NTAGReadT2TRawDataCallbackFn callback,
                   void *userContext);
 
NTAGError
NTAGWrite(VPADChan chan,
          uint32_t timeout,
          NFCUid *uid,
          uint32_t rwSize,
          void *rwData,
          NTAGCallbackFn callback,
          void *userContext);
 
NTAGError
NTAGWriteT2T(VPADChan chan,
             uint32_t timeout,
             NFCUid *uid,
             NTAGRawDataContainerT2T *dataContainer,
             NTAGCallbackFn callback,
             void *userContext);
 
NTAGError
NTAGWriteT2TConfigArea(VPADChan chan,
                       uint32_t timeout,
                       NFCUid *uid,
                       uint32_t *cfg0,
                       uint32_t *cfg1,
                       uint32_t *pwd,
                       uint16_t *pack,
                       NTAGCallbackFn callback,
                       void *userContext);
 
NTAGError
NTAGWriteT2TLockArea(VPADChan chan,
                     uint32_t timeout,
                     NFCUid *uid,
                     uint32_t *lockBytes,
                     uint32_t *dynamicLock,
                     uint32_t *cc,
                     NTAGCallbackFn callback,
                     void *userContext);
 
NTAGError
NTAGWriteT2TRawData(VPADChan chan,
                    uint32_t timeout,
                    NFCUid *uid,
                    NTAGRawDataT2T *data,
                    NTAGCallbackFn callback,
                    void *userContext);
 
NTAGError
NTAGWriteT2TRawDataEx(VPADChan chan,
                      uint32_t timeout,
                      NFCUid *uid,
                      NTAGRawDataT2T *data,
                      NTAGCallbackFn callback,
                      void *userContext,
                      uint8_t authenticate);
 
NTAGError
NTAGWriteT2TWithConvert(VPADChan chan,
                        uint32_t timeout,
                        NFCUid *uid,
                        NTAGDataT2T *data,
                        NTAGCallbackFn callback,
                        void *userContext);
 
NTAGError
NTAGConvertT2T(NTAGDataT2T *out,
               NTAGDataT2T *in);
 
NTAGError
NTAGParseHeader(void *data,
                NTAGNoftHeader *outNoftHeader,
                NTAGInfoHeader *outInfoHeader,
                NTAGAreaHeader *outRwHeader,
                NTAGAreaHeader *outRoHeader);
 
#ifdef __cplusplus
}
#endif