nbt-cmd.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024-2026 Infineon Technologies AG
// SPDX-License-Identifier: MIT
 
#ifndef NBT_CMD_H
#define NBT_CMD_H
 
#include "infineon/nbt-apdu-lib.h"
#include "infineon/nbt-apdu.h"
#include "infineon/nbt-parse-response.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Function identifiers */
 
#define NBT_AUTHENTICATE_TAG               UINT8_C(0x01)
 
#define NBT_APPLET_VERSION                 UINT8_C(0x02)
 
#define NBT_AVAILABLE_MEMORY               UINT8_C(0x03)
 
#define NBT_CHANGE_PASSWORD                UINT8_C(0x04)
 
#define NBT_CREATE_PASSWORD                UINT8_C(0x05)
 
#define NBT_DELETE_PASSWORD                UINT8_C(0x06)
 
#define NBT_GET_DATA                       UINT8_C(0x07)
 
#define NBT_GET_FAP_BYTES                  UINT8_C(0x08)
 
#define NBT_READ_BINARY                    UINT8_C(0x09)
 
#define NBT_READ_FAP_WITH_PASSWORD         UINT8_C(0x0A)
 
#define NBT_PARSE_FAP_BYTES                UINT8_C(0x0B)
 
#define NBT_PASS_THROUGH_FETCH_DATA        UINT8_C(0x0C)
 
#define NBT_PASS_THROUGH_PUT_RESPONSE      UINT8_C(0x0D)
 
#define NBT_SELECT_APPLICATION             UINT8_C(0x0E)
 
#define NBT_SELECT_FILE_BY_ID              UINT8_C(0x0F)
 
#define NBT_UNBLOCK_PASSWORD               UINT8_C(0x10)
 
#define NBT_UPDATE_BINARY                  UINT8_C(0x11)
 
#define NBT_UPDATE_FAP_BYTES_WITH_PASSWORD UINT8_C(0x12)
 
#define NBT_UPDATE_RECURSIVE_BINARY        UINT8_C(0x13)
 
#define NBT_FAP_FILE_ID                    UINT16_C(0xE1AF)
 
#define NBT_NDEF_FILE_ID                   UINT16_C(0xE104)
 
#define NBT_TOTAL_FILE                     UINT8_C(0x07)
 
#define NBT_FAP_ACCESS_CONDITION_LENGTH    UINT8_C(0x06)
 
#define NBT_FILE_ID_LENGTH                 UINT8_C(0x02)
 
#define NBT_MAX_LE                         UINT16_C(0x00FF)
 
#define NBT_MAX_LC                         UINT16_C(0x00FF)
 
#define NBT_PASSWORD_ID_MASK               UINT8_C(0x1F)
 
#define NBT_SIZE_OF_FAP_FILE               UINT8_C(0x2A)
 
#define NBT_RECURSIVE_READ_INIT_OFFSET     UINT16_C(0x0000)
 
#define NBT_RECURSIVE_UPDATE_INIT_OFFSET   UINT16_C(0x0000)
 
#define NBT_RECURSIVE_READ_INIT_MSG_LEN    UINT8_C(0xFF)
 
typedef struct
{
    uint16_t file_id;
 
    uint8_t i2c_read_access_condition;
 
    uint8_t i2c_write_access_condition;
 
    uint8_t nfc_read_access_condition;
 
    uint8_t nfc_write_access_condition;
} nbt_file_access_policy_t;
 
typedef enum
{
    NBT_ACCESS_ALWAYS = UINT8_C(0x40),
 
    NBT_ACCESS_NEVER = UINT8_C(0x00),
 
    NBT_ACCESS_PASSWORD_PROTECTED = UINT8_C(0x80)
} nbt_access_condition;
 
typedef enum
{
    NBT_BIT_MASK_STATE_L4_EXIT = UINT16_C(0x0040), 
    NBT_BIT_MASK_STATE_L4_ENTRY = UINT16_C(0x0020), 
    NBT_BIT_MASK_STATE_FIELD_EXIT = UINT16_C(0x0010), 
    NBT_BIT_MASK_STATE_FIELD_ENTRY =
        UINT16_C(0x0008), 
    NBT_BIT_MASK_PASS_THROUGH_APDU_AVAILABLE =
        UINT16_C(0x0004), 
    NBT_BIT_MASK_LAYER_4_ACTIVE =
        UINT16_C(0x0002), 
    NBT_BIT_MASK_NFC_FIELD_IS_PRESENT =
        UINT16_C(0x0001) 
} nbt_bit_mask_for_pass_through_status_word;
 
ifx_status_t nbt_select_application(nbt_cmd_t *self);
 
ifx_status_t nbt_select_file(nbt_cmd_t *self, uint16_t file_id);
 
ifx_status_t nbt_select_file_with_password(nbt_cmd_t *self, uint16_t file_id,
                                           const ifx_blob_t *read_password,
                                           const ifx_blob_t *write_password);
 
ifx_status_t nbt_read_binary(nbt_cmd_t *self, uint16_t offset,
                             uint8_t binary_data_length);
 
