]> cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmdhflegic.c
projects / proxmark3-svn / blob
? search:


08e283b5b26d12a598833a72ff1c7092c4cde2a9
[proxmark3-svn] / client / cmdhflegic.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
3 //
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
6 // the license.
7 //-----------------------------------------------------------------------------
8 // High frequency Legic commands
9 //-----------------------------------------------------------------------------
10 #include "cmdhflegic.h"
11
12 static int CmdHelp(const char *Cmd);
13
14 #define MAX_LENGTH 1024
15
16 int usage_legic_calccrc(void){
17 PrintAndLog("Calculates the legic crc8/crc16 on the given data.");
18 PrintAndLog("There must be an even number of hexsymbols as input.");
19 PrintAndLog("Usage: hf legic crc [h] d <data> u <uidcrc> c <8|16>");
20 PrintAndLog("Options:");
21 PrintAndLog(" h : this help");
22 PrintAndLog(" d <data> : (hex symbols) bytes to calculate crc over");
23 PrintAndLog(" u <uidcrc> : MCC hexbyte");
24 PrintAndLog(" c <8|16> : Crc type");
25 PrintAndLog("");
26 PrintAndLog("Samples:");
27 PrintAndLog(" hf legic crc b deadbeef1122");
28 PrintAndLog(" hf legic crc b deadbeef1122 u 9A c 16");
29 return 0;
30 }
31 int usage_legic_rdmem(void){
32 PrintAndLog("Read data from a legic tag.");
33 PrintAndLog("Usage: hf legic rdmem [h] <offset> <length> <IV>");
34 PrintAndLog("Options:");
35 PrintAndLog(" h : this help");
36 PrintAndLog(" <offset> : (hex) offset in data array to start download from");
37 PrintAndLog(" <length> : (hex) number of bytes to read");
38 PrintAndLog(" <IV> : (hex) (optional) Initialization vector to use. Must be odd and 7bits max");
39 PrintAndLog("");
40 PrintAndLog("Samples:");
41 PrintAndLog(" hf legic rdmem 0 16 - reads from byte[0] 0x16 bytes(system header)");
42 PrintAndLog(" hf legic rdmem 0 4 55 - reads from byte[0] 0x4 bytes with IV 0x55");
43 PrintAndLog(" hf legic rdmem 0 100 55 - reads 0x100 bytes with IV 0x55");
44 return 0;
45 }
46 int usage_legic_sim(void){
47 PrintAndLog("Simulates a LEGIC Prime tag. MIM22, MIM256, MIM1024 types can be emulated");
48 PrintAndLog("Use eload/esave to upload a dump into emulator memory");
49 PrintAndLog("Usage: hf legic sim [h] <tagtype> <phase> <frame> <reqresp>");
50 PrintAndLog("Options:");
51 PrintAndLog(" h : this help");
52 PrintAndLog(" <tagtype> : 0 = MIM22");
53 PrintAndLog(" : 1 = MIM256 (default)");
54 PrintAndLog(" : 2 = MIM1024");
55 PrintAndLog(" <phase> : phase drift");
56 PrintAndLog(" <frame> : frame drift");
57 PrintAndLog(" <reqresp> : reqresp drift");
58 PrintAndLog("");
59 PrintAndLog("Samples:");
60 PrintAndLog(" hf legic sim");
61 PrintAndLog(" hf legic sim ");
62 return 0;
63 }
64 int usage_legic_write(void){
65 PrintAndLog("Write data to a LEGIC Prime tag. It autodetects tagsize to make sure size");
66 PrintAndLog("Usage: hf legic write [h] o <offset> d <data (hex symbols)>");
67 PrintAndLog("Options:");
68 PrintAndLog(" h : this help");
69 PrintAndLog(" o <offset> : (hex) offset in data array to start writing");
70 //PrintAndLog(" <IV> : (optional) Initialization vector to use (ODD and 7bits)");
71 PrintAndLog(" d <data> : (hex symbols) bytes to write ");
72 PrintAndLog("");
73 PrintAndLog("Samples:");
74 PrintAndLog(" hf legic write o 10 d 11223344 - Write 0x11223344 starting from offset 0x10");
75 return 0;
76 }
77 int usage_legic_reader(void){
78 PrintAndLog("Read UID and type information from a legic tag.");
79 PrintAndLog("Usage: hf legic reader [h]");
80 PrintAndLog("Options:");
81 PrintAndLog(" h : this help");
82 PrintAndLog("");
83 PrintAndLog("Samples:");
84 PrintAndLog(" hf legic reader");
85 return 0;
86 }
87 int usage_legic_info(void){
88 PrintAndLog("Reads information from a legic prime tag.");
89 PrintAndLog("Shows systemarea, user areas etc");
90 PrintAndLog("Usage: hf legic info [h]");
91 PrintAndLog("Options:");
92 PrintAndLog(" h : this help");
93 PrintAndLog("");
94 PrintAndLog("Samples:");
95 PrintAndLog(" hf legic info");
96 return 0;
97 }
98 int usage_legic_dump(void){
99 PrintAndLog("Reads all pages from LEGIC Prime MIM22, MIM256, MIM1024");
100 PrintAndLog("and saves binary dump into the file `filename.bin` or `cardUID.bin`");
101 PrintAndLog("It autodetects card type.\n");
102 PrintAndLog("Usage: hf legic dump [h] o <filename w/o .bin>");
103 PrintAndLog("Options:");
104 PrintAndLog(" h : this help");
105 PrintAndLog(" o <filename> : filename w/o '.bin' to dump bytes");
106 PrintAndLog("");
107 PrintAndLog("Samples:");
108 PrintAndLog(" hf legic dump");
109 PrintAndLog(" hf legic dump o myfile");
110 return 0;
111 }
112 int usage_legic_restore(void){
113 PrintAndLog("Reads binary file and it autodetects card type and verifies that the file has the same size");
114 PrintAndLog("Then write the data back to card. All bytes except the first 7bytes [UID(4) MCC(1) DCF(2)]\n");
115 PrintAndLog("Usage: hf legic restore [h] i <filename w/o .bin>");
116 PrintAndLog("Options:");
117 PrintAndLog(" h : this help");
118 PrintAndLog(" i <filename> : filename w/o '.bin' to restore bytes on to card from");
119 PrintAndLog("");
120 PrintAndLog("Samples:");
121 PrintAndLog(" hf legic restore i myfile");
122 return 0;
123 }
124 int usage_legic_eload(void){
125 PrintAndLog("It loads binary dump from the file `filename.bin`");
126 PrintAndLog("Usage: hf legic eload [h] [card memory] <file name w/o `.bin`>");
127 PrintAndLog("Options:");
128 PrintAndLog(" h : this help");
129 PrintAndLog(" [card memory] : 0 = MIM22");
130 PrintAndLog(" : 1 = MIM256 (default)");
131 PrintAndLog(" : 2 = MIM1024");
132 PrintAndLog(" <filename> : filename w/o .bin to load");
133 PrintAndLog("");
134 PrintAndLog("Samples:");
135 PrintAndLog(" hf legic eload 2 myfile");
136 return 0;
137 }
138 int usage_legic_esave(void){
139 PrintAndLog("It saves binary dump into the file `filename.bin` or `cardID.bin`");
140 PrintAndLog(" Usage: hf legic esave [h] [card memory] [file name w/o `.bin`]");
141 PrintAndLog("Options:");
142 PrintAndLog(" h : this help");
143 PrintAndLog(" [card memory] : 0 = MIM22");
144 PrintAndLog(" : 1 = MIM256 (default)");
145 PrintAndLog(" : 2 = MIM1024");
146 PrintAndLog(" <filename> : filename w/o .bin to load");
147 PrintAndLog("");
148 PrintAndLog("Samples:");
149 PrintAndLog(" hf legic esave 2 myfile");
150 return 0;
151 }
152
153 /*
154 * Output BigBuf and deobfuscate LEGIC RF tag data.
155 * This is based on information given in the talk held
156 * by Henryk Ploetz and Karsten Nohl at 26c3
157 */
158 int CmdLegicInfo(const char *Cmd) {
159
160 char cmdp = param_getchar(Cmd, 0);
161 if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_info();
162
163 int i = 0, k = 0, segmentNum = 0, segment_len = 0, segment_flag = 0;
164 int crc = 0, wrp = 0, wrc = 0;
165 uint8_t stamp_len = 0;
166 uint8_t data[1024]; // receiver buffer
167 char token_type[5] = {0,0,0,0,0};
168 int dcf = 0;
169 int bIsSegmented = 0;
170
171 CmdLegicRdmem("0 22 55");
172
173 // copy data from device
174 GetEMLFromBigBuf(data, sizeof(data), 0);
175 if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
176 PrintAndLog("Command execute timeout");
177 return 1;
178 }
179
180 // Output CDF System area (9 bytes) plus remaining header area (12 bytes)
181 crc = data[4];
182 uint32_t calc_crc = CRC8Legic(data, 4);
183
184 PrintAndLog("\nCDF: System Area");
185 PrintAndLog("------------------------------------------------------");
186 PrintAndLog("MCD: %02x, MSN: %02x %02x %02x, MCC: %02x %s",
187 data[0],
188 data[1],
189 data[2],
190 data[3],
191 data[4],
192 (calc_crc == crc) ? "OK":"Fail"
193 );
194
195 // MCD = Manufacturer ID (should be list meaning something?)
196
197 token_type[0] = 0;
198 dcf = ((int)data[6] << 8) | (int)data[5];
199
200 // New unwritten media?
201 if(dcf == 0xFFFF) {
202
203 PrintAndLog("DCF: %d (%02x %02x), Token Type=NM (New Media)",
204 dcf,
205 data[5],
206 data[6]
207 );
208
209 } else if (dcf > 60000) { // Master token?
210
211 int fl = 0;
212
213 if(data[6] == 0xec) {
214 strncpy(token_type, "XAM", sizeof(token_type));
215 fl = 1;
216 stamp_len = 0x0c - (data[5] >> 4);
217 } else {
218 switch (data[5] & 0x7f) {
219 case 0x00 ... 0x2f:
220 strncpy(token_type, "IAM", sizeof(token_type));
221 fl = (0x2f - (data[5] & 0x7f)) + 1;
222 break;
223 case 0x30 ... 0x6f:
224 strncpy(token_type, "SAM", sizeof(token_type));
225 fl = (0x6f - (data[5] & 0x7f)) + 1;
226 break;
227 case 0x70 ... 0x7f:
228 strncpy(token_type, "GAM", sizeof(token_type));
229 fl = (0x7f - (data[5] & 0x7f)) + 1;
230 break;
231 }
232
233 stamp_len = 0xfc - data[6];
234 }
235
236 PrintAndLog("DCF: %d (%02x %02x), Token Type=%s (OLE=%01u), OL=%02u, FL=%02u",
237 dcf,
238 data[5],
239 data[6],
240 token_type,
241 (data[5] & 0x80 )>> 7,
242 stamp_len,
243 fl
244 );
245
246 } else { // Is IM(-S) type of card...
247
248 if(data[7] == 0x9F && data[8] == 0xFF) {
249 bIsSegmented = 1;
250 strncpy(token_type, "IM-S", sizeof(token_type));
251 } else {
252 strncpy(token_type, "IM", sizeof(token_type));
253 }
254
255 PrintAndLog("DCF: %d (%02x %02x), Token Type=%s (OLE=%01u)",
256 dcf,
257 data[5],
258 data[6],
259 token_type,
260 (data[5]&0x80) >> 7
261 );
262 }
263
264 // Makes no sence to show this on blank media...
265 if(dcf != 0xFFFF) {
266
267 if(bIsSegmented) {
268 PrintAndLog("WRP=%02u, WRC=%01u, RD=%01u, SSC=%02x",
269 data[7] & 0x0f,
270 (data[7] & 0x70) >> 4,
271 (data[7] & 0x80) >> 7,
272 data[8]
273 );
274 }
275
276 // Header area is only available on IM-S cards, on master tokens this data is the master token data itself
277 if(bIsSegmented || dcf > 60000) {
278 if(dcf > 60000) {
279 PrintAndLog("Master token data");
280 PrintAndLog("%s", sprint_hex(data+8, 14));
281 } else {
282 PrintAndLog("Remaining Header Area");
283 PrintAndLog("%s", sprint_hex(data+9, 13));
284 }
285 }
286 }
287
288 uint8_t segCrcBytes[8] = {0,0,0,0,0,0,0,0};
289 uint32_t segCalcCRC = 0;
290 uint32_t segCRC = 0;
291
292 // Data card?
293 if(dcf <= 60000) {
294
295 PrintAndLog("\nADF: User Area");
296 PrintAndLog("------------------------------------------------------");
297
298 if(bIsSegmented) {
299
300 // Data start point on segmented cards
301 i = 22;
302
303 // decode segments
304 for (segmentNum=1; segmentNum < 128; segmentNum++ )
305 {
306 segment_len = ((data[i+1] ^ crc) & 0x0f) * 256 + (data[i] ^ crc);
307 segment_flag = ((data[i+1] ^ crc) & 0xf0) >> 4;
308 wrp = (data[i+2] ^ crc);
309 wrc = ((data[i+3] ^ crc) & 0x70) >> 4;
310
311 bool hasWRC = (wrc > 0);
312 bool hasWRP = (wrp > wrc);
313 int wrp_len = (wrp - wrc);
314 int remain_seg_payload_len = (segment_len - wrp - 5);
315
316 // validate segment-crc
317 segCrcBytes[0]=data[0]; //uid0
318 segCrcBytes[1]=data[1]; //uid1
319 segCrcBytes[2]=data[2]; //uid2
320 segCrcBytes[3]=data[3]; //uid3
321 segCrcBytes[4]=(data[i] ^ crc); //hdr0
322 segCrcBytes[5]=(data[i+1] ^ crc); //hdr1
323 segCrcBytes[6]=(data[i+2] ^ crc); //hdr2
324 segCrcBytes[7]=(data[i+3] ^ crc); //hdr3
325
326 segCalcCRC = CRC8Legic(segCrcBytes, 8);
327 segCRC = data[i+4] ^ crc;
328
329 PrintAndLog("Segment %02u \nraw header | 0x%02X 0x%02X 0x%02X 0x%02X \nSegment len: %u, Flag: 0x%X (valid:%01u, last:%01u), WRP: %02u, WRC: %02u, RD: %01u, CRC: 0x%02X (%s)",
330 segmentNum,
331 data[i] ^ crc,
332 data[i+1] ^ crc,
333 data[i+2] ^ crc,
334 data[i+3] ^ crc,
335 segment_len,
336 segment_flag,
337 (segment_flag & 0x4) >> 2,
338 (segment_flag & 0x8) >> 3,
339 wrp,
340 wrc,
341 ((data[i+3]^crc) & 0x80) >> 7,
342 segCRC,
343 ( segCRC == segCalcCRC ) ? "OK" : "fail"
344 );
345
346 i += 5;
347
348 if ( hasWRC ) {
349 PrintAndLog("WRC protected area: (I %d | K %d| WRC %d)", i, k, wrc);
350 PrintAndLog("\nrow | data");
351 PrintAndLog("-----+------------------------------------------------");
352
353 for ( k=i; k < (i + wrc); ++k)
354 data[k] ^= crc;
355
356 print_hex_break( data+i, wrc, 16);
357
358 i += wrc;
359 }
360
361 if ( hasWRP ) {
362 PrintAndLog("Remaining write protected area: (I %d | K %d | WRC %d | WRP %d WRP_LEN %d)",i, k, wrc, wrp, wrp_len);
363 PrintAndLog("\nrow | data");
364 PrintAndLog("-----+------------------------------------------------");
365
366 for (k=i; k < (i+wrp_len); ++k)
367 data[k] ^= crc;
368
369 print_hex_break( data+i, wrp_len, 16);
370
371 i += wrp_len;
372
373 // does this one work? (Answer: Only if KGH/BGH is used with BCD encoded card number! So maybe this will show just garbage...)
374 if( wrp_len == 8 )
375 PrintAndLog("Card ID: %2X%02X%02X", data[i-4]^crc, data[i-3]^crc, data[i-2]^crc);
376 }
377
378 PrintAndLog("Remaining segment payload: (I %d | K %d | Remain LEN %d)", i, k, remain_seg_payload_len);
379 PrintAndLog("\nrow | data");
380 PrintAndLog("-----+------------------------------------------------");
381
382 for ( k=i; k < (i+remain_seg_payload_len); ++k)
383 data[k] ^= crc;
384
385 print_hex_break( data+i, remain_seg_payload_len, 16);
386
387 i += remain_seg_payload_len;
388
389 PrintAndLog("-----+------------------------------------------------\n");
390
391 // end with last segment
392 if (segment_flag & 0x8) return 0;
393
394 } // end for loop
395
396 } else {
397
398 // Data start point on unsegmented cards
399 i = 8;
400
401 wrp = data[7] & 0x0F;
402 wrc = (data[7] & 0x70) >> 4;
403
404 bool hasWRC = (wrc > 0);
405 bool hasWRP = (wrp > wrc);
406 int wrp_len = (wrp - wrc);
407 int remain_seg_payload_len = (1024 - 22 - wrp); // Any chance to get physical card size here!?
408
409 PrintAndLog("Unsegmented card - WRP: %02u, WRC: %02u, RD: %01u",
410 wrp,
411 wrc,
412 (data[7] & 0x80) >> 7
413 );
414
415 if ( hasWRC ) {
416 PrintAndLog("WRC protected area: (I %d | WRC %d)", i, wrc);
417 PrintAndLog("\nrow | data");
418 PrintAndLog("-----+------------------------------------------------");
419 print_hex_break( data+i, wrc, 16);
420 i += wrc;
421 }
422
423 if ( hasWRP ) {
424 PrintAndLog("Remaining write protected area: (I %d | WRC %d | WRP %d | WRP_LEN %d)", i, wrc, wrp, wrp_len);
425 PrintAndLog("\nrow | data");
426 PrintAndLog("-----+------------------------------------------------");
427 print_hex_break( data + i, wrp_len, 16);
428 i += wrp_len;
429
430 // does this one work? (Answer: Only if KGH/BGH is used with BCD encoded card number! So maybe this will show just garbage...)
431 if( wrp_len == 8 )
432 PrintAndLog("Card ID: %2X%02X%02X", data[i-4], data[i-3], data[i-2]);
433 }
434
435 PrintAndLog("Remaining segment payload: (I %d | Remain LEN %d)", i, remain_seg_payload_len);
436 PrintAndLog("\nrow | data");
437 PrintAndLog("-----+------------------------------------------------");
438 print_hex_break( data + i, remain_seg_payload_len, 16);
439 i += remain_seg_payload_len;
440
441 PrintAndLog("-----+------------------------------------------------\n");
442 }
443 }
444 return 0;
445 }
446
447 // params:
448 // offset in data memory
449 // number of bytes to read
450 int CmdLegicRdmem(const char *Cmd) {
451
452 char cmdp = param_getchar(Cmd, 0);
453 if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_rdmem();
454
455 uint32_t offset = 0, len = 0, IV = 1;
456 sscanf(Cmd, "%x %x %x", &offset, &len, &IV);
457
458 // tagtype
459 legic_card_select_t card;
460 if (legic_get_type(&card)) {
461 PrintAndLog("Failed to identify tagtype");
462 return 1;
463 }
464
465 legic_print_type(card.cardsize, 0);
466
467 // OUT-OF-BOUNDS check
468 // UID 4 bytes can't be written to.
469 if ( len + offset >= card.cardsize ) {
470 len = card.cardsize - offset;
471 PrintAndLog("Out-of-bounds, Cardsize = %d, Trunc offset+len = %d", card.cardsize, len + offset);
472 }
473
474 legic_chk_iv(&IV);
475
476 UsbCommand c = {CMD_READER_LEGIC_RF, {offset, len, IV}};
477 clearCommandBuffer();
478 SendCommand(&c);
479 UsbCommand resp;
480 if ( !WaitForResponseTimeout(CMD_ACK, &resp, 3000) ) {
481 PrintAndLog("command execution time out");
482 return 1;
483 }
484
485 uint8_t isOK = resp.arg[0] & 0xFF;
486 uint16_t readlen = resp.arg[1];
487 if ( !isOK ) {
488 PrintAndLog("failed reading tag");
489 return 2;
490 }
491
492 uint8_t *data = malloc(readlen);
493 if ( !data ){
494 PrintAndLog("Cannot allocate memory");
495 return 2;
496 }
497
498 if ( readlen != len )
499 PrintAndLog("Fail, only managed to read 0x%02X bytes", readlen);
500
501 // copy data from device
502 GetEMLFromBigBuf(data, readlen, 0);
503 if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)){
504 PrintAndLog("Command execute timeout");
505 free(data);
506 return 1;
507 }
508
509 PrintAndLog("\n ## | Data");
510 PrintAndLog("-----+-----");
511 print_hex_break( data, readlen, 32);
512 free(data);
513 return 0;
514 }
515
516 // should say which tagtype
517 // should load a tag to device mem.
518 // int phase, int frame, int reqresp
519 int CmdLegicRfSim(const char *Cmd) {
520 UsbCommand c = {CMD_SIMULATE_TAG_LEGIC_RF, {6,3,0}};
521 sscanf(Cmd, " %"lli" %"lli" %"lli, &c.arg[0], &c.arg[1], &c.arg[2]);
522 clearCommandBuffer();
523 SendCommand(&c);
524 return 0;
525 }
526
527 int CmdLegicRfWrite(const char *Cmd) {
528
529 uint8_t *data = NULL;
530 uint8_t cmdp = 0;
531 bool errors = false;
532 int len = 0, bg, en;
533 uint32_t offset = 0, IV = 0x55;
534
535 while(param_getchar(Cmd, cmdp) != 0x00) {
536 switch(param_getchar(Cmd, cmdp)) {
537 case 'd':
538 case 'D':
539 // peek at length of the input string so we can
540 // figure out how many elements to malloc in "data"
541 bg=en=0;
542 if (param_getptr(Cmd, &bg, &en, cmdp+1)) {
543 errors = true;
544 break;
545 }
546 len = (en - bg + 1);
547
548 // check that user entered even number of characters
549 // for hex data string
550 if (len & 1) {
551 errors = true;
552 break;
553 }
554
555 // it's possible for user to accidentally enter "b" parameter
556 // more than once - we have to clean previous malloc
557 if (data)
558 free(data);
559 data = malloc(len >> 1);
560 if ( data == NULL ) {
561 PrintAndLog("Can't allocate memory. exiting");
562 errors = true;
563 break;
564 }
565
566 if (param_gethex(Cmd, cmdp+1, data, len)) {
567 errors = true;
568 break;
569 }
570
571 len >>= 1;
572 cmdp += 2;
573 break;
574 case 'o':
575 case 'O':
576 offset = param_get32ex(Cmd, cmdp+1, 4, 16);
577 cmdp += 2;
578 break;
579 case 'h':
580 case 'H':
581 errors = true;
582 break;
583 default:
584 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
585 errors = true;
586 break;
587 }
588 if (errors) break;
589 }
590 //Validations
591 if (errors){
592 if (data)
593 free(data);
594 return usage_legic_write();
595 }
596
597 // tagtype
598 legic_card_select_t card;
599 if (legic_get_type(&card)) {
600 PrintAndLog("Failed to identify tagtype");
601 return -1;
602 }
603
604 legic_print_type(card.cardsize, 0);
605
606 // OUT-OF-BOUNDS checks
607 // UID 4 bytes can't be written to.
608 if ( offset < 4 ) {
609 PrintAndLog("Out-of-bounds, UID 4bytes can't be written to. Offset = %d", offset);
610 return -2;
611 }
612
613 if ( len + offset + 4 >= card.cardsize ) {
614 PrintAndLog("Out-of-bounds, Cardsize = %d, [offset+len = %d ]", card.cardsize, len + offset + 4);
615 return -2;
616 }
617
618 legic_chk_iv(&IV);
619
620 PrintAndLog("Writing to tag");
621 UsbCommand c = {CMD_WRITER_LEGIC_RF, {offset, len, IV}};
622 memcpy(c.d.asBytes, data, len);
623
624 clearCommandBuffer();
625 SendCommand(&c);
626 UsbCommand resp;
627 if (!WaitForResponseTimeout(CMD_ACK, &resp, 4000)) {
628 PrintAndLog("command execution time out");
629 return 1;
630 }
631 uint8_t isOK = resp.arg[0] & 0xFF;
632 if ( !isOK ) {
633 PrintAndLog("failed writing tag");
634 return 1;
635 }
636
637 return 0;
638 }
639
640 /*
641 PrintAndLog("############# DANGER !! #############");
642 PrintAndLog("# changing the DCF is irreversible #");
643 PrintAndLog("#####################################");
644 PrintAndLog("do youe really want to continue? y(es) n(o)");
645 // if (scanf(" %c", &answer) > 0 && (answer == 'y' || answer == 'Y')) {
646 // return 0;
647 // }
648 */
649
650 int CmdLegicCalcCrc(const char *Cmd){
651
652 uint8_t *data = NULL;
653 uint8_t cmdp = 0, uidcrc = 0, type=0;
654 bool errors = false;
655 int len = 0;
656 int bg, en;
657
658 while(param_getchar(Cmd, cmdp) != 0x00) {
659 switch(param_getchar(Cmd, cmdp)) {
660 case 'b':
661 case 'B':
662 // peek at length of the input string so we can
663 // figure out how many elements to malloc in "data"
664 bg=en=0;
665 if (param_getptr(Cmd, &bg, &en, cmdp+1)) {
666 errors = true;
667 break;
668 }
669 len = (en - bg + 1);
670
671 // check that user entered even number of characters
672 // for hex data string
673 if (len & 1) {
674 errors = true;
675 break;
676 }
677
678 // it's possible for user to accidentally enter "b" parameter
679 // more than once - we have to clean previous malloc
680 if (data) free(data);
681 data = malloc(len >> 1);
682 if ( data == NULL ) {
683 PrintAndLog("Can't allocate memory. exiting");
684 errors = true;
685 break;
686 }
687
688 if (param_gethex(Cmd, cmdp+1, data, len)) {
689 errors = true;
690 break;
691 }
692
693 len >>= 1;
694 cmdp += 2;
695 break;
696 case 'u':
697 case 'U':
698 uidcrc = param_get8ex(Cmd, cmdp+1, 0, 16);
699 cmdp += 2;
700 break;
701 case 'c':
702 case 'C':
703 type = param_get8ex(Cmd, cmdp+1, 0, 10);
704 cmdp += 2;
705 break;
706 case 'h':
707 case 'H':
708 errors = true;
709 break;
710 default:
711 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
712 errors = true;
713 break;
714 }
715 if (errors) break;
716 }
717 //Validations
718 if (errors){
719 if (data) free(data);
720 return usage_legic_calccrc();
721 }
722
723 switch (type){
724 case 16:
725 PrintAndLog("Legic crc16: %X", CRC16Legic(data, len, uidcrc));
726 break;
727 default:
728 PrintAndLog("Legic crc8: %X", CRC8Legic(data, len) );
729 break;
730 }
731
732 if (data) free(data);
733 return 0;
734 }
735
736 int legic_print_type(uint32_t tagtype, uint8_t spaces){
737 char spc[11] = " ";
738 spc[10]=0x00;
739 char *spacer = spc + (10-spaces);
740
741 if ( tagtype == 22 )
742 PrintAndLog("%sTYPE : MIM%d card (outdated)", spacer, tagtype);
743 else if ( tagtype == 256 )
744 PrintAndLog("%sTYPE : MIM%d card (234 bytes)", spacer, tagtype);
745 else if ( tagtype == 1024 )
746 PrintAndLog("%sTYPE : MIM%d card (1002 bytes)", spacer, tagtype);
747 else
748 PrintAndLog("%sTYPE : Unknown %06x", spacer, tagtype);
749 return 0;
750 }
751 int legic_get_type(legic_card_select_t *card){
752
753 if ( card == NULL ) return 1;
754
755 UsbCommand c = {CMD_LEGIC_INFO, {0,0,0}};
756 clearCommandBuffer();
757 SendCommand(&c);
758 UsbCommand resp;
759 if (!WaitForResponseTimeout(CMD_ACK, &resp, 500))
760 return 2;
761
762 uint8_t isOK = resp.arg[0] & 0xFF;
763 if ( !isOK )
764 return 3;
765
766 memcpy(card, (legic_card_select_t *)resp.d.asBytes, sizeof(legic_card_select_t));
767 return 0;
768 }
769 void legic_chk_iv(uint32_t *iv){
770 if ( (*iv & 0x7F) != *iv ){
771 *iv &= 0x7F;
772 PrintAndLog("Truncating IV to 7bits, %u", *iv);
773 }
774 // IV must be odd
775 if ( (*iv & 1) == 0 ){
776 *iv |= 0x01;
777 PrintAndLog("LSB of IV must be SET %u", *iv);
778 }
779 }
780 void legic_seteml(uint8_t *src, uint32_t offset, uint32_t numofbytes) {
781 size_t len = 0;
782 UsbCommand c = {CMD_LEGIC_ESET, {0, 0, 0}};
783 for(size_t i = 0; i < numofbytes; i += USB_CMD_DATA_SIZE) {
784
785 len = MIN((numofbytes - i), USB_CMD_DATA_SIZE);
786 c.arg[0] = i; // offset
787 c.arg[1] = len; // number of bytes
788 memcpy(c.d.asBytes, src+i, len);
789 clearCommandBuffer();
790 SendCommand(&c);
791 }
792 }
793
794 int HFLegicReader(const char *Cmd, bool verbose) {
795
796 char cmdp = param_getchar(Cmd, 0);
797 if ( cmdp == 'H' || cmdp == 'h' ) return usage_legic_reader();
798
799 legic_card_select_t card;
800 switch(legic_get_type(&card)){
801 case 1:
802 if ( verbose ) PrintAndLog("command execution time out");
803 return 1;
804 case 2:
805 case 3:
806 if ( verbose ) PrintAndLog("legic card select failed");
807 return 2;
808 default: break;
809 }
810 PrintAndLog(" UID : %s", sprint_hex(card.uid, sizeof(card.uid)));
811 legic_print_type(card.cardsize, 0);
812 return 0;
813 }
814 int CmdLegicReader(const char *Cmd){
815 return HFLegicReader(Cmd, TRUE);
816 }
817
818 int CmdLegicDump(const char *Cmd){
819
820 FILE *f;
821 char filename[FILE_PATH_SIZE] = {0x00};
822 char *fnameptr = filename;
823 size_t fileNlen = 0;
824 bool errors = false;
825 uint16_t dumplen;
826 uint8_t cmdp = 0;
827
828 memset(filename, 0, sizeof(filename));
829
830 while(param_getchar(Cmd, cmdp) != 0x00) {
831 switch(param_getchar(Cmd, cmdp)) {
832 case 'h':
833 case 'H':
834 return usage_legic_dump();
835 case 'o':
836 case 'O':
837 fileNlen = param_getstr(Cmd, cmdp+1, filename);
838 if (!fileNlen)
839 errors = true;
840 if (fileNlen > FILE_PATH_SIZE-5)
841 fileNlen = FILE_PATH_SIZE-5;
842 cmdp += 2;
843 break;
844 default:
845 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
846 errors = true;
847 break;
848 }
849 if(errors) break;
850 }
851
852 //Validations
853 if(errors) return usage_legic_dump();
854
855 // tagtype
856 legic_card_select_t card;
857 if (legic_get_type(&card)) {
858 PrintAndLog("Failed to identify tagtype");
859 return -1;
860 }
861 dumplen = card.cardsize;
862
863 legic_print_type(dumplen, 0);
864 PrintAndLog("Reading tag memory...");
865
866 UsbCommand c = {CMD_READER_LEGIC_RF, {0x00, dumplen, 0x55}};
867 clearCommandBuffer();
868 SendCommand(&c);
869 UsbCommand resp;
870 if (!WaitForResponseTimeout(CMD_ACK, &resp, 3000)) {
871 PrintAndLog("Command execute time-out");
872 return 1;
873 }
874
875 uint8_t isOK = resp.arg[0] & 0xFF;
876 if ( !isOK ) {
877 PrintAndLog("Failed dumping tag data");
878 return 2;
879 }
880
881 uint16_t readlen = resp.arg[1];
882 uint8_t *data = malloc(readlen);
883 if (!data) {
884 PrintAndLog("Fail, cannot allocate memory");
885 return 3;
886 }
887 memset(data, 0, readlen);
888
889 if ( readlen != dumplen )
890 PrintAndLog("Fail, only managed to read 0x%02X bytes of 0x%02X", readlen, dumplen);
891
892 // copy data from device
893 GetEMLFromBigBuf(data, readlen, 0);
894 if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
895 PrintAndLog("Fail, transfer from device time-out");
896 free(data);
897 return 4;
898 }
899
900 // user supplied filename?
901 if (fileNlen < 1)
902 sprintf(fnameptr,"%02X%02X%02X%02X.bin", data[0], data[1], data[2], data[3]);
903 else
904 sprintf(fnameptr + fileNlen,".bin");
905
906 if ((f = fopen(filename,"wb")) == NULL) {
907 PrintAndLog("Could not create file name %s", filename);
908 if (data)
909 free(data);
910 return 5;
911 }
912 fwrite(data, 1, readlen, f);
913 fclose(f);
914 free(data);
915 PrintAndLog("Wrote %d bytes to %s", readlen, filename);
916 return 0;
917 }
918
919 int CmdLegicRestore(const char *Cmd){
920
921 FILE *f;
922 char filename[FILE_PATH_SIZE] = {0x00};
923 char *fnameptr = filename;
924 size_t fileNlen = 0;
925 bool errors = false;
926 uint16_t numofbytes;
927 uint8_t cmdp = 0;
928
929 memset(filename, 0, sizeof(filename));
930
931 while(param_getchar(Cmd, cmdp) != 0x00) {
932 switch(param_getchar(Cmd, cmdp)) {
933 case 'h':
934 case 'H':
935 errors = true;
936 break;
937 case 'i':
938 case 'I':
939 fileNlen = param_getstr(Cmd, cmdp+1, filename);
940 if (!fileNlen)
941 errors = true;
942 if (fileNlen > FILE_PATH_SIZE-5)
943 fileNlen = FILE_PATH_SIZE-5;
944 cmdp += 2;
945 break;
946 default:
947 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd, cmdp));
948 errors = true;
949 break;
950 }
951 if(errors) break;
952 }
953
954 //Validations
955 if(errors) return usage_legic_restore();
956
957 // tagtype
958 legic_card_select_t card;
959 if (legic_get_type(&card)) {
960 PrintAndLog("Failed to identify tagtype");
961 return 1;
962 }
963 numofbytes = card.cardsize;
964
965 // set up buffer
966 uint8_t *data = malloc(numofbytes);
967 if (!data) {
968 PrintAndLog("Fail, cannot allocate memory");
969 return 2;
970 }
971 memset(data, 0, numofbytes);
972
973 legic_print_type(numofbytes, 0);
974
975 // set up file
976 fnameptr += fileNlen;
977 sprintf(fnameptr, ".bin");
978
979 if ((f = fopen(filename,"rb")) == NULL) {
980 PrintAndLog("File %s not found or locked", filename);
981 return 3;
982 }
983
984 // verify size of dumpfile is the same as card.
985 fseek(f, 0, SEEK_END); // seek to end of file
986 size_t filesize = ftell(f); // get current file pointer
987 fseek(f, 0, SEEK_SET); // seek back to beginning of file
988
989 if ( filesize != numofbytes) {
990 PrintAndLog("Fail, Filesize and cardsize is not equal. [%u != %u]", filesize, numofbytes);
991 free(data);
992 fclose(f);
993 return 4;
994 }
995
996
997 PrintAndLog("Reading binary file...");
998
999
1000 // load file
1001 size_t bytes_read = fread(data, 1, numofbytes, f);
1002 if ( bytes_read == 0){
1003 PrintAndLog("File reading error");
1004 free(data);
1005 fclose(f);
1006 return 2;
1007 }
1008 fclose(f);
1009
1010 PrintAndLog("Restoring %s to card", filename);
1011
1012 //loop writing :)
1013
1014 //endloop
1015
1016 free(data);
1017 PrintAndLog("\nLoaded %d bytes from file: %s to emulator memory", numofbytes, filename);
1018 return 0;
1019 }
1020
1021 int CmdLegicELoad(const char *Cmd) {
1022 FILE * f;
1023 char filename[FILE_PATH_SIZE];
1024 char *fnameptr = filename;
1025 int len, numofbytes;
1026 int nameParamNo = 1;
1027
1028 char cmdp = param_getchar(Cmd, 0);
1029 if ( cmdp == 'h' || cmdp == 'H' || cmdp == 0x00)
1030 return usage_legic_eload();
1031
1032 switch (cmdp) {
1033 case '0' : numofbytes = 22; break;
1034 case '1' :
1035 case '\0': numofbytes = 256; break;
1036 case '2' : numofbytes = 1024; break;
1037 default : numofbytes = 256; nameParamNo = 0;break;
1038 }
1039
1040 // set up buffer
1041 uint8_t *data = malloc(numofbytes);
1042 if (!data) {
1043 PrintAndLog("Fail, cannot allocate memory");
1044 return 3;
1045 }
1046 memset(data, 0, numofbytes);
1047
1048 // set up file
1049 len = param_getstr(Cmd, nameParamNo, filename);
1050 if (len > FILE_PATH_SIZE - 5)
1051 len = FILE_PATH_SIZE - 5;
1052 fnameptr += len;
1053 sprintf(fnameptr, ".bin");
1054
1055 // open file
1056 if ((f = fopen(filename,"rb")) == NULL) {
1057 PrintAndLog("File %s not found or locked", filename);
1058 free(data);
1059 return 1;
1060 }
1061
1062 // load file
1063 size_t bytes_read = fread(data, 1, numofbytes, f);
1064 if ( bytes_read == 0){
1065 PrintAndLog("File reading error");
1066 free(data);
1067 fclose(f);
1068 return 2;
1069 }
1070 fclose(f);
1071
1072 // transfer to device
1073 legic_seteml(data, 0, numofbytes);
1074
1075 free(data);
1076 PrintAndLog("\nLoaded %d bytes from file: %s to emulator memory", numofbytes, filename);
1077 return 0;
1078 }
1079
1080 int CmdLegicESave(const char *Cmd) {
1081 FILE *f;
1082 char filename[FILE_PATH_SIZE];
1083 char *fnameptr = filename;
1084 int fileNlen, numofbytes, nameParamNo = 1;
1085
1086 memset(filename, 0, sizeof(filename));
1087
1088 char cmdp = param_getchar(Cmd, 0);
1089
1090 if ( cmdp == 'h' || cmdp == 'H' || cmdp == 0x00)
1091 return usage_legic_esave();
1092
1093 switch (cmdp) {
1094 case '0' : numofbytes = 22; break;
1095 case '1' :
1096 case '\0': numofbytes = 256; break;
1097 case '2' : numofbytes = 1024; break;
1098 default : numofbytes = 256; nameParamNo = 0; break;
1099 }
1100
1101 fileNlen = param_getstr(Cmd, nameParamNo, filename);
1102
1103 if (fileNlen > FILE_PATH_SIZE - 5)
1104 fileNlen = FILE_PATH_SIZE - 5;
1105
1106 // set up buffer
1107 uint8_t *data = malloc(numofbytes);
1108 if (!data) {
1109 PrintAndLog("Fail, cannot allocate memory");
1110 return 3;
1111 }
1112 memset(data, 0, numofbytes);
1113
1114 // download emulator memory
1115 PrintAndLog("Reading emulator memory...");
1116 GetEMLFromBigBuf(data, numofbytes, 0);
1117 if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2500)) {
1118 PrintAndLog("Fail, transfer from device time-out");
1119 free(data);
1120 return 4;
1121 }
1122
1123 // user supplied filename?
1124 if (fileNlen < 1)
1125 sprintf(fnameptr,"%02X%02X%02X%02X.bin", data[0], data[1], data[2], data[3]);
1126 else
1127 sprintf(fnameptr + fileNlen,".bin");
1128
1129 // open file
1130 if ((f = fopen(filename,"wb")) == NULL) {
1131 PrintAndLog("Could not create file name %s", filename);
1132 free(data);
1133 return 1;
1134 }
1135 fwrite(data, 1, numofbytes, f);
1136 fclose(f);
1137 free(data);
1138 PrintAndLog("\nSaved %d bytes from emulator memory to file: %s", numofbytes, filename);
1139 return 0;
1140 }
1141
1142 int CmdLegicList(const char *Cmd) {
1143 CmdHFList("legic");
1144 return 0;
1145 }
1146
1147 static command_t CommandTable[] = {
1148 {"help", CmdHelp, 1, "This help"},
1149 {"reader", CmdLegicReader, 1, "LEGIC Prime Reader UID and tag info"},
1150 {"info", CmdLegicInfo, 0, "Display deobfuscated and decoded LEGIC Prime tag data"},
1151 {"dump", CmdLegicDump, 0, "Dump LEGIC Prime tag to binary file"},
1152 {"restore", CmdLegicRestore, 0, "Restore a dump onto a LEGIC Prime tag"},
1153 {"rdmem", CmdLegicRdmem, 0, "Read bytes from a LEGIC Prime tag"},
1154 {"sim", CmdLegicRfSim, 0, "Start tag simulator"},
1155 {"write", CmdLegicRfWrite, 0, "Write data to a LEGIC Prime tag"},
1156 {"crc", CmdLegicCalcCrc, 1, "Calculate Legic CRC over given bytes"},
1157 {"eload", CmdLegicELoad, 1, "Load binary dump to emulator memory"},
1158 {"esave", CmdLegicESave, 1, "Save emulator memory to binary file"},
1159 {"list", CmdLegicList, 1, "[Deprecated] List LEGIC history"},
1160 {NULL, NULL, 0, NULL}
1161 };
1162
1163 int CmdHFLegic(const char *Cmd) {
1164 clearCommandBuffer();
1165 CmdsParse(CommandTable, Cmd);
1166 return 0;
1167 }
1168
1169 int CmdHelp(const char *Cmd) {
1170 CmdsHelp(CommandTable);
1171 return 0;
1172 }
Proxmark3 GIT tracking
Impressum, Datenschutz