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


eef208a7ef060efa60752466eeb43c00c073a12b
[proxmark3-svn] / armsrc / appmain.c
1 //-----------------------------------------------------------------------------
2 // Jonathan Westhues, Mar 2006
3 // Edits by Gerhard de Koning Gans, Sep 2007 (##)
4 //
5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
6 // at your option, any later version. See the LICENSE.txt file for the text of
7 // the license.
8 //-----------------------------------------------------------------------------
9 // The main application code. This is the first thing called after start.c
10 // executes.
11 //-----------------------------------------------------------------------------
12
13 #include "usb_cdc.h"
14 #include "cmd.h"
15
16 #include "proxmark3.h"
17 #include "apps.h"
18 #include "util.h"
19 #include "printf.h"
20 #include "string.h"
21
22 #include <stdarg.h>
23
24 #include "legicrf.h"
25 #include <hitag2.h>
26
27 #ifdef WITH_LCD
28 #include "LCD.h"
29 #endif
30
31 #define abs(x) ( ((x)<0) ? -(x) : (x) )
32
33 //=============================================================================
34 // A buffer where we can queue things up to be sent through the FPGA, for
35 // any purpose (fake tag, as reader, whatever). We go MSB first, since that
36 // is the order in which they go out on the wire.
37 //=============================================================================
38
39 uint8_t ToSend[512];
40 int ToSendMax;
41 static int ToSendBit;
42 struct common_area common_area __attribute__((section(".commonarea")));
43
44 void BufferClear(void)
45 {
46 memset(BigBuf,0,sizeof(BigBuf));
47 Dbprintf("Buffer cleared (%i bytes)",sizeof(BigBuf));
48 }
49
50 void ToSendReset(void)
51 {
52 ToSendMax = -1;
53 ToSendBit = 8;
54 }
55
56 void ToSendStuffBit(int b)
57 {
58 if(ToSendBit >= 8) {
59 ToSendMax++;
60 ToSend[ToSendMax] = 0;
61 ToSendBit = 0;
62 }
63
64 if(b) {
65 ToSend[ToSendMax] |= (1 << (7 - ToSendBit));
66 }
67
68 ToSendBit++;
69
70 if(ToSendBit >= sizeof(ToSend)) {
71 ToSendBit = 0;
72 DbpString("ToSendStuffBit overflowed!");
73 }
74 }
75
76 //=============================================================================
77 // Debug print functions, to go out over USB, to the usual PC-side client.
78 //=============================================================================
79
80 void DbpString(char *str)
81 {
82 byte_t len = strlen(str);
83 cmd_send(CMD_DEBUG_PRINT_STRING,len,0,0,(byte_t*)str,len);
84 // /* this holds up stuff unless we're connected to usb */
85 // if (!UsbConnected())
86 // return;
87 //
88 // UsbCommand c;
89 // c.cmd = CMD_DEBUG_PRINT_STRING;
90 // c.arg[0] = strlen(str);
91 // if(c.arg[0] > sizeof(c.d.asBytes)) {
92 // c.arg[0] = sizeof(c.d.asBytes);
93 // }
94 // memcpy(c.d.asBytes, str, c.arg[0]);
95 //
96 // UsbSendPacket((uint8_t *)&c, sizeof(c));
97 // // TODO fix USB so stupid things like this aren't req'd
98 // SpinDelay(50);
99 }
100
101 #if 0
102 void DbpIntegers(int x1, int x2, int x3)
103 {
104 cmd_send(CMD_DEBUG_PRINT_INTEGERS,x1,x2,x3,0,0);
105 // /* this holds up stuff unless we're connected to usb */
106 // if (!UsbConnected())
107 // return;
108 //
109 // UsbCommand c;
110 // c.cmd = CMD_DEBUG_PRINT_INTEGERS;
111 // c.arg[0] = x1;
112 // c.arg[1] = x2;
113 // c.arg[2] = x3;
114 //
115 // UsbSendPacket((uint8_t *)&c, sizeof(c));
116 // // XXX
117 // SpinDelay(50);
118 }
119 #endif
120
121 void Dbprintf(const char *fmt, ...) {
122 // should probably limit size here; oh well, let's just use a big buffer
123 char output_string[128];
124 va_list ap;
125
126 va_start(ap, fmt);
127 kvsprintf(fmt, output_string, 10, ap);
128 va_end(ap);
129
130 DbpString(output_string);
131 }
132
133 // prints HEX & ASCII
134 void Dbhexdump(int len, uint8_t *d, bool bAsci) {
135 int l=0,i;
136 char ascii[9];
137
138 while (len>0) {
139 if (len>8) l=8;
140 else l=len;
141
142 memcpy(ascii,d,l);
143 ascii[l]=0;
144
145 // filter safe ascii
146 for (i=0;i<l;i++)
147 if (ascii[i]<32 || ascii[i]>126) ascii[i]='.';
148
149 if (bAsci) {
150 Dbprintf("%-8s %*D",ascii,l,d," ");
151 } else {
152 Dbprintf("%*D",l,d," ");
153 }
154
155 len-=8;
156 d+=8;
157 }
158 }
159
160 //-----------------------------------------------------------------------------
161 // Read an ADC channel and block till it completes, then return the result
162 // in ADC units (0 to 1023). Also a routine to average 32 samples and
163 // return that.
164 //-----------------------------------------------------------------------------
165 static int ReadAdc(int ch)
166 {
167 uint32_t d;
168
169 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_SWRST;
170 AT91C_BASE_ADC->ADC_MR =
171 ADC_MODE_PRESCALE(32) |
172 ADC_MODE_STARTUP_TIME(16) |
173 ADC_MODE_SAMPLE_HOLD_TIME(8);
174 AT91C_BASE_ADC->ADC_CHER = ADC_CHANNEL(ch);
175
176 AT91C_BASE_ADC->ADC_CR = AT91C_ADC_START;
177 while(!(AT91C_BASE_ADC->ADC_SR & ADC_END_OF_CONVERSION(ch)))
178 ;
179 d = AT91C_BASE_ADC->ADC_CDR[ch];
180
181 return d;
182 }
183
184 int AvgAdc(int ch) // was static - merlok
185 {
186 int i;
187 int a = 0;
188
189 for(i = 0; i < 32; i++) {
190 a += ReadAdc(ch);
191 }
192
193 return (a + 15) >> 5;
194 }
195
196 void MeasureAntennaTuning(void)
197 {
198 uint8_t *dest = (uint8_t *)BigBuf+FREE_BUFFER_OFFSET;
199 int i, adcval = 0, peak = 0, peakv = 0, peakf = 0; //ptr = 0
200 int vLf125 = 0, vLf134 = 0, vHf = 0; // in mV
201
202 // UsbCommand c;
203
204 LED_B_ON();
205 DbpString("Measuring antenna characteristics, please wait...");
206 memset(dest,0,sizeof(FREE_BUFFER_SIZE));
207
208 /*
209 * Sweeps the useful LF range of the proxmark from
210 * 46.8kHz (divisor=255) to 600kHz (divisor=19) and
211 * read the voltage in the antenna, the result left
212 * in the buffer is a graph which should clearly show
213 * the resonating frequency of your LF antenna
214 * ( hopefully around 95 if it is tuned to 125kHz!)
215 */
216
217 FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_READER);
218 for (i=255; i>19; i--) {
219 WDT_HIT();
220 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, i);
221 SpinDelay(20);
222 // Vref = 3.3V, and a 10000:240 voltage divider on the input
223 // can measure voltages up to 137500 mV
224 adcval = ((137500 * AvgAdc(ADC_CHAN_LF)) >> 10);
225 if (i==95) vLf125 = adcval; // voltage at 125Khz
226 if (i==89) vLf134 = adcval; // voltage at 134Khz
227
228 dest[i] = adcval>>8; // scale int to fit in byte for graphing purposes
229 if(dest[i] > peak) {
230 peakv = adcval;
231 peak = dest[i];
232 peakf = i;
233 //ptr = i;
234 }
235 }
236
237 LED_A_ON();
238 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
239 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
240 SpinDelay(20);
241 // Vref = 3300mV, and an 10:1 voltage divider on the input
242 // can measure voltages up to 33000 mV
243 vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
244
245 // c.cmd = CMD_MEASURED_ANTENNA_TUNING;
246 // c.arg[0] = (vLf125 << 0) | (vLf134 << 16);
247 // c.arg[1] = vHf;
248 // c.arg[2] = peakf | (peakv << 16);
249
250 DbpString("Measuring complete, sending report back to host");
251 cmd_send(CMD_MEASURED_ANTENNA_TUNING,vLf125|(vLf134<<16),vHf,peakf|(peakv<<16),0,0);
252 // UsbSendPacket((uint8_t *)&c, sizeof(c));
253 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
254 LED_A_OFF();
255 LED_B_OFF();
256 return;
257 }
258
259 void MeasureAntennaTuningHf(void)
260 {
261 int vHf = 0; // in mV
262
263 DbpString("Measuring HF antenna, press button to exit");
264
265 for (;;) {
266 // Let the FPGA drive the high-frequency antenna around 13.56 MHz.
267 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
268 SpinDelay(20);
269 // Vref = 3300mV, and an 10:1 voltage divider on the input
270 // can measure voltages up to 33000 mV
271 vHf = (33000 * AvgAdc(ADC_CHAN_HF)) >> 10;
272
273 Dbprintf("%d mV",vHf);
274 if (BUTTON_PRESS()) break;
275 }
276 DbpString("cancelled");
277 }
278
279
280 void SimulateTagHfListen(void)
281 {
282 uint8_t *dest = (uint8_t *)BigBuf+FREE_BUFFER_OFFSET;
283 uint8_t v = 0;
284 int i;
285 int p = 0;
286
287 // We're using this mode just so that I can test it out; the simulated
288 // tag mode would work just as well and be simpler.
289 FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR | FPGA_HF_READER_RX_XCORR_848_KHZ | FPGA_HF_READER_RX_XCORR_SNOOP);
290
291 // We need to listen to the high-frequency, peak-detected path.
292 SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
293
294 FpgaSetupSsc();
295
296 i = 0;
297 for(;;) {
298 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
299 AT91C_BASE_SSC->SSC_THR = 0xff;
300 }
301 if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
302 uint8_t r = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
303
304 v <<= 1;
305 if(r & 1) {
306 v |= 1;
307 }
308 p++;
309
310 if(p >= 8) {
311 dest[i] = v;
312 v = 0;
313 p = 0;
314 i++;
315
316 if(i >= FREE_BUFFER_SIZE) {
317 break;
318 }
319 }
320 }
321 }
322 DbpString("simulate tag (now type bitsamples)");
323 }
324
325 void ReadMem(int addr)
326 {
327 const uint8_t *data = ((uint8_t *)addr);
328
329 Dbprintf("%x: %02x %02x %02x %02x %02x %02x %02x %02x",
330 addr, data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7]);
331 }
332
333 /* osimage version information is linked in */
334 extern struct version_information version_information;
335 /* bootrom version information is pointed to from _bootphase1_version_pointer */
336 extern char *_bootphase1_version_pointer, _flash_start, _flash_end;
337 void SendVersion(void)
338 {
339 char temp[48]; /* Limited data payload in USB packets */
340 DbpString("Prox/RFID mark3 RFID instrument");
341
342 /* Try to find the bootrom version information. Expect to find a pointer at
343 * symbol _bootphase1_version_pointer, perform slight sanity checks on the
344 * pointer, then use it.
345 */
346 char *bootrom_version = *(char**)&_bootphase1_version_pointer;
347 if( bootrom_version < &_flash_start || bootrom_version >= &_flash_end ) {
348 DbpString("bootrom version information appears invalid");
349 } else {
350 FormatVersionInformation(temp, sizeof(temp), "bootrom: ", bootrom_version);
351 DbpString(temp);
352 }
353
354 FormatVersionInformation(temp, sizeof(temp), "os: ", &version_information);
355 DbpString(temp);
356
357 FpgaGatherVersion(temp, sizeof(temp));
358 DbpString(temp);
359 }
360
361 #ifdef WITH_LF
362 // samy's sniff and repeat routine
363 void SamyRun()
364 {
365 DbpString("Stand-alone mode! No PC necessary.");
366
367 // 3 possible options? no just 2 for now
368 #define OPTS 2
369
370 int high[OPTS], low[OPTS];
371
372 // Oooh pretty -- notify user we're in elite samy mode now
373 LED(LED_RED, 200);
374 LED(LED_ORANGE, 200);
375 LED(LED_GREEN, 200);
376 LED(LED_ORANGE, 200);
377 LED(LED_RED, 200);
378 LED(LED_ORANGE, 200);
379 LED(LED_GREEN, 200);
380 LED(LED_ORANGE, 200);
381 LED(LED_RED, 200);
382
383 int selected = 0;
384 int playing = 0;
385
386 // Turn on selected LED
387 LED(selected + 1, 0);
388
389 for (;;)
390 {
391 // UsbPoll(FALSE);
392 usb_poll();
393 WDT_HIT();
394
395 // Was our button held down or pressed?
396 int button_pressed = BUTTON_HELD(1000);
397 SpinDelay(300);
398
399 // Button was held for a second, begin recording
400 if (button_pressed > 0)
401 {
402 LEDsoff();
403 LED(selected + 1, 0);
404 LED(LED_RED2, 0);
405
406 // record
407 DbpString("Starting recording");
408
409 // wait for button to be released
410 while(BUTTON_PRESS())
411 WDT_HIT();
412
413 /* need this delay to prevent catching some weird data */
414 SpinDelay(500);
415
416 CmdHIDdemodFSK(1, &high[selected], &low[selected], 0);
417 Dbprintf("Recorded %x %x %x", selected, high[selected], low[selected]);
418
419 LEDsoff();
420 LED(selected + 1, 0);
421 // Finished recording
422
423 // If we were previously playing, set playing off
424 // so next button push begins playing what we recorded
425 playing = 0;
426 }
427
428 // Change where to record (or begin playing)
429 else if (button_pressed)
430 {
431 // Next option if we were previously playing
432 if (playing)
433 selected = (selected + 1) % OPTS;
434 playing = !playing;
435
436 LEDsoff();
437 LED(selected + 1, 0);
438
439 // Begin transmitting
440 if (playing)
441 {
442 LED(LED_GREEN, 0);
443 DbpString("Playing");
444 // wait for button to be released
445 while(BUTTON_PRESS())
446 WDT_HIT();
447 Dbprintf("%x %x %x", selected, high[selected], low[selected]);
448 CmdHIDsimTAG(high[selected], low[selected], 0);
449 DbpString("Done playing");
450 if (BUTTON_HELD(1000) > 0)
451 {
452 DbpString("Exiting");
453 LEDsoff();
454 return;
455 }
456
457 /* We pressed a button so ignore it here with a delay */
458 SpinDelay(300);
459
460 // when done, we're done playing, move to next option
461 selected = (selected + 1) % OPTS;
462 playing = !playing;
463 LEDsoff();
464 LED(selected + 1, 0);
465 }
466 else
467 while(BUTTON_PRESS())
468 WDT_HIT();
469 }
470 }
471 }
472 #endif
473
474 /*
475 OBJECTIVE
476 Listen and detect an external reader. Determine the best location
477 for the antenna.
478
479 INSTRUCTIONS:
480 Inside the ListenReaderField() function, there is two mode.
481 By default, when you call the function, you will enter mode 1.
482 If you press the PM3 button one time, you will enter mode 2.
483 If you press the PM3 button a second time, you will exit the function.
484
485 DESCRIPTION OF MODE 1:
486 This mode just listens for an external reader field and lights up green
487 for HF and/or red for LF. This is the original mode of the detectreader
488 function.
489
490 DESCRIPTION OF MODE 2:
491 This mode will visually represent, using the LEDs, the actual strength of the
492 current compared to the maximum current detected. Basically, once you know
493 what kind of external reader is present, it will help you spot the best location to place
494 your antenna. You will probably not get some good results if there is a LF and a HF reader
495 at the same place! :-)
496
497 LIGHT SCHEME USED:
498 */
499 static const char LIGHT_SCHEME[] = {
500 0x0, /* ---- | No field detected */
501 0x1, /* X--- | 14% of maximum current detected */
502 0x2, /* -X-- | 29% of maximum current detected */
503 0x4, /* --X- | 43% of maximum current detected */
504 0x8, /* ---X | 57% of maximum current detected */
505 0xC, /* --XX | 71% of maximum current detected */
506 0xE, /* -XXX | 86% of maximum current detected */
507 0xF, /* XXXX | 100% of maximum current detected */
508 };
509 static const int LIGHT_LEN = sizeof(LIGHT_SCHEME)/sizeof(LIGHT_SCHEME[0]);
510
511 void ListenReaderField(int limit)
512 {
513 int lf_av, lf_av_new, lf_baseline= 0, lf_count= 0, lf_max;
514 int hf_av, hf_av_new, hf_baseline= 0, hf_count= 0, hf_max;
515 int mode=1, display_val, display_max, i;
516
517 #define LF_ONLY 1
518 #define HF_ONLY 2
519
520 LEDsoff();
521
522 lf_av=lf_max=ReadAdc(ADC_CHAN_LF);
523
524 if(limit != HF_ONLY) {
525 Dbprintf("LF 125/134 Baseline: %d", lf_av);
526 lf_baseline = lf_av;
527 }
528
529 hf_av=hf_max=ReadAdc(ADC_CHAN_HF);
530
531 if (limit != LF_ONLY) {
532 Dbprintf("HF 13.56 Baseline: %d", hf_av);
533 hf_baseline = hf_av;
534 }
535
536 for(;;) {
537 if (BUTTON_PRESS()) {
538 SpinDelay(500);
539 switch (mode) {
540 case 1:
541 mode=2;
542 DbpString("Signal Strength Mode");
543 break;
544 case 2:
545 default:
546 DbpString("Stopped");
547 LEDsoff();
548 return;
549 break;
550 }
551 }
552 WDT_HIT();
553
554 if (limit != HF_ONLY) {
555 if(mode==1) {
556 if (abs(lf_av - lf_baseline) > 10) LED_D_ON();
557 else LED_D_OFF();
558 }
559
560 ++lf_count;
561 lf_av_new= ReadAdc(ADC_CHAN_LF);
562 // see if there's a significant change
563 if(abs(lf_av - lf_av_new) > 10) {
564 Dbprintf("LF 125/134 Field Change: %x %x %x", lf_av, lf_av_new, lf_count);
565 lf_av = lf_av_new;
566 if (lf_av > lf_max)
567 lf_max = lf_av;
568 lf_count= 0;
569 }
570 }
571
572 if (limit != LF_ONLY) {
573 if (mode == 1){
574 if (abs(hf_av - hf_baseline) > 10) LED_B_ON();
575 else LED_B_OFF();
576 }
577
578 ++hf_count;
579 hf_av_new= ReadAdc(ADC_CHAN_HF);
580 // see if there's a significant change
581 if(abs(hf_av - hf_av_new) > 10) {
582 Dbprintf("HF 13.56 Field Change: %x %x %x", hf_av, hf_av_new, hf_count);
583 hf_av = hf_av_new;
584 if (hf_av > hf_max)
585 hf_max = hf_av;
586 hf_count= 0;
587 }
588 }
589
590 if(mode == 2) {
591 if (limit == LF_ONLY) {
592 display_val = lf_av;
593 display_max = lf_max;
594 } else if (limit == HF_ONLY) {
595 display_val = hf_av;
596 display_max = hf_max;
597 } else { /* Pick one at random */
598 if( (hf_max - hf_baseline) > (lf_max - lf_baseline) ) {
599 display_val = hf_av;
600 display_max = hf_max;
601 } else {
602 display_val = lf_av;
603 display_max = lf_max;
604 }
605 }
606 for (i=0; i<LIGHT_LEN; i++) {
607 if (display_val >= ((display_max/LIGHT_LEN)*i) && display_val <= ((display_max/LIGHT_LEN)*(i+1))) {
608 if (LIGHT_SCHEME[i] & 0x1) LED_C_ON(); else LED_C_OFF();
609 if (LIGHT_SCHEME[i] & 0x2) LED_A_ON(); else LED_A_OFF();
610 if (LIGHT_SCHEME[i] & 0x4) LED_B_ON(); else LED_B_OFF();
611 if (LIGHT_SCHEME[i] & 0x8) LED_D_ON(); else LED_D_OFF();
612 break;
613 }
614 }
615 }
616 }
617 }
618
619 void UsbPacketReceived(uint8_t *packet, int len)
620 {
621 UsbCommand *c = (UsbCommand *)packet;
622
623 // Dbprintf("received %d bytes, with command: 0x%04x and args: %d %d %d",len,c->cmd,c->arg[0],c->arg[1],c->arg[2]);
624
625 switch(c->cmd) {
626 #ifdef WITH_LF
627 case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
628 AcquireRawAdcSamples125k(c->arg[0]);
629 cmd_send(CMD_ACK,0,0,0,0,0);
630 break;
631 case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
632 ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
633 break;
634 case CMD_HID_DEMOD_FSK:
635 CmdHIDdemodFSK(0, 0, 0, 1); // Demodulate HID tag
636 break;
637 case CMD_HID_SIM_TAG:
638 CmdHIDsimTAG(c->arg[0], c->arg[1], 1); // Simulate HID tag by ID
639 break;
640 case CMD_HID_CLONE_TAG: // Clone HID tag by ID to T55x7
641 CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
642 break;
643 case CMD_EM410X_WRITE_TAG:
644 WriteEM410x(c->arg[0], c->arg[1], c->arg[2]);
645 break;
646 case CMD_READ_TI_TYPE:
647 ReadTItag();
648 break;
649 case CMD_WRITE_TI_TYPE:
650 WriteTItag(c->arg[0],c->arg[1],c->arg[2]);
651 break;
652 case CMD_SIMULATE_TAG_125K:
653 LED_A_ON();
654 SimulateTagLowFrequency(c->arg[0], c->arg[1], 1);
655 LED_A_OFF();
656 break;
657 case CMD_LF_SIMULATE_BIDIR:
658 SimulateTagLowFrequencyBidir(c->arg[0], c->arg[1]);
659 break;
660 case CMD_INDALA_CLONE_TAG: // Clone Indala 64-bit tag by UID to T55x7
661 CopyIndala64toT55x7(c->arg[0], c->arg[1]);
662 break;
663 case CMD_INDALA_CLONE_TAG_L: // Clone Indala 224-bit tag by UID to T55x7
664 CopyIndala224toT55x7(c->d.asDwords[0], c->d.asDwords[1], c->d.asDwords[2], c->d.asDwords[3], c->d.asDwords[4], c->d.asDwords[5], c->d.asDwords[6]);
665 break;
666 case CMD_T55XX_READ_BLOCK:
667 T55xxReadBlock(c->arg[1], c->arg[2],c->d.asBytes[0]);
668 break;
669 case CMD_T55XX_WRITE_BLOCK:
670 T55xxWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
671 break;
672 case CMD_T55XX_READ_TRACE: // Clone HID tag by ID to T55x7
673 T55xxReadTrace();
674 break;
675 case CMD_PCF7931_READ: // Read PCF7931 tag
676 ReadPCF7931();
677 cmd_send(CMD_ACK,0,0,0,0,0);
678 // UsbSendPacket((uint8_t*)&ack, sizeof(ack));
679 break;
680 case CMD_EM4X_READ_WORD:
681 EM4xReadWord(c->arg[1], c->arg[2],c->d.asBytes[0]);
682 break;
683 case CMD_EM4X_WRITE_WORD:
684 EM4xWriteWord(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
685 break;
686 #endif
687
688 #ifdef WITH_HITAG
689 case CMD_SNOOP_HITAG: // Eavesdrop Hitag tag, args = type
690 SnoopHitag(c->arg[0]);
691 break;
692 case CMD_SIMULATE_HITAG: // Simulate Hitag tag, args = memory content
693 SimulateHitagTag((bool)c->arg[0],(byte_t*)c->d.asBytes);
694 break;
695 case CMD_READER_HITAG: // Reader for Hitag tags, args = type and function
696 ReaderHitag((hitag_function)c->arg[0],(hitag_data*)c->d.asBytes);
697 break;
698 #endif
699
700 #ifdef WITH_ISO15693
701 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693:
702 AcquireRawAdcSamplesIso15693();
703 break;
704 case CMD_RECORD_RAW_ADC_SAMPLES_ISO_15693:
705 RecordRawAdcSamplesIso15693();
706 break;
707
708 case CMD_ISO_15693_COMMAND:
709 DirectTag15693Command(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
710 break;
711
712 case CMD_ISO_15693_FIND_AFI:
713 BruteforceIso15693Afi(c->arg[0]);
714 break;
715
716 case CMD_ISO_15693_DEBUG:
717 SetDebugIso15693(c->arg[0]);
718 break;
719
720 case CMD_READER_ISO_15693:
721 ReaderIso15693(c->arg[0]);
722 break;
723 case CMD_SIMTAG_ISO_15693:
724 SimTagIso15693(c->arg[0]);
725 break;
726 #endif
727
728 #ifdef WITH_LEGICRF
729 case CMD_SIMULATE_TAG_LEGIC_RF:
730 LegicRfSimulate(c->arg[0], c->arg[1], c->arg[2]);
731 break;
732
733 case CMD_WRITER_LEGIC_RF:
734 LegicRfWriter(c->arg[1], c->arg[0]);
735 break;
736
737 case CMD_READER_LEGIC_RF:
738 LegicRfReader(c->arg[0], c->arg[1]);
739 break;
740 #endif
741
742 #ifdef WITH_ISO14443b
743 case CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443:
744 AcquireRawAdcSamplesIso14443(c->arg[0]);
745 break;
746 case CMD_READ_SRI512_TAG:
747 ReadSRI512Iso14443(c->arg[0]);
748 break;
749 case CMD_READ_SRIX4K_TAG:
750 ReadSRIX4KIso14443(c->arg[0]);
751 break;
752 case CMD_SNOOP_ISO_14443:
753 SnoopIso14443();
754 break;
755 case CMD_SIMULATE_TAG_ISO_14443:
756 SimulateIso14443Tag();
757 break;
758 #endif
759
760 #ifdef WITH_ISO14443a
761 case CMD_SNOOP_ISO_14443a:
762 SnoopIso14443a(c->arg[0]);
763 break;
764 case CMD_READER_ISO_14443a:
765 ReaderIso14443a(c);
766 break;
767 case CMD_SIMULATE_TAG_ISO_14443a:
768 SimulateIso14443aTag(c->arg[0], c->arg[1], c->arg[2]); // ## Simulate iso14443a tag - pass tag type & UID
769 break;
770 case CMD_EPA_PACE_COLLECT_NONCE:
771 EPA_PACE_Collect_Nonce(c);
772 break;
773
774 case CMD_READER_MIFARE:
775 ReaderMifare(c->arg[0]);
776 break;
777 case CMD_MIFARE_READBL:
778 MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
779 break;
780 case CMD_MIFARE_READSC:
781 MifareReadSector(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
782 break;
783 case CMD_MIFARE_WRITEBL:
784 MifareWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
785 break;
786 case CMD_MIFARE_NESTED:
787 MifareNested(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
788 break;
789 case CMD_MIFARE_CHKKEYS:
790 MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
791 break;
792 case CMD_SIMULATE_MIFARE_CARD:
793 Mifare1ksim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
794 break;
795
796 // emulator
797 case CMD_MIFARE_SET_DBGMODE:
798 MifareSetDbgLvl(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
799 break;
800 case CMD_MIFARE_EML_MEMCLR:
801 MifareEMemClr(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
802 break;
803 case CMD_MIFARE_EML_MEMSET:
804 MifareEMemSet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
805 break;
806 case CMD_MIFARE_EML_MEMGET:
807 MifareEMemGet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
808 break;
809 case CMD_MIFARE_EML_CARDLOAD:
810 MifareECardLoad(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
811 break;
812
813 // Work with "magic Chinese" card
814 case CMD_MIFARE_EML_CSETBLOCK:
815 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
816 break;
817 case CMD_MIFARE_EML_CGETBLOCK:
818 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
819 break;
820
821 // mifare sniffer
822 case CMD_MIFARE_SNIFFER:
823 SniffMifare(c->arg[0]);
824 break;
825 #endif
826
827 #ifdef WITH_ICLASS
828 // Makes use of ISO14443a FPGA Firmware
829 case CMD_SNOOP_ICLASS:
830 SnoopIClass();
831 break;
832 case CMD_SIMULATE_TAG_ICLASS:
833 SimulateIClass(c->arg[0], c->d.asBytes);
834 break;
835 case CMD_READER_ICLASS:
836 ReaderIClass(c->arg[0]);
837 break;
838 #endif
839
840 case CMD_SIMULATE_TAG_HF_LISTEN:
841 SimulateTagHfListen();
842 break;
843
844 case CMD_BUFF_CLEAR:
845 BufferClear();
846 break;
847
848 case CMD_MEASURE_ANTENNA_TUNING:
849 MeasureAntennaTuning();
850 break;
851
852 case CMD_MEASURE_ANTENNA_TUNING_HF:
853 MeasureAntennaTuningHf();
854 break;
855
856 case CMD_LISTEN_READER_FIELD:
857 ListenReaderField(c->arg[0]);
858 break;
859
860 case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
861 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
862 SpinDelay(200);
863 LED_D_OFF(); // LED D indicates field ON or OFF
864 break;
865
866 case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: {
867 // UsbCommand n;
868 // if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
869 // n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
870 // } else {
871 // n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
872 // }
873 // n.arg[0] = c->arg[0];
874 // memcpy(n.d.asBytes, BigBuf+c->arg[0], 48); // 12*sizeof(uint32_t)
875 // LED_B_ON();
876 // usb_write((uint8_t *)&n, sizeof(n));
877 // UsbSendPacket((uint8_t *)&n, sizeof(n));
878 // LED_B_OFF();
879
880 LED_B_ON();
881 for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
882 size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
883 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
884 }
885 // Trigger a finish downloading signal with an ACK frame
886 cmd_send(CMD_ACK,0,0,0,0,0);
887 LED_B_OFF();
888 } break;
889
890 case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
891 uint8_t *b = (uint8_t *)BigBuf;
892 memcpy(b+c->arg[0], c->d.asBytes, 48);
893 //Dbprintf("copied 48 bytes to %i",b+c->arg[0]);
894 // UsbSendPacket((uint8_t*)&ack, sizeof(ack));
895 cmd_send(CMD_ACK,0,0,0,0,0);
896 } break;
897
898 case CMD_READ_MEM:
899 ReadMem(c->arg[0]);
900 break;
901
902 case CMD_SET_LF_DIVISOR:
903 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->arg[0]);
904 break;
905
906 case CMD_SET_ADC_MUX:
907 switch(c->arg[0]) {
908 case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break;
909 case 1: SetAdcMuxFor(GPIO_MUXSEL_LORAW); break;
910 case 2: SetAdcMuxFor(GPIO_MUXSEL_HIPKD); break;
911 case 3: SetAdcMuxFor(GPIO_MUXSEL_HIRAW); break;
912 }
913 break;
914
915 case CMD_VERSION:
916 SendVersion();
917 break;
918
919 #ifdef WITH_LCD
920 case CMD_LCD_RESET:
921 LCDReset();
922 break;
923 case CMD_LCD:
924 LCDSend(c->arg[0]);
925 break;
926 #endif
927 case CMD_SETUP_WRITE:
928 case CMD_FINISH_WRITE:
929 case CMD_HARDWARE_RESET: {
930 usb_disable();
931 SpinDelay(1000);
932 SpinDelay(1000);
933 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
934 for(;;) {
935 // We're going to reset, and the bootrom will take control.
936 }
937 } break;
938
939 case CMD_START_FLASH: {
940 if(common_area.flags.bootrom_present) {
941 common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
942 }
943 usb_disable();
944 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
945 for(;;);
946 } break;
947
948 case CMD_DEVICE_INFO: {
949 uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
950 if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
951 // UsbSendPacket((uint8_t*)&c, sizeof(c));
952 cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
953 } break;
954
955 default: {
956 Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
957 } break;
958 }
959 }
960
961 void __attribute__((noreturn)) AppMain(void)
962 {
963 SpinDelay(100);
964
965 if(common_area.magic != COMMON_AREA_MAGIC || common_area.version != 1) {
966 /* Initialize common area */
967 memset(&common_area, 0, sizeof(common_area));
968 common_area.magic = COMMON_AREA_MAGIC;
969 common_area.version = 1;
970 }
971 common_area.flags.osimage_present = 1;
972
973 LED_D_OFF();
974 LED_C_OFF();
975 LED_B_OFF();
976 LED_A_OFF();
977
978 // Init USB device`
979 usb_enable();
980 // UsbStart();
981
982 // The FPGA gets its clock from us from PCK0 output, so set that up.
983 AT91C_BASE_PIOA->PIO_BSR = GPIO_PCK0;
984 AT91C_BASE_PIOA->PIO_PDR = GPIO_PCK0;
985 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_PCK0;
986 // PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
987 AT91C_BASE_PMC->PMC_PCKR[0] = AT91C_PMC_CSS_PLL_CLK |
988 AT91C_PMC_PRES_CLK_4;
989 AT91C_BASE_PIOA->PIO_OER = GPIO_PCK0;
990
991 // Reset SPI
992 AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
993 // Reset SSC
994 AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
995
996 // Load the FPGA image, which we have stored in our flash.
997 FpgaDownloadAndGo();
998
999 StartTickCount();
1000
1001 #ifdef WITH_LCD
1002 LCDInit();
1003 #endif
1004
1005 byte_t rx[sizeof(UsbCommand)];
1006 size_t rx_len;
1007
1008 for(;;) {
1009 if (usb_poll()) {
1010 rx_len = usb_read(rx,sizeof(UsbCommand));
1011 if (rx_len) {
1012 UsbPacketReceived(rx,rx_len);
1013 }
1014 }
1015 // UsbPoll(FALSE);
1016
1017 WDT_HIT();
1018
1019 #ifdef WITH_LF
1020 if (BUTTON_HELD(1000) > 0)
1021 SamyRun();
1022 #endif
1023 }
1024 }
Proxmark3 GIT tracking
Impressum, Datenschutz