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 //-----------------------------------------------------------------------------
15 #include "proxmark3.h"
19 #include "cmdparser.h"
25 #include "cmdlfawid.h"
27 #include "cmdlfem4x.h"
28 #include "cmdlfhitag.h"
29 #include "cmdlft55xx.h"
30 #include "cmdlfpcf7931.h"
33 #include "cmdlfviking.h"
34 static int CmdHelp(const char *Cmd
);
36 int usage_lf_cmdread(void) {
37 PrintAndLog("Usage: lf cmdread d <delay period> z <zero period> o <one period> c <cmdbytes> [H]");
38 PrintAndLog("Options: ");
39 PrintAndLog(" h This help");
40 PrintAndLog(" H Freqency High (134 KHz), default is 'Low (125KHz)'");
41 PrintAndLog(" d <delay> delay OFF period, (dec)");
42 PrintAndLog(" z <zero> time period ZERO, (dec)");
43 PrintAndLog(" o <one> time period ONE, (dec)");
44 PrintAndLog(" c <cmd> Command bytes");
45 PrintAndLog(" ************* All periods in microseconds (ms)");
46 PrintAndLog("Examples:");
47 PrintAndLog(" lf cmdread d 80 z 100 o 200 c 11000");
48 PrintAndLog(" lf cmdread d 80 z 100 o 100 c 11000 H");
51 int usage_lf_read(void){
52 PrintAndLog("Usage: lf read [h] [s]");
53 PrintAndLog("Options: ");
54 PrintAndLog(" h This help");
55 PrintAndLog(" s silent run no printout");
56 PrintAndLog("This function takes no arguments. ");
57 PrintAndLog("Use 'lf config' to set parameters.");
60 int usage_lf_snoop(void) {
61 PrintAndLog("Usage: lf snoop");
62 PrintAndLog("Options: ");
63 PrintAndLog(" h This help");
64 PrintAndLog("This function takes no arguments. ");
65 PrintAndLog("Use 'lf config' to set parameters.");
68 int usage_lf_config(void) {
69 PrintAndLog("Usage: lf config [H|<divisor>] [b <bps>] [d <decim>] [a 0|1]");
70 PrintAndLog("Options: ");
71 PrintAndLog(" h This help");
72 PrintAndLog(" L Low frequency (125 KHz)");
73 PrintAndLog(" H High frequency (134 KHz)");
74 PrintAndLog(" q <divisor> Manually set divisor. 88-> 134KHz, 95-> 125 Hz");
75 PrintAndLog(" b <bps> Sets resolution of bits per sample. Default (max): 8");
76 PrintAndLog(" d <decim> Sets decimation. A value of N saves only 1 in N samples. Default: 1");
77 PrintAndLog(" a [0|1] Averaging - if set, will average the stored sample value when decimating. Default: 1");
78 PrintAndLog(" t <threshold> Sets trigger threshold. 0 means no threshold (range: 0-128)");
79 PrintAndLog("Examples:");
80 PrintAndLog(" lf config b 8 L");
81 PrintAndLog(" Samples at 125KHz, 8bps.");
82 PrintAndLog(" lf config H b 4 d 3");
83 PrintAndLog(" Samples at 134KHz, averages three samples into one, stored with ");
84 PrintAndLog(" a resolution of 4 bits per sample.");
85 PrintAndLog(" lf read");
86 PrintAndLog(" Performs a read (active field)");
87 PrintAndLog(" lf snoop");
88 PrintAndLog(" Performs a snoop (no active field)");
91 int usage_lf_simfsk(void) {
92 PrintAndLog("Usage: lf simfsk [c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>]");
93 PrintAndLog("Options: ");
94 PrintAndLog(" h This help");
95 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
96 PrintAndLog(" i invert data");
97 PrintAndLog(" H <fcHigh> Manually set the larger Field Clock");
98 PrintAndLog(" L <fcLow> Manually set the smaller Field Clock");
99 //PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap");
100 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
101 PrintAndLog("\n NOTE: if you set one clock manually set them all manually");
104 int usage_lf_simask(void) {
105 PrintAndLog("Usage: lf simask [c <clock>] [i] [b|m|r] [s] [d <raw hex to sim>]");
106 PrintAndLog("Options: ");
107 PrintAndLog(" h This help");
108 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
109 PrintAndLog(" i invert data");
110 PrintAndLog(" b sim ask/biphase");
111 PrintAndLog(" m sim ask/manchester - Default");
112 PrintAndLog(" r sim ask/raw");
113 PrintAndLog(" s TBD- -to enable a gap between playback repetitions - default: no gap");
114 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
117 int usage_lf_simpsk(void) {
118 PrintAndLog("Usage: lf simpsk [1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>]");
119 PrintAndLog("Options: ");
120 PrintAndLog(" h This help");
121 PrintAndLog(" c <clock> Manually set clock - can autodetect if using DemodBuffer");
122 PrintAndLog(" i invert data");
123 PrintAndLog(" 1 set PSK1 (default)");
124 PrintAndLog(" 2 set PSK2");
125 PrintAndLog(" 3 set PSK3");
126 PrintAndLog(" r <carrier> 2|4|8 are valid carriers: default = 2");
127 PrintAndLog(" d <hexdata> Data to sim as hex - omit to sim from DemodBuffer");
131 /* send a LF command before reading */
132 int CmdLFCommandRead(const char *Cmd
)
134 static char dummy
[3] = {0x20,0x00,0x00};
135 UsbCommand c
= {CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K
};
141 while(param_getchar(Cmd
, cmdp
) != 0x00) {
142 switch(param_getchar(Cmd
, cmdp
))
145 return usage_lf_cmdread();
154 strLength
= param_getstr(Cmd
, cmdp
+1, (char *)&c
.d
.asBytes
);
158 c
.arg
[0] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
162 c
.arg
[1] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
166 c
.arg
[2] = param_get32ex(Cmd
, cmdp
+1, 0, 10);
170 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
177 if (cmdp
== 0) errors
= 1;
180 if (errors
) return usage_lf_cmdread();
182 // in case they specified 'H'
183 // added to the end..
184 strcpy((char *)&c
.d
.asBytes
+ strLength
, dummy
);
186 clearCommandBuffer();
191 int CmdFlexdemod(const char *Cmd
)
194 for (i
= 0; i
< GraphTraceLen
; ++i
) {
195 if (GraphBuffer
[i
] < 0) {
202 #define LONG_WAIT 100
204 for (start
= 0; start
< GraphTraceLen
- LONG_WAIT
; start
++) {
205 int first
= GraphBuffer
[start
];
206 for (i
= start
; i
< start
+ LONG_WAIT
; i
++) {
207 if (GraphBuffer
[i
] != first
) {
211 if (i
== (start
+ LONG_WAIT
)) {
215 if (start
== GraphTraceLen
- LONG_WAIT
) {
216 PrintAndLog("nothing to wait for");
220 GraphBuffer
[start
] = 2;
221 GraphBuffer
[start
+1] = -2;
222 uint8_t bits
[64] = {0x00};
226 for (bit
= 0; bit
< 64; bit
++) {
228 for (int j
= 0; j
< 16; j
++) {
229 sum
+= GraphBuffer
[i
++];
232 bits
[bit
] = (sum
> 0) ? 1 : 0;
234 PrintAndLog("bit %d sum %d", bit
, sum
);
237 for (bit
= 0; bit
< 64; bit
++) {
240 for (j
= 0; j
< 16; j
++) {
241 sum
+= GraphBuffer
[i
++];
243 if (sum
> 0 && bits
[bit
] != 1) {
244 PrintAndLog("oops1 at %d", bit
);
246 if (sum
< 0 && bits
[bit
] != 0) {
247 PrintAndLog("oops2 at %d", bit
);
251 // HACK writing back to graphbuffer.
252 GraphTraceLen
= 32*64;
255 for (bit
= 0; bit
< 64; bit
++) {
257 phase
= (bits
[bit
] == 0) ? 0 : 1;
260 for (j
= 0; j
< 32; j
++) {
261 GraphBuffer
[i
++] = phase
;
266 RepaintGraphWindow();
270 int CmdIndalaDemod(const char *Cmd
)
272 // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID
278 // worst case with GraphTraceLen=64000 is < 4096
279 // under normal conditions it's < 2048
281 uint8_t rawbits
[4096];
283 int worst
= 0, worstPos
= 0;
284 // PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32);
285 for (i
= 0; i
< GraphTraceLen
-1; i
+= 2) {
287 if ((GraphBuffer
[i
] > GraphBuffer
[i
+ 1]) && (state
!= 1)) {
289 for (j
= 0; j
< count
- 8; j
+= 16) {
290 rawbits
[rawbit
++] = 0;
292 if ((abs(count
- j
)) > worst
) {
293 worst
= abs(count
- j
);
299 } else if ((GraphBuffer
[i
] < GraphBuffer
[i
+ 1]) && (state
!= 0)) {
301 for (j
= 0; j
< count
- 8; j
+= 16) {
302 rawbits
[rawbit
++] = 1;
304 if ((abs(count
- j
)) > worst
) {
305 worst
= abs(count
- j
);
315 PrintAndLog("Recovered %d raw bits, expected: %d", rawbit
, GraphTraceLen
/32);
316 PrintAndLog("worst metric (0=best..7=worst): %d at pos %d", worst
, worstPos
);
321 // Finding the start of a UID
322 int uidlen
, long_wait
;
323 if (strcmp(Cmd
, "224") == 0) {
333 for (start
= 0; start
<= rawbit
- uidlen
; start
++) {
334 first
= rawbits
[start
];
335 for (i
= start
; i
< start
+ long_wait
; i
++) {
336 if (rawbits
[i
] != first
) {
340 if (i
== (start
+ long_wait
)) {
345 if (start
== rawbit
- uidlen
+ 1) {
346 PrintAndLog("nothing to wait for");
350 // Inverting signal if needed
352 for (i
= start
; i
< rawbit
; i
++) {
353 rawbits
[i
] = !rawbits
[i
];
358 uint8_t bits
[224] = {0x00};
359 char showbits
[225] = {0x00};
364 if (uidlen
> rawbit
) {
365 PrintAndLog("Warning: not enough raw bits to get a full UID");
366 for (bit
= 0; bit
< rawbit
; bit
++) {
367 bits
[bit
] = rawbits
[i
++];
368 // As we cannot know the parity, let's use "." and "/"
369 showbits
[bit
] = '.' + bits
[bit
];
371 showbits
[bit
+1]='\0';
372 PrintAndLog("Partial UID=%s", showbits
);
375 for (bit
= 0; bit
< uidlen
; bit
++) {
376 bits
[bit
] = rawbits
[i
++];
377 showbits
[bit
] = '0' + bits
[bit
];
383 uint32_t uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
;
388 for( idx
=0; idx
<64; idx
++) {
389 if (showbits
[idx
] == '0') {
390 uid1
=(uid1
<<1)|(uid2
>>31);
393 uid1
=(uid1
<<1)|(uid2
>>31);
397 PrintAndLog("UID=%s (%x%08x)", showbits
, uid1
, uid2
);
400 uid3
= uid4
= uid5
= uid6
= uid7
= 0;
402 for( idx
=0; idx
<224; idx
++) {
403 uid1
=(uid1
<<1)|(uid2
>>31);
404 uid2
=(uid2
<<1)|(uid3
>>31);
405 uid3
=(uid3
<<1)|(uid4
>>31);
406 uid4
=(uid4
<<1)|(uid5
>>31);
407 uid5
=(uid5
<<1)|(uid6
>>31);
408 uid6
=(uid6
<<1)|(uid7
>>31);
410 if (showbits
[idx
] == '0')
411 uid7
= (uid7
<<1) | 0;
413 uid7
= (uid7
<<1) | 1;
415 PrintAndLog("UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits
, uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
);
418 // Checking UID against next occurrences
420 for (; i
+ uidlen
<= rawbit
;) {
422 for (bit
= 0; bit
< uidlen
; bit
++) {
423 if (bits
[bit
] != rawbits
[i
++]) {
434 PrintAndLog("Occurrences: %d (expected %d)", times
, (rawbit
- start
) / uidlen
);
436 // Remodulating for tag cloning
437 // HACK: 2015-01-04 this will have an impact on our new way of seening lf commands (demod)
438 // since this changes graphbuffer data.
439 GraphTraceLen
= 32*uidlen
;
442 for (bit
= 0; bit
< uidlen
; bit
++) {
443 if (bits
[bit
] == 0) {
449 for (j
= 0; j
< 32; j
++) {
450 GraphBuffer
[i
++] = phase
;
455 RepaintGraphWindow();
459 int CmdIndalaClone(const char *Cmd
)
462 unsigned int uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
;
464 uid1
= uid2
= uid3
= uid4
= uid5
= uid6
= uid7
= 0;
467 if (strchr(Cmd
,'l') != 0) {
468 while (sscanf(&Cmd
[i
++], "%1x", &n
) == 1) {
469 uid1
= (uid1
<< 4) | (uid2
>> 28);
470 uid2
= (uid2
<< 4) | (uid3
>> 28);
471 uid3
= (uid3
<< 4) | (uid4
>> 28);
472 uid4
= (uid4
<< 4) | (uid5
>> 28);
473 uid5
= (uid5
<< 4) | (uid6
>> 28);
474 uid6
= (uid6
<< 4) | (uid7
>> 28);
475 uid7
= (uid7
<< 4) | (n
& 0xf);
477 PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1
, uid2
, uid3
, uid4
, uid5
, uid6
, uid7
);
478 c
.cmd
= CMD_INDALA_CLONE_TAG_L
;
479 c
.d
.asDwords
[0] = uid1
;
480 c
.d
.asDwords
[1] = uid2
;
481 c
.d
.asDwords
[2] = uid3
;
482 c
.d
.asDwords
[3] = uid4
;
483 c
.d
.asDwords
[4] = uid5
;
484 c
.d
.asDwords
[5] = uid6
;
485 c
.d
.asDwords
[6] = uid7
;
487 while (sscanf(&Cmd
[i
++], "%1x", &n
) == 1) {
488 uid1
= (uid1
<< 4) | (uid2
>> 28);
489 uid2
= (uid2
<< 4) | (n
& 0xf);
491 PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1
, uid2
);
492 c
.cmd
= CMD_INDALA_CLONE_TAG
;
501 int CmdLFSetConfig(const char *Cmd
)
504 uint8_t divisor
= 0;//Frequency divisor
505 uint8_t bps
= 0; // Bits per sample
506 uint8_t decimation
= 0; //How many to keep
507 bool averaging
= 1; // Defaults to true
509 int trigger_threshold
=-1;//Means no change
510 uint8_t unsigned_trigg
= 0;
513 while(param_getchar(Cmd
, cmdp
) != 0x00)
515 switch(param_getchar(Cmd
, cmdp
))
518 return usage_lf_config();
528 errors
|= param_getdec(Cmd
,cmdp
+1,&divisor
);
532 errors
|= param_getdec(Cmd
,cmdp
+1,&unsigned_trigg
);
534 if(!errors
) trigger_threshold
= unsigned_trigg
;
537 errors
|= param_getdec(Cmd
,cmdp
+1,&bps
);
541 errors
|= param_getdec(Cmd
,cmdp
+1,&decimation
);
545 averaging
= param_getchar(Cmd
,cmdp
+1) == '1';
549 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
557 errors
= 1;// No args
563 return usage_lf_config();
565 //Bps is limited to 8, so fits in lower half of arg1
566 if(bps
>> 8) bps
= 8;
568 sample_config config
= {
569 decimation
,bps
,averaging
,divisor
,trigger_threshold
571 //Averaging is a flag on high-bit of arg[1]
572 UsbCommand c
= {CMD_SET_LF_SAMPLING_CONFIG
};
573 memcpy(c
.d
.asBytes
,&config
,sizeof(sample_config
));
578 int CmdLFRead(const char *Cmd
)
581 uint8_t cmdp
= param_getchar(Cmd
, 0);
583 if ( cmdp
== 'h' || cmdp
== 'H') return usage_lf_read();
586 if ( cmdp
== 's' || cmdp
== 'S') arg1
= true;
588 UsbCommand c
= {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K
, {arg1
,0,0}};
589 clearCommandBuffer();
591 if ( !WaitForResponseTimeout(CMD_ACK
,NULL
,2500) ) {
592 PrintAndLog("command execution time out");
598 int CmdLFSnoop(const char *Cmd
)
600 uint8_t cmdp
= param_getchar(Cmd
, 0);
601 if(cmdp
== 'h' || cmdp
== 'H') return usage_lf_snoop();
603 UsbCommand c
= {CMD_LF_SNOOP_RAW_ADC_SAMPLES
};
604 clearCommandBuffer();
606 WaitForResponse(CMD_ACK
,NULL
);
610 static void ChkBitstream(const char *str
)
614 /* convert to bitstream if necessary */
615 for (i
= 0; i
< (int)(GraphTraceLen
/ 2); i
++){
616 if (GraphBuffer
[i
] > 1 || GraphBuffer
[i
] < 0) {
622 //Attempt to simulate any wave in buffer (one bit per output sample)
623 // converts GraphBuffer to bitstream (based on zero crossings) if needed.
624 int CmdLFSim(const char *Cmd
)
629 sscanf(Cmd
, "%i", &gap
);
631 // convert to bitstream if necessary
634 //can send only 512 bits at a time (1 byte sent per bit...)
635 printf("Sending [%d bytes]", GraphTraceLen
);
636 for (i
= 0; i
< GraphTraceLen
; i
+= USB_CMD_DATA_SIZE
) {
637 UsbCommand c
= {CMD_DOWNLOADED_SIM_SAMPLES_125K
, {i
, 0, 0}};
639 for (j
= 0; j
< USB_CMD_DATA_SIZE
; j
++) {
640 c
.d
.asBytes
[j
] = GraphBuffer
[i
+j
];
642 clearCommandBuffer();
644 WaitForResponse(CMD_ACK
,NULL
);
648 PrintAndLog("\nStarting to simulate");
649 UsbCommand c
= {CMD_SIMULATE_TAG_125K
, {GraphTraceLen
, gap
, 0}};
650 clearCommandBuffer();
655 // by marshmellow - sim ask data given clock, fcHigh, fcLow, invert
656 // - allow pull data from DemodBuffer
657 int CmdLFfskSim(const char *Cmd
)
659 //might be able to autodetect FCs and clock from Graphbuffer if using demod buffer
660 // otherwise will need FChigh, FClow, Clock, and bitstream
661 uint8_t fcHigh
=0, fcLow
=0, clk
=0;
664 char hexData
[32] = {0x00}; // store entered hex data
665 uint8_t data
[255] = {0x00};
668 while(param_getchar(Cmd
, cmdp
) != 0x00)
670 switch(param_getchar(Cmd
, cmdp
))
673 return usage_lf_simfsk();
679 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
683 errors
|= param_getdec(Cmd
,cmdp
+1,&fcHigh
);
687 errors
|= param_getdec(Cmd
,cmdp
+1,&fcLow
);
695 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
699 dataLen
= hextobinarray((char *)data
, hexData
);
701 if (dataLen
==0) errors
=TRUE
;
702 if (errors
) PrintAndLog ("Error getting hex data");
706 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
712 if(cmdp
== 0 && DemodBufferLen
== 0)
714 errors
= TRUE
;// No args
720 return usage_lf_simfsk();
723 if (dataLen
== 0){ //using DemodBuffer
724 if (clk
==0 || fcHigh
==0 || fcLow
==0){ //manual settings must set them all
725 uint8_t ans
= fskClocks(&fcHigh
, &fcLow
, &clk
, 0);
727 if (!fcHigh
) fcHigh
=10;
733 setDemodBuf(data
, dataLen
, 0);
736 //default if not found
737 if (clk
== 0) clk
= 50;
738 if (fcHigh
== 0) fcHigh
= 10;
739 if (fcLow
== 0) fcLow
= 8;
742 arg1
= fcHigh
<< 8 | fcLow
;
743 arg2
= invert
<< 8 | clk
;
744 size_t size
= DemodBufferLen
;
745 if (size
> USB_CMD_DATA_SIZE
) {
746 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
747 size
= USB_CMD_DATA_SIZE
;
749 UsbCommand c
= {CMD_FSK_SIM_TAG
, {arg1
, arg2
, size
}};
751 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
756 // by marshmellow - sim ask data given clock, invert, manchester or raw, separator
757 // - allow pull data from DemodBuffer
758 int CmdLFaskSim(const char *Cmd
)
760 //autodetect clock from Graphbuffer if using demod buffer
761 // needs clock, invert, manchester/raw as m or r, separator as s, and bitstream
762 uint8_t encoding
= 1, separator
= 0;
763 uint8_t clk
=0, invert
=0;
765 char hexData
[32] = {0x00};
766 uint8_t data
[255]= {0x00}; // store entered hex data
769 while(param_getchar(Cmd
, cmdp
) != 0x00)
771 switch(param_getchar(Cmd
, cmdp
))
774 return usage_lf_simask();
780 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
784 encoding
=2; //biphase
800 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
804 dataLen
= hextobinarray((char *)data
, hexData
);
806 if (dataLen
==0) errors
=TRUE
;
807 if (errors
) PrintAndLog ("Error getting hex data, datalen: %d",dataLen
);
811 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
817 if(cmdp
== 0 && DemodBufferLen
== 0)
819 errors
= TRUE
;// No args
825 return usage_lf_simask();
827 if (dataLen
== 0){ //using DemodBuffer
828 if (clk
== 0) clk
= GetAskClock("0", false, false);
830 setDemodBuf(data
, dataLen
, 0);
832 if (clk
== 0) clk
= 64;
833 if (encoding
== 0) clk
= clk
/2; //askraw needs to double the clock speed
835 size_t size
=DemodBufferLen
;
836 arg1
= clk
<< 8 | encoding
;
837 arg2
= invert
<< 8 | separator
;
838 if (size
> USB_CMD_DATA_SIZE
) {
839 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
840 size
= USB_CMD_DATA_SIZE
;
842 UsbCommand c
= {CMD_ASK_SIM_TAG
, {arg1
, arg2
, size
}};
843 PrintAndLog("preparing to sim ask data: %d bits", size
);
844 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
849 // by marshmellow - sim psk data given carrier, clock, invert
850 // - allow pull data from DemodBuffer or parameters
851 int CmdLFpskSim(const char *Cmd
)
853 //might be able to autodetect FC and clock from Graphbuffer if using demod buffer
854 //will need carrier, Clock, and bitstream
855 uint8_t carrier
=0, clk
=0;
858 char hexData
[32] = {0x00}; // store entered hex data
859 uint8_t data
[255] = {0x00};
863 while(param_getchar(Cmd
, cmdp
) != 0x00)
865 switch(param_getchar(Cmd
, cmdp
))
868 return usage_lf_simpsk();
874 errors
|= param_getdec(Cmd
,cmdp
+1,&clk
);
878 errors
|= param_getdec(Cmd
,cmdp
+1,&carrier
);
894 dataLen
= param_getstr(Cmd
, cmdp
+1, hexData
);
898 dataLen
= hextobinarray((char *)data
, hexData
);
900 if (dataLen
==0) errors
=TRUE
;
901 if (errors
) PrintAndLog ("Error getting hex data");
905 PrintAndLog("Unknown parameter '%c'", param_getchar(Cmd
, cmdp
));
911 if (cmdp
== 0 && DemodBufferLen
== 0)
913 errors
= TRUE
;// No args
919 return usage_lf_simpsk();
921 if (dataLen
== 0){ //using DemodBuffer
922 PrintAndLog("Getting Clocks");
923 if (clk
==0) clk
= GetPskClock("", FALSE
, FALSE
);
924 PrintAndLog("clk: %d",clk
);
925 if (!carrier
) carrier
= GetPskCarrier("", FALSE
, FALSE
);
926 PrintAndLog("carrier: %d", carrier
);
928 setDemodBuf(data
, dataLen
, 0);
931 if (clk
<= 0) clk
= 32;
932 if (carrier
== 0) carrier
= 2;
935 //need to convert psk2 to psk1 data before sim
936 psk2TOpsk1(DemodBuffer
, DemodBufferLen
);
938 PrintAndLog("Sorry, PSK3 not yet available");
942 arg1
= clk
<< 8 | carrier
;
944 size_t size
=DemodBufferLen
;
945 if (size
> USB_CMD_DATA_SIZE
) {
946 PrintAndLog("DemodBuffer too long for current implementation - length: %d - max: %d", size
, USB_CMD_DATA_SIZE
);
947 size
=USB_CMD_DATA_SIZE
;
949 UsbCommand c
= {CMD_PSK_SIM_TAG
, {arg1
, arg2
, size
}};
950 PrintAndLog("DEBUG: Sending DemodBuffer Length: %d", size
);
951 memcpy(c
.d
.asBytes
, DemodBuffer
, size
);
957 int CmdLFSimBidir(const char *Cmd
)
959 // Set ADC to twice the carrier for a slight supersampling
960 // HACK: not implemented in ARMSRC.
961 PrintAndLog("Not implemented yet.");
962 UsbCommand c
= {CMD_LF_SIMULATE_BIDIR
, {47, 384, 0}};
967 int CmdVchDemod(const char *Cmd
)
969 // Is this the entire sync pattern, or does this also include some
970 // data bits that happen to be the same everywhere? That would be
972 static const int SyncPattern
[] = {
973 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
974 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
975 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
976 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
977 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
978 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
979 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
980 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
981 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
982 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
985 // So first, we correlate for the sync pattern, and mark that.
986 int bestCorrel
= 0, bestPos
= 0;
988 // It does us no good to find the sync pattern, with fewer than
989 // 2048 samples after it...
990 for (i
= 0; i
< (GraphTraceLen
-2048); i
++) {
993 for (j
= 0; j
< arraylen(SyncPattern
); j
++) {
994 sum
+= GraphBuffer
[i
+j
]*SyncPattern
[j
];
996 if (sum
> bestCorrel
) {
1001 PrintAndLog("best sync at %d [metric %d]", bestPos
, bestCorrel
);
1006 int worst
= INT_MAX
;
1009 for (i
= 0; i
< 2048; i
+= 8) {
1012 for (j
= 0; j
< 8; j
++) {
1013 sum
+= GraphBuffer
[bestPos
+i
+j
];
1020 if(abs(sum
) < worst
) {
1025 PrintAndLog("bits:");
1026 PrintAndLog("%s", bits
);
1027 PrintAndLog("worst metric: %d at pos %d", worst
, worstPos
);
1029 if (strcmp(Cmd
, "clone")==0) {
1032 for(s
= bits
; *s
; s
++) {
1034 for(j
= 0; j
< 16; j
++) {
1035 GraphBuffer
[GraphTraceLen
++] = (*s
== '1') ? 1 : 0;
1038 RepaintGraphWindow();
1044 int CmdLFfind(const char *Cmd
)
1047 char cmdp
= param_getchar(Cmd
, 0);
1048 char testRaw
= param_getchar(Cmd
, 1);
1049 if (strlen(Cmd
) > 3 || cmdp
== 'h' || cmdp
== 'H') {
1050 PrintAndLog("Usage: lf search <0|1> [u]");
1051 PrintAndLog(" <use data from Graphbuffer> , if not set, try reading data from tag.");
1052 PrintAndLog(" [Search for Unknown tags] , if not set, reads only known tags.");
1054 PrintAndLog(" sample: lf search = try reading data from tag & search for known tags");
1055 PrintAndLog(" : lf search 1 = use data from GraphBuffer & search for known tags");
1056 PrintAndLog(" : lf search u = try reading data from tag & search for known and unknown tags");
1057 PrintAndLog(" : lf search 1 u = use data from GraphBuffer & search for known and unknown tags");
1062 if (!offline
&& (cmdp
!= '1')){
1064 getSamples("30000",false);
1065 } else if (GraphTraceLen
< 1000) {
1066 PrintAndLog("Data in Graphbuffer was too small.");
1069 if (cmdp
== 'u' || cmdp
== 'U') testRaw
= 'u';
1071 PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag");
1072 PrintAndLog("False Positives ARE possible\n");
1073 PrintAndLog("\nChecking for known tags:\n");
1075 ans
=CmdFSKdemodIO("");
1077 PrintAndLog("\nValid IO Prox ID Found!");
1081 ans
=CmdFSKdemodPyramid("");
1083 PrintAndLog("\nValid Pyramid ID Found!");
1087 ans
=CmdFSKdemodParadox("");
1089 PrintAndLog("\nValid Paradox ID Found!");
1093 ans
=CmdFSKdemodAWID("");
1095 PrintAndLog("\nValid AWID ID Found!");
1099 ans
=CmdFSKdemodHID("");
1101 PrintAndLog("\nValid HID Prox ID Found!");
1105 //add psk and indala
1106 ans
=CmdIndalaDecode("");
1108 PrintAndLog("\nValid Indala ID Found!");
1112 ans
=CmdAskEM410xDemod("");
1114 PrintAndLog("\nValid EM410x ID Found!");
1118 ans
=CmdG_Prox_II_Demod("");
1120 PrintAndLog("\nValid Guardall G-Prox II ID Found!");
1124 ans
=CmdFDXBdemodBI("");
1126 PrintAndLog("\nValid FDX-B ID Found!");
1130 ans
=EM4x50Read("", false);
1132 PrintAndLog("\nValid EM4x50 ID Found!");
1136 ans
=CmdPSKNexWatch("");
1138 PrintAndLog("\nValid NexWatch ID Found!");
1142 PrintAndLog("\nNo Known Tags Found!\n");
1143 if (testRaw
=='u' || testRaw
=='U'){
1144 //test unknown tag formats (raw mode)
1145 PrintAndLog("\nChecking for Unknown tags:\n");
1146 ans
=AutoCorrelate(4000, FALSE
, FALSE
);
1150 PrintAndLog("Possible Auto Correlation of %d repeating samples",ans
);
1152 if ( ans
% 8 == 0) {
1153 int bytes
= (ans
/ 8);
1154 PrintAndLog("Possible %d bytes", bytes
);
1156 if ( bytes
% 2 == 0) {
1157 blocks
= (bytes
/ 2);
1158 PrintAndLog("Possible 2 blocks, width %d", blocks
);
1160 if ( bytes
% 4 == 0) {
1161 blocks
= (bytes
/ 4);
1162 PrintAndLog("Possible 4 blocks, width %d", blocks
);
1164 if ( bytes
% 8 == 0) {
1165 blocks
= (bytes
/ 8);
1166 PrintAndLog("Possible 8 blocks, width %d", blocks
);
1168 if ( bytes
% 16 == 0) {
1169 blocks
= (bytes
/ 16);
1170 PrintAndLog("Possible 16 blocks, width %d", blocks
);
1174 ans
=GetFskClock("",FALSE
,FALSE
);
1175 if (ans
!= 0){ //fsk
1176 ans
=FSKrawDemod("",TRUE
);
1178 PrintAndLog("\nUnknown FSK Modulated Tag Found!");
1182 ans
=ASKDemod("0 0 0",TRUE
,FALSE
,1);
1184 PrintAndLog("\nUnknown ASK Modulated and Manchester encoded Tag Found!");
1185 PrintAndLog("\nif it does not look right it could instead be ASK/Biphase - try 'data rawdemod ab'");
1188 ans
=CmdPSK1rawDemod("");
1190 PrintAndLog("Possible unknown PSK1 Modulated Tag Found above!\n\nCould also be PSK2 - try 'data rawdemod p2'");
1191 PrintAndLog("\nCould also be PSK3 - [currently not supported]");
1192 PrintAndLog("\nCould also be NRZ - try 'data nrzrawdemod");
1195 PrintAndLog("\nNo Data Found!\n");
1200 static command_t CommandTable
[] =
1202 {"help", CmdHelp
, 1, "This help"},
1203 {"awid", CmdLFAWID
, 1, "{ AWID RFIDs... }"},
1204 {"em4x", CmdLFEM4X
, 1, "{ EM4X RFIDs... }"},
1205 {"hid", CmdLFHID
, 1, "{ HID RFIDs... }"},
1206 {"hitag", CmdLFHitag
, 1, "{ HITAG RFIDs... }"},
1207 {"io", CmdLFIO
, 1, "{ IOPROX RFIDs... }"},
1208 {"pcf7931", CmdLFPCF7931
, 1, "{ PCF7931 RFIDs... }"},
1209 {"ti", CmdLFTI
, 1, "{ TI RFIDs... }"},
1210 {"t55xx", CmdLFT55XX
, 1, "{ T55X7 RFIDs... }"},
1211 {"viking", CmdLFViking
, 1, "{ Viking RFIDs... }"},
1212 {"config", CmdLFSetConfig
, 0, "Set config for LF sampling, bit/sample, decimation, frequency"},
1214 {"cmdread", CmdLFCommandRead
, 0, "<off period> <'0' period> <'1' period> <command> ['h' 134] \n\t\t-- Modulate LF reader field to send command before read (all periods in microseconds)"},
1215 {"flexdemod", CmdFlexdemod
, 1, "Demodulate samples for FlexPass"},
1216 {"indalademod", CmdIndalaDemod
, 1, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"},
1217 {"indalaclone", CmdIndalaClone
, 0, "<UID> ['l']-- Clone Indala to T55x7 (tag must be in antenna)(UID in HEX)(option 'l' for 224 UID"},
1218 {"read", CmdLFRead
, 0, "['s' silent] Read 125/134 kHz LF ID-only tag. Do 'lf read h' for help"},
1219 {"search", CmdLFfind
, 1, "[offline] ['u'] Read and Search for valid known tag (in offline mode it you can load first then search) \n\t\t-- 'u' to search for unknown tags"},
1220 {"sim", CmdLFSim
, 0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"},
1221 {"simask", CmdLFaskSim
, 0, "[clock] [invert <1|0>] [biphase/manchester/raw <'b'|'m'|'r'>] [msg separator 's'] [d <hexdata>] \n\t\t-- Simulate LF ASK tag from demodbuffer or input"},
1222 {"simfsk", CmdLFfskSim
, 0, "[c <clock>] [i] [H <fcHigh>] [L <fcLow>] [d <hexdata>] \n\t\t-- Simulate LF FSK tag from demodbuffer or input"},
1223 {"simpsk", CmdLFpskSim
, 0, "[1|2|3] [c <clock>] [i] [r <carrier>] [d <raw hex to sim>] \n\t\t-- Simulate LF PSK tag from demodbuffer or input"},
1224 {"simbidir", CmdLFSimBidir
, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"},
1225 {"snoop", CmdLFSnoop
, 0, "Snoop LF"},
1226 {"vchdemod", CmdVchDemod
, 1, "['clone'] -- Demodulate samples for VeriChip"},
1227 {NULL
, NULL
, 0, NULL
}
1230 int CmdLF(const char *Cmd
)
1232 CmdsParse(CommandTable
, Cmd
);
1236 int CmdHelp(const char *Cmd
)
1238 CmdsHelp(CommandTable
);