dandri/seader
1
0 Fork 0
mirror of https://github.com/bettse/seader.git synced 2026-10-23 04:23:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Incorporate t=1 and CCID fixes and conformance enhancements

Browse Source
This commit is contained in:
CinderSocket committed 2026-03-08 19:28:13 -07:00
1 parent 2d60989bee
commit 7d93a75f5b
12 files changed
+485 -238
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

Makefile
+2 -1
View File
@@ -17,11 +17,12 @@ test-host:
lib/host_tests/test_lrc.c \
lib/host_tests/test_ccid_logic.c \
lib/host_tests/test_t1_existing.c \
lib/host_tests/test_t1_regressions.c \
lib/host_tests/test_t1_protocol.c \
lib/host_tests/t1_test_stubs.c \
lib/host_tests/bit_buffer_mock.c \
lrc.c \
ccid_logic.c \
t_1_logic.c \
t_1.c \
-o build/host_tests/seader_tests
./build/host_tests/seader_tests
lib/host_tests/t_1_host_env.h
+2 -29
View File
@@ -9,6 +9,7 @@
#include "bit_buffer.h"
#include "lrc.h"
#include "t_1_logic.h"
/* Keep the host harness aligned with the production UART scratchpad size. */
#define SEADER_UART_RX_BUF_SIZE (300)
@@ -19,38 +20,10 @@ typedef struct Seader Seader;
typedef struct SeaderWorker SeaderWorker;
typedef struct SeaderUartBridge SeaderUartBridge;
typedef enum {
SeaderWorkerEventSamPresent = 53,
} SeaderWorkerEvent;
typedef enum { SeaderWorkerEventSamPresent = 53 } SeaderWorkerEvent;
typedef void (*SeaderWorkerCallback)(uint32_t event, void* context);
typedef enum {
SEADER_T1_PCB_I_BLOCK_MORE = 0x20,
SEADER_T1_PCB_SEQUENCE_BIT = 0x40,
SEADER_T1_PCB_R_BLOCK = 0x80,
SEADER_T1_PCB_S_BLOCK = 0xC0,
SEADER_T1_R_BLOCK_SEQUENCE_MASK = 0x10,
SEADER_T1_S_BLOCK_RESPONSE_BIT = 0x20,
SEADER_T1_S_BLOCK_RESYNCH = 0x00,
SEADER_T1_S_BLOCK_IFS = 0x01,
SEADER_T1_S_BLOCK_ABORT = 0x02,
SEADER_T1_S_BLOCK_WTX = 0x03,
} SeaderT1Constant;
typedef struct {
uint8_t ifsc;
uint8_t ifsd;
uint8_t ifsd_pending;
uint8_t nad;
uint8_t send_pcb;
uint8_t recv_pcb;
BitBuffer* tx_buffer;
size_t tx_buffer_offset;
size_t last_tx_len;
BitBuffer* rx_buffer;
} SeaderT1State;
struct SeaderUartBridge {
uint8_t rx_buf[SEADER_UART_RX_BUF_SIZE];
uint8_t tx_buf[SEADER_UART_RX_BUF_SIZE];
lib/host_tests/test_ccid_logic.c
+11
View File
@@ -7,6 +7,7 @@ static MunitResult test_sequence_advance_wraps(const MunitParameter params[], vo
(void)params;
(void)fixture;
/* CCID says bSeq "is a monotonically increasing by one counter" and "rolls over to 00h after FFh." */
uint8_t seq = 0;
munit_assert_uint8(seader_ccid_sequence_advance(&seq), ==, 0);
munit_assert_uint8(seq, ==, 1);
@@ -25,6 +26,7 @@ static MunitResult test_payload_fits_buffer(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* CCID says XfrBlock "should never exceed the dwMaxCCIDMessageLength-10" because the header is 10 bytes. */
munit_assert_true(seader_ccid_payload_fits_frame(10, 300, 12));
munit_assert_false(seader_ccid_payload_fits_frame(289, 300, 12));
munit_assert_true(seader_ccid_payload_fits_frame(288, 300, 12));
@@ -35,6 +37,7 @@ static MunitResult test_data_in_scratchpad(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* CCID says the 10-byte header provides "a constant offset at which message data begins across all messages." */
uint8_t tx[64] = {0};
munit_assert_true(seader_ccid_data_in_scratchpad(tx, sizeof(tx), 12, tx + 12, 1));
munit_assert_true(seader_ccid_data_in_scratchpad(tx, sizeof(tx), 12, tx + 63, 1));
@@ -47,6 +50,7 @@ static MunitResult test_response_seq_match(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* CCID says responses use "the exact same sequence number contained in the command". */
munit_assert_true(seader_ccid_response_matches_pending(false, 0x00, 0xff));
munit_assert_true(seader_ccid_response_matches_pending(true, 0x12, 0x12));
munit_assert_false(seader_ccid_response_matches_pending(true, 0x12, 0x13));
@@ -57,6 +61,7 @@ static MunitResult test_status_decode_ok(const MunitParameter params[], void* fi
(void)params;
(void)fixture;
/* CCID says bmCommandStatus 0 means "Processed without error". */
SeaderCcidStatus status_ok = seader_ccid_decode_status(0x00);
munit_assert_uint8(status_ok.icc_status, ==, 0);
munit_assert_int(status_ok.command_status, ==, SeaderCcidDecodedCommandStatusProcessed);
@@ -67,6 +72,7 @@ static MunitResult test_status_decode_failed(const MunitParameter params[], void
(void)params;
(void)fixture;
/* CCID says bmCommandStatus 1 means "Failed" and the slot error register carries the error code. */
SeaderCcidStatus status_fail = seader_ccid_decode_status(0x41);
munit_assert_uint8(status_fail.icc_status, ==, 1);
munit_assert_int(status_fail.command_status, ==, SeaderCcidDecodedCommandStatusFailed);
@@ -77,6 +83,7 @@ static MunitResult test_status_decode_time_extension(const MunitParameter params
(void)params;
(void)fixture;
/* CCID says bmCommandStatus 2 means "Time Extension is requested". */
SeaderCcidStatus status_wait = seader_ccid_decode_status(0x80);
munit_assert_uint8(status_wait.icc_status, ==, 0);
munit_assert_int(
@@ -88,6 +95,7 @@ static MunitResult test_find_start_skips_nak_triplet(const MunitParameter params
(void)params;
(void)fixture;
/* Bridge framing invariant: skip the serial NAK triplet before looking for the next sync/control framed packet. */
const uint8_t sync = 0x03;
const uint8_t ctrl = 0x06;
const uint8_t nak = 0x15;
@@ -110,6 +118,7 @@ static MunitResult test_find_start_noise_only(const MunitParameter params[], voi
(void)params;
(void)fixture;
/* The bridge must not invent a CCID frame start when the sync/control header is incomplete. */
const uint8_t sync = 0x03;
const uint8_t ctrl = 0x06;
const uint8_t nak = 0x15;
@@ -126,6 +135,7 @@ static MunitResult test_pending_timeout_helper(const MunitParameter params[], vo
(void)params;
(void)fixture;
/* CCID says when Time Extension is set the host should "wait for a new response with the same bSeq number". */
munit_assert_false(seader_ccid_pending_timed_out(false, 100, 200, 50));
munit_assert_false(seader_ccid_pending_timed_out(true, 0, 200, 50));
munit_assert_false(seader_ccid_pending_timed_out(true, 100, 149, 50));
@@ -139,6 +149,7 @@ static MunitResult test_data_block_route(const MunitParameter params[], void* fi
(void)params;
(void)fixture;
/* CCID says "bSlot identifies which ICC slot is being addressed"; protocol 00h is T=0 and 01h is T=1. */
munit_assert_int(seader_ccid_route_data_block(true, 0, 0, 0), ==, SeaderCcidDataRouteSamT0);
munit_assert_int(seader_ccid_route_data_block(true, 0, 0, 1), ==, SeaderCcidDataRouteSamT1);
munit_assert_int(
lib/host_tests/test_lrc.c
+3
View File
@@ -7,6 +7,7 @@ static MunitResult test_calc_lrc(const MunitParameter params[], void* fixture) {
(void)params;
(void)fixture;
/* ISO 7816-3 says "exclusive-oring all the bytes of the block from NAD to LRC inclusive shall give '00'." */
uint8_t bytes[] = {0x03, 0x06, 0x62, 0x00};
munit_assert_uint8(
seader_calc_lrc(bytes, sizeof(bytes)), ==, (uint8_t)(0x03 ^ 0x06 ^ 0x62 ^ 0x00));
@@ -17,6 +18,7 @@ static MunitResult test_add_and_validate_lrc(const MunitParameter params[], void
(void)params;
(void)fixture;
/* ISO 7816-3 says "Any other value is invalid", so flipping one byte must break validation. */
uint8_t frame[8] = {0x03, 0x06, 0x62, 0x00, 0x01, 0x02, 0x00, 0x00};
size_t len = seader_add_lrc(frame, 6);
munit_assert_size(len, ==, 7);
@@ -31,6 +33,7 @@ static MunitResult test_validate_nak_triplet(const MunitParameter params[], void
(void)params;
(void)fixture;
/* Bridge framing invariant: SYNC, NAK, and XOR checksum form the transport-side NAK triplet. */
uint8_t nak_triplet[] = {0x03, 0x15, 0x16};
munit_assert_true(seader_validate_lrc(nak_triplet, 3));
return MUNIT_OK;
lib/host_tests/test_main.c
+2 -2
View File
@@ -3,13 +3,13 @@
extern MunitSuite test_lrc_suite;
extern MunitSuite test_ccid_logic_suite;
extern MunitSuite test_t1_existing_suite;
extern MunitSuite test_t1_regressions_suite;
extern MunitSuite test_t1_protocol_suite;
int main(int argc, char* argv[]) {
MunitSuite child_suites[] = {
{"/lrc", test_lrc_suite.tests, NULL, 1, MUNIT_SUITE_OPTION_NONE},
{"/t1", test_t1_existing_suite.tests, NULL, 1, MUNIT_SUITE_OPTION_NONE},
{"/t1-future", test_t1_regressions_suite.tests, NULL, 1, MUNIT_SUITE_OPTION_NONE},
{"/t1", test_t1_protocol_suite.tests, NULL, 1, MUNIT_SUITE_OPTION_NONE},
{"/ccid", test_ccid_logic_suite.tests, NULL, 1, MUNIT_SUITE_OPTION_NONE},
{NULL, NULL, NULL, 0, 0},
};
lib/host_tests/test_t1_existing.c
+24 -2
View File
@@ -15,6 +15,9 @@ static Seader make_test_seader(SeaderUartBridge* uart, SeaderWorker* worker) {
memset(worker, 0, sizeof(*worker));
worker->uart = uart;
worker->callback = test_callback;
uart->t1.ifsc = SEADER_T1_IFS_DEFAULT;
uart->t1.ifsd = SEADER_T1_IFS_DEFAULT;
uart->t1.send_pcb = SEADER_T1_PCB_SEQUENCE_BIT;
Seader seader = {.worker = worker};
return seader;
@@ -34,6 +37,7 @@ static MunitResult test_send_ifs_request(const MunitParameter params[], void* fi
(void)params;
(void)fixture;
/* ISO 7816-3 says "The interface device transmits S(IFS request) to indicate a new IFSD it can support." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -44,9 +48,10 @@ static MunitResult test_send_ifs_request(const MunitParameter params[], void* fi
uart.t1.send_pcb = SEADER_T1_PCB_SEQUENCE_BIT;
seader_t_1_set_IFSD(&seader);
/* ISO 7816-3 says "The values '01' to 'FE' encode the numbers 1 to 254", so the request uses 0xFE. */
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_size(g_t1_host_test_state.last_frame_len, ==, 5);
munit_assert_true(last_frame_prefix_matches((const uint8_t*)"\x00\xC1\x01\x20", 4));
munit_assert_true(last_frame_prefix_matches((const uint8_t*)"\x00\xC1\x01\xFE", 4));
munit_assert_true(
seader_validate_lrc(g_t1_host_test_state.last_frame, g_t1_host_test_state.last_frame_len));
return MUNIT_OK;
@@ -56,6 +61,7 @@ static MunitResult test_send_single_block(const MunitParameter params[], void* f
(void)params;
(void)fixture;
/* ISO 7816-3 says "The command APDU is mapped onto the information field of an I-block without any change." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
make_test_seader(&uart, &worker);
@@ -78,6 +84,7 @@ static MunitResult test_send_scratchpad_block(const MunitParameter params[], voi
(void)params;
(void)fixture;
/* ISO 7816-3 still requires the same I-block image even when the payload already sits in our scratchpad. */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
make_test_seader(&uart, &worker);
@@ -99,6 +106,7 @@ static MunitResult test_send_chained_block(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* ISO 7816-3 says information longer than IFSC/IFSD "should divide the information into pieces". */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
make_test_seader(&uart, &worker);
@@ -109,6 +117,7 @@ static MunitResult test_send_chained_block(const MunitParameter params[], void*
uint8_t apdu_long[] = {0xAA, 0xBB, 0xCC, 0xDD, 0xEE};
seader_send_t1(&uart, apdu_long, sizeof(apdu_long));
/* ISO 7816-3 says "I(N(S), 1) is a part of a chain and shall be followed by at least one chained block." */
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_uint8(
g_t1_host_test_state.last_frame[1], ==, (SEADER_T1_PCB_I_BLOCK_MORE | 0x00));
@@ -124,6 +133,7 @@ static MunitResult test_recv_ifs_response(const MunitParameter params[], void* f
(void)params;
(void)fixture;
/* ISO 7816-3 says "The card shall acknowledge by S(IFS response) with the same INF." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -144,17 +154,20 @@ static MunitResult test_recv_single_i_block(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* ISO 7816-3 says "The information field of the I-block in response is mapped onto the response APDU without any change." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
t1_host_test_reset();
uart.t1.recv_pcb = 0x00;
uart.t1.ifsd = SEADER_T1_IFS_DEFAULT;
uint8_t i_block[] = {0x00, 0x00, 0x03, 0x11, 0x22, 0x33, 0x00};
seader_add_lrc(i_block, 6);
CCID_Message i_message = {.payload = i_block, .dwLength = 7};
munit_assert_true(seader_recv_t1(&seader, &i_message));
/* ISO 7816-3 says "the initial value is N(S) = 0; then the value alternates after transmitting each I-block." */
munit_assert_size(g_t1_host_test_state.process_call_count, ==, 1);
munit_assert_true(last_apdu_matches((const uint8_t*)"\x11\x22\x33", 3));
munit_assert_uint8(uart.t1.recv_pcb, ==, 0x40);
@@ -165,17 +178,20 @@ static MunitResult test_recv_chained_i_blocks(const MunitParameter params[], voi
(void)params;
(void)fixture;
/* ISO 7816-3 says successive chained I-block information fields are concatenated into one APDU. */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
t1_host_test_reset();
uart.t1.recv_pcb = 0x00;
uart.t1.ifsd = SEADER_T1_IFS_DEFAULT;
uint8_t i_more[] = {0x00, 0x20, 0x03, 0x44, 0x55, 0x66, 0x00};
seader_add_lrc(i_more, 6);
CCID_Message more_message = {.payload = i_more, .dwLength = 7};
munit_assert_false(seader_recv_t1(&seader, &more_message));
/* ISO 7816-3 says "R(N(R)) requests transmission of the next chained I-block". */
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_not_null(uart.t1.rx_buffer);
munit_assert_uint8(uart.t1.recv_pcb, ==, 0x40);
@@ -196,6 +212,7 @@ static MunitResult test_recv_ifs_request(const MunitParameter params[], void* fi
(void)params;
(void)fixture;
/* ISO 7816-3 says "The card transmits S(IFS request) to indicate a new IFSC it can support." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -207,8 +224,10 @@ static MunitResult test_recv_ifs_request(const MunitParameter params[], void* fi
CCID_Message ifs_request_message = {.payload = ifs_request, .dwLength = 5};
munit_assert_false(seader_recv_t1(&seader, &ifs_request_message));
/* ISO 7816-3 says "The interface device shall acknowledge by S(IFS response) with the same INF." */
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_true(last_frame_prefix_matches((const uint8_t*)"\x00\xE1\x01\x33", 4));
munit_assert_true(last_frame_prefix_matches((const uint8_t*)"\x00\xE1\x01\x20", 4));
munit_assert_uint8(uart.t1.ifsc, ==, 0x20);
return MUNIT_OK;
}
@@ -216,6 +235,7 @@ static MunitResult test_recv_r_block_resends_buffer(const MunitParameter params[
(void)params;
(void)fixture;
/* ISO 7816-3 says "Every R-block carries N(R) which is the send-sequence number N(S) of the expected I-block." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -231,6 +251,7 @@ static MunitResult test_recv_r_block_resends_buffer(const MunitParameter params[
CCID_Message r_message = {.payload = r_block, .dwLength = 4};
munit_assert_false(seader_recv_t1(&seader, &r_message));
/* ISO 7816-3 says "R(N(R)) requests transmission of the next chained I-block". */
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_not_null(uart.t1.tx_buffer);
bit_buffer_free(uart.t1.tx_buffer);
@@ -241,6 +262,7 @@ static MunitResult test_reset_clears_state(const MunitParameter params[], void*
(void)params;
(void)fixture;
/* ISO 7816-3 says "At the start of the transmission protocol ... IFSC and IFSD are initialized." */
SeaderUartBridge uart = {0};
uart.t1.nad = 0x77;
uart.t1.send_pcb = 0x00;
lib/host_tests/test_t1_regressions.c → lib/host_tests/test_t1_protocol.c
+11 -27
View File
@@ -23,6 +23,7 @@ static MunitResult test_recv_wtx_request_responds(const MunitParameter params[],
(void)params;
(void)fixture;
/* ISO 7816-3 says "The interface device shall acknowledge by S(WTX response) with the same INF." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -38,29 +39,11 @@ static MunitResult test_recv_wtx_request_responds(const MunitParameter params[],
return MUNIT_OK;
}
static MunitResult test_recv_resynch_request_responds(const MunitParameter params[], void* fixture) {
(void)params;
(void)fixture;
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
t1_host_test_reset();
uint8_t s_resync_req[] = {0x00, 0xC0, 0x00, 0x00};
seader_add_lrc(s_resync_req, 3);
CCID_Message message = {.payload = s_resync_req, .dwLength = 4};
munit_assert_false(seader_recv_t1(&seader, &message));
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_uint8(g_t1_host_test_state.last_frame[1], ==, 0xE0);
return MUNIT_OK;
}
static MunitResult test_recv_malformed_wtx_rejected(const MunitParameter params[], void* fixture) {
(void)params;
(void)fixture;
/* ISO 7816-3 says "INF shall be present with a single byte in an S-block adjusting IFS and WTX." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -80,6 +63,7 @@ static MunitResult test_recv_malformed_ifs_rejected(const MunitParameter params[
(void)params;
(void)fixture;
/* ISO 7816-3 says "INF shall be present with a single byte in an S-block adjusting IFS and WTX." */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -99,6 +83,7 @@ static MunitResult test_recv_ifs_request_updates_ifsc(const MunitParameter param
(void)params;
(void)fixture;
/* ISO 7816-3 says "The interface device assumes the new IFSC is valid as long as no other IFSC is indicated". */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -121,6 +106,7 @@ static MunitResult test_recv_ifs_response_applies_pending_ifsd(
(void)params;
(void)fixture;
/* ISO 7816-3 says "The card assumes the new IFSD is valid as long as no other IFSD is indicated". */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -144,6 +130,7 @@ static MunitResult test_recv_ifs_response_mismatch_rejected(
(void)params;
(void)fixture;
/* ISO 7816-3 says the response acknowledges "with the same INF", so mismatched IFS bytes are invalid. */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -166,6 +153,7 @@ static MunitResult test_recv_i_block_too_large_rejected(const MunitParameter par
(void)params;
(void)fixture;
/* ISO 7816-3 says each piece must have length "less than or equal to IFSC or IFSD". */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -188,6 +176,7 @@ static MunitResult test_recv_r_block_nack_retransmits(const MunitParameter param
(void)params;
(void)fixture;
/* ISO 7816-3 says an invalid block leads to an R-block that "requests with its N(R) for the expected I-block". */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -205,7 +194,7 @@ static MunitResult test_recv_r_block_nack_retransmits(const MunitParameter param
munit_assert_false(seader_recv_t1(&seader, &message));
munit_assert_size(g_t1_host_test_state.xfrblock_call_count, ==, 1);
munit_assert_uint8(uart.t1.send_pcb, ==, SEADER_T1_PCB_SEQUENCE_BIT);
munit_assert_uint8(g_t1_host_test_state.last_frame[1], ==, 0x00);
bit_buffer_free(uart.t1.tx_buffer);
return MUNIT_OK;
}
@@ -216,6 +205,7 @@ static MunitResult test_recv_r_block_invalid_retransmit_state_errors(
(void)params;
(void)fixture;
/* ISO 7816-3 ties R-block recovery to "the expected I-block"; without a prior chunk, retransmit state is invalid. */
SeaderUartBridge uart = {0};
SeaderWorker worker = {0};
Seader seader = make_test_seader(&uart, &worker);
@@ -242,12 +232,6 @@ static MunitTest test_t1_regression_cases[] = {
NULL,
MUNIT_TEST_OPTION_NONE,
NULL},
{(char*)"/recv/resynch-request-responds",
test_recv_resynch_request_responds,
NULL,
NULL,
MUNIT_TEST_OPTION_NONE,
NULL},
{(char*)"/recv/malformed-wtx-len-zero-rejected",
test_recv_malformed_wtx_rejected,
NULL,
@@ -299,7 +283,7 @@ static MunitTest test_t1_regression_cases[] = {
{NULL, NULL, NULL, NULL, 0, NULL},
};
MunitSuite test_t1_regressions_suite = {
MunitSuite test_t1_protocol_suite = {
"",
test_t1_regression_cases,
NULL,
seader_bridge.h
+2 -14
View File
@@ -9,6 +9,8 @@
#include <furi.h>
#include <furi_hal.h>
#include "t_1_logic.h"
// https://ww1.microchip.com/downloads/en/DeviceDoc/00001561C.pdf
#define SEADER_UART_RX_BUF_SIZE (300)
#define SEADER_CCID_SLOT_COUNT (2U)
@@ -40,20 +42,6 @@ typedef struct {
SeaderCcidSlotState slots[SEADER_CCID_SLOT_COUNT];
} SeaderCcidState;
typedef struct {
/* ICC information field size for T=1. */
uint8_t ifsc;
/* Host NAD used for T=1 block exchange. */
uint8_t nad;
/* Last transmit I-block sequence bit. */
uint8_t send_pcb;
/* Last receive I-block sequence bit. */
uint8_t recv_pcb;
BitBuffer* tx_buffer;
size_t tx_buffer_offset;
BitBuffer* rx_buffer;
} SeaderT1State;
struct SeaderUartBridge {
SeaderUartConfig cfg;
SeaderUartConfig cfg_new;
t_1.c
+154 -154
View File
@@ -4,46 +4,30 @@
#include "t_1.h"
#endif
#include "t_1_logic.h"
#define TAG "Seader:T=1"
// http://www.sat-digest.com/SatXpress/SmartCard/ISO7816-4.htm
/* I know my T=1 is terrible, but I'm also only targetting one specific 'card' */
static SeaderT1State* seader_t1_state(SeaderUartBridge* seader_uart) {
return &seader_uart->t1;
}
static uint8_t seader_next_dpcb(SeaderUartBridge* seader_uart) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t next_pcb = t1->send_pcb ^ SEADER_T1_PCB_SEQUENCE_BIT;
//FURI_LOG_D(TAG, "dPCB was: %02X, current dPCB: %02X", dPCB, next_pcb);
uint8_t next_pcb = seader_t1_next_pcb(t1->send_pcb);
t1->send_pcb = next_pcb;
return t1->send_pcb;
}
static uint8_t seader_next_cpcb(SeaderUartBridge* seader_uart) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t next_pcb = t1->recv_pcb ^ SEADER_T1_PCB_SEQUENCE_BIT;
//FURI_LOG_D(TAG, "cPCB was: %02X, current cPCB: %02X", cPCB, next_pcb);
t1->recv_pcb = next_pcb;
return t1->recv_pcb;
}
void seader_t_1_reset(SeaderUartBridge* seader_uart) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
t1->nad = 0x00;
t1->send_pcb = SEADER_T1_PCB_SEQUENCE_BIT;
t1->recv_pcb = 0x00;
if(t1->tx_buffer != NULL) {
bit_buffer_free(t1->tx_buffer);
if(t1->ifsc == 0 || t1->ifsc > SEADER_T1_IFS_MAX) {
t1->ifsc = SEADER_T1_IFS_DEFAULT;
}
t1->tx_buffer = NULL;
t1->tx_buffer_offset = 0;
if(t1->rx_buffer != NULL) {
bit_buffer_free(t1->rx_buffer);
}
t1->rx_buffer = NULL;
t1->ifsd = SEADER_T1_IFS_DEFAULT;
t1->ifsd_pending = 0;
seader_t1_reset_link_state(t1);
}
void seader_t_1_set_IFSD(Seader* seader) {
@@ -52,19 +36,21 @@ void seader_t_1_set_IFSD(Seader* seader) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t frame[5];
uint8_t frame_len = 0;
/* Negotiate the largest host receive size we support so chained responses stay predictable. */
uint8_t requested_ifsd = SEADER_T1_IFS_MAX;
frame[0] = t1->nad;
frame[1] = SEADER_T1_PCB_S_BLOCK | SEADER_T1_S_BLOCK_IFS; // S(IFS request)
frame[1] = SEADER_T1_PCB_S_BLOCK | SEADER_T1_S_BLOCK_IFS;
frame[2] = 0x01;
frame[3] = t1->ifsc;
t1->ifsd_pending = requested_ifsd;
frame[3] = requested_ifsd;
frame_len = 4;
frame_len = seader_add_lrc(frame, frame_len);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
void seader_t_1_IFSD_response(Seader* seader) {
static void seader_t_1_IFSD_response(Seader* seader, uint8_t ifs_value) {
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
SeaderT1State* t1 = seader_t1_state(seader_uart);
@@ -72,13 +58,45 @@ void seader_t_1_IFSD_response(Seader* seader) {
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = 0xE0 | 0x01; // S(IFS response)
frame[1] = 0xE0 | SEADER_T1_S_BLOCK_IFS;
frame[2] = 0x01;
frame[3] = t1->ifsc;
frame[3] = ifs_value;
frame_len = 4;
frame_len = seader_add_lrc(frame, frame_len);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
static void seader_t_1_WTX_response(Seader* seader, uint8_t multiplier) {
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t frame[5];
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = 0xE0 | SEADER_T1_S_BLOCK_WTX;
frame[2] = 0x01;
frame[3] = multiplier;
frame_len = 4;
frame_len = seader_add_lrc(frame, frame_len);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
static void seader_t_1_resynch_response(Seader* seader) {
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t frame[4];
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = 0xE0 | SEADER_T1_S_BLOCK_RESYNCH;
frame[2] = 0x00;
frame_len = 3;
frame_len = seader_add_lrc(frame, frame_len);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
@@ -90,24 +108,38 @@ void seader_t_1_send_ack(Seader* seader) {
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = SEADER_T1_PCB_R_BLOCK | (seader_next_cpcb(seader_uart) >> 2);
frame[1] = SEADER_T1_PCB_R_BLOCK | (t1->recv_pcb >> 2);
frame[2] = 0x00;
frame_len = 3;
frame_len = seader_add_lrc(frame, frame_len);
//FURI_LOG_D(TAG, "Sending R-Block ACK: PCB: %02x", frame[1]);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
void seader_send_t1_chunk(SeaderUartBridge* seader_uart, uint8_t PCB, uint8_t* chunk, size_t len) {
static void seader_t_1_send_nak(Seader* seader) {
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t frame[4];
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = SEADER_T1_PCB_R_BLOCK | (t1->recv_pcb >> 2) | 0x01;
frame[2] = 0x00;
frame_len = 3;
frame_len = seader_add_lrc(frame, frame_len);
FURI_LOG_W(TAG, "Sending R-Block NACK: PCB: %02x", frame[1]);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
}
void seader_send_t1_chunk(SeaderUartBridge* seader_uart, uint8_t pcb, uint8_t* chunk, size_t len) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t* frame = malloc(3 + len + 1);
uint8_t frame_len = 0;
frame[0] = t1->nad;
frame[1] = PCB;
frame[1] = pcb;
frame[2] = len;
frame_len = 3;
@@ -117,20 +149,20 @@ void seader_send_t1_chunk(SeaderUartBridge* seader_uart, uint8_t PCB, uint8_t* c
}
frame_len = seader_add_lrc(frame, frame_len);
seader_ccid_XfrBlock(seader_uart, frame, frame_len);
free(frame);
}
void seader_send_t1_scratchpad(
SeaderUartBridge* seader_uart,
uint8_t PCB,
uint8_t pcb,
uint8_t* apdu,
size_t len) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t* frame = apdu - 3;
frame[0] = t1->nad;
frame[1] = PCB;
frame[1] = pcb;
frame[2] = (uint8_t)len;
size_t frame_len = seader_add_lrc(frame, 3 + len);
@@ -141,145 +173,113 @@ void seader_send_t1(SeaderUartBridge* seader_uart, uint8_t* apdu, size_t len) {
SeaderT1State* t1 = seader_t1_state(seader_uart);
uint8_t ifsc = t1->ifsc;
bool in_scratchpad =
(apdu >= seader_uart->tx_buf + 3 && apdu < seader_uart->tx_buf + SEADER_UART_RX_BUF_SIZE);
if(len > ifsc) {
if(t1->tx_buffer == NULL) {
t1->tx_buffer = bit_buffer_alloc(768);
bit_buffer_copy_bytes(t1->tx_buffer, apdu, len);
}
size_t remaining = (bit_buffer_get_size_bytes(t1->tx_buffer) - t1->tx_buffer_offset);
size_t copy_length = remaining > ifsc ? ifsc : remaining;
uint8_t* chunk = (uint8_t*)bit_buffer_get_data(t1->tx_buffer) + t1->tx_buffer_offset;
if(remaining > ifsc) {
uint8_t PCB = seader_next_dpcb(seader_uart) | SEADER_T1_PCB_I_BLOCK_MORE;
seader_send_t1_chunk(seader_uart, PCB, chunk, copy_length);
} else {
uint8_t PCB = seader_next_dpcb(seader_uart);
seader_send_t1_chunk(seader_uart, PCB, chunk, copy_length);
}
t1->tx_buffer_offset += copy_length;
if(t1->tx_buffer_offset >= bit_buffer_get_size_bytes(t1->tx_buffer)) {
bit_buffer_free(t1->tx_buffer);
t1->tx_buffer = NULL;
t1->tx_buffer_offset = 0;
}
return;
if(ifsc == 0 || ifsc > SEADER_T1_IFS_MAX) {
ifsc = SEADER_T1_IFS_DEFAULT;
}
if(in_scratchpad) {
seader_send_t1_scratchpad(seader_uart, seader_next_dpcb(seader_uart), apdu, len);
if(t1->tx_buffer == NULL) {
bool in_scratchpad =
apdu != NULL &&
seader_t1_apdu_in_scratchpad(seader_uart->tx_buf, SEADER_UART_RX_BUF_SIZE, apdu);
if(in_scratchpad && len <= ifsc) {
seader_send_t1_scratchpad(seader_uart, seader_next_dpcb(seader_uart), apdu, len);
t1->last_tx_len = len;
return;
}
t1->tx_buffer = bit_buffer_alloc(768);
bit_buffer_copy_bytes(t1->tx_buffer, apdu, len);
t1->tx_buffer_offset = 0;
}
size_t total_len = bit_buffer_get_size_bytes(t1->tx_buffer);
size_t remaining = total_len - t1->tx_buffer_offset;
size_t copy_length = seader_t1_chunk_length(total_len, t1->tx_buffer_offset, ifsc);
uint8_t* chunk = (uint8_t*)bit_buffer_get_data(t1->tx_buffer) + t1->tx_buffer_offset;
uint8_t pcb;
if(remaining > ifsc) {
pcb = seader_next_dpcb(seader_uart) | SEADER_T1_PCB_I_BLOCK_MORE;
} else {
seader_send_t1_chunk(seader_uart, seader_next_dpcb(seader_uart), apdu, len);
pcb = seader_next_dpcb(seader_uart);
}
seader_send_t1_chunk(seader_uart, pcb, chunk, copy_length);
t1->last_tx_len = copy_length;
t1->tx_buffer_offset += copy_length;
}
bool seader_recv_t1(Seader* seader, CCID_Message* message) {
SeaderWorker* seader_worker = seader->worker;
SeaderUartBridge* seader_uart = seader_worker->uart;
SeaderT1State* t1 = seader_t1_state(seader_uart);
// remove/validate NAD, PCB, LEN, LRC
if(message->dwLength < 4) {
FURI_LOG_W(TAG, "Invalid T=1 frame: too short");
return false;
}
//uint8_t NAD = message->payload[0];
uint8_t rPCB = message->payload[1];
uint8_t LEN = message->payload[2];
//uint8_t LRC = message->payload[3 + LEN];
//FURI_LOG_D(TAG, "NAD: %02X, rPCB: %02X, LEN: %02X, LRC: %02X", NAD, rPCB, LEN, LRC);
uint8_t* apdu = NULL;
size_t apdu_len = 0;
if(rPCB == 0xE1) {
// S(IFS response)
//FURI_LOG_D(TAG, "Received IFS Response");
seader_worker_send_version(seader);
SeaderWorker* seader_worker = seader->worker;
if(seader_worker->callback) {
seader_worker->callback(SeaderWorkerEventSamPresent, seader_worker->context);
}
return false;
}
SeaderT1Action action =
seader_t1_handle_block(t1, message->payload, message->dwLength, &apdu, &apdu_len);
if(rPCB == t1->recv_pcb) {
seader_next_cpcb(seader_uart);
/* Keep transport decisions here so host tests exercise the same action-to-wire mapping. */
switch(action) {
case SeaderT1ActionDeliverAPDU:
if(t1->rx_buffer != NULL) {
bit_buffer_append_bytes(t1->rx_buffer, message->payload + 3, LEN);
// TODO: validate LRC
seader_worker_process_sam_message(
seader,
(uint8_t*)bit_buffer_get_data(t1->rx_buffer),
bit_buffer_get_size_bytes(t1->rx_buffer));
seader_worker_process_sam_message(seader, apdu, apdu_len);
bit_buffer_free(t1->rx_buffer);
t1->rx_buffer = NULL;
return true;
}
return seader_worker_process_sam_message(seader, apdu, apdu_len);
if(seader_validate_lrc(message->payload, message->dwLength) == false) {
return false;
}
// Skip NAD, PCB, LEN
message->payload = message->payload + 3;
message->dwLength = LEN;
if(message->dwLength == 0) {
//FURI_LOG_D(TAG, "Received T=1 frame with no data");
return true;
}
return seader_worker_process_sam_message(seader, message->payload, message->dwLength);
} else if(rPCB == (t1->recv_pcb | SEADER_T1_PCB_I_BLOCK_MORE)) {
//FURI_LOG_D(TAG, "Received T=1 frame with more bit set");
if(t1->rx_buffer == NULL) {
t1->rx_buffer = bit_buffer_alloc(512);
}
bit_buffer_append_bytes(t1->rx_buffer, message->payload + 3, LEN);
case SeaderT1ActionSendAck:
seader_t_1_send_ack(seader);
return false;
} else if((rPCB & SEADER_T1_PCB_S_BLOCK) == SEADER_T1_PCB_S_BLOCK) {
//FURI_LOG_D(TAG, "Received S-Block");
if((rPCB & 0x0F) == SEADER_T1_S_BLOCK_IFS) {
seader_t_1_IFSD_response(seader);
return false;
}
} else if((rPCB & SEADER_T1_PCB_R_BLOCK) == SEADER_T1_PCB_R_BLOCK) {
uint8_t R_SEQ = (rPCB & SEADER_T1_R_BLOCK_SEQUENCE_MASK) >> 4;
uint8_t I_SEQ = (t1->send_pcb ^ SEADER_T1_PCB_SEQUENCE_BIT) >> 6;
if(R_SEQ != I_SEQ) {
/*
FURI_LOG_D(
TAG,
"Received R-Block: Incorrect sequence. Expected: %02X, Received: %02X",
I_SEQ,
R_SEQ);
case SeaderT1ActionSendNak:
seader_t_1_send_nak(seader);
return false;
*/
// When this happens, the flipper freezes if it is doing NFC and my attempts to do events to stop that have failed
return false;
case SeaderT1ActionSendIFSResponse:
if(apdu_len == 1 && apdu != NULL) {
seader_t_1_IFSD_response(seader, apdu[0]);
} else {
seader_t_1_send_nak(seader);
}
return false;
if(t1->tx_buffer != NULL) {
// Send more data, re-using the buffer to trigger the code path that sends the next block
seader_send_t1(
seader_uart,
(uint8_t*)bit_buffer_get_data(t1->tx_buffer),
bit_buffer_get_size_bytes(t1->tx_buffer));
return false;
case SeaderT1ActionSendWTXResponse:
seader_t_1_WTX_response(seader, apdu[0]);
return false;
case SeaderT1ActionSendResynchResponse:
seader_t1_reset_link_state(t1);
seader_t_1_resynch_response(seader);
return false;
case SeaderT1ActionSendVersion:
seader_worker_send_version(seader);
if(seader_worker->callback) {
seader_worker->callback(SeaderWorkerEventSamPresent, seader_worker->context);
}
} else {
FURI_LOG_W(
TAG,
"Invalid T=1 frame: PCB mismatch. Expected: %02X, Received: %02X",
t1->recv_pcb,
rPCB);
return false;
case SeaderT1ActionSendMoreData:
seader_send_t1(
seader_uart,
(uint8_t*)bit_buffer_get_data(t1->tx_buffer),
bit_buffer_get_size_bytes(t1->tx_buffer));
return false;
case SeaderT1ActionRetransmit:
seader_send_t1(seader_uart, NULL, 0);
return false;
case SeaderT1ActionNone:
return true;
case SeaderT1ActionError:
default:
FURI_LOG_W(TAG, "T=1 error or unhandled action %d", action);
return false;
}
return false;
}
t_1.h
+1 -9
View File
@@ -1,18 +1,10 @@
#pragma once
#include "ccid.h"
#include "t_1_logic.h"
typedef struct CCID_Message CCID_Message;
typedef enum {
SEADER_T1_PCB_I_BLOCK_MORE = 0x20,
SEADER_T1_PCB_SEQUENCE_BIT = 0x40,
SEADER_T1_PCB_R_BLOCK = 0x80,
SEADER_T1_PCB_S_BLOCK = 0xC0,
SEADER_T1_R_BLOCK_SEQUENCE_MASK = 0x10,
SEADER_T1_S_BLOCK_IFS = 0x01,
} SeaderT1Constant;
void seader_send_t1(SeaderUartBridge* seader_uart, uint8_t* apdu, size_t len);
bool seader_recv_t1(Seader* seader, CCID_Message* message);
void seader_t_1_set_IFSD(Seader* seader);
t_1_logic.c
+200
View File
@@ -0,0 +1,200 @@
#include "t_1_logic.h"
#include "lrc.h"
#include <string.h>
#ifdef SEADER_HOST_TEST
#include "lib/host_tests/bit_buffer.h"
#else
#include <lib/toolbox/bit_buffer.h>
#endif
uint8_t seader_t1_next_pcb(uint8_t current_pcb) {
return current_pcb ^ SEADER_T1_PCB_SEQUENCE_BIT;
}
bool seader_t1_apdu_in_scratchpad(const uint8_t* tx_buf, size_t tx_buf_size, const uint8_t* apdu) {
return apdu >= tx_buf + 3 && apdu < tx_buf + tx_buf_size;
}
size_t seader_t1_chunk_length(size_t total_length, size_t offset, uint8_t ifsc) {
size_t remaining = total_length - offset;
if(ifsc == 0) {
ifsc = SEADER_T1_IFS_DEFAULT;
}
return remaining > ifsc ? ifsc : remaining;
}
bool seader_t1_validate_block(const uint8_t* block, size_t dw_length) {
if(!block || dw_length < 4) {
return false;
}
uint8_t len = block[2];
if(dw_length != (size_t)(len + 4)) {
return false;
}
return seader_validate_lrc((uint8_t*)block, dw_length);
}
void seader_t1_reset_link_state(SeaderT1State* t1) {
if(!t1) {
return;
}
t1->send_pcb = SEADER_T1_PCB_SEQUENCE_BIT;
t1->recv_pcb = 0x00;
if(t1->tx_buffer != NULL) {
bit_buffer_free(t1->tx_buffer);
}
t1->tx_buffer = NULL;
t1->tx_buffer_offset = 0;
t1->last_tx_len = 0;
if(t1->rx_buffer != NULL) {
bit_buffer_free(t1->rx_buffer);
}
t1->rx_buffer = NULL;
}
SeaderT1Action seader_t1_handle_block(
SeaderT1State* t1,
const uint8_t* payload,
size_t dw_length,
uint8_t** apdu_out,
size_t* apdu_len_out) {
if(!seader_t1_validate_block(payload, dw_length)) {
return SeaderT1ActionSendNak;
}
uint8_t rPCB = payload[1];
uint8_t LEN = payload[2];
if((rPCB & SEADER_T1_PCB_S_BLOCK) == SEADER_T1_PCB_S_BLOCK) {
uint8_t type = rPCB & SEADER_T1_S_BLOCK_TYPE_MASK;
bool is_response = (rPCB & SEADER_T1_S_BLOCK_RESPONSE_BIT) != 0;
/* The regression suite expects malformed S-block lengths to be rejected before payload use. */
if((type == SEADER_T1_S_BLOCK_IFS || type == SEADER_T1_S_BLOCK_WTX) && LEN != 1) {
return SeaderT1ActionSendNak;
}
if((type == SEADER_T1_S_BLOCK_RESYNCH || type == SEADER_T1_S_BLOCK_ABORT) && LEN != 0) {
return SeaderT1ActionSendNak;
}
switch(type) {
case SEADER_T1_S_BLOCK_IFS:
if(is_response) {
/* Only accept the pending IFSD we negotiated so a stray response cannot retune framing. */
uint8_t ifs = payload[3];
if(ifs == 0 || ifs > SEADER_T1_IFS_MAX) {
return SeaderT1ActionSendNak;
}
if(t1->ifsd_pending != 0 && ifs != t1->ifsd_pending) {
return SeaderT1ActionSendNak;
}
t1->ifsd = ifs;
t1->ifsd_pending = 0;
return SeaderT1ActionSendVersion;
} else {
/* Card-initiated IFS updates our outbound chunk size and must be echoed back verbatim. */
uint8_t ifs = payload[3];
if(ifs == 0 || ifs > SEADER_T1_IFS_MAX) {
return SeaderT1ActionSendNak;
}
t1->ifsc = ifs;
*apdu_out = (uint8_t*)payload + 3;
*apdu_len_out = 1;
return SeaderT1ActionSendIFSResponse;
}
case SEADER_T1_S_BLOCK_WTX:
if(!is_response) {
/* WTX requests do not advance link state; they only request a matching S(WTX response). */
*apdu_out = (uint8_t*)payload + 3;
*apdu_len_out = LEN;
return SeaderT1ActionSendWTXResponse;
}
break;
case SEADER_T1_S_BLOCK_RESYNCH:
if(!is_response) {
/* RESYNCH resets sequence tracking before we send the response frame. */
return SeaderT1ActionSendResynchResponse;
}
break;
case SEADER_T1_S_BLOCK_ABORT:
return SeaderT1ActionError;
}
return SeaderT1ActionNone;
}
if(rPCB == t1->recv_pcb) {
if(LEN > t1->ifsd) {
return SeaderT1ActionSendNak;
}
t1->recv_pcb = seader_t1_next_pcb(t1->recv_pcb);
if(t1->tx_buffer != NULL) {
bit_buffer_free(t1->tx_buffer);
t1->tx_buffer = NULL;
t1->tx_buffer_offset = 0;
t1->last_tx_len = 0;
}
if(t1->rx_buffer != NULL) {
bit_buffer_append_bytes(t1->rx_buffer, payload + 3, LEN);
*apdu_out = (uint8_t*)bit_buffer_get_data(t1->rx_buffer);
*apdu_len_out = bit_buffer_get_size_bytes(t1->rx_buffer);
return SeaderT1ActionDeliverAPDU;
}
if(LEN == 0) {
return SeaderT1ActionNone;
}
*apdu_out = (uint8_t*)payload + 3;
*apdu_len_out = LEN;
return SeaderT1ActionDeliverAPDU;
} else if(rPCB == (t1->recv_pcb | SEADER_T1_PCB_I_BLOCK_MORE)) {
if(LEN > t1->ifsd) {
return SeaderT1ActionSendNak;
}
t1->recv_pcb = seader_t1_next_pcb(t1->recv_pcb);
if(t1->rx_buffer == NULL) {
t1->rx_buffer = bit_buffer_alloc(512);
}
bit_buffer_append_bytes(t1->rx_buffer, payload + 3, LEN);
return SeaderT1ActionSendAck;
} else if((rPCB & SEADER_T1_PCB_R_BLOCK) == SEADER_T1_PCB_R_BLOCK) {
uint8_t r_seq = (rPCB & SEADER_T1_R_BLOCK_SEQUENCE_MASK) >> 4;
uint8_t next_i_seq = (t1->send_pcb ^ SEADER_T1_PCB_SEQUENCE_BIT) >> 6;
uint8_t err = rPCB & 0x0F;
if(err == 0 && r_seq == next_i_seq) {
/* Matching R-block ACKs advance a chained transmit if more buffered data remains. */
if(t1->tx_buffer != NULL) {
if(t1->tx_buffer_offset < bit_buffer_get_size_bytes(t1->tx_buffer)) {
return SeaderT1ActionSendMoreData;
}
return SeaderT1ActionNone;
}
return SeaderT1ActionNone;
} else {
if(t1->tx_buffer != NULL) {
/* NACK retransmits the previous chunk by rewinding exactly last_tx_len bytes. */
if(t1->last_tx_len == 0 || t1->last_tx_len > t1->tx_buffer_offset) {
return SeaderT1ActionError;
}
t1->tx_buffer_offset -= t1->last_tx_len;
t1->send_pcb ^= SEADER_T1_PCB_SEQUENCE_BIT;
return SeaderT1ActionRetransmit;
}
return SeaderT1ActionError;
}
}
return SeaderT1ActionError;
}
t_1_logic.h
+73
View File
@@ -0,0 +1,73 @@
#pragma once
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
typedef enum {
SEADER_T1_PCB_I_BLOCK_MORE = 0x20,
SEADER_T1_PCB_SEQUENCE_BIT = 0x40,
SEADER_T1_PCB_R_BLOCK = 0x80,
SEADER_T1_PCB_S_BLOCK = 0xC0,
SEADER_T1_R_BLOCK_SEQUENCE_MASK = 0x10,
SEADER_T1_S_BLOCK_RESPONSE_BIT = 0x20,
SEADER_T1_S_BLOCK_TYPE_MASK = 0x1F,
SEADER_T1_S_BLOCK_RESYNCH = 0x00,
SEADER_T1_S_BLOCK_IFS = 0x01,
SEADER_T1_S_BLOCK_ABORT = 0x02,
SEADER_T1_S_BLOCK_WTX = 0x03,
} SeaderT1Constant;
typedef enum {
SeaderT1ActionNone,
SeaderT1ActionDeliverAPDU,
SeaderT1ActionSendAck,
SeaderT1ActionSendIFSResponse,
SeaderT1ActionSendWTXResponse,
SeaderT1ActionSendResynchResponse,
SeaderT1ActionSendVersion,
SeaderT1ActionSendMoreData,
SeaderT1ActionRetransmit,
SeaderT1ActionSendNak,
SeaderT1ActionError,
} SeaderT1Action;
typedef struct BitBuffer BitBuffer;
typedef struct {
/* ICC information field size (card receive capability; host transmit chunking). */
uint8_t ifsc;
/* IFD information field size (host receive capability; card transmit chunking). */
uint8_t ifsd;
/* Pending IFSD value proposed through S(IFS request); 0 means none pending. */
uint8_t ifsd_pending;
/* Host NAD used for T=1 block exchange. */
uint8_t nad;
/* Last transmit I-block sequence bit. */
uint8_t send_pcb;
/* Last receive I-block sequence bit. */
uint8_t recv_pcb;
BitBuffer* tx_buffer;
size_t tx_buffer_offset;
/* Length of the last transmitted chunk, used to roll back on NACK. */
size_t last_tx_len;
BitBuffer* rx_buffer;
} SeaderT1State;
enum {
SEADER_T1_IFS_DEFAULT = 32,
SEADER_T1_IFS_MAX = 254,
};
uint8_t seader_t1_next_pcb(uint8_t current_pcb);
bool seader_t1_apdu_in_scratchpad(const uint8_t* tx_buf, size_t tx_buf_size, const uint8_t* apdu);
size_t seader_t1_chunk_length(size_t total_length, size_t offset, uint8_t ifsc);
bool seader_t1_validate_block(const uint8_t* block, size_t dw_length);
void seader_t1_reset_link_state(SeaderT1State* t1);
SeaderT1Action seader_t1_handle_block(
SeaderT1State* t1,
const uint8_t* payload,
size_t dw_length,
uint8_t** apdu_out,
size_t* apdu_len_out);