1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
7 //-----------------------------------------------------------------------------
8 // High frequency ISO14443B commands
9 //-----------------------------------------------------------------------------
16 #include "iso14443crc.h"
17 #include "proxmark3.h"
22 #include "cmdparser.h"
27 static int CmdHelp(const char *Cmd
);
29 int CmdHF14BList(const char *Cmd
)
31 PrintAndLog("Deprecated command, use 'hf list 14b' instead");
36 int CmdHF14BSim(const char *Cmd
)
38 UsbCommand c
={CMD_SIMULATE_TAG_ISO_14443B
};
44 int CmdHF14BSnoop(const char *Cmd
)
46 UsbCommand c
= {CMD_SNOOP_ISO_14443B
};
52 /* New command to read the contents of a SRI512 tag
53 * SRI512 tags are ISO14443-B modulated memory tags,
54 * this command just dumps the contents of the memory
56 int CmdSri512Read(const char *Cmd
)
58 UsbCommand c
= {CMD_READ_SRI512_TAG
, {strtol(Cmd
, NULL
, 0), 0, 0}};
64 /* New command to read the contents of a SRIX4K tag
65 * SRIX4K tags are ISO14443-B modulated memory tags,
66 * this command just dumps the contents of the memory/
68 int CmdSrix4kRead(const char *Cmd
)
70 UsbCommand c
= {CMD_READ_SRIX4K_TAG
, {strtol(Cmd
, NULL
, 0), 0, 0}};
78 UsbCommand c
= {CMD_ISO_14443B_COMMAND
, {0, 0, 0}};
81 if (!WaitForResponseTimeout(CMD_ACK
,&resp
,1000)) {
87 int HF14BCmdRaw(bool reply
, bool *crc
, bool power
, uint8_t *data
, uint8_t *datalen
, bool verbose
){
89 UsbCommand c
= {CMD_ISO_14443B_COMMAND
, {0, 0, 0}}; // len,recv,power
92 uint8_t first
, second
;
93 ComputeCrc14443(CRC_14443_B
, data
, *datalen
, &first
, &second
);
94 data
[*datalen
] = first
;
95 data
[*datalen
+ 1] = second
;
102 memcpy(c
.d
.asBytes
,data
,*datalen
);
103 clearCommandBuffer();
106 if (!reply
) return 1;
108 if (!WaitForResponseTimeout(CMD_ACK
,&resp
,1000)) {
109 if (verbose
) PrintAndLog("timeout while waiting for reply.");
112 *datalen
= resp
.arg
[0];
113 if (verbose
) PrintAndLog("received %u octets", *datalen
);
114 if(*datalen
<2) return 0;
116 memcpy(data
, resp
.d
.asBytes
, *datalen
);
117 if (verbose
) PrintAndLog("%s", sprint_hex(data
, *datalen
));
119 uint8_t first
, second
;
120 ComputeCrc14443(CRC_14443_B
, data
, *datalen
-2, &first
, &second
);
121 if(data
[*datalen
-2] == first
&& data
[*datalen
-1] == second
) {
122 if (verbose
) PrintAndLog("CRC OK");
125 if (verbose
) PrintAndLog("CRC failed");
131 int CmdHF14BCmdRaw (const char *Cmd
) {
137 uint8_t data
[100] = {0x00};
142 PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] <0A 0B 0C ... hex>");
143 PrintAndLog(" -r do not read response");
144 PrintAndLog(" -c calculate and append CRC");
145 PrintAndLog(" -p leave the field on after receive");
146 PrintAndLog(" -s active signal field ON with select");
151 while (*Cmd
==' ' || *Cmd
=='\t') Cmd
++;
153 while (Cmd
[i
]!='\0') {
154 if (Cmd
[i
]==' ' || Cmd
[i
]=='\t') { i
++; continue; }
174 PrintAndLog("Invalid option");
180 if ((Cmd
[i
]>='0' && Cmd
[i
]<='9') ||
181 (Cmd
[i
]>='a' && Cmd
[i
]<='f') ||
182 (Cmd
[i
]>='A' && Cmd
[i
]<='F') ) {
183 buf
[strlen(buf
)+1]=0;
184 buf
[strlen(buf
)]=Cmd
[i
];
187 if (strlen(buf
)>=2) {
188 sscanf(buf
,"%x",&temp
);
189 data
[datalen
++]=(uint8_t)(temp
& 0xff);
194 PrintAndLog("Invalid char on input");
199 PrintAndLog("Missing data input");
203 if (select
){ //auto select 14b tag
212 if (HF14BCmdRaw(true, &crc2
, true, cmd2
, &cmdLen
, false)==0) return rawClose();
214 if (cmd2
[0] != 0x50 || cmdLen
!= 14 || !crc2
) return rawClose();
217 // UID from data[1 - 4]
225 if (HF14BCmdRaw(true, &crc2
, true, cmd2
, &cmdLen
, false)==0) return rawClose();
227 if (cmdLen
!= 3 || !crc2
) return rawClose();
230 return HF14BCmdRaw(reply
, &crc
, power
, data
, &datalen
, true);
233 // print full atqb info
234 static void print_atqb_resp(uint8_t *data
){
235 //PrintAndLog (" UID: %s", sprint_hex(data+1,4));
236 PrintAndLog (" App Data: %s", sprint_hex(data
+5,4));
237 PrintAndLog (" Protocol: %s", sprint_hex(data
+9,3));
238 uint8_t BitRate
= data
[9];
240 PrintAndLog (" Bit Rate: 106 kbit/s only PICC <-> PCD");
242 PrintAndLog (" Bit Rate: 212 kbit/s PICC -> PCD supported");
244 PrintAndLog (" Bit Rate: 424 kbit/s PICC -> PCD supported");
246 PrintAndLog (" Bit Rate: 847 kbit/s PICC -> PCD supported");
248 PrintAndLog (" Bit Rate: 212 kbit/s PICC <- PCD supported");
250 PrintAndLog (" Bit Rate: 424 kbit/s PICC <- PCD supported");
252 PrintAndLog (" Bit Rate: 847 kbit/s PICC <- PCD supported");
254 PrintAndLog (" Same bit rate <-> required");
256 uint16_t maxFrame
= data
[10]>>4;
258 maxFrame
= 8*maxFrame
+ 16;
259 else if (maxFrame
== 5)
261 else if (maxFrame
== 6)
263 else if (maxFrame
== 7)
265 else if (maxFrame
== 8)
270 PrintAndLog ("Max Frame Size: %u%s",maxFrame
, (maxFrame
== 257) ? "+ RFU" : "");
272 uint8_t protocolT
= data
[10] & 0xF;
273 PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT
) ? "" : "not " );
274 PrintAndLog ("Frame Wait Int: %u", data
[11]>>4);
275 PrintAndLog (" App Data Code: Application is %s",(data
[11]&4) ? "Standard" : "Proprietary");
276 PrintAndLog (" Frame Options: NAD is %ssupported",(data
[11]&2) ? "" : "not ");
277 PrintAndLog (" Frame Options: CID is %ssupported",(data
[11]&1) ? "" : "not ");
278 PrintAndLog ("Max Buf Length: %u (MBLI) %s",data
[14]>>4, (data
[14] & 0xF0) ? "" : "not supported");
283 // get SRx chip model (from UID) // from ST Microelectronics
284 char *get_ST_Chip_Model(uint8_t data
){
285 static char model
[20];
286 char *retStr
= model
;
287 memset(model
,0, sizeof(model
));
290 case 0x0: sprintf(retStr
, "SRIX4K (Special)"); break;
291 case 0x2: sprintf(retStr
, "SR176"); break;
292 case 0x3: sprintf(retStr
, "SRIX4K"); break;
293 case 0x4: sprintf(retStr
, "SRIX512"); break;
294 case 0x6: sprintf(retStr
, "SRI512"); break;
295 case 0x7: sprintf(retStr
, "SRI4K"); break;
296 case 0xC: sprintf(retStr
, "SRT512"); break;
297 default : sprintf(retStr
, "Unknown"); break;
302 int print_ST_Lock_info(uint8_t model
){
303 //assume connection open and tag selected...
304 uint8_t data
[16] = {0x00};
311 if (model
== 0x2) { //SR176 has special command:
320 if (HF14BCmdRaw(true, &crc
, true, data
, &datalen
, false)==0) return rawClose();
322 if (datalen
!= resplen
|| !crc
) return rawClose();
324 PrintAndLog("Chip Write Protection Bits:");
325 // now interpret the data
327 case 0x0: //fall through (SRIX4K special)
328 case 0x3: //fall through (SRIx4K)
332 PrintAndLog(" raw: %s",printBits(1,data
+3));
333 PrintAndLog(" 07/08:%slocked", (data
[3] & 1) ? " not " : " " );
334 for (uint8_t i
= 1; i
<8; i
++){
335 PrintAndLog(" %02u:%slocked", blk1
, (data
[3] & (1 << i
)) ? " not " : " " );
339 case 0x4: //fall through (SRIX512)
340 case 0x6: //fall through (SRI512)
341 case 0xC: // (SRT512)
342 //need data[2] and data[3]
344 PrintAndLog(" raw: %s",printBits(2,data
+2));
345 for (uint8_t b
=2; b
<4; b
++){
346 for (uint8_t i
=0; i
<8; i
++){
347 PrintAndLog(" %02u:%slocked", blk1
, (data
[b
] & (1 << i
)) ? " not " : " " );
355 PrintAndLog(" raw: %s",printBits(1,data
+2));
356 for (uint8_t i
= 0; i
<8; i
++){
357 PrintAndLog(" %02u/%02u:%slocked", blk1
, blk1
+1, (data
[2] & (1 << i
)) ? " " : " not " );
367 // print UID info from SRx chips (ST Microelectronics)
368 static void print_st_general_info(uint8_t *data
){
369 //uid = first 8 bytes in data
370 PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data
,8,8),8));
371 PrintAndLog(" MFG: %02X, %s", data
[6], getTagInfo(data
[6]));
372 PrintAndLog(" Chip: %02X, %s", data
[5]>>2, get_ST_Chip_Model(data
[5]>>2));
376 // 14b get and print UID only (general info)
377 int HF14BStdReader(uint8_t *data
, uint8_t *datalen
){
378 //05 00 00 = find one tag in field
379 //1d xx xx xx xx 00 08 01 00 = attrib xx=UID (resp 10 [f9 e0])
380 //a3 = ? (resp 03 [e2 c2])
381 //02 = ? (resp 02 [6a d3])
382 // 022b (resp 02 67 00 [29 5b])
383 // 0200a40400 (resp 02 67 00 [29 5b])
384 // 0200a4040c07a0000002480300 (resp 02 67 00 [29 5b])
385 // 0200a4040c07a0000002480200 (resp 02 67 00 [29 5b])
386 // 0200a4040006a0000000010100 (resp 02 6a 82 [4b 4c])
387 // 0200a4040c09d27600002545500200 (resp 02 67 00 [29 5b])
388 // 0200a404000cd2760001354b414e4d30310000 (resp 02 6a 82 [4b 4c])
389 // 0200a404000ca000000063504b43532d313500 (resp 02 6a 82 [4b 4c])
390 // 0200a4040010a000000018300301000000000000000000 (resp 02 6a 82 [4b 4c])
391 //03 = ? (resp 03 [e3 c2])
392 //c2 = ? (resp c2 [66 15])
393 //b2 = ? (resp a3 [e9 67])
394 //a2 = ? (resp 02 [6a d3])
402 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
404 if (data
[0] != 0x50 || *datalen
!= 14 || !crc
) return rawClose();
406 PrintAndLog ("\n14443-3b tag found:");
407 PrintAndLog (" UID: %s", sprint_hex(data
+1,4));
414 // UID from data[1 - 4]
426 if (HF14BCmdRaw(true, &crc2
, true, cmd2
, &cmdLen
, false)==0) return rawClose();
428 if (cmdLen
!= 3 || !crc2
) return rawClose();
429 // add attrib responce to data
435 // 14b get and print Full Info (as much as we know)
436 int HF14BStdInfo(uint8_t *data
, uint8_t *datalen
){
437 if (!HF14BStdReader(data
,datalen
)) return 0;
440 print_atqb_resp(data
);
446 // SRx get and print general info about SRx chip from UID
447 int HF14B_ST_Reader(uint8_t *data
, uint8_t *datalen
, bool closeCon
){
455 // verbose on for now for testing - turn off when functional
456 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
458 if (*datalen
!= 3 || !crc
) return rawClose();
460 uint8_t chipID
= data
[0];
467 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
469 if (*datalen
!= 3 || !crc
|| data
[0] != chipID
) return rawClose();
476 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
478 if (*datalen
!= 10 || !crc
) return rawClose();
481 if (closeCon
) rawClose();
483 PrintAndLog("\n14443-3b ST tag found:");
484 print_st_general_info(data
);
488 // SRx get and print full info (needs more info...)
489 int HF14B_ST_Info(uint8_t *data
, uint8_t *datalen
){
490 if (!HF14B_ST_Reader(data
, datalen
, false)) return 0;
492 //add locking bit information here.
493 if (print_ST_Lock_info(data
[5]>>2))
499 // test for other 14b type tags (mimic another reader - don't have tags to identify)
500 int HF14B_Other_Reader(uint8_t *data
, uint8_t *datalen
){
509 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
510 if (*datalen
> 2 || !crc
) {
511 PrintAndLog ("\n14443-3b tag found:");
512 PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:");
513 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
523 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
525 PrintAndLog ("\n14443-3b tag found:");
526 PrintAndLog ("Unknown tag type answered to a 0x0A command ans:");
527 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
537 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
539 PrintAndLog ("\n14443-3b tag found:");
540 PrintAndLog ("Unknown tag type answered to a 0x0C command ans:");
541 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
550 // get and print all info known about any known 14b tag
551 int HF14BInfo(bool verbose
){
555 // try std 14b (atqb)
556 if (HF14BStdInfo(data
, &datalen
)) return 1;
559 if (HF14B_ST_Info(data
, &datalen
)) return 1;
561 // try unknown 14b read commands (to be identified later)
562 // could be read of calypso, CEPAS, moneo, or pico pass.
563 if (HF14B_Other_Reader(data
, &datalen
)) return 1;
565 if (verbose
) PrintAndLog("no 14443B tag found");
569 // menu command to get and print all info known about any known 14b tag
570 int CmdHF14Binfo(const char *Cmd
){
571 return HF14BInfo(true);
574 // get and print general info about all known 14b chips
575 int HF14BReader(bool verbose
){
579 // try std 14b (atqb)
580 if (HF14BStdReader(data
, &datalen
)) return 1;
583 if (HF14B_ST_Reader(data
, &datalen
, true)) return 1;
585 // try unknown 14b read commands (to be identified later)
586 // could be read of calypso, CEPAS, moneo, or pico pass.
587 if (HF14B_Other_Reader(data
, &datalen
)) return 1;
589 if (verbose
) PrintAndLog("no 14443B tag found");
593 // menu command to get and print general info about all known 14b chips
594 int CmdHF14BReader(const char *Cmd
){
595 return HF14BReader(true);
598 int CmdSriWrite( const char *Cmd
){
600 * For SRIX4K blocks 00 - 7F
601 * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
603 * For SR512 blocks 00 - 0F
604 * hf 14b raw -c -p 09 $sr512wblock $sr512wdata
606 * Special block FF = otp_lock_reg block.
609 char cmdp
= param_getchar(Cmd
, 0);
610 uint8_t blockno
= -1;
611 uint8_t data
[4] = {0x00};
612 bool isSrix4k
= true;
615 if (strlen(Cmd
) < 1 || cmdp
== 'h' || cmdp
== 'H') {
616 PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>");
617 PrintAndLog(" [1 = SRIX4K]");
618 PrintAndLog(" [2 = SRI512]");
619 PrintAndLog(" [BLOCK number depends on tag, special block == FF]");
620 PrintAndLog(" sample: hf 14b write 1 7F 11223344");
621 PrintAndLog(" : hf 14b write 1 FF 11223344");
622 PrintAndLog(" : hf 14b write 2 15 11223344");
623 PrintAndLog(" : hf 14b write 2 FF 11223344");
630 //blockno = param_get8(Cmd, 1);
632 if ( param_gethex(Cmd
,1, &blockno
, 2) ) {
633 PrintAndLog("Block number must include 2 HEX symbols");
638 if ( blockno
> 0x7f && blockno
!= 0xff ){
639 PrintAndLog("Block number out of range");
643 if ( blockno
> 0x0f && blockno
!= 0xff ){
644 PrintAndLog("Block number out of range");
649 if (param_gethex(Cmd
, 2, data
, 8)) {
650 PrintAndLog("Data must include 8 HEX symbols");
654 if ( blockno
== 0xff)
655 PrintAndLog("[%s] Write special block %02X [ %s ]", (isSrix4k
)?"SRIX4K":"SRI512" , blockno
, sprint_hex(data
,4) );
657 PrintAndLog("[%s] Write block %02X [ %s ]", (isSrix4k
)?"SRIX4K":"SRI512", blockno
, sprint_hex(data
,4) );
659 sprintf(str
, "-c 09 %02x %02x%02x%02x%02x", blockno
, data
[0], data
[1], data
[2], data
[3]);
665 static command_t CommandTable
[] =
667 {"help", CmdHelp
, 1, "This help"},
668 {"info", CmdHF14Binfo
, 0, "Find and print details about a 14443B tag"},
669 {"list", CmdHF14BList
, 0, "[Deprecated] List ISO 14443B history"},
670 {"reader", CmdHF14BReader
, 0, "Act as a 14443B reader to identify a tag"},
671 {"sim", CmdHF14BSim
, 0, "Fake ISO 14443B tag"},
672 {"snoop", CmdHF14BSnoop
, 0, "Eavesdrop ISO 14443B"},
673 {"sri512read", CmdSri512Read
, 0, "Read contents of a SRI512 tag"},
674 {"srix4kread", CmdSrix4kRead
, 0, "Read contents of a SRIX4K tag"},
675 {"sriwrite", CmdSriWrite
, 0, "Write data to a SRI512 | SRIX4K tag"},
676 {"raw", CmdHF14BCmdRaw
, 0, "Send raw hex data to tag"},
677 {NULL
, NULL
, 0, NULL
}
680 int CmdHF14B(const char *Cmd
)
682 CmdsParse(CommandTable
, Cmd
);
686 int CmdHelp(const char *Cmd
)
688 CmdsHelp(CommandTable
);