1 //-----------------------------------------------------------------------------
3 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>, Hagen Fritsch
5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
6 // at your option, any later version. See the LICENSE.txt file for the text of
8 //-----------------------------------------------------------------------------
9 // High frequency ISO14443A commands
10 //-----------------------------------------------------------------------------
17 #include "iso14443crc.h"
19 #include "proxmark3.h"
21 #include "cmdparser.h"
27 static int CmdHelp(const char *Cmd
);
28 static void waitCmd(uint8_t iLen
);
30 int CmdHF14AList(const char *Cmd
)
32 bool ShowWaitCycles
= false;
33 char param
= param_getchar(Cmd
, 0);
35 if (param
== 'h' || (param
!= 0 && param
!= 'f')) {
36 PrintAndLog("List data in trace buffer.");
37 PrintAndLog("Usage: hf 14a list [f]");
38 PrintAndLog("f - show frame delay times as well");
39 PrintAndLog("sample: hf 14a list f");
44 ShowWaitCycles
= true;
47 // for the time being. Need better Bigbuf handling.
48 #define TRACE_SIZE 3000
50 uint8_t trace
[TRACE_SIZE
];
51 GetFromBigBuf(trace
, TRACE_SIZE
, 0);
52 WaitForResponse(CMD_ACK
, NULL
);
54 PrintAndLog("Recorded Activity");
56 PrintAndLog("Start = Start of Start Bit, End = End of last modulation. Src = Source of Transfer");
57 PrintAndLog("All times are in carrier periods (1/13.56Mhz)");
59 PrintAndLog(" Start | End | Src | Data (! denotes parity error) | CRC ");
60 PrintAndLog("-----------|-----------|-----|-----------------------------------------------------------------------");
62 uint16_t tracepos
= 0;
68 uint32_t first_timestamp
;
69 uint32_t EndOfTransmissionTimestamp
;
73 if(tracepos
>= TRACE_SIZE
) {
77 timestamp
= *((uint32_t *)(trace
+ tracepos
));
79 first_timestamp
= timestamp
;
82 duration
= *((uint16_t *)(trace
+ tracepos
));
84 data_len
= *((uint16_t *)(trace
+ tracepos
));
87 if (data_len
& 0x8000) {
94 parity_len
= (data_len
-1)/8 + 1;
96 if (tracepos
+ data_len
+ parity_len
>= TRACE_SIZE
) {
100 uint8_t *frame
= trace
+ tracepos
;
101 tracepos
+= data_len
;
102 uint8_t *parityBytes
= trace
+ tracepos
;
103 tracepos
+= parity_len
;
105 // Break and stick with current result if buffer was not completely full
106 if (timestamp
== 0x44444444) break;
109 for (int j
= 0; j
< data_len
; j
++) {
110 int oddparity
= 0x01;
114 oddparity
^= (((frame
[j
] & 0xFF) >> k
) & 0x01);
117 uint8_t parityBits
= parityBytes
[j
>>3];
118 if (isResponse
&& (oddparity
!= ((parityBits
>> (7-(j
&0x0007))) & 0x01))) {
119 sprintf(line
[j
/16]+((j
%16)*4), "%02x! ", frame
[j
]);
121 sprintf(line
[j
/16]+((j
%16)*4), "%02x ", frame
[j
]);
129 ComputeCrc14443(CRC_14443_A
, frame
, data_len
-2, &b1
, &b2
);
130 if (b1
!= frame
[data_len
-2] || b2
!= frame
[data_len
-1]) {
131 sprintf(crc
, (isResponse
& (data_len
< 6)) ? "" : "!crc");
137 EndOfTransmissionTimestamp
= timestamp
+ duration
;
139 int num_lines
= (data_len
- 1)/16 + 1;
140 for (int j
= 0; j
< num_lines
; j
++) {
142 PrintAndLog(" %9d | %9d | %s | %-64s| %s",
143 (timestamp
- first_timestamp
),
144 (EndOfTransmissionTimestamp
- first_timestamp
),
145 (isResponse
? "Tag" : "Rdr"),
147 (j
== num_lines
-1)?crc
:"");
149 PrintAndLog(" | | | %-64s| %s",
151 (j
== num_lines
-1)?crc
:"");
155 bool next_isResponse
= *((uint16_t *)(trace
+ tracepos
+ 6)) & 0x8000;
157 if (ShowWaitCycles
&& !isResponse
&& next_isResponse
) {
158 uint32_t next_timestamp
= *((uint32_t *)(trace
+ tracepos
));
159 if (next_timestamp
!= 0x44444444) {
160 PrintAndLog(" %9d | %9d | %s | fdt (Frame Delay Time): %d",
161 (EndOfTransmissionTimestamp
- first_timestamp
),
162 (next_timestamp
- first_timestamp
),
164 (next_timestamp
- EndOfTransmissionTimestamp
));
173 void iso14a_set_timeout(uint32_t timeout
) {
174 UsbCommand c
= {CMD_READER_ISO_14443a
, {ISO14A_SET_TIMEOUT
, 0, timeout
}};
178 int CmdHF14AReader(const char *Cmd
)
180 UsbCommand c
= {CMD_READER_ISO_14443a
, {ISO14A_CONNECT
| ISO14A_NO_DISCONNECT
, 0, 0}};
184 WaitForResponse(CMD_ACK
,&resp
);
186 iso14a_card_select_t card
;
187 memcpy(&card
, (iso14a_card_select_t
*)resp
.d
.asBytes
, sizeof(iso14a_card_select_t
));
189 uint64_t select_status
= resp
.arg
[0]; // 0: couldn't read, 1: OK, with ATS, 2: OK, no ATS
191 if(select_status
== 0) {
192 PrintAndLog("iso14443a card select failed");
196 PrintAndLog("ATQA : %02x %02x", card
.atqa
[1], card
.atqa
[0]);
197 PrintAndLog(" UID : %s", sprint_hex(card
.uid
, card
.uidlen
));
198 PrintAndLog(" SAK : %02x [%d]", card
.sak
, resp
.arg
[0]);
201 case 0x00: PrintAndLog("TYPE : NXP MIFARE Ultralight | Ultralight C"); break;
202 case 0x04: PrintAndLog("TYPE : NXP MIFARE (various !DESFire !DESFire EV1)"); break;
203 case 0x08: PrintAndLog("TYPE : NXP MIFARE CLASSIC 1k | Plus 2k SL1"); break;
204 case 0x09: PrintAndLog("TYPE : NXP MIFARE Mini 0.3k"); break;
205 case 0x10: PrintAndLog("TYPE : NXP MIFARE Plus 2k SL2"); break;
206 case 0x11: PrintAndLog("TYPE : NXP MIFARE Plus 4k SL2"); break;
207 case 0x18: PrintAndLog("TYPE : NXP MIFARE Classic 4k | Plus 4k SL1"); break;
208 case 0x20: PrintAndLog("TYPE : NXP MIFARE DESFire 4k | DESFire EV1 2k/4k/8k | Plus 2k/4k SL3 | JCOP 31/41"); break;
209 case 0x24: PrintAndLog("TYPE : NXP MIFARE DESFire | DESFire EV1"); break;
210 case 0x28: PrintAndLog("TYPE : JCOP31 or JCOP41 v2.3.1"); break;
211 case 0x38: PrintAndLog("TYPE : Nokia 6212 or 6131 MIFARE CLASSIC 4K"); break;
212 case 0x88: PrintAndLog("TYPE : Infineon MIFARE CLASSIC 1K"); break;
213 case 0x98: PrintAndLog("TYPE : Gemplus MPCOS"); break;
218 // try to request ATS even if tag claims not to support it
219 if (select_status
== 2) {
220 uint8_t rats
[] = { 0xE0, 0x80 }; // FSDI=8 (FSD=256), CID=0
221 c
.arg
[0] = ISO14A_RAW
| ISO14A_APPEND_CRC
| ISO14A_NO_DISCONNECT
;
224 memcpy(c
.d
.asBytes
, rats
, 2);
226 WaitForResponse(CMD_ACK
,&resp
);
228 memcpy(&card
.ats
, resp
.d
.asBytes
, resp
.arg
[0]);
229 card
.ats_len
= resp
.arg
[0]; // note: ats_len includes CRC Bytes
239 if(card
.ats_len
>= 3) { // a valid ATS consists of at least the length byte (TL) and 2 CRC bytes
240 bool ta1
= 0, tb1
= 0, tc1
= 0;
243 if (select_status
== 2) {
244 PrintAndLog("SAK incorrectly claims that card doesn't support RATS");
246 PrintAndLog(" ATS : %s", sprint_hex(card
.ats
, card
.ats_len
));
247 PrintAndLog(" - TL : length is %d bytes", card
.ats
[0]);
248 if (card
.ats
[0] != card
.ats_len
- 2) {
249 PrintAndLog("ATS may be corrupted. Length of ATS (%d bytes incl. 2 Bytes CRC) doesn't match TL", card
.ats_len
);
252 if (card
.ats
[0] > 1) { // there is a format byte (T0)
253 ta1
= (card
.ats
[1] & 0x10) == 0x10;
254 tb1
= (card
.ats
[1] & 0x20) == 0x20;
255 tc1
= (card
.ats
[1] & 0x40) == 0x40;
256 int16_t fsci
= card
.ats
[1] & 0x0f;
257 PrintAndLog(" - T0 : TA1 is%s present, TB1 is%s present, "
258 "TC1 is%s present, FSCI is %d (FSC = %ld)",
259 (ta1
? "" : " NOT"), (tb1
? "" : " NOT"), (tc1
? "" : " NOT"),
261 fsci
< 5 ? (fsci
- 2) * 8 :
262 fsci
< 8 ? (fsci
- 3) * 32 :
270 dr
[0] = ds
[0] = '\0';
271 if (card
.ats
[pos
] & 0x10) strcat(ds
, "2, ");
272 if (card
.ats
[pos
] & 0x20) strcat(ds
, "4, ");
273 if (card
.ats
[pos
] & 0x40) strcat(ds
, "8, ");
274 if (card
.ats
[pos
] & 0x01) strcat(dr
, "2, ");
275 if (card
.ats
[pos
] & 0x02) strcat(dr
, "4, ");
276 if (card
.ats
[pos
] & 0x04) strcat(dr
, "8, ");
277 if (strlen(ds
) != 0) ds
[strlen(ds
) - 2] = '\0';
278 if (strlen(dr
) != 0) dr
[strlen(dr
) - 2] = '\0';
279 PrintAndLog(" - TA1 : different divisors are%s supported, "
280 "DR: [%s], DS: [%s]",
281 (card
.ats
[pos
] & 0x80 ? " NOT" : ""), dr
, ds
);
285 uint32_t sfgi
= card
.ats
[pos
] & 0x0F;
286 uint32_t fwi
= card
.ats
[pos
] >> 4;
287 PrintAndLog(" - TB1 : SFGI = %d (SFGT = %s%ld/fc), FWI = %d (FWT = %ld/fc)",
289 sfgi
? "" : "(not needed) ",
290 sfgi
? (1 << 12) << sfgi
: 0,
297 PrintAndLog(" - TC1 : NAD is%s supported, CID is%s supported",
298 (card
.ats
[pos
] & 0x01) ? "" : " NOT",
299 (card
.ats
[pos
] & 0x02) ? "" : " NOT");
302 if (card
.ats
[0] > pos
) {
304 if (card
.ats
[0] - pos
>= 7) {
305 if (memcmp(card
.ats
+ pos
, "\xC1\x05\x2F\x2F\x01\xBC\xD6", 7) == 0) {
306 tip
= "-> MIFARE Plus X 2K or 4K";
307 } else if (memcmp(card
.ats
+ pos
, "\xC1\x05\x2F\x2F\x00\x35\xC7", 7) == 0) {
308 tip
= "-> MIFARE Plus S 2K or 4K";
311 PrintAndLog(" - HB : %s%s", sprint_hex(card
.ats
+ pos
, card
.ats
[0] - pos
), tip
);
312 if (card
.ats
[pos
] == 0xC1) {
313 PrintAndLog(" c1 -> Mifare or (multiple) virtual cards of various type");
314 PrintAndLog(" %02x -> Length is %d bytes",
315 card
.ats
[pos
+ 1], card
.ats
[pos
+ 1]);
316 switch (card
.ats
[pos
+ 2] & 0xf0) {
318 PrintAndLog(" 1x -> MIFARE DESFire");
321 PrintAndLog(" 2x -> MIFARE Plus");
324 switch (card
.ats
[pos
+ 2] & 0x0f) {
326 PrintAndLog(" x0 -> <1 kByte");
329 PrintAndLog(" x0 -> 1 kByte");
332 PrintAndLog(" x0 -> 2 kByte");
335 PrintAndLog(" x0 -> 4 kByte");
338 PrintAndLog(" x0 -> 8 kByte");
341 switch (card
.ats
[pos
+ 3] & 0xf0) {
343 PrintAndLog(" 0x -> Engineering sample");
346 PrintAndLog(" 2x -> Released");
349 switch (card
.ats
[pos
+ 3] & 0x0f) {
351 PrintAndLog(" x0 -> Generation 1");
354 PrintAndLog(" x1 -> Generation 2");
357 PrintAndLog(" x2 -> Generation 3");
360 switch (card
.ats
[pos
+ 4] & 0x0f) {
362 PrintAndLog(" x0 -> Only VCSL supported");
365 PrintAndLog(" x1 -> VCS, VCSL, and SVC supported");
368 PrintAndLog(" xE -> no VCS command supported");
374 PrintAndLog("proprietary non iso14443-4 card found, RATS not supported");
377 return select_status
;
380 // Collect ISO14443 Type A UIDs
381 int CmdHF14ACUIDs(const char *Cmd
)
383 // requested number of UIDs
385 // collect at least 1 (e.g. if no parameter was given)
388 PrintAndLog("Collecting %d UIDs", n
);
389 PrintAndLog("Start: %u", time(NULL
));
391 for (int i
= 0; i
< n
; i
++) {
392 // execute anticollision procedure
393 UsbCommand c
= {CMD_READER_ISO_14443a
, {ISO14A_CONNECT
, 0, 0}};
397 WaitForResponse(CMD_ACK
,&resp
);
399 iso14a_card_select_t
*card
= (iso14a_card_select_t
*) resp
.d
.asBytes
;
401 // check if command failed
402 if (resp
.arg
[0] == 0) {
403 PrintAndLog("Card select failed.");
406 for (uint16_t i
= 0; i
< card
->uidlen
; i
++) {
407 sprintf(&uid_string
[2*i
], "%02X", card
->uid
[i
]);
409 PrintAndLog("%s", uid_string
);
412 PrintAndLog("End: %u", time(NULL
));
417 // ## simulate iso14443a tag
418 // ## greg - added ability to specify tag UID
419 int CmdHF14ASim(const char *Cmd
)
421 UsbCommand c
= {CMD_SIMULATE_TAG_ISO_14443a
,{0,0,0}};
423 // Retrieve the tag type
424 uint8_t tagtype
= param_get8ex(Cmd
,0,0,10);
426 // When no argument was given, just print help message
429 PrintAndLog(" Emulating ISO/IEC 14443 type A tag with 4 or 7 byte UID");
431 PrintAndLog(" syntax: hf 14a sim <type> <uid>");
432 PrintAndLog(" types: 1 = MIFARE Classic");
433 PrintAndLog(" 2 = MIFARE Ultralight");
434 PrintAndLog(" 3 = MIFARE DESFIRE");
435 PrintAndLog(" 4 = ISO/IEC 14443-4");
440 // Store the tag type
443 // Retrieve the full 4 or 7 byte long uid
444 uint64_t long_uid
= param_get64ex(Cmd
,1,0,16);
446 // Are we handling the (optional) second part uid?
447 if (long_uid
> 0xffffffff) {
448 PrintAndLog("Emulating ISO/IEC 14443 type A tag with 7 byte UID (%014"llx
")",long_uid
);
449 // Store the second part
450 c
.arg
[2] = (long_uid
& 0xffffffff);
452 // Store the first part, ignore the first byte, it is replaced by cascade byte (0x88)
453 c
.arg
[1] = (long_uid
& 0xffffff);
455 PrintAndLog("Emulating ISO/IEC 14443 type A tag with 4 byte UID (%08x)",long_uid
);
456 // Only store the first part
457 c
.arg
[1] = long_uid
& 0xffffffff;
460 // At lease save the mandatory first part of the UID
461 c.arg[0] = long_uid & 0xffffffff;
464 // At lease save the mandatory first part of the UID
465 c.arg[0] = long_uid & 0xffffffff;
468 PrintAndLog("Emulating ISO/IEC 14443 type A tag with UID %01d %08x %08x",c.arg[0],c.arg[1],c.arg[2]);
473 PrintAndLog("Emulating ISO/IEC 14443-3 type A tag with 4 byte UID");
474 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)};
477 PrintAndLog("Emulating ISO/IEC 14443-4 type A tag with 7 byte UID");
480 PrintAndLog("Error: unkown tag type (%d)",c.arg[0]);
481 PrintAndLog("syntax: hf 14a sim <uid>",c.arg[0]);
482 PrintAndLog(" type1: 4 ",c.arg[0]);
489 unsigned int hi = 0, lo = 0;
491 while (sscanf(&Cmd[i++], "%1x", &n ) == 1) {
492 hi= (hi << 4) | (lo >> 28);
493 lo= (lo << 4) | (n & 0xf);
496 // 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)};
497 // PrintAndLog("Emulating ISO/IEC 14443 type A tag with UID %01d %08x %08x",c.arg[0],c.arg[1],c.arg[2]);
502 int CmdHF14ASnoop(const char *Cmd
) {
505 if (param_getchar(Cmd
, 0) == 'h') {
506 PrintAndLog("It get data from the field and saves it into command buffer.");
507 PrintAndLog("Buffer accessible from command hf 14a list.");
508 PrintAndLog("Usage: hf 14a snoop [c][r]");
509 PrintAndLog("c - triggered by first data from card");
510 PrintAndLog("r - triggered by first 7-bit request from reader (REQ,WUP,...)");
511 PrintAndLog("sample: hf 14a snoop c r");
515 for (int i
= 0; i
< 2; i
++) {
516 char ctmp
= param_getchar(Cmd
, i
);
517 if (ctmp
== 'c' || ctmp
== 'C') param
|= 0x01;
518 if (ctmp
== 'r' || ctmp
== 'R') param
|= 0x02;
521 UsbCommand c
= {CMD_SNOOP_ISO_14443a
, {param
, 0, 0}};
526 int CmdHF14ACmdRaw(const char *cmd
) {
527 UsbCommand c
= {CMD_READER_ISO_14443a
, {0, 0, 0}};
532 uint8_t active_select
=0;
537 unsigned int datalen
=0, temp
;
540 PrintAndLog("Usage: hf 14a raw [-r] [-c] [-p] [-f] [-b] <number of bits> <0A 0B 0C ... hex>");
541 PrintAndLog(" -r do not read response");
542 PrintAndLog(" -c calculate and append CRC");
543 PrintAndLog(" -p leave the signal field ON after receive");
544 PrintAndLog(" -a active signal field ON without select");
545 PrintAndLog(" -s active signal field ON with select");
546 PrintAndLog(" -b number of bits to send. Useful for send partial byte");
551 while (*cmd
==' ' || *cmd
=='\t') cmd
++;
553 while (cmd
[i
]!='\0') {
554 if (cmd
[i
]==' ' || cmd
[i
]=='\t') { i
++; continue; }
573 sscanf(cmd
+i
+2,"%d",&temp
);
574 numbits
= temp
& 0xFFFF;
576 while(cmd
[i
]!=' ' && cmd
[i
]!='\0') { i
++; }
580 PrintAndLog("Invalid option");
586 if ((cmd
[i
]>='0' && cmd
[i
]<='9') ||
587 (cmd
[i
]>='a' && cmd
[i
]<='f') ||
588 (cmd
[i
]>='A' && cmd
[i
]<='F') ) {
589 buf
[strlen(buf
)+1]=0;
590 buf
[strlen(buf
)]=cmd
[i
];
593 if (strlen(buf
)>=2) {
594 sscanf(buf
,"%x",&temp
);
595 data
[datalen
]=(uint8_t)(temp
& 0xff);
601 PrintAndLog("Invalid char on input");
606 uint8_t first
, second
;
607 ComputeCrc14443(CRC_14443_A
, data
, datalen
, &first
, &second
);
608 data
[datalen
++] = first
;
609 data
[datalen
++] = second
;
612 if(active
|| active_select
)
614 c
.arg
[0] |= ISO14A_CONNECT
;
616 c
.arg
[0] |= ISO14A_NO_SELECT
;
619 c
.arg
[0] |= ISO14A_NO_DISCONNECT
;
621 c
.arg
[0] |= ISO14A_RAW
;
625 memcpy(c
.d
.asBytes
,data
,datalen
);
638 static void waitCmd(uint8_t iSelect
)
644 if (WaitForResponseTimeout(CMD_ACK
,&resp
,1000)) {
645 recv
= resp
.d
.asBytes
;
646 uint8_t iLen
= iSelect
? resp
.arg
[1] : resp
.arg
[0];
647 PrintAndLog("received %i octets",iLen
);
650 hexout
= (char *)malloc(iLen
* 3 + 1);
651 if (hexout
!= NULL
) {
652 for (int i
= 0; i
< iLen
; i
++) { // data in hex
653 sprintf(&hexout
[i
* 3], "%02X ", recv
[i
]);
655 PrintAndLog("%s", hexout
);
658 PrintAndLog("malloc failed your client has low memory?");
661 PrintAndLog("timeout while waiting for reply.");
665 static command_t CommandTable
[] =
667 {"help", CmdHelp
, 1, "This help"},
668 {"list", CmdHF14AList
, 0, "List ISO 14443a history"},
669 {"reader", CmdHF14AReader
, 0, "Act like an ISO14443 Type A reader"},
670 {"cuids", CmdHF14ACUIDs
, 0, "<n> Collect n>0 ISO14443 Type A UIDs in one go"},
671 {"sim", CmdHF14ASim
, 0, "<UID> -- Fake ISO 14443a tag"},
672 {"snoop", CmdHF14ASnoop
, 0, "Eavesdrop ISO 14443 Type A"},
673 {"raw", CmdHF14ACmdRaw
, 0, "Send raw hex data to tag"},
674 {NULL
, NULL
, 0, NULL
}
677 int CmdHF14A(const char *Cmd
) {
679 WaitForResponseTimeout(CMD_ACK
,NULL
,100);
682 CmdsParse(CommandTable
, Cmd
);
686 int CmdHelp(const char *Cmd
)
688 CmdsHelp(CommandTable
);