]> cvs.zerfleddert.de Git - proxmark3-svn/blob - armsrc/appmain.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Made script-based default key check a bit more intelligent, so it works not only...
[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 ReadSTMemoryIso14443(0x0F);
748 break;
749 case CMD_READ_SRIX4K_TAG:
750 ReadSTMemoryIso14443(0x7F);
751 break;
752 case CMD_SNOOP_ISO_14443:
753 SnoopIso14443();
754 break;
755 case CMD_SIMULATE_TAG_ISO_14443:
756 SimulateIso14443Tag();
757 break;
758 case CMD_ISO_14443B_COMMAND:
759 SendRawCommand14443B(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
760 break;
761 #endif
762
763 #ifdef WITH_ISO14443a
764 case CMD_SNOOP_ISO_14443a:
765 SnoopIso14443a(c->arg[0]);
766 break;
767 case CMD_READER_ISO_14443a:
768 ReaderIso14443a(c);
769 break;
770 case CMD_SIMULATE_TAG_ISO_14443a:
771 SimulateIso14443aTag(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes); // ## Simulate iso14443a tag - pass tag type & UID
772 break;
773 case CMD_EPA_PACE_COLLECT_NONCE:
774 EPA_PACE_Collect_Nonce(c);
775 break;
776
777 case CMD_READER_MIFARE:
778 ReaderMifare(c->arg[0]);
779 break;
780 case CMD_MIFARE_READBL:
781 MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
782 break;
783 case CMD_MIFARE_READSC:
784 MifareReadSector(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
785 break;
786 case CMD_MIFARE_WRITEBL:
787 MifareWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
788 break;
789 case CMD_MIFARE_NESTED:
790 MifareNested(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
791 break;
792 case CMD_MIFARE_CHKKEYS:
793 MifareChkKeys(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
794 break;
795 case CMD_SIMULATE_MIFARE_CARD:
796 Mifare1ksim(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
797 break;
798
799 // emulator
800 case CMD_MIFARE_SET_DBGMODE:
801 MifareSetDbgLvl(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
802 break;
803 case CMD_MIFARE_EML_MEMCLR:
804 MifareEMemClr(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
805 break;
806 case CMD_MIFARE_EML_MEMSET:
807 MifareEMemSet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
808 break;
809 case CMD_MIFARE_EML_MEMGET:
810 MifareEMemGet(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
811 break;
812 case CMD_MIFARE_EML_CARDLOAD:
813 MifareECardLoad(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
814 break;
815
816 // Work with "magic Chinese" card
817 case CMD_MIFARE_EML_CSETBLOCK:
818 MifareCSetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
819 break;
820 case CMD_MIFARE_EML_CGETBLOCK:
821 MifareCGetBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
822 break;
823
824 // mifare sniffer
825 case CMD_MIFARE_SNIFFER:
826 SniffMifare(c->arg[0]);
827 break;
828 #endif
829
830 #ifdef WITH_ICLASS
831 // Makes use of ISO14443a FPGA Firmware
832 case CMD_SNOOP_ICLASS:
833 SnoopIClass();
834 break;
835 case CMD_SIMULATE_TAG_ICLASS:
836 SimulateIClass(c->arg[0], c->d.asBytes);
837 break;
838 case CMD_READER_ICLASS:
839 ReaderIClass(c->arg[0]);
840 break;
841 #endif
842
843 case CMD_SIMULATE_TAG_HF_LISTEN:
844 SimulateTagHfListen();
845 break;
846
847 case CMD_BUFF_CLEAR:
848 BufferClear();
849 break;
850
851 case CMD_MEASURE_ANTENNA_TUNING:
852 MeasureAntennaTuning();
853 break;
854
855 case CMD_MEASURE_ANTENNA_TUNING_HF:
856 MeasureAntennaTuningHf();
857 break;
858
859 case CMD_LISTEN_READER_FIELD:
860 ListenReaderField(c->arg[0]);
861 break;
862
863 case CMD_FPGA_MAJOR_MODE_OFF: // ## FPGA Control
864 FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
865 SpinDelay(200);
866 LED_D_OFF(); // LED D indicates field ON or OFF
867 break;
868
869 case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K:
870 // UsbCommand n;
871 // if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
872 // n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
873 // } else {
874 // n.cmd = CMD_DOWNLOADED_RAW_BITS_TI_TYPE;
875 // }
876 // n.arg[0] = c->arg[0];
877 // memcpy(n.d.asBytes, BigBuf+c->arg[0], 48); // 12*sizeof(uint32_t)
878 // LED_B_ON();
879 // usb_write((uint8_t *)&n, sizeof(n));
880 // UsbSendPacket((uint8_t *)&n, sizeof(n));
881 // LED_B_OFF();
882
883 LED_B_ON();
884 for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
885 size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
886 cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
887 }
888 // Trigger a finish downloading signal with an ACK frame
889 cmd_send(CMD_ACK,0,0,0,0,0);
890 LED_B_OFF();
891 break;
892
893 case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
894 uint8_t *b = (uint8_t *)BigBuf;
895 memcpy(b+c->arg[0], c->d.asBytes, 48);
896 //Dbprintf("copied 48 bytes to %i",b+c->arg[0]);
897 // UsbSendPacket((uint8_t*)&ack, sizeof(ack));
898 cmd_send(CMD_ACK,0,0,0,0,0);
899 break;
900 }
901 case CMD_READ_MEM:
902 ReadMem(c->arg[0]);
903 break;
904
905 case CMD_SET_LF_DIVISOR:
906 FpgaSendCommand(FPGA_CMD_SET_DIVISOR, c->arg[0]);
907 break;
908
909 case CMD_SET_ADC_MUX:
910 switch(c->arg[0]) {
911 case 0: SetAdcMuxFor(GPIO_MUXSEL_LOPKD); break;
912 case 1: SetAdcMuxFor(GPIO_MUXSEL_LORAW); break;
913 case 2: SetAdcMuxFor(GPIO_MUXSEL_HIPKD); break;
914 case 3: SetAdcMuxFor(GPIO_MUXSEL_HIRAW); break;
915 }
916 break;
917
918 case CMD_VERSION:
919 SendVersion();
920 break;
921
922 #ifdef WITH_LCD
923 case CMD_LCD_RESET:
924 LCDReset();
925 break;
926 case CMD_LCD:
927 LCDSend(c->arg[0]);
928 break;
929 #endif
930 case CMD_SETUP_WRITE:
931 case CMD_FINISH_WRITE:
932 case CMD_HARDWARE_RESET:
933 usb_disable();
934 SpinDelay(1000);
935 SpinDelay(1000);
936 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
937 for(;;) {
938 // We're going to reset, and the bootrom will take control.
939 }
940 break;
941
942 case CMD_START_FLASH:
943 if(common_area.flags.bootrom_present) {
944 common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
945 }
946 usb_disable();
947 AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
948 for(;;);
949 break;
950
951 case CMD_DEVICE_INFO: {
952 uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
953 if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
954 // UsbSendPacket((uint8_t*)&c, sizeof(c));
955 cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
956 break;
957 }
958 default:
959 Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
960 break;
961 }
962 }
963
964 void __attribute__((noreturn)) AppMain(void)
965 {
966 SpinDelay(100);
967
968 if(common_area.magic != COMMON_AREA_MAGIC || common_area.version != 1) {
969 /* Initialize common area */
970 memset(&common_area, 0, sizeof(common_area));
971 common_area.magic = COMMON_AREA_MAGIC;
972 common_area.version = 1;
973 }
974 common_area.flags.osimage_present = 1;
975
976 LED_D_OFF();
977 LED_C_OFF();
978 LED_B_OFF();
979 LED_A_OFF();
980
981 // Init USB device`
982 usb_enable();
983 // UsbStart();
984
985 // The FPGA gets its clock from us from PCK0 output, so set that up.
986 AT91C_BASE_PIOA->PIO_BSR = GPIO_PCK0;
987 AT91C_BASE_PIOA->PIO_PDR = GPIO_PCK0;
988 AT91C_BASE_PMC->PMC_SCER = AT91C_PMC_PCK0;
989 // PCK0 is PLL clock / 4 = 96Mhz / 4 = 24Mhz
990 AT91C_BASE_PMC->PMC_PCKR[0] = AT91C_PMC_CSS_PLL_CLK |
991 AT91C_PMC_PRES_CLK_4;
992 AT91C_BASE_PIOA->PIO_OER = GPIO_PCK0;
993
994 // Reset SPI
995 AT91C_BASE_SPI->SPI_CR = AT91C_SPI_SWRST;
996 // Reset SSC
997 AT91C_BASE_SSC->SSC_CR = AT91C_SSC_SWRST;
998
999 // Load the FPGA image, which we have stored in our flash.
1000 FpgaDownloadAndGo();
1001
1002 StartTickCount();
1003
1004 #ifdef WITH_LCD
1005 LCDInit();
1006 #endif
1007
1008 byte_t rx[sizeof(UsbCommand)];
1009 size_t rx_len;
1010
1011 for(;;) {
1012 if (usb_poll()) {
1013 rx_len = usb_read(rx,sizeof(UsbCommand));
1014 if (rx_len) {
1015 UsbPacketReceived(rx,rx_len);
1016 }
1017 }
1018 // UsbPoll(FALSE);
1019
1020 WDT_HIT();
1021
1022 #ifdef WITH_LF
1023 if (BUTTON_HELD(1000) > 0)
1024 SamyRun();
1025 #endif
1026 }
1027 }
Proxmark3 GIT tracking
Impressum, Datenschutz