X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/proxmark3-svn/blobdiff_plain/20f9a2a1d54952ed15066c93490f0e8fb0d43b67..0beed8fc67c20ba60952d627b7bdbebc0a1655b8:/client/cmdhf14a.c?ds=sidebyside diff --git a/client/cmdhf14a.c b/client/cmdhf14a.c index 922d1b7f..78c269cb 100644 --- a/client/cmdhf14a.c +++ b/client/cmdhf14a.c @@ -1,4 +1,5 @@ //----------------------------------------------------------------------------- +// 2011, Merlok // Copyright (C) 2010 iZsh , Hagen Fritsch // // This code is licensed to you under the terms of the GNU GPL, version 2 or, @@ -11,22 +12,26 @@ #include #include #include +#include #include "util.h" #include "iso14443crc.h" #include "data.h" -#include "proxusb.h" +//#include "proxusb.h" +#include "proxmark3.h" #include "ui.h" #include "cmdparser.h" #include "cmdhf14a.h" #include "common.h" #include "cmdmain.h" +#include "mifare.h" static int CmdHelp(const char *Cmd); int CmdHF14AList(const char *Cmd) { uint8_t got[1920]; - GetFromBigBuf(got, sizeof(got)); + GetFromBigBuf(got,sizeof(got),0); + WaitForResponse(CMD_ACK,NULL); PrintAndLog("recorded activity:"); PrintAndLog(" ETU :rssi: who bytes"); @@ -147,7 +152,7 @@ int CmdHF14AList(const char *Cmd) prev = timestamp; i += (len + 9); } - return 0; + return 0; } void iso14a_set_timeout(uint32_t timeout) { @@ -155,304 +160,331 @@ void iso14a_set_timeout(uint32_t timeout) { SendCommand(&c); } -int CmdHF14AMifare(const char *Cmd) -{ - UsbCommand c = {CMD_READER_MIFARE, {strtol(Cmd, NULL, 0), 0, 0}}; - SendCommand(&c); - return 0; -} - -int CmdHF14AMfWrBl(const char *Cmd) +int CmdHF14AReader(const char *Cmd) { - int i, temp; - uint8_t blockNo = 0; - uint8_t keyType = 0; - uint8_t key[6] = {0, 0, 0, 0, 0, 0}; - uint8_t bldata[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - - const char *cmdp = Cmd; - const char *cmdpe = Cmd; + UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}}; + SendCommand(&c); - if (strlen(Cmd)<3) { - PrintAndLog("Usage: hf 14 mfwrbl "); - PrintAndLog(" sample: hf 14a mfwrbl 0 A FFFFFFFFFFFF 000102030405060708090A0B0C0D0E0F"); - return 0; - } - PrintAndLog("l: %s", Cmd); - - // skip spaces - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - blockNo = strtol(cmdp, NULL, 0) & 0xff; + UsbCommand resp; + WaitForResponse(CMD_ACK,&resp); - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - if (*cmdp != 'A' && *cmdp != 'a') { - keyType = 1; - } + iso14a_card_select_t *card = (iso14a_card_select_t *)resp.d.asBytes; - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - - // next value here:cmdpe - cmdpe = cmdp; - while (*cmdpe!=' ' && *cmdpe!='\t') cmdpe++; - while (*cmdpe==' ' || *cmdpe=='\t') cmdpe++; - - if ((int)cmdpe - (int)cmdp != 13) { - PrintAndLog("Length of key must be 12 hex symbols"); + if(resp.arg[0] == 0) { + PrintAndLog("iso14443a card select failed"); return 0; } - - for(i = 0; i < 6; i++) { - sscanf((char[]){cmdp[0],cmdp[1],0},"%X",&temp); - key[i] = temp & 0xff; - cmdp++; - cmdp++; - } - - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - if (strlen(cmdp) != 32) { - PrintAndLog("Length of block data must be 32 hex symbols"); - return 0; + PrintAndLog("ATQA : %02x %02x", card->atqa[0], card->atqa[1]); + PrintAndLog(" UID : %s", sprint_hex(card->uid, card->uidlen)); + PrintAndLog(" SAK : %02x [%d]", card->sak, resp.arg[0]); + + switch (card->sak) { + case 0x00: PrintAndLog("TYPE : NXP MIFARE Ultralight | Ultralight C"); break; + case 0x04: PrintAndLog("TYPE : NXP MIFARE (various !DESFire !DESFire EV1)"); break; + + case 0x08: PrintAndLog("TYPE : NXP MIFARE CLASSIC 1k | Plus 2k"); break; + case 0x09: PrintAndLog("TYPE : NXP MIFARE Mini 0.3k"); break; + case 0x10: PrintAndLog("TYPE : NXP MIFARE Plus 2k"); break; + case 0x11: PrintAndLog("TYPE : NXP MIFARE Plus 4k"); break; + case 0x18: PrintAndLog("TYPE : NXP MIFARE Classic 4k | Plus 4k"); break; + case 0x20: PrintAndLog("TYPE : NXP MIFARE DESFire 4k | DESFire EV1 2k/4k/8k | Plus 2k/4k | JCOP 31/41"); break; + case 0x24: PrintAndLog("TYPE : NXP MIFARE DESFire | DESFire EV1"); break; + case 0x28: PrintAndLog("TYPE : JCOP31 or JCOP41 v2.3.1"); break; + case 0x38: PrintAndLog("TYPE : Nokia 6212 or 6131 MIFARE CLASSIC 4K"); break; + case 0x88: PrintAndLog("TYPE : Infineon MIFARE CLASSIC 1K"); break; + case 0x98: PrintAndLog("TYPE : Gemplus MPCOS"); break; + default: ; } + if(resp.arg[0] == 1) { + bool ta1 = 0, tb1 = 0, tc1 = 0; + int pos; - for(i = 0; i < 16; i++) { - sscanf((char[]){cmdp[0],cmdp[1],0},"%X",&temp); - bldata[i] = temp & 0xff; - cmdp++; - cmdp++; - } - PrintAndLog(" block no:%02x key type:%02x key:%s", blockNo, keyType, sprint_hex(key, 6)); - PrintAndLog(" data: %s", sprint_hex(bldata, 16)); - - UsbCommand c = {CMD_MIFARE_WRITEBL, {blockNo, keyType, 0}}; - memcpy(c.d.asBytes, key, 6); - memcpy(c.d.asBytes + 10, bldata, 16); - SendCommand(&c); - UsbCommand * resp = WaitForResponseTimeout(CMD_ACK, 1500); - - if (resp != NULL) { - uint8_t isOK = resp->arg[0] & 0xff; - - PrintAndLog("isOk:%02x", isOK); + PrintAndLog(" ATS : %s", sprint_hex(card->ats, card->ats_len)); + if (card->ats_len > 0) { + PrintAndLog(" - TL : length is %d bytes", card->ats[0]); + } + if (card->ats_len > 1) { + ta1 = (card->ats[1] & 0x10) == 0x10; + tb1 = (card->ats[1] & 0x20) == 0x20; + tc1 = (card->ats[1] & 0x40) == 0x40; + PrintAndLog(" - T0 : TA1 is%s present, TB1 is%s present, " + "TC1 is%s present, FSCI is %d", + (ta1 ? "" : " NOT"), (tb1 ? "" : " NOT"), (tc1 ? "" : " NOT"), + (card->ats[1] & 0x0f)); + } + pos = 2; + if (ta1 && card->ats_len > pos) { + char dr[16], ds[16]; + dr[0] = ds[0] = '\0'; + if (card->ats[pos] & 0x10) strcat(ds, "2, "); + if (card->ats[pos] & 0x20) strcat(ds, "4, "); + if (card->ats[pos] & 0x40) strcat(ds, "8, "); + if (card->ats[pos] & 0x01) strcat(dr, "2, "); + if (card->ats[pos] & 0x02) strcat(dr, "4, "); + if (card->ats[pos] & 0x04) strcat(dr, "8, "); + if (strlen(ds) != 0) ds[strlen(ds) - 2] = '\0'; + if (strlen(dr) != 0) dr[strlen(dr) - 2] = '\0'; + PrintAndLog(" - TA1 : different divisors are%s supported, " + "DR: [%s], DS: [%s]", + (card->ats[pos] & 0x80 ? " NOT" : ""), dr, ds); + pos++; + } + if (tb1 && card->ats_len > pos) { + PrintAndLog(" - TB1 : SFGI = %d, FWI = %d", + (card->ats[pos] & 0x08), + (card->ats[pos] & 0x80) >> 4); + pos++; + } + if (tc1 && card->ats_len > pos) { + PrintAndLog(" - TC1 : NAD is%s supported, CID is%s supported", + (card->ats[pos] & 0x01) ? "" : " NOT", + (card->ats[pos] & 0x02) ? "" : " NOT"); + pos++; + } + if (card->ats_len > pos) { + char *tip = ""; + if (card->ats_len - pos > 7) { + if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x01\xBC\xD6", 7) == 0) { + tip = "-> MIFARE Plus X 2K or 4K"; + } else if (memcmp(card->ats + pos, "\xC1\x05\x2F\x2F\x00\x35\xC7", 7) == 0) { + tip = "-> MIFARE Plus S 2K or 4K"; + } + } + PrintAndLog(" - HB : %s%s", sprint_hex(card->ats + pos, card->ats_len - pos - 2), tip); + if (card->ats[pos] == 0xC1) { + PrintAndLog(" c1 -> Mifare or (multiple) virtual cards of various type"); + PrintAndLog(" %02x -> Length is %d bytes", + card->ats[pos + 1], card->ats[pos + 1]); + switch (card->ats[pos + 2] & 0xf0) { + case 0x10: + PrintAndLog(" 1x -> MIFARE DESFire"); + break; + case 0x20: + PrintAndLog(" 2x -> MIFARE Plus"); + break; + } + switch (card->ats[pos + 2] & 0x0f) { + case 0x00: + PrintAndLog(" x0 -> <1 kByte"); + break; + case 0x01: + PrintAndLog(" x0 -> 1 kByte"); + break; + case 0x02: + PrintAndLog(" x0 -> 2 kByte"); + break; + case 0x03: + PrintAndLog(" x0 -> 4 kByte"); + break; + case 0x04: + PrintAndLog(" x0 -> 8 kByte"); + break; + } + switch (card->ats[pos + 3] & 0xf0) { + case 0x00: + PrintAndLog(" 0x -> Engineering sample"); + break; + case 0x20: + PrintAndLog(" 2x -> Released"); + break; + } + switch (card->ats[pos + 3] & 0x0f) { + case 0x00: + PrintAndLog(" x0 -> Generation 1"); + break; + case 0x01: + PrintAndLog(" x1 -> Generation 2"); + break; + case 0x02: + PrintAndLog(" x2 -> Generation 3"); + break; + } + switch (card->ats[pos + 4] & 0x0f) { + case 0x00: + PrintAndLog(" x0 -> Only VCSL supported"); + break; + case 0x01: + PrintAndLog(" x1 -> VCS, VCSL, and SVC supported"); + break; + case 0x0E: + PrintAndLog(" xE -> no VCS command supported"); + break; + } + } + } } else { - PrintAndLog("Command execute timeout"); - } + PrintAndLog("proprietary non iso14443a-4 card found, RATS not supported"); + } - return 0; + return resp.arg[0]; } -int CmdHF14AMfRdBl(const char *Cmd) +// Collect ISO14443 Type A UIDs +int CmdHF14ACUIDs(const char *Cmd) { - int i, temp; - uint8_t blockNo = 0; - uint8_t keyType = 0; - uint8_t key[6] = {0, 0, 0, 0, 0, 0}; - - const char *cmdp = Cmd; - - - if (strlen(Cmd)<3) { - PrintAndLog("Usage: hf 14 mfrdbl "); - PrintAndLog(" sample: hf 14a mfrdbl 0 A FFFFFFFFFFFF "); - return 0; - } - - // skip spaces - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - blockNo = strtol(cmdp, NULL, 0) & 0xff; - - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - if (*cmdp != 'A' && *cmdp != 'a') { - keyType = 1; - } - - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - - if (strlen(cmdp) != 12) { - PrintAndLog("Length of key must be 12 hex symbols"); - return 0; - } - - for(i = 0; i < 6; i++) { - sscanf((char[]){cmdp[0],cmdp[1],0},"%X",&temp); - key[i] = temp & 0xff; - cmdp++; - cmdp++; - } - PrintAndLog(" block no:%02x key type:%02x key:%s ", blockNo, keyType, sprint_hex(key, 6)); - - UsbCommand c = {CMD_MIFARE_READBL, {blockNo, keyType, 0}}; - memcpy(c.d.asBytes, key, 6); - SendCommand(&c); - UsbCommand * resp = WaitForResponseTimeout(CMD_ACK, 1500); - - if (resp != NULL) { - uint8_t isOK = resp->arg[0] & 0xff; - uint8_t * data = resp->d.asBytes; - - PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 16)); - } else { - PrintAndLog("Command execute timeout"); + // requested number of UIDs + int n = atoi(Cmd); + // collect at least 1 (e.g. if no parameter was given) + n = n > 0 ? n : 1; + + PrintAndLog("Collecting %d UIDs", n); + PrintAndLog("Start: %u", time(NULL)); + // repeat n times + for (int i = 0; i < n; i++) { + // execute anticollision procedure + UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}}; + SendCommand(&c); + + UsbCommand resp; + WaitForResponse(CMD_ACK,&resp); + + uint8_t *uid = resp.d.asBytes; + iso14a_card_select_t *card = (iso14a_card_select_t *)(uid + 12); + + // check if command failed + if (resp.arg[0] == 0) { + PrintAndLog("Card select failed."); + } else { + // check if UID is 4 bytes + if ((card->atqa[1] & 0xC0) == 0) { + PrintAndLog("%02X%02X%02X%02X", + *uid, *(uid + 1), *(uid + 2), *(uid + 3)); + } else { + PrintAndLog("UID longer than 4 bytes"); + } + } } + PrintAndLog("End: %u", time(NULL)); - return 0; + return 1; } -int CmdHF14AMfRdSc(const char *Cmd) +// ## simulate iso14443a tag +// ## greg - added ability to specify tag UID +int CmdHF14ASim(const char *Cmd) { - int i, temp; - uint8_t sectorNo = 0; - uint8_t keyType = 0; - uint8_t key[6] = {0, 0, 0, 0, 0, 0}; + UsbCommand c = {CMD_SIMULATE_TAG_ISO_14443a,{0,0,0}}; - const char *cmdp = Cmd; - - - if (strlen(Cmd)<3) { - PrintAndLog("Usage: hf 14 mfrdsc "); - PrintAndLog(" sample: hf 14a mfrdsc 0 A FFFFFFFFFFFF "); - return 0; - } - - // skip spaces - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - sectorNo = strtol(cmdp, NULL, 0) & 0xff; + // Retrieve the tag type + uint8_t tagtype = param_get8ex(Cmd,0,0,10); - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - if (*cmdp != 'A' && *cmdp != 'a') { - keyType = 1; - } - - // next value - while (*cmdp!=' ' && *cmdp!='\t') cmdp++; - while (*cmdp==' ' || *cmdp=='\t') cmdp++; - - if (strlen(cmdp) != 12) { - PrintAndLog("Length of key must be 12 hex symbols"); - return 0; + // When no argument was given, just print help message + if (tagtype == 0) { + PrintAndLog(""); + PrintAndLog(" Emulating ISO/IEC 14443 type A tag with 4 or 7 byte UID"); + PrintAndLog(""); + PrintAndLog(" syntax: hf 14a sim "); + PrintAndLog(" types: 1 = MIFARE Classic"); + PrintAndLog(" 2 = MIFARE Ultralight"); + PrintAndLog(" 3 = MIFARE DESFIRE"); + PrintAndLog(" 4 = ISO/IEC 14443-4"); + PrintAndLog(""); + return 1; } - for(i = 0; i < 6; i++) { - sscanf((char[]){cmdp[0],cmdp[1],0},"%X",&temp); - key[i] = temp & 0xff; - cmdp++; - cmdp++; - } - PrintAndLog(" sector no:%02x key type:%02x key:%s ", sectorNo, keyType, sprint_hex(key, 6)); + // Store the tag type + c.arg[0] = tagtype; - UsbCommand c = {CMD_MIFARE_READSC, {sectorNo, keyType, 0}}; - memcpy(c.d.asBytes, key, 6); - SendCommand(&c); - UsbCommand * resp = WaitForResponseTimeout(CMD_ACK, 1500); - PrintAndLog(" "); - - if (resp != NULL) { - uint8_t isOK = resp->arg[0] & 0xff; - uint8_t * data = resp->d.asBytes; - - PrintAndLog("isOk:%02x", isOK); - for (i = 0; i < 2; i++) { - PrintAndLog("data:%s", sprint_hex(data + i * 16, 16)); - } + // Retrieve the full 4 or 7 byte long uid + uint64_t long_uid = param_get64ex(Cmd,1,0,16); + + // Are we handling the (optional) second part uid? + if (long_uid > 0xffffffff) { + PrintAndLog("Emulating ISO/IEC 14443 type A tag with 7 byte UID (%014"llx")",long_uid); + // Store the second part + c.arg[2] = (long_uid & 0xffffffff); + long_uid >>= 32; + // Store the first part, ignore the first byte, it is replaced by cascade byte (0x88) + c.arg[1] = (long_uid & 0xffffff); } else { - PrintAndLog("Command1 execute timeout"); + PrintAndLog("Emulating ISO/IEC 14443 type A tag with 4 byte UID (%08x)",long_uid); + // Only store the first part + c.arg[1] = long_uid & 0xffffffff; } +/* + // At lease save the mandatory first part of the UID + c.arg[0] = long_uid & 0xffffffff; - // response2 - resp = WaitForResponseTimeout(CMD_ACK, 500); - PrintAndLog(" "); - - if (resp != NULL) { - uint8_t * data = resp->d.asBytes; - - for (i = 0; i < 2; i++) { - PrintAndLog("data:%s", sprint_hex(data + i * 16, 16)); - } - } else { - PrintAndLog("Command2 execute timeout"); - } - return 0; -} - -int CmdHF14AReader(const char *Cmd) -{ - UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}}; - SendCommand(&c); - UsbCommand * resp = WaitForResponse(CMD_ACK); - uint8_t * uid = resp->d.asBytes; - iso14a_card_select_t * card = uid + 12; - - if(resp->arg[0] == 0) { - PrintAndLog("iso14443a card select failed"); - return 0; + // At lease save the mandatory first part of the UID + c.arg[0] = long_uid & 0xffffffff; + + if (c.arg[1] == 0) { + PrintAndLog("Emulating ISO/IEC 14443 type A tag with UID %01d %08x %08x",c.arg[0],c.arg[1],c.arg[2]); } - - PrintAndLog("ATQA : %02x %02x", card->atqa[0], card->atqa[1]); - PrintAndLog(" UID : %s", sprint_hex(uid, 12)); - PrintAndLog(" SAK : %02x [%d]", card->sak, resp->arg[0]); - if(resp->arg[0] == 1) - PrintAndLog(" ATS : %s", sprint_hex(card->ats, card->ats_len)); - else - PrintAndLog("proprietary non-iso14443a card found, RATS not supported"); - - return resp->arg[0]; -} - -// ## simulate iso14443a tag -// ## greg - added ability to specify tag UID -int CmdHF14ASim(const char *Cmd) -{ - + + switch (c.arg[0]) { + case 1: { + PrintAndLog("Emulating ISO/IEC 14443-3 type A tag with 4 byte UID"); + UsbCommand c = {CMD_SIMULATE_TAG_ISO_14443a,param_get32ex(Cmd,0,0,10),param_get32ex(Cmd,1,0,16),param_get32ex(Cmd,2,0,16)}; + } break; + case 2: { + PrintAndLog("Emulating ISO/IEC 14443-4 type A tag with 7 byte UID"); + } break; + default: { + PrintAndLog("Error: unkown tag type (%d)",c.arg[0]); + PrintAndLog("syntax: hf 14a sim ",c.arg[0]); + PrintAndLog(" type1: 4 ",c.arg[0]); + + return 1; + } break; + } +*/ +/* unsigned int hi = 0, lo = 0; int n = 0, i = 0; while (sscanf(&Cmd[i++], "%1x", &n ) == 1) { hi= (hi << 4) | (lo >> 28); lo= (lo << 4) | (n & 0xf); } - - // c.arg should be set to *Cmd or convert *Cmd to the correct format for a uid - UsbCommand c = {CMD_SIMULATE_TAG_ISO_14443a, {hi, lo, 0}}; - PrintAndLog("Emulating 14443A TAG with UID %x%16x", hi, lo); +*/ +// UsbCommand c = {CMD_SIMULATE_TAG_ISO_14443a,param_get32ex(Cmd,0,0,10),param_get32ex(Cmd,1,0,16),param_get32ex(Cmd,2,0,16)}; +// PrintAndLog("Emulating ISO/IEC 14443 type A tag with UID %01d %08x %08x",c.arg[0],c.arg[1],c.arg[2]); SendCommand(&c); return 0; } -int CmdHF14ASnoop(const char *Cmd) -{ - UsbCommand c = {CMD_SNOOP_ISO_14443a}; +int CmdHF14ASnoop(const char *Cmd) { + int param = 0; + + if (param_getchar(Cmd, 0) == 'h') { + PrintAndLog("It get data from the field and saves it into command buffer."); + PrintAndLog("Buffer accessible from command hf 14a list."); + PrintAndLog("Usage: hf 14a snoop [c][r]"); + PrintAndLog("c - triggered by first data from card"); + PrintAndLog("r - triggered by first 7-bit request from reader (REQ,WUP,...)"); + PrintAndLog("sample: hf 14a snoop c r"); + return 0; + } + + for (int i = 0; i < 2; i++) { + char ctmp = param_getchar(Cmd, i); + if (ctmp == 'c' || ctmp == 'C') param |= 0x01; + if (ctmp == 'r' || ctmp == 'R') param |= 0x02; + } + + UsbCommand c = {CMD_SNOOP_ISO_14443a, {param, 0, 0}}; SendCommand(&c); return 0; } static command_t CommandTable[] = { - {"help", CmdHelp, 1, "This help"}, - {"list", CmdHF14AList, 0, "List ISO 14443a history"}, - {"mifare", CmdHF14AMifare, 0, "Read out sector 0 parity error messages"}, - {"mfrdbl", CmdHF14AMfRdBl, 0, "Read MIFARE classic block"}, - {"mfrdsc", CmdHF14AMfRdSc, 0, "Read MIFARE classic sector"}, - {"mfwrbl", CmdHF14AMfWrBl, 0, "Write MIFARE classic block"}, - {"reader", CmdHF14AReader, 0, "Act like an ISO14443 Type A reader"}, - {"sim", CmdHF14ASim, 0, " -- Fake ISO 14443a tag"}, - {"snoop", CmdHF14ASnoop, 0, "Eavesdrop ISO 14443 Type A"}, + {"help", CmdHelp, 1, "This help"}, + {"list", CmdHF14AList, 0, "List ISO 14443a history"}, + {"reader", CmdHF14AReader, 0, "Act like an ISO14443 Type A reader"}, + {"cuids", CmdHF14ACUIDs, 0, " Collect n>0 ISO14443 Type A UIDs in one go"}, + {"sim", CmdHF14ASim, 0, " -- Fake ISO 14443a tag"}, + {"snoop", CmdHF14ASnoop, 0, "Eavesdrop ISO 14443 Type A"}, {NULL, NULL, 0, NULL} }; -int CmdHF14A(const char *Cmd) -{ +int CmdHF14A(const char *Cmd) { + // flush + WaitForResponseTimeout(CMD_ACK,NULL,100); + + // parse CmdsParse(CommandTable, Cmd); return 0; }