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}};
77 UsbCommand c
= {CMD_ISO_14443B_COMMAND
, {0, 0, 0}};
83 int HF14BCmdRaw(bool reply
, bool *crc
, bool power
, uint8_t *data
, uint8_t *datalen
, bool verbose
){
86 ComputeCrc14443(CRC_14443_B
, data
, *datalen
, data
+*datalen
, data
+*datalen
+1);
90 UsbCommand c
= {CMD_ISO_14443B_COMMAND
, {0, 0, 0}}; // len,recv,power
94 memcpy(c
.d
.asBytes
, data
, *datalen
);
101 if (!WaitForResponseTimeout(CMD_ACK
, &resp
, 2000)) {
102 if (verbose
) PrintAndLog("timeout while waiting for reply.");
106 *datalen
= resp
.arg
[0];
107 if ( *datalen
< 3 ) return 0;
109 memcpy(data
, resp
.d
.asBytes
, *datalen
);
111 uint8_t first
= 0, second
= 0;
112 ComputeCrc14443(CRC_14443_B
, data
, *datalen
-2, &first
, &second
);
113 *crc
= ( data
[*datalen
-2] == first
&& data
[*datalen
-1] == second
);
116 PrintAndLog("[LEN %u] %s[%02X %02X] %s",
118 sprint_hex(data
, *datalen
-2),
127 int CmdHF14BCmdRaw (const char *Cmd
) {
132 uint8_t data
[USB_CMD_DATA_SIZE
] = {0x00};
137 PrintAndLog("Usage: hf 14b raw [-r] [-c] [-p] <0A 0B 0C ... hex>");
138 PrintAndLog(" -r do not read response");
139 PrintAndLog(" -c calculate and append CRC");
140 PrintAndLog(" -p leave the field on after receive");
145 while (*Cmd
==' ' || *Cmd
=='\t') Cmd
++;
147 while (Cmd
[i
]!='\0') {
148 if (Cmd
[i
]==' ' || Cmd
[i
]=='\t') { i
++; continue; }
164 PrintAndLog("Invalid option");
170 if ((Cmd
[i
]>='0' && Cmd
[i
]<='9') ||
171 (Cmd
[i
]>='a' && Cmd
[i
]<='f') ||
172 (Cmd
[i
]>='A' && Cmd
[i
]<='F') ) {
173 buf
[strlen(buf
)+1]=0;
174 buf
[strlen(buf
)]=Cmd
[i
];
177 if (strlen(buf
)>=2) {
178 sscanf(buf
,"%x",&temp
);
179 data
[datalen
++]=(uint8_t)(temp
& 0xff);
184 PrintAndLog("Invalid char on input");
189 PrintAndLog("Missing data input");
193 return HF14BCmdRaw(reply
, &crc
, power
, data
, &datalen
, true);
196 // print full atqb info
197 static void print_atqb_resp(uint8_t *data
){
198 PrintAndLog (" UID: %s", sprint_hex(data
+1,4));
199 PrintAndLog (" App Data: %s", sprint_hex(data
+5,4));
200 PrintAndLog (" Protocol: %s", sprint_hex(data
+9,3));
201 uint8_t BitRate
= data
[9];
202 if (!BitRate
) PrintAndLog (" Bit Rate: 106 kbit/s only PICC <-> PCD");
203 if (BitRate
& 0x10) PrintAndLog (" Bit Rate: 212 kbit/s PICC -> PCD supported");
204 if (BitRate
& 0x20) PrintAndLog (" Bit Rate: 424 kbit/s PICC -> PCD supported");
205 if (BitRate
& 0x40) PrintAndLog (" Bit Rate: 847 kbit/s PICC -> PCD supported");
206 if (BitRate
& 0x01) PrintAndLog (" Bit Rate: 212 kbit/s PICC <- PCD supported");
207 if (BitRate
& 0x02) PrintAndLog (" Bit Rate: 424 kbit/s PICC <- PCD supported");
208 if (BitRate
& 0x04) PrintAndLog (" Bit Rate: 847 kbit/s PICC <- PCD supported");
209 if (BitRate
& 0x80) PrintAndLog (" Same bit rate <-> required");
211 uint16_t maxFrame
= data
[10]>>4;
212 if (maxFrame
< 5) maxFrame
= 8 * maxFrame
+ 16;
213 else if (maxFrame
== 5) maxFrame
= 64;
214 else if (maxFrame
== 6) maxFrame
= 96;
215 else if (maxFrame
== 7) maxFrame
= 128;
216 else if (maxFrame
== 8) maxFrame
= 256;
219 PrintAndLog ("Max Frame Size: %d%s", maxFrame
, (maxFrame
== 257) ? "+ RFU" : "");
221 uint8_t protocolT
= data
[10] & 0xF;
222 PrintAndLog (" Protocol Type: Protocol is %scompliant with ISO/IEC 14443-4",(protocolT
) ? "" : "not " );
223 PrintAndLog ("Frame Wait Int: %d", data
[11]>>4);
224 PrintAndLog (" App Data Code: Application is %s",(data
[11]&4) ? "Standard" : "Proprietary");
225 PrintAndLog (" Frame Options: NAD is %ssupported",(data
[11]&2) ? "" : "not ");
226 PrintAndLog (" Frame Options: CID is %ssupported",(data
[11]&1) ? "" : "not ");
231 // get SRx chip model (from UID) // from ST Microelectronics
232 char *get_ST_Chip_Model(uint8_t data
){
233 static char model
[20];
234 char *retStr
= model
;
235 memset(model
,0, sizeof(model
));
238 case 0x0: sprintf(retStr
, "SRIX4K (Special)"); break;
239 case 0x2: sprintf(retStr
, "SR176"); break;
240 case 0x3: sprintf(retStr
, "SRIX4K"); break;
241 case 0x4: sprintf(retStr
, "SRIX512"); break;
242 case 0x6: sprintf(retStr
, "SRI512"); break;
243 case 0x7: sprintf(retStr
, "SRI4K"); break;
244 case 0xC: sprintf(retStr
, "SRT512"); break;
245 default: sprintf(retStr
, "Unknown"); break;
250 // print UID info from SRx chips (ST Microelectronics)
251 static void print_st_general_info(uint8_t *data
){
252 //uid = first 8 bytes in data
253 PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data
,8,8),8));
254 PrintAndLog(" MFG: %02X, %s", data
[6], getTagInfo(data
[6]));
255 PrintAndLog("Chip: %02X, %s", data
[5]>>2, get_ST_Chip_Model(data
[5]>>2));
259 // 14b get and print UID only (general info)
260 int HF14BStdReader(uint8_t *data
, uint8_t *datalen
){
261 //05 00 00 = find one tag in field
262 //1d xx xx xx xx 20 00 08 01 00 = attrib xx=crc
263 //a3 = ? (resp 03 e2 c2)
264 //02 = ? (resp 02 6a d3)
265 // 022b (resp 02 67 00 [29 5b])
266 // 0200a40400 (resp 02 67 00 [29 5b])
267 // 0200a4040c07a0000002480300 (resp 02 67 00 [29 5b])
268 // 0200a4040c07a0000002480200 (resp 02 67 00 [29 5b])
269 // 0200a4040006a0000000010100 (resp 02 6a 82 [4b 4c])
270 // 0200a4040c09d27600002545500200 (resp 02 67 00 [29 5b])
271 // 0200a404000cd2760001354b414e4d30310000 (resp 02 6a 82 [4b 4c])
272 // 0200a404000ca000000063504b43532d313500 (resp 02 6a 82 [4b 4c])
273 // 0200a4040010a000000018300301000000000000000000 (resp 02 6a 82 [4b 4c])
274 //03 = ? (resp 03 [e3 c2])
275 //c2 = ? (resp c2 [66 15])
276 //b2 = ? (resp a3 [e9 67])
284 // response, crc, powerfield, data, len, verbose
285 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return 0;
287 if (data
[0] != 0x50 || *datalen
!= 14 || !crc
) return 0;
289 PrintAndLog ("\n14443-3b tag found:");
290 PrintAndLog (" UID: %s", sprint_hex(data
+1,4));
295 // 14b get and print Full Info (as much as we know)
296 int HF14BStdInfo(uint8_t *data
, uint8_t *datalen
){
297 if (!HF14BStdReader(data
,datalen
)) return 0;
300 print_atqb_resp(data
);
305 // SRx get and print general info about SRx chip from UID
306 int HF14B_ST_Reader(uint8_t *data
, uint8_t *datalen
){
314 // verbose on for now for testing - turn off when functional
315 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
317 if (*datalen
!= 3 || !crc
) return rawClose();
319 uint8_t chipID
= data
[0];
326 // verbose on for now for testing - turn off when functional
327 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return rawClose();
329 if (*datalen
!= 3 || !crc
|| data
[0] != chipID
) return rawClose();
336 // verbose on for now for testing - turn off when functional
337 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)==0) return 0;
339 if (*datalen
!= 10 || !crc
) return 0;
341 PrintAndLog("\n14443-3b ST tag found:");
342 print_st_general_info(data
);
346 // SRx get and print full info (needs more info...)
347 int HF14B_ST_Info(uint8_t *data
, uint8_t *datalen
){
348 if (!HF14B_ST_Reader(data
, datalen
)) return 0;
350 //add locking bit information here.
356 // test for other 14b type tags (mimic another reader - don't have tags to identify)
357 int HF14B_Other_Reader(uint8_t *data
, uint8_t *datalen
){
366 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
367 if (*datalen
> 2 || !crc
) {
368 PrintAndLog ("\n14443-3b tag found:");
369 PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:");
370 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
379 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
381 PrintAndLog ("\n14443-3b tag found:");
382 PrintAndLog ("Unknown tag type answered to a 0x0A command ans:");
383 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
392 if (HF14BCmdRaw(true, &crc
, true, data
, datalen
, false)!=0) {
394 PrintAndLog ("\n14443-3b tag found:");
395 PrintAndLog ("Unknown tag type answered to a 0x0C command ans:");
396 PrintAndLog ("%s",sprint_hex(data
,*datalen
));
404 // get and print all info known about any known 14b tag
405 int HF14BInfo(bool verbose
){
406 uint8_t data
[USB_CMD_DATA_SIZE
];
409 // try std 14b (atqb)
410 if (HF14BStdInfo(data
, &datalen
)) return 1;
413 if (HF14B_ST_Info(data
, &datalen
)) return 1;
415 // try unknown 14b read commands (to be identified later)
416 // could be read of calypso, CEPAS, moneo, or pico pass.
417 if (HF14B_Other_Reader(data
, &datalen
)) return 1;
419 if (verbose
) PrintAndLog("no 14443B tag found");
423 // menu command to get and print all info known about any known 14b tag
424 int CmdHF14Binfo(const char *Cmd
){
425 return HF14BInfo(true);
428 // get and print general info about all known 14b chips
429 int HF14BReader(bool verbose
){
430 uint8_t data
[USB_CMD_DATA_SIZE
];
433 // try std 14b (atqb)
434 if (HF14BStdReader(data
, &datalen
)) return 1;
437 if (HF14B_ST_Reader(data
, &datalen
)) return 1;
439 // try unknown 14b read commands (to be identified later)
440 // could be read of calypso, CEPAS, moneo, or pico pass.
441 if (HF14B_Other_Reader(data
, &datalen
)) return 1;
443 if (verbose
) PrintAndLog("no 14443B tag found");
447 // menu command to get and print general info about all known 14b chips
448 int CmdHF14BReader(const char *Cmd
){
449 return HF14BReader(true);
452 int CmdSriWrite( const char *Cmd
){
454 * For SRIX4K blocks 00 - 7F
455 * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
457 * For SR512 blocks 00 - 0F
458 * hf 14b raw -c -p 09 $sr512wblock $sr512wdata
460 * Special block FF = otp_lock_reg block.
463 char cmdp
= param_getchar(Cmd
, 0);
464 uint8_t blockno
= -1;
465 uint8_t data
[4] = {0x00};
466 bool isSrix4k
= true;
469 if (strlen(Cmd
) < 1 || cmdp
== 'h' || cmdp
== 'H') {
470 PrintAndLog("Usage: hf 14b write <1|2> <BLOCK> <DATA>");
471 PrintAndLog(" [1 = SRIX4K]");
472 PrintAndLog(" [2 = SRI512]");
473 PrintAndLog(" [BLOCK number depends on tag, special block == FF]");
474 PrintAndLog(" sample: hf 14b write 1 7F 11223344");
475 PrintAndLog(" : hf 14b write 1 FF 11223344");
476 PrintAndLog(" : hf 14b write 2 15 11223344");
477 PrintAndLog(" : hf 14b write 2 FF 11223344");
484 //blockno = param_get8(Cmd, 1);
486 if ( param_gethex(Cmd
,1, &blockno
, 2) ) {
487 PrintAndLog("Block number must include 2 HEX symbols");
492 if ( blockno
> 0x7f && blockno
!= 0xff ){
493 PrintAndLog("Block number out of range");
497 if ( blockno
> 0x0f && blockno
!= 0xff ){
498 PrintAndLog("Block number out of range");
503 if (param_gethex(Cmd
, 2, data
, 8)) {
504 PrintAndLog("Data must include 8 HEX symbols");
508 if ( blockno
== 0xff)
509 PrintAndLog("[%s] Write special block %02X [ %s ]", (isSrix4k
)?"SRIX4K":"SRI512" , blockno
, sprint_hex(data
,4) );
511 PrintAndLog("[%s] Write block %02X [ %s ]", (isSrix4k
)?"SRIX4K":"SRI512", blockno
, sprint_hex(data
,4) );
513 sprintf(str
, "-c 09 %02x %02x%02x%02x%02x", blockno
, data
[0], data
[1], data
[2], data
[3]);
519 static command_t CommandTable
[] =
521 {"help", CmdHelp
, 1, "This help"},
522 {"info", CmdHF14Binfo
, 0, "Find and print details about a 14443B tag"},
523 {"list", CmdHF14BList
, 0, "[Deprecated] List ISO 14443B history"},
524 {"reader", CmdHF14BReader
, 0, "Act as a 14443B reader to identify a tag"},
525 {"sim", CmdHF14BSim
, 0, "Fake ISO 14443B tag"},
526 {"snoop", CmdHF14BSnoop
, 0, "Eavesdrop ISO 14443B"},
527 {"sri512read", CmdSri512Read
, 0, "Read contents of a SRI512 tag"},
528 {"srix4kread", CmdSrix4kRead
, 0, "Read contents of a SRIX4K tag"},
529 {"sriwrite", CmdSriWrite
, 0, "Write data to a SRI512 | SRIX4K tag"},
530 {"raw", CmdHF14BCmdRaw
, 0, "Send raw hex data to tag"},
531 {NULL
, NULL
, 0, NULL
}
534 int CmdHF14B(const char *Cmd
)
536 CmdsParse(CommandTable
, Cmd
);
540 int CmdHelp(const char *Cmd
)
542 CmdsHelp(CommandTable
);