]> git.zerfleddert.de Git - proxmark3-svn/blame - client/util.c
ADD: new found cloner pwd.
[proxmark3-svn] / client / util.c
CommitLineData
20f9a2a1
M
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// utilities
9//-----------------------------------------------------------------------------
10
11#include "util.h"
bf32dd92 12#define MAX_BIN_BREAK_LENGTH (3072+384+1)
534983d7 13
cb64309e 14#ifndef _WIN32
3e134b4c 15int ukbhit(void) {
f397b5cc
M
16 int cnt = 0;
17 int error;
18 static struct termios Otty, Ntty;
19
d04b71c1 20 if ( tcgetattr( 0, &Otty) == -1) return -1;
f397b5cc
M
21 Ntty = Otty;
22
d04b71c1 23 Ntty.c_iflag = 0; /* input mode */
24 Ntty.c_oflag = 0; /* output mode */
25 Ntty.c_lflag &= ~ICANON; /* raw mode */
26 Ntty.c_cc[VMIN] = CMIN; /* minimum time to wait */
27 Ntty.c_cc[VTIME] = CTIME; /* minimum characters to wait for */
f397b5cc
M
28
29 if (0 == (error = tcsetattr(0, TCSANOW, &Ntty))) {
30 error += ioctl(0, FIONREAD, &cnt);
31 error += tcsetattr(0, TCSANOW, &Otty);
32 }
33
34 return ( error == 0 ? cnt : -1 );
35}
36
37#else
f397b5cc
M
38int ukbhit(void) {
39 return kbhit();
40}
41#endif
42
55acbb2a 43// log files functions
b915fda3 44void AddLogLine(char *file, char *extData, char *c) {
c805748f 45 FILE *f = NULL;
b915fda3 46 char filename[FILE_PATH_SIZE] = {0x00};
47 int len = 0;
48
49 len = strlen(file);
50 if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;
51 memcpy(filename, file, len);
52
c805748f 53 f = fopen(filename, "a");
54 if (!f) {
b915fda3 55 printf("Could not append log file %s", filename);
55acbb2a
M
56 return;
57 }
58
c805748f 59 fprintf(f, "%s", extData);
60 fprintf(f, "%s\n", c);
61 fflush(f);
2dcf60f3 62 if (f) {
63 fclose(f);
64 f = NULL;
65 }
55acbb2a
M
66}
67
68void AddLogHex(char *fileName, char *extData, const uint8_t * data, const size_t len){
69 AddLogLine(fileName, extData, sprint_hex(data, len));
70}
71
72void AddLogUint64(char *fileName, char *extData, const uint64_t data) {
c805748f 73 char buf[20] = {0};
74 memset(buf, 0x00, sizeof(buf));
75 //sprintf(buf, "%X%X", (unsigned int)((data & 0xFFFFFFFF00000000) >> 32), (unsigned int)(data & 0xFFFFFFFF));
76 sprintf(buf, "%012"llx"", data);
55acbb2a
M
77 AddLogLine(fileName, extData, buf);
78}
79
80void AddLogCurrentDT(char *fileName) {
c805748f 81 char buf[20];
82 memset(buf, 0x00, sizeof(buf));
55acbb2a 83 struct tm *curTime;
55acbb2a
M
84 time_t now = time(0);
85 curTime = gmtime(&now);
c805748f 86 strftime (buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", curTime);
87 AddLogLine(fileName, "\nanticollision: ", buf);
55acbb2a
M
88}
89
c805748f 90void FillFileNameByUID(char *fileName, uint8_t *uid, char *ext, int byteCount) {
91 if ( fileName == NULL || uid == NULL || ext == NULL ){
92 printf("error: parameter is NULL\n");
93 return;
94 }
55acbb2a 95 char * fnameptr = fileName;
c805748f 96 memset(fileName, 0x00, FILE_PATH_SIZE);
55acbb2a 97
e0c635d1 98 for (int j = 0; j < byteCount; j++, fnameptr += 2)
c805748f 99 sprintf(fnameptr, "%02X", uid[j]);
55acbb2a 100 sprintf(fnameptr, "%s", ext);
55acbb2a
M
101}
102
103// printing and converting functions
9827020a 104void print_hex(const uint8_t * data, const size_t len) {
534983d7 105 size_t i;
9827020a 106 for (i=0; i < len; ++i)
534983d7 107 printf("%02x ", data[i]);
9827020a 108 printf("\n");
109}
0d2c5909 110
9827020a 111void print_hex_break(const uint8_t *data, const size_t len, uint8_t breaks) {
a1689f41 112
113 int rownum = 0;
114 printf("[%02d] | ", rownum);
115 for (int i = 0; i < len; ++i) {
534983d7 116
9827020a 117 printf("%02X ", data[i]);
118
119 // check if a line break is needed
a1689f41 120 if ( breaks > 0 && !((i+1) % breaks) && (i+1 < len) ) {
121 ++rownum;
122 printf("\n[%02d] | ", rownum);
123 }
9827020a 124 }
534983d7 125 printf("\n");
126}
127
334cc089 128char *sprint_hex(const uint8_t *data, const size_t len) {
b915fda3 129
130 int maxLen = ( len > 1024/3) ? 1024/3 : len;
534983d7 131 static char buf[1024];
334cc089 132 memset(buf, 0x00, 1024);
534983d7 133 char * tmp = buf;
134 size_t i;
135
b915fda3 136 for (i=0; i < maxLen; ++i, tmp += 3)
334cc089 137 sprintf(tmp, "%02X ", data[i]);
534983d7 138 return buf;
139}
f89c7050 140
2767fc02 141char *sprint_bin_break(const uint8_t *data, const size_t len, const uint8_t breaks) {
581b31fb 142
bf32dd92 143 // make sure we don't go beyond our char array memory
581b31fb 144 size_t in_index = 0, out_index = 0;
145 int max_len;
0c97a456 146 if (breaks==0)
147 max_len = ( len > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len;
148 else
149 max_len = ( len+(len/breaks) > MAX_BIN_BREAK_LENGTH ) ? MAX_BIN_BREAK_LENGTH : len+(len/breaks);
150
bf32dd92 151 static char buf[MAX_BIN_BREAK_LENGTH]; // 3072 + end of line characters if broken at 8 bits
152 //clear memory
153 memset(buf, 0x00, sizeof(buf));
2767fc02 154 char *tmp = buf;
79544b28 155
bf32dd92 156 // loop through the out_index to make sure we don't go too far
581b31fb 157 for (out_index=0; out_index < max_len-2; out_index++) {
bf32dd92 158 // set character
05164399 159 sprintf(tmp++, "%u", (unsigned int) data[in_index]);
9332b857 160 // check if a line break is needed and we have room to print it in our array
bf32dd92 161 if ( (breaks > 0) && !((in_index+1) % breaks) && (out_index+1 != max_len) ) {
162 // increment and print line break
163 out_index++;
2767fc02 164 sprintf(tmp++, "%s","\n");
581b31fb 165 }
bf32dd92 166 in_index++;
167 }
581b31fb 168 // last char.
169 sprintf(tmp++, "%u", (unsigned int) data[in_index]);
79544b28 170 return buf;
171}
172
2767fc02 173char *sprint_bin(const uint8_t *data, const size_t len) {
174 return sprint_bin_break(data, len, 0);
175}
0c97a456 176
177char *sprint_hex_ascii(const uint8_t *data, const size_t len) {
178 static char buf[1024];
508b37ba 179 char *tmp = buf;
9827020a 180 memset(buf, 0x00, 1024);
181 size_t max_len = (len > 1010) ? 1010 : len;
182 sprintf(tmp, "%s| %s", sprint_hex(data, max_len) , data);
0c97a456 183 return buf;
184}
0d2c5909 185
1f1d974f 186void num_to_bytes(uint64_t n, size_t len, uint8_t* dest) {
f89c7050 187 while (len--) {
7d159efe 188 dest[len] = n & 0xFF;
f89c7050
M
189 n >>= 8;
190 }
191}
192
1f1d974f 193uint64_t bytes_to_num(uint8_t* src, size_t len) {
f89c7050 194 uint64_t num = 0;
1f1d974f 195 while (len--) {
f89c7050
M
196 num = (num << 8) | (*src);
197 src++;
198 }
199 return num;
200}
f397b5cc 201
0d2c5909 202// takes a number (uint64_t) and creates a binarray in dest.
203void num_to_bytebits(uint64_t n, size_t len, uint8_t *dest) {
a126332a 204 while (len--) {
205 dest[len] = n & 1;
206 n >>= 1;
207 }
208}
1f1d974f 209
0d2c5909 210//least significant bit first
c805748f 211void num_to_bytebitsLSBF(uint64_t n, size_t len, uint8_t *dest) {
0d2c5909 212 for(int i = 0 ; i < len ; ++i) {
213 dest[i] = n & 1;
214 n >>= 1;
215 }
216}
217
e1c88b09 218// aa,bb,cc,dd,ee,ff,gg,hh, ii,jj,kk,ll,mm,nn,oo,pp
219// to
220// hh,gg,ff,ee,dd,cc,bb,aa, pp,oo,nn,mm,ll,kk,jj,ii
221// up to 64 bytes or 512 bits
224e8c1a 222uint8_t *SwapEndian64(const uint8_t *src, const size_t len, const uint8_t blockSize){
3f5bcc3b 223 static uint8_t buf[64];
224e8c1a 224 memset(buf, 0x00, 64);
225 uint8_t *tmp = buf;
226 for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
227 for (size_t i = 0; i < blockSize; i++){
228 tmp[i+(blockSize*block)] = src[(blockSize-1-i)+(blockSize*block)];
e1c88b09 229 }
230 }
3f5bcc3b 231 return buf;
e1c88b09 232}
233
0d2c5909 234// takes a uint8_t src array, for len items and reverses the byte order in blocksizes (8,16,32,64),
235// returns: the dest array contains the reordered src array.
f4d0ffd1 236void SwapEndian64ex(const uint8_t *src, const size_t len, const uint8_t blockSize, uint8_t *dest){
237 for (uint8_t block=0; block < (uint8_t)(len/blockSize); block++){
238 for (size_t i = 0; i < blockSize; i++){
239 dest[i+(blockSize*block)] = src[(blockSize-1-i)+(blockSize*block)];
240 }
241 }
242}
243
9ca155ba
M
244// -------------------------------------------------------------------------
245// string parameters lib
246// -------------------------------------------------------------------------
247
f397b5cc
M
248// -------------------------------------------------------------------------
249// line - param line
250// bg, en - symbol numbers in param line of beginning an ending parameter
251// paramnum - param number (from 0)
252// -------------------------------------------------------------------------
253int param_getptr(const char *line, int *bg, int *en, int paramnum)
254{
255 int i;
256 int len = strlen(line);
257
258 *bg = 0;
259 *en = 0;
260
261 // skip spaces
262 while (line[*bg] ==' ' || line[*bg]=='\t') (*bg)++;
263 if (*bg >= len) {
264 return 1;
265 }
266
267 for (i = 0; i < paramnum; i++) {
268 while (line[*bg]!=' ' && line[*bg]!='\t' && line[*bg] != '\0') (*bg)++;
269 while (line[*bg]==' ' || line[*bg]=='\t') (*bg)++;
270
271 if (line[*bg] == '\0') return 1;
272 }
273
274 *en = *bg;
275 while (line[*en] != ' ' && line[*en] != '\t' && line[*en] != '\0') (*en)++;
276
277 (*en)--;
278
279 return 0;
280}
281
282char param_getchar(const char *line, int paramnum)
283{
284 int bg, en;
285
286 if (param_getptr(line, &bg, &en, paramnum)) return 0x00;
287
288 return line[bg];
289}
290
291uint8_t param_get8(const char *line, int paramnum)
292{
60e86577 293 return param_get8ex(line, paramnum, 0, 10);
f397b5cc
M
294}
295
f6d9fb17 296/**
31abe49f 297 * @brief Reads a decimal integer (actually, 0-254, not 255)
f6d9fb17
MHS
298 * @param line
299 * @param paramnum
31abe49f 300 * @return -1 if error
f6d9fb17
MHS
301 */
302uint8_t param_getdec(const char *line, int paramnum, uint8_t *destination)
303{
31abe49f 304 uint8_t val = param_get8ex(line, paramnum, 255, 10);
31abe49f 305 if( (int8_t) val == -1) return 1;
f6d9fb17
MHS
306 (*destination) = val;
307 return 0;
308}
309/**
310 * @brief Checks if param is decimal
311 * @param line
312 * @param paramnum
313 * @return
314 */
315uint8_t param_isdec(const char *line, int paramnum)
316{
317 int bg, en;
318 //TODO, check more thorougly
319 if (!param_getptr(line, &bg, &en, paramnum)) return 1;
320 // return strtoul(&line[bg], NULL, 10) & 0xff;
321
322 return 0;
323}
324
f397b5cc
M
325uint8_t param_get8ex(const char *line, int paramnum, int deflt, int base)
326{
327 int bg, en;
328
329 if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1 330 return strtoul(&line[bg], NULL, base) & 0xff;
f397b5cc
M
331 else
332 return deflt;
333}
334
335uint32_t param_get32ex(const char *line, int paramnum, int deflt, int base)
336{
337 int bg, en;
338
339 if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1 340 return strtoul(&line[bg], NULL, base);
f397b5cc
M
341 else
342 return deflt;
343}
344
345uint64_t param_get64ex(const char *line, int paramnum, int deflt, int base)
346{
347 int bg, en;
348
349 if (!param_getptr(line, &bg, &en, paramnum))
6c6d1ac1 350 return strtoull(&line[bg], NULL, base);
f397b5cc
M
351 else
352 return deflt;
f397b5cc
M
353}
354
355int param_gethex(const char *line, int paramnum, uint8_t * data, int hexcnt)
356{
357 int bg, en, temp, i;
358
508b37ba 359 if (hexcnt & 1) return 1;
f397b5cc
M
360
361 if (param_getptr(line, &bg, &en, paramnum)) return 1;
362
508b37ba 363 if (en - bg + 1 != hexcnt) return 1;
f397b5cc
M
364
365 for(i = 0; i < hexcnt; i += 2) {
366 if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
367
368 sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
369 data[i / 2] = temp & 0xff;
370 }
371
372 return 0;
373}
e98572a1 374int param_gethex_ex(const char *line, int paramnum, uint8_t * data, int *hexcnt)
375{
376 int bg, en, temp, i;
377
378 //if (hexcnt % 2)
379 // return 1;
380
381 if (param_getptr(line, &bg, &en, paramnum)) return 1;
382
383 *hexcnt = en - bg + 1;
384 if (*hexcnt % 2) //error if not complete hex bytes
385 return 1;
aea4d766 386
e98572a1 387 for(i = 0; i < *hexcnt; i += 2) {
3bc7b13d 388 if (!(isxdigit(line[bg + i]) && isxdigit(line[bg + i + 1])) ) return 1;
e98572a1 389
390 sscanf((char[]){line[bg + i], line[bg + i + 1], 0}, "%X", &temp);
391 data[i / 2] = temp & 0xff;
392 }
393
394 return 0;
395}
aea4d766 396int param_getstr(const char *line, int paramnum, char * str)
397{
398 int bg, en;
399
400 if (param_getptr(line, &bg, &en, paramnum)) return 0;
401
402 memcpy(str, line + bg, en - bg + 1);
403 str[en - bg + 1] = 0;
404
405 return en - bg + 1;
406}
79544b28 407
408/*
409The following methods comes from Rfidler sourcecode.
410https://github.com/ApertureLabsLtd/RFIDler/blob/master/firmware/Pic32/RFIDler.X/src/
411*/
412
413// convert hex to sequence of 0/1 bit values
414// returns number of bits converted
415int hextobinarray(char *target, char *source)
416{
417 int length, i, count= 0;
418 char x;
419
420 length = strlen(source);
421 // process 4 bits (1 hex digit) at a time
422 while(length--)
423 {
424 x= *(source++);
425 // capitalize
426 if (x >= 'a' && x <= 'f')
427 x -= 32;
428 // convert to numeric value
429 if (x >= '0' && x <= '9')
430 x -= '0';
431 else if (x >= 'A' && x <= 'F')
432 x -= 'A' - 10;
433 else
434 return 0;
435 // output
436 for(i= 0 ; i < 4 ; ++i, ++count)
437 *(target++)= (x >> (3 - i)) & 1;
438 }
439
440 return count;
441}
442
443// convert hex to human readable binary string
444int hextobinstring(char *target, char *source)
445{
446 int length;
447
448 if(!(length= hextobinarray(target, source)))
449 return 0;
450 binarraytobinstring(target, target, length);
451 return length;
452}
453
454// convert binary array of 0x00/0x01 values to hex (safe to do in place as target will always be shorter than source)
455// return number of bits converted
456int binarraytohex(char *target, char *source, int length)
457{
458 unsigned char i, x;
459 int j = length;
460
461 if(j % 4)
462 return 0;
463
464 while(j)
465 {
466 for(i= x= 0 ; i < 4 ; ++i)
467 x += ( source[i] << (3 - i));
468 sprintf(target,"%X", x);
469 ++target;
470 source += 4;
471 j -= 4;
472 }
473 return length;
474}
475
476// convert binary array to human readable binary
477void binarraytobinstring(char *target, char *source, int length)
478{
479 int i;
480
481 for(i= 0 ; i < length ; ++i)
482 *(target++)= *(source++) + '0';
483 *target= '\0';
484}
485
486// return parity bit required to match type
a126332a 487uint8_t GetParity( uint8_t *bits, uint8_t type, int length)
79544b28 488{
489 int x;
ab7bb494 490 for( x = 0 ; length > 0 ; --length)
79544b28 491 x += bits[length - 1];
492 x %= 2;
79544b28 493 return x ^ type;
494}
495
496// add HID parity to binary array: EVEN prefix for 1st half of ID, ODD suffix for 2nd half
a126332a 497void wiegand_add_parity(uint8_t *target, uint8_t *source, uint8_t length)
79544b28 498{
499 *(target++)= GetParity(source, EVEN, length / 2);
500 memcpy(target, source, length);
501 target += length;
502 *(target)= GetParity(source + length / 2, ODD, length / 2);
503}
c3c241f3 504
0d2c5909 505// xor two arrays together for len items. The dst array contains the new xored values.
c3c241f3 506void xor(unsigned char * dst, unsigned char * src, size_t len) {
507 for( ; len > 0; len--,dst++,src++)
508 *dst ^= *src;
509}
510
511int32_t le24toh (uint8_t data[3]) {
512 return (data[2] << 16) | (data[1] << 8) | data[0];
513}
c805748f 514uint32_t le32toh (uint8_t *data) {
515 return (uint32_t)( (data[3]<<24) | (data[2]<<16) | (data[1]<<8) | data[0]);
516}
0d2c5909 517// Pack a bitarray into a uint32_t.
ad6219fc 518uint32_t PackBits(uint8_t start, uint8_t len, uint8_t* bits) {
9984b173 519
520 if (len > 32) return 0;
ad6219fc 521
522 int i = start;
523 int j = len-1;
ad6219fc 524 uint32_t tmp = 0;
9984b173 525
ad6219fc 526 for (; j >= 0; --j, ++i)
527 tmp |= bits[i] << j;
528
529 return tmp;
530}
9984b173 531
ab7bb494 532// RotateLeft - Ultralight, Desfire, works on byte level
533// 00-01-02 >> 01-02-00
6bb7609c 534void rol(uint8_t *data, const size_t len){
9984b173 535 uint8_t first = data[0];
536 for (size_t i = 0; i < len-1; i++) {
537 data[i] = data[i+1];
538 }
539 data[len-1] = first;
6bb7609c 540}
541
0d2c5909 542// Swap bit order on a uint32_t value. Can be limited by nrbits just use say 8bits reversal
1f1d974f 543// And clears the rest of the bits.
6bb7609c 544uint32_t SwapBits(uint32_t value, int nrbits) {
545 uint32_t newvalue = 0;
546 for(int i = 0; i < nrbits; i++) {
547 newvalue ^= ((value >> i) & 1) << (nrbits - 1 - i);
548 }
549 return newvalue;
3e134b4c 550}
551/*
552 ref http://www.csm.ornl.gov/~dunigan/crc.html
553 Returns the value v with the bottom b [0,32] bits reflected.
554 Example: reflect(0x3e23L,3) == 0x3e26
555*/
556uint32_t reflect(uint32_t v, int b) {
557 uint32_t t = v;
558 for ( int i = 0; i < b; ++i) {
559 if (t & 1)
560 v |= BITMASK((b-1)-i);
561 else
562 v &= ~BITMASK((b-1)-i);
563 t>>=1;
564 }
565 return v;
566}
dae31af2 567
568uint64_t HornerScheme(uint64_t num, uint64_t divider, uint64_t factor) {
569 uint64_t remainder=0, quotient=0, result=0;
570 remainder = num % divider;
571 quotient = num / divider;
572 if(!(quotient == 0 && remainder == 0))
573 result += HornerScheme(quotient, divider, factor) * factor + remainder;
574 return result;
575}
Impressum, Datenschutz