]> git.zerfleddert.de Git - proxmark3-svn/blob - client/ui.c
FIX: I think the dumping of data is correct now in tnp3.lua. MD5 string vs bytearra...
[proxmark3-svn] / client / ui.c
1 //-----------------------------------------------------------------------------
2 // Copyright (C) 2009 Michael Gernoth <michael at gernoth.net>
3 // Copyright (C) 2010 iZsh <izsh at fail0verflow.com>
4 //
5 // This code is licensed to you under the terms of the GNU GPL, version 2 or,
6 // at your option, any later version. See the LICENSE.txt file for the text of
7 // the license.
8 //-----------------------------------------------------------------------------
9 // UI utilities
10 //-----------------------------------------------------------------------------
11
12 #include <stdarg.h>
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <stdbool.h>
16 #include <time.h>
17 #include <readline/readline.h>
18 #include <pthread.h>
19 #include "loclass/cipherutils.h"
20 #include "ui.h"
21 #include "cmdmain.h"
22 #include "cmddata.h"
23 //#include <liquid/liquid.h>
24 #define M_PI 3.14159265358979323846264338327
25
26 double CursorScaleFactor;
27 int PlotGridX, PlotGridY, PlotGridXdefault= 64, PlotGridYdefault= 64;
28 int offline;
29 int flushAfterWrite = 0; //buzzy
30 extern pthread_mutex_t print_lock;
31
32 static char *logfilename = "proxmark3.log";
33
34 void PrintAndLog(char *fmt, ...)
35 {
36 char *saved_line;
37 int saved_point;
38 va_list argptr, argptr2;
39 static FILE *logfile = NULL;
40 static int logging=1;
41
42 // lock this section to avoid interlacing prints from different threats
43 pthread_mutex_lock(&print_lock);
44
45 if (logging && !logfile) {
46 logfile=fopen(logfilename, "a");
47 if (!logfile) {
48 fprintf(stderr, "Can't open logfile, logging disabled!\n");
49 logging=0;
50 }
51 }
52
53 int need_hack = (rl_readline_state & RL_STATE_READCMD) > 0;
54
55 if (need_hack) {
56 saved_point = rl_point;
57 saved_line = rl_copy_text(0, rl_end);
58 rl_save_prompt();
59 rl_replace_line("", 0);
60 rl_redisplay();
61 }
62
63 va_start(argptr, fmt);
64 va_copy(argptr2, argptr);
65 vprintf(fmt, argptr);
66 printf(" "); // cleaning prompt
67 va_end(argptr);
68 printf("\n");
69
70 if (need_hack) {
71 rl_restore_prompt();
72 rl_replace_line(saved_line, 0);
73 rl_point = saved_point;
74 rl_redisplay();
75 free(saved_line);
76 }
77
78 if (logging && logfile) {
79 vfprintf(logfile, fmt, argptr2);
80 fprintf(logfile,"\n");
81 fflush(logfile);
82 }
83 va_end(argptr2);
84
85 if (flushAfterWrite == 1) //buzzy
86 {
87 fflush(NULL);
88 }
89 //release lock
90 pthread_mutex_unlock(&print_lock);
91 }
92
93 void SetLogFilename(char *fn)
94 {
95 logfilename = fn;
96 }
97
98 int manchester_decode( int * data, const size_t len, uint8_t * dataout, size_t dataoutlen){
99
100 int bitlength = 0;
101 int i, clock, high, low, startindex;
102 low = startindex = 0;
103 high = 1;
104 uint8_t * bitStream = (uint8_t* ) malloc(sizeof(uint8_t) * dataoutlen);
105 memset(bitStream, 0x00, dataoutlen);
106
107 /* Detect high and lows */
108 for (i = 0; i < len; i++) {
109 if (data[i] > high)
110 high = data[i];
111 else if (data[i] < low)
112 low = data[i];
113 }
114
115 /* get clock */
116 clock = GetT55x7Clock( data, len, high );
117 startindex = DetectFirstTransition(data, len, high);
118
119 //PrintAndLog(" Clock : %d", clock);
120
121 if (high != 1)
122 bitlength = ManchesterConvertFrom255(data, len, bitStream, dataoutlen, high, low, clock, startindex);
123 else
124 bitlength= ManchesterConvertFrom1(data, len, bitStream, dataoutlen, clock, startindex);
125
126 memcpy(dataout, bitStream, bitlength);
127 free(bitStream);
128 return bitlength;
129 }
130
131 int GetT55x7Clock( const int * data, const size_t len, int peak ){
132
133 int i,lastpeak,clock;
134 clock = 0xFFFF;
135 lastpeak = 0;
136
137 /* Detect peak if we don't have one */
138 if (!peak) {
139 for (i = 0; i < len; ++i) {
140 if (data[i] > peak) {
141 peak = data[i];
142 }
143 }
144 }
145
146 for (i = 1; i < len; ++i) {
147 /* if this is the beginning of a peak */
148 if ( data[i-1] != data[i] && data[i] == peak) {
149 /* find lowest difference between peaks */
150 if (lastpeak && i - lastpeak < clock)
151 clock = i - lastpeak;
152 lastpeak = i;
153 }
154 }
155
156 // When detected clock is 31 or 33 then then return
157 int clockmod = clock%8;
158 if ( clockmod == 0) return clock;
159
160 if ( clockmod == 7 ) clock += 1;
161 else if ( clockmod == 1 ) clock -= 1;
162
163 return clock;
164 }
165
166 int DetectFirstTransition(const int * data, const size_t len, int threshold){
167
168 int i =0;
169 /* now look for the first threshold */
170 for (; i < len; ++i) {
171 if (data[i] == threshold) {
172 break;
173 }
174 }
175 return i;
176 }
177
178 int ManchesterConvertFrom255(const int * data, const size_t len, uint8_t * dataout, int dataoutlen, int high, int low, int clock, int startIndex){
179
180 int i, j, z, hithigh, hitlow, bitIndex, startType;
181 i = 0;
182 bitIndex = 0;
183
184 int isDamp = 0;
185 int damplimit = (int)((high / 2) * 0.3);
186 int dampHi = (high/2)+damplimit;
187 int dampLow = (high/2)-damplimit;
188 int firstST = 0;
189
190 // i = clock frame of data
191 for (; i < (int)(len/clock); i++)
192 {
193 hithigh = 0;
194 hitlow = 0;
195 startType = -1;
196 z = startIndex + (i*clock);
197 isDamp = 0;
198
199 /* Find out if we hit both high and low peaks */
200 for (j = 0; j < clock; j++)
201 {
202 if (data[z+j] == high){
203 hithigh = 1;
204 if ( startType == -1)
205 startType = 1;
206 }
207
208 if (data[z+j] == low ){
209 hitlow = 1;
210 if ( startType == -1)
211 startType = 0;
212 }
213
214 if (hithigh && hitlow)
215 break;
216 }
217
218 // No high value found, are we in a dampening field?
219 if ( !hithigh ) {
220 //PrintAndLog(" # Entering damp test at index : %d (%d)", z+j, j);
221 for (j = 0; j < clock; j++) {
222 if (
223 (data[z+j] <= dampHi && data[z+j] >= dampLow)
224 ){
225 isDamp++;
226 }
227 }
228 }
229
230 /* Manchester Switching..
231 0: High -> Low
232 1: Low -> High
233 */
234 if (startType == 0)
235 dataout[bitIndex++] = 1;
236 else if (startType == 1)
237 dataout[bitIndex++] = 0;
238 else
239 dataout[bitIndex++] = 2;
240
241 if ( isDamp > clock/2 ) {
242 firstST++;
243 }
244
245 if ( firstST == 4)
246 break;
247 if ( bitIndex >= dataoutlen-1 )
248 break;
249 }
250 return bitIndex;
251 }
252
253 int ManchesterConvertFrom1(const int * data, const size_t len, uint8_t * dataout,int dataoutlen, int clock, int startIndex){
254
255 PrintAndLog(" Path B");
256
257 int i,j, bitindex, lc, tolerance, warnings;
258 warnings = 0;
259 int upperlimit = len*2/clock+8;
260 i = startIndex;
261 j = 0;
262 tolerance = clock/4;
263 uint8_t decodedArr[len];
264
265 /* Detect duration between 2 successive transitions */
266 for (bitindex = 1; i < len; i++) {
267
268 if (data[i-1] != data[i]) {
269 lc = i - startIndex;
270 startIndex = i;
271
272 // Error check: if bitindex becomes too large, we do not
273 // have a Manchester encoded bitstream or the clock is really wrong!
274 if (bitindex > upperlimit ) {
275 PrintAndLog("Error: the clock you gave is probably wrong, aborting.");
276 return 0;
277 }
278 // Then switch depending on lc length:
279 // Tolerance is 1/4 of clock rate (arbitrary)
280 if (abs((lc-clock)/2) < tolerance) {
281 // Short pulse : either "1" or "0"
282 decodedArr[bitindex++] = data[i-1];
283 } else if (abs(lc-clock) < tolerance) {
284 // Long pulse: either "11" or "00"
285 decodedArr[bitindex++] = data[i-1];
286 decodedArr[bitindex++] = data[i-1];
287 } else {
288 ++warnings;
289 PrintAndLog("Warning: Manchester decode error for pulse width detection.");
290 if (warnings > 10) {
291 PrintAndLog("Error: too many detection errors, aborting.");
292 return 0;
293 }
294 }
295 }
296 }
297
298 /*
299 * We have a decodedArr of "01" ("1") or "10" ("0")
300 * parse it into final decoded dataout
301 */
302 for (i = 0; i < bitindex; i += 2) {
303
304 if ((decodedArr[i] == 0) && (decodedArr[i+1] == 1)) {
305 dataout[j++] = 1;
306 } else if ((decodedArr[i] == 1) && (decodedArr[i+1] == 0)) {
307 dataout[j++] = 0;
308 } else {
309 i++;
310 warnings++;
311 PrintAndLog("Unsynchronized, resync...");
312 PrintAndLog("(too many of those messages mean the stream is not Manchester encoded)");
313
314 if (warnings > 10) {
315 PrintAndLog("Error: too many decode errors, aborting.");
316 return 0;
317 }
318 }
319 }
320
321 PrintAndLog("%s", sprint_hex(dataout, j));
322 return j;
323 }
324
325 void ManchesterDiffDecodedString(const uint8_t* bitstream, size_t len, uint8_t invert){
326 /*
327 * We have a bitstream of "01" ("1") or "10" ("0")
328 * parse it into final decoded bitstream
329 */
330 int i, j, warnings;
331 uint8_t decodedArr[(len/2)+1];
332
333 j = warnings = 0;
334
335 uint8_t lastbit = 0;
336
337 for (i = 0; i < len; i += 2) {
338
339 uint8_t first = bitstream[i];
340 uint8_t second = bitstream[i+1];
341
342 if ( first == second ) {
343 ++i;
344 ++warnings;
345 if (warnings > 10) {
346 PrintAndLog("Error: too many decode errors, aborting.");
347 return;
348 }
349 }
350 else if ( lastbit != first ) {
351 decodedArr[j++] = 0 ^ invert;
352 }
353 else {
354 decodedArr[j++] = 1 ^ invert;
355 }
356 lastbit = second;
357 }
358
359 PrintAndLog("%s", sprint_hex(decodedArr, j));
360 }
361
362 void PrintPaddedManchester( uint8_t* bitStream, size_t len, size_t blocksize){
363
364 PrintAndLog(" Manchester decoded : %d bits", len);
365
366 uint8_t mod = len % blocksize;
367 uint8_t div = len / blocksize;
368 int i;
369
370 // Now output the bitstream to the scrollback by line of 16 bits
371 for (i = 0; i < div*blocksize; i+=blocksize) {
372 PrintAndLog(" %s", sprint_bin(bitStream+i,blocksize) );
373 }
374
375 if ( mod > 0 )
376 PrintAndLog(" %s", sprint_bin(bitStream+i, mod) );
377 }
378
379 /* Sliding DFT
380 Smooths out
381 */
382 void iceFsk2(int * data, const size_t len){
383
384 int i, j;
385 int * output = (int* ) malloc(sizeof(int) * len);
386 memset(output, 0x00, len);
387
388 // for (i=0; i<len-5; ++i){
389 // for ( j=1; j <=5; ++j) {
390 // output[i] += data[i*j];
391 // }
392 // output[i] /= 5;
393 // }
394 int rest = 127;
395 int tmp =0;
396 for (i=0; i<len; ++i){
397 if ( data[i] < 127)
398 output[i] = 0;
399 else {
400 tmp = (100 * (data[i]-rest)) / rest;
401 output[i] = (tmp > 60)? 100:0;
402 }
403 }
404
405 for (j=0; j<len; ++j)
406 data[j] = output[j];
407
408 free(output);
409 }
410
411 void iceFsk3(int * data, const size_t len){
412
413 int i,j;
414
415 int * output = (int* ) malloc(sizeof(int) * len);
416 memset(output, 0x00, len);
417 float fc = 0.1125f; // center frequency
418 size_t adjustedLen = len;
419
420 // create very simple low-pass filter to remove images (2nd-order Butterworth)
421 float complex iir_buf[3] = {0,0,0};
422 float b[3] = {0.003621681514929, 0.007243363029857, 0.003621681514929};
423 float a[3] = {1.000000000000000, -1.822694925196308, 0.837181651256023};
424
425 float sample = 0; // input sample read from file
426 float complex x_prime = 1.0f; // save sample for estimating frequency
427 float complex x;
428
429 for (i=0; i<adjustedLen; ++i) {
430
431 sample = data[i]+128;
432
433 // remove DC offset and mix to complex baseband
434 x = (sample - 127.5f) * cexpf( _Complex_I * 2 * M_PI * fc * i );
435
436 // apply low-pass filter, removing spectral image (IIR using direct-form II)
437 iir_buf[2] = iir_buf[1];
438 iir_buf[1] = iir_buf[0];
439 iir_buf[0] = x - a[1]*iir_buf[1] - a[2]*iir_buf[2];
440 x = b[0]*iir_buf[0] +
441 b[1]*iir_buf[1] +
442 b[2]*iir_buf[2];
443
444 // compute instantaneous frequency by looking at phase difference
445 // between adjacent samples
446 float freq = cargf(x*conjf(x_prime));
447 x_prime = x; // retain this sample for next iteration
448
449 output[i] =(freq > 0)? 10 : -10;
450 }
451
452 // show data
453 for (j=0; j<adjustedLen; ++j)
454 data[j] = output[j];
455
456 CmdLtrim("30");
457 adjustedLen -= 30;
458
459 // zero crossings.
460 for (j=0; j<adjustedLen; ++j){
461 if ( data[j] == 10) break;
462 }
463 int startOne =j;
464
465 for (;j<adjustedLen; ++j){
466 if ( data[j] == -10 ) break;
467 }
468 int stopOne = j-1;
469
470 int fieldlen = stopOne-startOne;
471
472 fieldlen = (fieldlen == 39 || fieldlen == 41)? 40 : fieldlen;
473 fieldlen = (fieldlen == 59 || fieldlen == 51)? 50 : fieldlen;
474 if ( fieldlen != 40 && fieldlen != 50){
475 printf("Detected field Length: %d \n", fieldlen);
476 printf("Can only handle 40 or 50. Aborting...\n");
477 return;
478 }
479
480 // FSK sequence start == 000111
481 int startPos = 0;
482 for (i =0; i<adjustedLen; ++i){
483 int dec = 0;
484 for ( j = 0; j < 6*fieldlen; ++j){
485 dec += data[i + j];
486 }
487 if (dec == 0) {
488 startPos = i;
489 break;
490 }
491 }
492
493 printf("000111 position: %d \n", startPos);
494
495 startPos += 6*fieldlen+5;
496
497 int bit =0;
498 printf("BINARY\n");
499 printf("R/40 : ");
500 for (i =startPos ; i < adjustedLen; i += 40){
501 bit = data[i]>0 ? 1:0;
502 printf("%d", bit );
503 }
504 printf("\n");
505
506 printf("R/50 : ");
507 for (i =startPos ; i < adjustedLen; i += 50){
508 bit = data[i]>0 ? 1:0;
509 printf("%d", bit ); }
510 printf("\n");
511
512 free(output);
513 }
514
515 float complex cexpf (float complex Z)
516 {
517 float complex Res;
518 double rho = exp (__real__ Z);
519 __real__ Res = rho * cosf(__imag__ Z);
520 __imag__ Res = rho * sinf(__imag__ Z);
521 return Res;
522 }
Impressum, Datenschutz