]> git.zerfleddert.de Git - proxmark3-svn/blob - client/cmddata.c
projects / proxmark3-svn / blob
? search:


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