ifx_status_t nbt_update_binary(nbt_cmd_t *self, uint16_t offset,
                               uint32_t data_length, const uint8_t *data);
 
ifx_status_t nbt_change_password(nbt_cmd_t *self, uint8_t pwd_id,
                                 const ifx_blob_t *master_password,
                                 const ifx_blob_t *new_password);
 
ifx_status_t nbt_unblock_password(nbt_cmd_t *self, uint8_t pwd_id,
                                  const ifx_blob_t *master_password);
 
ifx_status_t nbt_authenticate_tag(nbt_cmd_t *self, const ifx_blob_t *challenge);
 
ifx_status_t nbt_create_password(nbt_cmd_t *self,
                                 const ifx_blob_t *master_password,
                                 uint8_t new_password_id,
                                 const ifx_blob_t *new_password,
                                 uint16_t pwd_resp, uint16_t pwd_limit);
 
ifx_status_t nbt_delete_password(nbt_cmd_t *self,
                                 const ifx_blob_t *master_password,
                                 uint8_t password_id);
 
ifx_status_t nbt_get_data(nbt_cmd_t *self, uint16_t get_data_rcp);
 
ifx_status_t nbt_get_data_applet_version(nbt_cmd_t *self,
                                         nbt_applet_version_t *applet_version);
 
ifx_status_t nbt_get_data_available_memory(
    nbt_cmd_t *self, nbt_available_memory_t *available_memory);
 
uint8_t nbt_access_condition_get(nbt_access_condition access_type,
                                 const uint8_t *password_id);
 
ifx_status_t nbt_update_fap(nbt_cmd_t *self,
                            const nbt_file_access_policy_t *fap_policy);
 
ifx_status_t nbt_update_fap_with_password(
    nbt_cmd_t *self, const nbt_file_access_policy_t *fap_policy,
    const ifx_blob_t *master_password);
 
ifx_status_t nbt_update_fap_bytes(nbt_cmd_t *self,
                                  const ifx_blob_t *policy_bytes);
 
ifx_status_t nbt_update_fap_bytes_with_password(
    nbt_cmd_t *self, const ifx_blob_t *policy_bytes,
    const ifx_blob_t *master_password);
 
ifx_status_t nbt_parse_fap_bytes(const ifx_blob_t *fap_bytes,
                                 uint8_t no_of_fap_policies,
                                 nbt_file_access_policy_t *fap_policies);
 
ifx_status_t nbt_read_fap(nbt_cmd_t *self,
                          nbt_file_access_policy_t *fap_policies);
 
ifx_status_t nbt_read_fap_with_password(nbt_cmd_t *self,
                                        const ifx_blob_t *master_password,
                                        nbt_file_access_policy_t *fap_policies);
 
ifx_status_t nbt_read_fap_bytes(nbt_cmd_t *self);
 
ifx_status_t nbt_read_fap_bytes_with_password(
    nbt_cmd_t *self, const ifx_blob_t *master_password);
 
ifx_status_t nbt_pass_through_fetch_data(nbt_cmd_t *self,
                                         ifx_apdu_response_t *response);
 
ifx_status_t nbt_pass_through_decode_sw(const ifx_apdu_response_t *response,
                                        uint16_t *pass_through_status_word);
 
ifx_status_t nbt_pass_through_decode_apdu_bytes(
    const ifx_apdu_response_t *response, ifx_blob_t *nfc_apdu);
 
ifx_status_t nbt_pass_through_decode_apdu(const ifx_apdu_response_t *response,
                                          ifx_apdu_t *nfc_apdu);
 
ifx_status_t nbt_pass_through_put_response(
    nbt_cmd_t *self, const ifx_apdu_response_t *pass_through_response_data,
    ifx_apdu_response_t *response);
 
ifx_status_t nbt_ndef_read_with_id_password(nbt_cmd_t *self, uint16_t file_id,
                                            const ifx_blob_t *read_password);
 
ifx_status_t nbt_ndef_read_with_id(nbt_cmd_t *self, uint16_t file_id);
ifx_status_t nbt_ndef_read_with_password(nbt_cmd_t *self,
                                         const ifx_blob_t *read_password);
 
ifx_status_t nbt_ndef_read(nbt_cmd_t *self);
 
ifx_status_t nbt_ndef_update_with_id_password(nbt_cmd_t *self, uint16_t file_id,
                                              const ifx_blob_t *write_password,
                                              ifx_blob_t *ndef_bytes);
 
ifx_status_t nbt_ndef_update_with_id(nbt_cmd_t *self, uint16_t file_id,
                                     ifx_blob_t *ndef_bytes);
 
ifx_status_t nbt_ndef_update_with_password(nbt_cmd_t *self,
                                           const ifx_blob_t *write_password,
                                           ifx_blob_t *ndef_bytes);
 
ifx_status_t nbt_ndef_update(nbt_cmd_t *self, ifx_blob_t *ndef_bytes);
 
#ifdef __cplusplus
}
 
#endif /* __cplusplus */
#endif /* NBT_CMD_H */