se050_apdu.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "se050_types.hpp"
 
#include <cstddef>
#include <cstdint>
#include <cstring>
 
namespace se050::apdu {
 
struct StatusWords {
    std::uint8_t sw1{0};
    std::uint8_t sw2{0};
};
 
[[nodiscard]] inline Error BuildCaseShort(std::uint8_t cla, std::uint8_t ins, std::uint8_t p1,
                                          std::uint8_t p2, const std::uint8_t* data,
                                          std::uint8_t data_len, bool le_present, std::uint8_t le,
                                          std::uint8_t* out, std::size_t out_cap,
                                          std::size_t* out_len) noexcept;
 
[[nodiscard]] inline Error BuildCase4Extended(std::uint8_t cla, std::uint8_t ins, std::uint8_t p1,
                                              std::uint8_t p2, const std::uint8_t* data,
                                              std::size_t data_len, std::uint8_t* out,
                                              std::size_t out_cap, std::size_t* out_len) noexcept {
    if (out_len == nullptr) {
        return Error::InvalidArgument;
    }
    *out_len = 0;
    /* SE050C2 on this desk answers short APDUs (SELECT 0x9000) and rejects
     * Bertin-style extended Lc/Le for the same INS (GetVersion). Prefer
     * short CASE 2/4 whenever the payload fits in one Lc byte. */
    if (data_len <= 255U) {
        if (data_len == 0U) {
            if (out_cap < 5U) {
                return Error::BufferTooSmall;
            }
            out[0] = cla;
            out[1] = ins;
            out[2] = p1;
            out[3] = p2;
            out[4] = 0x00U; /* CASE 2 Le */
            *out_len = 5U;
            return Error::Ok;
        }
        return BuildCaseShort(cla, ins, p1, p2, data, static_cast<std::uint8_t>(data_len), true, 0x00U,
                              out, out_cap, out_len);
    }
    constexpr std::size_t kHeader = 7U; /* CLA.. + 00 LcHi LcLo */
    constexpr std::size_t kLeExt = 2U;    /* LeHi LeLo (case 4E: Lc already extended) */
    if (data_len > (kMaxApduCommandBytes - kHeader - kLeExt)) {
        return Error::InvalidArgument;
    }
    const std::size_t need = kHeader + data_len + kLeExt;
    if (need > out_cap) {
        return Error::BufferTooSmall;
    }
    std::size_t i = 0;
    out[i++] = cla;
    out[i++] = ins;
    out[i++] = p1;
    out[i++] = p2;
    out[i++] = 0x00;
    out[i++] = static_cast<std::uint8_t>((data_len >> 8) & 0xFFU);
    out[i++] = static_cast<std::uint8_t>(data_len & 0xFFU);
    if (data_len > 0U && data != nullptr) {
        std::memcpy(out + i, data, data_len);
        i += data_len;
    }
    out[i++] = 0x00;
    out[i++] = 0x00; /* Le = 00 00: Ne = 65536 (ISO/IEC 7816-4 5.1) */
    *out_len = i;
    return Error::Ok;
}
 
[[nodiscard]] inline Error BuildCaseShort(std::uint8_t cla, std::uint8_t ins, std::uint8_t p1,
                                          std::uint8_t p2, const std::uint8_t* data,
                                          std::uint8_t data_len, bool le_present, std::uint8_t le,
                                          std::uint8_t* out, std::size_t out_cap,
                                          std::size_t* out_len) noexcept {
    if (out_len == nullptr) {
        return Error::InvalidArgument;
    }
    *out_len = 0;
    const std::size_t need = 5U + data_len + (le_present ? 1U : 0U);
    if (need > out_cap) {
        return Error::BufferTooSmall;
    }
    std::size_t i = 0;
    out[i++] = cla;
    out[i++] = ins;
    out[i++] = p1;
    out[i++] = p2;
    out[i++] = data_len;
    if (data_len > 0U && data != nullptr) {
        std::memcpy(out + i, data, data_len);
        i += data_len;
    }
    if (le_present) {
        out[i++] = le;
    }
    *out_len = i;
    return Error::Ok;
}
 
[[nodiscard]] inline Error ParseResponse(const std::uint8_t* rsp, std::size_t rsp_len,
                                         const std::uint8_t** data_out, std::size_t* data_len_out,
                                         StatusWords* sw_out) noexcept {
    if (data_out == nullptr || data_len_out == nullptr || sw_out == nullptr) {
        return Error::InvalidArgument;
    }
    if (rsp_len < 2U) {
        return Error::Protocol;
    }
    *data_out = rsp;
    *data_len_out = rsp_len - 2U;
    sw_out->sw1 = rsp[rsp_len - 2U];
    sw_out->sw2 = rsp[rsp_len - 1U];
    return Error::Ok;
}
 
[[nodiscard]] inline bool IsSuccess(const StatusWords& sw) noexcept {
    return sw.sw1 == 0x90U && sw.sw2 == 0x00U;
}
 
[[nodiscard]] inline bool IsMoreData(const StatusWords& sw) noexcept { return sw.sw1 == 0x61U; }
 
}  // namespace se050::apdu