Merge pull request #3369 from dangerous-tac0s/15693-inventory-enhancements

15693 inventory enhancements
This commit is contained in:
Iceman authored and GitHub committed 2026-06-09 07:59:40 +02:00
commit d9265ad813
3 files changed
+651 -61

No files matched your search

+173 -54
View File
@@ -51,8 +51,9 @@
// *) UID is always used "transmission order" (LSB), which is reverse to display order
// TODO / BUGS / ISSUES:
// *) signal decoding is unable to detect collisions.
// *) add anti-collision support for inventory-commands
// *) signal decoding has basic collision detection via signal_activity flag
// (detects modulation-in-both-halves and failed SOF patterns)
// *) 16-slot inventory with anti-collision tree walking is implemented
// *) read security status of a block
// *) simulation do not support two subcarrier modes.
// *) remove or refactor code under "deprecated"
@@ -90,6 +91,11 @@
// times in samples @ 212kHz when acting as reader
#define ISO15693_READER_TIMEOUT 330 // 330/212kHz = 1558us
#define ISO15693_READER_TIMEOUT_WRITE 4700 // 4700/212kHz = 22ms, nominal 20ms
// Per-slot listen window for 16-slot inventory. Only needs to catch the START of a
// response (a SOF) within t1 (~320us) + margin -- once a SOF is detected the timeout
// no longer applies and the full response is received. Tuned down from the single-slot
// ISO15693_READER_TIMEOUT (1558us) to speed up empty slots. Bump up if tags get missed.
#define ISO15693_INVENTORY_SLOT_TIMEOUT 160 // 160/212kHz = 755us (~2.3x t1)
// iceman: This defines below exists in the header file, just here for my easy reading
// Delays in SSP_CLK ticks.
@@ -436,6 +442,7 @@ typedef struct {
int threshold_sof;
int threshold_half;
uint16_t previous_amplitude;
bool signal_activity; // set when signal detected but decode failed (collision hint)
uint8_t *output;
} DecodeTag_t;
@@ -491,6 +498,7 @@ static RAMFUNC int Handle15693SamplesFromTag(uint16_t amplitude, DecodeTag_t *ta
tag->state = STATE_TAG_SOF_HIGH_END;
}
} else { // high phase was too short
tag->signal_activity = true; // signal detected but SOF failed (possible collision)
tag->posCount = 1;
tag->previous_amplitude = amplitude;
tag->state = STATE_TAG_SOF_LOW;
@@ -513,6 +521,7 @@ static RAMFUNC int Handle15693SamplesFromTag(uint16_t amplitude, DecodeTag_t *ta
} else {
tag->posCount++;
if (tag->posCount > (recv_speed ? 13 : 52)) { // high phase too long
tag->signal_activity = true; // signal detected but SOF failed (possible collision)
tag->posCount = 0;
tag->previous_amplitude = amplitude;
tag->state = STATE_TAG_SOF_LOW;
@@ -539,6 +548,7 @@ static RAMFUNC int Handle15693SamplesFromTag(uint16_t amplitude, DecodeTag_t *ta
if (tag->lastBit == LOGIC0) { // this was already part of EOF
tag->state = STATE_TAG_EOF;
} else {
tag->signal_activity = true; // collision: modulation in both halves during data
tag->posCount = 0;
tag->previous_amplitude = amplitude;
tag->state = STATE_TAG_SOF_LOW;
@@ -721,6 +731,7 @@ typedef struct DecodeTagFSK {
uint8_t shiftReg;
uint16_t len;
uint16_t max_len;
bool signal_activity; // set when signal detected but decode failed (collision hint)
uint8_t *output;
} DecodeTagFSK_t;
@@ -887,6 +898,7 @@ static int RAMFUNC Handle15693FSKSamplesFromTag(uint8_t freq, DecodeTagFSK_t *De
Dbprintf("RECEIVING_DATA_424 error: freq=%d, count=%d, recv_speed=%d, lastbit=%d, state=%d", freq, DecodeTag->count, recv_speed, DecodeTag->lastBit, DecodeTag->state);
}
#endif
DecodeTag->signal_activity = true; // signal present but decode failed (possible collision)
DecodeTag->state = STATE_FSK_ERROR;
LED_C_OFF();
return true;
@@ -944,6 +956,7 @@ static int RAMFUNC Handle15693FSKSamplesFromTag(uint8_t freq, DecodeTagFSK_t *De
}
#endif
LED_C_OFF();
DecodeTag->signal_activity = true; // signal present but decode failed (possible collision)
DecodeTag->state = STATE_FSK_ERROR;
return true;
}
@@ -1081,7 +1094,12 @@ int GetIso15693AnswerFromTag(uint8_t *response, uint16_t max_len, uint16_t timeo
// timeout
if (samples > timeout && dtf->state < STATE_FSK_RECEIVING_DATA_484) {
ret = PM3_ETIMEOUT;
if (dtf->signal_activity) {
ret = PM3_EPARTIAL;
if (g_dbglevel >= DBG_DEBUG) Dbprintf("ISO15693 FSK: signal activity detected but decode failed (collision hint)");
} else {
ret = PM3_ETIMEOUT;
}
break;
}
@@ -1104,7 +1122,12 @@ int GetIso15693AnswerFromTag(uint8_t *response, uint16_t max_len, uint16_t timeo
// timeout
if (samples > timeout && dt->state < STATE_TAG_RECEIVING_DATA) {
ret = PM3_ETIMEOUT;
if (dt->signal_activity) {
ret = PM3_EPARTIAL;
if (g_dbglevel >= DBG_DEBUG) Dbprintf("ISO15693: signal activity detected but decode failed (collision hint)");
} else {
ret = PM3_ETIMEOUT;
}
break;
}
}
@@ -2802,76 +2825,172 @@ void SendRawCommand15693(iso15_raw_cmd_t *packet) {
timeout = ISO15693_READER_TIMEOUT_WRITE;
}
if (packet->rawlen == 0) {
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_EINVARG, NULL, 0);
LED_A_OFF();
return;
}
bool speed = ((packet->flags & ISO15_HIGH_SPEED) == ISO15_HIGH_SPEED);
bool keep_field_on = ((packet->flags & ISO15_NO_DISCONNECT) == ISO15_NO_DISCONNECT);
bool read_respone = ((packet->flags & ISO15_READ_RESPONSE) == ISO15_READ_RESPONSE);
bool init = ((packet->flags & ISO15_CONNECT) == ISO15_CONNECT);
// This is part of ISO15693 protocol definitions where the following commands needs to request option.
// note:
// it seem like previous we just guessed and never followed the fISO145_REQ_OPTION flag if it was set / not set from client side.
// this is a problem. Since without this the response from the tag is one byte shorter. And a lot of client side functions has been
// hardcoded to assume for the extra byte in the response.
// Detect 16-slot inventory mode from protocol flags
bool is_inventory = (packet->raw[0] & ISO15_REQ_INVENTORY) != 0;
bool is_16slot = is_inventory && ((packet->raw[0] & ISO15_REQINV_SLOT1) == 0);
bool request_answer = false;
if (is_16slot) {
// 16-slot inventory: send command for slot 0, then EOF for slots 1-15
bool fsk = ((packet->raw[0] & ISO15_REQ_SUBCARRIER_TWO) == ISO15_REQ_SUBCARRIER_TWO);
bool recv_speed = ((packet->raw[0] & ISO15_REQ_DATARATE_HIGH) == ISO15_REQ_DATARATE_HIGH);
switch (packet->raw[1]) {
case ISO15693_SET_PASSWORD:
case ISO15693_ENABLE_PRIVACY:
case ISO15693_WRITEBLOCK:
case ISO15693_LOCKBLOCK:
case ISO15693_WRITE_MULTI_BLOCK:
case ISO15693_WRITE_AFI:
case ISO15693_LOCK_AFI:
case ISO15693_WRITE_DSFID:
case ISO15693_WRITE_PASSWORD:
case ISO15693_PASSWORD_PROTECT_EAS:
case ISO15693_LOCK_DSFID:
request_answer = ((packet->raw[0] & ISO15_REQ_OPTION) == ISO15_REQ_OPTION);
break;
default:
break;
}
uint8_t resp_buf[PM3_CMD_DATA_SIZE] = {0};
iso15_inventory_response_t *resp = (iso15_inventory_response_t *)resp_buf;
resp->slot_count = 16;
uint32_t eof_time = 0;
uint32_t start_time = 0;
uint16_t recvlen = 0;
uint8_t recv[ISO15693_MAX_SLOT_RESPONSE] = {0};
uint32_t eof_time = 0;
uint32_t start_time = 0;
uint16_t recvlen = 0;
uint16_t data_offset = 0;
// Maximum data space available after the fixed header
uint16_t max_data = PM3_CMD_DATA_SIZE - 1 - (ISO15693_MAX_SLOTS * sizeof(iso15_slot_result_t));
uint8_t buf[ISO15693_MAX_RESPONSE_LENGTH] = {0x00};
// Slot 0: send the full command
int res = SendDataTag(packet->raw, packet->rawlen, init, speed,
recv, sizeof(recv), start_time, ISO15693_INVENTORY_SLOT_TIMEOUT,
&eof_time, &recvlen);
int res = SendDataTag(packet->raw, packet->rawlen, init, speed, (read_respone ? buf : NULL), sizeof(buf), start_time, timeout, &eof_time, &recvlen);
if (res == PM3_ETEAROFF) {
reply_ng(CMD_HF_ISO15693_COMMAND, res, NULL, 0);
goto out;
}
if (res == PM3_ETEAROFF) { // tearoff occurred
reply_ng(CMD_HF_ISO15693_COMMAND, res, NULL, 0);
} else {
// if tag answers with an error code, it don't care about EOF packet
// normal tag answer without Option_flag also processed here
if (recvlen || !request_answer) {
if (request_answer || read_respone) {
recvlen = MIN(recvlen, ISO15693_MAX_RESPONSE_LENGTH);
reply_ng(CMD_HF_ISO15693_COMMAND, res, buf, recvlen);
} else {
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_SUCCESS, NULL, 0);
}
if (res == PM3_SUCCESS && recvlen > 0) {
resp->slots[0].status = 1; // got data (client validates CRC for collision detection)
resp->slots[0].len = MIN(recvlen, ISO15693_MAX_SLOT_RESPONSE);
} else if (res == PM3_EPARTIAL) {
resp->slots[0].status = 2; // signal detected but decode failed (collision hint)
resp->slots[0].len = 0;
} else {
// looking at the first byte of the RAW bytes to determine Subcarrier, datarate, request option
bool fsk = ((packet->raw[0] & ISO15_REQ_SUBCARRIER_TWO) == ISO15_REQ_SUBCARRIER_TWO);
bool recv_speed = ((packet->raw[0] & ISO15_REQ_DATARATE_HIGH) == ISO15_REQ_DATARATE_HIGH);
resp->slots[0].status = 0; // no response / timeout
resp->slots[0].len = 0;
}
// send a single EOF to get the tag response
if (resp->slots[0].len > 0 && data_offset + resp->slots[0].len <= max_data) {
memcpy(resp->data + data_offset, recv, resp->slots[0].len);
data_offset += resp->slots[0].len;
} else {
resp->slots[0].len = 0;
}
// Slots 1-15: send EOF and listen
for (uint8_t slot = 1; slot < 16; slot++) {
start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
res = SendDataTagEOF((read_respone ? buf : NULL), sizeof(buf), start_time, ISO15693_READER_TIMEOUT, &eof_time, fsk, recv_speed, &recvlen);
recvlen = 0;
memset(recv, 0, sizeof(recv));
if (read_respone) {
recvlen = MIN(recvlen, ISO15693_MAX_RESPONSE_LENGTH);
reply_ng(CMD_HF_ISO15693_COMMAND, res, buf, recvlen);
res = SendDataTagEOF(recv, sizeof(recv), start_time,
ISO15693_INVENTORY_SLOT_TIMEOUT, &eof_time,
fsk, recv_speed, &recvlen);
if (res == PM3_SUCCESS && recvlen > 0) {
resp->slots[slot].status = 1; // got data (client validates CRC)
resp->slots[slot].len = MIN(recvlen, ISO15693_MAX_SLOT_RESPONSE);
} else if (res == PM3_EPARTIAL) {
resp->slots[slot].status = 2; // signal detected but decode failed (collision hint)
resp->slots[slot].len = 0;
} else {
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_SUCCESS, NULL, 0);
resp->slots[slot].status = 0; // no response / timeout
resp->slots[slot].len = 0;
}
if (resp->slots[slot].len > 0 && data_offset + resp->slots[slot].len <= max_data) {
memcpy(resp->data + data_offset, recv, resp->slots[slot].len);
data_offset += resp->slots[slot].len;
} else if (resp->slots[slot].len > 0) {
// No room left, truncate
resp->slots[slot].len = 0;
resp->slots[slot].status = 0;
}
WDT_HIT();
}
uint16_t total_len = 1 + (16 * sizeof(iso15_slot_result_t)) + data_offset;
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_SUCCESS, resp_buf, MIN(total_len, PM3_CMD_DATA_SIZE));
} else {
// Original single send-receive path (1-slot or non-inventory commands)
// This is part of ISO15693 protocol definitions where the following commands needs to request option.
// note:
// it seem like previous we just guessed and never followed the fISO145_REQ_OPTION flag if it was set / not set from client side.
// this is a problem. Since without this the response from the tag is one byte shorter. And a lot of client side functions has been
// hardcoded to assume for the extra byte in the response.
bool request_answer = false;
switch (packet->raw[1]) {
case ISO15693_SET_PASSWORD:
case ISO15693_ENABLE_PRIVACY:
case ISO15693_WRITEBLOCK:
case ISO15693_LOCKBLOCK:
case ISO15693_WRITE_MULTI_BLOCK:
case ISO15693_WRITE_AFI:
case ISO15693_LOCK_AFI:
case ISO15693_WRITE_DSFID:
case ISO15693_WRITE_PASSWORD:
case ISO15693_PASSWORD_PROTECT_EAS:
case ISO15693_LOCK_DSFID:
request_answer = ((packet->raw[0] & ISO15_REQ_OPTION) == ISO15_REQ_OPTION);
break;
default:
break;
}
uint32_t eof_time = 0;
uint32_t start_time = 0;
uint16_t recvlen = 0;
uint8_t buf[ISO15693_MAX_RESPONSE_LENGTH] = {0x00};
int res = SendDataTag(packet->raw, packet->rawlen, init, speed, (read_respone ? buf : NULL), sizeof(buf), start_time, timeout, &eof_time, &recvlen);
if (res == PM3_ETEAROFF) { // tearoff occurred
reply_ng(CMD_HF_ISO15693_COMMAND, res, NULL, 0);
} else {
// if tag answers with an error code, it don't care about EOF packet
// normal tag answer without Option_flag also processed here
if (recvlen || !request_answer) {
if (request_answer || read_respone) {
recvlen = MIN(recvlen, ISO15693_MAX_RESPONSE_LENGTH);
reply_ng(CMD_HF_ISO15693_COMMAND, res, buf, recvlen);
} else {
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_SUCCESS, NULL, 0);
}
} else {
// looking at the first byte of the RAW bytes to determine Subcarrier, datarate, request option
bool fsk = ((packet->raw[0] & ISO15_REQ_SUBCARRIER_TWO) == ISO15_REQ_SUBCARRIER_TWO);
bool recv_speed = ((packet->raw[0] & ISO15_REQ_DATARATE_HIGH) == ISO15_REQ_DATARATE_HIGH);
// send a single EOF to get the tag response
start_time = eof_time + DELAY_ISO15693_VICC_TO_VCD_READER;
res = SendDataTagEOF((read_respone ? buf : NULL), sizeof(buf), start_time, ISO15693_READER_TIMEOUT, &eof_time, fsk, recv_speed, &recvlen);
if (read_respone) {
recvlen = MIN(recvlen, ISO15693_MAX_RESPONSE_LENGTH);
reply_ng(CMD_HF_ISO15693_COMMAND, res, buf, recvlen);
} else {
reply_ng(CMD_HF_ISO15693_COMMAND, PM3_SUCCESS, NULL, 0);
}
}
}
}
out:
if (keep_field_on == false) {
switch_off(); // disconnect raw
SpinDelay(20);
+463 -7
View File
@@ -447,6 +447,7 @@ static int getUID(bool verbose, bool loop, uint8_t *buf) {
if (verbose) {
PrintAndLogEx(NORMAL, "");
PrintAndLogEx(SUCCESS, "UID.... " _GREEN_("%s"), iso15693_sprintUID(NULL, buf));
PrintAndLogEx(SUCCESS, "DSFID.. %02X", resp.data.asBytes[1]);
printTagInfo_15(buf);
PrintAndLogEx(NORMAL, "");
}
@@ -472,6 +473,124 @@ bool readHF15Uid(bool loop, bool verbose) {
return true;
}
// Per-slot result for 16-slot inventory
typedef struct {
uint8_t slot;
uint8_t status; // 0=empty, 1=valid, 2=collision (CRC fail)
uint8_t data[ISO15693_MAX_SLOT_RESPONSE];
uint8_t data_len;
} iso15_inventory_result_t;
// Performs a 16-slot (or 1-slot) inventory round with arbitrary command bytes.
// raw_cmd: full ISO 15693 command bytes (flags + cmd_code + params), WITHOUT CRC
// raw_len: length of raw_cmd
// add_crc: whether to append CRC15
// fast: true for high-speed (1 out of 4), false for low-speed (1 out of 256)
// keep_field_on: if true, keep RF field active after command (for multi-round tree walking)
// results: caller-provided array of iso15_inventory_result_t[16]
// num_found: output - number of slots with valid (CRC-OK) responses
// Returns PM3_SUCCESS or error code
static int perform_iso15_inventory(
const uint8_t *raw_cmd,
uint16_t raw_len,
bool add_crc,
bool fast,
bool keep_field_on,
iso15_inventory_result_t *results,
uint8_t *num_found
) {
*num_found = 0;
memset(results, 0, sizeof(iso15_inventory_result_t) * ISO15693_MAX_SLOTS);
uint16_t cmdlen = raw_len + (add_crc ? 2 : 0);
iso15_raw_cmd_t *packet = (iso15_raw_cmd_t *)calloc(1, sizeof(iso15_raw_cmd_t) + cmdlen);
if (packet == NULL) {
PrintAndLogEx(WARNING, "Failed to allocate memory");
return PM3_EMALLOC;
}
memcpy(packet->raw, raw_cmd, raw_len);
packet->rawlen = raw_len;
if (add_crc) {
AddCrc15(packet->raw, raw_len);
packet->rawlen += 2;
}
packet->flags = ISO15_CONNECT | ISO15_READ_RESPONSE;
if (fast) {
packet->flags |= ISO15_HIGH_SPEED;
}
if (keep_field_on) {
packet->flags |= ISO15_NO_DISCONNECT;
}
// Determine if this is a 16-slot request
bool is_inventory = (raw_cmd[0] & ISO15_REQ_INVENTORY) != 0;
bool is_16slot = is_inventory && ((raw_cmd[0] & ISO15_REQINV_SLOT1) == 0);
uint8_t num_slots = is_16slot ? 16 : 1;
clearCommandBuffer();
SendCommandNG(CMD_HF_ISO15693_COMMAND, (uint8_t *)packet, ISO15_RAW_LEN(packet->rawlen));
free(packet);
PacketResponseNG resp;
if (!WaitForResponseTimeout(CMD_HF_ISO15693_COMMAND, &resp, 4000)) {
PrintAndLogEx(WARNING, "timeout while waiting for reply");
return PM3_ETIMEOUT;
}
if (resp.status != PM3_SUCCESS) {
return resp.status;
}
if (is_16slot) {
// Parse multi-slot response (iso15_inventory_response_t format)
if (resp.length < 1 + (num_slots * 2)) {
PrintAndLogEx(WARNING, "response too short for 16-slot inventory");
return PM3_ESOFT;
}
iso15_inventory_response_t *inv = (iso15_inventory_response_t *)resp.data.asBytes;
uint16_t offset = 0;
for (uint8_t s = 0; s < num_slots; s++) {
results[s].slot = s;
results[s].status = inv->slots[s].status;
results[s].data_len = inv->slots[s].len;
if (inv->slots[s].len > 0 && inv->slots[s].len <= sizeof(results[s].data)) {
memcpy(results[s].data, inv->data + offset, inv->slots[s].len);
offset += inv->slots[s].len;
// Validate CRC to distinguish valid response from collision
if (inv->slots[s].status == 1) {
if (inv->slots[s].len >= 4 && CheckCrc15(results[s].data, inv->slots[s].len)) {
(*num_found)++;
} else {
results[s].status = 2; // CRC fail = collision
}
}
}
}
} else {
// Single-slot: parse as normal single response
results[0].slot = 0;
if (resp.length >= 12 && CheckCrc15(resp.data.asBytes, resp.length)) {
results[0].status = 1;
results[0].data_len = MIN(resp.length, sizeof(results[0].data));
memcpy(results[0].data, resp.data.asBytes, results[0].data_len);
(*num_found)++;
} else if (resp.length > 0) {
results[0].status = 2; // got data but CRC failed
results[0].data_len = MIN(resp.length, sizeof(results[0].data));
memcpy(results[0].data, resp.data.asBytes, results[0].data_len);
} else {
results[0].status = 0;
results[0].data_len = 0;
}
}
return PM3_SUCCESS;
}
// adds 6
static uint8_t arg_add_default(void *at[]) {
at[0] = arg_param_begin;
@@ -1175,26 +1294,329 @@ static int CmdHF15Sniff(const char *Cmd) {
return PM3_SUCCESS;
}
// Single 1-slot inventory round with optional AFI and speed control
static int reader_single_tag(bool fast, bool loop, uint8_t *afi_buf, int afi_len) {
do {
uint8_t raw_cmd[8] = {0};
uint16_t raw_len = 0;
raw_cmd[raw_len] = ISO15_REQ_SUBCARRIER_SINGLE
| ISO15_REQ_DATARATE_HIGH
| ISO15_REQ_INVENTORY
| ISO15_REQINV_SLOT1;
if (afi_len > 0)
raw_cmd[raw_len] |= ISO15_REQINV_AFI;
raw_len++;
raw_cmd[raw_len++] = ISO15693_INVENTORY;
if (afi_len > 0)
raw_cmd[raw_len++] = afi_buf[0];
raw_cmd[raw_len++] = 0; // mask length = 0
iso15_inventory_result_t results[ISO15693_MAX_SLOTS] = {{0}};
uint8_t num_found = 0;
int res = perform_iso15_inventory(raw_cmd, raw_len, true, fast, false, results, &num_found);
if (res == PM3_SUCCESS && num_found > 0 && results[0].status == 1 && results[0].data_len >= 12) {
uint8_t uid[8];
memcpy(uid, results[0].data + 2, 8);
PrintAndLogEx(NORMAL, "");
PrintAndLogEx(SUCCESS, "UID.... " _GREEN_("%s"), iso15693_sprintUID(NULL, uid));
PrintAndLogEx(SUCCESS, "DSFID.. %02X", results[0].data[1]);
printTagInfo_15(uid);
PrintAndLogEx(NORMAL, "");
if (!loop)
return PM3_SUCCESS;
}
} while (loop && kbd_enter_pressed() == false);
return PM3_SUCCESS;
}
// 16-slot anti-collision tree walking to discover all tags in the field
// One persistent row per UID ever seen during a continuous `hf 15 reader --all -@`.
typedef struct {
uint8_t uid[8];
uint8_t dsfid;
uint64_t last_seen_ms;
bool present;
} iso15_seen_tag_t;
// Redraw the presence table in place via cursor-up. Printed with newlines BETWEEN rows but none
// after the last, so the cursor never drops below the bottom row (a trailing newline at the
// screen bottom would scroll and leave the header behind). To refresh, return to the top of the
// block (\r + cursor-up) and clear to end of screen. All printf, so header/data columns align.
static void iso15_render_presence_table(const iso15_seen_tag_t *seen, int n,
bool inplace, bool *first_draw, int *table_lines) {
if (inplace && (*first_draw == false)) {
if (*table_lines > 1) {
printf("\r\x1b[%dA\x1b[J", *table_lines - 1);
} else {
printf("\r\x1b[J");
}
} else if ((inplace == false) && (*first_draw == false)) {
printf("\n"); // piped/non-TTY: separate snapshots
}
int present = 0;
for (int i = 0; i < n; i++) {
if (seen[i].present) present++;
}
uint64_t now = msclock();
const char *c_grn = g_session.supports_colors ? "\x1b[32m" : "";
const char *c_yel = g_session.supports_colors ? "\x1b[33m" : "";
const char *c_off = g_session.supports_colors ? "\x1b[0m" : "";
int lines = 0;
printf("hf 15 --all present %d / %d " _GREEN_("<Enter>") " to exit", present, n); lines++;
printf("\n%3s %-25s %-5s %s", "#", "UID", "DSFID", "status"); lines++;
printf("\n%3s %-25s %-5s %s", "---", "-------------------------", "-----", "----------------"); lines++;
for (int i = 0; i < n; i++) {
if (seen[i].present) {
printf("\n%3d %-25s %02X %spresent%s",
i + 1, iso15693_sprintUID(NULL, (uint8_t *)seen[i].uid), seen[i].dsfid, c_grn, c_off);
} else {
uint32_t secs = (uint32_t)((now - seen[i].last_seen_ms) / 1000);
printf("\n%3d %-25s %02X %sgone%s (%us ago)",
i + 1, iso15693_sprintUID(NULL, (uint8_t *)seen[i].uid), seen[i].dsfid, c_yel, c_off, secs);
}
lines++;
}
*table_lines = lines;
*first_draw = false;
fflush(stdout);
}
static int reader_inventory_all(bool fast, bool loop, uint8_t *afi_buf, int afi_len) {
typedef struct {
uint8_t mask[8];
uint8_t mask_len; // in bits
} inventory_work_item_t;
#define MAX_WORK_ITEMS 256
#define MAX_FOUND_TAGS 64
#define MAX_SEEN_TAGS 128
// Persistent across scans in continuous (-@) mode: every UID seen this session.
iso15_seen_tag_t seen[MAX_SEEN_TAGS];
int seen_count = 0;
bool inplace = loop && g_session.stdoutOnTTY;
bool first_draw = true;
int table_lines = 0;
do {
inventory_work_item_t work_queue[MAX_WORK_ITEMS];
int work_head = 0;
int work_tail = 0;
uint8_t found_uids[MAX_FOUND_TAGS][8];
uint8_t found_dsfids[MAX_FOUND_TAGS];
int found_count = 0;
// Start with empty mask
memset(&work_queue[0], 0, sizeof(inventory_work_item_t));
work_tail = 1;
while (work_head < work_tail && work_head < MAX_WORK_ITEMS) {
inventory_work_item_t *item = &work_queue[work_head++];
// Build inventory command with current mask
uint8_t raw_cmd[16] = {0};
uint16_t raw_len = 0;
raw_cmd[raw_len] = ISO15_REQ_SUBCARRIER_SINGLE
| ISO15_REQ_DATARATE_HIGH
| ISO15_REQ_INVENTORY;
// 16-slot: do NOT set ISO15_REQINV_SLOT1
if (afi_len > 0)
raw_cmd[raw_len] |= ISO15_REQINV_AFI;
raw_len++;
raw_cmd[raw_len++] = ISO15693_INVENTORY;
if (afi_len > 0)
raw_cmd[raw_len++] = afi_buf[0];
raw_cmd[raw_len++] = item->mask_len;
// Copy mask bytes
uint8_t mask_bytes = (item->mask_len + 7) / 8;
if (mask_bytes > 0) {
memcpy(raw_cmd + raw_len, item->mask, mask_bytes);
raw_len += mask_bytes;
}
iso15_inventory_result_t results[ISO15693_MAX_SLOTS] = {{0}};
uint8_t num_found = 0;
// Always keep field on during tree walking; we drop it once after the loop
int res = perform_iso15_inventory(raw_cmd, raw_len, true, fast, true, results, &num_found);
if (res != PM3_SUCCESS) {
PrintAndLogEx(DEBUG, "Inventory round failed (mask_len=%d)", item->mask_len);
continue;
}
for (uint8_t s = 0; s < 16; s++) {
if (results[s].status == 1 && results[s].data_len >= 12) {
// Valid response: extract UID (in transmission order, LSB first)
uint8_t uid[8];
memcpy(uid, results[s].data + 2, 8);
// Check for duplicate
bool duplicate = false;
for (int d = 0; d < found_count; d++) {
if (memcmp(found_uids[d], uid, 8) == 0) {
duplicate = true;
break;
}
}
if (!duplicate && found_count < MAX_FOUND_TAGS) {
memcpy(found_uids[found_count], uid, 8);
found_dsfids[found_count] = results[s].data[1];
found_count++;
}
} else if (results[s].status == 2) {
// Collision in this slot - add to work queue with extended mask
if (item->mask_len + 4 <= 64 && work_tail < MAX_WORK_ITEMS) {
inventory_work_item_t *new_item = &work_queue[work_tail++];
memcpy(new_item->mask, item->mask, sizeof(new_item->mask));
new_item->mask_len = item->mask_len + 4;
// The slot number (0-15) represents the 4 bits that
// differentiated this slot. Append slot number to mask.
uint8_t bit_pos = item->mask_len;
uint8_t byte_pos = bit_pos / 8;
uint8_t bit_offset = bit_pos % 8;
// Write the 4-bit slot number into the mask at the current position
if (byte_pos < 8) {
new_item->mask[byte_pos] |= (s << bit_offset) & 0xFF;
if (bit_offset > 4 && (byte_pos + 1) < 8) {
new_item->mask[byte_pos + 1] |= (s >> (8 - bit_offset)) & 0xFF;
}
}
}
}
// status == 0: no response, skip silently
}
if (kbd_enter_pressed()) {
PrintAndLogEx(INFO, "Aborted by user");
DropField();
return PM3_SUCCESS;
}
}
// NB: don't DropField() per scan in continuous mode -- it re-inits the field every
// round (slow, and spams "Setting ISODEP" when APDU logging is on). The next round
// re-selects anyway, and the field is dropped once when the loop exits.
if (loop) {
// Continuous mode: fold this scan into the persistent table and redraw it in place.
for (int i = 0; i < seen_count; i++) {
seen[i].present = false;
}
for (int j = 0; j < found_count; j++) {
int idx = -1;
for (int i = 0; i < seen_count; i++) {
if (memcmp(seen[i].uid, found_uids[j], 8) == 0) {
idx = i;
break;
}
}
if (idx < 0 && seen_count < MAX_SEEN_TAGS) {
idx = seen_count++;
memcpy(seen[idx].uid, found_uids[j], 8);
}
if (idx >= 0) {
seen[idx].dsfid = found_dsfids[j];
seen[idx].last_seen_ms = msclock();
seen[idx].present = true;
}
}
iso15_render_presence_table(seen, seen_count, inplace, &first_draw, &table_lines);
} else {
// Single-shot mode: list what was found.
if (found_count > 0) {
PrintAndLogEx(NORMAL, "");
PrintAndLogEx(SUCCESS, "Found " _GREEN_("%d") " tag(s):", found_count);
for (int i = 0; i < found_count; i++) {
PrintAndLogEx(SUCCESS, " %2d: UID " _GREEN_("%s") " DSFID: %02X",
i + 1,
iso15693_sprintUID(NULL, found_uids[i]),
found_dsfids[i]);
}
PrintAndLogEx(NORMAL, "");
} else {
PrintAndLogEx(WARNING, "No tags found");
}
}
} while (loop && kbd_enter_pressed() == false);
DropField();
return PM3_SUCCESS;
}
static int CmdHF15Reader(const char *Cmd) {
CLIParserContext *ctx;
CLIParserInit(&ctx, "hf 15 reader",
"Act as a ISO-15693 reader. Look for ISO-15693 tags until Enter or the pm3 button is pressed\n",
"Act as a ISO-15693 reader. Look for ISO-15693 tags until " _GREEN_("<Enter>") " is pressed\n"
"Use --all to perform 16-slot inventory with anti-collision tree walking\n"
"to discover all tags in the field.",
"hf 15 reader\n"
"hf 15 reader -@ -> Continuous mode");
"hf 15 reader -@ -> continuous mode\n"
"hf 15 reader --afi 01 -> filter by AFI\n"
"hf 15 reader -2 -> slower '1 out of 256' mode\n"
"hf 15 reader --all -> find all tags (16-slot anti-collision)\n"
"hf 15 reader --all -@ -> continuously scan for all tags\n"
"hf 15 reader --all --afi 01 -> find all tags with AFI filter\n"
"hf 15 reader --all -2 -> find all tags, slow mode\n");
void *argtable[] = {
arg_param_begin,
arg_lit0("@", NULL, "continuous reader mode"),
arg_lit0(NULL, "all", "find all tags using 16-slot anti-collision"),
arg_str0(NULL, "afi", "<hex>", "Application Family Identifier (1 byte)"),
arg_lit0("2", NULL, "use slower '1 out of 256' mode"),
arg_param_end
};
CLIExecWithReturn(ctx, Cmd, argtable, true);
bool cm = arg_get_lit(ctx, 1);
bool loop = arg_get_lit(ctx, 1);
bool all = arg_get_lit(ctx, 2);
int afi_len = 0;
uint8_t afi_buf[1] = {0};
CLIGetHexWithReturn(ctx, 3, afi_buf, &afi_len);
bool fast = (arg_get_lit(ctx, 4) == false); // default is fast
CLIParserFree(ctx);
if (cm) {
if (loop) {
PrintAndLogEx(INFO, "Press " _GREEN_("<Enter>") " to exit");
}
readHF15Uid(cm, true);
if (all) {
return reader_inventory_all(fast, loop, afi_buf, afi_len);
}
// Single-tag mode: use --afi/-2 aware path if those flags are set,
// otherwise preserve original behavior via readHF15Uid
if (afi_len > 0 || !fast) {
return reader_single_tag(fast, loop, afi_buf, afi_len);
}
readHF15Uid(loop, true);
return PM3_SUCCESS;
}
@@ -2179,15 +2601,49 @@ static int CmdHF15Raw(const char *Cmd) {
SendCommandNG(CMD_HF_ISO15693_COMMAND, (uint8_t *)packet, ISO15_RAW_LEN(datalen));
free(packet);
// Check if this was a 16-slot inventory request
bool is_inventory = (datalen > 0) && ((data[0] & ISO15_REQ_INVENTORY) != 0);
bool is_16slot = is_inventory && ((data[0] & ISO15_REQINV_SLOT1) == 0);
if (read_respone) {
PacketResponseNG resp;
if (WaitForResponseTimeout(CMD_HF_ISO15693_COMMAND, &resp, 2000)) {
if (WaitForResponseTimeout(CMD_HF_ISO15693_COMMAND, &resp, is_16slot ? 4000 : 2000)) {
if (resp.status == PM3_ETEAROFF) {
PrintAndLogEx(INFO, "Tear off triggered");
return resp.status;
}
if (resp.length < 2) {
if (is_16slot && resp.length >= 1 + (16 * sizeof(iso15_slot_result_t))) {
// Parse 16-slot inventory response
iso15_inventory_response_t *inv = (iso15_inventory_response_t *)resp.data.asBytes;
uint16_t offset = 0;
int found = 0;
for (uint8_t s = 0; s < inv->slot_count && s < 16; s++) {
if (inv->slots[s].status == 1 && inv->slots[s].len > 0) {
uint8_t *slot_data = inv->data + offset;
if (inv->slots[s].len >= 3 && CheckCrc15(slot_data, inv->slots[s].len)) {
// CRC valid - show raw hex (format varies by command)
PrintAndLogEx(SUCCESS, "Slot %2d: (%u) %s", s, inv->slots[s].len,
sprint_hex(slot_data, inv->slots[s].len));
found++;
} else {
PrintAndLogEx(INFO, "Slot %2d: " _YELLOW_("collision / CRC fail") " (%u) %s", s,
inv->slots[s].len,
sprint_hex(slot_data, inv->slots[s].len));
}
}
if (inv->slots[s].len > 0)
offset += inv->slots[s].len;
}
if (found == 0) {
PrintAndLogEx(WARNING, "No valid responses in any slot");
} else {
PrintAndLogEx(SUCCESS, "Found %d tag(s) in 16-slot inventory", found);
}
} else if (resp.length < 2) {
PrintAndLogEx(WARNING, "command failed");
} else {
PrintAndLogEx(SUCCESS, "(%u) %s", resp.length, sprint_hex(resp.data.asBytes, resp.length));
+15
View File
@@ -48,6 +48,21 @@ typedef struct {
uint8_t raw[]; // First byte in raw, raw[0] is ISO15693 protocol flag byte
} PACKED iso15_raw_cmd_t;
// 16-slot inventory support
#define ISO15693_MAX_SLOTS 16
#define ISO15693_MAX_SLOT_RESPONSE 128
typedef struct {
uint8_t status; // 0=no response (timeout), 1=valid response, 2=collision/error
uint8_t len; // response data length for this slot
} PACKED iso15_slot_result_t;
typedef struct {
uint8_t slot_count; // 1 or 16
iso15_slot_result_t slots[ISO15693_MAX_SLOTS]; // per-slot metadata
uint8_t data[]; // concatenated response bytes
} PACKED iso15_inventory_response_t;
#define ISO15693_TAG_MAX_PAGES 160 // in pages (0xA0)
#define ISO15693_TAG_MAX_SIZE 2048 // in byte (64 pages of 256 bits)