Merge pull request #3369 from dangerous-tac0s/15693-inventory-enhancements
15693 inventory enhancements
This commit is contained in:
3 files changed
+651
-61
No files matched your search
+173
-54
@@ -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
@@ -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));
|
||||
|
||||
@@ -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)
|
||||
|
||||
|
||||
Reference in new issue
Block a user