]>
Commit | Line | Data |
---|---|---|
a553f267 | 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 | // Low frequency commands | |
9 | //----------------------------------------------------------------------------- | |
10 | ||
7fe9b0b7 | 11 | #include <stdio.h> |
590f8ff9 | 12 | #include <stdlib.h> |
7fe9b0b7 | 13 | #include <string.h> |
393c3ef9 | 14 | #include <limits.h> |
902cb3c0 | 15 | #include "proxmark3.h" |
7fe9b0b7 | 16 | #include "data.h" |
17 | #include "graph.h" | |
18 | #include "ui.h" | |
19 | #include "cmdparser.h" | |
040a7baa | 20 | #include "cmdmain.h" |
7fe9b0b7 | 21 | #include "cmddata.h" |
31d1caa5 | 22 | #include "util.h" |
7fe9b0b7 | 23 | #include "cmdlf.h" |
24 | #include "cmdlfhid.h" | |
25 | #include "cmdlfti.h" | |
26 | #include "cmdlfem4x.h" | |
db09cb3a | 27 | #include "cmdlfhitag.h" |
54a942b0 | 28 | #include "cmdlft55xx.h" |
29 | #include "cmdlfpcf7931.h" | |
a1f3bb12 | 30 | #include "cmdlfio.h" |
7fe9b0b7 | 31 | |
32 | static int CmdHelp(const char *Cmd); | |
33 | ||
34 | /* send a command before reading */ | |
35 | int CmdLFCommandRead(const char *Cmd) | |
36 | { | |
37 | static char dummy[3]; | |
38 | ||
39 | dummy[0]= ' '; | |
40 | ||
41 | UsbCommand c = {CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K}; | |
1a07fd51 | 42 | sscanf(Cmd, "%"lli" %"lli" %"lli" %s %s", &c.arg[0], &c.arg[1], &c.arg[2],(char*)(&c.d.asBytes),(char*)(&dummy+1)); |
7fe9b0b7 | 43 | // in case they specified 'h' |
44 | strcpy((char *)&c.d.asBytes + strlen((char *)c.d.asBytes), dummy); | |
45 | SendCommand(&c); | |
46 | return 0; | |
47 | } | |
48 | ||
49 | int CmdFlexdemod(const char *Cmd) | |
50 | { | |
51 | int i; | |
52 | for (i = 0; i < GraphTraceLen; ++i) { | |
53 | if (GraphBuffer[i] < 0) { | |
54 | GraphBuffer[i] = -1; | |
55 | } else { | |
56 | GraphBuffer[i] = 1; | |
57 | } | |
58 | } | |
59 | ||
60 | #define LONG_WAIT 100 | |
61 | int start; | |
62 | for (start = 0; start < GraphTraceLen - LONG_WAIT; start++) { | |
63 | int first = GraphBuffer[start]; | |
64 | for (i = start; i < start + LONG_WAIT; i++) { | |
65 | if (GraphBuffer[i] != first) { | |
66 | break; | |
67 | } | |
68 | } | |
69 | if (i == (start + LONG_WAIT)) { | |
70 | break; | |
71 | } | |
72 | } | |
73 | if (start == GraphTraceLen - LONG_WAIT) { | |
74 | PrintAndLog("nothing to wait for"); | |
75 | return 0; | |
76 | } | |
77 | ||
78 | GraphBuffer[start] = 2; | |
79 | GraphBuffer[start+1] = -2; | |
3fe4ff4f | 80 | uint8_t bits[64] = {0x00}; |
7fe9b0b7 | 81 | |
3fe4ff4f | 82 | int bit, sum; |
7fe9b0b7 | 83 | i = start; |
84 | for (bit = 0; bit < 64; bit++) { | |
3fe4ff4f | 85 | sum = 0; |
86 | for (int j = 0; j < 16; j++) { | |
7fe9b0b7 | 87 | sum += GraphBuffer[i++]; |
88 | } | |
3fe4ff4f | 89 | |
90 | bits[bit] = (sum > 0) ? 1 : 0; | |
91 | ||
7fe9b0b7 | 92 | PrintAndLog("bit %d sum %d", bit, sum); |
93 | } | |
94 | ||
95 | for (bit = 0; bit < 64; bit++) { | |
96 | int j; | |
97 | int sum = 0; | |
98 | for (j = 0; j < 16; j++) { | |
99 | sum += GraphBuffer[i++]; | |
100 | } | |
101 | if (sum > 0 && bits[bit] != 1) { | |
102 | PrintAndLog("oops1 at %d", bit); | |
103 | } | |
104 | if (sum < 0 && bits[bit] != 0) { | |
105 | PrintAndLog("oops2 at %d", bit); | |
106 | } | |
107 | } | |
108 | ||
3fe4ff4f | 109 | // HACK writing back to graphbuffer. |
7fe9b0b7 | 110 | GraphTraceLen = 32*64; |
111 | i = 0; | |
112 | int phase = 0; | |
113 | for (bit = 0; bit < 64; bit++) { | |
3fe4ff4f | 114 | |
115 | phase = (bits[bit] == 0) ? 0 : 1; | |
116 | ||
7fe9b0b7 | 117 | int j; |
118 | for (j = 0; j < 32; j++) { | |
119 | GraphBuffer[i++] = phase; | |
120 | phase = !phase; | |
121 | } | |
122 | } | |
123 | ||
124 | RepaintGraphWindow(); | |
125 | return 0; | |
126 | } | |
a1f3bb12 | 127 | |
7fe9b0b7 | 128 | int CmdIndalaDemod(const char *Cmd) |
129 | { | |
130 | // Usage: recover 64bit UID by default, specify "224" as arg to recover a 224bit UID | |
131 | ||
132 | int state = -1; | |
133 | int count = 0; | |
134 | int i, j; | |
3fe4ff4f | 135 | |
7fe9b0b7 | 136 | // worst case with GraphTraceLen=64000 is < 4096 |
137 | // under normal conditions it's < 2048 | |
3fe4ff4f | 138 | |
7fe9b0b7 | 139 | uint8_t rawbits[4096]; |
140 | int rawbit = 0; | |
141 | int worst = 0, worstPos = 0; | |
d5a72d2f | 142 | // PrintAndLog("Expecting a bit less than %d raw bits", GraphTraceLen / 32); |
7fe9b0b7 | 143 | for (i = 0; i < GraphTraceLen-1; i += 2) { |
144 | count += 1; | |
145 | if ((GraphBuffer[i] > GraphBuffer[i + 1]) && (state != 1)) { | |
146 | if (state == 0) { | |
147 | for (j = 0; j < count - 8; j += 16) { | |
148 | rawbits[rawbit++] = 0; | |
149 | } | |
150 | if ((abs(count - j)) > worst) { | |
151 | worst = abs(count - j); | |
152 | worstPos = i; | |
153 | } | |
154 | } | |
155 | state = 1; | |
156 | count = 0; | |
157 | } else if ((GraphBuffer[i] < GraphBuffer[i + 1]) && (state != 0)) { | |
158 | if (state == 1) { | |
159 | for (j = 0; j < count - 8; j += 16) { | |
160 | rawbits[rawbit++] = 1; | |
161 | } | |
162 | if ((abs(count - j)) > worst) { | |
163 | worst = abs(count - j); | |
164 | worstPos = i; | |
165 | } | |
166 | } | |
167 | state = 0; | |
168 | count = 0; | |
169 | } | |
170 | } | |
3fe4ff4f | 171 | |
d5a72d2f | 172 | if (rawbit>0){ |
173 | PrintAndLog("Recovered %d raw bits, expected: %d", rawbit, GraphTraceLen/32); | |
174 | PrintAndLog("worst metric (0=best..7=worst): %d at pos %d", worst, worstPos); | |
3fe4ff4f | 175 | } else { |
176 | return 0; | |
177 | } | |
178 | ||
7fe9b0b7 | 179 | // Finding the start of a UID |
180 | int uidlen, long_wait; | |
181 | if (strcmp(Cmd, "224") == 0) { | |
182 | uidlen = 224; | |
183 | long_wait = 30; | |
184 | } else { | |
185 | uidlen = 64; | |
186 | long_wait = 29; | |
187 | } | |
3fe4ff4f | 188 | |
7fe9b0b7 | 189 | int start; |
190 | int first = 0; | |
191 | for (start = 0; start <= rawbit - uidlen; start++) { | |
192 | first = rawbits[start]; | |
193 | for (i = start; i < start + long_wait; i++) { | |
194 | if (rawbits[i] != first) { | |
195 | break; | |
196 | } | |
197 | } | |
198 | if (i == (start + long_wait)) { | |
199 | break; | |
200 | } | |
201 | } | |
3fe4ff4f | 202 | |
7fe9b0b7 | 203 | if (start == rawbit - uidlen + 1) { |
204 | PrintAndLog("nothing to wait for"); | |
205 | return 0; | |
206 | } | |
207 | ||
208 | // Inverting signal if needed | |
209 | if (first == 1) { | |
210 | for (i = start; i < rawbit; i++) { | |
211 | rawbits[i] = !rawbits[i]; | |
212 | } | |
213 | } | |
214 | ||
215 | // Dumping UID | |
3fe4ff4f | 216 | uint8_t bits[224] = {0x00}; |
217 | char showbits[225] = {0x00}; | |
7fe9b0b7 | 218 | int bit; |
219 | i = start; | |
220 | int times = 0; | |
3fe4ff4f | 221 | |
7fe9b0b7 | 222 | if (uidlen > rawbit) { |
223 | PrintAndLog("Warning: not enough raw bits to get a full UID"); | |
224 | for (bit = 0; bit < rawbit; bit++) { | |
225 | bits[bit] = rawbits[i++]; | |
226 | // As we cannot know the parity, let's use "." and "/" | |
227 | showbits[bit] = '.' + bits[bit]; | |
228 | } | |
229 | showbits[bit+1]='\0'; | |
230 | PrintAndLog("Partial UID=%s", showbits); | |
231 | return 0; | |
232 | } else { | |
233 | for (bit = 0; bit < uidlen; bit++) { | |
234 | bits[bit] = rawbits[i++]; | |
235 | showbits[bit] = '0' + bits[bit]; | |
236 | } | |
237 | times = 1; | |
238 | } | |
2414f978 | 239 | |
240 | //convert UID to HEX | |
241 | uint32_t uid1, uid2, uid3, uid4, uid5, uid6, uid7; | |
242 | int idx; | |
3fe4ff4f | 243 | uid1 = uid2 = 0; |
244 | ||
2414f978 | 245 | if (uidlen==64){ |
246 | for( idx=0; idx<64; idx++) { | |
247 | if (showbits[idx] == '0') { | |
248 | uid1=(uid1<<1)|(uid2>>31); | |
249 | uid2=(uid2<<1)|0; | |
250 | } else { | |
251 | uid1=(uid1<<1)|(uid2>>31); | |
252 | uid2=(uid2<<1)|1; | |
253 | } | |
254 | } | |
255 | PrintAndLog("UID=%s (%x%08x)", showbits, uid1, uid2); | |
256 | } | |
257 | else { | |
3fe4ff4f | 258 | uid3 = uid4 = uid5 = uid6 = uid7 = 0; |
259 | ||
2414f978 | 260 | for( idx=0; idx<224; idx++) { |
261 | uid1=(uid1<<1)|(uid2>>31); | |
262 | uid2=(uid2<<1)|(uid3>>31); | |
263 | uid3=(uid3<<1)|(uid4>>31); | |
264 | uid4=(uid4<<1)|(uid5>>31); | |
265 | uid5=(uid5<<1)|(uid6>>31); | |
266 | uid6=(uid6<<1)|(uid7>>31); | |
3fe4ff4f | 267 | |
268 | if (showbits[idx] == '0') | |
269 | uid7 = (uid7<<1) | 0; | |
270 | else | |
271 | uid7 = (uid7<<1) | 1; | |
2414f978 | 272 | } |
273 | PrintAndLog("UID=%s (%x%08x%08x%08x%08x%08x%08x)", showbits, uid1, uid2, uid3, uid4, uid5, uid6, uid7); | |
274 | } | |
7fe9b0b7 | 275 | |
0ff9a939 | 276 | // Checking UID against next occurrences |
7fe9b0b7 | 277 | int failed = 0; |
3fe4ff4f | 278 | for (; i + uidlen <= rawbit;) { |
279 | failed = 0; | |
7fe9b0b7 | 280 | for (bit = 0; bit < uidlen; bit++) { |
281 | if (bits[bit] != rawbits[i++]) { | |
282 | failed = 1; | |
283 | break; | |
284 | } | |
285 | } | |
286 | if (failed == 1) { | |
287 | break; | |
288 | } | |
289 | times += 1; | |
290 | } | |
3fe4ff4f | 291 | |
0ff9a939 | 292 | PrintAndLog("Occurrences: %d (expected %d)", times, (rawbit - start) / uidlen); |
7fe9b0b7 | 293 | |
294 | // Remodulating for tag cloning | |
3fe4ff4f | 295 | // HACK: 2015-01-04 this will have an impact on our new way of seening lf commands (demod) |
296 | // since this changes graphbuffer data. | |
7fe9b0b7 | 297 | GraphTraceLen = 32*uidlen; |
298 | i = 0; | |
299 | int phase = 0; | |
300 | for (bit = 0; bit < uidlen; bit++) { | |
301 | if (bits[bit] == 0) { | |
302 | phase = 0; | |
303 | } else { | |
304 | phase = 1; | |
305 | } | |
306 | int j; | |
307 | for (j = 0; j < 32; j++) { | |
308 | GraphBuffer[i++] = phase; | |
309 | phase = !phase; | |
310 | } | |
311 | } | |
312 | ||
313 | RepaintGraphWindow(); | |
d5a72d2f | 314 | return 1; |
7fe9b0b7 | 315 | } |
316 | ||
2414f978 | 317 | int CmdIndalaClone(const char *Cmd) |
318 | { | |
2414f978 | 319 | UsbCommand c; |
3fe4ff4f | 320 | unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7; |
321 | ||
322 | uid1 = uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0; | |
2414f978 | 323 | int n = 0, i = 0; |
324 | ||
325 | if (strchr(Cmd,'l') != 0) { | |
326 | while (sscanf(&Cmd[i++], "%1x", &n ) == 1) { | |
327 | uid1 = (uid1 << 4) | (uid2 >> 28); | |
328 | uid2 = (uid2 << 4) | (uid3 >> 28); | |
329 | uid3 = (uid3 << 4) | (uid4 >> 28); | |
330 | uid4 = (uid4 << 4) | (uid5 >> 28); | |
331 | uid5 = (uid5 << 4) | (uid6 >> 28); | |
332 | uid6 = (uid6 << 4) | (uid7 >> 28); | |
333 | uid7 = (uid7 << 4) | (n & 0xf); | |
334 | } | |
335 | PrintAndLog("Cloning 224bit tag with UID %x%08x%08x%08x%08x%08x%08x", uid1, uid2, uid3, uid4, uid5, uid6, uid7); | |
336 | c.cmd = CMD_INDALA_CLONE_TAG_L; | |
337 | c.d.asDwords[0] = uid1; | |
338 | c.d.asDwords[1] = uid2; | |
339 | c.d.asDwords[2] = uid3; | |
340 | c.d.asDwords[3] = uid4; | |
341 | c.d.asDwords[4] = uid5; | |
342 | c.d.asDwords[5] = uid6; | |
343 | c.d.asDwords[6] = uid7; | |
3fe4ff4f | 344 | } else { |
2414f978 | 345 | while (sscanf(&Cmd[i++], "%1x", &n ) == 1) { |
346 | uid1 = (uid1 << 4) | (uid2 >> 28); | |
347 | uid2 = (uid2 << 4) | (n & 0xf); | |
348 | } | |
349 | PrintAndLog("Cloning 64bit tag with UID %x%08x", uid1, uid2); | |
350 | c.cmd = CMD_INDALA_CLONE_TAG; | |
351 | c.arg[0] = uid1; | |
352 | c.arg[1] = uid2; | |
353 | } | |
354 | ||
355 | SendCommand(&c); | |
356 | return 0; | |
357 | } | |
358 | ||
f6d9fb17 MHS |
359 | int CmdLFReadUsage() |
360 | { | |
361 | PrintAndLog("Usage: lf read [H|<divisor>] [b <bps>] [d <decim>] [a 0|1]"); | |
362 | PrintAndLog("Options: "); | |
363 | PrintAndLog(" h This help"); | |
364 | PrintAndLog(" H High frequency (134 KHz). Defaults to 125 KHz"); | |
365 | PrintAndLog(" <divisor> Manually set divisor. 88-> 134KHz, 95-> 125 Hz"); | |
366 | PrintAndLog(" b <bps> Sets resolution of bits per sample. Default (max): 8"); | |
367 | PrintAndLog(" d <decim> Sets decimation. A value of N saves only 1 in N samples. Default: 1"); | |
368 | PrintAndLog(" a [0|1] Averaging - if set, will average the stored sample value when decimating. Default: 1"); | |
369 | PrintAndLog("Examples:"); | |
370 | PrintAndLog(" lf read"); | |
371 | PrintAndLog(" Samples at 125KHz, 8bps."); | |
372 | PrintAndLog(" lf read h b 4 d 3"); | |
373 | PrintAndLog(" Samples at 134KHz, averages three samples into one, stored with "); | |
374 | PrintAndLog(" a resolution of 4 bits per sample."); | |
375 | return 0; | |
376 | } | |
7fe9b0b7 | 377 | int CmdLFRead(const char *Cmd) |
378 | { | |
f6d9fb17 MHS |
379 | uint8_t divisor = 95;//Frequency divisor |
380 | uint8_t bps = 8; // Bits per sample | |
381 | uint8_t decimation = 1; //How many to keep | |
382 | bool averaging = 1; // Should we use averaging when discarding samples? | |
383 | bool errors = FALSE; | |
384 | ||
385 | uint8_t cmdp =0; | |
386 | if(param_getchar(Cmd, cmdp) == 'h') | |
387 | { | |
388 | return CmdLFReadUsage(); | |
389 | } | |
390 | ||
391 | // Divisor | |
392 | if(param_getchar(Cmd, cmdp) == 'H') { | |
393 | divisor = 88; | |
394 | cmdp++; | |
395 | }else if(param_isdec(Cmd,cmdp) ) | |
396 | { | |
397 | errors |= param_getdec(Cmd,cmdp, &divisor); | |
398 | } | |
399 | //BPS | |
400 | if(param_getchar(Cmd, cmdp) == 'b') { | |
401 | errors |= param_getdec(Cmd,cmdp+1,&bps); | |
402 | cmdp+=2; | |
403 | } | |
404 | //Decimation | |
405 | if(param_getchar(Cmd, cmdp) == 'd') | |
406 | { | |
407 | errors |= param_getdec(Cmd,cmdp+1,&decimation); | |
408 | cmdp+=2; | |
409 | } | |
410 | //Averaging | |
411 | if(param_getchar(Cmd, cmdp) == 'a') | |
412 | { | |
413 | averaging = param_getchar(Cmd,cmdp+1) == '1'; | |
414 | cmdp+=2; | |
415 | } | |
416 | //Validations | |
417 | if(errors) | |
418 | { | |
419 | return CmdLFReadUsage(); | |
420 | } | |
421 | ||
422 | //Bps is limited to 8, so fits in lower half of arg1 | |
423 | if(bps > 8) bps = 8; | |
424 | ||
425 | //Feedback | |
426 | PrintAndLog("Sampling config: "); | |
427 | PrintAndLog(" divisor: %d ", divisor); | |
428 | PrintAndLog(" bps: %d ", bps); | |
429 | PrintAndLog(" decimation: %d ", decimation); | |
430 | PrintAndLog(" averaging: %d ", averaging); | |
431 | PrintAndLog("OBS, this is sticky on the device and affects all LF listening operations"); | |
432 | PrintAndLog("To reset, issue 'lf read'"); | |
433 | ||
434 | //And ship it to device | |
435 | //Averaging is a flag on high-bit of arg[1] | |
436 | UsbCommand c = {CMD_ACQUIRE_RAW_ADC_SAMPLES_125K}; | |
437 | c.arg[0] = divisor; | |
438 | c.arg[1] = bps | (averaging << 7) ; | |
439 | c.arg[2] = decimation; | |
440 | ||
441 | SendCommand(&c); | |
442 | WaitForResponse(CMD_ACK,NULL); | |
443 | return 0; | |
7fe9b0b7 | 444 | } |
445 | ||
446 | static void ChkBitstream(const char *str) | |
447 | { | |
448 | int i; | |
449 | ||
450 | /* convert to bitstream if necessary */ | |
b915fda3 | 451 | for (i = 0; i < (int)(GraphTraceLen / 2); i++){ |
452 | if (GraphBuffer[i] > 1 || GraphBuffer[i] < 0) { | |
7fe9b0b7 | 453 | CmdBitstream(str); |
454 | break; | |
455 | } | |
456 | } | |
457 | } | |
458 | ||
459 | int CmdLFSim(const char *Cmd) | |
460 | { | |
52ab55ab | 461 | int i,j; |
7fe9b0b7 | 462 | static int gap; |
463 | ||
464 | sscanf(Cmd, "%i", &gap); | |
465 | ||
466 | /* convert to bitstream if necessary */ | |
467 | ChkBitstream(Cmd); | |
468 | ||
52ab55ab | 469 | printf("Sending [%d bytes]", GraphTraceLen); |
470 | for (i = 0; i < GraphTraceLen; i += USB_CMD_DATA_SIZE) { | |
7fe9b0b7 | 471 | UsbCommand c={CMD_DOWNLOADED_SIM_SAMPLES_125K, {i, 0, 0}}; |
52ab55ab | 472 | |
473 | for (j = 0; j < USB_CMD_DATA_SIZE; j++) { | |
7fe9b0b7 | 474 | c.d.asBytes[j] = GraphBuffer[i+j]; |
475 | } | |
476 | SendCommand(&c); | |
902cb3c0 | 477 | WaitForResponse(CMD_ACK,NULL); |
52ab55ab | 478 | printf("."); |
7fe9b0b7 | 479 | } |
480 | ||
52ab55ab | 481 | printf("\n"); |
482 | PrintAndLog("Starting to simulate"); | |
7fe9b0b7 | 483 | UsbCommand c = {CMD_SIMULATE_TAG_125K, {GraphTraceLen, gap, 0}}; |
484 | SendCommand(&c); | |
485 | return 0; | |
486 | } | |
487 | ||
488 | int CmdLFSimBidir(const char *Cmd) | |
489 | { | |
3fe4ff4f | 490 | // Set ADC to twice the carrier for a slight supersampling |
491 | // HACK: not implemented in ARMSRC. | |
492 | PrintAndLog("Not implemented yet."); | |
7fe9b0b7 | 493 | UsbCommand c = {CMD_LF_SIMULATE_BIDIR, {47, 384, 0}}; |
494 | SendCommand(&c); | |
495 | return 0; | |
496 | } | |
497 | ||
498 | /* simulate an LF Manchester encoded tag with specified bitstream, clock rate and inter-id gap */ | |
499 | int CmdLFSimManchester(const char *Cmd) | |
500 | { | |
501 | static int clock, gap; | |
502 | static char data[1024], gapstring[8]; | |
503 | ||
7fe9b0b7 | 504 | sscanf(Cmd, "%i %s %i", &clock, &data[0], &gap); |
505 | ||
7fe9b0b7 | 506 | ClearGraph(0); |
507 | ||
7fe9b0b7 | 508 | for (int i = 0; i < strlen(data) ; ++i) |
509 | AppendGraph(0, clock, data[i]- '0'); | |
510 | ||
7fe9b0b7 | 511 | CmdManchesterMod(""); |
512 | ||
7fe9b0b7 | 513 | RepaintGraphWindow(); |
514 | ||
7fe9b0b7 | 515 | sprintf(&gapstring[0], "%i", gap); |
516 | CmdLFSim(gapstring); | |
517 | return 0; | |
518 | } | |
519 | ||
b014c96d | 520 | int CmdLFSnoop(const char *Cmd) |
521 | { | |
522 | UsbCommand c = {CMD_LF_SNOOP_RAW_ADC_SAMPLES}; | |
3fe4ff4f | 523 | |
b014c96d | 524 | // 'h' means higher-low-frequency, 134 kHz |
525 | c.arg[0] = 0; | |
526 | c.arg[1] = -1; | |
3fe4ff4f | 527 | |
528 | if (*Cmd == 'l') { | |
b014c96d | 529 | sscanf(Cmd, "l %"lli, &c.arg[1]); |
530 | } else if(*Cmd == 'h') { | |
531 | c.arg[0] = 1; | |
532 | sscanf(Cmd, "h %"lli, &c.arg[1]); | |
533 | } else if (sscanf(Cmd, "%"lli" %"lli, &c.arg[0], &c.arg[1]) < 1) { | |
3fe4ff4f | 534 | PrintAndLog("usage 1: snoop"); |
535 | PrintAndLog(" 2: snoop {l,h} [trigger threshold]"); | |
536 | PrintAndLog(" 3: snoop <divisor> [trigger threshold]"); | |
b014c96d | 537 | return 0; |
538 | } | |
3fe4ff4f | 539 | |
b014c96d | 540 | SendCommand(&c); |
541 | WaitForResponse(CMD_ACK,NULL); | |
542 | return 0; | |
543 | } | |
544 | ||
7fe9b0b7 | 545 | int CmdVchDemod(const char *Cmd) |
546 | { | |
547 | // Is this the entire sync pattern, or does this also include some | |
548 | // data bits that happen to be the same everywhere? That would be | |
549 | // lovely to know. | |
550 | static const int SyncPattern[] = { | |
551 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
552 | 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
553 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
554 | 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
555 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
556 | 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
557 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
558 | 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
559 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | |
560 | 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, | |
561 | }; | |
562 | ||
563 | // So first, we correlate for the sync pattern, and mark that. | |
564 | int bestCorrel = 0, bestPos = 0; | |
565 | int i; | |
566 | // It does us no good to find the sync pattern, with fewer than | |
567 | // 2048 samples after it... | |
568 | for (i = 0; i < (GraphTraceLen-2048); i++) { | |
569 | int sum = 0; | |
570 | int j; | |
571 | for (j = 0; j < arraylen(SyncPattern); j++) { | |
572 | sum += GraphBuffer[i+j]*SyncPattern[j]; | |
573 | } | |
574 | if (sum > bestCorrel) { | |
575 | bestCorrel = sum; | |
576 | bestPos = i; | |
577 | } | |
578 | } | |
579 | PrintAndLog("best sync at %d [metric %d]", bestPos, bestCorrel); | |
580 | ||
581 | char bits[257]; | |
582 | bits[256] = '\0'; | |
583 | ||
584 | int worst = INT_MAX; | |
fddf220a | 585 | int worstPos = 0; |
7fe9b0b7 | 586 | |
587 | for (i = 0; i < 2048; i += 8) { | |
588 | int sum = 0; | |
589 | int j; | |
590 | for (j = 0; j < 8; j++) { | |
591 | sum += GraphBuffer[bestPos+i+j]; | |
592 | } | |
593 | if (sum < 0) { | |
594 | bits[i/8] = '.'; | |
595 | } else { | |
596 | bits[i/8] = '1'; | |
597 | } | |
598 | if(abs(sum) < worst) { | |
599 | worst = abs(sum); | |
600 | worstPos = i; | |
601 | } | |
602 | } | |
603 | PrintAndLog("bits:"); | |
604 | PrintAndLog("%s", bits); | |
605 | PrintAndLog("worst metric: %d at pos %d", worst, worstPos); | |
606 | ||
607 | if (strcmp(Cmd, "clone")==0) { | |
608 | GraphTraceLen = 0; | |
609 | char *s; | |
610 | for(s = bits; *s; s++) { | |
611 | int j; | |
612 | for(j = 0; j < 16; j++) { | |
613 | GraphBuffer[GraphTraceLen++] = (*s == '1') ? 1 : 0; | |
614 | } | |
615 | } | |
616 | RepaintGraphWindow(); | |
617 | } | |
618 | return 0; | |
619 | } | |
620 | ||
d5a72d2f | 621 | //by marshmellow |
622 | int CmdLFfind(const char *Cmd) | |
623 | { | |
624 | int ans=0; | |
b915fda3 | 625 | char cmdp = param_getchar(Cmd, 0); |
626 | ||
627 | if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') { | |
628 | PrintAndLog("Usage: lf search <0|1>"); | |
629 | PrintAndLog(" <use data from Graphbuffer>, if not set, try reading data from tag."); | |
630 | PrintAndLog(""); | |
631 | PrintAndLog(" sample: lf search"); | |
632 | PrintAndLog(" : lf search 1"); | |
633 | return 0; | |
634 | } | |
635 | ||
84871873 | 636 | if (!offline && (cmdp != '1')){ |
d5a72d2f | 637 | ans=CmdLFRead(""); |
84871873 | 638 | ans=CmdSamples("20000"); |
b915fda3 | 639 | } else if (GraphTraceLen < 1000) { |
640 | PrintAndLog("Data in Graphbuffer was too small."); | |
641 | return 0; | |
d5a72d2f | 642 | } |
b915fda3 | 643 | |
84871873 | 644 | PrintAndLog("NOTE: some demods output possible binary\n if it finds something that looks like a tag"); |
d5a72d2f | 645 | PrintAndLog("Checking for known tags:"); |
d5a72d2f | 646 | ans=CmdFSKdemodIO(""); |
84871873 | 647 | if (ans>0) { |
648 | PrintAndLog("Valid IO Prox ID Found!"); | |
649 | return 1; | |
650 | } | |
651 | ans=CmdFSKdemodHID(""); | |
652 | if (ans>0) { | |
653 | PrintAndLog("Valid HID Prox ID Found!"); | |
654 | return 1; | |
655 | } | |
d5a72d2f | 656 | //add psk and indala |
84871873 | 657 | ans=CmdIndalaDecode("0"); |
658 | if (ans>0) { | |
659 | PrintAndLog("Valid Indala ID Found!"); | |
660 | return 1; | |
661 | } | |
662 | ans=Cmdaskmandemod(""); | |
663 | if (ans>0) { | |
664 | PrintAndLog("Valid EM410x ID Found!"); | |
665 | return 1; | |
666 | } | |
d5a72d2f | 667 | PrintAndLog("No Known Tags Found!\n"); |
668 | return 0; | |
669 | } | |
670 | ||
7fe9b0b7 | 671 | static command_t CommandTable[] = |
672 | { | |
673 | {"help", CmdHelp, 1, "This help"}, | |
674 | {"cmdread", CmdLFCommandRead, 0, "<off period> <'0' period> <'1' period> <command> ['h'] -- Modulate LF reader field to send command before read (all periods in microseconds) (option 'h' for 134)"}, | |
37239a7c | 675 | {"em4x", CmdLFEM4X, 1, "{ EM4X RFIDs... }"}, |
7fe9b0b7 | 676 | {"flexdemod", CmdFlexdemod, 1, "Demodulate samples for FlexPass"}, |
37239a7c | 677 | {"hid", CmdLFHID, 1, "{ HID RFIDs... }"}, |
083ca3de | 678 | {"io", CmdLFIO, 1, "{ ioProx tags... }"}, |
7fe9b0b7 | 679 | {"indalademod", CmdIndalaDemod, 1, "['224'] -- Demodulate samples for Indala 64 bit UID (option '224' for 224 bit)"}, |
083ca3de | 680 | {"indalaclone", CmdIndalaClone, 0, "<UID> ['l']-- Clone Indala to T55x7 (tag must be in antenna)(UID in HEX)(option 'l' for 224 UID"}, |
57c69556 | 681 | {"read", CmdLFRead, 0, "['h' or <divisor>] -- Read 125/134 kHz LF ID-only tag (option 'h' for 134, alternatively: f=12MHz/(divisor+1))"}, |
d5a72d2f | 682 | {"search", CmdLFfind, 1, "Read and Search for valid known tag (in offline mode it you can load first then search)"}, |
7fe9b0b7 | 683 | {"sim", CmdLFSim, 0, "[GAP] -- Simulate LF tag from buffer with optional GAP (in microseconds)"}, |
684 | {"simbidir", CmdLFSimBidir, 0, "Simulate LF tag (with bidirectional data transmission between reader and tag)"}, | |
685 | {"simman", CmdLFSimManchester, 0, "<Clock> <Bitstream> [GAP] Simulate arbitrary Manchester LF tag"}, | |
b014c96d | 686 | {"snoop", CmdLFSnoop, 0, "['l'|'h'|<divisor>] [trigger threshold]-- Snoop LF (l:125khz, h:134khz)"}, |
37239a7c | 687 | {"ti", CmdLFTI, 1, "{ TI RFIDs... }"}, |
db09cb3a | 688 | {"hitag", CmdLFHitag, 1, "{ Hitag tags and transponders... }"}, |
7fe9b0b7 | 689 | {"vchdemod", CmdVchDemod, 1, "['clone'] -- Demodulate samples for VeriChip"}, |
54a942b0 | 690 | {"t55xx", CmdLFT55XX, 1, "{ T55xx RFIDs... }"}, |
691 | {"pcf7931", CmdLFPCF7931, 1, "{PCF7931 RFIDs...}"}, | |
7fe9b0b7 | 692 | {NULL, NULL, 0, NULL} |
693 | }; | |
694 | ||
695 | int CmdLF(const char *Cmd) | |
696 | { | |
697 | CmdsParse(CommandTable, Cmd); | |
698 | return 0; | |
699 | } | |
700 | ||
701 | int CmdHelp(const char *Cmd) | |
702 | { | |
703 | CmdsHelp(CommandTable); | |
704 | return 0; | |
705 | } |