trace list/extract: frame bounds, CRC checks and annotation fixes

Annotators, `trace extract`, `-x` and `-c` stay inside the frame, the
trace and the row buffer, `-t ht2` inside the Hitag 2 state, and frame
lengths are 16 bit wide. Topaz, FeliCa and five byte ISO14443-A frames
get the right CRC check, Topaz and iCLASS traces tell their ISO14443-A
and ISO15693 frames apart, and the SEOS, 14b, DESFire and Hitag µ
labels are corrected. Six make check expectations on the repository
traces cover the fixes.

Co-Authored-By: Claude Mythos 5.1 <noreply@anthropic.com>
This commit is contained in:
Gabriele GristinaandClaude Mythos 5.1 committed 2026-11-08 01:18:04 +01:00
1 parent 444c703b37
commit c6dc5ef1bb
11 files changed
+537 -307

No files matched your search

+210 -164
View File
@@ -78,7 +78,7 @@ static uint8_t *gs_mfuc_key = NULL;
* 2 : Not crc-command
*/
uint8_t iso14443A_CRC_check(bool isResponse, uint8_t *d, uint8_t n) {
uint8_t iso14443A_CRC_check(bool isResponse, uint8_t *d, uint16_t n) {
// Neither half of a bit oriented ANTICOLLISION exchange carries a CRC: the
// request stops mid byte and the answer completes it. NVB counts SEL and
@@ -106,33 +106,21 @@ uint8_t iso14443A_CRC_check(bool isResponse, uint8_t *d, uint8_t n) {
return 2;
}
if (isResponse && (n == 5)) {
// an ANTICOLLISION answer, UID and BCC, has no CRC: its BCC tells it from
// a five byte ISO14443-4 answer
if (isResponse && (n == 5) && ((d[0] ^ d[1] ^ d[2] ^ d[3]) == d[4])) {
return 2;
}
return check_crc(CRC_14443_A, d, n);
}
uint8_t seos_CRC_check(bool isResponse, uint8_t *d, uint8_t n) {
if (n < 3) {
return 2;
}
// 5 bytes response Card busy 0xFA have crc, the rest is most likely 14a anticollision
if ((n == 5) && (d[0] != 0xFA)) {
return 2;
}
if (d[1] == 0x50 &&
d[0] >= ISO14443A_CMD_ANTICOLL_OR_SELECT &&
d[0] <= ISO14443A_CMD_ANTICOLL_OR_SELECT_3) {
return 2;
}
return check_crc(CRC_14443_A, d, n);
uint8_t seos_CRC_check(bool isResponse, uint8_t *d, uint16_t n) {
return iso14443A_CRC_check(isResponse, d, n);
}
uint8_t mifare_CRC_check(bool isResponse, uint8_t *data, uint8_t len) {
uint8_t mifare_CRC_check(bool isResponse, uint8_t *data, uint16_t len) {
switch (MifareAuthState) {
case masNone:
case masError:
@@ -156,15 +144,15 @@ uint8_t mifare_CRC_check(bool isResponse, uint8_t *data, uint8_t len) {
* 1 : CRC-command, CRC ok
* 2 : Not crc-command
*/
uint8_t iso14443B_CRC_check(uint8_t *d, uint8_t n) {
uint8_t iso14443B_CRC_check(uint8_t *d, uint16_t n) {
return check_crc(CRC_14443_B, d, n);
}
uint8_t iso15693_CRC_check(uint8_t *d, uint8_t n) {
uint8_t iso15693_CRC_check(uint8_t *d, uint16_t n) {
return check_crc(CRC_15693, d, n);
}
uint8_t felica_CRC_check(uint8_t *d, uint8_t n) {
uint8_t felica_CRC_check(uint8_t *d, uint16_t n) {
return check_crc(CRC_FELICA, d, n);
}
@@ -177,7 +165,7 @@ uint8_t felica_CRC_check(uint8_t *d, uint8_t n) {
* 1 : CRC-command, CRC ok
* 2 : Not crc-command
*/
uint8_t iclass_CRC_check(bool isResponse, uint8_t *d, uint8_t n) {
uint8_t iclass_CRC_check(bool isResponse, uint8_t *d, uint16_t n) {
//CRC commands (and responses) are all at least 4 bytes
if (n < 4) return 2;
@@ -225,7 +213,7 @@ uint8_t iclass_CRC_check(bool isResponse, uint8_t *d, uint8_t n) {
}
static int annotateEcp(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize) {
static int annotateEcp(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize < 7 || cmd[0] != ECP_HEADER) {
return PM3_ESOFT;
}
@@ -265,7 +253,22 @@ static int annotateEcp(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsi
return PM3_ESOFT;
}
int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response) {
// "name(operand)", or the name alone when the frame stops before the operand
static void annotateCmdOperand(char *exp, size_t size, const char *name, bool color, const uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize < 2) {
snprintf(exp, size, "%s", name);
} else if (color) {
snprintf(exp, size, "%s(" _MAGENTA_("%d") ")", name, cmd[1]);
} else {
snprintf(exp, size, "%s(%d)", name, cmd[1]);
}
}
int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize == 0) {
return PM3_ESOFT;
}
if (is_response == false) {
if ((gs_ntag_i2c_state == 1) && (cmdsize == 6) && (memcmp(cmd + 1, "\x00\x00\x00", 3) == 0)) {
@@ -334,16 +337,20 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
snprintf(exp, size, "REQA");
break;
case ISO14443A_CMD_READBLOCK:
snprintf(exp, size, "READBLOCK(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "READBLOCK", true, cmd, cmdsize);
break;
case ISO14443A_CMD_WRITEBLOCK:
snprintf(exp, size, "WRITEBLOCK(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "WRITEBLOCK", true, cmd, cmdsize);
break;
case ISO14443A_CMD_HALT:
snprintf(exp, size, "HALT");
MifareAuthState = masNone;
break;
case ISO14443A_CMD_RATS: {
if (cmdsize < 2) {
snprintf(exp, size, "RATS");
break;
}
uint16_t fsdi2fsd[] = {16, 24, 32, 40, 48, 64, 96, 128, 256, 512, 1024, 2048, 4096, 4096, 4096, 4096};
snprintf(exp, size, "RATS - FSDI=%x (FSD=%u), CID=%x", (cmd[1] & 0xF0) >> 4, fsdi2fsd[(cmd[1] & 0xF0) >> 4], (cmd[1] & 0x0F));
break;
@@ -357,10 +364,10 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
snprintf(exp, size, "OPTIONAL TIMESLOT");
break;
case MIFARE_CMD_INC:
snprintf(exp, size, "INC(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "INC", true, cmd, cmdsize);
break;
case MIFARE_CMD_DEC:
snprintf(exp, size, "DEC(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "DEC", true, cmd, cmdsize);
break;
case MIFARE_CMD_RESTORE:
@@ -379,7 +386,7 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
break;
case MIFARE_CMD_TRANSFER:
snprintf(exp, size, "TRANSFER(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "TRANSFER", true, cmd, cmdsize);
break;
case MIFARE_AUTH_KEYA: {
if (cmdsize > 3) {
@@ -393,7 +400,7 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
}
case MIFARE_AUTH_KEYB: {
MifareAuthState = masNt;
snprintf(exp, size, "AUTH-B(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "AUTH-B", true, cmd, cmdsize);
break;
}
case MIFARE_MAGIC_GDM_AUTH_KEY: {
@@ -404,7 +411,7 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
break;
}
case MIFARE_MAGIC_GDM_WRITEBLOCK: {
snprintf(exp, size, "MAGIC WRITEBLOCK(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "MAGIC WRITEBLOCK", true, cmd, cmdsize);
break;
}
case MIFARE_MAGICWUPC1:
@@ -445,13 +452,17 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
case MIFARE_ULEV1_FASTREAD : {
if (cmdsize >= 3 && cmd[2] <= 0xE6)
snprintf(exp, size, "READ RANGE (" _MAGENTA_("%d-%d") ")", cmd[1], cmd[2]);
else
else if (cmdsize >= 3)
// outside limits, useful for some tags...
snprintf(exp, size, "READ RANGE (" _MAGENTA_("%d-%d") ") (?)", cmd[1], cmd[2]);
else
snprintf(exp, size, "READ RANGE");
break;
}
case MIFARE_ULC_WRITE : {
if (cmd[1] < 0x21)
if (cmdsize < 2)
snprintf(exp, size, "WRITEBLOCK");
else if (cmd[1] < 0x21)
snprintf(exp, size, "WRITEBLOCK(" _MAGENTA_("%d") ")", cmd[1]);
else if (cmdsize >= 6)
// outside limits, useful for some tags...
@@ -459,14 +470,14 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
break;
}
case MIFARE_ULEV1_READ_CNT : {
if (cmd[1] < 5)
if (cmdsize > 1 && cmd[1] < 5)
snprintf(exp, size, "READ CNT(" _MAGENTA_("%d") ")", cmd[1]);
else
snprintf(exp, size, "?");
break;
}
case MIFARE_ULEV1_INCR_CNT : {
if (cmd[1] < 5) {
if (cmdsize >= 5 && cmd[1] < 5) {
uint32_t v = MemLeToUint3byte(cmd + 2);
snprintf(exp, size, "INCR CNT(" _MAGENTA_("%d") ") %u", cmd[1], v);
} else {
@@ -478,7 +489,7 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
snprintf(exp, size, "READ SIG");
break;
case MIFARE_ULEV1_CHECKTEAR:
snprintf(exp, size, "CHK TEARING(" _MAGENTA_("%d") ")", cmd[1]);
annotateCmdOperand(exp, size, "CHK TEARING", true, cmd, cmdsize);
break;
case MIFARE_ULEV1_VCSL:
snprintf(exp, size, "VCSL");
@@ -487,9 +498,9 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
snprintf(exp, size, "WRITE SIG");
break;
case MIFARE_ULNANO_LOCKSIG: {
if (cmd[1] == 0)
if (cmdsize > 1 && cmd[1] == 0)
snprintf(exp, size, "UNLOCK SIG");
else if (cmd[1] == 2)
else if (cmdsize > 1 && cmd[1] == 2)
snprintf(exp, size, "LOCK SIG");
else
snprintf(exp, size, "?");
@@ -543,11 +554,11 @@ int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool i
return PM3_SUCCESS;
}
void annotateIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateIso14443a(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response) {
applyIso14443a(exp, size, cmd, cmdsize, is_response);
}
void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool isResponse) {
void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool isResponse) {
enum pico_state {PICO_NONE, PICO_SELECT, PICO_AUTH_EPURSE, PICO_AUTH_MACS };
static enum pico_state curr_state = PICO_NONE;
@@ -556,6 +567,10 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
static uint8_t rmac[4];
static uint8_t tmac[4];
if (cmdsize == 0) {
return;
}
if (isResponse == false) {
uint8_t c = cmd[0] & 0x0F;
// uint8_t parity = 0;
@@ -582,6 +597,10 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
break;
case ICLASS_CMD_CHECK:
curr_state = PICO_AUTH_MACS;
if (cmdsize < 9) {
snprintf(exp, size, "CHECK");
break;
}
memcpy(rmac, cmd + 1, 4);
memcpy(tmac, cmd + 5, 4);
@@ -594,7 +613,7 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
break;
case ICLASS_CMD_READ4:
snprintf(exp, size, "READ4(%d)", cmd[1]);
annotateCmdOperand(exp, size, "READ4", false, cmd, cmdsize);
break;
case ICLASS_CMD_READ_OR_IDENTIFY: {
@@ -606,19 +625,19 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
break;
}
case ICLASS_CMD_PAGESEL:
snprintf(exp, size, "PAGESEL(%d)", cmd[1]);
annotateCmdOperand(exp, size, "PAGESEL", false, cmd, cmdsize);
curr_state = PICO_NONE;
break;
case ICLASS_CMD_UPDATE:
snprintf(exp, size, "UPDATE(%d)", cmd[1]);
annotateCmdOperand(exp, size, "UPDATE", false, cmd, cmdsize);
curr_state = PICO_NONE;
break;
case ICLASS_CMD_READCHECK:
if (ICLASS_CREDIT(cmd[0])) {
snprintf(exp, size, "READCHECK[Kc](%d)", cmd[1]);
annotateCmdOperand(exp, size, "READCHECK[Kc]", false, cmd, cmdsize);
curr_state = PICO_AUTH_EPURSE;
} else {
snprintf(exp, size, "READCHECK[Kd](%d)", cmd[1]);
annotateCmdOperand(exp, size, "READCHECK[Kd]", false, cmd, cmdsize);
curr_state = PICO_AUTH_EPURSE;
}
break;
@@ -635,10 +654,14 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
} else {
if (curr_state == PICO_SELECT) {
memcpy(csn, cmd, 8);
if (cmdsize >= 8) {
memcpy(csn, cmd, 8);
}
curr_state = PICO_NONE;
} else if (curr_state == PICO_AUTH_EPURSE) {
memcpy(epurse, cmd, 8);
if (cmdsize >= 8) {
memcpy(epurse, cmd, 8);
}
} else if (curr_state == PICO_AUTH_MACS) {
snprintf(exp, size, _GREEN_("CHECK SUCCESS"));
curr_state = PICO_NONE;
@@ -647,7 +670,7 @@ void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
return;
}
void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize >= 2) {
switch (cmd[1]) {
@@ -683,8 +706,10 @@ void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
case ISO15693_READ_MULTI_BLOCK:
if (cmdsize == 6) {
snprintf(exp, size, "READ_MULTI_BLOCK(%d-%d)", cmd[2], (cmd[2] + cmd[3]));
} else {
} else if (cmdsize == 6 + 8) { // with UID
snprintf(exp, size, "READ_MULTI_BLOCK(%d-%d)", cmd[10], (cmd[10] + cmd[11]));
} else {
snprintf(exp, size, "READ_MULTI_BLOCK");
}
return;
case ISO15693_WRITE_MULTI_BLOCK:
@@ -803,7 +828,10 @@ void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
}
void annotateTopaz(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateTopaz(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize == 0) {
return;
}
switch (cmd[0]) {
case TOPAZ_REQA:
snprintf(exp, size, "REQA");
@@ -844,13 +872,15 @@ void annotateTopaz(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
}
static bool annotateIso14443_s_r_block(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response, bool show_block_number);
// iso 7816-3
//
// contact tells the two framings apart: a contactless frame is always a block
// typed by its first byte, while a contact T=0 frame is a bare APDU and a T=1
// frame is NAD PCB LEN INF EDC. Without it a GSM APDU starting with CLA 'A0'
// matches the T=CL R-block test.
void annotateIso7816(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response, bool contact) {
void annotateIso7816(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response, bool contact) {
if (cmdsize < 2) {
return;
@@ -930,39 +960,7 @@ not_a_block:
// S-block
if (blocks && ((cmd[0] & 0xC0) == 0xC0) && ((cmdsize == 3) || (cmdsize == 4))) {
switch ((cmd[0] & 0x3F)) {
case 0x00 :
snprintf(exp, size, "S-block RESYNCH req");
break;
case 0x20 :
snprintf(exp, size, "S-block RESYNCH resp");
break;
case 0x01 :
snprintf(exp, size, "S-block IFS req");
break;
case 0x21 :
snprintf(exp, size, "S-block IFS resp");
break;
case 0x02 :
snprintf(exp, size, "S-block ABORT req");
break;
case 0x22 :
snprintf(exp, size, "S-block ABORT resp");
break;
case 0x03 :
snprintf(exp, size, "S-block WTX reqt");
break;
case 0x23 :
snprintf(exp, size, "S-block WTX resp");
break;
case 0x32:
snprintf(exp, size, "S-block WTX req");
break;
default :
snprintf(exp, size, "S-block");
break;
}
annotateIso14443_s_r_block(exp, size, cmd, cmdsize, is_response, false);
}
// R-block (ack)
else if (blocks && ((cmd[0] & 0xD0) == 0x80) && (cmdsize > 2)) {
@@ -1056,7 +1054,7 @@ not_a_block:
}
}
static bool iso14443_4_get_i_block_inf(uint8_t *cmd, uint8_t cmdsize, bool is_response, const uint8_t **inf, size_t *inf_len) {
static bool iso14443_4_get_i_block_inf(uint8_t *cmd, uint16_t cmdsize, bool is_response, const uint8_t **inf, size_t *inf_len) {
(void)is_response;
size_t frame_len = cmdsize;
if (frame_len < 1 || (cmd[0] & 0xC0) != 0x00 || (cmd[0] & 0x02) != 0x02) {
@@ -1081,7 +1079,7 @@ static bool iso14443_4_get_i_block_inf(uint8_t *cmd, uint8_t cmdsize, bool is_re
return true;
}
static bool annotateIso14443_s_r_block(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response, bool show_block_number) {
static bool annotateIso14443_s_r_block(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response, bool show_block_number) {
(void)is_response;
size_t frame_len = cmdsize;
if (frame_len < 1 || frame_len > 4) {
@@ -1338,7 +1336,7 @@ static bool annotateCalypsoApdu(char *exp, size_t size, const uint8_t *apdu, siz
}
}
static bool annotateIso14443bPrime(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response) {
static bool annotateIso14443bPrime(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize < 2) {
return false;
}
@@ -1398,7 +1396,7 @@ static bool annotateIso14443bPrime(char *exp, size_t size, const uint8_t *cmd, u
}
}
void annotateCalypso(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateCalypso(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize < 1) {
return;
}
@@ -1432,7 +1430,7 @@ void annotateCalypso(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
}
// MIFARE DESFire
void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
// it's basically a ISO14443a tag, so try annotation from there
if (applyIso14443a(exp, size, cmd, cmdsize, false) != PM3_SUCCESS) {
@@ -1441,7 +1439,7 @@ void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
return;
}
// I-block 000xCN1x
else if (((cmd[0] & 0xC0) == 0x00) && (cmdsize > 2)) {
else if ((cmdsize > 2) && ((cmd[0] & 0xC0) == 0x00)) {
const uint8_t *inf = NULL;
if (iso14443_4_get_i_block_inf(cmd, cmdsize, false, &inf, NULL) == false) {
@@ -1451,6 +1449,9 @@ void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
int pos = inf - cmd;
for (uint8_t i = 0; i < 2; i++, pos++) {
if (pos >= cmdsize) {
break;
}
bool found_annotation = true;
uint8_t *data = cmd + pos + 1;
@@ -1458,7 +1459,7 @@ void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
if (i > 0 && cmd[pos - 1] == 0x90) {
data += 3;
}
uint8_t data_size = 0;
uint16_t data_size = 0;
if (cmdsize > (data - cmd)) {
data_size = cmdsize - (data - cmd);
}
@@ -1590,11 +1591,11 @@ void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
break;
case MFDES_UPDATE_RECORD: {
snprintf(exp, size, "MFDES_UPDATE_RECORD)");
snprintf(exp, size, "UPDATE RECORD");
break;
}
case MFDES_UPDATE_RECORD2: {
snprintf(exp, size, "MFDES_UPDATE_RECORD_2)");
snprintf(exp, size, "UPDATE RECORD_2");
break;
}
case MFDES_NOTIFY_TRANSACTION_SUCCESS:
@@ -1864,7 +1865,7 @@ const char *mfpGetCommandMacedForCode(uint8_t code) {
return "MACed" ;
}
void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
// If we are in Mifare Classic Authenticated mode, all the work has already be done elsewhere
if ((MifareAuthState != masNone) && (MifareAuthState != masError)) {
@@ -1877,7 +1878,7 @@ void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
// ok this part is copy paste from annotateMfDesfire, it seems to work for MIFARE Plus also
if (((cmd[0] & 0xC0) == 0x00) && (cmdsize > 2)) {
if ((cmdsize > 2) && ((cmd[0] & 0xC0) == 0x00)) {
const uint8_t *inf = NULL;
if (iso14443_4_get_i_block_inf(cmd, cmdsize, false, &inf, NULL) == false) {
@@ -1887,6 +1888,9 @@ void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
int pos = inf - cmd;
for (uint8_t i = 0; i < 2; i++, pos++) {
if (pos >= cmdsize) {
break;
}
bool found_annotation = true;
uint8_t *data = cmd + pos + 1;
@@ -1894,7 +1898,7 @@ void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
if (i > 0 && cmd[pos - 1] == 0x90) {
data += 3;
}
uint8_t data_size = 0;
uint16_t data_size = 0;
if (cmdsize > (data - cmd)) {
data_size = cmdsize - (data - cmd);
}
@@ -2144,7 +2148,11 @@ void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
0F = Completion
0A 11 22 33 44 55 66 = Authenticate (11 22 33 44 55 66 = data to authenticate)
**/
void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize == 0) {
return;
}
if (annotateIso14443bPrime(exp, size, cmd, cmdsize, is_response)) {
return;
@@ -2180,7 +2188,7 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
snprintf(exp, size, "Slot 2 NACK");
return;
case 0xA7: {
snprintf(exp, size, "Slot 0 NACK");
snprintf(exp, size, "Slot 3 NACK");
return;
}
default:
@@ -2191,6 +2199,11 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
switch (cmd[0]) {
case ISO14443B_REQB : {
if (cmdsize < 3) {
snprintf(exp, size, "REQB");
break;
}
switch (cmd[2] & 0x07) {
case 0:
snprintf(exp, size, "1 slot ");
@@ -2208,10 +2221,11 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
snprintf(exp, size, "16 slots ");
break;
}
size_t n = strlen(exp);
if ((cmd[2] & 0x8))
snprintf(exp, size, "WUPB");
snprintf(exp + n, size - n, "WUPB");
else
snprintf(exp, size, "REQB");
snprintf(exp + n, size - n, "REQB");
break;
}
case ISO14443B_ATTRIB:
@@ -2224,16 +2238,16 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
snprintf(exp, size, "INITIATE");
break;
case ISO14443B_SELECT:
snprintf(exp, size, "SELECT(%d)", cmd[1]);
annotateCmdOperand(exp, size, "SELECT", false, cmd, cmdsize);
break;
case ISO14443B_GET_UID:
snprintf(exp, size, "GET UID");
break;
case ISO14443B_READ_BLK:
snprintf(exp, size, "READ_BLK(%d)", cmd[1]);
annotateCmdOperand(exp, size, "READ_BLK", false, cmd, cmdsize);
break;
case ISO14443B_WRITE_BLK:
snprintf(exp, size, "WRITE_BLK(%d)", cmd[1]);
annotateCmdOperand(exp, size, "WRITE_BLK", false, cmd, cmdsize);
break;
case ISO14443B_RESET:
snprintf(exp, size, "RESET");
@@ -2263,6 +2277,9 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
snprintf(exp, size, "XEROX EXT_READ_BLK(%u)", cmd[2 + 8]);
break;
}
// any other 02 frame, an I-block among them, is no Xerox WUP
snprintf(exp, size, "?");
break;
case ISO14443B_XEROX_WUP1:
if (cmdsize == 5) {
@@ -2271,7 +2288,7 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
}
case ISO14443B_XEROX_WUP2:
if (cmdsize == 5) {
snprintf(exp, size, "XEROX WUP1");
snprintf(exp, size, "XEROX WUP2");
break;
}
default:
@@ -2284,7 +2301,11 @@ void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bo
}
// CryptoRF which is based on ISO-14443B
void annotateCryptoRF(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateCryptoRF(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize == 0) {
return;
}
switch (cmd[0]) {
case CRYPTORF_SET_USER_ZONE:
@@ -2323,7 +2344,16 @@ void annotateCryptoRF(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
}
void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool isResponse) {
// the frame holds the bytes of apdu at pos
static bool seos_frame_matches_apdu(const uint8_t *cmd, uint16_t cmdsize, int pos, const char *apdu, size_t len) {
return (((size_t)pos + len) <= cmdsize) && (memcmp(cmd + pos, apdu, len) == 0);
}
void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool isResponse) {
if (cmdsize == 0) {
return;
}
if (cmd[0] == 0xFA && cmdsize == 5) {
snprintf(exp, size, (isResponse) ? "BUSY" : "DONE?");
@@ -2331,7 +2361,7 @@ void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is
}
// it's basically a ISO14443a tag, so try annotation from there
if (applyIso14443a(exp, size, cmd, cmdsize, false) != PM3_SUCCESS) {
if (applyIso14443a(exp, size, cmd, cmdsize, isResponse) != PM3_SUCCESS) {
annotateIso7816(exp, size, cmd, cmdsize, isResponse, false);
@@ -2349,100 +2379,100 @@ void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is
}
}
if (memcmp(cmd + pos, "\x00\xA4\x04\x00", 4) == 0) {
uint8_t n = cmd[pos + 4];
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x00\xA4\x04\x00", 4) && (cmdsize > pos + 4)) {
uint8_t n = MIN(cmd[pos + 4], cmdsize - (pos + 5));
snprintf(exp, size, "SELECT AID " _WHITE_("%s"), sprint_hex_inrow(cmd + pos + 4 + 1, n));
// iceman: add a lookup to known SEOS AID's
return;
}
if (memcmp(cmd + pos, "\x80\xA5\x00\x00", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x80\xA5\x00\x00", 4)) {
snprintf(exp, size, "SELECT GDF");
return;
}
if (memcmp(cmd + pos, "\x80\xA5\x04\x00", 4) == 0) {
uint8_t n = cmd[pos + 4 + 2];
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x80\xA5\x04\x00", 4) && (cmdsize > pos + 6)) {
uint8_t n = MIN(cmd[pos + 4 + 2], cmdsize - (pos + 7));
snprintf(exp, size, "SELECT OID " _WHITE_("%s"), sprint_hex_inrow(cmd + pos + 4 + 2 + 1, n));
return;
}
if (memcmp(cmd + pos, "\x80\xA5\x07", 3) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x80\xA5\x07", 3) && (cmdsize > pos + 3)) {
uint8_t ks = cmd[pos + 3];
snprintf(exp, size, "SELECT GDF " _WHITE_("(") " key " _MAGENTA_("%02X") " )", ks);
return;
}
if (memcmp(cmd + pos, "\x00\x87\x00", 3) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x00\x87\x00", 3) && (cmdsize > pos + 3)) {
uint8_t ks = cmd[pos + 3];
if (memcmp(cmd + pos + 3 + 1, "\x04\x7c\x02\x81\x00", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos + 3 + 1, "\x04\x7c\x02\x81\x00", 5)) {
snprintf(exp, size, "GET CHALLENGE " _WHITE_("(") " key " _MAGENTA_("%02X") " )", ks);
return;
}
if (memcmp(cmd + pos + 3 + 1, "\x2C\x7C\x2A\x82\x28", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos + 3 + 1, "\x2C\x7C\x2A\x82\x28", 5)) {
snprintf(exp, size, "MUTUAL AUTHENTICATION " _WHITE_("(") " key " _MAGENTA_("%02X") " )", ks);
}
return;
}
if (memcmp(cmd + pos, "\x0C\xCB\x3F\xFF", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x0C\xCB\x3F\xFF", 4)) {
snprintf(exp, size, "GET DATA");
return;
}
if (memcmp(cmd + pos, "\x0C\xDB\x3F\xFF", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x0C\xDB\x3F\xFF", 4)) {
snprintf(exp, size, "UPDATE DATA");
return;
}
if (memcmp(cmd + pos, "\x0C\xED\x06\x00", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x0C\xED\x06\x00", 4)) {
snprintf(exp, size, "DELETE DATA");
return;
}
if (memcmp(cmd + pos, "\x0C\x41\x0C\x03", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x0C\x41\x0C\x03", 4)) {
snprintf(exp, size, "CREATE ADF");
return;
}
if (memcmp(cmd + pos, "\x00\xD4\x00\x00\x00", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x00\xD4\x00\x00\x00", 5)) {
snprintf(exp, size, "GET REMAINING CREDITS");
return;
}
if (memcmp(cmd + pos, "\xA0\x10\x00\x00\x00", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\x10\x00\x00\x00", 5)) {
snprintf(exp, size, "GET APPLET INFO");
return;
}
if (memcmp(cmd + pos, "\xA0\xD3\x00\x00\x00", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xD3\x00\x00\x00", 5)) {
snprintf(exp, size, "GET APPLET VERSION");
return;
}
if (memcmp(cmd + pos, "\xA0\xDA\x04", 3) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xDA\x04", 3)) {
snprintf(exp, size, "PUSH ENGINE ID");
return;
}
if (memcmp(cmd + pos, "\xA0\xDA\x05", 3) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xDA\x05", 3)) {
snprintf(exp, size, "PUSH USERNAME");
return;
}
if (memcmp(cmd + pos, "\xA0\xDA\x10\x00\x01\x01", 6) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xDA\x10\x00\x01\x01", 6)) {
snprintf(exp, size, "FINAL PERSONALIZE");
return;
}
if (memcmp(cmd + pos, "\xA0\xDA\x25\x00\x02\x01", 6) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xDA\x25\x00\x02\x01", 6)) {
snprintf(exp, size, "UNKNOWN OPCODE ( 0x25 )");
return;
}
if (memcmp(cmd + pos, "\xA0\xCA\x00\x00\x00", 5) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xA0\xCA\x00\x00\x00", 5)) {
snprintf(exp, size, "GET DATA");
return ;
}
@@ -2451,14 +2481,14 @@ void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is
// Tells the card "the next byte is a DESFire native opcode, not an ISO 7816 standard INS."
// INS 0x5A DESFire native opcode SelectApplication (3-byte AID).
if (memcmp(cmd + pos, "\x90\x5A\x00\x00", 4) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\x90\x5A\x00\x00", 4) && (cmdsize > pos + 7)) {
snprintf(exp, size, "(desfire) SELECT AID " _CYAN_("%02X%02X%02X"), cmd[pos + 5], cmd[pos + 6], cmd[pos + 7]);
return;
}
if (isResponse) {
if (memcmp(cmd + pos, "\xCD\x02", 2) == 0) {
if (seos_frame_matches_apdu(cmd, cmdsize, pos, "\xCD\x02", 2) && (cmdsize > pos + 3)) {
uint8_t ea = cmd[pos + 2];
uint8_t ha = cmd[pos + 3];
@@ -2489,7 +2519,10 @@ void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is
// 1 = read
// 0 = write
// Quite simpel tag
void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize < 2) {
return;
}
uint8_t bitsend = cmd[0];
uint8_t cmdBit = (cmd[1] & 1);
switch (bitsend) {
@@ -2519,6 +2552,9 @@ void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
case 9:
case 11: {
if (cmdsize < 3) {
break;
}
uint16_t address = (cmd[2] << 7) | cmd[1] >> 1;
if (cmdBit == LEGIC_READ) {
@@ -2531,7 +2567,7 @@ void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
break;
}
case 21: {
if (cmdBit == LEGIC_WRITE) {
if ((cmdsize >= 4) && (cmdBit == LEGIC_WRITE)) {
uint16_t address = ((cmd[2] << 7) | cmd[1] >> 1) & 0xFF;
uint8_t val = (cmd[3] & 1) << 7 | cmd[2] >> 1;
snprintf(exp, size, "WRITE Byte(%d) %02X", address, val);
@@ -2539,7 +2575,7 @@ void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
break;
}
case 23: {
if (cmdBit == LEGIC_WRITE) {
if ((cmdsize >= 4) && (cmdBit == LEGIC_WRITE)) {
uint16_t address = ((cmd[2] << 7) | cmd[1] >> 1) & 0x3FF;
uint8_t val = (cmd[3] & 0x7) << 5 | cmd[2] >> 3;
snprintf(exp, size, "WRITE Byte(%d) %02X", address, val);
@@ -2553,7 +2589,7 @@ void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
}
static bool annotateFelicaSeac(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response) {
static bool annotateFelicaSeac(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize < 7 || cmd[4] != 0x01 || cmd[5] != 0x01 ||
(cmd[6] != 0x01 && cmd[6] < 0x0F)) {
return false;
@@ -2587,7 +2623,7 @@ static bool annotateFelicaSeac(char *exp, size_t size, const uint8_t *cmd, uint8
return true;
}
void annotateFelica(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateFelica(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (cmdsize < 4) {
snprintf(exp, size, "?");
return;
@@ -3051,15 +3087,18 @@ void annotateFelica(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool
}
}
void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize == 0) {
return;
}
switch (cmd[0]) {
case LTO_REQ_STANDARD:
snprintf(exp, size, "REQ Standard");
break;
case LTO_SELECT:
if (cmd[1] == 0x70)
if (cmdsize > 1 && cmd[1] == 0x70)
snprintf(exp, size, "SELECT_UID-2");
else if (cmd[1] == 0x20)
else if (cmdsize > 1 && cmd[1] == 0x20)
snprintf(exp, size, "SELECT");
break;
case LTO_REQ_ALL:
@@ -3075,7 +3114,7 @@ void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
snprintf(exp, size, "READWORD");
break;
case (LTO_READBLOCK & 0xF0):
snprintf(exp, size, "READBLOCK(%d)", cmd[1]);
annotateCmdOperand(exp, size, "READBLOCK", false, cmd, cmdsize);
break;
case LTO_READBLOCK_CONT:
snprintf(exp, size, "READBLOCK CONT");
@@ -3084,7 +3123,7 @@ void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
snprintf(exp, size, "WRITEWORD");
break;
case (LTO_WRITEBLOCK & 0xF0):
snprintf(exp, size, "WRITEBLOCK(%d)", cmd[1]);
annotateCmdOperand(exp, size, "WRITEBLOCK", false, cmd, cmdsize);
break;
case LTO_HALT:
snprintf(exp, size, "HALT");
@@ -3094,8 +3133,8 @@ void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
}
}
void annotateMifare(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize,
const uint8_t *parity, uint8_t paritysize, bool isResponse) {
void annotateMifare(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize,
const uint8_t *parity, uint16_t paritysize, bool isResponse) {
if (!isResponse && cmdsize == 1) {
switch (cmd[0]) {
case ISO14443A_CMD_WUPA:
@@ -3198,7 +3237,7 @@ static void mf_get_paritybinstr(char *s, uint32_t val, uint8_t par) {
s[0] = '\0';
}
bool DecodeMifareData(uint8_t *cmd, uint8_t cmdsize, uint8_t *parity, bool isResponse, uint8_t *mfData, size_t *mfDataLen, const uint64_t *dicKeys, uint32_t dicKeysCount) {
bool DecodeMifareData(uint8_t *cmd, uint16_t cmdsize, uint8_t *parity, bool isResponse, uint8_t *mfData, size_t *mfDataLen, const uint64_t *dicKeys, uint32_t dicKeysCount) {
static struct Crypto1State *traceCrypto1;
*mfDataLen = 0;
@@ -3380,7 +3419,7 @@ bool NTParityChk(AuthData_t *ad, uint32_t ntx) {
return true;
}
bool NestedCheckKey(uint64_t key, AuthData_t *ad, uint8_t *cmd, uint8_t cmdsize, uint8_t *parity) {
bool NestedCheckKey(uint64_t key, AuthData_t *ad, uint8_t *cmd, uint16_t cmdsize, uint8_t *parity) {
uint8_t buf[32] = {0};
struct Crypto1State *pcs;
@@ -3418,7 +3457,7 @@ bool NestedCheckKey(uint64_t key, AuthData_t *ad, uint8_t *cmd, uint8_t cmdsize,
return true;
}
bool CheckCrypto1Parity(const uint8_t *cmd_enc, uint8_t cmdsize, uint8_t *cmd, const uint8_t *parity_enc) {
bool CheckCrypto1Parity(const uint8_t *cmd_enc, uint16_t cmdsize, uint8_t *cmd, const uint8_t *parity_enc) {
for (int i = 0; i < cmdsize - 1; i++) {
if (oddparity8(cmd[i]) ^ (cmd[i + 1] & 0x01) ^ ((parity_enc[i / 8] >> (7 - i % 8)) & 0x01) ^ (cmd_enc[i + 1] & 0x01))
return false;
@@ -3441,7 +3480,7 @@ uint64_t GetCrypto1ProbableKey(AuthData_t *ad) {
}
// FMCOS 2.0
void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize) {
if (cmdsize < 2)
return;
@@ -3459,6 +3498,13 @@ void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
pos = 3;
break;
}
if (pos >= cmdsize) {
return;
}
// P1, 0xFF when the frame stops before it
uint8_t p1 = (pos + 1 < cmdsize) ? cmd[pos + 1] : 0xFF;
switch (cmd[pos]) {
case FMCOS20_CMD_EXTERNAL_AUTHENTICATION:
snprintf(exp, size, "EXT. AUTH");
@@ -3506,9 +3552,9 @@ void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
snprintf(exp, size, "APP UNBLOCK");
break;
case FMCOS20_CMD_APP_BLOCK:
if (cmd[pos + 1] == 0)
if (p1 == 0)
snprintf(exp, size, "APP BLOCK (TEMP)");
else if (cmd[pos + 1] == 1)
else if (p1 == 1)
snprintf(exp, size, "APP BLOCK (PERM)");
else
snprintf(exp, size, "APP BLOCK");
@@ -3517,34 +3563,34 @@ void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
snprintf(exp, size, "PIN UNBLOCK");
break;
case FMCOS20_CMD_CHANGE_PIN:
if (cmd[pos + 1] == 0)
if (p1 == 0)
snprintf(exp, size, "RESET PIN");
else if (cmd[pos + 1] == 1)
else if (p1 == 1)
snprintf(exp, size, "CHANGE PIN");
break;
case FMCOS20_CMD_INITIALIZE_TRANSACTION:
if (cmd[pos + 1] == 0)
if (p1 == 0)
snprintf(exp, size, "INIT. TRANSACTION (CREDIT)");
else if (cmd[pos + 1] == 1)
else if (p1 == 1)
snprintf(exp, size, "INIT. TRANSACTION (PURCHASE)");
else if (cmd[pos + 1] == 2)
else if (p1 == 2)
snprintf(exp, size, "INIT. TRANSACTION (CASH WITHDRAW)");
else if (cmd[pos + 1] == 3)
else if (p1 == 3)
snprintf(exp, size, "INIT. TRANSACTION (CAPP PURCHASE)");
else if (cmd[pos + 1] == 4)
else if (p1 == 4)
snprintf(exp, size, "INIT. TRANSACTION (OVERDRAFT)");
else if (cmd[pos + 1] == 5)
else if (p1 == 5)
snprintf(exp, size, "INIT. TRANSACTION (WITHDRAW)");
break;
case FMCOS20_CMD_CREDIT_LOAD:
snprintf(exp, size, "CREDIT LOAD");
break;
case FMCOS20_CMD_PURCHASE:
if (cmd[pos + 1] == 0)
if (p1 == 0)
snprintf(exp, size, "PURCHASE");
else if (cmd[pos + 1] == 1)
else if (p1 == 1)
snprintf(exp, size, "CAPP PURCHASE / CASH WITHDRAW");
else if (cmd[pos + 1] == 3)
else if (p1 == 3)
snprintf(exp, size, "WITHDRAW");
break;
case FMCOS20_CMD_UPDATE_OVERDRAW_LIMIT:
@@ -3557,15 +3603,15 @@ void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize) {
snprintf(exp, size, "GET BALANCE");
break;
case FMCOS20_CMD_INITIALIZE_GREY_LOCK_UNLOCK:
if (cmd[pos + 1] == 8)
if (p1 == 8)
snprintf(exp, size, "INIT. GRAY LOCK");
else if (cmd[pos + 1] == 9)
else if (p1 == 9)
snprintf(exp, size, "INIT. GRAY UNLOCK");
break;
case FMCOS20_CMD_GREY_LOCK_UNLOCK:
if (cmd[pos + 1] == 8)
if (p1 == 8)
snprintf(exp, size, "GRAY LOCK");
else if (cmd[pos + 1] == 9)
else if (p1 == 9)
snprintf(exp, size, "GRAY UNLOCK");
break;
case FMCOS20_CMD_DEBIT_UNLOCK:
+28 -28
View File
@@ -40,44 +40,44 @@ typedef struct {
void ClearAuthData(void);
uint8_t iso14443A_CRC_check(bool isResponse, uint8_t *d, uint8_t n);
uint8_t iso14443B_CRC_check(uint8_t *d, uint8_t n);
uint8_t felica_CRC_check(uint8_t *d, uint8_t n);
uint8_t mifare_CRC_check(bool isResponse, uint8_t *data, uint8_t len);
uint8_t iso15693_CRC_check(uint8_t *d, uint8_t n);
uint8_t iclass_CRC_check(bool isResponse, uint8_t *d, uint8_t n);
uint8_t seos_CRC_check(bool isResponse, uint8_t *d, uint8_t n);
uint8_t iso14443A_CRC_check(bool isResponse, uint8_t *d, uint16_t n);
uint8_t iso14443B_CRC_check(uint8_t *d, uint16_t n);
uint8_t felica_CRC_check(uint8_t *d, uint16_t n);
uint8_t mifare_CRC_check(bool isResponse, uint8_t *data, uint16_t len);
uint8_t iso15693_CRC_check(uint8_t *d, uint16_t n);
uint8_t iclass_CRC_check(bool isResponse, uint8_t *d, uint16_t n);
uint8_t seos_CRC_check(bool isResponse, uint8_t *d, uint16_t n);
int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response);
int applyIso14443a(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool isResponse);
void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateTopaz(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateFelica(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateIso7816(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response, bool contact);
void annotateCalypso(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateIso14443a(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateIclass(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool isResponse);
void annotateIso15693(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateTopaz(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateLegic(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateFelica(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateIso7816(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response, bool contact);
void annotateCalypso(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateIso14443b(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateIso14443a(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateMfDesfire(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
const char *mfpGetAnnotationForCode(uint8_t code);
const char *mfpGetEncryptedForCode(uint8_t code);
const char *mfpGetResponseMacedForCode(uint8_t code);
const char *mfpGetCommandMacedForCode(uint8_t code);
void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateMifare(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize,
const uint8_t *parity, uint8_t paritysize, bool isResponse);
void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateCryptoRF(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateMfPlus(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateMifare(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize,
const uint8_t *parity, uint16_t paritysize, bool isResponse);
void annotateLTO(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateCryptoRF(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize, bool isResponse);
void annotateSeos(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize, bool isResponse);
bool DecodeMifareData(uint8_t *cmd, uint8_t cmdsize, uint8_t *parity, bool isResponse, uint8_t *mfData, size_t *mfDataLen, const uint64_t *dicKeys, uint32_t dicKeysCount);
bool DecodeMifareData(uint8_t *cmd, uint16_t cmdsize, uint8_t *parity, bool isResponse, uint8_t *mfData, size_t *mfDataLen, const uint64_t *dicKeys, uint32_t dicKeysCount);
bool NTParityChk(AuthData_t *ad, uint32_t ntx);
bool NestedCheckKey(uint64_t key, AuthData_t *ad, uint8_t *cmd, uint8_t cmdsize, uint8_t *parity);
bool CheckCrypto1Parity(const uint8_t *cmd_enc, uint8_t cmdsize, uint8_t *cmd, const uint8_t *parity_enc);
bool NestedCheckKey(uint64_t key, AuthData_t *ad, uint8_t *cmd, uint16_t cmdsize, uint8_t *parity);
bool CheckCrypto1Parity(const uint8_t *cmd_enc, uint16_t cmdsize, uint8_t *cmd, const uint8_t *parity_enc);
uint64_t GetCrypto1ProbableKey(AuthData_t *ad);
void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint8_t cmdsize);
void annotateFMCOS20(char *exp, size_t size, uint8_t *cmd, uint16_t cmdsize);
#endif // CMDHFLIST
+9 -8
View File
@@ -420,7 +420,7 @@ static void print_hitag2_blocks(uint8_t *d, uint16_t n) {
}
// Annotate HITAG protocol
void annotateHitag1(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateHitag1(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response) {
}
static struct {
@@ -583,7 +583,7 @@ static uint8_t hitag2_get_page(const char *bs) {
return 255;
}
void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits) {
void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, uint8_t bits) {
if (cmdsize == 0) {
return;
@@ -598,7 +598,7 @@ void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint8_t c
bytes_2_binstr(binstr, cmd, cmdsize);
size_t bn = strlen(binstr);
if (bits) {
if ((bits > 0) && (bits <= 8)) {
if (cmdsize == 1) {
bn = bits;
} else if (cmdsize > 1) {
@@ -651,7 +651,7 @@ void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint8_t c
free(binstr);
}
void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits, bool is_response, const uint64_t *keys, uint32_t keycount, bool isdecrypted) {
void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, uint8_t bits, bool is_response, const uint64_t *keys, uint32_t keycount, bool isdecrypted) {
if (cmdsize == 0) {
return;
@@ -666,7 +666,7 @@ void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize,
bytes_2_binstr(binstr, cmd, cmdsize);
size_t bn = strlen(binstr);
if (bits) {
if ((bits > 0) && (bits <= 8)) {
if (cmdsize == 1) {
bn = bits;
} else if (cmdsize > 1) {
@@ -674,12 +674,13 @@ void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize,
}
}
memcpy(_ht2state.plain, cmd, cmdsize);
_ht2state.plainlen = cmdsize;
// a frame longer than plain is no Hitag 2 frame, it is kept cut and not decrypted
_ht2state.plainlen = MIN(cmdsize, sizeof(_ht2state.plain));
memcpy(_ht2state.plain, cmd, _ht2state.plainlen);
if (_ht2state.state == STATE_ENCRYPTED || _ht2state.state == STATE_START_ENCRYPTED) {
if (_ht2state.found_key && isdecrypted == false) {
if (_ht2state.found_key && isdecrypted == false && (bn <= (sizeof(_ht2state.plain) * 8))) {
ht2_hitag2_cipher_transcrypt(&_ht2state.cipher_state, _ht2state.plain, bn / 8, bn % 8);
}
}
+3 -3
View File
@@ -29,12 +29,12 @@ int CmdLFHitag(const char *Cmd);
int ht2_read_uid(void);
int ht2_read_paxton(void);
void annotateHitag1(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits, bool is_response, const uint64_t *keys, uint32_t keycount, bool isdecrypted);
void annotateHitag1(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response);
void annotateHitag2(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, uint8_t bits, bool is_response, const uint64_t *keys, uint32_t keycount, bool isdecrypted);
void annotateHitag2_init(void);
bool hitag2_get_plain(uint8_t *plain, uint8_t *plen);
void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, uint8_t bits);
void hitag2_annotate_plain(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, uint8_t bits);
uint8_t hitag1_CRC_check(uint8_t *d, uint32_t nbit);
#endif
+2 -2
View File
@@ -37,7 +37,7 @@
static int CmdHelp(const char *Cmd);
void annotateHitagS(char *exp, size_t size, const uint8_t *cmd, uint8_t nbits, bool is_response) {
void annotateHitagS(char *exp, size_t size, const uint8_t *cmd, uint16_t nbits, bool is_response) {
uint8_t command = 0;
// the caller reuses this buffer across frames, and the appends below are
@@ -347,7 +347,7 @@ static void hitags_config_print(hitags_config_t config) {
PrintAndLogEx(INFO, " Memory type...... " _GREEN_("%s"),
(const char *[]) {"Hitag S 32", "Hitag S 256", "Hitag S 2048", "Unknown Hitag S/8211"}[config.MEMT]);
PrintAndLogEx(INFO, " Authenticaion.... %s", config.auth ? _YELLOW_("Yes") : "No");
PrintAndLogEx(INFO, " Authentication... %s", config.auth ? _YELLOW_("Yes") : "No");
PrintAndLogEx(INFO, " TTF coding....... %s",
config.RES3 ? "FSK 0=RF/10 1=RF/8" : (const char *[]) {"Manchester", "Biphase"}[config.TTFC]);
+1 -1
View File
@@ -22,7 +22,7 @@
#include "common.h"
#include "hitag.h"
void annotateHitagS(char *exp, size_t size, const uint8_t *cmd, uint8_t nbits, bool is_response);
void annotateHitagS(char *exp, size_t size, const uint8_t *cmd, uint16_t nbits, bool is_response);
int CmdLFHitagS(const char *Cmd);
+30 -7
View File
@@ -45,11 +45,15 @@ uint8_t hitagu_CRC_check(uint8_t *d, uint32_t nbit) {
return (Crc16(d, nbit, 0, CRC16_POLY_CCITT, false, false) == 0);
}
void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response) {
void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response) {
if (is_response) {
} else {
// flags and command take 11 bits
if (cmdsize < 2) {
return;
}
uint8_t flag = reflect8(cmd[0]) & 0x1F;
uint8_t command = ((reflect8(cmd[0]) >> 5) & 0x07) | ((reflect8(cmd[1]) & 0x07) << 3);
bool has_uid = false;
@@ -102,14 +106,19 @@ void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize,
} else if (cmdsize == (7 + (has_uid * HITAGU_UID_SIZE)) || cmdsize == (9 + (has_uid * HITAGU_UID_SIZE))) {
uint8_t mfc = 0;
concatbits(&mfc, 0, cmd, 5 + 6 + 8 + 32, 8, false);
concatbits(&mfc, 0, cmd, 5 + 6, 8, false);
snprintf(exp + strlen(exp), size - strlen(exp), "LOGIN mfc:%02x ", mfc);
has_mfc = true;
}
// flags, command, IC MFC, UID, password
if ((cmdsize * 8) < (5 + 6 + has_mfc * 8 + has_uid * HITAGU_UID_SIZE * 8 + HITAG_PASSWORD_SIZE * 8)) {
break;
}
if (has_uid) {
uint8_t uid[HITAGU_UID_SIZE] = {0};
concatbits(uid, 0, cmd, 5 + 6 + has_mfc * 8 + 32, HITAGU_UID_SIZE * 8, false);
concatbits(uid, 0, cmd, 5 + 6 + has_mfc * 8, HITAGU_UID_SIZE * 8, false);
snprintf(exp + strlen(exp), size - strlen(exp), " uid:%s", sprint_hex_inrow(uid, HITAGU_UID_SIZE));
}
@@ -123,11 +132,18 @@ void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize,
break;
}
case HITAGU_CMD_READ_MULTIPLE_BLOCK: {
// an addressed request has the UID before the block number
uint8_t bit_offset = 5 + 6 + has_uid * HITAGU_UID_SIZE * 8;
if ((cmdsize * 8) < (bit_offset + 8 + 8)) {
snprintf(exp + strlen(exp), size - strlen(exp), "READ MULTIPLE BLOCK");
break;
}
uint8_t block_addr = 0;
concatbits(&block_addr, 0, cmd, 5 + 6, 8, false);
concatbits(&block_addr, 0, cmd, bit_offset, 8, false);
uint8_t block_count = 0;
concatbits(&block_count, 0, cmd, 5 + 6 + 8, 8, false);
concatbits(&block_count, 0, cmd, bit_offset + 8, 8, false);
snprintf(exp + strlen(exp), size - strlen(exp), "READ MULTIPLE BLOCK start:%d num:%d"
, reflect8(block_addr)
@@ -136,11 +152,18 @@ void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize,
break;
}
case HITAGU_CMD_WRITE_SINGLE_BLOCK: {
// an addressed request has the UID before the block number
uint8_t bit_offset = 5 + 6 + has_uid * HITAGU_UID_SIZE * 8;
if ((cmdsize * 8) < (bit_offset + 8 + 32)) {
snprintf(exp + strlen(exp), size - strlen(exp), "WRITE SINGLE BLOCK");
break;
}
uint8_t block_addr = 0;
concatbits(&block_addr, 0, cmd, 5 + 6, 8, false);
concatbits(&block_addr, 0, cmd, bit_offset, 8, false);
uint8_t block_data[4] = {0};
concatbits(block_data, 0, cmd, 5 + 6 + 8, 32, false);
concatbits(block_data, 0, cmd, bit_offset + 8, 32, false);
snprintf(exp + strlen(exp), size - strlen(exp), "WRITE SINGLE BLOCK start:%d data:[%s]"
, reflect8(block_addr)
+1 -1
View File
@@ -23,7 +23,7 @@
#include "hitag.h"
uint8_t hitagu_CRC_check(uint8_t *d, uint32_t nbit);
void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint8_t cmdsize, bool is_response);
void annotateHitagU(char *exp, size_t size, const uint8_t *cmd, uint16_t cmdsize, bool is_response);
int CmdLFHitagU(const char *Cmd);
+243 -93
View File
@@ -56,10 +56,60 @@ static bool next_record_is_response(uint16_t tracepos, uint8_t *trace) {
return (hdr->isResponse);
}
// the record at tracepos, NULL when it does not fit in the trace
static const tracelog_hdr_t *get_record(uint16_t tracepos, uint16_t traceLen, const uint8_t *trace) {
if (is_last_record(tracepos, traceLen)) {
return NULL;
}
const tracelog_hdr_t *hdr = (const tracelog_hdr_t *)(trace + tracepos);
if (tracepos + TRACELOG_HDR_LEN + hdr->data_len + TRACELOG_PARITY_LEN(hdr) > traceLen) {
return NULL;
}
return hdr;
}
// bits of a Hitag frame whose last byte holds last_bits of them, 0 for a whole byte
static uint16_t hitag_frame_bits(uint16_t data_len, uint8_t last_bits) {
if (data_len == 0) {
return 0;
}
if ((last_bits == 0) || (last_bits > 8)) {
return data_len * 8;
}
return ((data_len - 1) * 8) + last_bits;
}
// Topaz reader commands are at most 16 bytes long (RSEG/READ8/WRITE-*8:
// cmd + adds + 8 data bytes + 4 UID bytes + 2 CRC bytes)
#define MAX_TOPAZ_READER_CMD_LEN 16
// a 14a frame that lasts less than this has 7 bits or fewer
#define ISO14A_SHORT_FRAME_DURATION (1056 + 32)
// in a Topaz trace, the reader's last frame was an ISO14443-A one: the answer
// to it is one too
static bool gs_topaz_14a_exchange = false;
// the frames of a Topaz command, the 7 bit command code included; 0 for an
// unknown code
static uint8_t topaz_reader_cmd_len(uint8_t code) {
switch (code) {
case TOPAZ_RID:
case TOPAZ_RALL:
case TOPAZ_READ:
case TOPAZ_WRITE_E:
case TOPAZ_WRITE_NE:
return 9;
case TOPAZ_RSEG:
case TOPAZ_READ8:
case TOPAZ_WRITE_E8:
case TOPAZ_WRITE_NE8:
return MAX_TOPAZ_READER_CMD_LEN;
default:
return 0;
}
}
static bool merge_topaz_reader_frames(uint32_t timestamp, uint32_t *duration, uint16_t *tracepos, uint16_t traceLen,
uint8_t *trace, const uint8_t *frame, uint8_t *topaz_reader_command, uint16_t *data_len) {
@@ -67,24 +117,35 @@ static bool merge_topaz_reader_frames(uint32_t timestamp, uint32_t *duration, ui
if ((*data_len != 1) || (frame[0] == TOPAZ_WUPA) || (frame[0] == TOPAZ_REQA)) return false;
// a command starts with its 7 bit code: an 8 bit frame is an operand left
// from a command cut short
if (*duration >= ISO14A_SHORT_FRAME_DURATION) return false;
memcpy(topaz_reader_command, frame, *data_len);
while (!is_last_record(*tracepos, traceLen) && !next_record_is_response(*tracepos, trace)) {
// stop at the frames the command code takes, or before when a reader sent
// fewer: the next command starts with its 7 bit code, an operand has 8 bits
uint8_t cmd_len = topaz_reader_cmd_len(frame[0]);
if (cmd_len == 0) {
cmd_len = MAX_TOPAZ_READER_CMD_LEN;
}
while ((*data_len < cmd_len) && !is_last_record(*tracepos, traceLen) && !next_record_is_response(*tracepos, trace)) {
const tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + *tracepos);
*tracepos += TRACELOG_HDR_LEN + hdr->data_len;
if ((hdr->data_len == 1) && (*data_len + hdr->data_len <= MAX_TOPAZ_READER_CMD_LEN)) {
memcpy(topaz_reader_command + *data_len, hdr->frame, hdr->data_len);
*data_len += hdr->data_len;
last_timestamp = hdr->timestamp + hdr->duration;
} else {
// rewind and exit
*tracepos = *tracepos - hdr->data_len - TRACELOG_HDR_LEN;
if ((hdr->data_len != 1) || (hdr->duration < ISO14A_SHORT_FRAME_DURATION)) {
break;
}
*tracepos += TRACELOG_PARITY_LEN(hdr);
if (*tracepos + TRACELOG_HDR_LEN + hdr->data_len + TRACELOG_PARITY_LEN(hdr) > traceLen) {
break;
}
memcpy(topaz_reader_command + *data_len, hdr->frame, hdr->data_len);
*data_len += hdr->data_len;
last_timestamp = hdr->timestamp + hdr->duration;
*tracepos += TRACELOG_HDR_LEN + hdr->data_len + TRACELOG_PARITY_LEN(hdr);
}
*duration = last_timestamp - timestamp;
@@ -130,9 +191,9 @@ static uint8_t extract_epurse[8] = {0};
#define SKIP_TO_NEXT(a) (TRACELOG_HDR_LEN + (a)->data_len + TRACELOG_PARITY_LEN((a)))
static uint16_t extractChall_ev2(uint16_t tracepos, uint8_t *trace, uint8_t cmdpos, uint8_t long_jmp) {
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
if (next_hdr->data_len != 21) {
static uint16_t extractChall_ev2(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, uint8_t cmdpos, uint8_t long_jmp) {
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if ((next_hdr == NULL) || (next_hdr->data_len != 21)) {
return 0;
}
@@ -140,10 +201,14 @@ static uint16_t extractChall_ev2(uint16_t tracepos, uint8_t *trace, uint8_t cmdp
PrintAndLogEx(INFO, "1499999999 %s " NOLF, sprint_hex_inrow(next_hdr->frame + 1, 16));
next_hdr = (tracelog_hdr_t *)(trace + tracepos);
next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr == NULL) {
PrintAndLogEx(NORMAL, "");
return tracepos;
}
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
if (next_hdr->frame[cmdpos] == MFDES_ADDITIONAL_FRAME) {
if ((next_hdr->data_len >= cmdpos + long_jmp + 32) && (next_hdr->frame[cmdpos] == MFDES_ADDITIONAL_FRAME)) {
PrintAndLogEx(NORMAL, "%s", sprint_hex_inrow(next_hdr->frame + cmdpos + long_jmp, 32));
} else {
PrintAndLogEx(NORMAL, "");
@@ -204,7 +269,10 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
}
// time to skip to next
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr == NULL) {
break;
}
tracepos += SKIP_TO_NEXT(next_hdr);
if (next_hdr->data_len != 11) {
break;
@@ -217,10 +285,12 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
PrintAndLogEx(INFO, "Found a MFU-C authententication attempt");
PrintAndLogEx(INFO, "3DES %s " NOLF, sprint_hex_inrow(next_hdr->frame + 1, 8));
next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += SKIP_TO_NEXT(next_hdr);
next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr != NULL) {
tracepos += SKIP_TO_NEXT(next_hdr);
}
if (next_hdr->frame[0] == MIFARE_ULC_AUTH_2 && next_hdr->data_len == 19) {
if ((next_hdr != NULL) && (next_hdr->data_len == 19) && (next_hdr->frame[0] == MIFARE_ULC_AUTH_2)) {
PrintAndLogEx(NORMAL, "%s", sprint_hex_inrow(next_hdr->frame + 1, 16));
} else {
PrintAndLogEx(NORMAL, "( " _RED_("partial") " )");
@@ -239,7 +309,10 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
switch (c) {
case ICLASS_CMD_SELECT: {
const tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr == NULL) {
break;
}
tracepos += SKIP_TO_NEXT(next_hdr);
if (next_hdr->data_len != 10) {
break;
@@ -251,8 +324,11 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
case ICLASS_CMD_READCHECK: {
// get epurse
if (frame[1] == 2 && data_len == 2) {
const tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
if (data_len == 2 && frame[1] == 2) {
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr == NULL) {
break;
}
tracepos += SKIP_TO_NEXT(next_hdr);
if (next_hdr->data_len < 8) {
break;
@@ -283,7 +359,7 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
// 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor)
// 93 50 = Bit oriented anti-collision (usage: 9350+ up to 5bytes, 9350 answer - up to 5bytes UID+BCC)
// 93 70 = Select (usage: 9370+5bytes 9370 answer - answer: 1byte SAK)
if (frame[1] == 0x70) {
if ((data_len >= 6) && (frame[1] == 0x70)) {
if (frame[2] == 0x88) {
memcpy(extract_uid, frame + 3, 3);
extract_uidlen = 3;
@@ -299,13 +375,14 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
// 95 20 = Anticollision of cascade level2
// 95 50 = Bit oriented anti-collision level2
// 95 70 = Select of cascade level2
if (frame[1] == 0x70) {
if ((data_len >= 6) && (frame[1] == 0x70)) {
// cascade level 2 starts at UID byte 3, level 3 at byte 6
if (frame[2] == 0x88) {
memcpy(extract_uid + extract_uidlen, frame + 3, 3);
extract_uidlen += 3;
memcpy(extract_uid + 3, frame + 3, 3);
extract_uidlen = 6;
} else {
memcpy(extract_uid + extract_uidlen, frame + 2, 4);
extract_uidlen += 4;
memcpy(extract_uid + 3, frame + 2, 4);
extract_uidlen = 7;
PrintAndLogEx(INFO, "UID... " _YELLOW_("%s"), sprint_hex_inrow(extract_uid, extract_uidlen));
}
}
@@ -315,9 +392,9 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
// 97 20 = Anticollision of cascade level3
// 97 50 = Bit oriented anti-collision level3
// 97 70 = Select of cascade level3
if (frame[1] == 0x70) {
memcpy(extract_uid + extract_uidlen, frame + 2, 4);
extract_uidlen += 4;
if ((data_len >= 6) && (frame[1] == 0x70)) {
memcpy(extract_uid + 6, frame + 2, 4);
extract_uidlen = 10;
PrintAndLogEx(INFO, "UID... " _YELLOW_("%s"), sprint_hex_inrow(extract_uid, extract_uidlen));
}
break;
@@ -339,28 +416,35 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
for (uint8_t i = 0; i < 2; i++, pos++) {
// the command and its key number
if (pos + long_jmp >= data_len) {
break;
}
switch (frame[pos]) {
case MFDES_AUTHENTICATE: {
// Assume wrapped or unwrapped
PrintAndLogEx(INFO, "Found a MFDES Auth NATIVE (keyNo %d)", frame[pos + long_jmp]);
if (next_record_is_response(tracepos, trace) == false) {
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if ((next_hdr == NULL) || (next_hdr->isResponse == false)) {
break;
}
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
if (next_hdr->data_len < 7) {
if (next_hdr->data_len < 9) {
break;
}
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
PrintAndLogEx(INFO, "DES 1499999999 %s " NOLF, sprint_hex_inrow(next_hdr->frame + 1, 8));
next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr != NULL) {
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
}
if (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME) {
if ((next_hdr != NULL) && (next_hdr->data_len >= pos + long_jmp + 16) && (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME)) {
PrintAndLogEx(NORMAL, "%s", sprint_hex_inrow(next_hdr->frame + pos + long_jmp, 16));
} else {
PrintAndLogEx(NORMAL, "");
@@ -370,13 +454,13 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
case MFDES_AUTHENTICATE_ISO: {
// Assume wrapped or unwrapped
PrintAndLogEx(INFO, "Found a MFDES Auth ISO (keyNo %d)", frame[pos + long_jmp]);
if (next_record_is_response(tracepos, trace) == false) {
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if ((next_hdr == NULL) || (next_hdr->isResponse == false)) {
break;
}
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
if (next_hdr->data_len < 7) {
if (next_hdr->data_len < 9) {
break;
}
@@ -388,10 +472,12 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
PrintAndLogEx(INFO, "2TDEA 1499999999 %s " NOLF, sprint_hex_inrow(next_hdr->frame + 1, tdea));
}
next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr != NULL) {
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
}
if (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME) {
if ((next_hdr != NULL) && (next_hdr->data_len >= pos + long_jmp + (tdea << 1)) && (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME)) {
PrintAndLogEx(NORMAL, "%s", sprint_hex_inrow(next_hdr->frame + pos + long_jmp, (tdea << 1)));
} else {
PrintAndLogEx(NORMAL, "");
@@ -401,22 +487,24 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
case MFDES_AUTHENTICATE_AES: {
// Assume wrapped or unwrapped
PrintAndLogEx(INFO, "Found a MFDES Auth AES (keyNo %d)", frame[pos + long_jmp]);
if (next_record_is_response(tracepos, trace)) {
const tracelog_hdr_t *next_hdr = get_record(tracepos, traceLen, trace);
if ((next_hdr == NULL) || (next_hdr->isResponse == false)) {
break;
}
tracelog_hdr_t *next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
if (next_hdr->data_len < 7) {
if (next_hdr->data_len < 9) {
break;
}
PrintAndLogEx(INFO, "AES 1499999999 %s " NOLF, sprint_hex_inrow(next_hdr->frame + 1, 8));
next_hdr = (tracelog_hdr_t *)(trace + tracepos);
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
next_hdr = get_record(tracepos, traceLen, trace);
if (next_hdr != NULL) {
tracepos += TRACELOG_HDR_LEN + next_hdr->data_len + TRACELOG_PARITY_LEN(next_hdr);
}
if (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME) {
if ((next_hdr != NULL) && (next_hdr->data_len >= pos + long_jmp + 16) && (next_hdr->frame[pos] == MFDES_ADDITIONAL_FRAME)) {
PrintAndLogEx(NORMAL, "%s", sprint_hex_inrow(next_hdr->frame + pos + long_jmp, 16));
} else {
PrintAndLogEx(NORMAL, "");
@@ -425,7 +513,7 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
}
case MFDES_AUTHENTICATE_EV2F: {
PrintAndLogEx(INFO, "Found a MFDES Auth EV2 First");
uint16_t tmp = extractChall_ev2(tracepos, trace, pos, long_jmp);
uint16_t tmp = extractChall_ev2(tracepos, traceLen, trace, pos, long_jmp);
if (tmp == 0)
break;
else
@@ -434,7 +522,7 @@ static uint16_t extractChallenges(uint16_t tracepos, uint16_t traceLen, uint8_t
}
case MFDES_AUTHENTICATE_EV2NF: {
PrintAndLogEx(INFO, "Found a MFDES Auth EV2 Non First");
uint16_t tmp = extractChall_ev2(tracepos, trace, pos, long_jmp);
uint16_t tmp = extractChall_ev2(tracepos, traceLen, trace, pos, long_jmp);
if (tmp == 0)
break;
else
@@ -452,7 +540,7 @@ static uint16_t printHexLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trac
tracelog_hdr_t *hdr = (tracelog_hdr_t *)(trace + tracepos);
if (TRACELOG_HDR_LEN + hdr->data_len + TRACELOG_PARITY_LEN(hdr) > traceLen) {
if (tracepos + TRACELOG_HDR_LEN + hdr->data_len + TRACELOG_PARITY_LEN(hdr) > traceLen) {
return traceLen;
}
@@ -548,30 +636,63 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
uint8_t *frame = hdr->frame;
uint8_t *parityBytes = hdr->frame + data_len;
// Hitag keeps the bit count of the last byte in the first parity byte, 0 for a whole byte
uint8_t hitag_last_bits = (parityBytes[0] <= 8) ? parityBytes[0] : 0;
tracepos += TRACELOG_HDR_LEN + data_len + TRACELOG_PARITY_LEN(hdr);
bool topaz_merged = false;
if (protocol == TOPAZ && !hdr->isResponse) {
// topaz reader commands come in 1 or 9 separate frames with 7 or 8 Bits each.
// topaz reader commands come in 1, 9 or 16 separate frames with 7 or 8 Bits each.
// merge them:
if (merge_topaz_reader_frames(hdr->timestamp, &duration, &tracepos, traceLen, trace, frame, topaz_reader_command, &data_len)) {
frame = topaz_reader_command;
topaz_merged = true;
}
}
// a Topaz command comes one byte per frame: a longer reader frame is an
// ISO14443-A one, the HLTA or the anticollision of a multi protocol reader
bool topaz_14a_frame = (protocol == TOPAZ) && (hdr->isResponse == false) && (topaz_merged == false) && (data_len > 1);
if ((protocol == TOPAZ) && (hdr->isResponse == false)) {
gs_topaz_14a_exchange = topaz_14a_frame;
}
bool topaz_14a_answer = (protocol == TOPAZ) && hdr->isResponse && gs_topaz_14a_exchange;
// a lone 8 bit reader frame: an operand of a command cut short, no command code
bool topaz_operand = (protocol == TOPAZ) && (hdr->isResponse == false) && (topaz_merged == false) &&
(data_len == 1) && (hdr->duration >= ISO14A_SHORT_FRAME_DURATION);
// a Topaz command with fewer frames than its code takes, cut by the end of
// the trace or by the reader, carries no CRC to check
bool topaz_cut = topaz_merged && (data_len < topaz_reader_cmd_len(frame[0]));
// an iCLASS trace also holds the ISO15693 frames of a reader that polls
// both: their CRC covers the whole frame, an iCLASS one the bytes after the command
bool iclass_15693_frame = (protocol == ICLASS) && (hdr->isResponse == false) && (data_len >= 3) && (iso15693_CRC_check(frame, data_len) == 1);
//Check the CRC status
trace_crc_status_t crcStatus = TRACE_CRC_NONE;
if (data_len > 2) {
switch (protocol) {
case ICLASS:
crcStatus = iclass_CRC_check(hdr->isResponse, frame, data_len);
crcStatus = (iclass_15693_frame) ? TRACE_CRC_OK : iclass_CRC_check(hdr->isResponse, frame, data_len);
break;
case ISO_14443B:
case TOPAZ:
crcStatus = iso14443B_CRC_check(frame, data_len);
break;
case TOPAZ:
if (topaz_cut) {
crcStatus = TRACE_CRC_NONE;
} else {
crcStatus = (topaz_14a_frame || topaz_14a_answer) ? iso14443A_CRC_check(hdr->isResponse, frame, data_len) : iso14443B_CRC_check(frame, data_len);
}
break;
case FELICA:
crcStatus = !felica_CRC_check(frame + 2, data_len - 4);
// after the B2 4D sync, the CRC covers LEN to the end
crcStatus = felica_CRC_check(frame + 2, data_len - 2);
break;
case PROTO_MIFARE:
case PROTO_MFPLUS:
@@ -622,16 +743,38 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
break;
case PROTO_HITAG1:
case PROTO_HITAGS:
crcStatus = hitag1_CRC_check(frame, (data_len * 8) - ((8 - parityBytes[0]) % 8));
crcStatus = hitag1_CRC_check(frame, hitag_frame_bits(data_len, hitag_last_bits));
break;
case PROTO_HITAGU:
crcStatus = hitagu_CRC_check(frame, (data_len * 8) - ((8 - parityBytes[0]) % 8));
crcStatus = hitagu_CRC_check(frame, hitag_frame_bits(data_len, hitag_last_bits));
break;
case PROTO_HITAG2:
case PROTO_CRYPTORF:
default:
break;
}
} else if (hdr->isResponse == false) {
// an ISO14443-A anticollision answer is told by the request before it,
// ANTICOLL 93 20 among them: the 14a checks see the short frames too
switch (protocol) {
case PROTO_MIFARE:
case PROTO_MFPLUS:
mifare_CRC_check(false, frame, data_len);
break;
case ISO_14443A:
case MFDES:
case LTO:
case SEOS:
iso14443A_CRC_check(false, frame, data_len);
break;
case TOPAZ:
if (topaz_14a_frame) {
iso14443A_CRC_check(false, frame, data_len);
}
break;
default:
break;
}
}
//0 CRC-command, CRC not ok
//1 CRC-command, CRC ok
@@ -677,7 +820,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
snprintf(line[j / 18] + ((j % 18) * 4), 120, "%02X! ", frame[j]);
} else if (protocol == ICLASS && hdr->isResponse == false) {
} else if (protocol == ICLASS && hdr->isResponse == false && iclass_15693_frame == false) {
uint8_t parity = 0;
for (int i = 0; i < 6; i++) {
@@ -697,7 +840,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
// handle partial bytes. The parity array[0] is used to store number of left over bits from NBYTES
// The bit count now goes in the CRC column, which is unused for
// hitag, so the data field holds nothing but data.
uint8_t nbits = parityBytes[0];
uint8_t nbits = hitag_last_bits;
// only apply this to lesser than one byte
// One leading space, so the hex lines up under the "Data" header.
@@ -708,6 +851,9 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
}
offset = 1;
} else if ((j % 18) == 0) {
// the next rows start with the same leading space
snprintf(line[j / 18], 120, " %02X ", frame[j]);
} else {
snprintf(line[j / 18] + ((j % 18) * 4) + offset, 120, "%02X ", frame[j]);
}
@@ -718,14 +864,15 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
}
if (markCRCBytes && data_len > 2) {
// the rows above hold TRACE_MAX_HEX_BYTES * TRACE_MAX_HEX_BYTES bytes, a longer frame has its CRC past them
if (markCRCBytes && (data_len > 2) && (data_len <= (TRACE_MAX_HEX_BYTES * TRACE_MAX_HEX_BYTES))) {
// CRC-command
if (((protocol == PROTO_HITAG1) || (protocol == PROTO_HITAGS))) {
// Note that UID REQUEST response has no CRC, but we don't know
// if the response we see is a UID
char *pos1 = line[(data_len - 1) / 18] + (((data_len - 1) % 18) * 4) + offset - 1;
(*pos1) = '[';
char *pos2 = line[(data_len) / 18] + (((data_len) % 18) * 4) + offset - 2;
char *pos2 = line[(data_len - 1) / 18] + (((data_len - 1) % 18) * 4) + offset + 2;
(*pos2) = ']';
(*(pos2 + 1)) = '\0';
} else {
@@ -794,16 +941,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
if ((protocol == PROTO_HITAG1) || (protocol == PROTO_HITAG2) ||
(protocol == PROTO_HITAGS) || (protocol == PROTO_HITAGU)) {
uint8_t leftover = parityBytes[0];
uint16_t total;
if ((data_len == 1) && (leftover != 0)) {
total = leftover;
} else if (leftover == 0) {
total = (uint16_t)(data_len * 8);
} else {
total = (uint16_t)(((data_len - 1) * 8) + leftover);
}
snprintf(hitag_nbits, sizeof(hitag_nbits), "%3u ", total);
snprintf(hitag_nbits, sizeof(hitag_nbits), "%3u ", hitag_frame_bits(data_len, hitag_last_bits));
crc = hitag_nbits;
}
@@ -814,7 +952,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
protocol == THINFILM) {
// approximated with 128 * (9 * data_len);
uint16_t bitime = 1056 + 32;
uint16_t bitime = ISO14A_SHORT_FRAME_DURATION;
if (duration < bitime) {
@@ -827,10 +965,11 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
m--;
}
if (data_len) {
line[(data_len - 1) / 16][((data_len - 1) % 16) * 4 + 2] = '(';
line[(data_len - 1) / 16][((data_len - 1) % 16) * 4 + 3] = m + 0x30;
line[(data_len - 1) / 16][((data_len - 1) % 16) * 4 + 4] = ')';
// only a one byte frame can be that short, a longer one has a wrong duration
if (data_len == 1) {
line[0][2] = '(';
line[0][3] = m + 0x30;
line[0][4] = ')';
}
}
}
@@ -872,10 +1011,10 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
annotateHitag1(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
break;
case PROTO_HITAG2:
annotateHitag2(explanation, sizeof(explanation), frame, data_len, parityBytes[0], hdr->isResponse, mfDicKeys, mfDicKeysCount, false);
annotateHitag2(explanation, sizeof(explanation), frame, data_len, hitag_last_bits, hdr->isResponse, mfDicKeys, mfDicKeysCount, false);
break;
case PROTO_HITAGS:
annotateHitagS(explanation, sizeof(explanation), frame, (data_len * 8) - ((8 - parityBytes[0]) % 8), hdr->isResponse);
annotateHitagS(explanation, sizeof(explanation), frame, hitag_frame_bits(data_len, hitag_last_bits), hdr->isResponse);
break;
case FELICA:
annotateFelica(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
@@ -884,7 +1023,11 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
annotateHitagU(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
break;
case ICLASS:
annotateIclass(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
if (iclass_15693_frame) {
annotateIso15693(explanation, sizeof(explanation), frame, data_len);
} else {
annotateIclass(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
}
break;
case SEOS:
annotateSeos(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
@@ -905,7 +1048,17 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
annotateMfPlus(explanation, sizeof(explanation), frame, data_len);
break;
case TOPAZ:
annotateTopaz(explanation, sizeof(explanation), frame, data_len);
if (topaz_14a_frame) {
annotateIso14443a(explanation, sizeof(explanation), frame, data_len, hdr->isResponse);
} else if (topaz_operand) {
snprintf(explanation, sizeof(explanation), "operand");
} else {
annotateTopaz(explanation, sizeof(explanation), frame, data_len);
if (topaz_cut) {
size_t n = strlen(explanation);
snprintf(explanation + n, sizeof(explanation) - n, " (incomplete)");
}
}
break;
case ISO_7816_4:
// trace type "7816" is the contact reader, i.e. `smart list`
@@ -1099,7 +1252,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
// handle partial bytes. The parity array[0] is used to store number of left over bits from NBYTES
// This part prints the number of bits in the trace entry for hitag.
uint8_t nbits = parityBytes[0];
uint8_t nbits = hitag_last_bits;
annotateHitag2(explanation, sizeof(explanation), ht2plain, n, nbits, hdr->isResponse, NULL, 0, true);
// iceman: colorise crc bytes here will need a refactor of code from above.
@@ -1110,7 +1263,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
// Bit count goes in the Bit column, same as the frame above.
// One leading space so the hex lines up under "Data".
if (n == 1) {
if ((n == 1) && (nbits != 0)) {
snprintf(line[0], 120, " %02X ", ht2plain[0] >> (8 - nbits));
} else {
snprintf(line[0], 120, " %02X ", ht2plain[0]);
@@ -1125,13 +1278,7 @@ static uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *tr
num_lines = MIN((n - 1) / TRACE_MAX_HEX_BYTES + 1, TRACE_MAX_HEX_BYTES);
char plain_nbits[8] = {0};
if (n == 1) {
snprintf(plain_nbits, sizeof(plain_nbits), "%3u ", nbits);
} else if (nbits == 0) {
snprintf(plain_nbits, sizeof(plain_nbits), "%3u ", (uint16_t)(n * 8));
} else {
snprintf(plain_nbits, sizeof(plain_nbits), "%3u ", (uint16_t)(((n - 1) * 8) + nbits));
}
snprintf(plain_nbits, sizeof(plain_nbits), "%3u ", hitag_frame_bits(n, nbits));
for (int j = 0; j < num_lines ; j++) {
bool last = (j == num_lines - 1);
@@ -1776,10 +1923,13 @@ int CmdTraceList(const char *Cmd) {
}
PrintAndLogEx(NORMAL, "------------+------------+-----+-------------------------------------------------------------------------+-----+--------------------");
// clean authentication data used with the mifare classic decrypt fct
if (protocol == ISO_14443A || protocol == PROTO_MIFARE || protocol == PROTO_MFPLUS) {
// clean authentication data used with the mifare classic decrypt fct,
// and the anticollision state of the ISO14443-A checks
if (protocol == ISO_14443A || protocol == PROTO_MIFARE || protocol == PROTO_MFPLUS ||
protocol == MFDES || protocol == LTO || protocol == SEOS || protocol == TOPAZ) {
ClearAuthData();
}
gs_topaz_14a_exchange = false;
// reset hitag state machine
if (protocol == PROTO_HITAG1 || protocol == PROTO_HITAG2 || protocol == PROTO_HITAGS || protocol == PROTO_HITAGU) {