]> git.zerfleddert.de Git - proxmark3-svn/blob - winsrc/command.cpp
projects / proxmark3-svn / blob
? search:


f947f45cfd1a470967e9ba5c35255ce0b1db85a9
[proxmark3-svn] / winsrc / command.cpp
1 //-----------------------------------------------------------------------------
2 // The actual command interpeter for what the user types at the command line.
3 // Jonathan Westhues, Sept 2005
4 // Edits by Gerhard de Koning Gans, Sep 2007 (##)
5 //-----------------------------------------------------------------------------
6 #include <windows.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <stdio.h>
10 #include <limits.h>
11 #include <math.h>
12
13 #include "prox.h"
14 #include "../common/iso14443_crc.c"
15
16 #define arraylen(x) (sizeof(x)/sizeof((x)[0]))
17
18 static int CmdHisamplest(char *str, int nrlow);
19
20 static void GetFromBigBuf(BYTE *dest, int bytes)
21 {
22 int n = bytes/4;
23
24 if(n % 48 != 0) {
25 PrintToScrollback("bad len in GetFromBigBuf");
26 return;
27 }
28
29 int i;
30 for(i = 0; i < n; i += 12) {
31 UsbCommand c;
32 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
33 c.ext1 = i;
34 SendCommand(&c, FALSE);
35 ReceiveCommand(&c);
36 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
37 PrintToScrollback("bad resp\n");
38 return;
39 }
40
41 memcpy(dest+(i*4), c.d.asBytes, 48);
42 }
43 }
44
45 static void CmdQuit(char *str)
46 {
47 exit(0);
48 }
49
50 static void CmdHIDdemodFSK(char *str)
51 {
52 UsbCommand c;
53 c.cmd = CMD_HID_DEMOD_FSK;
54 SendCommand(&c, FALSE);
55 }
56
57 static void CmdTune(char *str)
58 {
59 UsbCommand c;
60 c.cmd = CMD_MEASURE_ANTENNA_TUNING;
61 SendCommand(&c, FALSE);
62 }
63
64 static void CmdHi15read(char *str)
65 {
66 UsbCommand c;
67 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_15693;
68 SendCommand(&c, FALSE);
69 }
70
71 static void CmdHi14read(char *str)
72 {
73 UsbCommand c;
74 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;
75 c.ext1 = atoi(str);
76 SendCommand(&c, FALSE);
77 }
78
79 // ## New command
80 static void CmdHi14areader(char *str)
81 {
82 UsbCommand c;
83 c.cmd = CMD_READER_ISO_14443a;
84 c.ext1 = atoi(str);
85 SendCommand(&c, FALSE);
86 }
87
88 // ## New command
89 static void CmdHi15reader(char *str)
90 {
91 UsbCommand c;
92 c.cmd = CMD_READER_ISO_15693;
93 c.ext1 = atoi(str);
94 SendCommand(&c, FALSE);
95 }
96
97 // ## New command
98 static void CmdHi15tag(char *str)
99 {
100 UsbCommand c;
101 c.cmd = CMD_SIMTAG_ISO_15693;
102 c.ext1 = atoi(str);
103 SendCommand(&c, FALSE);
104 }
105
106 static void CmdHi14read_sim(char *str)
107 {
108 UsbCommand c;
109 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443_SIM;
110 c.ext1 = atoi(str);
111 SendCommand(&c, FALSE);
112 }
113
114 static void CmdHi14readt(char *str)
115 {
116 UsbCommand c;
117 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;
118 c.ext1 = atoi(str);
119 SendCommand(&c, FALSE);
120
121 //CmdHisamplest(str);
122 while(CmdHisamplest(str,atoi(str))==0) {
123 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_ISO_14443;
124 c.ext1 = atoi(str);
125 SendCommand(&c, FALSE);
126 }
127 RepaintGraphWindow();
128 }
129
130 static void CmdHisimlisten(char *str)
131 {
132 UsbCommand c;
133 c.cmd = CMD_SIMULATE_TAG_HF_LISTEN;
134 SendCommand(&c, FALSE);
135 }
136
137 static void CmdHi14sim(char *str)
138 {
139 UsbCommand c;
140 c.cmd = CMD_SIMULATE_TAG_ISO_14443;
141 SendCommand(&c, FALSE);
142 }
143
144
145
146 static void CmdHi14asim(char *str) // ## simulate iso14443a tag
147 { // ## greg - added ability to specify tag UID
148
149 unsigned int hi=0, lo=0;
150 int n=0, i=0;
151 UsbCommand c;
152
153 while (sscanf(&str[i++], "%1x", &n ) == 1) {
154 hi=(hi<<4)|(lo>>28);
155 lo=(lo<<4)|(n&0xf);
156 }
157
158 c.cmd = CMD_SIMULATE_TAG_ISO_14443a;
159 // c.ext should be set to *str or convert *str to the correct format for a uid
160 c.ext1 = hi;
161 c.ext2 = lo;
162 PrintToScrollback("Emulating 14443A TAG with UID %x%16x", hi, lo);
163 SendCommand(&c, FALSE);
164 }
165
166 static void CmdHi14snoop(char *str)
167 {
168 UsbCommand c;
169 c.cmd = CMD_SNOOP_ISO_14443;
170 SendCommand(&c, FALSE);
171 }
172
173 static void CmdHi14asnoop(char *str)
174 {
175 UsbCommand c;
176 c.cmd = CMD_SNOOP_ISO_14443a;
177 SendCommand(&c, FALSE);
178 }
179
180 static void CmdFPGAOff(char *str) // ## FPGA Control
181 {
182 UsbCommand c;
183 c.cmd = CMD_FPGA_MAJOR_MODE_OFF;
184 SendCommand(&c, FALSE);
185 }
186
187 static void CmdLosim(char *str)
188 {
189 int i;
190
191 for(i = 0; i < GraphTraceLen; i += 48) {
192 UsbCommand c;
193 int j;
194 for(j = 0; j < 48; j++) {
195 c.d.asBytes[j] = GraphBuffer[i+j];
196 }
197 c.cmd = CMD_DOWNLOADED_SIM_SAMPLES_125K;
198 c.ext1 = i;
199 SendCommand(&c, FALSE);
200 }
201
202 UsbCommand c;
203 c.cmd = CMD_SIMULATE_TAG_125K;
204 c.ext1 = GraphTraceLen;
205 SendCommand(&c, FALSE);
206 }
207
208 static void CmdLoread(char *str)
209 {
210 UsbCommand c;
211 // 'h' means higher-low-frequency, 134 kHz
212 if(*str == 'h') {
213 c.ext1 = 1;
214 } else if (*str == '\0') {
215 c.ext1 = 0;
216 } else {
217 PrintToScrollback("use 'loread' or 'loread h'");
218 return;
219 }
220 c.cmd = CMD_ACQUIRE_RAW_ADC_SAMPLES_125K;
221 SendCommand(&c, FALSE);
222 }
223
224 static void CmdLosamples(char *str)
225 {
226 int cnt = 0;
227 int i;
228 int n;
229
230 n=atoi(str);
231 if (n==0) n=128;
232 if (n>16000) n=16000;
233
234 for(i = 0; i < n; i += 12) {
235 UsbCommand c;
236 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
237 c.ext1 = i;
238 SendCommand(&c, FALSE);
239 ReceiveCommand(&c);
240 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
241 PrintToScrollback("bad resp\n");
242 return;
243 }
244 int j;
245 for(j = 0; j < 48; j++) {
246 GraphBuffer[cnt++] = ((int)c.d.asBytes[j]) - 128;
247 }
248 }
249 GraphTraceLen = n*4;
250 RepaintGraphWindow();
251 }
252
253 static void CmdBitsamples(char *str)
254 {
255 int cnt = 0;
256 int i;
257 int n;
258
259 n = 3072;
260 for(i = 0; i < n; i += 12) {
261 UsbCommand c;
262 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
263 c.ext1 = i;
264 SendCommand(&c, FALSE);
265 ReceiveCommand(&c);
266 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
267 PrintToScrollback("bad resp\n");
268 return;
269 }
270 int j, k;
271 for(j = 0; j < 48; j++) {
272 for(k = 0; k < 8; k++) {
273 if(c.d.asBytes[j] & (1 << (7 - k))) {
274 GraphBuffer[cnt++] = 1;
275 } else {
276 GraphBuffer[cnt++] = 0;
277 }
278 }
279 }
280 }
281 GraphTraceLen = cnt;
282 RepaintGraphWindow();
283 }
284
285 static void CmdHisamples(char *str)
286 {
287 int cnt = 0;
288 int i;
289 int n;
290 n = 1000;
291 for(i = 0; i < n; i += 12) {
292 UsbCommand c;
293 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
294 c.ext1 = i;
295 SendCommand(&c, FALSE);
296 ReceiveCommand(&c);
297 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
298 PrintToScrollback("bad resp\n");
299 return;
300 }
301 int j;
302 for(j = 0; j < 48; j++) {
303 GraphBuffer[cnt++] = (int)((BYTE)c.d.asBytes[j]);
304 }
305 }
306 GraphTraceLen = n*4;
307
308 RepaintGraphWindow();
309 }
310
311
312 static int CmdHisamplest(char *str, int nrlow)
313 {
314 int cnt = 0;
315 int t1, t2;
316 int i;
317 int n;
318 int hasbeennull;
319 int show;
320
321
322 n = 1000;
323 hasbeennull = 0;
324 for(i = 0; i < n; i += 12) {
325 UsbCommand c;
326 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
327 c.ext1 = i;
328 SendCommand(&c, FALSE);
329 ReceiveCommand(&c);
330 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
331 PrintToScrollback("bad resp\n");
332 return 0;
333 }
334 int j;
335 for(j = 0; j < 48; j++) {
336 t2 = (int)((BYTE)c.d.asBytes[j]);
337 if((t2 ^ 0xC0) & 0xC0) { hasbeennull++; }
338
339 show = 0;
340 switch(show) {
341 case 0:
342 // combined
343 t1 = (t2 & 0x80) ^ (t2 & 0x20);
344 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x20);
345 break;
346
347 case 1:
348 // only reader
349 t1 = (t2 & 0x80);
350 t2 = ((t2 << 1) & 0x80);
351 break;
352
353 case 2:
354 // only tag
355 t1 = (t2 & 0x20);
356 t2 = ((t2 << 1) & 0x20);
357 break;
358
359 case 3:
360 // both, but tag with other algorithm
361 t1 = (t2 & 0x80) ^ (t2 & 0x08);
362 t2 = ((t2 << 1) & 0x80) ^ ((t2 << 1) & 0x08);
363 break;
364 }
365
366 GraphBuffer[cnt++] = t1;
367 GraphBuffer[cnt++] = t2;
368 }
369 }
370 GraphTraceLen = n*4;
371 // 1130
372 if(hasbeennull>nrlow || nrlow==0) {
373 PrintToScrollback("hasbeennull=%d", hasbeennull);
374 return 1;
375 }
376 else {
377 return 0;
378 }
379 }
380
381
382 static void CmdHexsamples(char *str)
383 {
384 int i;
385 int n;
386
387 if(atoi(str) == 0) {
388 n = 12;
389 } else {
390 n = atoi(str)/4;
391 }
392
393 for(i = 0; i < n; i += 12) {
394 UsbCommand c;
395 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
396 c.ext1 = i;
397 SendCommand(&c, FALSE);
398 ReceiveCommand(&c);
399 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
400 PrintToScrollback("bad resp\n");
401 return;
402 }
403 int j;
404 for(j = 0; j < 48; j += 8) {
405 PrintToScrollback("%02x %02x %02x %02x %02x %02x %02x %02x",
406 c.d.asBytes[j+0],
407 c.d.asBytes[j+1],
408 c.d.asBytes[j+2],
409 c.d.asBytes[j+3],
410 c.d.asBytes[j+4],
411 c.d.asBytes[j+5],
412 c.d.asBytes[j+6],
413 c.d.asBytes[j+7],
414 c.d.asBytes[j+8]
415 );
416 }
417 }
418 }
419
420 static void CmdHisampless(char *str)
421 {
422 int cnt = 0;
423 int i;
424 int n;
425
426 if(atoi(str) == 0) {
427 n = 1000;
428 } else {
429 n = atoi(str)/4;
430 }
431
432 for(i = 0; i < n; i += 12) {
433 UsbCommand c;
434 c.cmd = CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K;
435 c.ext1 = i;
436 SendCommand(&c, FALSE);
437 ReceiveCommand(&c);
438 if(c.cmd != CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K) {
439 PrintToScrollback("bad resp\n");
440 return;
441 }
442 int j;
443 for(j = 0; j < 48; j++) {
444 GraphBuffer[cnt++] = (int)((signed char)c.d.asBytes[j]);
445 }
446 }
447 GraphTraceLen = cnt;
448
449 RepaintGraphWindow();
450 }
451
452 static WORD Iso15693Crc(BYTE *v, int n)
453 {
454 DWORD reg;
455 int i, j;
456
457 reg = 0xffff;
458 for(i = 0; i < n; i++) {
459 reg = reg ^ ((DWORD)v[i]);
460 for (j = 0; j < 8; j++) {
461 if (reg & 0x0001) {
462 reg = (reg >> 1) ^ 0x8408;
463 } else {
464 reg = (reg >> 1);
465 }
466 }
467 }
468
469 return (WORD)~reg;
470 }
471
472 static void CmdHi14bdemod(char *str)
473 {
474 int i, j, iold;
475 int isum, qsum;
476 int outOfWeakAt;
477 BOOL negateI, negateQ;
478
479 BYTE data[256];
480 int dataLen=0;
481
482 // As received, the samples are pairs, correlations against I and Q
483 // square waves. So estimate angle of initial carrier (or just
484 // quadrant, actually), and then do the demod.
485
486 // First, estimate where the tag starts modulating.
487 for(i = 0; i < GraphTraceLen; i += 2) {
488 if(abs(GraphBuffer[i]) + abs(GraphBuffer[i+1]) > 40) {
489 break;
490 }
491 }
492 if(i >= GraphTraceLen) {
493 PrintToScrollback("too weak to sync");
494 return;
495 }
496 PrintToScrollback("out of weak at %d", i);
497 outOfWeakAt = i;
498
499 // Now, estimate the phase in the initial modulation of the tag
500 isum = 0;
501 qsum = 0;
502 for(; i < (outOfWeakAt + 16); i += 2) {
503 isum += GraphBuffer[i+0];
504 qsum += GraphBuffer[i+1];
505 }
506 negateI = (isum < 0);
507 negateQ = (qsum < 0);
508
509 // Turn the correlation pairs into soft decisions on the bit.
510 j = 0;
511 for(i = 0; i < GraphTraceLen/2; i++) {
512 int si = GraphBuffer[j];
513 int sq = GraphBuffer[j+1];
514 if(negateI) si = -si;
515 if(negateQ) sq = -sq;
516 GraphBuffer[i] = si + sq;
517 j += 2;
518 }
519 GraphTraceLen = i;
520
521 i = outOfWeakAt/2;
522 while(GraphBuffer[i] > 0 && i < GraphTraceLen)
523 i++;
524 if(i >= GraphTraceLen) goto demodError;
525
526 iold = i;
527 while(GraphBuffer[i] < 0 && i < GraphTraceLen)
528 i++;
529 if(i >= GraphTraceLen) goto demodError;
530 if((i - iold) > 23) goto demodError;
531
532 PrintToScrollback("make it to demod loop");
533
534 for(;;) {
535 iold = i;
536 while(GraphBuffer[i] >= 0 && i < GraphTraceLen)
537 i++;
538 if(i >= GraphTraceLen) goto demodError;
539 if((i - iold) > 6) goto demodError;
540
541 WORD shiftReg = 0;
542 if(i + 20 >= GraphTraceLen) goto demodError;
543
544 for(j = 0; j < 10; j++) {
545 int soft = GraphBuffer[i] + GraphBuffer[i+1];
546
547 if(abs(soft) < ((abs(isum) + abs(qsum))/20)) {
548 PrintToScrollback("weak bit");
549 }
550
551 shiftReg >>= 1;
552 if(GraphBuffer[i] + GraphBuffer[i+1] >= 0) {
553 shiftReg |= 0x200;
554 }
555
556 i+= 2;
557 }
558
559 if( (shiftReg & 0x200) &&
560 !(shiftReg & 0x001))
561 {
562 // valid data byte, start and stop bits okay
563 PrintToScrollback(" %02x", (shiftReg >> 1) & 0xff);
564 data[dataLen++] = (shiftReg >> 1) & 0xff;
565 if(dataLen >= sizeof(data)) {
566 return;
567 }
568 } else if(shiftReg == 0x000) {
569 // this is EOF
570 break;
571 } else {
572 goto demodError;
573 }
574 }
575
576 BYTE first, second;
577 ComputeCrc14443(CRC_14443_B, data, dataLen-2, &first, &second);
578 PrintToScrollback("CRC: %02x %02x (%s)\n", first, second,
579 (first == data[dataLen-2] && second == data[dataLen-1]) ?
580 "ok" : "****FAIL****");
581
582 RepaintGraphWindow();
583 return;
584
585 demodError:
586 PrintToScrollback("demod error");
587 RepaintGraphWindow();
588 }
589
590 static void CmdHi14list(char *str)
591 {
592 BYTE got[960];
593 GetFromBigBuf(got, sizeof(got));
594
595 PrintToScrollback("recorded activity:");
596 PrintToScrollback(" time :rssi: who bytes");
597 PrintToScrollback("---------+----+----+-----------");
598
599 int i = 0;
600 int prev = -1;
601
602 for(;;) {
603 if(i >= 900) {
604 break;
605 }
606
607 BOOL isResponse;
608 int timestamp = *((DWORD *)(got+i));
609 if(timestamp & 0x80000000) {
610 timestamp &= 0x7fffffff;
611 isResponse = 1;
612 } else {
613 isResponse = 0;
614 }
615 int metric = *((DWORD *)(got+i+4));
616
617 int len = got[i+8];
618
619 if(len > 100) {
620 break;
621 }
622 if(i + len >= 900) {
623 break;
624 }
625
626 BYTE *frame = (got+i+9);
627
628 char line[1000] = "";
629 int j;
630 for(j = 0; j < len; j++) {
631 sprintf(line+(j*3), "%02x ", frame[j]);
632 }
633
634 char *crc;
635 if(len > 2) {
636 BYTE b1, b2;
637 ComputeCrc14443(CRC_14443_B, frame, len-2, &b1, &b2);
638 if(b1 != frame[len-2] || b2 != frame[len-1]) {
639 crc = "**FAIL CRC**";
640 } else {
641 crc = "";
642 }
643 } else {
644 crc = "(SHORT)";
645 }
646
647 char metricString[100];
648 if(isResponse) {
649 sprintf(metricString, "%3d", metric);
650 } else {
651 strcpy(metricString, " ");
652 }
653
654 PrintToScrollback(" +%7d: %s: %s %s %s",
655 (prev < 0 ? 0 : timestamp - prev),
656 metricString,
657 (isResponse ? "TAG" : " "), line, crc);
658
659 prev = timestamp;
660 i += (len + 9);
661 }
662 }
663
664 static void CmdHi14alist(char *str)
665 {
666 BYTE got[1920];
667 GetFromBigBuf(got, sizeof(got));
668
669 PrintToScrollback("recorded activity:");
670 PrintToScrollback(" ETU :rssi: who bytes");
671 PrintToScrollback("---------+----+----+-----------");
672
673 int i = 0;
674 int prev = -1;
675
676 for(;;) {
677 if(i >= 1900) {
678 break;
679 }
680
681 BOOL isResponse;
682 int timestamp = *((DWORD *)(got+i));
683 if(timestamp & 0x80000000) {
684 timestamp &= 0x7fffffff;
685 isResponse = 1;
686 } else {
687 isResponse = 0;
688 }
689
690 int metric = 0;
691 int parityBits = *((DWORD *)(got+i+4));
692 // 4 bytes of additional information...
693 // maximum of 32 additional parity bit information
694 //
695 // TODO:
696 // at each quarter bit period we can send power level (16 levels)
697 // or each half bit period in 256 levels.
698
699
700 int len = got[i+8];
701
702 if(len > 100) {
703 break;
704 }
705 if(i + len >= 1900) {
706 break;
707 }
708
709 BYTE *frame = (got+i+9);
710
711 // Break and stick with current result if buffer was not completely full
712 if(frame[0] == 0x44 && frame[1] == 0x44 && frame[3] == 0x44) { break; }
713
714 char line[1000] = "";
715 int j;
716 for(j = 0; j < len; j++) {
717 int oddparity = 0x01;
718 int k;
719
720 for(k=0;k<8;k++) {
721 oddparity ^= (((frame[j] & 0xFF) >> k) & 0x01);
722 }
723
724 //if((parityBits >> (len - j - 1)) & 0x01) {
725 if(isResponse && (oddparity != ((parityBits >> (len - j - 1)) & 0x01))) {
726 sprintf(line+(j*4), "%02x! ", frame[j]);
727 }
728 else {
729 sprintf(line+(j*4), "%02x ", frame[j]);
730 }
731 }
732
733 char *crc;
734 crc = "";
735 if(len > 2) {
736 BYTE b1, b2;
737 for(j = 0; j < (len - 1); j++) {
738 // gives problems... search for the reason..
739 /*if(frame[j] == 0xAA) {
740 switch(frame[j+1]) {
741 case 0x01:
742 crc = "[1] Two drops close after each other";
743 break;
744 case 0x02:
745 crc = "[2] Potential SOC with a drop in second half of bitperiod";
746 break;
747 case 0x03:
748 crc = "[3] Segment Z after segment X is not possible";
749 break;
750 case 0x04:
751 crc = "[4] Parity bit of a fully received byte was wrong";
752 break;
753 default:
754 crc = "[?] Unknown error";
755 break;
756 }
757 break;
758 }*/
759 }
760
761 if(strlen(crc)==0) {
762 ComputeCrc14443(CRC_14443_A, frame, len-2, &b1, &b2);
763 if(b1 != frame[len-2] || b2 != frame[len-1]) {
764 crc = (isResponse & (len < 6)) ? "" : " !crc";
765 } else {
766 crc = "";
767 }
768 }
769 } else {
770 crc = ""; // SHORT
771 }
772
773 char metricString[100];
774 if(isResponse) {
775 sprintf(metricString, "%3d", metric);
776 } else {
777 strcpy(metricString, " ");
778 }
779
780 PrintToScrollback(" +%7d: %s: %s %s %s",
781 (prev < 0 ? 0 : (timestamp - prev)),
782 metricString,
783 (isResponse ? "TAG" : " "), line, crc);
784
785 prev = timestamp;
786 i += (len + 9);
787 }
788 CommandFinished = 1;
789 }
790
791 static void CmdHi15demod(char *str)
792 {
793 // The sampling rate is 106.353 ksps/s, for T = 18.8 us
794
795 // SOF defined as
796 // 1) Unmodulated time of 56.64us
797 // 2) 24 pulses of 423.75khz
798 // 3) logic '1' (unmodulated for 18.88us followed by 8 pulses of 423.75khz)
799
800 static const int FrameSOF[] = {
801 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
802 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
803 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
804 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
805 -1, -1, -1, -1,
806 -1, -1, -1, -1,
807 1, 1, 1, 1,
808 1, 1, 1, 1
809 };
810 static const int Logic0[] = {
811 1, 1, 1, 1,
812 1, 1, 1, 1,
813 -1, -1, -1, -1,
814 -1, -1, -1, -1
815 };
816 static const int Logic1[] = {
817 -1, -1, -1, -1,
818 -1, -1, -1, -1,
819 1, 1, 1, 1,
820 1, 1, 1, 1
821 };
822
823 // EOF defined as
824 // 1) logic '0' (8 pulses of 423.75khz followed by unmodulated for 18.88us)
825 // 2) 24 pulses of 423.75khz
826 // 3) Unmodulated time of 56.64us
827
828 static const int FrameEOF[] = {
829 1, 1, 1, 1,
830 1, 1, 1, 1,
831 -1, -1, -1, -1,
832 -1, -1, -1, -1,
833 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
834 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
837 };
838
839 int i, j;
840 int max = 0, maxPos;
841
842 int skip = 4;
843
844 if(GraphTraceLen < 1000) return;
845
846 // First, correlate for SOF
847 for(i = 0; i < 100; i++) {
848 int corr = 0;
849 for(j = 0; j < arraylen(FrameSOF); j += skip) {
850 corr += FrameSOF[j]*GraphBuffer[i+(j/skip)];
851 }
852 if(corr > max) {
853 max = corr;
854 maxPos = i;
855 }
856 }
857 PrintToScrollback("SOF at %d, correlation %d", maxPos,
858 max/(arraylen(FrameSOF)/skip));
859
860 i = maxPos + arraylen(FrameSOF)/skip;
861 int k = 0;
862 BYTE outBuf[20];
863 memset(outBuf, 0, sizeof(outBuf));
864 BYTE mask = 0x01;
865 for(;;) {
866 int corr0 = 0, corr1 = 0, corrEOF = 0;
867 for(j = 0; j < arraylen(Logic0); j += skip) {
868 corr0 += Logic0[j]*GraphBuffer[i+(j/skip)];
869 }
870 for(j = 0; j < arraylen(Logic1); j += skip) {
871 corr1 += Logic1[j]*GraphBuffer[i+(j/skip)];
872 }
873 for(j = 0; j < arraylen(FrameEOF); j += skip) {
874 corrEOF += FrameEOF[j]*GraphBuffer[i+(j/skip)];
875 }
876 // Even things out by the length of the target waveform.
877 corr0 *= 4;
878 corr1 *= 4;
879
880 if(corrEOF > corr1 && corrEOF > corr0) {
881 PrintToScrollback("EOF at %d", i);
882 break;
883 } else if(corr1 > corr0) {
884 i += arraylen(Logic1)/skip;
885 outBuf[k] |= mask;
886 } else {
887 i += arraylen(Logic0)/skip;
888 }
889 mask <<= 1;
890 if(mask == 0) {
891 k++;
892 mask = 0x01;
893 }
894 if((i+(int)arraylen(FrameEOF)) >= GraphTraceLen) {
895 PrintToScrollback("ran off end!");
896 break;
897 }
898 }
899 if(mask != 0x01) {
900 PrintToScrollback("error, uneven octet! (discard extra bits!)");
901 PrintToScrollback(" mask=%02x", mask);
902 }
903 PrintToScrollback("%d octets", k);
904
905 for(i = 0; i < k; i++) {
906 PrintToScrollback("# %2d: %02x ", i, outBuf[i]);
907 }
908 PrintToScrollback("CRC=%04x", Iso15693Crc(outBuf, k-2));
909 }
910
911 static void CmdTiread(char *str)
912 {
913 UsbCommand c;
914 c.cmd = CMD_ACQUIRE_RAW_BITS_TI_TYPE;
915 SendCommand(&c, FALSE);
916 }
917
918 static void CmdTibits(char *str)
919 {
920 int cnt = 0;
921 int i;
922 for(i = 0; i < 1536; i += 12) {
923 UsbCommand c;
924 c.cmd = CMD_DOWNLOAD_RAW_BITS_TI_TYPE;
925 c.ext1 = i;
926 SendCommand(&c, FALSE);
927 ReceiveCommand(&c);
928 if(c.cmd != CMD_DOWNLOADED_RAW_BITS_TI_TYPE) {
929 PrintToScrollback("bad resp\n");
930 return;
931 }
932 int j;
933 for(j = 0; j < 12; j++) {
934 int k;
935 for(k = 31; k >= 0; k--) {
936 if(c.d.asDwords[j] & (1 << k)) {
937 GraphBuffer[cnt++] = 1;
938 } else {
939 GraphBuffer[cnt++] = -1;
940 }
941 }
942 }
943 }
944 GraphTraceLen = 1536*32;
945 RepaintGraphWindow();
946 }
947
948 static void CmdTidemod(char *cmdline)
949 {
950 /* MATLAB as follows:
951 f_s = 2000000; % sampling frequency
952 f_l = 123200; % low FSK tone
953 f_h = 134200; % high FSK tone
954
955 T_l = 119e-6; % low bit duration
956 T_h = 130e-6; % high bit duration
957
958 l = 2*pi*ones(1, floor(f_s*T_l))*(f_l/f_s);
959 h = 2*pi*ones(1, floor(f_s*T_h))*(f_h/f_s);
960
961 l = sign(sin(cumsum(l)));
962 h = sign(sin(cumsum(h)));
963 */
964 static const int LowTone[] = {
965 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1,
966 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
967 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1,
968 -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1,
969 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1,
970 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1,
971 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1,
972 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
973 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1,
974 -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1,
975 -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1,
976 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1,
977 1, 1, 1, 1, 1, 1, 1, -1, -1, -1,
978 };
979 static const int HighTone[] = {
980 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
981 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
982 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
983 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1,
984 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
985 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
986 -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
987 -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1,
988 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
989 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1,
990 -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
991 -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1,
992 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1,
993 1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1,
994 };
995
996 int convLen = max(arraylen(HighTone), arraylen(LowTone));
997
998 int i;
999 for(i = 0; i < GraphTraceLen - convLen; i++) {
1000 int j;
1001 int lowSum = 0, highSum = 0;;
1002 int lowLen = arraylen(LowTone);
1003 int highLen = arraylen(HighTone);
1004
1005 for(j = 0; j < lowLen; j++) {
1006 lowSum += LowTone[j]*GraphBuffer[i+j];
1007 }
1008 for(j = 0; j < highLen; j++) {
1009 highSum += HighTone[j]*GraphBuffer[i+j];
1010 }
1011 lowSum = abs((100*lowSum) / lowLen);
1012 highSum = abs((100*highSum) / highLen);
1013 GraphBuffer[i] = (highSum << 16) | lowSum;
1014 }
1015
1016 for(i = 0; i < GraphTraceLen - convLen - 16; i++) {
1017 int j;
1018 int lowTot = 0, highTot = 0;
1019 // 16 and 15 are f_s divided by f_l and f_h, rounded
1020 for(j = 0; j < 16; j++) {
1021 lowTot += (GraphBuffer[i+j] & 0xffff);
1022 }
1023 for(j = 0; j < 15; j++) {
1024 highTot += (GraphBuffer[i+j] >> 16);
1025 }
1026 GraphBuffer[i] = lowTot - highTot;
1027 }
1028
1029 GraphTraceLen -= (convLen + 16);
1030
1031 RepaintGraphWindow();
1032
1033 // Okay, so now we have unsliced soft decisions; find bit-sync, and then
1034 // get some bits.
1035
1036 int max = 0, maxPos = 0;
1037 for(i = 0; i < 6000; i++) {
1038 int j;
1039 int dec = 0;
1040 for(j = 0; j < 8*arraylen(LowTone); j++) {
1041 dec -= GraphBuffer[i+j];
1042 }
1043 for(; j < 8*arraylen(LowTone) + 8*arraylen(HighTone); j++) {
1044 dec += GraphBuffer[i+j];
1045 }
1046 if(dec > max) {
1047 max = dec;
1048 maxPos = i;
1049 }
1050 }
1051 GraphBuffer[maxPos] = 800;
1052 GraphBuffer[maxPos+1] = -800;
1053
1054 maxPos += 8*arraylen(LowTone);
1055 GraphBuffer[maxPos] = 800;
1056 GraphBuffer[maxPos+1] = -800;
1057 maxPos += 8*arraylen(HighTone);
1058
1059 GraphBuffer[maxPos] = 800;
1060 GraphBuffer[maxPos+1] = -800;
1061
1062 PrintToScrollback("actual data bits start at sample %d", maxPos);
1063
1064 PrintToScrollback("length %d/%d", arraylen(HighTone), arraylen(LowTone));
1065
1066 GraphBuffer[maxPos] = 800;
1067 GraphBuffer[maxPos+1] = -800;
1068
1069 BYTE bits[64+16+8+1];
1070 bits[sizeof(bits)-1] = '\0';
1071
1072 for(i = 0; i < arraylen(bits); i++) {
1073 int high = 0;
1074 int low = 0;
1075 int j;
1076 for(j = 0; j < arraylen(LowTone); j++) {
1077 low -= GraphBuffer[maxPos+j];
1078 }
1079 for(j = 0; j < arraylen(HighTone); j++) {
1080 high += GraphBuffer[maxPos+j];
1081 }
1082 if(high > low) {
1083 bits[i] = '1';
1084 maxPos += arraylen(HighTone);
1085 } else {
1086 bits[i] = '.';
1087 maxPos += arraylen(LowTone);
1088 }
1089 GraphBuffer[maxPos] = 800;
1090 GraphBuffer[maxPos+1] = -800;
1091 }
1092 PrintToScrollback("bits: '%s'", bits);
1093
1094 DWORD h = 0, l = 0;
1095 for(i = 0; i < 32; i++) {
1096 if(bits[i] == '1') {
1097 l |= (1<<i);
1098 }
1099 }
1100 for(i = 32; i < 64; i++) {
1101 if(bits[i] == '1') {
1102 h |= (1<<(i-32));
1103 }
1104 }
1105 PrintToScrollback("hex: %08x %08x", h, l);
1106 }
1107
1108 static void CmdNorm(char *str)
1109 {
1110 int i;
1111 int max = INT_MIN, min = INT_MAX;
1112 for(i = 10; i < GraphTraceLen; i++) {
1113 if(GraphBuffer[i] > max) {
1114 max = GraphBuffer[i];
1115 }
1116 if(GraphBuffer[i] < min) {
1117 min = GraphBuffer[i];
1118 }
1119 }
1120 if(max != min) {
1121 for(i = 0; i < GraphTraceLen; i++) {
1122 GraphBuffer[i] = (GraphBuffer[i] - ((max + min)/2))*1000/
1123 (max - min);
1124 }
1125 }
1126 RepaintGraphWindow();
1127 }
1128
1129 static void CmdDec(char *str)
1130 {
1131 int i;
1132 for(i = 0; i < (GraphTraceLen/2); i++) {
1133 GraphBuffer[i] = GraphBuffer[i*2];
1134 }
1135 GraphTraceLen /= 2;
1136 PrintToScrollback("decimated by 2");
1137 RepaintGraphWindow();
1138 }
1139
1140 static void CmdHpf(char *str)
1141 {
1142 int i;
1143 int accum = 0;
1144 for(i = 10; i < GraphTraceLen; i++) {
1145 accum += GraphBuffer[i];
1146 }
1147 accum /= (GraphTraceLen - 10);
1148 for(i = 0; i < GraphTraceLen; i++) {
1149 GraphBuffer[i] -= accum;
1150 }
1151
1152 RepaintGraphWindow();
1153 }
1154
1155 static void CmdZerocrossings(char *str)
1156 {
1157 int i;
1158 // Zero-crossings aren't meaningful unless the signal is zero-mean.
1159 CmdHpf("");
1160
1161 int sign = 1;
1162 int zc = 0;
1163 int lastZc = 0;
1164 for(i = 0; i < GraphTraceLen; i++) {
1165 if(GraphBuffer[i]*sign >= 0) {
1166 // No change in sign, reproduce the previous sample count.
1167 zc++;
1168 GraphBuffer[i] = lastZc;
1169 } else {
1170 // Change in sign, reset the sample count.
1171 sign = -sign;
1172 GraphBuffer[i] = lastZc;
1173 if(sign > 0) {
1174 lastZc = zc;
1175 zc = 0;
1176 }
1177 }
1178 }
1179
1180 RepaintGraphWindow();
1181 }
1182
1183 static void CmdLtrim(char *str)
1184 {
1185 int i;
1186 int ds = atoi(str);
1187
1188 for(i = ds; i < GraphTraceLen; i++) {
1189 GraphBuffer[i-ds] = GraphBuffer[i];
1190 }
1191 GraphTraceLen -= ds;
1192
1193 RepaintGraphWindow();
1194 }
1195
1196 static void CmdAutoCorr(char *str)
1197 {
1198 static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];
1199
1200 int window = atoi(str);
1201
1202 if(window == 0) {
1203 PrintToScrollback("needs a window");
1204 return;
1205 }
1206
1207 if(window >= GraphTraceLen) {
1208 PrintToScrollback("window must be smaller than trace (%d samples)",
1209 GraphTraceLen);
1210 return;
1211 }
1212
1213 PrintToScrollback("performing %d correlations", GraphTraceLen - window);
1214
1215 int i;
1216 for(i = 0; i < GraphTraceLen - window; i++) {
1217 int sum = 0;
1218 int j;
1219 for(j = 0; j < window; j++) {
1220 sum += (GraphBuffer[j]*GraphBuffer[i+j]) / 256;
1221 }
1222 CorrelBuffer[i] = sum;
1223 }
1224 GraphTraceLen = GraphTraceLen - window;
1225 memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen*sizeof(int));
1226
1227 RepaintGraphWindow();
1228 }
1229
1230 static void CmdVchdemod(char *str)
1231 {
1232 // Is this the entire sync pattern, or does this also include some
1233 // data bits that happen to be the same everywhere? That would be
1234 // lovely to know.
1235 static const int SyncPattern[] = {
1236 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1237 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1238 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1239 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1240 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1241 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1242 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1243 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1244 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1245 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1246 };
1247
1248 // So first, we correlate for the sync pattern, and mark that.
1249 int bestCorrel = 0, bestPos = 0;
1250 int i;
1251 // It does us no good to find the sync pattern, with fewer than
1252 // 2048 samples after it...
1253 for(i = 0; i < (GraphTraceLen-2048); i++) {
1254 int sum = 0;
1255 int j;
1256 for(j = 0; j < arraylen(SyncPattern); j++) {
1257 sum += GraphBuffer[i+j]*SyncPattern[j];
1258 }
1259 if(sum > bestCorrel) {
1260 bestCorrel = sum;
1261 bestPos = i;
1262 }
1263 }
1264 PrintToScrollback("best sync at %d [metric %d]", bestPos, bestCorrel);
1265
1266 char bits[257];
1267 bits[256] = '\0';
1268
1269 int worst = INT_MAX;
1270 int worstPos;
1271
1272 for(i = 0; i < 2048; i += 8) {
1273 int sum = 0;
1274 int j;
1275 for(j = 0; j < 8; j++) {
1276 sum += GraphBuffer[bestPos+i+j];
1277 }
1278 if(sum < 0) {
1279 bits[i/8] = '.';
1280 } else {
1281 bits[i/8] = '1';
1282 }
1283 if(abs(sum) < worst) {
1284 worst = abs(sum);
1285 worstPos = i;
1286 }
1287 }
1288 PrintToScrollback("bits:");
1289 PrintToScrollback("%s", bits);
1290 PrintToScrollback("worst metric: %d at pos %d", worst, worstPos);
1291
1292 if(strcmp(str, "clone")==0) {
1293 GraphTraceLen = 0;
1294 char *s;
1295 for(s = bits; *s; s++) {
1296 int j;
1297 for(j = 0; j < 16; j++) {
1298 GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0;
1299 }
1300 }
1301 RepaintGraphWindow();
1302 }
1303 }
1304
1305 static void CmdIndalademod(char *str)
1306 {
1307 // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID
1308
1309 int state = -1;
1310 int count = 0;
1311 int i, j;
1312 // worst case with GraphTraceLen=64000 is < 4096
1313 // under normal conditions it's < 2048
1314 BYTE rawbits[4096];
1315 int rawbit = 0;
1316 int worst = 0, worstPos = 0;
1317 PrintToScrollback("Expecting a bit less than %d raw bits", GraphTraceLen/32);
1318 for(i = 0; i < GraphTraceLen-1; i += 2) {
1319 count+=1;
1320 if((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) {
1321 if (state == 0) {
1322 for(j = 0; j < count - 8; j += 16) {
1323 rawbits[rawbit++] = 0;
1324 }
1325 if ((abs(count - j)) > worst) {
1326 worst = abs(count - j);
1327 worstPos = i;
1328 }
1329 }
1330 state = 1;
1331 count=0;
1332 } else if((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) {
1333 if (state == 1) {
1334 for(j = 0; j < count - 8; j += 16) {
1335 rawbits[rawbit++] = 1;
1336 }
1337 if ((abs(count - j)) > worst) {
1338 worst = abs(count - j);
1339 worstPos = i;
1340 }
1341 }
1342 state = 0;
1343 count=0;
1344 }
1345 }
1346 PrintToScrollback("Recovered %d raw bits", rawbit);
1347 PrintToScrollback("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos);
1348
1349 // Finding the start of a UID
1350 int uidlen, long_wait;
1351 if(strcmp(str, "224") == 0) {
1352 uidlen=224;
1353 long_wait=30;
1354 } else {
1355 uidlen=64;
1356 long_wait=29;
1357 }
1358 int start;
1359 int first = 0;
1360 for(start = 0; start <= rawbit - uidlen; start++) {
1361 first = rawbits[start];
1362 for(i = start; i < start + long_wait; i++) {
1363 if(rawbits[i] != first) {
1364 break;
1365 }
1366 }
1367 if(i == (start + long_wait)) {
1368 break;
1369 }
1370 }
1371 if(start == rawbit - uidlen + 1) {
1372 PrintToScrollback("nothing to wait for");
1373 return;
1374 }
1375
1376 // Inverting signal if needed
1377 if(first == 1) {
1378 for(i = start; i < rawbit; i++) {
1379 rawbits[i] = !rawbits[i];
1380 }
1381 }
1382
1383 // Dumping UID
1384 BYTE bits[224];
1385 char showbits[225];
1386 showbits[uidlen]='\0';
1387 int bit;
1388 i = start;
1389 int times = 0;
1390 if(uidlen > rawbit) {
1391 PrintToScrollback("Warning: not enough raw bits to get a full UID");
1392 for(bit = 0; bit < rawbit; bit++) {
1393 bits[bit] = rawbits[i++];
1394 // As we cannot know the parity, let's use "." and "/"
1395 showbits[bit] = '.' + bits[bit];
1396 }
1397 showbits[bit+1]='\0';
1398 PrintToScrollback("Partial UID=%s", showbits);
1399 return;
1400 } else {
1401 for(bit = 0; bit < uidlen; bit++) {
1402 bits[bit] = rawbits[i++];
1403 showbits[bit] = '0' + bits[bit];
1404 }
1405 times = 1;
1406 }
1407 PrintToScrollback("UID=%s", showbits);
1408
1409 // Checking UID against next occurences
1410 for(; i + uidlen <= rawbit;) {
1411 int failed = 0;
1412 for(bit = 0; bit < uidlen; bit++) {
1413 if(bits[bit] != rawbits[i++]) {
1414 failed = 1;
1415 break;
1416 }
1417 }
1418 if (failed == 1) {
1419 break;
1420 }
1421 times += 1;
1422 }
1423 PrintToScrollback("Occurences: %d (expected %d)", times, (rawbit - start) / uidlen);
1424
1425 // Remodulating for tag cloning
1426 GraphTraceLen = 32*uidlen;
1427 i = 0;
1428 int phase = 0;
1429 for(bit = 0; bit < uidlen; bit++) {
1430 if(bits[bit] == 0) {
1431 phase = 0;
1432 } else {
1433 phase = 1;
1434 }
1435 int j;
1436 for(j = 0; j < 32; j++) {
1437 GraphBuffer[i++] = phase;
1438 phase = !phase;
1439 }
1440 }
1441
1442 RepaintGraphWindow();
1443 }
1444
1445 static void CmdFlexdemod(char *str)
1446 {
1447 int i;
1448 for(i = 0; i < GraphTraceLen; i++) {
1449 if(GraphBuffer[i] < 0) {
1450 GraphBuffer[i] = -1;
1451 } else {
1452 GraphBuffer[i] = 1;
1453 }
1454 }
1455
1456 #define LONG_WAIT 100
1457 int start;
1458 for(start = 0; start < GraphTraceLen - LONG_WAIT; start++) {
1459 int first = GraphBuffer[start];
1460 for(i = start; i < start + LONG_WAIT; i++) {
1461 if(GraphBuffer[i] != first) {
1462 break;
1463 }
1464 }
1465 if(i == (start + LONG_WAIT)) {
1466 break;
1467 }
1468 }
1469 if(start == GraphTraceLen - LONG_WAIT) {
1470 PrintToScrollback("nothing to wait for");
1471 return;
1472 }
1473
1474 GraphBuffer[start] = 2;
1475 GraphBuffer[start+1] = -2;
1476
1477 BYTE bits[64];
1478
1479 int bit;
1480 i = start;
1481 for(bit = 0; bit < 64; bit++) {
1482 int j;
1483 int sum = 0;
1484 for(j = 0; j < 16; j++) {
1485 sum += GraphBuffer[i++];
1486 }
1487 if(sum > 0) {
1488 bits[bit] = 1;
1489 } else {
1490 bits[bit] = 0;
1491 }
1492 PrintToScrollback("bit %d sum %d", bit, sum);
1493 }
1494
1495 for(bit = 0; bit < 64; bit++) {
1496 int j;
1497 int sum = 0;
1498 for(j = 0; j < 16; j++) {
1499 sum += GraphBuffer[i++];
1500 }
1501 if(sum > 0 && bits[bit] != 1) {
1502 PrintToScrollback("oops1 at %d", bit);
1503 }
1504 if(sum < 0 && bits[bit] != 0) {
1505 PrintToScrollback("oops2 at %d", bit);
1506 }
1507 }
1508
1509 GraphTraceLen = 32*64;
1510 i = 0;
1511 int phase = 0;
1512 for(bit = 0; bit < 64; bit++) {
1513 if(bits[bit] == 0) {
1514 phase = 0;
1515 } else {
1516 phase = 1;
1517 }
1518 int j;
1519 for(j = 0; j < 32; j++) {
1520 GraphBuffer[i++] = phase;
1521 phase = !phase;
1522 }
1523 }
1524
1525 RepaintGraphWindow();
1526 }
1527
1528 /*
1529 * Generic command to demodulate ASK. bit length in argument.
1530 * Giving the bit length helps discriminate ripple effects
1531 * upon zero crossing for noisy traces.
1532 *
1533 * Second is convention: positive or negative (High mod means zero
1534 * or high mod means one)
1535 *
1536 * Updates the Graph trace with 0/1 values
1537 *
1538 * Arguments:
1539 * sl : bit length in terms of number of samples per bit
1540 * (use yellow/purple markers to compute).
1541 * c : 0 or 1
1542 */
1543
1544 static void Cmdaskdemod(char *str) {
1545 int i;
1546 int sign = 1;
1547 int n = 0;
1548 int c = 0;
1549 int t1 = 0;
1550
1551 // TODO: complain if we do not give 2 arguments here !
1552 sscanf(str, "%i %i", &n, &c);
1553 if (c == 0) {
1554 c = 1 ;
1555 } else {
1556 c = -1;
1557 }
1558
1559 if (GraphBuffer[0]*c > 0) {
1560 GraphBuffer[0] = 1;
1561 } else {
1562 GraphBuffer[0] = 0;
1563 }
1564 for(i=1;i<GraphTraceLen;i++) {
1565 /* Analyse signal within the symbol length */
1566 /* Decide if we crossed a zero */
1567 if (GraphBuffer[i]*sign < 0) {
1568 /* Crossed a zero, check if this is a ripple or not */
1569 if ( (i-t1) > n/4 ) {
1570 sign = -sign;
1571 t1=i;
1572 if (GraphBuffer[i]*c > 0){
1573 GraphBuffer[i]=1;
1574 } else {
1575 GraphBuffer[i]=0;
1576 }
1577 } else {
1578 /* This is a ripple, set the current sample value
1579 to the same as previous */
1580 GraphBuffer[i] = GraphBuffer[i-1];
1581 }
1582 } else {
1583 GraphBuffer[i] = GraphBuffer[i-1];
1584 }
1585 }
1586 RepaintGraphWindow();
1587 }
1588
1589
1590 /*
1591 * Manchester demodulate a bitstream. The bitstream needs to be already in
1592 * the GraphBuffer as 0 and 1 values
1593 *
1594 * Give the clock rate as argument in order to help the sync - the algorithm
1595 * resyncs at each pulse anyway.
1596 *
1597 * Not optimized by any means, this is the 1st time I'm writing this type of
1598 * routine, feel free to improve...
1599 *
1600 * 1st argument: clock rate (as number of samples per clock rate)
1601 * Typical values can be 64, 32, 128...
1602 */
1603 static void Cmdmanchesterdemod(char *str) {
1604 int i;
1605 int clock;
1606 int lastval;
1607 int lc = 0;
1608 int bitidx = 0;
1609 int bit2idx = 0;
1610
1611
1612 sscanf(str, "%i", &clock);
1613
1614 int tolerance = clock/4;
1615 /* Holds the decoded bitstream: each clock period contains 2 bits */
1616 /* later simplified to 1 bit after manchester decoding. */
1617 /* Add 10 bits to allow for noisy / uncertain traces without aborting */
1618 /* int BitStream[GraphTraceLen*2/clock+10]; */
1619
1620 /* But it does not work if compiling on WIndows: therefore we just allocate a */
1621 /* large array */
1622 int BitStream[MAX_GRAPH_TRACE_LEN];
1623
1624 /* Detect first transition */
1625 /* Lo-Hi (arbitrary) */
1626 for(i=1;i<GraphTraceLen;i++) {
1627 if (GraphBuffer[i-1]<GraphBuffer[i]) {
1628 lastval = i;
1629 BitStream[0]=0; // Previous state = 0;
1630 break;
1631 }
1632 }
1633
1634 /* Then detect duration between 2 successive transitions */
1635 for(bitidx = 1 ;i<GraphTraceLen;i++) {
1636 if (GraphBuffer[i-1] != GraphBuffer[i]) {
1637 lc = i-lastval;
1638 lastval = i;
1639 // Error check: if bitidx becomes too large, we do not
1640 // have a Manchester encoded bitstream or the clock is really
1641 // wrong!
1642 if (bitidx > (GraphTraceLen*2/clock+8) ) {
1643 PrintToScrollback("Error: the clock you gave is probably wrong, aborting.");
1644 return;
1645 }
1646 // Then switch depending on lc length:
1647 // Tolerance is 1/4 of clock rate (arbitrary)
1648 if (abs(lc-clock/2) < tolerance) {
1649 // Short pulse : either "1" or "0"
1650 BitStream[bitidx++]=GraphBuffer[i-1];
1651 } else if (abs(lc-clock) < tolerance) {
1652 // Long pulse: either "11" or "00"
1653 BitStream[bitidx++]=GraphBuffer[i-1];
1654 BitStream[bitidx++]=GraphBuffer[i-1];
1655 } else {
1656 // Error
1657 PrintToScrollback("Warning: Manchester decode error for pulse width detection.");
1658 PrintToScrollback("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
1659 }
1660 }
1661 }
1662
1663 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
1664 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
1665 // to stop output at the final bitidx2 value, not bitidx
1666 for (i = 0; i < bitidx; i += 2) {
1667 if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
1668 BitStream[bit2idx++] = 1;
1669 } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
1670 BitStream[bit2idx++] = 0;
1671 } else {
1672 // We cannot end up in this state, this means we are unsynchronized,
1673 // move up 1 bit:
1674 i++;
1675 PrintToScrollback("Unsynchronized, resync...");
1676 PrintToScrollback("(too many of those messages mean the stream is not Manchester encoded)");
1677 }
1678 }
1679 PrintToScrollback("Manchester decoded bitstream \n---------");
1680 // Now output the bitstream to the scrollback by line of 16 bits
1681 for (i = 0; i < (bit2idx-16); i+=16) {
1682 PrintToScrollback("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
1683 BitStream[i],
1684 BitStream[i+1],
1685 BitStream[i+2],
1686 BitStream[i+3],
1687 BitStream[i+4],
1688 BitStream[i+5],
1689 BitStream[i+6],
1690 BitStream[i+7],
1691 BitStream[i+8],
1692 BitStream[i+9],
1693 BitStream[i+10],
1694 BitStream[i+11],
1695 BitStream[i+12],
1696 BitStream[i+13],
1697 BitStream[i+14],
1698 BitStream[i+15]);
1699 }
1700 }
1701
1702
1703
1704 /*
1705 * Usage ???
1706 */
1707 static void CmdHiddemod(char *str)
1708 {
1709 if(GraphTraceLen < 4800) {
1710 PrintToScrollback("too short; need at least 4800 samples");
1711 return;
1712 }
1713
1714 GraphTraceLen = 4800;
1715 int i;
1716 for(i = 0; i < GraphTraceLen; i++) {
1717 if(GraphBuffer[i] < 0) {
1718 GraphBuffer[i] = 0;
1719 } else {
1720 GraphBuffer[i] = 1;
1721 }
1722 }
1723 RepaintGraphWindow();
1724 }
1725
1726 static void CmdPlot(char *str)
1727 {
1728 ShowGraphWindow();
1729 }
1730
1731 static void CmdHide(char *str)
1732 {
1733 HideGraphWindow();
1734 }
1735
1736 static void CmdScale(char *str)
1737 {
1738 CursorScaleFactor = atoi(str);
1739 if(CursorScaleFactor == 0) {
1740 PrintToScrollback("bad, can't have zero scale");
1741 CursorScaleFactor = 1;
1742 }
1743 RepaintGraphWindow();
1744 }
1745
1746 static void CmdSave(char *str)
1747 {
1748 FILE *f = fopen(str, "w");
1749 if(!f) {
1750 PrintToScrollback("couldn't open '%s'", str);
1751 return;
1752 }
1753 int i;
1754 for(i = 0; i < GraphTraceLen; i++) {
1755 fprintf(f, "%d\n", GraphBuffer[i]);
1756 }
1757 fclose(f);
1758 PrintToScrollback("saved to '%s'", str);
1759 }
1760
1761 static void CmdLoad(char *str)
1762 {
1763 FILE *f = fopen(str, "r");
1764 if(!f) {
1765 PrintToScrollback("couldn't open '%s'", str);
1766 return;
1767 }
1768
1769 GraphTraceLen = 0;
1770 char line[80];
1771 while(fgets(line, sizeof(line), f)) {
1772 GraphBuffer[GraphTraceLen] = atoi(line);
1773 GraphTraceLen++;
1774 }
1775 fclose(f);
1776 PrintToScrollback("loaded %d samples", GraphTraceLen);
1777 RepaintGraphWindow();
1778 }
1779
1780 static void CmdHIDsimTAG(char *str)
1781 {
1782 unsigned int hi=0, lo=0;
1783 int n=0, i=0;
1784 UsbCommand c;
1785
1786 while (sscanf(&str[i++], "%1x", &n ) == 1) {
1787 hi=(hi<<4)|(lo>>28);
1788 lo=(lo<<4)|(n&0xf);
1789 }
1790
1791 PrintToScrollback("Emulating tag with ID %x%16x", hi, lo);
1792
1793 c.cmd = CMD_HID_SIM_TAG;
1794 c.ext1 = hi;
1795 c.ext2 = lo;
1796 SendCommand(&c, FALSE);
1797 }
1798
1799 static void CmdLcdReset(char *str)
1800 {
1801 UsbCommand c;
1802 c.cmd = CMD_LCD_RESET;
1803 c.ext1 = atoi(str);
1804 SendCommand(&c, FALSE);
1805 }
1806
1807 static void CmdLcd(char *str)
1808 {
1809 int i, j;
1810 UsbCommand c;
1811 c.cmd = CMD_LCD;
1812 sscanf(str, "%x %d", &i, &j);
1813 while (j--) {
1814 c.ext1 = i&0x1ff;
1815 SendCommand(&c, FALSE);
1816 }
1817 }
1818
1819 static void CmdTest(char *str)
1820 {
1821 }
1822
1823 /*
1824 * Sets the divisor for LF frequency clock: lets the user choose any LF frequency below
1825 * 600kHz.
1826 */
1827 static void CmdSetDivisor(char *str)
1828 {
1829 UsbCommand c;
1830 c.cmd = CMD_SET_LF_DIVISOR;
1831 c.ext1 = atoi(str);
1832 if (( c.ext1<0) || (c.ext1>255)) {
1833 PrintToScrollback("divisor must be between 19 and 255");
1834 } else {
1835 SendCommand(&c, FALSE);
1836 PrintToScrollback("Divisor set, expected freq=%dHz", 12000000/(c.ext1+1));
1837 }
1838 }
1839
1840 static void CmdSweepLF(char *str)
1841 {
1842 UsbCommand c;
1843 c.cmd = CMD_SWEEP_LF;
1844 SendCommand(&c, FALSE);
1845 }
1846
1847
1848
1849 typedef void HandlerFunction(char *cmdline);
1850
1851 static struct {
1852 char *name;
1853 HandlerFunction *handler;
1854 char *docString;
1855 } CommandTable[] = {
1856 "tune", CmdTune, "measure antenna tuning",
1857 "tiread", CmdTiread, "read a TI-type 134 kHz tag",
1858 "tibits", CmdTibits, "get raw bits for TI-type LF tag",
1859 "tidemod", CmdTidemod, "demod raw bits for TI-type LF tag",
1860 "vchdemod", CmdVchdemod, "demod samples for VeriChip",
1861 "plot", CmdPlot, "show graph window",
1862 "hide", CmdHide, "hide graph window",
1863 "losim", CmdLosim, "simulate LF tag",
1864 "loread", CmdLoread, "read (125/134 kHz) LF ID-only tag",
1865 "losamples", CmdLosamples, "get raw samples for LF tag",
1866 "hisamples", CmdHisamples, "get raw samples for HF tag",
1867 "hisampless", CmdHisampless, "get signed raw samples, HF tag",
1868 "hisamplest", CmdHi14readt, "get samples HF, for testing",
1869 "higet", CmdHi14read_sim, "get samples HF, 'analog'",
1870 "bitsamples", CmdBitsamples, "get raw samples as bitstring",
1871 "hexsamples", CmdHexsamples, "dump big buffer as hex bytes",
1872 "hi15read", CmdHi15read, "read HF tag (ISO 15693)",
1873 "hi15reader", CmdHi15reader, "act like an ISO15693 reader", // new command greg
1874 "hi15sim", CmdHi15tag, "fake an ISO15693 tag", // new command greg
1875 "hi14read", CmdHi14read, "read HF tag (ISO 14443)",
1876 "hi14areader", CmdHi14areader, "act like an ISO14443 Type A reader", // ## New reader command
1877 "hi15demod", CmdHi15demod, "demod ISO15693 from tag",
1878 "hi14bdemod", CmdHi14bdemod, "demod ISO14443 Type B from tag",
1879 "autocorr", CmdAutoCorr, "autocorrelation over window",
1880 "norm", CmdNorm, "normalize max/min to +/-500",
1881 "dec", CmdDec, "decimate",
1882 "hpf", CmdHpf, "remove DC offset from trace",
1883 "zerocrossings", CmdZerocrossings, "count time between zero-crossings",
1884 "ltrim", CmdLtrim, "trim from left of trace",
1885 "scale", CmdScale, "set cursor display scale",
1886 "flexdemod", CmdFlexdemod, "demod samples for FlexPass",
1887 "indalademod", CmdIndalademod, "demod samples for Indala",
1888 "save", CmdSave, "save trace (from graph window)",
1889 "load", CmdLoad, "load trace (to graph window",
1890 "hisimlisten", CmdHisimlisten, "get HF samples as fake tag",
1891 "hi14sim", CmdHi14sim, "fake ISO 14443 tag",
1892 "hi14asim", CmdHi14asim, "fake ISO 14443a tag", // ## Simulate 14443a tag
1893 "hi14snoop", CmdHi14snoop, "eavesdrop ISO 14443",
1894 "hi14asnoop", CmdHi14asnoop, "eavesdrop ISO 14443 Type A", // ## New snoop command
1895 "hi14list", CmdHi14list, "list ISO 14443 history",
1896 "hi14alist", CmdHi14alist, "list ISO 14443a history", // ## New list command
1897 "hiddemod", CmdHiddemod, "HID Prox Card II (not optimal)",
1898 "hidfskdemod", CmdHIDdemodFSK, "HID FSK demodulator",
1899 "askdemod", Cmdaskdemod, "Attempt to demodulate simple ASK tags",
1900 "hidsimtag", CmdHIDsimTAG, "HID tag simulator",
1901 "mandemod", Cmdmanchesterdemod, "Try a Manchester demodulation on a binary stream",
1902 "fpgaoff", CmdFPGAOff, "set FPGA off", // ## FPGA Control
1903 "lcdreset", CmdLcdReset, "Hardware reset LCD",
1904 "lcd", CmdLcd, "Send command/data to LCD",
1905 "test", CmdTest, "Placeholder command for testing new code",
1906 "setlfdivisor", CmdSetDivisor, "Drive LF antenna at 12Mhz/(divisor+1)",
1907 "sweeplf", CmdSweepLF, "Sweep through LF freq range and store results in buffer",
1908 "quit", CmdQuit, "quit program"
1909 };
1910
1911 //-----------------------------------------------------------------------------
1912 // Entry point into our code: called whenever the user types a command and
1913 // then presses Enter, which the full command line that they typed.
1914 //-----------------------------------------------------------------------------
1915 void CommandReceived(char *cmd)
1916 {
1917 int i;
1918
1919 PrintToScrollback("> %s", cmd);
1920
1921 if(strcmp(cmd, "help")==0) {
1922 PrintToScrollback("\r\nAvailable commands:");
1923 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {
1924 char line[256];
1925 memset(line, ' ', sizeof(line));
1926 strcpy(line+2, CommandTable[i].name);
1927 line[strlen(line)] = ' ';
1928 sprintf(line+15, " -- %s", CommandTable[i].docString);
1929 PrintToScrollback("%s", line);
1930 }
1931 PrintToScrollback("");
1932 PrintToScrollback("and also: help, cls");
1933 return;
1934 }
1935
1936 for(i = 0; i < sizeof(CommandTable) / sizeof(CommandTable[0]); i++) {
1937 char *name = CommandTable[i].name;
1938 if(memcmp(cmd, name, strlen(name))==0 &&
1939 (cmd[strlen(name)] == ' ' || cmd[strlen(name)] == '\0'))
1940 {
1941 cmd += strlen(name);
1942 while(*cmd == ' ') {
1943 cmd++;
1944 }
1945 (CommandTable[i].handler)(cmd);
1946 return;
1947 }
1948 }
1949 PrintToScrollback(">> bad command '%s'", cmd);
1950 }
1951
1952 //-----------------------------------------------------------------------------
1953 // Entry point into our code: called whenever we received a packet over USB
1954 // that we weren't necessarily expecting, for example a debug print.
1955 //-----------------------------------------------------------------------------
1956 void UsbCommandReceived(UsbCommand *c)
1957 {
1958 switch(c->cmd) {
1959 case CMD_DEBUG_PRINT_STRING: {
1960 char s[100];
1961 if(c->ext1 > 70 || c->ext1 < 0) {
1962 c->ext1 = 0;
1963 }
1964 memcpy(s, c->d.asBytes, c->ext1);
1965 s[c->ext1] = '\0';
1966 PrintToScrollback("#db# %s", s);
1967 break;
1968 }
1969
1970 case CMD_DEBUG_PRINT_INTEGERS:
1971 PrintToScrollback("#db# %08x, %08x, %08x\r\n", c->ext1, c->ext2, c->ext3);
1972 break;
1973
1974 case CMD_MEASURED_ANTENNA_TUNING: {
1975 int zLf, zHf;
1976 int vLf125, vLf134, vHf;
1977 vLf125 = c->ext1 & 0xffff;
1978 vLf134 = c->ext1 >> 16;
1979 vHf = c->ext2;
1980 zLf = c->ext3 & 0xffff;
1981 zHf = c->ext3 >> 16;
1982 PrintToScrollback("# LF antenna @ %3d mA / %5d mV [%d ohms] 125Khz",
1983 vLf125/zLf, vLf125, zLf);
1984 PrintToScrollback("# LF antenna @ %3d mA / %5d mV [%d ohms] 134Khz",
1985 vLf134/((zLf*125)/134), vLf134, (zLf*125)/134);
1986 PrintToScrollback("# HF antenna @ %3d mA / %5d mV [%d ohms] 13.56Mhz",
1987 vHf/zHf, vHf, zHf);
1988 break;
1989 }
1990 default:
1991 PrintToScrollback("unrecognized command %08x\n", c->cmd);
1992 break;
1993 }
1994 }
Proxmark3 GIT tracking
Impressum, Datenschutz