]> git.zerfleddert.de Git - proxmark3-svn/blob - client/mifarehost.c
Minor typo
[proxmark3-svn] / client / mifarehost.c
1 // Merlok, 2011, 2012
2 // people from mifare@nethemba.com, 2010
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 // mifare commands
9 //-----------------------------------------------------------------------------
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <pthread.h>
15 #include "mifarehost.h"
16 #include "proxmark3.h"
17
18 // MIFARE
19 int compar_int(const void * a, const void * b) {
20 // didn't work: (the result is truncated to 32 bits)
21 //return (*(uint64_t*)b - *(uint64_t*)a);
22
23 // better:
24 if (*(uint64_t*)b == *(uint64_t*)a) return 0;
25 else if (*(uint64_t*)b > *(uint64_t*)a) return 1;
26 else return -1;
27 }
28
29
30
31 // Compare 16 Bits out of cryptostate
32 int Compare16Bits(const void * a, const void * b) {
33 if ((*(uint64_t*)b & 0x00ff000000ff0000) == (*(uint64_t*)a & 0x00ff000000ff0000)) return 0;
34 else if ((*(uint64_t*)b & 0x00ff000000ff0000) > (*(uint64_t*)a & 0x00ff000000ff0000)) return 1;
35 else return -1;
36 }
37
38
39 typedef
40 struct {
41 union {
42 struct Crypto1State *slhead;
43 uint64_t *keyhead;
44 } head;
45 union {
46 struct Crypto1State *sltail;
47 uint64_t *keytail;
48 } tail;
49 uint32_t len;
50 uint32_t uid;
51 uint32_t blockNo;
52 uint32_t keyType;
53 uint32_t nt;
54 uint32_t ks1;
55 } StateList_t;
56
57
58 // wrapper function for multi-threaded lfsr_recovery32
59 void* nested_worker_thread(void *arg)
60 {
61 struct Crypto1State *p1;
62 StateList_t *statelist = arg;
63
64 statelist->head.slhead = lfsr_recovery32(statelist->ks1, statelist->nt ^ statelist->uid);
65 for (p1 = statelist->head.slhead; *(uint64_t *)p1 != 0; p1++);
66 statelist->len = p1 - statelist->head.slhead;
67 statelist->tail.sltail = --p1;
68 qsort(statelist->head.slhead, statelist->len, sizeof(uint64_t), Compare16Bits);
69
70 return statelist->head.slhead;
71 }
72
73
74
75
76 int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t * key, uint8_t trgBlockNo, uint8_t trgKeyType, uint8_t * resultKey, bool calibrate)
77 {
78 uint16_t i, len;
79 uint32_t uid;
80 UsbCommand resp;
81
82
83 StateList_t statelists[2];
84 struct Crypto1State *p1, *p2, *p3, *p4;
85
86 // flush queue
87 WaitForResponseTimeout(CMD_ACK,NULL,100);
88
89 UsbCommand c = {CMD_MIFARE_NESTED, {blockNo + keyType * 0x100, trgBlockNo + trgKeyType * 0x100, calibrate}};
90 memcpy(c.d.asBytes, key, 6);
91 SendCommand(&c);
92
93 if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
94 len = resp.arg[1];
95 if (len == 2) {
96 memcpy(&uid, resp.d.asBytes, 4);
97 PrintAndLog("uid:%08x len=%d trgbl=%d trgkey=%x", uid, len, (uint16_t)resp.arg[2] & 0xff, (uint16_t)resp.arg[2] >> 8);
98
99 for (i = 0; i < 2; i++) {
100 statelists[i].blockNo = resp.arg[2] & 0xff;
101 statelists[i].keyType = (resp.arg[2] >> 8) & 0xff;
102 statelists[i].uid = uid;
103
104 memcpy(&statelists[i].nt, (void *)(resp.d.asBytes + 4 + i * 8 + 0), 4);
105 memcpy(&statelists[i].ks1, (void *)(resp.d.asBytes + 4 + i * 8 + 4), 4);
106 }
107 }
108 else {
109 PrintAndLog("Got 0 keys from proxmark.");
110 return 1;
111 }
112 }
113
114 // calc keys
115
116 pthread_t thread_id[2];
117
118 // create and run worker threads
119 for (i = 0; i < 2; i++) {
120 pthread_create(thread_id + i, NULL, nested_worker_thread, &statelists[i]);
121 }
122
123 // wait for threads to terminate:
124 for (i = 0; i < 2; i++) {
125 pthread_join(thread_id[i], (void*)&statelists[i].head.slhead);
126 }
127
128
129 // the first 16 Bits of the cryptostate already contain part of our key.
130 // Create the intersection of the two lists based on these 16 Bits and
131 // roll back the cryptostate
132 p1 = p3 = statelists[0].head.slhead;
133 p2 = p4 = statelists[1].head.slhead;
134 while (p1 <= statelists[0].tail.sltail && p2 <= statelists[1].tail.sltail) {
135 if (Compare16Bits(p1, p2) == 0) {
136 struct Crypto1State savestate, *savep = &savestate;
137 savestate = *p1;
138 while(Compare16Bits(p1, savep) == 0 && p1 <= statelists[0].tail.sltail) {
139 *p3 = *p1;
140 lfsr_rollback_word(p3, statelists[0].nt ^ statelists[0].uid, 0);
141 p3++;
142 p1++;
143 }
144 savestate = *p2;
145 while(Compare16Bits(p2, savep) == 0 && p2 <= statelists[1].tail.sltail) {
146 *p4 = *p2;
147 lfsr_rollback_word(p4, statelists[1].nt ^ statelists[1].uid, 0);
148 p4++;
149 p2++;
150 }
151 }
152 else {
153 while (Compare16Bits(p1, p2) == -1) p1++;
154 while (Compare16Bits(p1, p2) == 1) p2++;
155 }
156 }
157 p3->even = 0; p3->odd = 0;
158 p4->even = 0; p4->odd = 0;
159 statelists[0].len = p3 - statelists[0].head.slhead;
160 statelists[1].len = p4 - statelists[1].head.slhead;
161 statelists[0].tail.sltail=--p3;
162 statelists[1].tail.sltail=--p4;
163
164 // the statelists now contain possible keys. The key we are searching for must be in the
165 // intersection of both lists. Create the intersection:
166 qsort(statelists[0].head.keyhead, statelists[0].len, sizeof(uint64_t), compar_int);
167 qsort(statelists[1].head.keyhead, statelists[1].len, sizeof(uint64_t), compar_int);
168
169 uint64_t *p5, *p6, *p7;
170 p5 = p7 = statelists[0].head.keyhead;
171 p6 = statelists[1].head.keyhead;
172 while (p5 <= statelists[0].tail.keytail && p6 <= statelists[1].tail.keytail) {
173 if (compar_int(p5, p6) == 0) {
174 *p7++ = *p5++;
175 p6++;
176 }
177 else {
178 while (compar_int(p5, p6) == -1) p5++;
179 while (compar_int(p5, p6) == 1) p6++;
180 }
181 }
182 statelists[0].len = p7 - statelists[0].head.keyhead;
183 statelists[0].tail.keytail=--p7;
184
185 memset(resultKey, 0, 6);
186 // The list may still contain several key candidates. Test each of them with mfCheckKeys
187 for (i = 0; i < statelists[0].len; i++) {
188 uint8_t keyBlock[6];
189 uint64_t key64;
190 crypto1_get_lfsr(statelists[0].head.slhead + i, &key64);
191 num_to_bytes(key64, 6, keyBlock);
192 key64 = 0;
193 if (!mfCheckKeys(statelists[0].blockNo, statelists[0].keyType, 1, keyBlock, &key64)) {
194 num_to_bytes(key64, 6, resultKey);
195 break;
196 }
197 }
198
199 free(statelists[0].head.slhead);
200 free(statelists[1].head.slhead);
201
202 return 0;
203 }
204
205 int mfCheckKeys (uint8_t blockNo, uint8_t keyType, uint8_t keycnt, uint8_t * keyBlock, uint64_t * key){
206
207 *key = 0;
208
209 UsbCommand c = {CMD_MIFARE_CHKKEYS, {blockNo, keyType, keycnt}};
210 memcpy(c.d.asBytes, keyBlock, 6 * keycnt);
211 SendCommand(&c);
212
213 UsbCommand resp;
214 if (!WaitForResponseTimeout(CMD_ACK,&resp,3000)) return 1;
215 if ((resp.arg[0] & 0xff) != 0x01) return 2;
216 *key = bytes_to_num(resp.d.asBytes, 6);
217 return 0;
218 }
219
220 // EMULATOR
221
222 int mfEmlGetMem(uint8_t *data, int blockNum, int blocksCount) {
223 UsbCommand c = {CMD_MIFARE_EML_MEMGET, {blockNum, blocksCount, 0}};
224 SendCommand(&c);
225
226 UsbCommand resp;
227 if (!WaitForResponseTimeout(CMD_ACK,&resp,1500)) return 1;
228 memcpy(data, resp.d.asBytes, blocksCount * 16);
229 return 0;
230 }
231
232 int mfEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
233 UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
234 memcpy(c.d.asBytes, data, blocksCount * 16);
235 SendCommand(&c);
236 return 0;
237 }
238
239 // "MAGIC" CARD
240
241 int mfCSetUID(uint8_t *uid, uint8_t *oldUID, int wantWipe) {
242 uint8_t block0[16];
243 memset(block0, 0, 16);
244 memcpy(block0, uid, 4);
245 block0[4] = block0[0]^block0[1]^block0[2]^block0[3]; // Mifare UID BCC
246 // mifare classic SAK(byte 5) and ATQA(byte 6 and 7)
247 block0[5] = 0x88;
248 block0[6] = 0x04;
249 block0[7] = 0x00;
250
251 return mfCSetBlock(0, block0, oldUID, wantWipe, CSETBLOCK_SINGLE_OPER);
252 }
253
254 int mfCSetBlock(uint8_t blockNo, uint8_t *data, uint8_t *uid, int wantWipe, uint8_t params) {
255 uint8_t isOK = 0;
256
257 UsbCommand c = {CMD_MIFARE_EML_CSETBLOCK, {wantWipe, params & (0xFE | (uid == NULL ? 0:1)), blockNo}};
258 memcpy(c.d.asBytes, data, 16);
259 SendCommand(&c);
260
261 UsbCommand resp;
262 if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
263 isOK = resp.arg[0] & 0xff;
264 if (uid != NULL) memcpy(uid, resp.d.asBytes, 4);
265 if (!isOK) return 2;
266 } else {
267 PrintAndLog("Command execute timeout");
268 return 1;
269 }
270 return 0;
271 }
272
273 int mfCGetBlock(uint8_t blockNo, uint8_t *data, uint8_t params) {
274 uint8_t isOK = 0;
275
276 UsbCommand c = {CMD_MIFARE_EML_CGETBLOCK, {params, 0, blockNo}};
277 SendCommand(&c);
278
279 UsbCommand resp;
280 if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
281 isOK = resp.arg[0] & 0xff;
282 memcpy(data, resp.d.asBytes, 16);
283 if (!isOK) return 2;
284 } else {
285 PrintAndLog("Command execute timeout");
286 return 1;
287 }
288 return 0;
289 }
290
291 // SNIFFER
292
293 // constants
294 static uint8_t trailerAccessBytes[4] = {0x08, 0x77, 0x8F, 0x00};
295
296 // variables
297 char logHexFileName[200] = {0x00};
298 static uint8_t traceCard[4096] = {0x00};
299 static char traceFileName[20];
300 static int traceState = TRACE_IDLE;
301 static uint8_t traceCurBlock = 0;
302 static uint8_t traceCurKey = 0;
303
304 struct Crypto1State *traceCrypto1 = NULL;
305
306 struct Crypto1State *revstate;
307 uint64_t lfsr;
308 uint32_t ks2;
309 uint32_t ks3;
310
311 uint32_t uid; // serial number
312 uint32_t nt; // tag challenge
313 uint32_t nt_par;
314 uint32_t nr_enc; // encrypted reader challenge
315 uint32_t ar_enc; // encrypted reader response
316 uint32_t nr_ar_par;
317 uint32_t at_enc; // encrypted tag response
318 uint32_t at_par;
319
320 int isTraceCardEmpty(void) {
321 return ((traceCard[0] == 0) && (traceCard[1] == 0) && (traceCard[2] == 0) && (traceCard[3] == 0));
322 }
323
324 int isBlockEmpty(int blockN) {
325 for (int i = 0; i < 16; i++)
326 if (traceCard[blockN * 16 + i] != 0) return 0;
327
328 return 1;
329 }
330
331 int isBlockTrailer(int blockN) {
332 return ((blockN & 0x03) == 0x03);
333 }
334
335 int loadTraceCard(uint8_t *tuid) {
336 FILE * f;
337 char buf[64];
338 uint8_t buf8[64];
339 int i, blockNum;
340
341 if (!isTraceCardEmpty()) saveTraceCard();
342 memset(traceCard, 0x00, 4096);
343 memcpy(traceCard, tuid + 3, 4);
344 FillFileNameByUID(traceFileName, tuid, ".eml", 7);
345
346 f = fopen(traceFileName, "r");
347 if (!f) return 1;
348
349 blockNum = 0;
350 while(!feof(f)){
351 memset(buf, 0, sizeof(buf));
352 if (fgets(buf, sizeof(buf), f) == NULL) {
353 PrintAndLog("File reading error.");
354 return 2;
355 }
356
357 if (strlen(buf) < 32){
358 if (feof(f)) break;
359 PrintAndLog("File content error. Block data must include 32 HEX symbols");
360 return 2;
361 }
362 for (i = 0; i < 32; i += 2)
363 sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);
364
365 memcpy(traceCard + blockNum * 16, buf8, 16);
366
367 blockNum++;
368 }
369 fclose(f);
370
371 return 0;
372 }
373
374 int saveTraceCard(void) {
375 FILE * f;
376
377 if ((!strlen(traceFileName)) || (isTraceCardEmpty())) return 0;
378
379 f = fopen(traceFileName, "w+");
380 for (int i = 0; i < 64; i++) { // blocks
381 for (int j = 0; j < 16; j++) // bytes
382 fprintf(f, "%02x", *(traceCard + i * 16 + j));
383 fprintf(f,"\n");
384 }
385 fclose(f);
386
387 return 0;
388 }
389
390 int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile) {
391
392 if (traceCrypto1) crypto1_destroy(traceCrypto1);
393 traceCrypto1 = NULL;
394
395 if (wantSaveToEmlFile) loadTraceCard(tuid);
396 traceCard[4] = traceCard[0] ^ traceCard[1] ^ traceCard[2] ^ traceCard[3];
397 traceCard[5] = sak;
398 memcpy(&traceCard[6], atqa, 2);
399 traceCurBlock = 0;
400 uid = bytes_to_num(tuid + 3, 4);
401
402 traceState = TRACE_IDLE;
403
404 return 0;
405 }
406
407 void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len, bool isEncrypted){
408 uint8_t bt = 0;
409 int i;
410
411 if (len != 1) {
412 for (i = 0; i < len; i++)
413 data[i] = crypto1_byte(pcs, 0x00, isEncrypted) ^ data[i];
414 } else {
415 bt = 0;
416 for (i = 0; i < 4; i++)
417 bt |= (crypto1_bit(pcs, 0, isEncrypted) ^ BIT(data[0], i)) << i;
418
419 data[0] = bt;
420 }
421 return;
422 }
423
424
425 int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEmlFile) {
426 uint8_t data[64];
427
428 if (traceState == TRACE_ERROR) return 1;
429 if (len > 64) {
430 traceState = TRACE_ERROR;
431 return 1;
432 }
433
434 memcpy(data, data_src, len);
435 if ((traceCrypto1) && ((traceState == TRACE_IDLE) || (traceState > TRACE_AUTH_OK))) {
436 mf_crypto1_decrypt(traceCrypto1, data, len, 0);
437 PrintAndLog("dec> %s", sprint_hex(data, len));
438 AddLogHex(logHexFileName, "dec> ", data, len);
439 }
440
441 switch (traceState) {
442 case TRACE_IDLE:
443 // check packet crc16!
444 if ((len >= 4) && (!CheckCrc14443(CRC_14443_A, data, len))) {
445 PrintAndLog("dec> CRC ERROR!!!");
446 AddLogLine(logHexFileName, "dec> ", "CRC ERROR!!!");
447 traceState = TRACE_ERROR; // do not decrypt the next commands
448 return 1;
449 }
450
451 // AUTHENTICATION
452 if ((len ==4) && ((data[0] == 0x60) || (data[0] == 0x61))) {
453 traceState = TRACE_AUTH1;
454 traceCurBlock = data[1];
455 traceCurKey = data[0] == 60 ? 1:0;
456 return 0;
457 }
458
459 // READ
460 if ((len ==4) && ((data[0] == 0x30))) {
461 traceState = TRACE_READ_DATA;
462 traceCurBlock = data[1];
463 return 0;
464 }
465
466 // WRITE
467 if ((len ==4) && ((data[0] == 0xA0))) {
468 traceState = TRACE_WRITE_OK;
469 traceCurBlock = data[1];
470 return 0;
471 }
472
473 // HALT
474 if ((len ==4) && ((data[0] == 0x50) && (data[1] == 0x00))) {
475 traceState = TRACE_ERROR; // do not decrypt the next commands
476 return 0;
477 }
478
479 return 0;
480 break;
481
482 case TRACE_READ_DATA:
483 if (len == 18) {
484 traceState = TRACE_IDLE;
485
486 if (isBlockTrailer(traceCurBlock)) {
487 memcpy(traceCard + traceCurBlock * 16 + 6, data + 6, 4);
488 } else {
489 memcpy(traceCard + traceCurBlock * 16, data, 16);
490 }
491 if (wantSaveToEmlFile) saveTraceCard();
492 return 0;
493 } else {
494 traceState = TRACE_ERROR;
495 return 1;
496 }
497 break;
498
499 case TRACE_WRITE_OK:
500 if ((len == 1) && (data[0] = 0x0a)) {
501 traceState = TRACE_WRITE_DATA;
502
503 return 0;
504 } else {
505 traceState = TRACE_ERROR;
506 return 1;
507 }
508 break;
509
510 case TRACE_WRITE_DATA:
511 if (len == 18) {
512 traceState = TRACE_IDLE;
513
514 memcpy(traceCard + traceCurBlock * 16, data, 16);
515 if (wantSaveToEmlFile) saveTraceCard();
516 return 0;
517 } else {
518 traceState = TRACE_ERROR;
519 return 1;
520 }
521 break;
522
523 case TRACE_AUTH1:
524 if (len == 4) {
525 traceState = TRACE_AUTH2;
526
527 nt = bytes_to_num(data, 4);
528 nt_par = parity;
529 return 0;
530 } else {
531 traceState = TRACE_ERROR;
532 return 1;
533 }
534 break;
535
536 case TRACE_AUTH2:
537 if (len == 8) {
538 traceState = TRACE_AUTH_OK;
539
540 nr_enc = bytes_to_num(data, 4);
541 ar_enc = bytes_to_num(data + 4, 4);
542 nr_ar_par = parity;
543 return 0;
544 } else {
545 traceState = TRACE_ERROR;
546 return 1;
547 }
548 break;
549
550 case TRACE_AUTH_OK:
551 if (len ==4) {
552 traceState = TRACE_IDLE;
553
554 at_enc = bytes_to_num(data, 4);
555 at_par = parity;
556
557 // decode key here)
558 if (!traceCrypto1) {
559 ks2 = ar_enc ^ prng_successor(nt, 64);
560 ks3 = at_enc ^ prng_successor(nt, 96);
561 revstate = lfsr_recovery64(ks2, ks3);
562 lfsr_rollback_word(revstate, 0, 0);
563 lfsr_rollback_word(revstate, 0, 0);
564 lfsr_rollback_word(revstate, nr_enc, 1);
565 lfsr_rollback_word(revstate, uid ^ nt, 0);
566 }else{
567 ks2 = ar_enc ^ prng_successor(nt, 64);
568 ks3 = at_enc ^ prng_successor(nt, 96);
569 revstate = lfsr_recovery64(ks2, ks3);
570 lfsr_rollback_word(revstate, 0, 0);
571 lfsr_rollback_word(revstate, 0, 0);
572 lfsr_rollback_word(revstate, nr_enc, 1);
573 lfsr_rollback_word(revstate, uid ^ nt, 0);
574 }
575 crypto1_get_lfsr(revstate, &lfsr);
576 printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF));
577 AddLogUint64(logHexFileName, "key> ", lfsr);
578
579 int blockShift = ((traceCurBlock & 0xFC) + 3) * 16;
580 if (isBlockEmpty((traceCurBlock & 0xFC) + 3)) memcpy(traceCard + blockShift + 6, trailerAccessBytes, 4);
581
582 if (traceCurKey) {
583 num_to_bytes(lfsr, 6, traceCard + blockShift + 10);
584 } else {
585 num_to_bytes(lfsr, 6, traceCard + blockShift);
586 }
587 if (wantSaveToEmlFile) saveTraceCard();
588
589 if (traceCrypto1) {
590 crypto1_destroy(traceCrypto1);
591 }
592
593 // set cryptosystem state
594 traceCrypto1 = lfsr_recovery64(ks2, ks3);
595
596 // nt = crypto1_word(traceCrypto1, nt ^ uid, 1) ^ nt;
597
598 /* traceCrypto1 = crypto1_create(lfsr); // key in lfsr
599 crypto1_word(traceCrypto1, nt ^ uid, 0);
600 crypto1_word(traceCrypto1, ar, 1);
601 crypto1_word(traceCrypto1, 0, 0);
602 crypto1_word(traceCrypto1, 0, 0);*/
603
604 return 0;
605 } else {
606 traceState = TRACE_ERROR;
607 return 1;
608 }
609 break;
610
611 default:
612 traceState = TRACE_ERROR;
613 return 1;
614 }
615
616 return 0;
617 }
Impressum, Datenschutz