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