]> git.zerfleddert.de Git - proxmark3-svn/blob - client/mifarehost.c
Minor dox
[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, bool 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, bool 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[200] = {0};
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 nr_enc; // encrypted reader challenge
314 uint32_t ar_enc; // encrypted reader response
315 uint32_t at_enc; // encrypted tag response
316
317 int isTraceCardEmpty(void) {
318 return ((traceCard[0] == 0) && (traceCard[1] == 0) && (traceCard[2] == 0) && (traceCard[3] == 0));
319 }
320
321 int isBlockEmpty(int blockN) {
322 for (int i = 0; i < 16; i++)
323 if (traceCard[blockN * 16 + i] != 0) return 0;
324
325 return 1;
326 }
327
328 int isBlockTrailer(int blockN) {
329 return ((blockN & 0x03) == 0x03);
330 }
331
332 int loadTraceCard(uint8_t *tuid) {
333 FILE * f;
334 char buf[64];
335 uint8_t buf8[64];
336 int i, blockNum;
337
338 if (!isTraceCardEmpty()) saveTraceCard();
339 memset(traceCard, 0x00, 4096);
340 memcpy(traceCard, tuid + 3, 4);
341 FillFileNameByUID(traceFileName, tuid, ".eml", 7);
342
343 f = fopen(traceFileName, "r");
344 if (!f) return 1;
345
346 blockNum = 0;
347 while(!feof(f)){
348 memset(buf, 0, sizeof(buf));
349 if (fgets(buf, sizeof(buf), f) == NULL) {
350 PrintAndLog("File reading error.");
351 fclose(f);
352 return 2;
353 }
354
355 if (strlen(buf) < 32){
356 if (feof(f)) break;
357 PrintAndLog("File content error. Block data must include 32 HEX symbols");
358 fclose(f);
359 return 2;
360 }
361 for (i = 0; i < 32; i += 2)
362 sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);
363
364 memcpy(traceCard + blockNum * 16, buf8, 16);
365
366 blockNum++;
367 }
368 fclose(f);
369
370 return 0;
371 }
372
373 int saveTraceCard(void) {
374 FILE * f;
375
376 if ((!strlen(traceFileName)) || (isTraceCardEmpty())) return 0;
377
378 f = fopen(traceFileName, "w+");
379 for (int i = 0; i < 64; i++) { // blocks
380 for (int j = 0; j < 16; j++) // bytes
381 fprintf(f, "%02x", *(traceCard + i * 16 + j));
382 fprintf(f,"\n");
383 }
384 fclose(f);
385
386 return 0;
387 }
388
389 int mfTraceInit(uint8_t *tuid, uint8_t *atqa, uint8_t sak, bool wantSaveToEmlFile) {
390
391 if (traceCrypto1) crypto1_destroy(traceCrypto1);
392 traceCrypto1 = NULL;
393
394 if (wantSaveToEmlFile) loadTraceCard(tuid);
395 traceCard[4] = traceCard[0] ^ traceCard[1] ^ traceCard[2] ^ traceCard[3];
396 traceCard[5] = sak;
397 memcpy(&traceCard[6], atqa, 2);
398 traceCurBlock = 0;
399 uid = bytes_to_num(tuid + 3, 4);
400
401 traceState = TRACE_IDLE;
402
403 return 0;
404 }
405
406 void mf_crypto1_decrypt(struct Crypto1State *pcs, uint8_t *data, int len, bool isEncrypted){
407 uint8_t bt = 0;
408 int i;
409
410 if (len != 1) {
411 for (i = 0; i < len; i++)
412 data[i] = crypto1_byte(pcs, 0x00, isEncrypted) ^ data[i];
413 } else {
414 bt = 0;
415 for (i = 0; i < 4; i++)
416 bt |= (crypto1_bit(pcs, 0, isEncrypted) ^ BIT(data[0], i)) << i;
417
418 data[0] = bt;
419 }
420 return;
421 }
422
423
424 int mfTraceDecode(uint8_t *data_src, int len, bool wantSaveToEmlFile) {
425 uint8_t data[64];
426
427 if (traceState == TRACE_ERROR) return 1;
428 if (len > 64) {
429 traceState = TRACE_ERROR;
430 return 1;
431 }
432
433 memcpy(data, data_src, len);
434 if ((traceCrypto1) && ((traceState == TRACE_IDLE) || (traceState > TRACE_AUTH_OK))) {
435 mf_crypto1_decrypt(traceCrypto1, data, len, 0);
436 PrintAndLog("dec> %s", sprint_hex(data, len));
437 AddLogHex(logHexFileName, "dec> ", data, len);
438 }
439
440 switch (traceState) {
441 case TRACE_IDLE:
442 // check packet crc16!
443 if ((len >= 4) && (!CheckCrc14443(CRC_14443_A, data, len))) {
444 PrintAndLog("dec> CRC ERROR!!!");
445 AddLogLine(logHexFileName, "dec> ", "CRC ERROR!!!");
446 traceState = TRACE_ERROR; // do not decrypt the next commands
447 return 1;
448 }
449
450 // AUTHENTICATION
451 if ((len ==4) && ((data[0] == 0x60) || (data[0] == 0x61))) {
452 traceState = TRACE_AUTH1;
453 traceCurBlock = data[1];
454 traceCurKey = data[0] == 60 ? 1:0;
455 return 0;
456 }
457
458 // READ
459 if ((len ==4) && ((data[0] == 0x30))) {
460 traceState = TRACE_READ_DATA;
461 traceCurBlock = data[1];
462 return 0;
463 }
464
465 // WRITE
466 if ((len ==4) && ((data[0] == 0xA0))) {
467 traceState = TRACE_WRITE_OK;
468 traceCurBlock = data[1];
469 return 0;
470 }
471
472 // HALT
473 if ((len ==4) && ((data[0] == 0x50) && (data[1] == 0x00))) {
474 traceState = TRACE_ERROR; // do not decrypt the next commands
475 return 0;
476 }
477
478 return 0;
479 break;
480
481 case TRACE_READ_DATA:
482 if (len == 18) {
483 traceState = TRACE_IDLE;
484
485 if (isBlockTrailer(traceCurBlock)) {
486 memcpy(traceCard + traceCurBlock * 16 + 6, data + 6, 4);
487 } else {
488 memcpy(traceCard + traceCurBlock * 16, data, 16);
489 }
490 if (wantSaveToEmlFile) saveTraceCard();
491 return 0;
492 } else {
493 traceState = TRACE_ERROR;
494 return 1;
495 }
496 break;
497
498 case TRACE_WRITE_OK:
499 if ((len == 1) && (data[0] == 0x0a)) {
500 traceState = TRACE_WRITE_DATA;
501
502 return 0;
503 } else {
504 traceState = TRACE_ERROR;
505 return 1;
506 }
507 break;
508
509 case TRACE_WRITE_DATA:
510 if (len == 18) {
511 traceState = TRACE_IDLE;
512
513 memcpy(traceCard + traceCurBlock * 16, data, 16);
514 if (wantSaveToEmlFile) saveTraceCard();
515 return 0;
516 } else {
517 traceState = TRACE_ERROR;
518 return 1;
519 }
520 break;
521
522 case TRACE_AUTH1:
523 if (len == 4) {
524 traceState = TRACE_AUTH2;
525
526 nt = bytes_to_num(data, 4);
527 return 0;
528 } else {
529 traceState = TRACE_ERROR;
530 return 1;
531 }
532 break;
533
534 case TRACE_AUTH2:
535 if (len == 8) {
536 traceState = TRACE_AUTH_OK;
537
538 nr_enc = bytes_to_num(data, 4);
539 ar_enc = bytes_to_num(data + 4, 4);
540 return 0;
541 } else {
542 traceState = TRACE_ERROR;
543 return 1;
544 }
545 break;
546
547 case TRACE_AUTH_OK:
548 if (len ==4) {
549 traceState = TRACE_IDLE;
550
551 at_enc = bytes_to_num(data, 4);
552
553 // decode key here)
554 ks2 = ar_enc ^ prng_successor(nt, 64);
555 ks3 = at_enc ^ prng_successor(nt, 96);
556 revstate = lfsr_recovery64(ks2, ks3);
557 lfsr_rollback_word(revstate, 0, 0);
558 lfsr_rollback_word(revstate, 0, 0);
559 lfsr_rollback_word(revstate, nr_enc, 1);
560 lfsr_rollback_word(revstate, uid ^ nt, 0);
561 crypto1_get_lfsr(revstate, &lfsr);
562 printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF));
563 AddLogUint64(logHexFileName, "key> ", lfsr);
564
565 int blockShift = ((traceCurBlock & 0xFC) + 3) * 16;
566 if (isBlockEmpty((traceCurBlock & 0xFC) + 3)) memcpy(traceCard + blockShift + 6, trailerAccessBytes, 4);
567
568 if (traceCurKey) {
569 num_to_bytes(lfsr, 6, traceCard + blockShift + 10);
570 } else {
571 num_to_bytes(lfsr, 6, traceCard + blockShift);
572 }
573 if (wantSaveToEmlFile) saveTraceCard();
574
575 if (traceCrypto1) {
576 crypto1_destroy(traceCrypto1);
577 }
578
579 // set cryptosystem state
580 traceCrypto1 = lfsr_recovery64(ks2, ks3);
581
582 // nt = crypto1_word(traceCrypto1, nt ^ uid, 1) ^ nt;
583
584 /* traceCrypto1 = crypto1_create(lfsr); // key in lfsr
585 crypto1_word(traceCrypto1, nt ^ uid, 0);
586 crypto1_word(traceCrypto1, ar, 1);
587 crypto1_word(traceCrypto1, 0, 0);
588 crypto1_word(traceCrypto1, 0, 0);*/
589
590 return 0;
591 } else {
592 traceState = TRACE_ERROR;
593 return 1;
594 }
595 break;
596
597 default:
598 traceState = TRACE_ERROR;
599 return 1;
600 }
601
602 return 0;
603 }
Impressum, Datenschutz