]> cvs.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c
projects / proxmark3-svn / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of https://github.com/Proxmark/proxmark3
[proxmark3-svn] / client / cmddata.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
3 //
4 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
5 // at your option, any later version. See the LICENSE.txt file for the text of
6 // the license.
7 //-----------------------------------------------------------------------------
8 // Data and Graph commands
9 //-----------------------------------------------------------------------------
10
11 #include <stdio.h>
12 #include <stdlib.h>
13 #include <string.h>
14 #include <limits.h>
15 #include "proxmark3.h"
16 #include "data.h"
17 #include "ui.h"
18 #include "graph.h"
19 #include "cmdparser.h"
20 #include "util.h"
21 #include "cmdmain.h"
22 #include "cmddata.h"
23 #include "lfdemod.h"
24 #include "usb_cmd.h"
25
26 uint8_t DemodBuffer[MAX_DEMOD_BUF_LEN];
27 uint8_t g_debugMode;
28 int DemodBufferLen;
29 static int CmdHelp(const char *Cmd);
30
31 //set the demod buffer with given array of binary (one bit per byte)
32 //by marshmellow
33 void setDemodBuf(uint8_t *buff, size_t size, size_t startIdx)
34 {
35 if (buff == NULL)
36 return;
37
38 if ( size >= MAX_DEMOD_BUF_LEN)
39 size = MAX_DEMOD_BUF_LEN;
40
41 size_t i = 0;
42 for (; i < size; i++){
43 DemodBuffer[i]=buff[startIdx++];
44 }
45 DemodBufferLen=size;
46 return;
47 }
48
49 int CmdSetDebugMode(const char *Cmd)
50 {
51 int demod=0;
52 sscanf(Cmd, "%i", &demod);
53 g_debugMode=(uint8_t)demod;
54 return 1;
55 }
56
57 //by marshmellow
58 void printDemodBuff()
59 {
60 uint32_t i = 0;
61 int bitLen = DemodBufferLen;
62 if (bitLen<16) {
63 PrintAndLog("no bits found in demod buffer");
64 return;
65 }
66 if (bitLen>512) bitLen=512; //max output to 512 bits if we have more - should be plenty
67
68 // ensure equally divided by 16
69 bitLen &= 0xfff0;
70
71 for (i = 0; i <= (bitLen-16); i+=16) {
72 PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
73 DemodBuffer[i],
74 DemodBuffer[i+1],
75 DemodBuffer[i+2],
76 DemodBuffer[i+3],
77 DemodBuffer[i+4],
78 DemodBuffer[i+5],
79 DemodBuffer[i+6],
80 DemodBuffer[i+7],
81 DemodBuffer[i+8],
82 DemodBuffer[i+9],
83 DemodBuffer[i+10],
84 DemodBuffer[i+11],
85 DemodBuffer[i+12],
86 DemodBuffer[i+13],
87 DemodBuffer[i+14],
88 DemodBuffer[i+15]);
89 }
90 return;
91 }
92
93
94 int CmdAmp(const char *Cmd)
95 {
96 int i, rising, falling;
97 int max = INT_MIN, min = INT_MAX;
98
99 for (i = 10; i < GraphTraceLen; ++i) {
100 if (GraphBuffer[i] > max)
101 max = GraphBuffer[i];
102 if (GraphBuffer[i] < min)
103 min = GraphBuffer[i];
104 }
105
106 if (max != min) {
107 rising = falling= 0;
108 for (i = 0; i < GraphTraceLen; ++i) {
109 if (GraphBuffer[i + 1] < GraphBuffer[i]) {
110 if (rising) {
111 GraphBuffer[i] = max;
112 rising = 0;
113 }
114 falling = 1;
115 }
116 if (GraphBuffer[i + 1] > GraphBuffer[i]) {
117 if (falling) {
118 GraphBuffer[i] = min;
119 falling = 0;
120 }
121 rising= 1;
122 }
123 }
124 }
125 RepaintGraphWindow();
126 return 0;
127 }
128
129 /*
130 * Generic command to demodulate ASK.
131 *
132 * Argument is convention: positive or negative (High mod means zero
133 * or high mod means one)
134 *
135 * Updates the Graph trace with 0/1 values
136 *
137 * Arguments:
138 * c : 0 or 1
139 */
140 //this method is dependant on all highs and lows to be the same(or clipped) this creates issues[marshmellow] it also ignores the clock
141 int Cmdaskdemod(const char *Cmd)
142 {
143 int i;
144 int c, high = 0, low = 0;
145
146 // TODO: complain if we do not give 2 arguments here !
147 // (AL - this doesn't make sense! we're only using one argument!!!)
148 sscanf(Cmd, "%i", &c);
149
150 /* Detect high and lows and clock */
151 // (AL - clock???)
152 for (i = 0; i < GraphTraceLen; ++i)
153 {
154 if (GraphBuffer[i] > high)
155 high = GraphBuffer[i];
156 else if (GraphBuffer[i] < low)
157 low = GraphBuffer[i];
158 }
159 high=abs(high*.75);
160 low=abs(low*.75);
161 if (c != 0 && c != 1) {
162 PrintAndLog("Invalid argument: %s", Cmd);
163 return 0;
164 }
165 //prime loop
166 if (GraphBuffer[0] > 0) {
167 GraphBuffer[0] = 1-c;
168 } else {
169 GraphBuffer[0] = c;
170 }
171 for (i = 1; i < GraphTraceLen; ++i) {
172 /* Transitions are detected at each peak
173 * Transitions are either:
174 * - we're low: transition if we hit a high
175 * - we're high: transition if we hit a low
176 * (we need to do it this way because some tags keep high or
177 * low for long periods, others just reach the peak and go
178 * down)
179 */
180 //[marhsmellow] change == to >= for high and <= for low for fuzz
181 if ((GraphBuffer[i] == high) && (GraphBuffer[i - 1] == c)) {
182 GraphBuffer[i] = 1 - c;
183 } else if ((GraphBuffer[i] == low) && (GraphBuffer[i - 1] == (1 - c))){
184 GraphBuffer[i] = c;
185 } else {
186 /* No transition */
187 GraphBuffer[i] = GraphBuffer[i - 1];
188 }
189 }
190 RepaintGraphWindow();
191 return 0;
192 }
193
194 //by marshmellow
195 void printBitStream(uint8_t BitStream[], uint32_t bitLen)
196 {
197 uint32_t i = 0;
198 if (bitLen<16) {
199 PrintAndLog("Too few bits found: %d",bitLen);
200 return;
201 }
202 if (bitLen>512) bitLen=512;
203
204 // ensure equally divided by 16
205 bitLen &= 0xfff0;
206
207
208 for (i = 0; i <= (bitLen-16); i+=16) {
209 PrintAndLog("%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i%i",
210 BitStream[i],
211 BitStream[i+1],
212 BitStream[i+2],
213 BitStream[i+3],
214 BitStream[i+4],
215 BitStream[i+5],
216 BitStream[i+6],
217 BitStream[i+7],
218 BitStream[i+8],
219 BitStream[i+9],
220 BitStream[i+10],
221 BitStream[i+11],
222 BitStream[i+12],
223 BitStream[i+13],
224 BitStream[i+14],
225 BitStream[i+15]);
226 }
227 return;
228 }
229 //by marshmellow
230 //print EM410x ID in multiple formats
231 void printEM410x(uint64_t id)
232 {
233 if (id !=0){
234 uint64_t iii=1;
235 uint64_t id2lo=0;
236 uint32_t ii=0;
237 uint32_t i=0;
238 for (ii=5; ii>0;ii--){
239 for (i=0;i<8;i++){
240 id2lo=(id2lo<<1LL) | ((id & (iii << (i+((ii-1)*8)))) >> (i+((ii-1)*8)));
241 }
242 }
243 //output em id
244 PrintAndLog("EM TAG ID : %010llx", id);
245 PrintAndLog("Unique TAG ID: %010llx", id2lo);
246 PrintAndLog("DEZ 8 : %08lld",id & 0xFFFFFF);
247 PrintAndLog("DEZ 10 : %010lld",id & 0xFFFFFF);
248 PrintAndLog("DEZ 5.5 : %05lld.%05lld",(id>>16LL) & 0xFFFF,(id & 0xFFFF));
249 PrintAndLog("DEZ 3.5A : %03lld.%05lld",(id>>32ll),(id & 0xFFFF));
250 PrintAndLog("DEZ 14/IK2 : %014lld",id);
251 PrintAndLog("DEZ 15/IK3 : %015lld",id2lo);
252 PrintAndLog("Other : %05lld_%03lld_%08lld",(id&0xFFFF),((id>>16LL) & 0xFF),(id & 0xFFFFFF));
253 }
254 return;
255 }
256
257 //by marshmellow
258 //take binary from demod buffer and see if we can find an EM410x ID
259 int CmdEm410xDecode(const char *Cmd)
260 {
261 uint64_t id=0;
262 size_t size = DemodBufferLen, idx=0;
263 id = Em410xDecode(DemodBuffer, &size, &idx);
264 if (id>0){
265 setDemodBuf(DemodBuffer, size, idx);
266 if (g_debugMode){
267 PrintAndLog("DEBUG: Printing demod buffer:");
268 printDemodBuff();
269 }
270 printEM410x(id);
271 return 1;
272 }
273 return 0;
274 }
275
276
277 //by marshmellow
278 //takes 2 arguments - clock and invert both as integers
279 //attempts to demodulate ask while decoding manchester
280 //prints binary found and saves in graphbuffer for further commands
281 int Cmdaskmandemod(const char *Cmd)
282 {
283 int invert=0;
284 int clk=0;
285 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
286 sscanf(Cmd, "%i %i", &clk, &invert);
287 if (invert != 0 && invert != 1) {
288 PrintAndLog("Invalid argument: %s", Cmd);
289 return 0;
290 }
291
292 size_t BitLen = getFromGraphBuf(BitStream);
293 if (g_debugMode==1) PrintAndLog("DEBUG: Bitlen from grphbuff: %d",BitLen);
294 int errCnt=0;
295 errCnt = askmandemod(BitStream, &BitLen,&clk,&invert);
296 if (errCnt<0||BitLen<16){ //if fatal error (or -1)
297 if (g_debugMode==1) PrintAndLog("no data found %d, errors:%d, bitlen:%d, clock:%d",errCnt,invert,BitLen,clk);
298 return 0;
299 }
300 PrintAndLog("\nUsing Clock: %d - Invert: %d - Bits Found: %d",clk,invert,BitLen);
301
302 //output
303 if (errCnt>0){
304 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
305 }
306 PrintAndLog("ASK/Manchester decoded bitstream:");
307 // Now output the bitstream to the scrollback by line of 16 bits
308 setDemodBuf(BitStream,BitLen,0);
309 printDemodBuff();
310 uint64_t lo =0;
311 size_t idx=0;
312 lo = Em410xDecode(BitStream, &BitLen, &idx);
313 if (lo>0){
314 //set GraphBuffer for clone or sim command
315 setDemodBuf(BitStream, BitLen, idx);
316 if (g_debugMode){
317 PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
318 printDemodBuff();
319 }
320 PrintAndLog("EM410x pattern found: ");
321 printEM410x(lo);
322 return 1;
323 }
324 return 0;
325 }
326
327 //by marshmellow
328 //manchester decode
329 //stricktly take 10 and 01 and convert to 0 and 1
330 int Cmdmandecoderaw(const char *Cmd)
331 {
332 int i =0;
333 int errCnt=0;
334 size_t size=0;
335 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
336 int high=0,low=0;
337 for (;i<DemodBufferLen;++i){
338 if (DemodBuffer[i]>high) high=DemodBuffer[i];
339 else if(DemodBuffer[i]<low) low=DemodBuffer[i];
340 BitStream[i]=DemodBuffer[i];
341 }
342 if (high>1 || low <0 ){
343 PrintAndLog("Error: please raw demod the wave first then mancheseter raw decode");
344 return 0;
345 }
346 size=i;
347 errCnt=manrawdecode(BitStream, &size);
348 if (errCnt>=20){
349 PrintAndLog("Too many errors: %d",errCnt);
350 return 0;
351 }
352 PrintAndLog("Manchester Decoded - # errors:%d - data:",errCnt);
353 printBitStream(BitStream, size);
354 if (errCnt==0){
355 uint64_t id = 0;
356 size_t idx=0;
357 id = Em410xDecode(BitStream, &size, &idx);
358 if (id>0){
359 //need to adjust to set bitstream back to manchester encoded data
360 //setDemodBuf(BitStream, size, idx);
361
362 printEM410x(id);
363 }
364 }
365 return 1;
366 }
367
368 //by marshmellow
369 //biphase decode
370 //take 01 or 10 = 0 and 11 or 00 = 1
371 //takes 2 arguments "offset" default = 0 if 1 it will shift the decode by one bit
372 // and "invert" default = 0 if 1 it will invert output
373 // since it is not like manchester and doesn't have an incorrect bit pattern we
374 // cannot determine if our decode is correct or if it should be shifted by one bit
375 // the argument offset allows us to manually shift if the output is incorrect
376 // (better would be to demod and decode at the same time so we can distinguish large
377 // width waves vs small width waves to help the decode positioning) or askbiphdemod
378 int CmdBiphaseDecodeRaw(const char *Cmd)
379 {
380 int i = 0;
381 int errCnt=0;
382 size_t size=0;
383 int offset=0;
384 int invert=0;
385 int high=0, low=0;
386 sscanf(Cmd, "%i %i", &offset, &invert);
387 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
388 //get graphbuffer & high and low
389 for (;i<DemodBufferLen;++i){
390 if(DemodBuffer[i]>high)high=DemodBuffer[i];
391 else if(DemodBuffer[i]<low)low=DemodBuffer[i];
392 BitStream[i]=DemodBuffer[i];
393 }
394 if (high>1 || low <0){
395 PrintAndLog("Error: please raw demod the wave first then decode");
396 return 0;
397 }
398 size=i;
399 errCnt=BiphaseRawDecode(BitStream, &size, offset, invert);
400 if (errCnt>=20){
401 PrintAndLog("Too many errors attempting to decode: %d",errCnt);
402 return 0;
403 }
404 PrintAndLog("Biphase Decoded using offset: %d - # errors:%d - data:",offset,errCnt);
405 printBitStream(BitStream, size);
406 PrintAndLog("\nif bitstream does not look right try offset=1");
407 return 1;
408 }
409
410 //by marshmellow
411 //takes 2 arguments - clock and invert both as integers
412 //attempts to demodulate ask only
413 //prints binary found and saves in graphbuffer for further commands
414 int Cmdaskrawdemod(const char *Cmd)
415 {
416 int invert=0;
417 int clk=0;
418 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
419 sscanf(Cmd, "%i %i", &clk, &invert);
420 if (invert != 0 && invert != 1) {
421 PrintAndLog("Invalid argument: %s", Cmd);
422 return 0;
423 }
424 size_t BitLen = getFromGraphBuf(BitStream);
425 int errCnt=0;
426 errCnt = askrawdemod(BitStream, &BitLen,&clk,&invert);
427 if (errCnt==-1||BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
428 PrintAndLog("no data found");
429 if (g_debugMode==1) PrintAndLog("errCnt: %d, BitLen: %d, clk: %d, invert: %d", errCnt, BitLen, clk, invert);
430 return 0;
431 }
432 PrintAndLog("Using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
433
434 //move BitStream back to DemodBuffer
435 setDemodBuf(BitStream,BitLen,0);
436
437 //output
438 if (errCnt>0){
439 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
440 }
441 PrintAndLog("ASK demoded bitstream:");
442 // Now output the bitstream to the scrollback by line of 16 bits
443 printBitStream(BitStream,BitLen);
444
445 return 1;
446 }
447
448 int CmdAutoCorr(const char *Cmd)
449 {
450 static int CorrelBuffer[MAX_GRAPH_TRACE_LEN];
451
452 int window = atoi(Cmd);
453
454 if (window == 0) {
455 PrintAndLog("needs a window");
456 return 0;
457 }
458 if (window >= GraphTraceLen) {
459 PrintAndLog("window must be smaller than trace (%d samples)",
460 GraphTraceLen);
461 return 0;
462 }
463
464 PrintAndLog("performing %d correlations", GraphTraceLen - window);
465
466 for (int i = 0; i < GraphTraceLen - window; ++i) {
467 int sum = 0;
468 for (int j = 0; j < window; ++j) {
469 sum += (GraphBuffer[j]*GraphBuffer[i + j]) / 256;
470 }
471 CorrelBuffer[i] = sum;
472 }
473 GraphTraceLen = GraphTraceLen - window;
474 memcpy(GraphBuffer, CorrelBuffer, GraphTraceLen * sizeof (int));
475
476 RepaintGraphWindow();
477 return 0;
478 }
479
480 int CmdBitsamples(const char *Cmd)
481 {
482 int cnt = 0;
483 uint8_t got[12288];
484
485 GetFromBigBuf(got,sizeof(got),0);
486 WaitForResponse(CMD_ACK,NULL);
487
488 for (int j = 0; j < sizeof(got); j++) {
489 for (int k = 0; k < 8; k++) {
490 if(got[j] & (1 << (7 - k))) {
491 GraphBuffer[cnt++] = 1;
492 } else {
493 GraphBuffer[cnt++] = 0;
494 }
495 }
496 }
497 GraphTraceLen = cnt;
498 RepaintGraphWindow();
499 return 0;
500 }
501
502 /*
503 * Convert to a bitstream
504 */
505 int CmdBitstream(const char *Cmd)
506 {
507 int i, j;
508 int bit;
509 int gtl;
510 int clock;
511 int low = 0;
512 int high = 0;
513 int hithigh, hitlow, first;
514
515 /* Detect high and lows and clock */
516 for (i = 0; i < GraphTraceLen; ++i)
517 {
518 if (GraphBuffer[i] > high)
519 high = GraphBuffer[i];
520 else if (GraphBuffer[i] < low)
521 low = GraphBuffer[i];
522 }
523
524 /* Get our clock */
525 clock = GetClock(Cmd, high, 1);
526 gtl = ClearGraph(0);
527
528 bit = 0;
529 for (i = 0; i < (int)(gtl / clock); ++i)
530 {
531 hithigh = 0;
532 hitlow = 0;
533 first = 1;
534 /* Find out if we hit both high and low peaks */
535 for (j = 0; j < clock; ++j)
536 {
537 if (GraphBuffer[(i * clock) + j] == high)
538 hithigh = 1;
539 else if (GraphBuffer[(i * clock) + j] == low)
540 hitlow = 1;
541 /* it doesn't count if it's the first part of our read
542 because it's really just trailing from the last sequence */
543 if (first && (hithigh || hitlow))
544 hithigh = hitlow = 0;
545 else
546 first = 0;
547
548 if (hithigh && hitlow)
549 break;
550 }
551
552 /* If we didn't hit both high and low peaks, we had a bit transition */
553 if (!hithigh || !hitlow)
554 bit ^= 1;
555
556 AppendGraph(0, clock, bit);
557 }
558
559 RepaintGraphWindow();
560 return 0;
561 }
562
563 int CmdBuffClear(const char *Cmd)
564 {
565 UsbCommand c = {CMD_BUFF_CLEAR};
566 SendCommand(&c);
567 ClearGraph(true);
568 return 0;
569 }
570
571 int CmdDec(const char *Cmd)
572 {
573 for (int i = 0; i < (GraphTraceLen / 2); ++i)
574 GraphBuffer[i] = GraphBuffer[i * 2];
575 GraphTraceLen /= 2;
576 PrintAndLog("decimated by 2");
577 RepaintGraphWindow();
578 return 0;
579 }
580 /**
581 * Undecimate - I'd call it 'interpolate', but we'll save that
582 * name until someone does an actual interpolation command, not just
583 * blindly repeating samples
584 * @param Cmd
585 * @return
586 */
587 int CmdUndec(const char *Cmd)
588 {
589 if(param_getchar(Cmd, 0) == 'h')
590 {
591 PrintAndLog("Usage: data undec [factor]");
592 PrintAndLog("This function performs un-decimation, by repeating each sample N times");
593 PrintAndLog("Options: ");
594 PrintAndLog(" h This help");
595 PrintAndLog(" factor The number of times to repeat each sample.[default:2]");
596 PrintAndLog("Example: 'data undec 3'");
597 return 0;
598 }
599
600 uint8_t factor = param_get8ex(Cmd, 0,2, 10);
601 //We have memory, don't we?
602 int swap[MAX_GRAPH_TRACE_LEN] = { 0 };
603 uint32_t g_index = 0 ,s_index = 0;
604 while(g_index < GraphTraceLen && s_index < MAX_GRAPH_TRACE_LEN)
605 {
606 int count = 0;
607 for(count = 0; count < factor && s_index+count < MAX_GRAPH_TRACE_LEN; count ++)
608 swap[s_index+count] = GraphBuffer[g_index];
609 s_index+=count;
610 }
611
612 memcpy(GraphBuffer,swap, s_index * sizeof(int));
613 GraphTraceLen = s_index;
614 RepaintGraphWindow();
615 return 0;
616 }
617
618 //by marshmellow
619 //shift graph zero up or down based on input + or -
620 int CmdGraphShiftZero(const char *Cmd)
621 {
622
623 int shift=0;
624 //set options from parameters entered with the command
625 sscanf(Cmd, "%i", &shift);
626 int shiftedVal=0;
627 for(int i = 0; i<GraphTraceLen; i++){
628 shiftedVal=GraphBuffer[i]+shift;
629 if (shiftedVal>127)
630 shiftedVal=127;
631 else if (shiftedVal<-127)
632 shiftedVal=-127;
633 GraphBuffer[i]= shiftedVal;
634 }
635 CmdNorm("");
636 return 0;
637 }
638
639 /* Print our clock rate */
640 // uses data from graphbuffer
641 int CmdDetectClockRate(const char *Cmd)
642 {
643 GetClock("",0,0);
644 //int clock = DetectASKClock(0);
645 //PrintAndLog("Auto-detected clock rate: %d", clock);
646 return 0;
647 }
648
649 //by marshmellow
650 //fsk raw demod and print binary
651 //takes 4 arguments - Clock, invert, rchigh, rclow
652 //defaults: clock = 50, invert=0, rchigh=10, rclow=8 (RF/10 RF/8 (fsk2a))
653 int CmdFSKrawdemod(const char *Cmd)
654 {
655 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
656 //set defaults
657 int rfLen = 0;
658 int invert=0;
659 int fchigh=0;
660 int fclow=0;
661 //set options from parameters entered with the command
662 sscanf(Cmd, "%i %i %i %i", &rfLen, &invert, &fchigh, &fclow);
663
664 if (strlen(Cmd)>0 && strlen(Cmd)<=2) {
665 if (rfLen==1){
666 invert=1; //if invert option only is used
667 rfLen = 0;
668 }
669 }
670
671 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
672 size_t BitLen = getFromGraphBuf(BitStream);
673 //get field clock lengths
674 uint16_t fcs=0;
675 if (fchigh==0 || fclow == 0){
676 fcs=countFC(BitStream, BitLen);
677 if (fcs==0){
678 fchigh=10;
679 fclow=8;
680 }else{
681 fchigh = (fcs >> 8) & 0xFF;
682 fclow = fcs & 0xFF;
683 }
684 }
685 //get bit clock length
686 if (rfLen==0){
687 rfLen = detectFSKClk(BitStream, BitLen, fchigh, fclow);
688 if (rfLen == 0) rfLen = 50;
689 }
690 PrintAndLog("Args invert: %d - Clock:%d - fchigh:%d - fclow: %d",invert,rfLen,fchigh, fclow);
691 int size = fskdemod(BitStream,BitLen,(uint8_t)rfLen,(uint8_t)invert,(uint8_t)fchigh,(uint8_t)fclow);
692 if (size>0){
693 PrintAndLog("FSK decoded bitstream:");
694 setDemodBuf(BitStream,size,0);
695
696 // Now output the bitstream to the scrollback by line of 16 bits
697 if(size > (8*32)+2) size = (8*32)+2; //only output a max of 8 blocks of 32 bits most tags will have full bit stream inside that sample size
698 printBitStream(BitStream,size);
699 } else{
700 PrintAndLog("no FSK data found");
701 }
702 return 0;
703 }
704
705 //by marshmellow (based on existing demod + holiman's refactor)
706 //HID Prox demod - FSK RF/50 with preamble of 00011101 (then manchester encoded)
707 //print full HID Prox ID and some bit format details if found
708 int CmdFSKdemodHID(const char *Cmd)
709 {
710 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
711 uint32_t hi2=0, hi=0, lo=0;
712
713 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
714 size_t BitLen = getFromGraphBuf(BitStream);
715 //get binary from fsk wave
716 int idx = HIDdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
717 if (idx<0){
718 if (g_debugMode){
719 if (idx==-1){
720 PrintAndLog("DEBUG: Just Noise Detected");
721 } else if (idx == -2) {
722 PrintAndLog("DEBUG: Error demoding fsk");
723 } else if (idx == -3) {
724 PrintAndLog("DEBUG: Preamble not found");
725 } else if (idx == -4) {
726 PrintAndLog("DEBUG: Error in Manchester data, SIZE: %d", BitLen);
727 } else {
728 PrintAndLog("DEBUG: Error demoding fsk %d", idx);
729 }
730 }
731 return 0;
732 }
733 if (hi2==0 && hi==0 && lo==0) {
734 if (g_debugMode) PrintAndLog("DEBUG: Error - no values found");
735 return 0;
736 }
737 if (hi2 != 0){ //extra large HID tags
738 PrintAndLog("HID Prox TAG ID: %x%08x%08x (%d)",
739 (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
740 }
741 else { //standard HID tags <38 bits
742 uint8_t fmtLen = 0;
743 uint32_t fc = 0;
744 uint32_t cardnum = 0;
745 if (((hi>>5)&1)==1){//if bit 38 is set then < 37 bit format is used
746 uint32_t lo2=0;
747 lo2=(((hi & 31) << 12) | (lo>>20)); //get bits 21-37 to check for format len bit
748 uint8_t idx3 = 1;
749 while(lo2>1){ //find last bit set to 1 (format len bit)
750 lo2=lo2>>1;
751 idx3++;
752 }
753 fmtLen =idx3+19;
754 fc =0;
755 cardnum=0;
756 if(fmtLen==26){
757 cardnum = (lo>>1)&0xFFFF;
758 fc = (lo>>17)&0xFF;
759 }
760 if(fmtLen==34){
761 cardnum = (lo>>1)&0xFFFF;
762 fc= ((hi&1)<<15)|(lo>>17);
763 }
764 if(fmtLen==35){
765 cardnum = (lo>>1)&0xFFFFF;
766 fc = ((hi&1)<<11)|(lo>>21);
767 }
768 }
769 else { //if bit 38 is not set then 37 bit format is used
770 fmtLen = 37;
771 fc = 0;
772 cardnum = 0;
773 if(fmtLen == 37){
774 cardnum = (lo>>1)&0x7FFFF;
775 fc = ((hi&0xF)<<12)|(lo>>20);
776 }
777 }
778 PrintAndLog("HID Prox TAG ID: %x%08x (%d) - Format Len: %dbit - FC: %d - Card: %d",
779 (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF,
780 (unsigned int) fmtLen, (unsigned int) fc, (unsigned int) cardnum);
781 }
782 setDemodBuf(BitStream,BitLen,idx);
783 if (g_debugMode){
784 PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, BitLen);
785 printDemodBuff();
786 }
787 return 1;
788 }
789
790 //by marshmellow
791 //Paradox Prox demod - FSK RF/50 with preamble of 00001111 (then manchester encoded)
792 //print full Paradox Prox ID and some bit format details if found
793 int CmdFSKdemodParadox(const char *Cmd)
794 {
795 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
796 uint32_t hi2=0, hi=0, lo=0;
797
798 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
799 size_t BitLen = getFromGraphBuf(BitStream);
800 //get binary from fsk wave
801 int idx = ParadoxdemodFSK(BitStream,&BitLen,&hi2,&hi,&lo);
802 if (idx<0){
803 if (g_debugMode){
804 if (idx==-1){
805 PrintAndLog("DEBUG: Just Noise Detected");
806 } else if (idx == -2) {
807 PrintAndLog("DEBUG: Error demoding fsk");
808 } else if (idx == -3) {
809 PrintAndLog("DEBUG: Preamble not found");
810 } else if (idx == -4) {
811 PrintAndLog("DEBUG: Error in Manchester data");
812 } else {
813 PrintAndLog("DEBUG: Error demoding fsk %d", idx);
814 }
815 }
816 return 0;
817 }
818 if (hi2==0 && hi==0 && lo==0){
819 if (g_debugMode) PrintAndLog("DEBUG: Error - no value found");
820 return 0;
821 }
822 uint32_t fc = ((hi & 0x3)<<6) | (lo>>26);
823 uint32_t cardnum = (lo>>10)&0xFFFF;
824
825 PrintAndLog("Paradox TAG ID: %x%08x - FC: %d - Card: %d - Checksum: %02x",
826 hi>>10, (hi & 0x3)<<26 | (lo>>10), fc, cardnum, (lo>>2) & 0xFF );
827 setDemodBuf(BitStream,BitLen,idx);
828 if (g_debugMode){
829 PrintAndLog("DEBUG: idx: %d, len: %d, Printing Demod Buffer:", idx, BitLen);
830 printDemodBuff();
831 }
832 return 1;
833 }
834
835
836 //by marshmellow
837 //IO-Prox demod - FSK RF/64 with preamble of 000000001
838 //print ioprox ID and some format details
839 int CmdFSKdemodIO(const char *Cmd)
840 {
841 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
842 //set defaults
843 int idx=0;
844 //something in graphbuffer?
845 if (GraphTraceLen < 65) {
846 if (g_debugMode)PrintAndLog("DEBUG: not enough samples in GraphBuffer");
847 return 0;
848 }
849 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
850 size_t BitLen = getFromGraphBuf(BitStream);
851
852 //get binary from fsk wave
853 idx = IOdemodFSK(BitStream,BitLen);
854 if (idx<0){
855 if (g_debugMode){
856 if (idx==-1){
857 PrintAndLog("DEBUG: Just Noise Detected");
858 } else if (idx == -2) {
859 PrintAndLog("DEBUG: not enough samples");
860 } else if (idx == -3) {
861 PrintAndLog("DEBUG: error during fskdemod");
862 } else if (idx == -4) {
863 PrintAndLog("DEBUG: Preamble not found");
864 } else if (idx == -5) {
865 PrintAndLog("DEBUG: Separator bits not found");
866 } else {
867 PrintAndLog("DEBUG: Error demoding fsk %d", idx);
868 }
869 }
870 return 0;
871 }
872 if (idx==0){
873 if (g_debugMode==1){
874 PrintAndLog("DEBUG: IO Prox Data not found - FSK Bits: %d",BitLen);
875 if (BitLen > 92) printBitStream(BitStream,92);
876 }
877 return 0;
878 }
879 //Index map
880 //0 10 20 30 40 50 60
881 //| | | | | | |
882 //01234567 8 90123456 7 89012345 6 78901234 5 67890123 4 56789012 3 45678901 23
883 //-----------------------------------------------------------------------------
884 //00000000 0 11110000 1 facility 1 version* 1 code*one 1 code*two 1 ???????? 11
885 //
886 //XSF(version)facility:codeone+codetwo (raw)
887 //Handle the data
888 if (idx+64>BitLen) {
889 if (g_debugMode==1) PrintAndLog("not enough bits found - bitlen: %d",BitLen);
890 return 0;
891 }
892 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx], BitStream[idx+1], BitStream[idx+2], BitStream[idx+3], BitStream[idx+4], BitStream[idx+5], BitStream[idx+6], BitStream[idx+7], BitStream[idx+8]);
893 PrintAndLog("%d%d%d%d%d%d%d%d %d",BitStream[idx+9], BitStream[idx+10], BitStream[idx+11],BitStream[idx+12],BitStream[idx+13],BitStream[idx+14],BitStream[idx+15],BitStream[idx+16],BitStream[idx+17]);
894 PrintAndLog("%d%d%d%d%d%d%d%d %d facility",BitStream[idx+18], BitStream[idx+19], BitStream[idx+20],BitStream[idx+21],BitStream[idx+22],BitStream[idx+23],BitStream[idx+24],BitStream[idx+25],BitStream[idx+26]);
895 PrintAndLog("%d%d%d%d%d%d%d%d %d version",BitStream[idx+27], BitStream[idx+28], BitStream[idx+29],BitStream[idx+30],BitStream[idx+31],BitStream[idx+32],BitStream[idx+33],BitStream[idx+34],BitStream[idx+35]);
896 PrintAndLog("%d%d%d%d%d%d%d%d %d code1",BitStream[idx+36], BitStream[idx+37], BitStream[idx+38],BitStream[idx+39],BitStream[idx+40],BitStream[idx+41],BitStream[idx+42],BitStream[idx+43],BitStream[idx+44]);
897 PrintAndLog("%d%d%d%d%d%d%d%d %d code2",BitStream[idx+45], BitStream[idx+46], BitStream[idx+47],BitStream[idx+48],BitStream[idx+49],BitStream[idx+50],BitStream[idx+51],BitStream[idx+52],BitStream[idx+53]);
898 PrintAndLog("%d%d%d%d%d%d%d%d %d%d checksum",BitStream[idx+54],BitStream[idx+55],BitStream[idx+56],BitStream[idx+57],BitStream[idx+58],BitStream[idx+59],BitStream[idx+60],BitStream[idx+61],BitStream[idx+62],BitStream[idx+63]);
899
900 uint32_t code = bytebits_to_byte(BitStream+idx,32);
901 uint32_t code2 = bytebits_to_byte(BitStream+idx+32,32);
902 uint8_t version = bytebits_to_byte(BitStream+idx+27,8); //14,4
903 uint8_t facilitycode = bytebits_to_byte(BitStream+idx+18,8) ;
904 uint16_t number = (bytebits_to_byte(BitStream+idx+36,8)<<8)|(bytebits_to_byte(BitStream+idx+45,8)); //36,9
905 PrintAndLog("IO Prox XSF(%02d)%02x:%05d (%08x%08x)",version,facilitycode,number,code,code2);
906 setDemodBuf(BitStream,64,idx);
907 if (g_debugMode){
908 PrintAndLog("DEBUG: idx: %d, Len: %d, Printing demod buffer:",idx,64);
909 printDemodBuff();
910 }
911 return 1;
912 }
913
914
915 //by marshmellow
916 //AWID Prox demod - FSK RF/50 with preamble of 00000001 (always a 96 bit data stream)
917 //print full AWID Prox ID and some bit format details if found
918 int CmdFSKdemodAWID(const char *Cmd)
919 {
920
921 //int verbose=1;
922 //sscanf(Cmd, "%i", &verbose);
923
924 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
925 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
926 size_t size = getFromGraphBuf(BitStream);
927
928 //get binary from fsk wave
929 int idx = AWIDdemodFSK(BitStream, &size);
930 if (idx<=0){
931 if (g_debugMode==1){
932 if (idx == -1)
933 PrintAndLog("DEBUG: Error - not enough samples");
934 else if (idx == -2)
935 PrintAndLog("DEBUG: Error - only noise found");
936 else if (idx == -3)
937 PrintAndLog("DEBUG: Error - problem during FSK demod");
938 // else if (idx == -3)
939 // PrintAndLog("Error: thought we had a tag but the parity failed");
940 else if (idx == -4)
941 PrintAndLog("DEBUG: Error - AWID preamble not found");
942 else if (idx == -5)
943 PrintAndLog("DEBUG: Error - Size not correct: %d", size);
944 else
945 PrintAndLog("DEBUG: Error %d",idx);
946 }
947 return 0;
948 }
949
950 // Index map
951 // 0 10 20 30 40 50 60
952 // | | | | | | |
953 // 01234567 890 1 234 5 678 9 012 3 456 7 890 1 234 5 678 9 012 3 456 7 890 1 234 5 678 9 012 3 - to 96
954 // -----------------------------------------------------------------------------
955 // 00000001 000 1 110 1 101 1 011 1 101 1 010 0 000 1 000 1 010 0 001 0 110 1 100 0 000 1 000 1
956 // premable bbb o bbb o bbw o fff o fff o ffc o ccc o ccc o ccc o ccc o ccc o wxx o xxx o xxx o - to 96
957 // |---26 bit---| |-----117----||-------------142-------------|
958 // b = format bit len, o = odd parity of last 3 bits
959 // f = facility code, c = card number
960 // w = wiegand parity
961 // (26 bit format shown)
962
963 //get raw ID before removing parities
964 uint32_t rawLo = bytebits_to_byte(BitStream+idx+64,32);
965 uint32_t rawHi = bytebits_to_byte(BitStream+idx+32,32);
966 uint32_t rawHi2 = bytebits_to_byte(BitStream+idx,32);
967 setDemodBuf(BitStream,96,idx);
968
969 size = removeParity(BitStream, idx+8, 4, 1, 88);
970 if (size != 66){
971 if (g_debugMode==1) PrintAndLog("DEBUG: Error - at parity check-tag size does not match AWID format");
972 return 0;
973 }
974 // ok valid card found!
975
976 // Index map
977 // 0 10 20 30 40 50 60
978 // | | | | | | |
979 // 01234567 8 90123456 7890123456789012 3 456789012345678901234567890123456
980 // -----------------------------------------------------------------------------
981 // 00011010 1 01110101 0000000010001110 1 000000000000000000000000000000000
982 // bbbbbbbb w ffffffff cccccccccccccccc w xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
983 // |26 bit| |-117--| |-----142------|
984 // b = format bit len, o = odd parity of last 3 bits
985 // f = facility code, c = card number
986 // w = wiegand parity
987 // (26 bit format shown)
988
989 uint32_t fc = 0;
990 uint32_t cardnum = 0;
991 uint32_t code1 = 0;
992 uint32_t code2 = 0;
993 uint8_t fmtLen = bytebits_to_byte(BitStream,8);
994 if (fmtLen==26){
995 fc = bytebits_to_byte(BitStream+9, 8);
996 cardnum = bytebits_to_byte(BitStream+17, 16);
997 code1 = bytebits_to_byte(BitStream+8,fmtLen);
998 PrintAndLog("AWID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x", fmtLen, fc, cardnum, code1, rawHi2, rawHi, rawLo);
999 } else {
1000 cardnum = bytebits_to_byte(BitStream+8+(fmtLen-17), 16);
1001 if (fmtLen>32){
1002 code1 = bytebits_to_byte(BitStream+8,fmtLen-32);
1003 code2 = bytebits_to_byte(BitStream+8+(fmtLen-32),32);
1004 PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x%08x, Raw: %x%08x%08x", fmtLen, cardnum, code1, code2, rawHi2, rawHi, rawLo);
1005 } else{
1006 code1 = bytebits_to_byte(BitStream+8,fmtLen);
1007 PrintAndLog("AWID Found - BitLength: %d -unknown BitLength- (%d) - Wiegand: %x, Raw: %x%08x%08x", fmtLen, cardnum, code1, rawHi2, rawHi, rawLo);
1008 }
1009 }
1010 if (g_debugMode){
1011 PrintAndLog("DEBUG: idx: %d, Len: %d Printing Demod Buffer:", idx, 96);
1012 printDemodBuff();
1013 }
1014 //todo - convert hi2, hi, lo to demodbuffer for future sim/clone commands
1015 return 1;
1016 }
1017
1018 //by marshmellow
1019 //Pyramid Prox demod - FSK RF/50 with preamble of 0000000000000001 (always a 128 bit data stream)
1020 //print full Farpointe Data/Pyramid Prox ID and some bit format details if found
1021 int CmdFSKdemodPyramid(const char *Cmd)
1022 {
1023 //raw fsk demod no manchester decoding no start bit finding just get binary from wave
1024 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
1025 size_t size = getFromGraphBuf(BitStream);
1026
1027 //get binary from fsk wave
1028 int idx = PyramiddemodFSK(BitStream, &size);
1029 if (idx < 0){
1030 if (g_debugMode==1){
1031 if (idx == -5)
1032 PrintAndLog("DEBUG: Error - not enough samples");
1033 else if (idx == -1)
1034 PrintAndLog("DEBUG: Error - only noise found");
1035 else if (idx == -2)
1036 PrintAndLog("DEBUG: Error - problem during FSK demod");
1037 else if (idx == -3)
1038 PrintAndLog("DEBUG: Error - Size not correct: %d", size);
1039 else if (idx == -4)
1040 PrintAndLog("DEBUG: Error - Pyramid preamble not found");
1041 else
1042 PrintAndLog("DEBUG: Error - idx: %d",idx);
1043 }
1044 return 0;
1045 }
1046 // Index map
1047 // 0 10 20 30 40 50 60
1048 // | | | | | | |
1049 // 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3
1050 // -----------------------------------------------------------------------------
1051 // 0000000 0 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1 0000000 1
1052 // premable xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o xxxxxxx o
1053
1054 // 64 70 80 90 100 110 120
1055 // | | | | | | |
1056 // 4567890 1 2345678 9 0123456 7 8901234 5 6789012 3 4567890 1 2345678 9 0123456 7
1057 // -----------------------------------------------------------------------------
1058 // 0000000 1 0000000 1 0000000 1 0110111 0 0011000 1 0000001 0 0001100 1 1001010 0
1059 // xxxxxxx o xxxxxxx o xxxxxxx o xswffff o ffffccc o ccccccc o ccccccw o ppppppp o
1060 // |---115---||---------71---------|
1061 // s = format start bit, o = odd parity of last 7 bits
1062 // f = facility code, c = card number
1063 // w = wiegand parity, x = extra space for other formats
1064 // p = unknown checksum
1065 // (26 bit format shown)
1066
1067 //get raw ID before removing parities
1068 uint32_t rawLo = bytebits_to_byte(BitStream+idx+96,32);
1069 uint32_t rawHi = bytebits_to_byte(BitStream+idx+64,32);
1070 uint32_t rawHi2 = bytebits_to_byte(BitStream+idx+32,32);
1071 uint32_t rawHi3 = bytebits_to_byte(BitStream+idx,32);
1072 setDemodBuf(BitStream,128,idx);
1073
1074 size = removeParity(BitStream, idx+8, 8, 1, 120);
1075 if (size != 105){
1076 if (g_debugMode==1) PrintAndLog("DEBUG: Error at parity check-tag size does not match Pyramid format, SIZE: %d, IDX: %d, hi3: %x",size, idx, rawHi3);
1077 return 0;
1078 }
1079
1080 // ok valid card found!
1081
1082 // Index map
1083 // 0 10 20 30 40 50 60 70
1084 // | | | | | | | |
1085 // 01234567890123456789012345678901234567890123456789012345678901234567890
1086 // -----------------------------------------------------------------------
1087 // 00000000000000000000000000000000000000000000000000000000000000000000000
1088 // xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
1089
1090 // 71 80 90 100
1091 // | | | |
1092 // 1 2 34567890 1234567890123456 7 8901234
1093 // ---------------------------------------
1094 // 1 1 01110011 0000000001000110 0 1001010
1095 // s w ffffffff cccccccccccccccc w ppppppp
1096 // |--115-| |------71------|
1097 // s = format start bit, o = odd parity of last 7 bits
1098 // f = facility code, c = card number
1099 // w = wiegand parity, x = extra space for other formats
1100 // p = unknown checksum
1101 // (26 bit format shown)
1102
1103 //find start bit to get fmtLen
1104 int j;
1105 for (j=0; j<size; j++){
1106 if(BitStream[j]) break;
1107 }
1108 uint8_t fmtLen = size-j-8;
1109 uint32_t fc = 0;
1110 uint32_t cardnum = 0;
1111 uint32_t code1 = 0;
1112 //uint32_t code2 = 0;
1113 if (fmtLen==26){
1114 fc = bytebits_to_byte(BitStream+73, 8);
1115 cardnum = bytebits_to_byte(BitStream+81, 16);
1116 code1 = bytebits_to_byte(BitStream+72,fmtLen);
1117 PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Wiegand: %x, Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, code1, rawHi3, rawHi2, rawHi, rawLo);
1118 } else if (fmtLen==45){
1119 fmtLen=42; //end = 10 bits not 7 like 26 bit fmt
1120 fc = bytebits_to_byte(BitStream+53, 10);
1121 cardnum = bytebits_to_byte(BitStream+63, 32);
1122 PrintAndLog("Pyramid ID Found - BitLength: %d, FC: %d, Card: %d - Raw: %x%08x%08x%08x", fmtLen, fc, cardnum, rawHi3, rawHi2, rawHi, rawLo);
1123 } else {
1124 cardnum = bytebits_to_byte(BitStream+81, 16);
1125 if (fmtLen>32){
1126 //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen-32);
1127 //code2 = bytebits_to_byte(BitStream+(size-32),32);
1128 PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
1129 } else{
1130 //code1 = bytebits_to_byte(BitStream+(size-fmtLen),fmtLen);
1131 PrintAndLog("Pyramid ID Found - BitLength: %d -unknown BitLength- (%d), Raw: %x%08x%08x%08x", fmtLen, cardnum, rawHi3, rawHi2, rawHi, rawLo);
1132 }
1133 }
1134 if (g_debugMode){
1135 PrintAndLog("DEBUG: idx: %d, Len: %d, Printing Demod Buffer:", idx, 128);
1136 printDemodBuff();
1137 }
1138 return 1;
1139 }
1140
1141 int CmdFSKdemod(const char *Cmd) //old CmdFSKdemod needs updating
1142 {
1143 static const int LowTone[] = {
1144 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
1145 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
1146 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
1147 1, 1, 1, 1, 1, -1, -1, -1, -1, -1,
1148 1, 1, 1, 1, 1, -1, -1, -1, -1, -1
1149 };
1150 static const int HighTone[] = {
1151 1, 1, 1, 1, 1, -1, -1, -1, -1,
1152 1, 1, 1, 1, -1, -1, -1, -1,
1153 1, 1, 1, 1, -1, -1, -1, -1,
1154 1, 1, 1, 1, -1, -1, -1, -1,
1155 1, 1, 1, 1, -1, -1, -1, -1,
1156 1, 1, 1, 1, -1, -1, -1, -1, -1,
1157 };
1158
1159 int lowLen = sizeof (LowTone) / sizeof (int);
1160 int highLen = sizeof (HighTone) / sizeof (int);
1161 int convLen = (highLen > lowLen) ? highLen : lowLen;
1162 uint32_t hi = 0, lo = 0;
1163
1164 int i, j;
1165 int minMark = 0, maxMark = 0;
1166
1167 for (i = 0; i < GraphTraceLen - convLen; ++i) {
1168 int lowSum = 0, highSum = 0;
1169
1170 for (j = 0; j < lowLen; ++j) {
1171 lowSum += LowTone[j]*GraphBuffer[i+j];
1172 }
1173 for (j = 0; j < highLen; ++j) {
1174 highSum += HighTone[j] * GraphBuffer[i + j];
1175 }
1176 lowSum = abs(100 * lowSum / lowLen);
1177 highSum = abs(100 * highSum / highLen);
1178 GraphBuffer[i] = (highSum << 16) | lowSum;
1179 }
1180
1181 for(i = 0; i < GraphTraceLen - convLen - 16; ++i) {
1182 int lowTot = 0, highTot = 0;
1183 // 10 and 8 are f_s divided by f_l and f_h, rounded
1184 for (j = 0; j < 10; ++j) {
1185 lowTot += (GraphBuffer[i+j] & 0xffff);
1186 }
1187 for (j = 0; j < 8; j++) {
1188 highTot += (GraphBuffer[i + j] >> 16);
1189 }
1190 GraphBuffer[i] = lowTot - highTot;
1191 if (GraphBuffer[i] > maxMark) maxMark = GraphBuffer[i];
1192 if (GraphBuffer[i] < minMark) minMark = GraphBuffer[i];
1193 }
1194
1195 GraphTraceLen -= (convLen + 16);
1196 RepaintGraphWindow();
1197
1198 // Find bit-sync (3 lo followed by 3 high) (HID ONLY)
1199 int max = 0, maxPos = 0;
1200 for (i = 0; i < 6000; ++i) {
1201 int dec = 0;
1202 for (j = 0; j < 3 * lowLen; ++j) {
1203 dec -= GraphBuffer[i + j];
1204 }
1205 for (; j < 3 * (lowLen + highLen ); ++j) {
1206 dec += GraphBuffer[i + j];
1207 }
1208 if (dec > max) {
1209 max = dec;
1210 maxPos = i;
1211 }
1212 }
1213
1214 // place start of bit sync marker in graph
1215 GraphBuffer[maxPos] = maxMark;
1216 GraphBuffer[maxPos + 1] = minMark;
1217
1218 maxPos += j;
1219
1220 // place end of bit sync marker in graph
1221 GraphBuffer[maxPos] = maxMark;
1222 GraphBuffer[maxPos+1] = minMark;
1223
1224 PrintAndLog("actual data bits start at sample %d", maxPos);
1225 PrintAndLog("length %d/%d", highLen, lowLen);
1226
1227 uint8_t bits[46] = {0x00};
1228
1229 // find bit pairs and manchester decode them
1230 for (i = 0; i < arraylen(bits) - 1; ++i) {
1231 int dec = 0;
1232 for (j = 0; j < lowLen; ++j) {
1233 dec -= GraphBuffer[maxPos + j];
1234 }
1235 for (; j < lowLen + highLen; ++j) {
1236 dec += GraphBuffer[maxPos + j];
1237 }
1238 maxPos += j;
1239 // place inter bit marker in graph
1240 GraphBuffer[maxPos] = maxMark;
1241 GraphBuffer[maxPos + 1] = minMark;
1242
1243 // hi and lo form a 64 bit pair
1244 hi = (hi << 1) | (lo >> 31);
1245 lo = (lo << 1);
1246 // store decoded bit as binary (in hi/lo) and text (in bits[])
1247 if(dec < 0) {
1248 bits[i] = '1';
1249 lo |= 1;
1250 } else {
1251 bits[i] = '0';
1252 }
1253 }
1254 PrintAndLog("bits: '%s'", bits);
1255 PrintAndLog("hex: %08x %08x", hi, lo);
1256 return 0;
1257 }
1258
1259 //by marshmellow
1260 //attempt to detect the field clock and bit clock for FSK
1261 int CmdFSKfcDetect(const char *Cmd)
1262 {
1263 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
1264 size_t size = getFromGraphBuf(BitStream);
1265
1266 uint16_t ans = countFC(BitStream, size);
1267 if (ans==0) {
1268 if (g_debugMode) PrintAndLog("DEBUG: No data found");
1269 return 0;
1270 }
1271 uint8_t fc1, fc2;
1272 fc1 = (ans >> 8) & 0xFF;
1273 fc2 = ans & 0xFF;
1274
1275 uint8_t rf1 = detectFSKClk(BitStream, size, fc1, fc2);
1276 if (rf1==0) {
1277 if (g_debugMode) PrintAndLog("DEBUG: Clock detect error");
1278 return 0;
1279 }
1280 PrintAndLog("Detected Field Clocks: FC/%d, FC/%d - Bit Clock: RF/%d", fc1, fc2, rf1);
1281 return 1;
1282 }
1283
1284 //by marshmellow
1285 //attempt to detect the bit clock for PSK or NRZ modulations
1286 int CmdDetectNRZpskClockRate(const char *Cmd)
1287 {
1288 GetNRZpskClock("",0,0);
1289 return 0;
1290 }
1291
1292 //by marshmellow
1293 //attempt to psk1 or nrz demod graph buffer
1294 //NOTE CURRENTLY RELIES ON PEAKS :(
1295 int PSKnrzDemod(const char *Cmd, uint8_t verbose)
1296 {
1297 int invert=0;
1298 int clk=0;
1299 sscanf(Cmd, "%i %i", &clk, &invert);
1300 if (invert != 0 && invert != 1) {
1301 PrintAndLog("Invalid argument: %s", Cmd);
1302 return -1;
1303 }
1304 uint8_t BitStream[MAX_GRAPH_TRACE_LEN]={0};
1305 size_t BitLen = getFromGraphBuf(BitStream);
1306 int errCnt=0;
1307 errCnt = pskNRZrawDemod(BitStream, &BitLen,&clk,&invert);
1308 if (errCnt<0|| BitLen<16){ //throw away static - allow 1 and -1 (in case of threshold command first)
1309 if (g_debugMode==1) PrintAndLog("no data found, clk: %d, invert: %d, numbits: %d, errCnt: %d",clk,invert,BitLen,errCnt);
1310 return -1;
1311 }
1312 if (verbose) PrintAndLog("Tried PSK/NRZ Demod using Clock: %d - invert: %d - Bits Found: %d",clk,invert,BitLen);
1313
1314 //prime demod buffer for output
1315 setDemodBuf(BitStream,BitLen,0);
1316 return errCnt;
1317 }
1318 // Indala 26 bit decode
1319 // by marshmellow
1320 // optional arguments - same as CmdpskNRZrawDemod (clock & invert)
1321 int CmdIndalaDecode(const char *Cmd)
1322 {
1323 int ans;
1324 if (strlen(Cmd)>0){
1325 ans = PSKnrzDemod(Cmd, 0);
1326 } else{ //default to RF/32
1327 ans = PSKnrzDemod("32", 0);
1328 }
1329
1330 if (ans < 0){
1331 if (g_debugMode==1)
1332 PrintAndLog("Error1: %d",ans);
1333 return 0;
1334 }
1335 uint8_t invert=0;
1336 ans = indala26decode(DemodBuffer,(size_t *) &DemodBufferLen, &invert);
1337 if (ans < 1) {
1338 if (g_debugMode==1)
1339 PrintAndLog("Error2: %d",ans);
1340 return -1;
1341 }
1342 char showbits[251]={0x00};
1343 if (invert)
1344 if (g_debugMode==1)
1345 PrintAndLog("Had to invert bits");
1346
1347 //convert UID to HEX
1348 uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7;
1349 int idx;
1350 uid1=0;
1351 uid2=0;
1352 PrintAndLog("BitLen: %d",DemodBufferLen);
1353 if (DemodBufferLen==64){
1354 for( idx=0; idx<64; idx++) {
1355 uid1=(uid1<<1)|(uid2>>31);
1356 if (DemodBuffer[idx] == 0) {
1357 uid2=(uid2<<1)|0;
1358 showbits[idx]='0';
1359 } else {
1360 uid2=(uid2<<1)|1;
1361 showbits[idx]='1';
1362 }
1363 }
1364 showbits[idx]='\0';
1365 PrintAndLog("Indala UID=%s (%x%08x)", showbits, uid1, uid2);
1366 }
1367 else {
1368 uid3=0;
1369 uid4=0;
1370 uid5=0;
1371 uid6=0;
1372 uid7=0;
1373 for( idx=0; idx<DemodBufferLen; idx++) {
1374 uid1=(uid1<<1)|(uid2>>31);
1375 uid2=(uid2<<1)|(uid3>>31);
1376 uid3=(uid3<<1)|(uid4>>31);
1377 uid4=(uid4<<1)|(uid5>>31);
1378 uid5=(uid5<<1)|(uid6>>31);
1379 uid6=(uid6<<1)|(uid7>>31);
1380 if (DemodBuffer[idx] == 0) {
1381 uid7=(uid7<<1)|0;
1382 showbits[idx]='0';
1383 }
1384 else {
1385 uid7=(uid7<<1)|1;
1386 showbits[idx]='1';
1387 }
1388 }
1389 showbits[idx]='\0';
1390 PrintAndLog("Indala UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7);
1391 }
1392 if (g_debugMode){
1393 PrintAndLog("DEBUG: printing demodbuffer:");
1394 printDemodBuff();
1395 }
1396 return 1;
1397 }
1398
1399 //by marshmellow
1400 //attempt to clean psk wave noise after a peak
1401 //NOTE RELIES ON PEAKS :(
1402 int CmdPskClean(const char *Cmd)
1403 {
1404 uint8_t bitStream[MAX_GRAPH_TRACE_LEN]={0};
1405 size_t bitLen = getFromGraphBuf(bitStream);
1406 pskCleanWave(bitStream, bitLen);
1407 setGraphBuf(bitStream, bitLen);
1408 return 0;
1409 }
1410
1411 // by marshmellow
1412 // takes 2 arguments - clock and invert both as integers
1413 // attempts to demodulate psk only
1414 // prints binary found and saves in demodbuffer for further commands
1415 int CmdpskNRZrawDemod(const char *Cmd)
1416 {
1417 int errCnt;
1418
1419 errCnt = PSKnrzDemod(Cmd, 1);
1420 //output
1421 if (errCnt<0){
1422 if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);
1423 return 0;
1424 }
1425 if (errCnt>0){
1426 if (g_debugMode){
1427 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
1428 PrintAndLog("PSK or NRZ demoded bitstream:");
1429 // Now output the bitstream to the scrollback by line of 16 bits
1430 printDemodBuff();
1431 }
1432 }else{
1433 PrintAndLog("PSK or NRZ demoded bitstream:");
1434 // Now output the bitstream to the scrollback by line of 16 bits
1435 printDemodBuff();
1436 return 1;
1437 }
1438 return 0;
1439 }
1440
1441 // by marshmellow
1442 // takes same args as cmdpsknrzrawdemod
1443 int CmdPSK2rawDemod(const char *Cmd)
1444 {
1445 int errCnt=0;
1446 errCnt=PSKnrzDemod(Cmd, 1);
1447 if (errCnt<0){
1448 if (g_debugMode) PrintAndLog("Error demoding: %d",errCnt);
1449 return 0;
1450 }
1451 psk1TOpsk2(DemodBuffer, DemodBufferLen);
1452 if (errCnt>0){
1453 if (g_debugMode){
1454 PrintAndLog("# Errors during Demoding (shown as 77 in bit stream): %d",errCnt);
1455 PrintAndLog("PSK2 demoded bitstream:");
1456 // Now output the bitstream to the scrollback by line of 16 bits
1457 printDemodBuff();
1458 }
1459 }else{
1460 PrintAndLog("PSK2 demoded bitstream:");
1461 // Now output the bitstream to the scrollback by line of 16 bits
1462 printDemodBuff();
1463 }
1464 return 1;
1465 }
1466
1467 int CmdGrid(const char *Cmd)
1468 {
1469 sscanf(Cmd, "%i %i", &PlotGridX, &PlotGridY);
1470 PlotGridXdefault= PlotGridX;
1471 PlotGridYdefault= PlotGridY;
1472 RepaintGraphWindow();
1473 return 0;
1474 }
1475
1476 int CmdHexsamples(const char *Cmd)
1477 {
1478 int i, j;
1479 int requested = 0;
1480 int offset = 0;
1481 char string_buf[25];
1482 char* string_ptr = string_buf;
1483 uint8_t got[BIGBUF_SIZE];
1484
1485 sscanf(Cmd, "%i %i", &requested, &offset);
1486
1487 /* if no args send something */
1488 if (requested == 0) {
1489 requested = 8;
1490 }
1491 if (offset + requested > sizeof(got)) {
1492 PrintAndLog("Tried to read past end of buffer, <bytes> + <offset> > %d", BIGBUF_SIZE);
1493 return 0;
1494 }
1495
1496 GetFromBigBuf(got,requested,offset);
1497 WaitForResponse(CMD_ACK,NULL);
1498
1499 i = 0;
1500 for (j = 0; j < requested; j++) {
1501 i++;
1502 string_ptr += sprintf(string_ptr, "%02x ", got[j]);
1503 if (i == 8) {
1504 *(string_ptr - 1) = '\0'; // remove the trailing space
1505 PrintAndLog("%s", string_buf);
1506 string_buf[0] = '\0';
1507 string_ptr = string_buf;
1508 i = 0;
1509 }
1510 if (j == requested - 1 && string_buf[0] != '\0') { // print any remaining bytes
1511 *(string_ptr - 1) = '\0';
1512 PrintAndLog("%s", string_buf);
1513 string_buf[0] = '\0';
1514 }
1515 }
1516 return 0;
1517 }
1518
1519 int CmdHide(const char *Cmd)
1520 {
1521 HideGraphWindow();
1522 return 0;
1523 }
1524
1525 int CmdHpf(const char *Cmd)
1526 {
1527 int i;
1528 int accum = 0;
1529
1530 for (i = 10; i < GraphTraceLen; ++i)
1531 accum += GraphBuffer[i];
1532 accum /= (GraphTraceLen - 10);
1533 for (i = 0; i < GraphTraceLen; ++i)
1534 GraphBuffer[i] -= accum;
1535
1536 RepaintGraphWindow();
1537 return 0;
1538 }
1539 typedef struct {
1540 uint8_t * buffer;
1541 uint32_t numbits;
1542 uint32_t position;
1543 }BitstreamOut;
1544
1545 bool _headBit( BitstreamOut *stream)
1546 {
1547 int bytepos = stream->position >> 3; // divide by 8
1548 int bitpos = (stream->position++) & 7; // mask out 00000111
1549 return (*(stream->buffer + bytepos) >> (7-bitpos)) & 1;
1550 }
1551
1552 uint8_t getByte(uint8_t bits_per_sample, BitstreamOut* b)
1553 {
1554 int i;
1555 uint8_t val = 0;
1556 for(i =0 ; i < bits_per_sample; i++)
1557 {
1558 val |= (_headBit(b) << (7-i));
1559 }
1560 return val;
1561 }
1562
1563 int CmdSamples(const char *Cmd)
1564 {
1565 //If we get all but the last byte in bigbuf,
1566 // we don't have to worry about remaining trash
1567 // in the last byte in case the bits-per-sample
1568 // does not line up on byte boundaries
1569 uint8_t got[BIGBUF_SIZE-1] = { 0 };
1570
1571 int n = strtol(Cmd, NULL, 0);
1572 if (n == 0)
1573 n = sizeof(got);
1574
1575 if (n > sizeof(got))
1576 n = sizeof(got);
1577
1578 PrintAndLog("Reading %d bytes from device memory\n", n);
1579 GetFromBigBuf(got,n,0);
1580 PrintAndLog("Data fetched");
1581 UsbCommand response;
1582 WaitForResponse(CMD_ACK, &response);
1583 uint8_t bits_per_sample = 8;
1584
1585 //Old devices without this feature would send 0 at arg[0]
1586 if(response.arg[0] > 0)
1587 {
1588 sample_config *sc = (sample_config *) response.d.asBytes;
1589 PrintAndLog("Samples @ %d bits/smpl, decimation 1:%d ", sc->bits_per_sample
1590 , sc->decimation);
1591 bits_per_sample = sc->bits_per_sample;
1592 }
1593 if(bits_per_sample < 8)
1594 {
1595 PrintAndLog("Unpacking...");
1596 BitstreamOut bout = { got, bits_per_sample * n, 0};
1597 int j =0;
1598 for (j = 0; j * bits_per_sample < n * 8 && j < sizeof(GraphBuffer); j++) {
1599 uint8_t sample = getByte(bits_per_sample, &bout);
1600 GraphBuffer[j] = ((int) sample )- 128;
1601 }
1602 GraphTraceLen = j;
1603 PrintAndLog("Unpacked %d samples" , j );
1604 }else
1605 {
1606 for (int j = 0; j < n; j++) {
1607 GraphBuffer[j] = ((int)got[j]) - 128;
1608 }
1609 GraphTraceLen = n;
1610 }
1611
1612 RepaintGraphWindow();
1613 return 0;
1614 }
1615
1616 int CmdTuneSamples(const char *Cmd)
1617 {
1618 int timeout = 0;
1619 printf("\nMeasuring antenna characteristics, please wait...");
1620
1621 UsbCommand c = {CMD_MEASURE_ANTENNA_TUNING};
1622 SendCommand(&c);
1623
1624 UsbCommand resp;
1625 while(!WaitForResponseTimeout(CMD_MEASURED_ANTENNA_TUNING,&resp,1000)) {
1626 timeout++;
1627 printf(".");
1628 if (timeout > 7) {
1629 PrintAndLog("\nNo response from Proxmark. Aborting...");
1630 return 1;
1631 }
1632 }
1633
1634 int peakv, peakf;
1635 int vLf125, vLf134, vHf;
1636 vLf125 = resp.arg[0] & 0xffff;
1637 vLf134 = resp.arg[0] >> 16;
1638 vHf = resp.arg[1] & 0xffff;;
1639 peakf = resp.arg[2] & 0xffff;
1640 peakv = resp.arg[2] >> 16;
1641 PrintAndLog("");
1642 PrintAndLog("# LF antenna: %5.2f V @ 125.00 kHz", vLf125/1000.0);
1643 PrintAndLog("# LF antenna: %5.2f V @ 134.00 kHz", vLf134/1000.0);
1644 PrintAndLog("# LF optimal: %5.2f V @%9.2f kHz", peakv/1000.0, 12000.0/(peakf+1));
1645 PrintAndLog("# HF antenna: %5.2f V @ 13.56 MHz", vHf/1000.0);
1646 if (peakv<2000)
1647 PrintAndLog("# Your LF antenna is unusable.");
1648 else if (peakv<10000)
1649 PrintAndLog("# Your LF antenna is marginal.");
1650 if (vHf<2000)
1651 PrintAndLog("# Your HF antenna is unusable.");
1652 else if (vHf<5000)
1653 PrintAndLog("# Your HF antenna is marginal.");
1654
1655 for (int i = 0; i < 256; i++) {
1656 GraphBuffer[i] = resp.d.asBytes[i] - 128;
1657 }
1658
1659 PrintAndLog("Done! Divisor 89 is 134khz, 95 is 125khz.\n");
1660 PrintAndLog("\n");
1661 GraphTraceLen = 256;
1662 ShowGraphWindow();
1663
1664 return 0;
1665 }
1666
1667
1668 int CmdLoad(const char *Cmd)
1669 {
1670 char filename[FILE_PATH_SIZE] = {0x00};
1671 int len = 0;
1672
1673 len = strlen(Cmd);
1674 if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
1675 memcpy(filename, Cmd, len);
1676
1677 FILE *f = fopen(filename, "r");
1678 if (!f) {
1679 PrintAndLog("couldn't open '%s'", filename);
1680 return 0;
1681 }
1682
1683 GraphTraceLen = 0;
1684 char line[80];
1685 while (fgets(line, sizeof (line), f)) {
1686 GraphBuffer[GraphTraceLen] = atoi(line);
1687 GraphTraceLen++;
1688 }
1689 fclose(f);
1690 PrintAndLog("loaded %d samples", GraphTraceLen);
1691 RepaintGraphWindow();
1692 return 0;
1693 }
1694
1695 int CmdLtrim(const char *Cmd)
1696 {
1697 int ds = atoi(Cmd);
1698
1699 for (int i = ds; i < GraphTraceLen; ++i)
1700 GraphBuffer[i-ds] = GraphBuffer[i];
1701 GraphTraceLen -= ds;
1702
1703 RepaintGraphWindow();
1704 return 0;
1705 }
1706
1707 // trim graph to input argument length
1708 int CmdRtrim(const char *Cmd)
1709 {
1710 int ds = atoi(Cmd);
1711
1712 GraphTraceLen = ds;
1713
1714 RepaintGraphWindow();
1715 return 0;
1716 }
1717
1718 /*
1719 * Manchester demodulate a bitstream. The bitstream needs to be already in
1720 * the GraphBuffer as 0 and 1 values
1721 *
1722 * Give the clock rate as argument in order to help the sync - the algorithm
1723 * resyncs at each pulse anyway.
1724 *
1725 * Not optimized by any means, this is the 1st time I'm writing this type of
1726 * routine, feel free to improve...
1727 *
1728 * 1st argument: clock rate (as number of samples per clock rate)
1729 * Typical values can be 64, 32, 128...
1730 */
1731 int CmdManchesterDemod(const char *Cmd)
1732 {
1733 int i, j, invert= 0;
1734 int bit;
1735 int clock;
1736 int lastval = 0;
1737 int low = 0;
1738 int high = 0;
1739 int hithigh, hitlow, first;
1740 int lc = 0;
1741 int bitidx = 0;
1742 int bit2idx = 0;
1743 int warnings = 0;
1744
1745 /* check if we're inverting output */
1746 if (*Cmd == 'i')
1747 {
1748 PrintAndLog("Inverting output");
1749 invert = 1;
1750 ++Cmd;
1751 do
1752 ++Cmd;
1753 while(*Cmd == ' '); // in case a 2nd argument was given
1754 }
1755
1756 /* Holds the decoded bitstream: each clock period contains 2 bits */
1757 /* later simplified to 1 bit after manchester decoding. */
1758 /* Add 10 bits to allow for noisy / uncertain traces without aborting */
1759 /* int BitStream[GraphTraceLen*2/clock+10]; */
1760
1761 /* But it does not work if compiling on WIndows: therefore we just allocate a */
1762 /* large array */
1763 uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0};
1764
1765 /* Detect high and lows */
1766 for (i = 0; i < GraphTraceLen; i++)
1767 {
1768 if (GraphBuffer[i] > high)
1769 high = GraphBuffer[i];
1770 else if (GraphBuffer[i] < low)
1771 low = GraphBuffer[i];
1772 }
1773
1774 /* Get our clock */
1775 clock = GetClock(Cmd, high, 1);
1776
1777 int tolerance = clock/4;
1778
1779 /* Detect first transition */
1780 /* Lo-Hi (arbitrary) */
1781 /* skip to the first high */
1782 for (i= 0; i < GraphTraceLen; i++)
1783 if (GraphBuffer[i] == high)
1784 break;
1785 /* now look for the first low */
1786 for (; i < GraphTraceLen; i++)
1787 {
1788 if (GraphBuffer[i] == low)
1789 {
1790 lastval = i;
1791 break;
1792 }
1793 }
1794
1795 /* If we're not working with 1/0s, demod based off clock */
1796 if (high != 1)
1797 {
1798 bit = 0; /* We assume the 1st bit is zero, it may not be
1799 * the case: this routine (I think) has an init problem.
1800 * Ed.
1801 */
1802 for (; i < (int)(GraphTraceLen / clock); i++)
1803 {
1804 hithigh = 0;
1805 hitlow = 0;
1806 first = 1;
1807
1808 /* Find out if we hit both high and low peaks */
1809 for (j = 0; j < clock; j++)
1810 {
1811 if (GraphBuffer[(i * clock) + j] == high)
1812 hithigh = 1;
1813 else if (GraphBuffer[(i * clock) + j] == low)
1814 hitlow = 1;
1815
1816 /* it doesn't count if it's the first part of our read
1817 because it's really just trailing from the last sequence */
1818 if (first && (hithigh || hitlow))
1819 hithigh = hitlow = 0;
1820 else
1821 first = 0;
1822
1823 if (hithigh && hitlow)
1824 break;
1825 }
1826
1827 /* If we didn't hit both high and low peaks, we had a bit transition */
1828 if (!hithigh || !hitlow)
1829 bit ^= 1;
1830
1831 BitStream[bit2idx++] = bit ^ invert;
1832 }
1833 }
1834
1835 /* standard 1/0 bitstream */
1836 else
1837 {
1838
1839 /* Then detect duration between 2 successive transitions */
1840 for (bitidx = 1; i < GraphTraceLen; i++)
1841 {
1842 if (GraphBuffer[i-1] != GraphBuffer[i])
1843 {
1844 lc = i-lastval;
1845 lastval = i;
1846
1847 // Error check: if bitidx becomes too large, we do not
1848 // have a Manchester encoded bitstream or the clock is really
1849 // wrong!
1850 if (bitidx > (GraphTraceLen*2/clock+8) ) {
1851 PrintAndLog("Error: the clock you gave is probably wrong, aborting.");
1852 return 0;
1853 }
1854 // Then switch depending on lc length:
1855 // Tolerance is 1/4 of clock rate (arbitrary)
1856 if (abs(lc-clock/2) < tolerance) {
1857 // Short pulse : either "1" or "0"
1858 BitStream[bitidx++]=GraphBuffer[i-1];
1859 } else if (abs(lc-clock) < tolerance) {
1860 // Long pulse: either "11" or "00"
1861 BitStream[bitidx++]=GraphBuffer[i-1];
1862 BitStream[bitidx++]=GraphBuffer[i-1];
1863 } else {
1864 // Error
1865 warnings++;
1866 PrintAndLog("Warning: Manchester decode error for pulse width detection.");
1867 PrintAndLog("(too many of those messages mean either the stream is not Manchester encoded, or clock is wrong)");
1868
1869 if (warnings > 10)
1870 {
1871 PrintAndLog("Error: too many detection errors, aborting.");
1872 return 0;
1873 }
1874 }
1875 }
1876 }
1877
1878 // At this stage, we now have a bitstream of "01" ("1") or "10" ("0"), parse it into final decoded bitstream
1879 // Actually, we overwrite BitStream with the new decoded bitstream, we just need to be careful
1880 // to stop output at the final bitidx2 value, not bitidx
1881 for (i = 0; i < bitidx; i += 2) {
1882 if ((BitStream[i] == 0) && (BitStream[i+1] == 1)) {
1883 BitStream[bit2idx++] = 1 ^ invert;
1884 } else if ((BitStream[i] == 1) && (BitStream[i+1] == 0)) {
1885 BitStream[bit2idx++] = 0 ^ invert;
1886 } else {
1887 // We cannot end up in this state, this means we are unsynchronized,
1888 // move up 1 bit:
1889 i++;
1890 warnings++;
1891 PrintAndLog("Unsynchronized, resync...");
1892 PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
1893
1894 if (warnings > 10)
1895 {
1896 PrintAndLog("Error: too many decode errors, aborting.");
1897 return 0;
1898 }
1899 }
1900 }
1901 }
1902
1903 PrintAndLog("Manchester decoded bitstream");
1904 // Now output the bitstream to the scrollback by line of 16 bits
1905 for (i = 0; i < (bit2idx-16); i+=16) {
1906 PrintAndLog("%i %i %i %i %i %i %i %i %i %i %i %i %i %i %i %i",
1907 BitStream[i],
1908 BitStream[i+1],
1909 BitStream[i+2],
1910 BitStream[i+3],
1911 BitStream[i+4],
1912 BitStream[i+5],
1913 BitStream[i+6],
1914 BitStream[i+7],
1915 BitStream[i+8],
1916 BitStream[i+9],
1917 BitStream[i+10],
1918 BitStream[i+11],
1919 BitStream[i+12],
1920 BitStream[i+13],
1921 BitStream[i+14],
1922 BitStream[i+15]);
1923 }
1924 return 0;
1925 }
1926
1927 /* Modulate our data into manchester */
1928 int CmdManchesterMod(const char *Cmd)
1929 {
1930 int i, j;
1931 int clock;
1932 int bit, lastbit, wave;
1933
1934 /* Get our clock */
1935 clock = GetClock(Cmd, 0, 1);
1936
1937 wave = 0;
1938 lastbit = 1;
1939 for (i = 0; i < (int)(GraphTraceLen / clock); i++)
1940 {
1941 bit = GraphBuffer[i * clock] ^ 1;
1942
1943 for (j = 0; j < (int)(clock/2); j++)
1944 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave;
1945 for (j = (int)(clock/2); j < clock; j++)
1946 GraphBuffer[(i * clock) + j] = bit ^ lastbit ^ wave ^ 1;
1947
1948 /* Keep track of how we start our wave and if we changed or not this time */
1949 wave ^= bit ^ lastbit;
1950 lastbit = bit;
1951 }
1952
1953 RepaintGraphWindow();
1954 return 0;
1955 }
1956
1957 int CmdNorm(const char *Cmd)
1958 {
1959 int i;
1960 int max = INT_MIN, min = INT_MAX;
1961
1962 for (i = 10; i < GraphTraceLen; ++i) {
1963 if (GraphBuffer[i] > max)
1964 max = GraphBuffer[i];
1965 if (GraphBuffer[i] < min)
1966 min = GraphBuffer[i];
1967 }
1968
1969 if (max != min) {
1970 for (i = 0; i < GraphTraceLen; ++i) {
1971 GraphBuffer[i] = (GraphBuffer[i] - ((max + min) / 2)) * 256 /
1972 (max - min);
1973 //marshmelow: adjusted *1000 to *256 to make +/- 128 so demod commands still work
1974 }
1975 }
1976 RepaintGraphWindow();
1977 return 0;
1978 }
1979
1980 int CmdPlot(const char *Cmd)
1981 {
1982 ShowGraphWindow();
1983 return 0;
1984 }
1985
1986 int CmdSave(const char *Cmd)
1987 {
1988 char filename[FILE_PATH_SIZE] = {0x00};
1989 int len = 0;
1990
1991 len = strlen(Cmd);
1992 if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
1993 memcpy(filename, Cmd, len);
1994
1995
1996 FILE *f = fopen(filename, "w");
1997 if(!f) {
1998 PrintAndLog("couldn't open '%s'", filename);
1999 return 0;
2000 }
2001 int i;
2002 for (i = 0; i < GraphTraceLen; i++) {
2003 fprintf(f, "%d\n", GraphBuffer[i]);
2004 }
2005 fclose(f);
2006 PrintAndLog("saved to '%s'", Cmd);
2007 return 0;
2008 }
2009
2010 int CmdScale(const char *Cmd)
2011 {
2012 CursorScaleFactor = atoi(Cmd);
2013 if (CursorScaleFactor == 0) {
2014 PrintAndLog("bad, can't have zero scale");
2015 CursorScaleFactor = 1;
2016 }
2017 RepaintGraphWindow();
2018 return 0;
2019 }
2020
2021 int CmdThreshold(const char *Cmd)
2022 {
2023 int threshold = atoi(Cmd);
2024
2025 for (int i = 0; i < GraphTraceLen; ++i) {
2026 if (GraphBuffer[i] >= threshold)
2027 GraphBuffer[i] = 1;
2028 else
2029 GraphBuffer[i] = -1;
2030 }
2031 RepaintGraphWindow();
2032 return 0;
2033 }
2034
2035 int CmdDirectionalThreshold(const char *Cmd)
2036 {
2037 int8_t upThres = param_get8(Cmd, 0);
2038 int8_t downThres = param_get8(Cmd, 1);
2039
2040 printf("Applying Up Threshold: %d, Down Threshold: %d\n", upThres, downThres);
2041
2042 int lastValue = GraphBuffer[0];
2043 GraphBuffer[0] = 0; // Will be changed at the end, but init 0 as we adjust to last samples value if no threshold kicks in.
2044
2045 for (int i = 1; i < GraphTraceLen; ++i) {
2046 // Apply first threshold to samples heading up
2047 if (GraphBuffer[i] >= upThres && GraphBuffer[i] > lastValue)
2048 {
2049 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
2050 GraphBuffer[i] = 1;
2051 }
2052 // Apply second threshold to samples heading down
2053 else if (GraphBuffer[i] <= downThres && GraphBuffer[i] < lastValue)
2054 {
2055 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
2056 GraphBuffer[i] = -1;
2057 }
2058 else
2059 {
2060 lastValue = GraphBuffer[i]; // Buffer last value as we overwrite it.
2061 GraphBuffer[i] = GraphBuffer[i-1];
2062
2063 }
2064 }
2065 GraphBuffer[0] = GraphBuffer[1]; // Aline with first edited sample.
2066 RepaintGraphWindow();
2067 return 0;
2068 }
2069
2070 int CmdZerocrossings(const char *Cmd)
2071 {
2072 // Zero-crossings aren't meaningful unless the signal is zero-mean.
2073 CmdHpf("");
2074
2075 int sign = 1;
2076 int zc = 0;
2077 int lastZc = 0;
2078
2079 for (int i = 0; i < GraphTraceLen; ++i) {
2080 if (GraphBuffer[i] * sign >= 0) {
2081 // No change in sign, reproduce the previous sample count.
2082 zc++;
2083 GraphBuffer[i] = lastZc;
2084 } else {
2085 // Change in sign, reset the sample count.
2086 sign = -sign;
2087 GraphBuffer[i] = lastZc;
2088 if (sign > 0) {
2089 lastZc = zc;
2090 zc = 0;
2091 }
2092 }
2093 }
2094
2095 RepaintGraphWindow();
2096 return 0;
2097 }
2098
2099 static command_t CommandTable[] =
2100 {
2101 {"help", CmdHelp, 1, "This help"},
2102 {"amp", CmdAmp, 1, "Amplify peaks"},
2103 {"askdemod", Cmdaskdemod, 1, "<0 or 1> -- Attempt to demodulate simple ASK tags"},
2104 {"askmandemod", Cmdaskmandemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK/Manchester tags and output binary (args optional)"},
2105 {"askrawdemod", Cmdaskrawdemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate ASK tags and output bin (args optional)"},
2106 {"autocorr", CmdAutoCorr, 1, "<window length> -- Autocorrelation over window"},
2107 {"biphaserawdecode",CmdBiphaseDecodeRaw,1,"[offset] [invert<0|1>] Biphase decode bin stream in demod buffer (offset = 0|1 bits to shift the decode start)"},
2108 {"bitsamples", CmdBitsamples, 0, "Get raw samples as bitstring"},
2109 {"bitstream", CmdBitstream, 1, "[clock rate] -- Convert waveform into a bitstream"},
2110 {"buffclear", CmdBuffClear, 1, "Clear sample buffer and graph window"},
2111 {"dec", CmdDec, 1, "Decimate samples"},
2112 {"detectclock", CmdDetectClockRate, 1, "Detect ASK clock rate"},
2113 {"fskdemod", CmdFSKdemod, 1, "Demodulate graph window as a HID FSK"},
2114 {"fskawiddemod", CmdFSKdemodAWID, 1, "Demodulate graph window as an AWID FSK tag using raw"},
2115 {"fskfcdetect", CmdFSKfcDetect, 1, "Try to detect the Field Clock of an FSK wave"},
2116 {"fskhiddemod", CmdFSKdemodHID, 1, "Demodulate graph window as a HID FSK tag using raw"},
2117 {"fskiodemod", CmdFSKdemodIO, 1, "Demodulate graph window as an IO Prox tag FSK using raw"},
2118 {"fskpyramiddemod",CmdFSKdemodPyramid,1, "Demodulate graph window as a Pyramid FSK tag using raw"},
2119 {"fskparadoxdemod",CmdFSKdemodParadox,1, "Demodulate graph window as a Paradox FSK tag using raw"},
2120 {"fskrawdemod", CmdFSKrawdemod, 1, "[clock rate] [invert] [rchigh] [rclow] Demodulate graph window from FSK to bin (clock = 50)(invert = 1|0)(rchigh = 10)(rclow=8)"},
2121 {"grid", CmdGrid, 1, "<x> <y> -- overlay grid on graph window, use zero value to turn off either"},
2122 {"hexsamples", CmdHexsamples, 0, "<bytes> [<offset>] -- Dump big buffer as hex bytes"},
2123 {"hide", CmdHide, 1, "Hide graph window"},
2124 {"hpf", CmdHpf, 1, "Remove DC offset from trace"},
2125 {"load", CmdLoad, 1, "<filename> -- Load trace (to graph window"},
2126 {"ltrim", CmdLtrim, 1, "<samples> -- Trim samples from left of trace"},
2127 {"rtrim", CmdRtrim, 1, "<location to end trace> -- Trim samples from right of trace"},
2128 {"mandemod", CmdManchesterDemod, 1, "[i] [clock rate] -- Manchester demodulate binary stream (option 'i' to invert output)"},
2129 {"manrawdecode", Cmdmandecoderaw, 1, "Manchester decode binary stream already in graph buffer"},
2130 {"manmod", CmdManchesterMod, 1, "[clock rate] -- Manchester modulate a binary stream"},
2131 {"norm", CmdNorm, 1, "Normalize max/min to +/-128"},
2132 {"plot", CmdPlot, 1, "Show graph window (hit 'h' in window for keystroke help)"},
2133 {"pskclean", CmdPskClean, 1, "Attempt to clean psk wave"},
2134 {"pskdetectclock",CmdDetectNRZpskClockRate, 1, "Detect ASK, PSK, or NRZ clock rate"},
2135 {"pskindalademod",CmdIndalaDecode, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 indala tags and output ID binary & hex (args optional)"},
2136 {"psk1nrzrawdemod",CmdpskNRZrawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk1 or nrz tags and output binary (args optional)"},
2137 {"psk2rawdemod", CmdPSK2rawDemod, 1, "[clock] [invert<0|1>] -- Attempt to demodulate psk2 tags and output binary (args optional)"},
2138 {"samples", CmdSamples, 0, "[512 - 40000] -- Get raw samples for graph window"},
2139 {"save", CmdSave, 1, "<filename> -- Save trace (from graph window)"},
2140 {"scale", CmdScale, 1, "<int> -- Set cursor display scale"},
2141 {"setdebugmode", CmdSetDebugMode, 1, "<0|1> -- Turn on or off Debugging Mode for demods"},
2142 {"shiftgraphzero",CmdGraphShiftZero, 1, "<shift> -- Shift 0 for Graphed wave + or - shift value"},
2143 {"threshold", CmdThreshold, 1, "<threshold> -- Maximize/minimize every value in the graph window depending on threshold"},
2144 {"dirthreshold", CmdDirectionalThreshold, 1, "<thres up> <thres down> -- Max rising higher up-thres/ Min falling lower down-thres, keep rest as prev."},
2145 {"tune", CmdTuneSamples, 0, "Get hw tune samples for graph window"},
2146 {"undec", CmdUndec, 1, "Un-decimate samples by 2"},
2147 {"zerocrossings", CmdZerocrossings, 1, "Count time between zero-crossings"},
2148 {NULL, NULL, 0, NULL}
2149 };
2150
2151 int CmdData(const char *Cmd)
2152 {
2153 CmdsParse(CommandTable, Cmd);
2154 return 0;
2155 }
2156
2157 int CmdHelp(const char *Cmd)
2158 {
2159 CmdsHelp(CommandTable);
2160 return 0;
2161 }
Proxmark3 GIT tracking
Impressum, Datenschutz