1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
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
7 //-----------------------------------------------------------------------------
8 // Low frequency commands
9 //-----------------------------------------------------------------------------
17 #include "proxmark3.h"
19 #include "lfdemod.h" // for psk2TOpsk1
20 #include "util.h" // for parsing cli command utils
21 #include "ui.h" // for show graph controls
22 #include "graph.h" // for graph data
23 #include "cmdparser.h" // for getting cli commands included in cmdmain.h
24 #include "cmdmain.h" // for sending cmds to device
25 #include "data.h" // for GetFromBigBuf
26 #include "cmddata.h" // for `lf search`
27 #include "cmdlfawid.h" // for awid menu
28 #include "cmdlfem4x.h" // for em4x menu
29 #include "cmdlfhid.h" // for hid menu
30 #include "cmdlfhitag.h" // for hitag menu
31 #include "cmdlfio.h" // for ioprox menu
32 #include "cmdlft55xx.h" // for t55xx menu
33 #include "cmdlfti.h" // for ti menu
34 #include "cmdlfpresco.h" // for presco menu
35 #include "cmdlfpcf7931.h"// for pcf7931 menu
36 #include "cmdlfpyramid.h"// for pyramid menu
37 #include "cmdlfviking.h" // for viking menu
38 #include "cmdlfcotag.h" // for COTAG menu
39 #include "cmdlfvisa2000.h" // for VISA2000 menu
40 #include "cmdlfindala.h" // for indala menu
41 #include "cmdlfgproxii.h"// for gproxii menu
42 #include "cmdlffdx.h" // for fdx-b menu
43 #include "cmdlfparadox.h"// for paradox menu
44 #include "cmdlfnexwatch.h"//for nexwatch menu
45 #include "cmdlfjablotron.h" //for jablotron menu
46 #include "cmdlfnoralsy.h"// for noralsy menu
47 #include "cmdlfsecurakey.h"//for securakey menu
48 #include "cmdlfpac.h" // for pac menu
50 bool g_lf_threshold_set
= false;
51 static int CmdHelp(const char *Cmd
);
55 int usage_lf_cmdread(void)
57 PrintAndLog("Usage: lf cmdread d <delay period> z <zero period> o <one period> c <cmdbytes> [H] ");
58 PrintAndLog("Options: ");
59 PrintAndLog(" h This help");
60 PrintAndLog(" L Low frequency (125 KHz)");
61 PrintAndLog(" H High frequency (134 KHz)");
62 PrintAndLog(" d <delay> delay OFF period");
63 PrintAndLog(" z <zero> time period ZERO");
64 PrintAndLog(" o <one> time period ONE");
65 PrintAndLog(" c <cmd> Command bytes");
66 PrintAndLog(" ************* All periods in microseconds");
67 PrintAndLog("Examples:");
68 PrintAndLog(" lf cmdread d 80 z 100 o 200 c 11000");
69 PrintAndLog(" lf cmdread d 80 z 100 o 100 c 11000 H");
73 /* send a command before reading */
74 int CmdLFCommandRead(const char *Cmd
)
76 static char dummy
[3] = {0x20,0x00,0x00};
77 UsbCommand c
= {CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K
};
79 //uint8_t divisor = 95; //125khz
81 while(param_getchar(Cmd
, cmdp
) != 0x00)
83 switch(param_getchar(Cmd
, cmdp
))
86 return usage_lf_cmdread();
96 param_getstr(Cmd
, cmdp
+1, (char *)&c
.d
.asBytes
);
100 c
.arg
[0] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
104 c
.arg
[1] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
108 c
.arg
[2] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
112 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
119 if(cmdp
== 0) errors
= 1;
122 if(errors
) return usage_lf_cmdread();
124 // in case they specified 'H'
125 strcpy((char *)&c
.d
.asBytes
+ strlen((char *)c
.d
.asBytes
), dummy
);
127 clearCommandBuffer();
132 int CmdFlexdemod(const char *Cmd
)
135 for (i
= 0; i
< GraphTraceLen
; ++i
) {
136 if (GraphBuffer
[i
] < 0) {
143 #define LONG_WAIT 100
145 for (start
= 0; start
< GraphTraceLen
- LONG_WAIT
; start
++) {
146 int first
= GraphBuffer
[start
];
147 for (i
= start
; i
< start
+ LONG_WAIT
; i
++) {
148 if (GraphBuffer
[i
] != first
) {
152 if (i
== (start
+ LONG_WAIT
)) {
156 if (start
== GraphTraceLen
- LONG_WAIT
) {
157 PrintAndLog("nothing to wait for");
161 GraphBuffer
[start
] = 2;
162 GraphBuffer
[start
+1] = -2;
163 uint8_t bits
[64] = {0x00};
167 for (bit
= 0; bit
< 64; bit
++) {
169 for (int j
= 0; j
< 16; j
++) {
170 sum
+= GraphBuffer
[i
++];
173 bits
[bit
] = (sum
> 0) ? 1 : 0;
175 PrintAndLog("bit %d sum %d", bit
, sum
);
178 for (bit
= 0; bit
< 64; bit
++) {
181 for (j
= 0; j
< 16; j
++) {
182 sum
+= GraphBuffer
[i
++];
184 if (sum
> 0 && bits
[bit
] != 1) {
185 PrintAndLog("oops1 at %d", bit
);
187 if (sum
< 0 && bits
[bit
] != 0) {
188 PrintAndLog("oops2 at %d", bit
);
192 // HACK writing back to graphbuffer.
193 GraphTraceLen
= 32*64;
196 for (bit
= 0; bit
< 64; bit
++) {
198 phase
= (bits
[bit
] == 0) ? 0 : 1;
201 for (j
= 0; j
< 32; j
++) {
202 GraphBuffer
[i
++] = phase
;
207 RepaintGraphWindow();
211 int usage_lf_read(void)
213 PrintAndLog("Usage: lf read");
214 PrintAndLog("Options: ");
215 PrintAndLog(" h This help");
216 PrintAndLog(" s silent run no printout");
217 PrintAndLog(" [# samples] # samples to collect (optional)");
218 PrintAndLog("Use 'lf config' to set parameters.");
221 int usage_lf_snoop(void)
223 PrintAndLog("Usage: lf snoop");
224 PrintAndLog("Options: ");
225 PrintAndLog(" h This help");
226 PrintAndLog("This function takes no arguments. ");
227 PrintAndLog("Use 'lf config' to set parameters.");
231 int usage_lf_config(void)
233 PrintAndLog("Usage: lf config [H|<divisor>] [b <bps>] [d <decim>] [a 0|1]");
234 PrintAndLog("Options: ");
235 PrintAndLog(" h This help");
236 PrintAndLog(" L Low frequency (125 KHz)");
237 PrintAndLog(" H High frequency (134 KHz)");
238 PrintAndLog(" q <divisor> Manually set divisor. 88-> 134KHz, 95-> 125 Hz");
239 PrintAndLog(" b <bps> Sets resolution of bits per sample. Default (max): 8");
240 PrintAndLog(" d <decim> Sets decimation. A value of N saves only 1 in N samples. Default: 1");
241 PrintAndLog(" a [0|1] Averaging - if set, will average the stored sample value when decimating. Default: 1");
242 PrintAndLog(" t <threshold> Sets trigger threshold. 0 means no threshold (range: 0-128)");
243 PrintAndLog("Examples:");
244 PrintAndLog(" lf config b 8 L");
245 PrintAndLog(" Samples at 125KHz, 8bps.");
246 PrintAndLog(" lf config H b 4 d 3");
247 PrintAndLog(" Samples at 134KHz, averages three samples into one, stored with ");
248 PrintAndLog(" a resolution of 4 bits per sample.");
249 PrintAndLog(" lf read");
250 PrintAndLog(" Performs a read (active field)");
251 PrintAndLog(" lf snoop");
252 PrintAndLog(" Performs a snoop (no active field)");
256 int CmdLFSetConfig(const char *Cmd
)
259 uint8_t divisor
= 0;//Frequency divisor
260 uint8_t bps
= 0; // Bits per sample
261 uint8_t decimation
= 0; //How many to keep
262 bool averaging
= 1; // Defaults to true
264 int trigger_threshold
=-1;//Means no change
265 uint8_t unsigned_trigg
= 0;
268 while(param_getchar(Cmd
, cmdp
) != 0x00)
270 switch(param_getchar(Cmd
, cmdp
))
273 return usage_lf_config();
283 errors
|= param_getdec(Cmd
,cmdp
+1,&divisor
);
287 errors
|= param_getdec(Cmd
,cmdp
+1,&unsigned_trigg
);
290 trigger_threshold
= unsigned_trigg
;
291 if (trigger_threshold
> 0) g_lf_threshold_set
= true;
295 errors
|= param_getdec(Cmd
,cmdp
+1,&bps
);
299 errors
|= param_getdec(Cmd
,cmdp
+1,&decimation
);
303 averaging
= param_getchar(Cmd
,cmdp
+1) == '1';
307 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
315 errors
= 1;// No args
321 return usage_lf_config();
323 //Bps is limited to 8, so fits in lower half of arg1
324 if(bps
>> 4) bps
= 8;
326 sample_config config
= {
327 decimation
,bps
,averaging
,divisor
,trigger_threshold
329 //Averaging is a flag on high-bit of arg[1]
330 UsbCommand c
= {CMD_SET_LF_SAMPLING_CONFIG
};
331 memcpy(c
.d
.asBytes
,&config
,sizeof(sample_config
));
332 clearCommandBuffer();
337 bool lf_read(bool silent
, uint32_t samples
) {
338 if (offline
) return false;
339 UsbCommand c
= {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K
, {silent
,samples
,0}};
340 clearCommandBuffer();
341 //And ship it to device
345 if (g_lf_threshold_set
) {
346 WaitForResponse(CMD_ACK
,&resp
);
348 if ( !WaitForResponseTimeout(CMD_ACK
,&resp
,2500) ) {
349 PrintAndLog("command execution time out");
353 // resp.arg[0] is bits read not bytes read.
354 getSamples(resp
.arg
[0]/8, silent
);
359 int CmdLFRead(const char *Cmd
)
363 if (param_getchar(Cmd
, cmdp
) == 'h')
365 return usage_lf_read();
367 if (param_getchar(Cmd
, cmdp
) == 's') {
368 silent
= true; //suppress print
371 uint32_t samples
= param_get32ex(Cmd
, cmdp
, 0, 10);
372 return lf_read(silent
, samples
);
375 int CmdLFSnoop(const char *Cmd
)
378 if(param_getchar(Cmd
, cmdp
) == 'h')
380 return usage_lf_snoop();
383 UsbCommand c
= {CMD_LF_SNOOP_RAW_ADC_SAMPLES
};
384 clearCommandBuffer();
386 WaitForResponse(CMD_ACK
,NULL
);
392 static void ChkBitstream(const char *str
)
396 /* convert to bitstream if necessary */
397 for (i
= 0; i
< (int)(GraphTraceLen
/ 2); i
++){
398 if (GraphBuffer
[i
] > 1 || GraphBuffer
[i
] < 0) {
404 //Attempt to simulate any wave in buffer (one bit per output sample)
405 // converts GraphBuffer to bitstream (based on zero crossings) if needed.
406 int CmdLFSim(const char *Cmd
)
411 sscanf(Cmd
, "%i", &gap
);
413 // convert to bitstream if necessary
416 //can send only 512 bits at a time (1 byte sent per bit...)
417 printf("Sending [%d bytes]", GraphTraceLen
);
418 for (i
= 0; i
< GraphTraceLen
; i
+= USB_CMD_DATA_SIZE
) {
419 UsbCommand c
= {CMD_DOWNLOADED_SIM_SAMPLES_125K
, {i
, 0, 0}};
421 for (j
= 0; j
< USB_CMD_DATA_SIZE
; j
++) {
422 c
.d
.asBytes
[j
] = GraphBuffer
[i
+j
];
425 WaitForResponse(CMD_ACK
,NULL
);
430 PrintAndLog("Starting to simulate");
431 UsbCommand c
= {CMD_SIMULATE_TAG_125K
, {GraphTraceLen
, gap
, 0}};
432 clearCommandBuffer();
437 int usage_lf_simfsk(void)
440 PrintAndLog("Usage: lf simfsk [c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>]");
441 PrintAndLog("Options: ");
442 PrintAndLog(" h This help");
443 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
444 PrintAndLog(" i invert data");
445 PrintAndLog(" H <fcHigh> Manually set the larger Field Clock");
446 PrintAndLog(" L <fcLow> Manually set the smaller Field Clock");
447 //PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap");
448 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
449 PrintAndLog("\n NOTE: if you set one clock manually set them all manually");
453 int usage_lf_simask(void)
456 PrintAndLog("Usage: lf simask [c <clock>] [i] [b|m|r] [s] [d <raw hex to sim>]");
457 PrintAndLog("Options: ");
458 PrintAndLog(" h This help");
459 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
460 PrintAndLog(" i invert data");
461 PrintAndLog(" b sim ask/biphase");
462 PrintAndLog(" m sim ask/manchester - Default");
463 PrintAndLog(" r sim ask/raw");
464 PrintAndLog(" s add t55xx Sequence Terminator gap - default: no gaps (only manchester)");
465 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
469 int usage_lf_simpsk(void)
472 PrintAndLog("Usage: lf simpsk [1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>]");
473 PrintAndLog("Options: ");
474 PrintAndLog(" h This help");
475 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
476 PrintAndLog(" i invert data");
477 PrintAndLog(" 1 set PSK1 (default)");
478 PrintAndLog(" 2 set PSK2");
479 PrintAndLog(" 3 set PSK3");
480 PrintAndLog(" r <carrier> 2|4|8 are valid carriers: default = 2");
481 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
485 // by marshmellow - sim fsk data given clock, fcHigh, fcLow, invert
486 // - allow pull data from DemodBuffer
487 int CmdLFfskSim(const char *Cmd
)
489 //might be able to autodetect FCs and clock from Graphbuffer if using demod buffer
490 // otherwise will need FChigh, FClow, Clock, and bitstream
491 uint8_t fcHigh
=0, fcLow
=0, clk
=0;
494 char hexData
[32] = {0x00}; // store entered hex data
495 uint8_t data
[255] = {0x00};
498 while(param_getchar(Cmd
, cmdp
) != 0x00)
500 switch(param_getchar(Cmd
, cmdp
))
503 return usage_lf_simfsk();
509 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
513 errors
|= param_getdec(Cmd
,cmdp
+1,&fcHigh
);
517 errors
|= param_getdec(Cmd
,cmdp
+1,&fcLow
);
525 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
529 dataLen
= hextobinarray((char *)data
, hexData
);
531 if (dataLen
==0) errors
=true;
532 if (errors
) PrintAndLog ("Error getting hex data");
536 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
542 if(cmdp
== 0 && DemodBufferLen
== 0)
544 errors
= true;// No args
550 return usage_lf_simfsk();
552 int firstClockEdge
= 0;
553 if (dataLen
== 0){ //using DemodBuffer
554 if (clk
==0 || fcHigh
==0 || fcLow
==0){ //manual settings must set them all
555 uint8_t ans
= fskClocks(&fcHigh
, &fcLow
, &clk
, 0, &firstClockEdge
);
557 if (!fcHigh
) fcHigh
=10;
563 setDemodBuf(data
, dataLen
, 0);
566 //default if not found
567 if (clk
== 0) clk
= 50;
568 if (fcHigh
== 0) fcHigh
= 10;
569 if (fcLow
== 0) fcLow
= 8;
572 arg1
= fcHigh
<< 8 | fcLow
;
573 arg2
= invert
<< 8 | clk
;
574 size_t size
= DemodBufferLen
;
575 if (size
> USB_CMD_DATA_SIZE
) {
576 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
577 size
= USB_CMD_DATA_SIZE
;
579 UsbCommand c
= {CMD_FSK_SIM_TAG
, {arg1
, arg2
, size
}};
581 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
582 clearCommandBuffer();
587 // by marshmellow - sim ask data given clock, invert, manchester or raw, separator
588 // - allow pull data from DemodBuffer
589 int CmdLFaskSim(const char *Cmd
)
591 //autodetect clock from Graphbuffer if using demod buffer
592 // needs clock, invert, manchester/raw as m or r, separator as s, and bitstream
593 uint8_t encoding
= 1, separator
= 0;
594 uint8_t clk
=0, invert
=0;
596 char hexData
[32] = {0x00};
597 uint8_t data
[255]= {0x00}; // store entered hex data
600 while(param_getchar(Cmd
, cmdp
) != 0x00)
602 switch(param_getchar(Cmd
, cmdp
))
605 return usage_lf_simask();
611 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
615 encoding
=2; //biphase
631 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
635 dataLen
= hextobinarray((char *)data
, hexData
);
637 if (dataLen
==0) errors
=true;
638 if (errors
) PrintAndLog ("Error getting hex data, datalen: %d",dataLen
);
642 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
648 if(cmdp
== 0 && DemodBufferLen
== 0)
650 errors
= true;// No args
656 return usage_lf_simask();
658 if (dataLen
== 0){ //using DemodBuffer
659 if (clk
== 0) clk
= GetAskClock("0", false, false);
661 setDemodBuf(data
, dataLen
, 0);
663 if (clk
== 0) clk
= 64;
664 if (encoding
== 0) clk
= clk
/2; //askraw needs to double the clock speed
666 size_t size
=DemodBufferLen
;
667 arg1
= clk
<< 8 | encoding
;
668 arg2
= invert
<< 8 | separator
;
669 if (size
> USB_CMD_DATA_SIZE
) {
670 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
671 size
= USB_CMD_DATA_SIZE
;
673 UsbCommand c
= {CMD_ASK_SIM_TAG
, {arg1
, arg2
, size
}};
674 PrintAndLog("preparing to sim ask data: %d bits", size
);
675 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
676 clearCommandBuffer();
681 // by marshmellow - sim psk data given carrier, clock, invert
682 // - allow pull data from DemodBuffer or parameters
683 int CmdLFpskSim(const char *Cmd
)
685 //might be able to autodetect FC and clock from Graphbuffer if using demod buffer
686 //will need carrier, Clock, and bitstream
687 uint8_t carrier
=0, clk
=0;
690 char hexData
[32] = {0x00}; // store entered hex data
691 uint8_t data
[255] = {0x00};
695 while(param_getchar(Cmd
, cmdp
) != 0x00)
697 switch(param_getchar(Cmd
, cmdp
))
700 return usage_lf_simpsk();
706 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
710 errors
|= param_getdec(Cmd
,cmdp
+1,&carrier
);
726 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
730 dataLen
= hextobinarray((char *)data
, hexData
);
732 if (dataLen
==0) errors
=true;
733 if (errors
) PrintAndLog ("Error getting hex data");
737 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
743 if (cmdp
== 0 && DemodBufferLen
== 0)
745 errors
= true;// No args
751 return usage_lf_simpsk();
753 if (dataLen
== 0){ //using DemodBuffer
754 PrintAndLog("Getting Clocks");
755 if (clk
==0) clk
= GetPskClock("", false, false);
756 PrintAndLog("clk: %d",clk
);
757 if (!carrier
) carrier
= GetPskCarrier("", false, false);
758 PrintAndLog("carrier: %d", carrier
);
760 setDemodBuf(data
, dataLen
, 0);
763 if (clk
<= 0) clk
= 32;
764 if (carrier
== 0) carrier
= 2;
767 //need to convert psk2 to psk1 data before sim
768 psk2TOpsk1(DemodBuffer
, DemodBufferLen
);
770 PrintAndLog("Sorry, PSK3 not yet available");
774 arg1
= clk
<< 8 | carrier
;
776 size_t size
=DemodBufferLen
;
777 if (size
> USB_CMD_DATA_SIZE
) {
778 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
779 size
=USB_CMD_DATA_SIZE
;
781 UsbCommand c
= {CMD_PSK_SIM_TAG
, {arg1
, arg2
, size
}};
782 PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size
);
783 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
784 clearCommandBuffer();
790 int CmdLFSimBidir(const char *Cmd
)
792 // Set ADC to twice the carrier for a slight supersampling
793 // HACK: not implemented in ARMSRC.
794 PrintAndLog("Not implemented yet.");
795 UsbCommand c
= {CMD_LF_SIMULATE_BIDIR
, {47, 384, 0}};
800 int CmdVchDemod(const char *Cmd
)
802 // Is this the entire sync pattern, or does this also include some
803 // data bits that happen to be the same everywhere? That would be
805 static const int SyncPattern
[] = {
806 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
807 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
808 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
809 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
810 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
811 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
812 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
813 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
814 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
815 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
818 // So first, we correlate for the sync pattern, and mark that.
819 int bestCorrel
= 0, bestPos
= 0;
821 // It does us no good to find the sync pattern, with fewer than
822 // 2048 samples after it...
823 for (i
= 0; i
< (GraphTraceLen
-2048); i
++) {
826 for (j
= 0; j
< arraylen(SyncPattern
); j
++) {
827 sum
+= GraphBuffer
[i
+j
]*SyncPattern
[j
];
829 if (sum
> bestCorrel
) {
834 PrintAndLog("best sync at %d [metric %d]", bestPos
, bestCorrel
);
842 for (i
= 0; i
< 2048; i
+= 8) {
845 for (j
= 0; j
< 8; j
++) {
846 sum
+= GraphBuffer
[bestPos
+i
+j
];
853 if(abs(sum
) < worst
) {
858 PrintAndLog("bits:");
859 PrintAndLog("%s", bits
);
860 PrintAndLog("worst metric: %d at pos %d", worst
, worstPos
);
862 if (strcmp(Cmd
, "clone")==0) {
865 for(s
= bits
; *s
; s
++) {
867 for(j
= 0; j
< 16; j
++) {
868 GraphBuffer
[GraphTraceLen
++] = (*s
== '1') ? 1 : 0;
871 RepaintGraphWindow();
878 int CheckChipType(char cmdp
) {
879 uint32_t wordData
= 0;
881 if (offline
|| cmdp
== '1') return 0;
883 save_restoreGB(GRAPH_SAVE
);
884 save_restoreDB(GRAPH_SAVE
);
885 //check for em4x05/em4x69 chips first
886 if (EM4x05Block0Test(&wordData
)) {
887 PrintAndLog("\nValid EM4x05/EM4x69 Chip Found\nTry lf em 4x05... commands\n");
888 save_restoreGB(GRAPH_RESTORE
);
889 save_restoreDB(GRAPH_RESTORE
);
893 //check for t55xx chip...
894 if (tryDetectP1(true)) {
895 PrintAndLog("\nValid T55xx Chip Found\nTry lf t55xx ... commands\n");
896 save_restoreGB(GRAPH_RESTORE
);
897 save_restoreDB(GRAPH_RESTORE
);
900 save_restoreGB(GRAPH_RESTORE
);
901 save_restoreDB(GRAPH_RESTORE
);
906 int CmdLFfind(const char *Cmd
)
908 uint32_t wordData
= 0;
910 size_t minLength
= 1000;
911 char cmdp
= param_getchar(Cmd
, 0);
912 char testRaw
= param_getchar(Cmd
, 1);
913 if (strlen(Cmd
) > 3 || cmdp
== 'h' || cmdp
== 'H') {
914 PrintAndLog("Usage: lf search <0|1> [u]");
915 PrintAndLog(" <use data from Graphbuffer> , if not set, try reading data from tag.");
916 PrintAndLog(" [Search for Unknown tags] , if not set, reads only known tags.");
918 PrintAndLog(" sample: lf search = try reading data from tag & search for known tags");
919 PrintAndLog(" : lf search 1 = use data from GraphBuffer & search for known tags");
920 PrintAndLog(" : lf search u = try reading data from tag & search for known and unknown tags");
921 PrintAndLog(" : lf search 1 u = use data from GraphBuffer & search for known and unknown tags");
926 if (!offline
&& (cmdp
!= '1')) {
927 lf_read(true, 30000);
928 } else if (GraphTraceLen
< minLength
) {
929 PrintAndLog("Data in Graphbuffer was too small.");
932 if (cmdp
== 'u' || cmdp
== 'U') testRaw
= 'u';
934 PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag");
935 PrintAndLog("False Positives ARE possible\n");
936 PrintAndLog("\nChecking for known tags:\n");
938 size_t testLen
= minLength
;
939 // only run if graphbuffer is just noise as it should be for hitag/cotag
940 if (graphJustNoise(GraphBuffer
, testLen
)) {
941 // only run these tests if we are in online mode
942 if (!offline
&& (cmdp
!= '1')) {
943 // test for em4x05 in reader talk first mode.
944 if (EM4x05Block0Test(&wordData
)) {
945 PrintAndLog("\nValid EM4x05/EM4x69 Chip Found\nUse lf em 4x05readword/dump commands to read\n");
948 ans
=CmdLFHitagReader("26");
952 ans
=CmdCOTAGRead("");
954 PrintAndLog("\nValid COTAG ID Found!");
961 // TODO test for modulation then only test formats that use that modulation
963 ans
=CmdFSKdemodIO("");
965 PrintAndLog("\nValid IO Prox ID Found!");
966 return CheckChipType(cmdp
);
969 ans
=CmdFSKdemodPyramid("");
971 PrintAndLog("\nValid Pyramid ID Found!");
972 return CheckChipType(cmdp
);
975 ans
=CmdFSKdemodParadox("");
977 PrintAndLog("\nValid Paradox ID Found!");
978 return CheckChipType(cmdp
);
981 ans
=CmdFSKdemodAWID("");
983 PrintAndLog("\nValid AWID ID Found!");
984 return CheckChipType(cmdp
);
987 ans
=CmdFSKdemodHID("");
989 PrintAndLog("\nValid HID Prox ID Found!");
990 return CheckChipType(cmdp
);
993 ans
=CmdAskEM410xDemod("");
995 PrintAndLog("\nValid EM410x ID Found!");
996 return CheckChipType(cmdp
);
999 ans
=CmdVisa2kDemod("");
1001 PrintAndLog("\nValid Visa2000 ID Found!");
1002 return CheckChipType(cmdp
);
1005 ans
=CmdG_Prox_II_Demod("");
1007 PrintAndLog("\nValid G Prox II ID Found!");
1008 return CheckChipType(cmdp
);
1011 ans
=CmdFdxDemod(""); //biphase
1013 PrintAndLog("\nValid FDX-B ID Found!");
1014 return CheckChipType(cmdp
);
1017 ans
=EM4x50Read("", false); //ask
1019 PrintAndLog("\nValid EM4x50 ID Found!");
1023 ans
=CmdJablotronDemod("");
1025 PrintAndLog("\nValid Jablotron ID Found!");
1026 return CheckChipType(cmdp
);
1029 ans
=CmdNoralsyDemod("");
1031 PrintAndLog("\nValid Noralsy ID Found!");
1032 return CheckChipType(cmdp
);
1035 ans
=CmdSecurakeyDemod("");
1037 PrintAndLog("\nValid Securakey ID Found!");
1038 return CheckChipType(cmdp
);
1041 ans
=CmdVikingDemod("");
1043 PrintAndLog("\nValid Viking ID Found!");
1044 return CheckChipType(cmdp
);
1047 ans
=CmdIndalaDecode(""); //psk
1049 PrintAndLog("\nValid Indala ID Found!");
1050 return CheckChipType(cmdp
);
1053 ans
=CmdPSKNexWatch("");
1055 PrintAndLog("\nValid NexWatch ID Found!");
1056 return CheckChipType(cmdp
);
1059 ans
=CmdPacDemod("");
1061 PrintAndLog("\nValid PAC/Stanley ID Found!");
1062 return CheckChipType(cmdp
);
1065 PrintAndLog("\nNo Known Tags Found!\n");
1066 if (testRaw
=='u' || testRaw
=='U') {
1067 //ans=CheckChipType(cmdp);
1068 //test unknown tag formats (raw mode)0
1069 PrintAndLog("\nChecking for Unknown tags:\n");
1070 ans
=AutoCorrelate(GraphBuffer
, GraphBuffer
, GraphTraceLen
, 4000, false, false);
1071 if (ans
> 0) PrintAndLog("Possible Auto Correlation of %d repeating samples",ans
);
1072 ans
=GetFskClock("",false,false);
1073 if (ans
!= 0) { //fsk
1074 ans
=FSKrawDemod("",true);
1076 PrintAndLog("\nUnknown FSK Modulated Tag Found!");
1077 return CheckChipType(cmdp
);
1081 ans
=ASKDemod_ext("0 0 0",true,false,1,&st
);
1083 PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
1084 PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'");
1085 return CheckChipType(cmdp
);
1087 ans
=CmdPSK1rawDemod("");
1089 PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data rawdemod p2'");
1090 PrintAndLog("\nCould also be PSK3 - [currently not supported]");
1091 PrintAndLog("\nCould also be NRZ - try 'data rawdemod nr'");
1092 return CheckChipType(cmdp
);
1094 ans
= CheckChipType(cmdp
);
1095 PrintAndLog("\nNo Data Found!\n");
1100 static command_t CommandTable
[] =
1102 {"help", CmdHelp
, 1, "This help"},
1103 {"awid", CmdLFAWID
, 1, "{ AWID RFIDs... }"},
1104 {"cotag", CmdLFCOTAG
, 1, "{ COTAG CHIPs... }"},
1105 {"em", CmdLFEM4X
, 1, "{ EM4X CHIPs & RFIDs... }"},
1106 {"fdx", CmdLFFdx
, 1, "{ FDX-B RFIDs... }"},
1107 {"gproxii", CmdLF_G_Prox_II
, 1, "{ G Prox II RFIDs... }"},
1108 {"hid", CmdLFHID
, 1, "{ HID RFIDs... }"},
1109 {"hitag", CmdLFHitag
, 1, "{ Hitag CHIPs... }"},
1110 {"io", CmdLFIO
, 1, "{ ioProx RFIDs... }"},
1111 {"indala", CmdLFINDALA
, 1, "{ Indala RFIDs... }"},
1112 {"jablotron", CmdLFJablotron
, 1, "{ Jablotron RFIDs... }"},
1113 {"nexwatch", CmdLFNexWatch
, 1, "{ NexWatch RFIDs... }"},
1114 {"noralsy", CmdLFNoralsy
, 1, "{ Noralsy RFIDs... }"},
1115 {"pac", CmdLFPac
, 1, "{ PAC/Stanley RFIDs... }"},
1116 {"paradox", CmdLFParadox
, 1, "{ Paradox RFIDs... }"},
1117 {"presco", CmdLFPresco
, 1, "{ Presco RFIDs... }"},
1118 {"pcf7931", CmdLFPCF7931
, 1, "{ PCF7931 CHIPs... }"},
1119 {"pyramid", CmdLFPyramid
, 1, "{ Farpointe/Pyramid RFIDs... }"},
1120 {"securakey", CmdLFSecurakey
, 1, "{ Securakey RFIDs... }"},
1121 {"t55xx", CmdLFT55XX
, 1, "{ T55xx CHIPs... }"},
1122 {"ti", CmdLFTI
, 1, "{ TI CHIPs... }"},
1123 {"viking", CmdLFViking
, 1, "{ Viking RFIDs... }"},
1124 {"visa2000", CmdLFVisa2k
, 1, "{ Visa2000 RFIDs... }"},
1125 {"cmdread", CmdLFCommandRead
, 0, "<d period> <z period> <o period> <c command> ['H'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'H' for 134)"},
1126 {"config", CmdLFSetConfig
, 0, "Set config for LF sampling, bit/sample, decimation, frequency"},
1127 {"flexdemod", CmdFlexdemod
, 1, "Demodulate samples for FlexPass"},
1128 {"read", CmdLFRead
, 0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"},
1129 {"search", CmdLFfind
, 1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) - 'u' to search for unknown tags"},
1130 {"sim", CmdLFSim
, 0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"},
1131 {"simask", CmdLFaskSim
, 0, "[clock] [invert <1|0>] [biphase/manchester/raw <'b'|'m'|'r'>] [msg separator 's'] [d <hexdata>] -- Simulate LF ASK tag from demodbuffer or input"},
1132 {"simfsk", CmdLFfskSim
, 0, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] -- Simulate LF FSK tag from demodbuffer or input"},
1133 {"simpsk", CmdLFpskSim
, 0, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] -- Simulate LF PSK tag from demodbuffer or input"},
1134 {"simbidir", CmdLFSimBidir
, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"},
1135 {"snoop", CmdLFSnoop
, 0, "['l'|'h'|<divisor>] [trigger threshold]-- Snoop LF (l:125khz, h:134khz)"},
1136 {"vchdemod", CmdVchDemod
, 1, "['clone'] -- Demodulate samples for VeriChip"},
1137 {NULL
, NULL
, 0, NULL
}
1140 int CmdLF(const char *Cmd
)
1142 CmdsParse(CommandTable
, Cmd
);
1146 int CmdHelp(const char *Cmd
)
1148 CmdsHelp(CommandTable
);