Fix typos in usage examples

Fix configure warnings about missing stuff
Removed xor swaps to fix GCC warnings
2026-02-27 20:26:38 +00:00 · 2018-07-14 12:31:54 +02:00 · 2018-05-09 16:11:51 +02:00 · 2018-05-09 16:11:51 +02:00 · 2018-05-09 16:11:51 +02:00 · 2018-05-09 16:11:51 +02:00
22 changed files with 3269 additions and 4117 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -0,0 +1,20 @@
 .svn
 *.o
 *~
 aclocal.m4
 autom4te.cache/*
 compile
 config.h
 config.h.in
 config.log
 config.status
 configure
 depcomp
 install-sh
 Makefile
 Makefile.in
 missing
 src/.deps/
 src/mfcuk.exe
 src/mfcuk
 stamp-h1
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,4 +1,10 @@
 SUBDIRS = src
-#pkgconfigdir = $(libdir)/pkgconfig
+style:
-#pkgconfig_DATA = libnfc.pc
+	find . -name "*.[ch]" -exec perl -pi -e 's/[ \t]+$$//' {} \;
 	find . -name "*.[ch]" -exec astyle --formatted --mode=c --suffix=none \
 		--indent=spaces=2 --indent-switches --indent-preprocessor \
 		--keep-one-line-blocks --max-instatement-indent=60 \
 		--brackets=linux --pad-oper --unpad-paren --pad-header \
 		--align-pointer=name {} \;
--- a/5
+++ b/5
@@ -2,8 +2,7 @@ README
 ======
 Compiling:
-    automake
+    autoreconf -is
    autoconf
    ./configure
    make
@@ -24,7 +23,7 @@ LICENSE
 GPL. See MFCUK_LICENSE for more information.
-BIBLIOGRPAHY (no specific order)
+BIBLIOGRAPHY (no specific order)
 ---------------------------------
 1. [WPMCC09] - "Wirelessly Pickpocketing a Mifare Classic Card"
 2. [ESO08] - "2008-esorics.pdf"
--- a/configure.ac
+++ b/configure.ac
@@ -1,25 +1,22 @@
-AC_INIT([mfcuk], [0.3.3], [zveriu@gmail.com])
+AC_INIT([mfcuk], [0.3.8], [zveriu@gmail.com])
-AC_CONFIG_MACRO_DIR([m4])
+AM_INIT_AUTOMAKE
 AC_PROG_CC
 AC_CONFIG_HEADERS([config.h])
 AC_CONFIG_SRCDIR([src/mfcuk.c])
 AM_INIT_AUTOMAKE
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 # Checks for pkg-config modules.
-LIBNFC_REQUIRED_VERSION=1.5.1
+LIBNFC_REQUIRED_VERSION=1.7.0
-PKG_CHECK_MODULES([LIBNFC], [libnfc >= $LIBNFC_REQUIRED_VERSION], [], [AC_MSG_ERROR([libnfc >= $LIBNFC_REQUIRED_VERSION is mandatory.])])
+PKG_CHECK_MODULES([libnfc], [libnfc >= $LIBNFC_REQUIRED_VERSION], [], [AC_MSG_ERROR([libnfc >= $LIBNFC_REQUIRED_VERSION is mandatory.])])
 PKG_CONFIG_REQUIRES="libnfc"
 AC_SUBST([PKG_CONFIG_REQUIRES])
 # Checks for typedefs, structures, and compiler characteristics.
 AC_C_INLINE
 AC_HEADER_STDBOOL
 AC_TYPE_SIZE_T
 AC_TYPE_UINT16_T
@@ -30,12 +27,20 @@ AC_TYPE_UINT8_T
 # Checks for library functions.
 AC_FUNC_MALLOC
 AC_FUNC_REALLOC
-AC_CHECK_FUNCS([memset strchr])
+
 AC_CHECK_FUNCS([memset strchr strtoul])
 # Checks for endianness convertion
 AC_CHECK_HEADERS([endian.h sys/endian.h CoreFoundation/CoreFoundation.h])
 if test $ac_cv_header_endian_h = "no" -a $ac_cv_header_sys_endian_h = "no" -a $ac_cv_header_CoreFoundation_CoreFoundation_h = "no"; then
  AC_MSG_ERROR(["Can't locate usable header file for endianness convertions."]);
 fi
 AC_CHECK_HEADERS([byteswap.h])
 AC_CHECK_HEADERS([unistd.h])
 AM_CONDITIONAL([HAVE_UNISTD], [test $ac_cv_header_unistd_h = "yes"])
 AC_DEFINE([_XOPEN_SOURCE], [600], [Define to 500 if Single Unix conformance is wanted, 600 for sixth revision.])
 # Help us to write great code ;-)
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -1,9 +1,15 @@
-AM_CFLAGS  = @LIBNFC_CFLAGS@
+AM_CFLAGS  = @libnfc_CFLAGS@
 AM_LDFLAGS = @LIBNFC_LIBS@
 bin_PROGRAMS = mfcuk
-noinst_HEADERS = crapto1.h mifare.h nfc-utils.h mfcuk_mifare.h mfcuk_finger.h mfcuk_utils.h xgetopt.h mfcuk.h
+noinst_HEADERS = crapto1.h mifare.h nfc-utils.h mfcuk_mifare.h mfcuk_finger.h mfcuk_utils.h mfcuk.h xgetopt.h
-mfcuk_SOURCES = crapto1.c crypto1.c mifare.c nfc-utils.c mfcuk_mifare.c mfcuk_finger.c mfcuk_utils.c xgetopt.c mfcuk.c 
+
 mfcuk_SOURCES = crapto1.c crypto1.c mifare.c nfc-utils.c mfcuk_mifare.c mfcuk_finger.c mfcuk_utils.c mfcuk.c
 mfcuk_LDADD = @libnfc_LIBS@
 # If system does not have unistd.h, use our own getopt function from xgetopt.c
 if ! HAVE_UNISTD
 mfcuk_SOURCES += xgetopt.c
 endif
 # dist_man_MANS = mfcuk.1
--- a/src/crapto1.c
+++ b/src/crapto1.c
@@ -22,52 +22,58 @@
 #if !defined LOWMEM && defined __GNUC__
 static uint8_t filterlut[1 << 20];
-static void __attribute__((constructor)) fill_lut()
+static void __attribute__((constructor)) fill_lut(void)
 {
-        uint32_t i;
+  uint32_t i;
-        for(i = 0; i < 1 << 20; ++i)
+  for (i = 0; i < 1 << 20; ++i)
-                filterlut[i] = filter(i);
+    filterlut[i] = filter(i);
 }
 #define filter(x) (filterlut[(x) & 0xfffff])
 #endif
-static void quicksort(uint32_t* const start, uint32_t* const stop)
+static void quicksort(uint32_t *const start, uint32_t *const stop)
 {
-	uint32_t *it = start + 1, *rit = stop;
+  uint32_t *it = start + 1, *rit = stop;
-	if(it > rit)
+  if (it > rit)
-		return;
+    return;
-	while(it < rit)
+  while (it < rit)
-		if(*it <= *start)
+    if (*it <= *start)
-			++it;
+      ++it;
-		else if(*rit > *start)
+    else if (*rit > *start)
-			--rit;
+      --rit;
-		else
+    else {
-			*it ^= (*it ^= *rit, *rit ^= *it);
+      uint32_t x = *it;
      *it = *rit;
      *rit = x;
    }
-	if(*rit >= *start)
+  if (*rit >= *start)
-		--rit;
+    --rit;
-	if(rit != start)
+  if (rit != start) {
-		*rit ^= (*rit ^= *start, *start ^= *rit);
+    uint32_t x = *it;
    *it = *rit;
    *rit = x;
  }
-	quicksort(start, rit - 1);
+  quicksort(start, rit - 1);
-	quicksort(rit + 1, stop);
+  quicksort(rit + 1, stop);
 }
 /** binsearch
 * Binary search for the first occurence of *stop's MSB in sorted [start,stop]
 */
-static inline uint32_t*
+static inline uint32_t *
 binsearch(uint32_t *start, uint32_t *stop)
 {
-	uint32_t mid, val = *stop & 0xff000000;
+  uint32_t mid, val = *stop & 0xff000000;
-	while(start != stop)
+  while (start != stop)
-		if(start[mid = (stop - start) >> 1] > val)
+    if (start[mid = (stop - start) >> 1] > val)
-			stop = &start[mid];
+      stop = &start[mid];
-		else
+    else
-			start += mid + 1;
+      start += mid + 1;
-	return start;
+  return start;
 }
 /** update_contribution
@@ -76,11 +82,11 @@ binsearch(uint32_t *start, uint32_t *stop)
 static inline void
 update_contribution(uint32_t *item, const uint32_t mask1, const uint32_t mask2)
 {
-	uint32_t p = *item >> 25;
+  uint32_t p = *item >> 25;
-	p = p << 1 | parity(*item & mask1);
+  p = p << 1 | parity(*item & mask1);
-	p = p << 1 | parity(*item & mask2);
+  p = p << 1 | parity(*item & mask2);
-	*item = p << 24 | (*item & 0xffffff);
+  *item = p << 24 | (*item & 0xffffff);
 }
 /** extend_table
@@ -89,21 +95,21 @@ update_contribution(uint32_t *item, const uint32_t mask1, const uint32_t mask2)
 static inline void
 extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in)
 {
-	in <<= 24;
+  in <<= 24;
-	for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
+  for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
-		if(filter(*tbl) ^ filter(*tbl | 1)) {
+    if (filter(*tbl) ^ filter(*tbl | 1)) {
-			*tbl |= filter(*tbl) ^ bit;
+      *tbl |= filter(*tbl) ^ bit;
-			update_contribution(tbl, m1, m2);
+      update_contribution(tbl, m1, m2);
-			*tbl ^= in;
+      *tbl ^= in;
-		} else if(filter(*tbl) == bit) {
+    } else if (filter(*tbl) == bit) {
-			*++*end = tbl[1];
+      *++*end = tbl[1];
-			tbl[1] = tbl[0] | 1;
+      tbl[1] = tbl[0] | 1;
-			update_contribution(tbl, m1, m2);
+      update_contribution(tbl, m1, m2);
-			*tbl++ ^= in;
+      *tbl++ ^= in;
-			update_contribution(tbl, m1, m2);
+      update_contribution(tbl, m1, m2);
-			*tbl ^= in;
+      *tbl ^= in;
-		} else
+    } else
-			*tbl-- = *(*end)--;
+      *tbl-- = *(*end)--;
 }
 /** extend_table_simple
 * using a bit of the keystream extend the table of possible lfsr states
@@ -111,244 +117,251 @@ extend_table(uint32_t *tbl, uint32_t **end, int bit, int m1, int m2, uint32_t in
 static inline void
 extend_table_simple(uint32_t *tbl, uint32_t **end, int bit)
 {
-	for(*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
+  for (*tbl <<= 1; tbl <= *end; *++tbl <<= 1)
-		if(filter(*tbl) ^ filter(*tbl | 1)) {
+    if (filter(*tbl) ^ filter(*tbl | 1)) {
-			*tbl |= filter(*tbl) ^ bit;
+      *tbl |= filter(*tbl) ^ bit;
-		} else if(filter(*tbl) == bit) {
+    } else if (filter(*tbl) == bit) {
-			*++*end = *++tbl;
+      *++*end = *++tbl;
-			*tbl = tbl[-1] | 1;
+      *tbl = tbl[-1] | 1;
-		} else
+    } else
-			*tbl-- = *(*end)--;
+      *tbl-- = *(*end)--;
 }
 /** recover
 * recursively narrow down the search space, 4 bits of keystream at a time
 */
-static struct Crypto1State*
+static struct Crypto1State *
 recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
-	uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem,
+        uint32_t *e_head, uint32_t *e_tail, uint32_t eks, int rem,
-	struct Crypto1State *sl, uint32_t in)
+        struct Crypto1State *sl, uint32_t in) {
-{
+  uint32_t *o, *e, i;
 	uint32_t *o, *e, i;
-	if(rem == -1) {
+  if (rem == -1) {
-		for(e = e_head; e <= e_tail; ++e) {
+    for (e = e_head; e <= e_tail; ++e) {
-			*e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4);
+      *e = *e << 1 ^ parity(*e & LF_POLY_EVEN) ^ !!(in & 4);
-			for(o = o_head; o <= o_tail; ++o, ++sl) {
+      for (o = o_head; o <= o_tail; ++o, ++sl) {
-				sl->even = *o;
+        sl->even = *o;
-				sl->odd = *e ^ parity(*o & LF_POLY_ODD);
+        sl->odd = *e ^ parity(*o & LF_POLY_ODD);
-				sl[1].odd = sl[1].even = 0;
+        sl[1].odd = sl[1].even = 0;
-			}
+      }
-		}
+    }
-		return sl;
+    return sl;
-	}
+  }
-	for(i = 0; i < 4 && rem--; i++) {
+  for (i = 0; i < 4 && rem--; i++) {
-		extend_table(o_head, &o_tail, (oks >>= 1) & 1,
+    extend_table(o_head, &o_tail, (oks >>= 1) & 1,
-			LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0);
+                 LF_POLY_EVEN << 1 | 1, LF_POLY_ODD << 1, 0);
-		if(o_head > o_tail)
+    if (o_head > o_tail)
-			return sl;
+      return sl;
-		extend_table(e_head, &e_tail, (eks >>= 1) & 1,
+    extend_table(e_head, &e_tail, (eks >>= 1) & 1,
-			LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3);
+                 LF_POLY_ODD, LF_POLY_EVEN << 1 | 1, (in >>= 2) & 3);
-		if(e_head > e_tail)
+    if (e_head > e_tail)
-			return sl;
+      return sl;
-	}
+  }
-	quicksort(o_head, o_tail);
+  quicksort(o_head, o_tail);
-	quicksort(e_head, e_tail);
+  quicksort(e_head, e_tail);
-	while(o_tail >= o_head && e_tail >= e_head)
+  while (o_tail >= o_head && e_tail >= e_head)
-		if(((*o_tail ^ *e_tail) >> 24) == 0) {
+    if (((*o_tail ^ *e_tail) >> 24) == 0) {
-			o_tail = binsearch(o_head, o = o_tail);
+      o_tail = binsearch(o_head, o = o_tail);
-			e_tail = binsearch(e_head, e = e_tail);
+      e_tail = binsearch(e_head, e = e_tail);
-			sl = recover(o_tail--, o, oks,
+      sl = recover(o_tail--, o, oks,
-				     e_tail--, e, eks, rem, sl, in);
+                   e_tail--, e, eks, rem, sl, in);
-		}
+    } else if (*o_tail > *e_tail)
-		else if(*o_tail > *e_tail)
+      o_tail = binsearch(o_head, o_tail) - 1;
-			o_tail = binsearch(o_head, o_tail) - 1;
+    else
-		else
+      e_tail = binsearch(e_head, e_tail) - 1;
 			e_tail = binsearch(e_head, e_tail) - 1;
-	return sl;
+  return sl;
 }
 /** lfsr_recovery
 * recover the state of the lfsr given 32 bits of the keystream
 * additionally you can use the in parameter to specify the value
 * that was fed into the lfsr at the time the keystream was generated
 */
-struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in)
+struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in) {
-{
+  struct Crypto1State *statelist;
-	struct Crypto1State *statelist;
+  uint32_t *odd_head = 0, *odd_tail = 0, oks = 0;
-	uint32_t *odd_head = 0, *odd_tail = 0, oks = 0;
+  uint32_t *even_head = 0, *even_tail = 0, eks = 0;
-	uint32_t *even_head = 0, *even_tail = 0, eks = 0;
+  int i;
 	int i;
-	for(i = 31; i >= 0; i -= 2)
+  for (i = 31; i >= 0; i -= 2)
-		oks = oks << 1 | BEBIT(ks2, i);
+    oks = oks << 1 | BEBIT(ks2, i);
-	for(i = 30; i >= 0; i -= 2)
+  for (i = 30; i >= 0; i -= 2)
- 		eks = eks << 1 | BEBIT(ks2, i);
+    eks = eks << 1 | BEBIT(ks2, i);
-	odd_head = odd_tail = malloc(sizeof(uint32_t) << 21);
+  odd_head = odd_tail = malloc(sizeof(uint32_t) << 21);
-	even_head = even_tail = malloc(sizeof(uint32_t) << 21);
+  even_head = even_tail = malloc(sizeof(uint32_t) << 21);
-	statelist =  malloc(sizeof(struct Crypto1State) << 18);
+  statelist =  malloc(sizeof(struct Crypto1State) << 18);
-	if(!odd_tail-- || !even_tail-- || !statelist)
+  if (!odd_tail-- || !even_tail-- || !statelist)
-		goto out;
+    goto out;
-	statelist->odd = statelist->even = 0;
+  statelist->odd = statelist->even = 0;
-	for(i = 1 << 20; i >= 0; --i) {
+  for (i = 1 << 20; i >= 0; --i) {
-		if(filter(i) == (oks & 1))
+    if (filter(i) == (oks & 1))
-			*++odd_tail = i;
+      *++odd_tail = i;
-		if(filter(i) == (eks & 1))
+    if (filter(i) == (eks & 1))
-			*++even_tail = i;
+      *++even_tail = i;
-	}
+  }
-	for(i = 0; i < 4; i++) {
+  for (i = 0; i < 4; i++) {
-		extend_table_simple(odd_head,  &odd_tail, (oks >>= 1) & 1);
+    extend_table_simple(odd_head,  &odd_tail, (oks >>= 1) & 1);
-		extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1);
+    extend_table_simple(even_head, &even_tail, (eks >>= 1) & 1);
-	}
+  }
-	in = (in >> 16 & 0xff) | (in << 16) | (in & 0xff00);
+  in = (in >> 16 & 0xff) | (in << 16) | (in & 0xff00);
-	recover(odd_head, odd_tail, oks,
+  recover(odd_head, odd_tail, oks,
-		even_head, even_tail, eks, 11, statelist, in << 1);
+          even_head, even_tail, eks, 11, statelist, in << 1);
 out:
-	free(odd_head);
+  free(odd_head);
-	free(even_head);
+  free(even_head);
-	return statelist;
+  return statelist;
 }
 static const uint32_t S1[] = {     0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214,
-	0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83,
+                                   0x0310A, 0x85E30, 0xC69AD, 0x634D6, 0xB5CDE, 0xDE8DA, 0x6F46D, 0xB3C83,
-	0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA};
+                                   0x59E41, 0xA8995, 0xD027F, 0x6813F, 0x3409F, 0x9E6FA
                             };
 static const uint32_t S2[] = {  0x3A557B00, 0x5D2ABD80, 0x2E955EC0, 0x174AAF60,
-	0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8,
+                                0x0BA557B0, 0x05D2ABD8, 0x0449DE68, 0x048464B0, 0x42423258, 0x278192A8,
-	0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20,
+                                0x156042D0, 0x0AB02168, 0x43F89B30, 0x61FC4D98, 0x765EAD48, 0x7D8FDD20,
-	0x7EC7EE90, 0x7F63F748, 0x79117020};
+                                0x7EC7EE90, 0x7F63F748, 0x79117020
                             };
 static const uint32_t T1[] = {
-	0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66,
+  0x4F37D, 0x279BE, 0x97A6A, 0x4BD35, 0x25E9A, 0x12F4D, 0x097A6, 0x80D66,
-	0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B,
+  0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B,
-	0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615,
+  0x582BD, 0x2C15E, 0x160AF, 0x8F6E2, 0xC3DC4, 0xE5857, 0x72C2B, 0x39615,
-	0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C};
+  0x98DBF, 0xC806A, 0xE0680, 0x70340, 0x381A0, 0x98665, 0x4C332, 0xA272C
 };
 static const uint32_t T2[] = {  0x3C88B810, 0x5E445C08, 0x2982A580, 0x14C152C0,
-	0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268,
+                                0x4A60A960, 0x253054B0, 0x52982A58, 0x2FEC9EA8, 0x1156C4D0, 0x08AB6268,
-	0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0,
+                                0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0,
-	0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0,
+                                0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0,
-	0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950,
+                                0x4967E070, 0x64B3F038, 0x74F97398, 0x7CDC3248, 0x38CE92A0, 0x1C674950,
-	0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0};
+                                0x0E33A4A8, 0x01B959D0, 0x40DCACE8, 0x26CEDDF0
                             };
 static const uint32_t C1[] = { 0x846B5, 0x4235A, 0x211AD};
 static const uint32_t C2[] = { 0x1A822E0, 0x21A822E0, 0x21A822E0};
 /** Reverse 64 bits of keystream into possible cipher states
 * Variation mentioned in the paper. Somewhat optimized version
 */
-struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
+struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3) {
-{
+  struct Crypto1State *statelist, *sl;
-	struct Crypto1State *statelist, *sl;
+  uint8_t oks[32], eks[32], hi[32];
-	uint8_t oks[32], eks[32], hi[32];
+  uint32_t low = 0,  win = 0;
-	uint32_t low = 0,  win = 0;
+  uint32_t *tail, table[1 << 16];
-	uint32_t *tail, table[1 << 16];
+  int i, j;
 	int i, j;
-	sl = statelist = malloc(sizeof(struct Crypto1State) << 4);
+  sl = statelist = malloc(sizeof(struct Crypto1State) << 4);
-	if(!sl)
+  if (!sl)
-		return 0;
+    return 0;
-	sl->odd = sl->even = 0;
+  sl->odd = sl->even = 0;
-	for(i = 30; i >= 0; i -= 2) {
+  for (i = 30; i >= 0; i -= 2) {
-		oks[i >> 1] = BIT(ks2, i ^ 24);
+    oks[i >> 1] = BIT(ks2, i ^ 24);
-		oks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
+    oks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
-	}
+  }
-	for(i = 31; i >= 0; i -= 2) {
+  for (i = 31; i >= 0; i -= 2) {
-		eks[i >> 1] = BIT(ks2, i ^ 24);
+    eks[i >> 1] = BIT(ks2, i ^ 24);
-		eks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
+    eks[16 + (i >> 1)] = BIT(ks3, i ^ 24);
-	}
+  }
-	for(i = 0xfffff; i >= 0; --i) {
+  for (i = 0xfffff; i >= 0; --i) {
-		if (filter(i) != oks[0])
+    if (filter(i) != oks[0])
-			continue;
+      continue;
-		*(tail = table) = i;
+    *(tail = table) = i;
-		for(j = 1; tail >= table && j < 29; ++j)
+    for (j = 1; tail >= table && j < 29; ++j)
-			extend_table_simple(table, &tail, oks[j]);
+      extend_table_simple(table, &tail, oks[j]);
-		if(tail < table)
+    if (tail < table)
-			continue;
+      continue;
-		for(j = 0; j < 19; ++j)
+    for (j = 0; j < 19; ++j)
-			low = low << 1 | parity(i & S1[j]);
+      low = low << 1 | parity(i & S1[j]);
-		for(j = 0; j < 32; ++j)
+    for (j = 0; j < 32; ++j)
-			hi[j] = parity(i & T1[j]);
+      hi[j] = parity(i & T1[j]);
-		for(; tail >= table; --tail) {
+    for (; tail >= table; --tail) {
-			for(j = 0; j < 3; ++j) {
+      for (j = 0; j < 3; ++j) {
-				*tail = *tail << 1;
+        *tail = *tail << 1;
-				*tail |= parity((i & C1[j]) ^ (*tail & C2[j]));
+        *tail |= parity((i & C1[j]) ^(*tail & C2[j]));
-				if(filter(*tail) != oks[29 + j])
+        if (filter(*tail) != oks[29 + j])
-					goto continue2;
+          goto continue2;
-			}
+      }
-			for(j = 0; j < 19; ++j)
+      for (j = 0; j < 19; ++j)
-				win = win << 1 | parity(*tail & S2[j]);
+        win = win << 1 | parity(*tail & S2[j]);
-			win ^= low;
+      win ^= low;
-			for(j = 0; j < 32; ++j) {
+      for (j = 0; j < 32; ++j) {
-				win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]);
+        win = win << 1 ^ hi[j] ^ parity(*tail & T2[j]);
-				if(filter(win) != eks[j])
+        if (filter(win) != eks[j])
-					goto continue2;
+          goto continue2;
-			}
+      }
-			*tail = *tail << 1 | parity(LF_POLY_EVEN & *tail);
+      *tail = *tail << 1 | parity(LF_POLY_EVEN & *tail);
-			sl->odd = *tail ^ parity(LF_POLY_ODD & win);
+      sl->odd = *tail ^ parity(LF_POLY_ODD & win);
-			sl->even = win;
+      sl->even = win;
-			++sl;
+      ++sl;
-			sl->odd = sl->even = 0;
+      sl->odd = sl->even = 0;
-			continue2:;
+continue2:
-		}
+      ;
-	}
+    }
-	return statelist;
+  }
  return statelist;
 }
 uint8_t lfsr_rollback_bit(struct Crypto1State *s, uint32_t in, int fb);
 uint8_t lfsr_rollback_byte(struct Crypto1State *s, uint32_t in, int fb);
 uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd);
 /** lfsr_rollback_bit
 * Rollback the shift register in order to get previous states
 */
 uint8_t lfsr_rollback_bit(struct Crypto1State *s, uint32_t in, int fb)
 {
-	int out;
+  int out;
-	uint8_t ret;
+  uint8_t ret;
-	s->odd &= 0xffffff;
+  s->odd &= 0xffffff;
-	s->odd ^= (s->odd ^= s->even, s->even ^= s->odd);
+  uint32_t x = s->odd;
  s->odd = s->even;
  s->even = x;
-	out = s->even & 1;
+  out = s->even & 1;
-	out ^= LF_POLY_EVEN & (s->even >>= 1);
+  out ^= LF_POLY_EVEN & (s->even >>= 1);
-	out ^= LF_POLY_ODD & s->odd;
+  out ^= LF_POLY_ODD & s->odd;
-	out ^= !!in;
+  out ^= !!in;
-	out ^= (ret = filter(s->odd)) & !!fb;
+  out ^= (ret = filter(s->odd)) & !!fb;
-	s->even |= parity(out) << 23;
+  s->even |= parity(out) << 23;
-	return ret;
+  return ret;
 }
 /** lfsr_rollback_byte
 * Rollback the shift register in order to get previous states
 */
 uint8_t lfsr_rollback_byte(struct Crypto1State *s, uint32_t in, int fb)
 {
-	int i;
+  int i;
-	uint8_t ret = 0;
+  uint8_t ret = 0;
-	for (i = 7; i >= 0; --i)
+  for (i = 7; i >= 0; --i)
-		ret |= lfsr_rollback_bit(s, BIT(in, i), fb) << i;
+    ret |= lfsr_rollback_bit(s, BIT(in, i), fb) << i;
-	return ret;
+  return ret;
 }
 /** lfsr_rollback_word
 * Rollback the shift register in order to get previous states
 */
 uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb)
 {
-	int i;
+  int i;
-	uint32_t ret = 0;
+  uint32_t ret = 0;
-	for (i = 31; i >= 0; --i)
+  for (i = 31; i >= 0; --i)
-		ret |= lfsr_rollback_bit(s, BEBIT(in, i), fb) << (i ^ 24);
+    ret |= lfsr_rollback_bit(s, BEBIT(in, i), fb) << (i ^ 24);
-	return ret;
+  return ret;
 }
 /** nonce_distance
@@ -357,23 +370,24 @@ uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb)
 static uint16_t *dist = 0;
 int nonce_distance(uint32_t from, uint32_t to)
 {
-	uint16_t x, i;
+  uint16_t x, i;
-	if(!dist) {
+  if (!dist) {
-		dist = malloc(2 << 16);
+    dist = malloc(2 << 16);
-		if(!dist)
+    if (!dist)
-			return -1;
+      return -1;
-		for (x = i = 1; i; ++i) {
+    for (x = i = 1; i; ++i) {
-			dist[(x & 0xff) << 8 | x >> 8] = i;
+      dist[(x & 0xff) << 8 | x >> 8] = i;
-			x = x >> 1 | (x ^ x >> 2 ^ x >> 3 ^ x >> 5) << 15;
+      x = x >> 1 | (x ^ x >> 2 ^ x >> 3 ^ x >> 5) << 15;
-		}
+    }
-	}
+  }
-	return (65535 + dist[to >> 16] - dist[from >> 16]) % 65535;
+  return (65535 + dist[to >> 16] - dist[from >> 16]) % 65535;
 }
 static uint32_t fastfwd[2][8] = {
-	{ 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB},
+  { 0, 0x4BC53, 0xECB1, 0x450E2, 0x25E29, 0x6E27A, 0x2B298, 0x60ECB},
-	{ 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}};
+  { 0, 0x1D962, 0x4BC53, 0x56531, 0xECB1, 0x135D3, 0x450E2, 0x58980}
 };
 /** lfsr_prefix_ks
@@ -387,61 +401,60 @@ static uint32_t fastfwd[2][8] = {
 */
 uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)
 {
-	uint32_t c, entry, *candidates = malloc(4 << 21);
+  uint32_t c, entry, *candidates = malloc(4 << 21);
-	int i, size = (1 << 21) - 1;
+  int i, size = (1 << 21) - 1;
-	if(!candidates)
+  if (!candidates)
-		return 0;
+    return 0;
-	for(i = 0; i <= size; ++i)
+  for (i = 0; i <= size; ++i)
-		candidates[i] = i;
+    candidates[i] = i;
-	for(c = 0;  c < 8; ++c)
+  for (c = 0;  c < 8; ++c)
-		for(i = 0;i <= size; ++i) {
+    for (i = 0; i <= size; ++i) {
-			entry = candidates[i] ^ fastfwd[isodd][c];
+      entry = candidates[i] ^ fastfwd[isodd][c];
-			if(filter(entry >> 1) != BIT(ks[c], isodd) ||
+      if (filter(entry >> 1) != BIT(ks[c], isodd) ||
-			   filter(entry) != BIT(ks[c], isodd + 2))
+          filter(entry) != BIT(ks[c], isodd + 2))
-				candidates[i--] = candidates[size--];
+        candidates[i--] = candidates[size--];
-		}
+    }
-	candidates[size + 1] = -1;
+  candidates[size + 1] = -1;
-	return candidates;
+  return candidates;
 }
 /** check_pfx_parity
 * helper function which eliminates possible secret states using parity bits
 */
-static struct Crypto1State*
+static struct Crypto1State *
 check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
-          	uint32_t odd, uint32_t even, struct Crypto1State* sl)
+                 uint32_t odd, uint32_t even, struct Crypto1State *sl) {
-{
+  uint32_t ks1, nr, ks2, rr, ks3, c, good = 1;
 	uint32_t ks1, nr, ks2, rr, ks3, c, good = 1;
-	for(c = 0; good && c < 8; ++c) {
+  for (c = 0; good && c < 8; ++c) {
-		sl->odd = odd ^ fastfwd[1][c];
+    sl->odd = odd ^ fastfwd[1][c];
-		sl->even = even ^ fastfwd[0][c];
+    sl->even = even ^ fastfwd[0][c];
-		lfsr_rollback_bit(sl, 0, 0);
+    lfsr_rollback_bit(sl, 0, 0);
-		lfsr_rollback_bit(sl, 0, 0);
+    lfsr_rollback_bit(sl, 0, 0);
-		ks3 = lfsr_rollback_bit(sl, 0, 0);
+    ks3 = lfsr_rollback_bit(sl, 0, 0);
-		ks2 = lfsr_rollback_word(sl, 0, 0);
+    ks2 = lfsr_rollback_word(sl, 0, 0);
-		ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1);
+    ks1 = lfsr_rollback_word(sl, prefix | c << 5, 1);
-		nr = ks1 ^ (prefix | c << 5);
+    nr = ks1 ^(prefix | c << 5);
-		rr = ks2 ^ rresp;
+    rr = ks2 ^ rresp;
-		good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24);
+    good &= parity(nr & 0x000000ff) ^ parities[c][3] ^ BIT(ks2, 24);
-		good &= parity(rr & 0xff000000) ^ parities[c][4] ^ BIT(ks2, 16);
+    good &= parity(rr & 0xff000000) ^ parities[c][4] ^ BIT(ks2, 16);
-		good &= parity(rr & 0x00ff0000) ^ parities[c][5] ^ BIT(ks2,  8);
+    good &= parity(rr & 0x00ff0000) ^ parities[c][5] ^ BIT(ks2,  8);
-		good &= parity(rr & 0x0000ff00) ^ parities[c][6] ^ BIT(ks2,  0);
+    good &= parity(rr & 0x0000ff00) ^ parities[c][6] ^ BIT(ks2,  0);
-		good &= parity(rr & 0x000000ff) ^ parities[c][7] ^ ks3;
+    good &= parity(rr & 0x000000ff) ^ parities[c][7] ^ ks3;
-	}
+  }
-	return sl + good;
+  return sl + good;
-} 
+}
 /** lfsr_common_prefix
@@ -453,35 +466,34 @@ check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
 * It returns a zero terminated list of possible cipher states after the
 * tag nonce was fed in
 */
-struct Crypto1State*
+struct Crypto1State *
-lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8])
+lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]) {
-{
+  struct Crypto1State *statelist, *s;
-	struct Crypto1State *statelist, *s;
+  uint32_t *odd, *even, *o, *e, top;
 	uint32_t *odd, *even, *o, *e, top;
-	odd = lfsr_prefix_ks(ks, 1);
+  odd = lfsr_prefix_ks(ks, 1);
-	even = lfsr_prefix_ks(ks, 0);
+  even = lfsr_prefix_ks(ks, 0);
-	s = statelist = malloc((sizeof *statelist) << 20);
+  s = statelist = malloc((sizeof *statelist) << 20);
-	if(!s || !odd || !even) {
+  if (!s || !odd || !even) {
-		free(odd);
+    free(odd);
-		free(even);
+    free(even);
-		free(statelist);
+    free(statelist);
-                return 0;
+    return 0;
-	}
+  }
-	for(o = odd; *o + 1; ++o)
+  for (o = odd; *o + 1; ++o)
-		for(e = even; *e + 1; ++e)
+    for (e = even; *e + 1; ++e)
-			for(top = 0; top < 64; ++top) {
+      for (top = 0; top < 64; ++top) {
-				*o += 1 << 21;
+        *o += 1 << 21;
-				*e += (!(top & 7) + 1) << 21;
+        *e += (!(top & 7) + 1) << 21;
-				s = check_pfx_parity(pfx, rr, par, *o, *e, s);
+        s = check_pfx_parity(pfx, rr, par, *o, *e, s);
-			}
+      }
-	s->odd = s->even = 0;
+  s->odd = s->even = 0;
-	free(odd);
+  free(odd);
-	free(even);
+  free(even);
-	return statelist;
+  return statelist;
 }
--- a/src/crapto1.h
+++ b/src/crapto1.h
@@ -24,66 +24,66 @@
 extern "C" {
 #endif
-struct Crypto1State {uint32_t odd, even;};
+  struct Crypto1State {uint32_t odd, even;};
-struct Crypto1State* crypto1_create(uint64_t);
+  struct Crypto1State *crypto1_create(uint64_t);
-void crypto1_destroy(struct Crypto1State*);
+  void crypto1_destroy(struct Crypto1State *);
-void crypto1_get_lfsr(struct Crypto1State*, uint64_t*);
+  void crypto1_get_lfsr(struct Crypto1State *, uint64_t *);
-uint8_t crypto1_bit(struct Crypto1State*, uint8_t, int);
+  uint8_t crypto1_bit(struct Crypto1State *, uint8_t, int);
-uint8_t crypto1_byte(struct Crypto1State*, uint8_t, int);
+  uint8_t crypto1_byte(struct Crypto1State *, uint8_t, int);
-uint32_t crypto1_word(struct Crypto1State*, uint32_t, int);
+  uint32_t crypto1_word(struct Crypto1State *, uint32_t, int);
-uint32_t prng_successor(uint32_t x, uint32_t n);
+  uint32_t prng_successor(uint32_t x, uint32_t n);
-struct Crypto1State* lfsr_recovery32(uint32_t ks2, uint32_t in);
+  struct Crypto1State *lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8]);
-struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3);
+  struct Crypto1State *lfsr_recovery32(uint32_t ks2, uint32_t in);
  struct Crypto1State *lfsr_recovery64(uint32_t ks2, uint32_t ks3);
-void lfsr_rollback(struct Crypto1State* s, uint32_t in, int fb);
+  void lfsr_rollback(struct Crypto1State *s, uint32_t in, int fb);
-int nonce_distance(uint32_t from, uint32_t to);
+  uint32_t lfsr_rollback_word(struct Crypto1State *s, uint32_t in, int fb);
  int nonce_distance(uint32_t from, uint32_t to);
 #define FOREACH_VALID_NONCE(N, FILTER, FSIZE)\
-	uint32_t __n = 0,__M = 0, N = 0;\
+  uint32_t __n = 0,__M = 0, N = 0;\
-	int __i;\
+  int __i;\
-	for(; __n < 1 << 16; N = prng_successor(__M = ++__n, 16))\
+  for(; __n < 1 << 16; N = prng_successor(__M = ++__n, 16))\
-		for(__i = FSIZE - 1; __i >= 0; __i--)\
+    for(__i = FSIZE - 1; __i >= 0; __i--)\
-			if(BIT(FILTER, __i) ^ parity(__M & 0xFF01))\
+      if(BIT(FILTER, __i) ^ parity(__M & 0xFF01))\
-				break;\
+        break;\
-			else if(__i)\
+      else if(__i)\
-				__M = prng_successor(__M, (__i == 7) ? 48 : 8);\
+        __M = prng_successor(__M, (__i == 7) ? 48 : 8);\
-			else 
+      else
 #define LF_POLY_ODD (0x29CE5C)
 #define LF_POLY_EVEN (0x870804)
 #define BIT(x, n) ((x) >> (n) & 1)
 #define BEBIT(x, n) BIT(x, (n) ^ 24)
-static inline int parity(uint32_t x)
+  static inline int parity(uint32_t x)
-{
+  {
 #if !defined __i386__ || !defined __GNUC__
-	x ^= x >> 16;
+    x ^= x >> 16;
-	x ^= x >> 8;
+    x ^= x >> 8;
-	x ^= x >> 4;
+    x ^= x >> 4;
-	return BIT(0x6996, x & 0xf);
+    return BIT(0x6996, x & 0xf);
 #else
-	__asm__(
+    __asm__("movl %1, %%eax\n"
-		"movl %1, %%eax\n"
+            "mov %%ax, %%cx\n"
-		"mov %%ax, %%cx\n"
+            "shrl $0x10, %%eax\n"
-		"shrl $0x10, %%eax\n"
+            "xor %%ax, %%cx\n"
-		"xor %%ax, %%cx\n"
+            "xor %%ch, %%cl\n"
-		"xor %%ch, %%cl\n"
+            "setpo %%al\n"
-		"setpo %%al\n"
+            "movzx %%al, %0\n": "=r"(x) : "r"(x): "eax", "ecx");
-		"movzx %%al, %0\n": "=r"(x) : "r"(x): "eax","ecx"
+    return x;
 	);
 	return x;
 #endif
-}
+  }
-static inline int filter(uint32_t const x)
+  static inline int filter(uint32_t const x)
-{
+  {
-	uint32_t f;
+    uint32_t f;
-	f  = 0xf22c0 >> (x       & 0xf) & 16;
+    f  = 0xf22c0 >> (x       & 0xf) & 16;
-	f |= 0x6c9c0 >> (x >>  4 & 0xf) &  8;
+    f |= 0x6c9c0 >> (x >>  4 & 0xf) &  8;
-	f |= 0x3c8b0 >> (x >>  8 & 0xf) &  4;
+    f |= 0x3c8b0 >> (x >>  8 & 0xf) &  4;
-	f |= 0x1e458 >> (x >> 12 & 0xf) &  2;
+    f |= 0x1e458 >> (x >> 12 & 0xf) &  2;
-	f |= 0x0d938 >> (x >> 16 & 0xf) &  1;
+    f |= 0x0d938 >> (x >> 16 & 0xf) &  1;
-	return BIT(0xEC57E80A, f);
+    return BIT(0xEC57E80A, f);
-}
+  }
 #ifdef __cplusplus
 }
 #endif
--- a/src/crypto1.c
+++ b/src/crypto1.c
@@ -21,63 +21,64 @@
 #include <stdlib.h>
 #define SWAPENDIAN(x)\
-	(x = (x >> 8 & 0xff00ff) | (x & 0xff00ff) << 8, x = x >> 16 | x << 16)
+  (x = (x >> 8 & 0xff00ff) | (x & 0xff00ff) << 8, x = x >> 16 | x << 16)
-struct Crypto1State * crypto1_create(uint64_t key)
+struct Crypto1State *crypto1_create(uint64_t key) {
-{
+  struct Crypto1State *s = malloc(sizeof(*s));
-	struct Crypto1State *s = malloc(sizeof(*s));
+  int i;
 	int i;
-	for(i = 47;s && i > 0; i -= 2) {
+  for (i = 47; s && i > 0; i -= 2) {
-		s->odd  = s->odd  << 1 | BIT(key, (i - 1) ^ 7);
+    s->odd  = s->odd  << 1 | BIT(key, (i - 1) ^ 7);
-		s->even = s->even << 1 | BIT(key, i ^ 7);
+    s->even = s->even << 1 | BIT(key, i ^ 7);
-	}
+  }
-	return s;
+  return s;
 }
 void crypto1_destroy(struct Crypto1State *state)
 {
-	free(state);
+  free(state);
 }
 void crypto1_get_lfsr(struct Crypto1State *state, uint64_t *lfsr)
 {
-	int i;
+  int i;
-	for(*lfsr = 0, i = 23; i >= 0; --i) {
+  for (*lfsr = 0, i = 23; i >= 0; --i) {
-		*lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3);
+    *lfsr = *lfsr << 1 | BIT(state->odd, i ^ 3);
-		*lfsr = *lfsr << 1 | BIT(state->even, i ^ 3);
+    *lfsr = *lfsr << 1 | BIT(state->even, i ^ 3);
-	}
+  }
 }
 uint8_t crypto1_bit(struct Crypto1State *s, uint8_t in, int is_encrypted)
 {
-	uint32_t feedin;
+  uint32_t feedin;
-	uint8_t ret = filter(s->odd);
+  uint8_t ret = filter(s->odd);
-	feedin  = ret & !!is_encrypted;
+  feedin  = ret & !!is_encrypted;
-	feedin ^= !!in;
+  feedin ^= !!in;
-	feedin ^= LF_POLY_ODD & s->odd;
+  feedin ^= LF_POLY_ODD & s->odd;
-	feedin ^= LF_POLY_EVEN & s->even;
+  feedin ^= LF_POLY_EVEN & s->even;
-	s->even = s->even << 1 | parity(feedin);
+  s->even = s->even << 1 | parity(feedin);
-	s->odd ^= (s->odd ^= s->even, s->even ^= s->odd);
+  uint32_t x = s->odd;
  s->odd = s->even;
  s->even = x;
-	return ret;
+  return ret;
 }
 uint8_t crypto1_byte(struct Crypto1State *s, uint8_t in, int is_encrypted)
 {
-	uint8_t i, ret = 0;
+  uint8_t i, ret = 0;
-	for (i = 0; i < 8; ++i)
+  for (i = 0; i < 8; ++i)
-		ret |= crypto1_bit(s, BIT(in, i), is_encrypted) << i;
+    ret |= crypto1_bit(s, BIT(in, i), is_encrypted) << i;
-	return ret;
+  return ret;
 }
 uint32_t crypto1_word(struct Crypto1State *s, uint32_t in, int is_encrypted)
 {
-	uint32_t i, ret = 0;
+  uint32_t i, ret = 0;
-	for (i = 0; i < 32; ++i)
+  for (i = 0; i < 32; ++i)
-		ret |= crypto1_bit(s, BEBIT(in, i), is_encrypted) << (i ^ 24);
+    ret |= crypto1_bit(s, BEBIT(in, i), is_encrypted) << (i ^ 24);
-	return ret;
+  return ret;
 }
 /* prng_successor
@@ -85,9 +86,9 @@ uint32_t crypto1_word(struct Crypto1State *s, uint32_t in, int is_encrypted)
 */
 uint32_t prng_successor(uint32_t x, uint32_t n)
 {
-	SWAPENDIAN(x);
+  SWAPENDIAN(x);
-	while(n--)
+  while (n--)
-		x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31;
+    x = x >> 1 | (x >> 16 ^ x >> 18 ^ x >> 19 ^ x >> 21) << 31;
-	return SWAPENDIAN(x);
+  return SWAPENDIAN(x);
 }
--- a/src/mfcuk.c
+++ b/src/mfcuk.c
--- a/src/mfcuk.h
+++ b/src/mfcuk.h
@@ -1,120 +1,119 @@
-/*
+/*
- Package:
+ Package:
-    MiFare Classic Universal toolKit (MFCUK)
+    MiFare Classic Universal toolKit (MFCUK)
- 
+
- Filename:
+ Filename:
-    mfcuk_keyrecovery_darkside.h
+    mfcuk_keyrecovery_darkside.h
-
+
- Description:
+ Description:
-    MFCUK DarkSide Key Recovery specific typedefs and defines
+    MFCUK DarkSide Key Recovery specific typedefs and defines
-
+
- Contact, bug-reports:
+ Contact, bug-reports:
-    http://andreicostin.com/
+    http://andreicostin.com/
-    mailto:zveriu@gmail.com
+    mailto:zveriu@gmail.com
-
+
- License:
+ License:
-    GPL2 (see below), Copyright (C) 2009, Andrei Costin
+    GPL2 (see below), Copyright (C) 2009, Andrei Costin
-
+
- * @file mfcuk_keyrecovery_darkside.h
+ * @file mfcuk_keyrecovery_darkside.h
- * @brief 
+ * @brief
-*/
+*/
-
+
-/*
+/*
- VERSION HISTORY
+ VERSION HISTORY
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-| Number     : 0.1
+| Number     : 0.1
-| dd/mm/yyyy : 23/11/2009
+| dd/mm/yyyy : 23/11/2009
-| Author     : zveriu@gmail.com, http://andreicostin.com
+| Author     : zveriu@gmail.com, http://andreicostin.com
-| Description: Moved bulk of defines and things from "mfcuk_keyrecovery_darkside.c"
+| Description: Moved bulk of defines and things from "mfcuk_keyrecovery_darkside.c"
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-*/
+*/
-
+
-/*
+/*
- LICENSE
+ LICENSE
-
+
- This program is free software: you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
+ the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
+ (at your option) any later version.
- 
+
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+ GNU General Public License for more details.
- 
+
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+*/
-
+
-#ifndef _MFCUK_KEYRECOVERY_DARKSIDE_H_
+#ifndef _MFCUK_KEYRECOVERY_DARKSIDE_H_
-#define _MFCUK_KEYRECOVERY_DARKSIDE_H_
+#define _MFCUK_KEYRECOVERY_DARKSIDE_H_
-
+
-// Define package and executable related info
+// Define package and executable related info
-#define BUILD_NAME      "Mifare Classic DarkSide Key Recovery Tool"
+#define BUILD_NAME      "Mifare Classic DarkSide Key Recovery Tool"
-#define BUILD_VERSION   "0.3"
+#define BUILD_VERSION   "0.3"
-#define BUILD_AUTHOR    "Andrei Costin, zveriu@gmail.com, http://andreicostin.com"
+#define BUILD_AUTHOR    "Andrei Costin, zveriu@gmail.com, http://andreicostin.com"
-
+
-// Define return statuses
+// Define return statuses
-#define MFCUK_SUCCESS                 0x0
+#define MFCUK_SUCCESS                 0x0
-#define MFCUK_OK_KEY_RECOVERED        (MFCUK_SUCCESS+1)
+#define MFCUK_OK_KEY_RECOVERED        (MFCUK_SUCCESS+1)
-#define MFCUK_FAIL_AUTH               (MFCUK_OK_KEY_RECOVERED+1)
+#define MFCUK_FAIL_AUTH               (MFCUK_OK_KEY_RECOVERED+1)
-#define MFCUK_FAIL_CRAPTO             (MFCUK_FAIL_AUTH+1)
+#define MFCUK_FAIL_CRAPTO             (MFCUK_FAIL_AUTH+1)
-#define MFCUK_FAIL_TAGTYPE_INVALID    (MFCUK_FAIL_CRAPTO+1)
+#define MFCUK_FAIL_TAGTYPE_INVALID    (MFCUK_FAIL_CRAPTO+1)
-#define MFCUK_FAIL_KEYTYPE_INVALID    (MFCUK_FAIL_TAGTYPE_INVALID+1)
+#define MFCUK_FAIL_KEYTYPE_INVALID    (MFCUK_FAIL_TAGTYPE_INVALID+1)
-#define MFCUK_FAIL_BLOCK_INVALID      (MFCUK_FAIL_KEYTYPE_INVALID+1)
+#define MFCUK_FAIL_BLOCK_INVALID      (MFCUK_FAIL_KEYTYPE_INVALID+1)
-#define MFCUK_FAIL_SECTOR_INVALID     (MFCUK_FAIL_BLOCK_INVALID+1)
+#define MFCUK_FAIL_SECTOR_INVALID     (MFCUK_FAIL_BLOCK_INVALID+1)
-#define MFCUK_FAIL_COMM               (MFCUK_FAIL_SECTOR_INVALID+1)
+#define MFCUK_FAIL_COMM               (MFCUK_FAIL_SECTOR_INVALID+1)
-#define MFCUK_FAIL_MEMORY             (MFCUK_FAIL_COMM+1)
+#define MFCUK_FAIL_MEMORY             (MFCUK_FAIL_COMM+1)
-
+
-// There are 4 bytes in ACBITS, use each byte as below
+// There are 4 bytes in ACBITS, use each byte as below
-#define ACTIONS_KEY_A           0 // Specifies the byte index where actions for key A are stored
+#define ACTIONS_KEY_A           0 // Specifies the byte index where actions for key A are stored
-#define RESULTS_KEY_A           1 // Specifies the byte index where results for key A are stored
+#define RESULTS_KEY_A           1 // Specifies the byte index where results for key A are stored
-#define ACTIONS_KEY_B           2 // Specifies the byte index where actions for key B are stored
+#define ACTIONS_KEY_B           2 // Specifies the byte index where actions for key B are stored
-#define RESULTS_KEY_B           3 // Specifies the byte index where results for key B are stored
+#define RESULTS_KEY_B           3 // Specifies the byte index where results for key B are stored
-
+
-// The action/result byte can contain any combination of these
+// The action/result byte can contain any combination of these
-#define ACTIONS_VERIFY          0x1 // Specifies whether the key should be first verified
+#define ACTIONS_VERIFY          0x1 // Specifies whether the key should be first verified
-#define ACTIONS_RECOVER         0x2 // Specifies whether the key should be recovered. If a key has verify action and the key was verified, RESULTS_ byte will indicate that and recovery will not take place
+#define ACTIONS_RECOVER         0x2 // Specifies whether the key should be recovered. If a key has verify action and the key was verified, RESULTS_ byte will indicate that and recovery will not take place
-#define ACTIONS_KEYSET          0x4 // Specifies whether the key was set from command line rather that should be loaded from the eventual -i/-I dump
+#define ACTIONS_KEYSET          0x4 // Specifies whether the key was set from command line rather that should be loaded from the eventual -i/-I dump
-
+
-// Implementation specific, since we are not 100% sure we can fix the tag nonce
+// Implementation specific, since we are not 100% sure we can fix the tag nonce
-// Suppose from 2^32, only MAX 2^16 tag nonces will appear given current SLEEP_ values
+// Suppose from 2^32, only MAX 2^16 tag nonces will appear given current SLEEP_ values
-#define MAX_TAG_NONCES                  65536
+#define MAX_TAG_NONCES                  65536
-// Maximum possible states allocated and returned by lsfr_common_prefix(). Used this value in the looping
+// Maximum possible states allocated and returned by lsfr_common_prefix(). Used this value in the looping
-#define MAX_COMMON_PREFIX_STATES        (1<<20)
+#define MAX_COMMON_PREFIX_STATES        (1<<20)
-// 10 ms, though {WPMCC09} claims 30 us is enough
+// 10 ms, though {WPMCC09} claims 30 us is enough
-#define SLEEP_AT_FIELD_OFF              10
+#define SLEEP_AT_FIELD_OFF              10
-// 50 ms, seems pretty good constant, though if you don't like it - make it even 3.1415..., we don't care
+// 50 ms, seems pretty good constant, though if you don't like it - make it even 3.1415..., we don't care
-#define SLEEP_AFTER_FIELD_ON            50
+#define SLEEP_AFTER_FIELD_ON            50
-// Since the 29 bits of {Nr} are constant, darkside varies only "last" (0xFFFFFF1F) 3 bits, thus we have 8 possible parity bits arrays
+// Since the 29 bits of {Nr} are constant, darkside varies only "last" (0xFFFFFF1F) 3 bits, thus we have 8 possible parity bits arrays
-#define MFCUK_DARKSIDE_MAX_LEVELS       8
+#define MFCUK_DARKSIDE_MAX_LEVELS       8
-
+
-#define MFCUK_DARKSIDE_START_NR         0xDEADBEEF
+#define MFCUK_DARKSIDE_START_NR         0xDEADBEEF
-#define MFCUK_DARKSIDE_START_AR         0xFACECAFE
+#define MFCUK_DARKSIDE_START_AR         0xFACECAFE
-
+
-typedef struct tag_nonce_entry
+typedef struct tag_nonce_entry {
-{
+  uint32_t tagNonce; // Tag nonce we target for fixation
-	uint32_t tagNonce; // Tag nonce we target for fixation
+  uint8_t spoofFlag; // No spoofing until we have a successful auth with this tagNonce. Once we have, we want to spoof to get the encrypted 0x5 value
-    byte_t spoofFlag; // No spoofing until we have a successful auth with this tagNonce. Once we have, we want to spoof to get the encrypted 0x5 value
+  uint32_t num_of_appearances; // For statistics, how many times this tag nonce appeared for the given SLEEP_ values
-    uint32_t num_of_appearances; // For statistics, how many times this tag nonce appeared for the given SLEEP_ values
+
-
+  // STAGE1 data for "dark side" and lsfr_common_prefix()
-    // STAGE1 data for "dark side" and lsfr_common_prefix()
+  uint32_t spoofNrPfx; // PARAM: used as pfx, calculated from (spoofNrEnc & 0xFFFFFF1F). BUG: weird way to denote "first 29 prefix bits" in "dark side" paper. Perhaps I see the world different
-    uint32_t spoofNrPfx; // PARAM: used as pfx, calculated from (spoofNrEnc & 0xFFFFFF1F). BUG: weird way to denote "first 29 prefix bits" in "dark side" paper. Perhaps I see the world different
+  uint32_t spoofNrEnc; // {Nr} value which we will be using to make the tag respond with 4 bits
-    uint32_t spoofNrEnc; // {Nr} value which we will be using to make the tag respond with 4 bits
+  uint32_t spoofArEnc; // PARAM: used as rr
-    uint32_t spoofArEnc; // PARAM: used as rr
+  uint8_t spoofParBitsEnc; // parity bits we are trying to guess for the first time
-    uint8_t spoofParBitsEnc; // parity bits we are trying to guess for the first time
+  uint8_t spoofNackEnc; // store here the encrypted NACK returned first time we match the parity bits
-    uint8_t spoofNackEnc; // store here the encrypted NACK returned first time we match the parity bits
+  uint8_t spoofKs; // store here the keystream ks used for encryptying spoofNackEnc, specifically spoofKs = spoofNackEnc ^ 0x5
-    uint8_t spoofKs; // store here the keystream ks used for encryptying spoofNackEnc, specifically spoofKs = spoofNackEnc ^ 0x5
+
-
+  // STAGE2 data for "dark side" and lsfr_common_prefix()
-    // STAGE2 data for "dark side" and lsfr_common_prefix()
+  int current_out_of_8; // starting from -1 until we find parity for chosen spoofNrEnc,spoofArEnc
-    int current_out_of_8; // starting from -1 until we find parity for chosen spoofNrEnc,spoofArEnc
+  uint8_t parBitsCrntCombination[MFCUK_DARKSIDE_MAX_LEVELS]; // Loops over 32 combinations of the last 5 parity bits which generated the 4 bit NACK in STAGE1
-    uint8_t parBitsCrntCombination[MFCUK_DARKSIDE_MAX_LEVELS]; // Loops over 32 combinations of the last 5 parity bits which generated the 4 bit NACK in STAGE1
+  uint32_t nrEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // the 29 bits constant prefix, varying only 3 bits, thus 8 possible values
-    uint32_t nrEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // the 29 bits constant prefix, varying only 3 bits, thus 8 possible values
+  uint32_t arEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // the same reader response as spoofArEnc; redundant but... :)
-    uint32_t arEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // the same reader response as spoofArEnc; redundant but... :)
+  uint8_t ks[MFCUK_DARKSIDE_MAX_LEVELS]; // PARAM: used as ks, obtained as (ks[i] = nackEnc[i] ^ 0x5)
-    uint8_t ks[MFCUK_DARKSIDE_MAX_LEVELS]; // PARAM: used as ks, obtained as (ks[i] = nackEnc[i] ^ 0x5)
+  uint8_t nackEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // store here the encrypted 4 bits values which tag responded
-    uint8_t nackEnc[MFCUK_DARKSIDE_MAX_LEVELS]; // store here the encrypted 4 bits values which tag responded
+  uint8_t parBits[MFCUK_DARKSIDE_MAX_LEVELS]; // store here the values based on spoofParBitsEnc, varying only last 5 bits
-    uint8_t parBits[MFCUK_DARKSIDE_MAX_LEVELS]; // store here the values based on spoofParBitsEnc, varying only last 5 bits
+  uint8_t parBitsArr[MFCUK_DARKSIDE_MAX_LEVELS][8]; // PARAM: used as par, contains value of parBits byte-bit values just splitted out one bit per byte thus second pair of braces [8]
-    uint8_t parBitsArr[MFCUK_DARKSIDE_MAX_LEVELS][8]; // PARAM: used as par, contains value of parBits byte-bit values just splitted out one bit per byte thus second pair of braces [8]
+} tag_nonce_entry_t;
-} tag_nonce_entry_t;
+
-
+#endif // _MFCUK_KEYRECOVERY_DARKSIDE_H_
 #endif // _MFCUK_KEYRECOVERY_DARKSIDE_H_
--- a/src/mfcuk_finger.c
+++ b/src/mfcuk_finger.c
@@ -5,23 +5,23 @@
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
- 
+
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
- 
+
 You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
 Package:
    MiFare Classic Universal toolKit (MFCUK)
- 
+
 Package version:
    0.1
- 
+
 Filename:
    mfcuk_finger.c
@@ -38,179 +38,150 @@
 #include "mfcuk_finger.h"
-mfcuk_finger_tmpl_entry mfcuk_finger_db[] = 
+mfcuk_finger_tmpl_entry mfcuk_finger_db[] = {
-{
+  { "./data/tmpls_fingerprints/mfcuk_tmpl_skgt.mfd", "Sofia SKGT", mfcuk_finger_default_comparator, mfcuk_finger_skgt_decoder, NULL },
-    { "./data/tmpls_fingerprints/mfcuk_tmpl_skgt.mfd", "Sofia SKGT", mfcuk_finger_default_comparator, mfcuk_finger_skgt_decoder, NULL },
+  { "./data/tmpls_fingerprints/mfcuk_tmpl_ratb.mfd", "Bucharest RATB", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
-    { "./data/tmpls_fingerprints/mfcuk_tmpl_ratb.mfd", "Bucharest RATB", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
+  { "./data/tmpls_fingerprints/mfcuk_tmpl_oyster.mfd", "London OYSTER", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
    { "./data/tmpls_fingerprints/mfcuk_tmpl_oyster.mfd", "London OYSTER", mfcuk_finger_default_comparator, mfcuk_finger_default_decoder, NULL },
 };
-int mfcuk_finger_db_entries = sizeof(mfcuk_finger_db)/sizeof(mfcuk_finger_db[0]);
+int mfcuk_finger_db_entries = sizeof(mfcuk_finger_db) / sizeof(mfcuk_finger_db[0]);
 int mfcuk_finger_default_decoder(mifare_classic_tag *dump)
 {
-    if (!dump)
+  if (!dump) {
-    {
+    fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
-        fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
+    return 0;
-        return 0;
+  }
-    }
+
-    
+  printf("UID:\t%02x%02x%02x%02x\n", dump->amb[0].mbm.abtUID[0], dump->amb[0].mbm.abtUID[1], dump->amb[0].mbm.abtUID[2], dump->amb[0].mbm.abtUID[3]);
-    printf("UID:\t%02x%02x%02x%02x\n", dump->amb[0].mbm.abtUID[0], dump->amb[0].mbm.abtUID[1], dump->amb[0].mbm.abtUID[2], dump->amb[0].mbm.abtUID[3]);
+  printf("TYPE:\t%02x\n", dump->amb[0].mbm.btUnknown);
-    printf("TYPE:\t%02x\n", dump->amb[0].mbm.btUnknown);
+
-    
+  return 1;
    return 1;
 }
 // Yes, I know C++ class inheritance would perfectly fit the decoders/comparators... Though C is more to my heart. Anyone to rewrite in C++?
 int mfcuk_finger_skgt_decoder(mifare_classic_tag *dump)
 {
-    unsigned char *dump_ptr = NULL;
+  if (!dump) {
-    unsigned short car_number = 0;
+    fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
-    
+    return 0;
-    if (!dump)
+  }
-    {
+
-        fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
+  printf("Bulgaria/Sofia/SKGT public transport card information decoder (info credits to Andy)\n");
-        return 0;
+  mfcuk_finger_default_decoder(dump);
-    }
+
-    
+  printf("LAST TRAVEL DATA\n");
-    dump_ptr = (unsigned char *) dump;
+
-    
+  // TODO: get proper information
-    printf("Bulgaria/Sofia/SKGT public transport card information decoder (info credits to Andy)\n");
+
-    mfcuk_finger_default_decoder(dump);
+  return 1;
    printf("LAST TRAVEL DATA\n");
    // TODO: get proper information
    return 1;
 }
 int mfcuk_finger_default_comparator(mifare_classic_tag *dump, mfcuk_finger_template *tmpl, float *score)
 {
-    int max_bytes = 0;
+  int max_bytes = 0;
-    int i;
+  int i;
-    int num_bytes_tomatch = 0;
+  int num_bytes_tomatch = 0;
-    int num_bytes_matched = 0;
+  int num_bytes_matched = 0;
-    
+
-    if ( (!dump) || (!tmpl) || (!score) )
+  if ((!dump) || (!tmpl) || (!score)) {
-    {
+    return 0;
-        return 0;
+  }
  if (IS_MIFARE_CLASSIC_1K_TAG(dump)) {
    max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_1K_MAX_BLOCKS;
  } else if (IS_MIFARE_CLASSIC_4K_TAG(dump)) {
    max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_4K_MAX_BLOCKS;
  } else {
    return 0;
  }
  for (i = 0; i < max_bytes; i++) {
    if (((char *)(&tmpl->mask))[i] == 0x0) {
      continue;
    }
-    
+
-    if (IS_MIFARE_CLASSIC_1K_TAG(dump))
+    num_bytes_tomatch++;
-    {
+
-        max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_1K_MAX_BLOCKS;
+    if (((char *)(&tmpl->values))[i] == ((char *)dump)[i]) {
      num_bytes_matched++;
    }
-    else if (IS_MIFARE_CLASSIC_4K_TAG(dump))
+  }
-    {
+
-        max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_4K_MAX_BLOCKS;
+  if (num_bytes_tomatch == 0) {
-    }
+    return 0;
-    else
+  } else {
-    {
+    *score = (float)(num_bytes_matched) / num_bytes_tomatch;
-        return 0;
+  }
-    }
+
-    
+  return 1;
    for (i=0; i<max_bytes; i++)
    {
        if ( ((char *)(&tmpl->mask))[i] == 0x0 )
        {
            continue;
        }
        num_bytes_tomatch++;
        if ( ((char *)(&tmpl->values))[i] == ((char *)dump)[i] )
        {
            num_bytes_matched++;
        }
    }
    if (num_bytes_tomatch == 0)
    {
        return 0;
    }
    else
    {
        *score = (float)(num_bytes_matched)/num_bytes_tomatch;
    }
    return 1;
 }
-int mfcuk_finger_load()
+int mfcuk_finger_load(void)
 {
-    int i;
+  int i;
-    mifare_classic_tag mask;
+  mifare_classic_tag mask;
-    mifare_classic_tag values;
+  mifare_classic_tag values;
-    FILE *fp = NULL;
+  FILE *fp = NULL;
-    size_t result = 0;
+  size_t result = 0;
-    mfcuk_finger_template *tmpl_new = NULL;
+  mfcuk_finger_template *tmpl_new = NULL;
-    int template_loaded_count = 0;
+  int template_loaded_count = 0;
-    for (i = 0; i<mfcuk_finger_db_entries; i++)
+  for (i = 0; i < mfcuk_finger_db_entries; i++) {
-    {
+    fp = fopen(mfcuk_finger_db[i].tmpl_filename, "rb");
-        fp = fopen(mfcuk_finger_db[i].tmpl_filename, "rb");
+
-        
+    if (!fp) {
-        if (!fp)
+      fprintf(stderr, "WARN: cannot open template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
-        {
+      continue;
            fprintf(stderr, "WARN: cannot open template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
            continue;
        }
        // If not read exactly 1 record, something is wrong
        if ( (result = fread((void *)(&mask), sizeof(mask), 1, fp)) != 1)
        {
            fprintf(stderr, "WARN: cannot read MASK from template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
            fclose(fp);
            continue;
        }
        // If not read exactly 1 record, something is wrong
        if ( (result = fread((void *)(&values), sizeof(values), 1, fp)) != 1)
        {
            fprintf(stderr, "WARN: cannot read VALUES template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
            fclose(fp);
            continue;
        }
        if (mfcuk_finger_db[i].tmpl_data == NULL)
        {
            if ( (tmpl_new = (mfcuk_finger_template *) malloc(sizeof(mfcuk_finger_template))) == NULL)
            {
                fprintf(stderr, "WARN: cannot allocate memory to template record %d\n", i);
                fclose(fp);
                continue;
            }
            memcpy( &(tmpl_new->mask), &(mask), sizeof(mask));
            memcpy( &(tmpl_new->values), &(values), sizeof(values));
            mfcuk_finger_db[i].tmpl_data = tmpl_new;
            template_loaded_count++;
        }
        if (fp)
        {
            fclose(fp);
            fp = NULL;
        }
    }
-    
+
-    return template_loaded_count;
+    // If not read exactly 1 record, something is wrong
    if ((result = fread((void *)(&mask), sizeof(mask), 1, fp)) != 1) {
      fprintf(stderr, "WARN: cannot read MASK from template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
      fclose(fp);
      continue;
    }
    // If not read exactly 1 record, something is wrong
    if ((result = fread((void *)(&values), sizeof(values), 1, fp)) != 1) {
      fprintf(stderr, "WARN: cannot read VALUES template file '%s'\n", mfcuk_finger_db[i].tmpl_filename);
      fclose(fp);
      continue;
    }
    if (mfcuk_finger_db[i].tmpl_data == NULL) {
      if ((tmpl_new = (mfcuk_finger_template *) malloc(sizeof(mfcuk_finger_template))) == NULL) {
        fprintf(stderr, "WARN: cannot allocate memory to template record %d\n", i);
        fclose(fp);
        continue;
      }
      memcpy(&(tmpl_new->mask), &(mask), sizeof(mask));
      memcpy(&(tmpl_new->values), &(values), sizeof(values));
      mfcuk_finger_db[i].tmpl_data = tmpl_new;
      template_loaded_count++;
    }
    if (fp) {
      fclose(fp);
      fp = NULL;
    }
  }
  return template_loaded_count;
 }
-int mfcuk_finger_unload()
+int mfcuk_finger_unload(void)
 {
-    int i;
+  int i;
-    
+
-    for (i = 0; i<mfcuk_finger_db_entries; i++)
+  for (i = 0; i < mfcuk_finger_db_entries; i++) {
-    {
+    if (mfcuk_finger_db[i].tmpl_data != NULL) {
-        if (mfcuk_finger_db[i].tmpl_data != NULL)
+      free(mfcuk_finger_db[i].tmpl_data);
-        {
+      mfcuk_finger_db[i].tmpl_data = NULL;
            free(mfcuk_finger_db[i].tmpl_data);
            mfcuk_finger_db[i].tmpl_data = NULL;
        }
    }
-    
+  }
-    return 1;
+
  return 1;
 }
--- a/src/mfcuk_finger.h
+++ b/src/mfcuk_finger.h
@@ -5,23 +5,23 @@
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 2 of the License, or
 (at your option) any later version.
- 
+
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
- 
+
 You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 /*
 Package:
    MiFare Classic Universal toolKit (MFCUK)
- 
+
 Package version:
    0.1
- 
+
 Filename:
    mfcuk_finger.h
@@ -45,24 +45,22 @@
 #include "mfcuk_mifare.h"
 // Wrapping an ugly template into an externally pleasant name. To implement proper template later.
-typedef struct _mfcuk_finger_template_
+typedef struct _mfcuk_finger_template_ {
-{
+  mifare_classic_tag mask;
-    mifare_classic_tag mask;
+  mifare_classic_tag values;
    mifare_classic_tag values;
 } mfcuk_finger_template;
 // Function type definition, to be used for custom decoders/comparators
-typedef int (*mfcuk_finger_comparator) (mifare_classic_tag *dump, mfcuk_finger_template *tmpl, float *score);
+typedef int (*mfcuk_finger_comparator)(mifare_classic_tag *dump, mfcuk_finger_template *tmpl, float *score);
-typedef int (*mfcuk_finger_decoder) (mifare_classic_tag *dump);
+typedef int (*mfcuk_finger_decoder)(mifare_classic_tag *dump);
 // Naive implementation of a self-contained fingerprint database entry
-typedef struct _mfcuk_finger_tmpl_entry_
+typedef struct _mfcuk_finger_tmpl_entry_ {
-{
+  const char *tmpl_filename;
-    char *tmpl_filename;
+  const char *tmpl_name;
-    char *tmpl_name;
+  mfcuk_finger_comparator tmpl_comparison_func;
-    mfcuk_finger_comparator tmpl_comparison_func;
+  mfcuk_finger_decoder tmpl_decoder_func;
-    mfcuk_finger_decoder tmpl_decoder_func;
+  mfcuk_finger_template *tmpl_data;
    mfcuk_finger_template *tmpl_data;
 } mfcuk_finger_tmpl_entry;
 int mfcuk_finger_default_comparator(mifare_classic_tag *dump, mfcuk_finger_template *tmpl, float *score);
@@ -70,7 +68,7 @@ int mfcuk_finger_default_decoder(mifare_classic_tag *dump);
 int mfcuk_finger_skgt_decoder(mifare_classic_tag *dump);
 // "Housekeeping" functions
-int mfcuk_finger_load();
+int mfcuk_finger_load(void);
-int mfcuk_finger_unload();
+int mfcuk_finger_unload(void);
 #endif
--- a/src/mfcuk_mifare.c
+++ b/src/mfcuk_mifare.c
--- a/src/mfcuk_mifare.h
+++ b/src/mfcuk_mifare.h
@@ -1,145 +1,145 @@
-/*
+/*
- Package:
+ Package:
-    MiFare Classic Universal toolKit (MFCUK)
+    MiFare Classic Universal toolKit (MFCUK)
- 
+
- Package version:
+ Package version:
-    0.1
+    0.1
- 
+
- Filename:
+ Filename:
-    mfcuk_mifare.h
+    mfcuk_mifare.h
-
+
- Description:
+ Description:
-    MFCUK defines and function prototypes header file extending
+    MFCUK defines and function prototypes header file extending
-    mainly libnfc's "mifare.h" interface/functionality.
+    mainly libnfc's "mifare.h" interface/functionality.
-
+
- Contact, bug-reports:
+ Contact, bug-reports:
-    http://andreicostin.com/
+    http://andreicostin.com/
-    mailto:zveriu@gmail.com
+    mailto:zveriu@gmail.com
-
+
- License:
+ License:
-    GPL2 (see below), Copyright (C) 2009, Andrei Costin
+    GPL2 (see below), Copyright (C) 2009, Andrei Costin
-
+
- * @file mfcuk_mifare.h
+ * @file mfcuk_mifare.h
- * @brief 
+ * @brief
-*/
+*/
-
+
-/*
+/*
- VERSION HISTORY
+ VERSION HISTORY
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-| Number     : 0.1
+| Number     : 0.1
-| dd/mm/yyyy : 23/11/2009
+| dd/mm/yyyy : 23/11/2009
-| Author     : zveriu@gmail.com, http://andreicostin.com
+| Author     : zveriu@gmail.com, http://andreicostin.com
-| Description: Moved bulk of defines and functions from "mfcuk_keyrecovery_darkside.c"
+| Description: Moved bulk of defines and functions from "mfcuk_keyrecovery_darkside.c"
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-*/
+*/
-
+
-/*
+/*
- LICENSE
+ LICENSE
-
+
- This program is free software: you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
+ the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
+ (at your option) any later version.
- 
+
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+ GNU General Public License for more details.
- 
+
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+*/
-
+
-#ifndef _MFCUK_MIFARE_H_
+#ifndef _MFCUK_MIFARE_H_
-#define _MFCUK_MIFARE_H_
+#define _MFCUK_MIFARE_H_
-
+
-#include <stdio.h>
+#include <stdio.h>
-#include <stdlib.h>
+#include <stdlib.h>
-
+
-#include <nfc/nfc.h>
+#include <nfc/nfc.h>
-#include "mifare.h"
+#include "mifare.h"
-
+
-#define MIFARE_CLASSIC_UID_BYTELENGTH           4       // Length of a Mifare Classic UID in bytes
+#define MIFARE_CLASSIC_UID_BYTELENGTH           4       // Length of a Mifare Classic UID in bytes
-#define MIFARE_CLASSIC_KEY_BYTELENGTH           6       // Length of a Mifare Classic key in bytes
+#define MIFARE_CLASSIC_KEY_BYTELENGTH           6       // Length of a Mifare Classic key in bytes
-#define MIFARE_CLASSIC_1K_NAME                  "MC1K"
+#define MIFARE_CLASSIC_1K_NAME                  "MC1K"
-#define MIFARE_CLASSIC_4K_NAME                  "MC4K"
+#define MIFARE_CLASSIC_4K_NAME                  "MC4K"
-#define MIFARE_CLASSIC_UNKN_NAME                "UNKN"
+#define MIFARE_CLASSIC_UNKN_NAME                "UNKN"
-#define MIFARE_CLASSIC_1K                       0x08    // MF1ICS50 Functional Specifications - 0x08
+#define MIFARE_CLASSIC_1K                       0x08    // MF1ICS50 Functional Specifications - 0x08
-#define MIFARE_CLASSIC_4K                       0x18    // MF1ICS70 Functional Specifications - 0x18
+#define MIFARE_CLASSIC_4K                       0x18    // MF1ICS70 Functional Specifications - 0x18
-#define MIFARE_DESFIRE                          0x20    // XXXXXXXX Functional Specifications - 0x20
+#define MIFARE_DESFIRE                          0x20    // XXXXXXXX Functional Specifications - 0x20
-#define MIFARE_CLASSIC_1K_RATB                  0x88    // Infineon Licensed Mifare 1K = 0x88 (thanks JPS)
+#define MIFARE_CLASSIC_1K_RATB                  0x88    // Infineon Licensed Mifare 1K = 0x88 (thanks JPS)
-#define MIFARE_CLASSIC_4K_SKGT                  0x98    // Infineon Licensed Mifare 4K = 0x98???
+#define MIFARE_CLASSIC_4K_SKGT                  0x98    // Infineon Licensed Mifare 4K = 0x98???
-
+
-#define IS_MIFARE_CLASSIC_1K(ats_sak)           ( ((ats_sak) == MIFARE_CLASSIC_1K) || ((ats_sak) == MIFARE_CLASSIC_1K_RATB) )
+#define IS_MIFARE_CLASSIC_1K(ats_sak)           ( ((ats_sak) == MIFARE_CLASSIC_1K) || ((ats_sak) == MIFARE_CLASSIC_1K_RATB) )
-#define IS_MIFARE_CLASSIC_4K(ats_sak)           ( ((ats_sak) == MIFARE_CLASSIC_4K) || ((ats_sak) == MIFARE_CLASSIC_4K_SKGT) )
+#define IS_MIFARE_CLASSIC_4K(ats_sak)           ( ((ats_sak) == MIFARE_CLASSIC_4K) || ((ats_sak) == MIFARE_CLASSIC_4K_SKGT) )
-#define IS_MIFARE_DESFIRE(ats_sak)              ( ((ats_sak) == MIFARE_DESFIRE) )
+#define IS_MIFARE_DESFIRE(ats_sak)              ( ((ats_sak) == MIFARE_DESFIRE) )
-
+
-#define IS_MIFARE_CLASSIC_1K_TAG(tag)           IS_MIFARE_CLASSIC_1K(tag->amb[0].mbm.btUnknown)
+#define IS_MIFARE_CLASSIC_1K_TAG(tag)           IS_MIFARE_CLASSIC_1K(tag->amb[0].mbm.btUnknown)
-#define IS_MIFARE_CLASSIC_4K_TAG(tag)           IS_MIFARE_CLASSIC_4K(tag->amb[0].mbm.btUnknown)
+#define IS_MIFARE_CLASSIC_4K_TAG(tag)           IS_MIFARE_CLASSIC_4K(tag->amb[0].mbm.btUnknown)
-#define IS_MIFARE_DESFIRE_TAG(tag)              IS_MIFARE_DESFIRE(tag->amb[0].mbm.btUnknown)
+#define IS_MIFARE_DESFIRE_TAG(tag)              IS_MIFARE_DESFIRE(tag->amb[0].mbm.btUnknown)
-
+
-#define MIFARE_CLASSIC_BYTES_PER_BLOCK          16 // Common for Mifare Classic 1K and Mifare Classic 4K
+#define MIFARE_CLASSIC_BYTES_PER_BLOCK          16 // Common for Mifare Classic 1K and Mifare Classic 4K
-#define MIFARE_CLASSIC_INVALID_BLOCK            0xFFFFFFFF
+#define MIFARE_CLASSIC_INVALID_BLOCK            0xFFFFFFFF
-
+
-#define MIFARE_CLASSIC_1K_MAX_SECTORS           16
+#define MIFARE_CLASSIC_1K_MAX_SECTORS           16
-#define MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR     4
+#define MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR     4
-#define MIFARE_CLASSIC_1K_MAX_BLOCKS            ( (MIFARE_CLASSIC_1K_MAX_SECTORS) * (MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR) )
+#define MIFARE_CLASSIC_1K_MAX_BLOCKS            ( (MIFARE_CLASSIC_1K_MAX_SECTORS) * (MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR) )
-
+
-#define MIFARE_CLASSIC_4K_MAX_SECTORS1          32
+#define MIFARE_CLASSIC_4K_MAX_SECTORS1          32
-#define MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1    MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR // Possibly NXP made it for Mifare 1K backward compatibility
+#define MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1    MIFARE_CLASSIC_1K_BLOCKS_PER_SECTOR // Possibly NXP made it for Mifare 1K backward compatibility
-#define MIFARE_CLASSIC_4K_MAX_BLOCKS1           ( (MIFARE_CLASSIC_4K_MAX_SECTORS1) * (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) )
+#define MIFARE_CLASSIC_4K_MAX_BLOCKS1           ( (MIFARE_CLASSIC_4K_MAX_SECTORS1) * (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) )
-
+
-#define MIFARE_CLASSIC_4K_MAX_SECTORS2          8
+#define MIFARE_CLASSIC_4K_MAX_SECTORS2          8
-#define MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2    16
+#define MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2    16
-#define MIFARE_CLASSIC_4K_MAX_BLOCKS2           ( (MIFARE_CLASSIC_4K_MAX_SECTORS2) * (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) )
+#define MIFARE_CLASSIC_4K_MAX_BLOCKS2           ( (MIFARE_CLASSIC_4K_MAX_SECTORS2) * (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) )
-
+
-#define MIFARE_CLASSIC_4K_MAX_SECTORS           ( (MIFARE_CLASSIC_4K_MAX_SECTORS1) + (MIFARE_CLASSIC_4K_MAX_SECTORS2) )
+#define MIFARE_CLASSIC_4K_MAX_SECTORS           ( (MIFARE_CLASSIC_4K_MAX_SECTORS1) + (MIFARE_CLASSIC_4K_MAX_SECTORS2) )
-#define MIFARE_CLASSIC_4K_MAX_BLOCKS            ( (MIFARE_CLASSIC_4K_MAX_BLOCKS1) + (MIFARE_CLASSIC_4K_MAX_BLOCKS2) )
+#define MIFARE_CLASSIC_4K_MAX_BLOCKS            ( (MIFARE_CLASSIC_4K_MAX_BLOCKS1) + (MIFARE_CLASSIC_4K_MAX_BLOCKS2) )
-
+
-#define MFCUK_EXTENDED_DESCRIPTION_LENGTH       128
+#define MFCUK_EXTENDED_DESCRIPTION_LENGTH       128
-
+
-// Define an extended type of dump, basically a wrapper dump around basic tag dump
+// Define an extended type of dump, basically a wrapper dump around basic tag dump
-typedef struct {
+typedef struct {
-    uint32_t uid;  // looks redundant, but it is easier to use dmp.uid instead of dmp.amb.mbm.abtUID[0]...[3]
+  uint32_t uid;  // looks redundant, but it is easier to use dmp.uid instead of dmp.amb.mbm.abtUID[0]...[3]
-    byte_t type; // ATS/SAK from ti.tia.btSak, example 0x08h for Mifare 1K, 0x18h for Mifare 4K
+  uint8_t type; // ATS/SAK from ti.tia.btSak, example 0x08h for Mifare 1K, 0x18h for Mifare 4K
-    char datetime[14]; // non-zero-terminated date-time of dump in format YYYYMMDDH24MISS, example 20091114231541 - 14 Nov 2009, 11:15:41 PM
+  char datetime[14]; // non-zero-terminated date-time of dump in format YYYYMMDDH24MISS, example 20091114231541 - 14 Nov 2009, 11:15:41 PM
-    char description[MFCUK_EXTENDED_DESCRIPTION_LENGTH]; // a description of the tag dump, example "RATB_DUMP_BEFORE_PAY"
+  char description[MFCUK_EXTENDED_DESCRIPTION_LENGTH]; // a description of the tag dump, example "RATB_DUMP_BEFORE_PAY"
-    mifare_classic_tag tag_basic;
+  mifare_classic_tag tag_basic;
-} mifare_classic_tag_ext;
+} mifare_classic_tag_ext;
-
+
-// Define type of keys (A or B) in NXP notation
+// Define type of keys (A or B) in NXP notation
-typedef enum {
+typedef enum {
-    keyA = 0x60,
+  keyA = 0x60,
-    keyB = 0x61,
+  keyB = 0x61,
-} mifare_key_type;
+} mifare_key_type;
-
+
-// Default keys used as a *BIG* mistake in many applications - especially System Integrators should pay attention!
+// Default keys used as a *BIG* mistake in many applications - especially System Integrators should pay attention!
-extern byte_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH];
+extern uint8_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH];
-extern int mfcuk_default_keys_num;
+extern int mfcuk_default_keys_num;
-
+
-bool is_valid_block(byte_t bTagType, uint32_t uiBlock);
+bool is_valid_block(uint8_t bTagType, uint32_t uiBlock);
-bool is_valid_sector(byte_t bTagType, uint32_t uiSector);
+bool is_valid_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_first_block(byte_t bTagType, uint32_t uiBlock);
+bool is_first_block(uint8_t bTagType, uint32_t uiBlock);
-bool is_trailer_block(byte_t bTagType, uint32_t uiBlock);
+bool is_trailer_block(uint8_t bTagType, uint32_t uiBlock);
-uint32_t get_first_block(byte_t bTagType, uint32_t uiBlock);
+uint32_t get_first_block(uint8_t bTagType, uint32_t uiBlock);
-uint32_t get_trailer_block(byte_t bTagType, uint32_t uiBlock);
+uint32_t get_trailer_block(uint8_t bTagType, uint32_t uiBlock);
-bool is_big_sector(byte_t bTagType, uint32_t uiSector);
+bool is_big_sector(uint8_t bTagType, uint32_t uiSector);
-uint32_t get_first_block_for_sector(byte_t bTagType, uint32_t uiSector);
+uint32_t get_first_block_for_sector(uint8_t bTagType, uint32_t uiSector);
-uint32_t get_trailer_block_for_sector(byte_t bTagType, uint32_t uiSector);
+uint32_t get_trailer_block_for_sector(uint8_t bTagType, uint32_t uiSector);
-uint32_t get_sector_for_block(byte_t bTagType, uint32_t uiBlock);
+uint32_t get_sector_for_block(uint8_t bTagType, uint32_t uiBlock);
-bool is_first_sector(byte_t bTagType, uint32_t uiSector);
+bool is_first_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_first_big_sector(byte_t bTagType, uint32_t uiSector);
+bool is_first_big_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_first_small_sector(byte_t bTagType, uint32_t uiSector);
+bool is_first_small_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_last_sector(byte_t bTagType, uint32_t uiSector);
+bool is_last_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_last_big_sector(byte_t bTagType, uint32_t uiSector);
+bool is_last_big_sector(uint8_t bTagType, uint32_t uiSector);
-bool is_last_small_sector(byte_t bTagType, uint32_t uiSector);
+bool is_last_small_sector(uint8_t bTagType, uint32_t uiSector);
-void test_mifare_classic_blocks_sectors_functions(byte_t bTagType);
+void test_mifare_classic_blocks_sectors_functions(uint8_t bTagType);
-bool mfcuk_save_tag_dump(char *filename, mifare_classic_tag *tag);
+bool mfcuk_save_tag_dump(const char *filename, mifare_classic_tag *tag);
-bool mfcuk_save_tag_dump_ext(char *filename, mifare_classic_tag_ext *tag_ext);
+bool mfcuk_save_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_ext);
-bool mfcuk_load_tag_dump(char *filename, mifare_classic_tag *tag);
+bool mfcuk_load_tag_dump(const char *filename, mifare_classic_tag *tag);
-bool mfcuk_load_tag_dump_ext(char *filename, mifare_classic_tag_ext *tag_ext);
+bool mfcuk_load_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_ext);
-void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag);
+void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag);
-bool mfcuk_key_uint64_to_arr(const uint64_t *ui64Key, byte_t *arr6Key);
+bool mfcuk_key_uint64_to_arr(const uint64_t *ui64Key, uint8_t *arr6Key);
-bool mfcuk_key_arr_to_uint64(const byte_t *arr6Key, uint64_t *ui64Key);
+bool mfcuk_key_arr_to_uint64(const uint8_t *arr6Key, uint64_t *ui64Key);
-
+
-#endif // _MFCUK_MIFARE_H_
+#endif // _MFCUK_MIFARE_H_
--- a/src/mfcuk_utils.c
+++ b/src/mfcuk_utils.c
@@ -1,81 +1,107 @@
-/*
+/*
- Package:
+ Package:
-    MiFare Classic Universal toolKit (MFCUK)
+    MiFare Classic Universal toolKit (MFCUK)
- 
+
- Package version:
+ Package version:
-    0.1
+    0.1
- 
+
- Filename:
+ Filename:
-    mfcuk_utils.c
+    mfcuk_utils.c
-
+
- Description:
+ Description:
-    MFCUK common utility functions implementation.
+    MFCUK common utility functions implementation.
-
+
- License:
+ License:
-    GPL2 (see below), Copyright (C) 2009, Andrei Costin
+    GPL2 (see below), Copyright (C) 2009, Andrei Costin
-
+
- * @file mfcuk_utils.c
+ * @file mfcuk_utils.c
- * @brief 
+ * @brief
-*/
+*/
-
+
-/*
+/*
- VERSION HISTORY
+ VERSION HISTORY
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-| Number     : 0.1
+| Number     : 0.1
-| dd/mm/yyyy : 23/11/2009
+| dd/mm/yyyy : 23/11/2009
-| Author     : zveriu@gmail.com, http://andreicostin.com
+| Author     : zveriu@gmail.com, http://andreicostin.com
-| Description: Moved bulk of defines and prototypes from "mfcuk_keyrecovery_darkside.c"
+| Description: Moved bulk of defines and prototypes from "mfcuk_keyrecovery_darkside.c"
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-*/
+*/
-
+
-/*
+/*
- LICENSE
+ LICENSE
-
+
- This program is free software: you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
+ the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
+ (at your option) any later version.
- 
+
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+ GNU General Public License for more details.
- 
+
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+*/
-
+
-#include "mfcuk_utils.h"
+#include "config.h"
-
+
-#ifdef __STDC__
+#if defined(WIN32)
-    struct timeval global_timeout;
+#include <windows.h>
-#endif
+#elif defined(HAVE_UNISTD_H)
-
+#include <unistd.h>
-/*
+#else
-http://www.velocityreviews.com/forums/t451319-advice-required-on-my-ascii-to-hex-conversion-c.html
+#error "Unsupported system"
-Basically, converting a hex digit into a hex nibble (4 binary digits) algorithm looks like;
+#endif
-        char xdigit; // hex digit to convert [0-9A-Fa-f]
+
-        xdigit = tolower(xdigit); // make it lowercase [0-9a-f]
+#include "mfcuk_utils.h"
-        xdigit -= '0'; // if it was a [0-9] digit, it's the value now
+#include <stdio.h>
-        if(xdigit > 9) // if it was a [a-f] digit, compensate for that
+
-        xdigit = xdigit + '0' - 'a';
+/*
-The below code is just an optimization of the algorithm. Maxim Yegorushkin
+http://www.velocityreviews.com/forums/t451319-advice-required-on-my-ascii-to-hex-conversion-c.html
-*/
+Basically, converting a hex digit into a hex nibble (4 binary digits) algorithm looks like;
-
+        char xdigit; // hex digit to convert [0-9A-Fa-f]
-/*inline*/
+        xdigit = tolower(xdigit); // make it lowercase [0-9a-f]
-int is_hex(char c)
+        xdigit -= '0'; // if it was a [0-9] digit, it's the value now
-{
+        if(xdigit > 9) // if it was a [a-f] digit, compensate for that
-    return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
+        xdigit = xdigit + '0' - 'a';
-}
+The below code is just an optimization of the algorithm. Maxim Yegorushkin
-
+*/
-/*inline*/
+
-unsigned char hex2bin(unsigned char h, unsigned char l)
+/*inline*/
-{
+int is_hex(char c)
-    h |= 0x20; // to lower
+{
-    h -= 0x30;
+  return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
-    h -= -(h > 9) & 0x27;
+}
-    l |= 0x20;
+
-    l -= 0x30;
+/*inline*/
-    l -= -(l > 9) & 0x27;
+unsigned char hex2bin(unsigned char h, unsigned char l)
-    return h << 4 | l;
+{
-}
+  h |= 0x20; // to lower
  h -= 0x30;
  h -= -(h > 9) & 0x27;
  l |= 0x20;
  l -= 0x30;
  l -= -(l > 9) & 0x27;
  return h << 4 | l;
 }
 void sleepmillis(unsigned int millis)
 {
 #ifdef WIN32 // If system is Windows, use system's own function if possible to reduce overhead, even if a standard C library is available
  Sleep(millis);
 #else
  usleep(millis * 1000);
 #endif
 }
 void clear_screen()
 {
 #ifdef WIN32 // On Windows, use "cls" command
  system("cls");
 #else // Otherwise fall back to TTY control characters
  printf("\033[1;1H\033[J");
 #endif
 }
--- a/src/mfcuk_utils.h
+++ b/src/mfcuk_utils.h
@@ -1,82 +1,53 @@
-/*
+/*
- Package:
+ Package:
-    MiFare Classic Universal toolKit (MFCUK)
+    MiFare Classic Universal toolKit (MFCUK)
- 
+
- Package version:
+ Package version:
-    0.1
+    0.1
- 
+
- Filename:
+ Filename:
-    mfcuk_utils.h
+    mfcuk_utils.h
-
+
- Description:
+ Description:
-    MFCUK common utility functions prototypes.
+    MFCUK common utility functions prototypes.
-
+
- License:
+ License:
-    GPL2 (see below), Copyright (C) 2009, Andrei Costin
+    GPL2 (see below), Copyright (C) 2009, Andrei Costin
-
+
- * @file mfcuk_utils.h/
+ * @file mfcuk_utils.h/
- * @brief 
+ * @brief
-*/
+*/
-
+
-/*
+/*
- VERSION HISTORY
+ VERSION HISTORY
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-| Number     : 0.1
+| Number     : 0.1
-| dd/mm/yyyy : 23/11/2009
+| dd/mm/yyyy : 23/11/2009
-| Author     : zveriu@gmail.com, http://andreicostin.com
+| Author     : zveriu@gmail.com, http://andreicostin.com
-| Description: Moved bulk of defines and prototypes from "mfcuk_keyrecovery_darkside.c"
+| Description: Moved bulk of defines and prototypes from "mfcuk_keyrecovery_darkside.c"
--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
-*/
+*/
-
+
-/*
+/*
- LICENSE
+ LICENSE
-
+
- This program is free software: you can redistribute it and/or modify
+ This program is free software: you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
+ it under the terms of the GNU General Public License as published by
- the Free Software Foundation, either version 2 of the License, or
+ the Free Software Foundation, either version 2 of the License, or
- (at your option) any later version.
+ (at your option) any later version.
- 
+
- This program is distributed in the hope that it will be useful,
+ This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- GNU General Public License for more details.
+ GNU General Public License for more details.
- 
+
- You should have received a copy of the GNU General Public License
+ You should have received a copy of the GNU General Public License
- along with this program.  If not, see <http://www.gnu.org/licenses/>. 
+ along with this program.  If not, see <http://www.gnu.org/licenses/>.
-*/
+*/
-
+
-#ifndef _MFCUK_UTILS_H_
+#ifndef _MFCUK_UTILS_H_
-#define _MFCUK_UTILS_H_
+#define _MFCUK_UTILS_H_
-
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifdef WIN32
    #define NOMINMAX
    #include "windows.h"
    #include "xgetopt.h"
 #elif __STDC__
    #include <unistd.h>
    #include <sys/time.h>
    #include <sys/types.h>
 #endif
 // "Portable" sleep(miliseconds)
 #ifdef WIN32
    #define sleep(x) Sleep(x)
 #elif __STDC__
    extern struct timeval global_timeout;
    #define sleep(x) { global_timeout.tv_usec = 1000 * (x); select(0,NULL,NULL,NULL,&global_timeout); }
 #endif
 // "Portable" clear_screen() - NOTE: system performance penalty introduced
 #ifdef WIN32
    #define clear_screen()  system("cls")
 #elif __STDC__
    #define clear_screen()  system("sh -c clear")
 #endif
 /**
 * @fn int is_hex(char c)
 * @brief Checks if an ASCII character is a valid hexadecimal base digit
@@ -85,9 +56,9 @@
 *
 * Checks if an ASCII character is a valid hexadecimal base digit.
 * Used for hex2bin() functionality.
- */
+ */
-int is_hex(char c);
+int is_hex(char c);
-
+
 /**
 * @fn unsigned char hex2bin(unsigned char h, unsigned char l)
 * @brief Converts from two nibbles (4 bits) into the corresponding byte
@@ -98,7 +69,26 @@ int is_hex(char c);
 * Converts from two nibbles (4 bits) into the corresponding byte.
 * Uses the algorithm and implementation from here:
 * http://www.velocityreviews.com/forums/t451319-advice-required-on-my-ascii-to-hex-conversion-c.html
- */
+ */
-unsigned char hex2bin(unsigned char h, unsigned char l);
+unsigned char hex2bin(unsigned char h, unsigned char l);
-
+
-#endif // _MFCUK_UTILS_H_
+/**
 * @fn void sleepmillis(unsigned int millis)
 * @brief Pauses execution for a certain amount of milliseconds
 * @param millis Number of milliseconds to sleep
 *
 * Wrapper for system-dependant sleep function. It pauses execution for a certain amount of milliseconds.
 */
 void sleepmillis(unsigned int millis);
 /**
 * @fn void clear_screen(void);
 * @brief Clears output console
 *
 * Wrapper for system-dependant clear screen function.
 * Resets output console, clearing text and resetting character pointer.
 */
 void clear_screen(void);
 #endif // _MFCUK_UTILS_H_
--- a/src/mifare.c
+++ b/src/mifare.c
@@ -1,13 +1,14 @@
 /*-
 * Public platform independent Near Field Communication (NFC) library examples
- * 
+ *
- * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2009 Roel Verdult
- * Copyright (C) 2010, Romuald Conty, Romain Tartière
+ * Copyright (C) 2010 Romain Tartière
- * 
+ * Copyright (C) 2010, 2011 Romuald Conty
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  1) Redistributions of source code must retain the above copyright notice,
- *  this list of conditions and the following disclaimer. 
+ *  this list of conditions and the following disclaimer.
 *  2 )Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
@@ -23,11 +24,14 @@
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
 * Note that this license only applies on the examples, NFC library itself is under LGPL
 *
 */
-
+/**
 * @file mifare.c
 * @brief provide samples structs and functions to manipulate MIFARE Classic and Ultralight tags using libnfc
 */
 #include "mifare.h"
 #include <string.h>
@@ -42,85 +46,88 @@
 * The specified MIFARE command will be executed on the tag. There are different commands possible, they all require the destination block number.
 * @note There are three different types of information (Authenticate, Data and Value).
 *
- * First an authentication must take place using Key A or B. It requires a 48 bit Key (6 bytes) and the UID. 
+ * First an authentication must take place using Key A or B. It requires a 48 bit Key (6 bytes) and the UID.
 * They are both used to initialize the internal cipher-state of the PN53X chip (http://libnfc.org/hardware/pn53x-chip).
- * After a successful authentication it will be possible to execute other commands (e.g. Read/Write). 
+ * After a successful authentication it will be possible to execute other commands (e.g. Read/Write).
 * The MIFARE Classic Specification (http://www.nxp.com/acrobat/other/identification/M001053_MF1ICS50_rev5_3.pdf) explains more about this process.
 */
 bool
-nfc_initiator_mifare_cmd (nfc_device_t * pnd, const mifare_cmd mc, const uint8_t ui8Block, mifare_param * pmp)
+nfc_initiator_mifare_cmd(nfc_device *pnd, const mifare_cmd mc, const uint8_t ui8Block, mifare_param *pmp)
 {
-  byte_t  abtRx[265];
+  uint8_t  abtRx[265];
  size_t  szRx = sizeof(abtRx);
  size_t  szParamLen;
-  byte_t  abtCmd[265];
+  uint8_t  abtCmd[265];
-  bool    bEasyFraming;
+  //bool    bEasyFraming;
  abtCmd[0] = mc;               // The MIFARE Classic command
  abtCmd[1] = ui8Block;         // The block address (1K=0x00..0x39, 4K=0x00..0xff)
  switch (mc) {
-    // Read and store command have no parameter
+      // Read and store command have no parameter
-  case MC_READ:
+    case MC_READ:
-  case MC_STORE:
+    case MC_STORE:
-    szParamLen = 0;
+      szParamLen = 0;
-    break;
+      break;
-    // Authenticate command
+      // Authenticate command
-  case MC_AUTH_A:
+    case MC_AUTH_A:
-  case MC_AUTH_B:
+    case MC_AUTH_B:
-    szParamLen = sizeof (mifare_param_auth);
+      szParamLen = sizeof(struct mifare_param_auth);
-    break;
+      break;
-    // Data command
+      // Data command
-  case MC_WRITE:
+    case MC_WRITE:
-    szParamLen = sizeof (mifare_param_data);
+      szParamLen = sizeof(struct mifare_param_data);
-    break;
+      break;
-    // Value command
+      // Value command
-  case MC_DECREMENT:
+    case MC_DECREMENT:
-  case MC_INCREMENT:
+    case MC_INCREMENT:
-  case MC_TRANSFER:
+    case MC_TRANSFER:
-    szParamLen = sizeof (mifare_param_value);
+      szParamLen = sizeof(struct mifare_param_value);
-    break;
+      break;
-    // Please fix your code, you never should reach this statement
+      // Please fix your code, you never should reach this statement
-  default:
+    default:
-    return false;
+      return false;
-    break;
+      break;
  }
  // When available, copy the parameter bytes
  if (szParamLen)
-    memcpy (abtCmd + 2, (byte_t *) pmp, szParamLen);
+    memcpy(abtCmd + 2, (uint8_t *) pmp, szParamLen);
-  bEasyFraming = pnd->bEasyFraming;
+  // FIXME: Save and restore bEasyFraming
-  if (!nfc_configure (pnd, NDO_EASY_FRAMING, true)) {
+  // bEasyFraming = nfc_device_get_property_bool (pnd, NP_EASY_FRAMING, &bEasyFraming);
-    nfc_perror (pnd, "nfc_configure");
+  if (nfc_device_set_property_bool(pnd, NP_EASY_FRAMING, true) < 0) {
    nfc_perror(pnd, "nfc_device_set_property_bool");
    return false;
  }
  // Fire the mifare command
-  if (!nfc_initiator_transceive_bytes (pnd, abtCmd, 2 + szParamLen, abtRx, &szRx, NULL)) {
+  int res;
-    if (pnd->iLastError == EINVRXFRAM) {
+  if ((res = nfc_initiator_transceive_bytes(pnd, abtCmd, 2 + szParamLen, abtRx, sizeof(abtRx), -1))  < 0) {
-      // "Invalid received frame" AKA EINVRXFRAM,  usual means we are
+    if (res == NFC_ERFTRANS) {
      // "Invalid received frame",  usual means we are
      // authenticated on a sector but the requested MIFARE cmd (read, write)
      // is not permitted by current acces bytes;
      // So there is nothing to do here.
    } else {
-      nfc_perror (pnd, "nfc_initiator_transceive_bytes");
+      nfc_perror(pnd, "nfc_initiator_transceive_bytes");
    }
-    nfc_configure (pnd, NDO_EASY_FRAMING, bEasyFraming);
+    // XXX nfc_device_set_property_bool (pnd, NP_EASY_FRAMING, bEasyFraming);
    return false;
  }
-  if (!nfc_configure (pnd, NDO_EASY_FRAMING, bEasyFraming)) {
+  /* XXX
-    nfc_perror (pnd, "nfc_configure");
+  if (nfc_device_set_property_bool (pnd, NP_EASY_FRAMING, bEasyFraming) < 0) {
    nfc_perror (pnd, "nfc_device_set_property_bool");
    return false;
  }
  */
  // When we have executed a read command, copy the received bytes into the param
  if (mc == MC_READ) {
-    if (szRx == 16) {
+    if (res == 16) {
-      memcpy (pmp->mpd.abtData, abtRx, 16);
+      memcpy(pmp->mpd.abtData, abtRx, 16);
    } else {
      return false;
    }
--- a/src/mifare.h
+++ b/src/mifare.h
@@ -1,13 +1,14 @@
 /*-
 * Public platform independent Near Field Communication (NFC) library examples
- * 
+ *
- * Copyright (C) 2009, Roel Verdult
+ * Copyright (C) 2009 Roel Verdult
- * Copyright (C) 2010, Romuald Conty, Romain Tartière
+ * Copyright (C) 2010 Romain Tartière
- * 
+ * Copyright (C) 2010, 2011 Romuald Conty
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  1) Redistributions of source code must retain the above copyright notice,
- *  this list of conditions and the following disclaimer. 
+ *  this list of conditions and the following disclaimer.
 *  2 )Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
@@ -23,13 +24,13 @@
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
 * Note that this license only applies on the examples, NFC library itself is under LGPL
 *
 */
 /**
- * @file mifaretag.h
+ * @file mifare.h
 * @brief provide samples structs and functions to manipulate MIFARE Classic and Ultralight tags using libnfc
 */
@@ -38,7 +39,7 @@
 #  include <nfc/nfc-types.h>
-// Compiler directive, set struct alignment to 1 byte_t for compatibility
+// Compiler directive, set struct alignment to 1 uint8_t for compatibility
 #  pragma pack(1)
 typedef enum {
@@ -53,50 +54,50 @@ typedef enum {
 } mifare_cmd;
 // MIFARE command params
-typedef struct {
+struct mifare_param_auth {
-  byte_t  abtKey[6];
+  uint8_t  abtKey[6];
-  byte_t  abtUid[4];
+  uint8_t  abtAuthUid[4];
-} mifare_param_auth;
+};
-typedef struct {
+struct mifare_param_data {
-  byte_t  abtData[16];
+  uint8_t  abtData[16];
-} mifare_param_data;
+};
-typedef struct {
+struct mifare_param_value {
-  byte_t  abtValue[4];
+  uint8_t  abtValue[4];
-} mifare_param_value;
+};
 typedef union {
-  mifare_param_auth mpa;
+  struct mifare_param_auth mpa;
-  mifare_param_data mpd;
+  struct mifare_param_data mpd;
-  mifare_param_value mpv;
+  struct mifare_param_value mpv;
 } mifare_param;
 // Reset struct alignment to default
 #  pragma pack()
-bool    nfc_initiator_mifare_cmd (nfc_device_t * pnd, const mifare_cmd mc, const uint8_t ui8Block, mifare_param * pmp);
+bool    nfc_initiator_mifare_cmd(nfc_device *pnd, const mifare_cmd mc, const uint8_t ui8Block, mifare_param *pmp);
-// Compiler directive, set struct alignment to 1 byte_t for compatibility
+// Compiler directive, set struct alignment to 1 uint8_t for compatibility
 #  pragma pack(1)
 // MIFARE Classic
 typedef struct {
-  byte_t  abtUID[4];
+  uint8_t  abtUID[4];
-  byte_t  btBCC;
+  uint8_t  btBCC;
-  byte_t  btUnknown;
+  uint8_t  btUnknown;
-  byte_t  abtATQA[2];
+  uint8_t  abtATQA[2];
-  byte_t  abtUnknown[8];
+  uint8_t  abtUnknown[8];
 } mifare_classic_block_manufacturer;
 typedef struct {
-  byte_t  abtData[16];
+  uint8_t  abtData[16];
 } mifare_classic_block_data;
 typedef struct {
-  byte_t  abtKeyA[6];
+  uint8_t  abtKeyA[6];
-  byte_t  abtAccessBits[4];
+  uint8_t  abtAccessBits[4];
-  byte_t  abtKeyB[6];
+  uint8_t  abtKeyB[6];
 } mifare_classic_block_trailer;
 typedef union {
@@ -111,17 +112,17 @@ typedef struct {
 // MIFARE Ultralight
 typedef struct {
-  byte_t  sn0[3];
+  uint8_t  sn0[3];
-  byte_t  btBCC0;
+  uint8_t  btBCC0;
-  byte_t  sn1[4];
+  uint8_t  sn1[4];
-  byte_t  btBCC1;
+  uint8_t  btBCC1;
-  byte_t  internal;
+  uint8_t  internal;
-  byte_t  lock[2];
+  uint8_t  lock[2];
-  byte_t  otp[4];
+  uint8_t  otp[4];
 } mifareul_block_manufacturer;
 typedef struct {
-  byte_t  abtData[16];
+  uint8_t  abtData[16];
 } mifareul_block_data;
 typedef union {
--- a/src/nfc-utils.c
+++ b/src/nfc-utils.c
@@ -1,13 +1,18 @@
 /*-
- * Public platform independent Near Field Communication (NFC) library examples
+ * Free/Libre Near Field Communication (NFC) library
- * 
+ *
- * Copyright (C) 2009, Roel Verdult
+ * Libnfc historical contributors:
- * Copyright (C) 2010, Romuald Conty, Romain Tartière
+ * Copyright (C) 2009      Roel Verdult
- * 
+ * Copyright (C) 2009-2013 Romuald Conty
 * Copyright (C) 2010-2012 Romain Tartière
 * Copyright (C) 2010-2013 Philippe Teuwen
 * Copyright (C) 2012-2013 Ludovic Rousseau
 * Additional contributors of this file:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  1) Redistributions of source code must retain the above copyright notice,
- *  this list of conditions and the following disclaimer. 
+ *  this list of conditions and the following disclaimer.
 *  2 )Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
@@ -23,97 +28,82 @@
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
 * Note that this license only applies on the examples, NFC library itself is under LGPL
 *
 */
-
+/**
 * @file nfc-utils.c
 * @brief Provide some examples shared functions like print, parity calculation, options parsing.
 */
 #include <nfc/nfc.h>
 #include <err.h>
 #include "nfc-utils.h"
-static const byte_t OddParity[256] = {
+uint8_t
-  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
+oddparity(const uint8_t bt)
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0,
  1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1
 };
 byte_t
 oddparity (const byte_t bt)
 {
-  return OddParity[bt];
+  // cf http://graphics.stanford.edu/~seander/bithacks.html#ParityParallel
  return (0x9669 >> ((bt ^(bt >> 4)) & 0xF)) & 1;
 }
 void
-oddparity_bytes_ts (const byte_t * pbtData, const size_t szLen, byte_t * pbtPar)
+oddparity_bytes_ts(const uint8_t *pbtData, const size_t szLen, uint8_t *pbtPar)
 {
  size_t  szByteNr;
  // Calculate the parity bits for the command
  for (szByteNr = 0; szByteNr < szLen; szByteNr++) {
-    pbtPar[szByteNr] = OddParity[pbtData[szByteNr]];
+    pbtPar[szByteNr] = oddparity(pbtData[szByteNr]);
  }
 }
 void
-print_hex (const byte_t * pbtData, const size_t szBytes)
+print_hex(const uint8_t *pbtData, const size_t szBytes)
 {
  size_t  szPos;
  for (szPos = 0; szPos < szBytes; szPos++) {
-    printf ("%02x  ", pbtData[szPos]);
+    printf("%02x  ", pbtData[szPos]);
  }
-  printf ("\n");
+  printf("\n");
 }
 void
-print_hex_bits (const byte_t * pbtData, const size_t szBits)
+print_hex_bits(const uint8_t *pbtData, const size_t szBits)
 {
  uint8_t uRemainder;
  size_t  szPos;
  size_t  szBytes = szBits / 8;
  for (szPos = 0; szPos < szBytes; szPos++) {
-    printf ("%02x  ", pbtData[szPos]);
+    printf("%02x  ", pbtData[szPos]);
  }
  uRemainder = szBits % 8;
  // Print the rest bits
  if (uRemainder != 0) {
    if (uRemainder < 5)
-      printf ("%01x (%d bits)", pbtData[szBytes], uRemainder);
+      printf("%01x (%d bits)", pbtData[szBytes], uRemainder);
    else
-      printf ("%02x (%d bits)", pbtData[szBytes], uRemainder);
+      printf("%02x (%d bits)", pbtData[szBytes], uRemainder);
  }
-  printf ("\n");
+  printf("\n");
 }
 void
-print_hex_par (const byte_t * pbtData, const size_t szBits, const byte_t * pbtDataPar)
+print_hex_par(const uint8_t *pbtData, const size_t szBits, const uint8_t *pbtDataPar)
 {
  uint8_t uRemainder;
  size_t  szPos;
  size_t  szBytes = szBits / 8;
  for (szPos = 0; szPos < szBytes; szPos++) {
-    printf ("%02x", pbtData[szPos]);
+    printf("%02x", pbtData[szPos]);
-    if (OddParity[pbtData[szPos]] != pbtDataPar[szPos]) {
+    if (oddparity(pbtData[szPos]) != pbtDataPar[szPos]) {
-      printf ("! ");
+      printf("! ");
    } else {
-      printf ("  ");
+      printf("  ");
    }
  }
@@ -121,614 +111,18 @@ print_hex_par (const byte_t * pbtData, const size_t szBits, const byte_t * pbtDa
  // Print the rest bits, these cannot have parity bit
  if (uRemainder != 0) {
    if (uRemainder < 5)
-      printf ("%01x (%d bits)", pbtData[szBytes], uRemainder);
+      printf("%01x (%d bits)", pbtData[szBytes], uRemainder);
    else
-      printf ("%02x (%d bits)", pbtData[szBytes], uRemainder);
+      printf("%02x (%d bits)", pbtData[szBytes], uRemainder);
  }
  printf ("\n");
 }
 #define SAK_UID_NOT_COMPLETE     0x04
 #define SAK_ISO14443_4_COMPLIANT 0x20
 #define SAK_ISO18092_COMPLIANT   0x40
 void
 print_nfc_iso14443a_info (const nfc_iso14443a_info_t nai, bool verbose)
 {
  printf ("    ATQA (SENS_RES): ");
  print_hex (nai.abtAtqa, 2);
  if (verbose) {
    printf("* UID size: ");
    switch ((nai.abtAtqa[1] & 0xc0)>>6) {
      case 0:
        printf("single\n");
      break;
      case 1:
        printf("double\n");
      break;
      case 2:
        printf("triple\n");
      break;
      case 3:
        printf("RFU\n");
      break;
    }
    printf("* bit frame anticollision ");
    switch (nai.abtAtqa[1] & 0x1f) {
      case 0x01:
      case 0x02:
      case 0x04:
      case 0x08:
      case 0x10:
        printf("supported\n");
      break;
      default:
        printf("not supported\n");
      break;
    }
  }
  printf ("       UID (NFCID%c): ", (nai.abtUid[0] == 0x08 ? '3' : '1'));
  print_hex (nai.abtUid, nai.szUidLen);
  if (verbose) {
    if (nai.abtUid[0] == 0x08) {
      printf ("* Random UID\n");
    }
  }
  printf ("      SAK (SEL_RES): ");
  print_hex (&nai.btSak, 1);
  if (verbose) {
    if (nai.btSak & SAK_UID_NOT_COMPLETE) {
      printf ("* Warning! Cascade bit set: UID not complete\n");
    }
    if (nai.btSak & SAK_ISO14443_4_COMPLIANT) {
      printf ("* Compliant with ISO/IEC 14443-4\n");
    } else {
      printf ("* Not compliant with ISO/IEC 14443-4\n");
    }
    if (nai.btSak & SAK_ISO18092_COMPLIANT) {
      printf ("* Compliant with ISO/IEC 18092\n");
    } else {
      printf ("* Not compliant with ISO/IEC 18092\n");
    }
  }
  if (nai.szAtsLen) {
    printf ("                ATS: ");
    print_hex (nai.abtAts, nai.szAtsLen);
  }
  if (nai.szAtsLen && verbose) {
    // Decode ATS according to ISO/IEC 14443-4 (5.2 Answer to select)
    const int iMaxFrameSizes[] = { 16, 24, 32, 40, 48, 64, 96, 128, 256 };
    printf ("* Max Frame Size accepted by PICC: %d bytes\n", iMaxFrameSizes[nai.abtAts[0] & 0x0F]);
    size_t offset = 1;
    if (nai.abtAts[0] & 0x10) { // TA(1) present
      byte_t TA = nai.abtAts[offset];
      offset++;
      printf ("* Bit Rate Capability:\n");
      if (TA == 0) {
        printf ("  * PICC supports only 106 kbits/s in both directions\n");
      }
      if (TA & 1<<7) {
        printf ("  * Same bitrate in both directions mandatory\n");
      }
      if (TA & 1<<4) {
        printf ("  * PICC to PCD, DS=2, bitrate 212 kbits/s supported\n");
      }
      if (TA & 1<<5) {
        printf ("  * PICC to PCD, DS=4, bitrate 424 kbits/s supported\n");
      }
      if (TA & 1<<6) {
        printf ("  * PICC to PCD, DS=8, bitrate 847 kbits/s supported\n");
      }
      if (TA & 1<<0) {
        printf ("  * PCD to PICC, DR=2, bitrate 212 kbits/s supported\n");
      }
      if (TA & 1<<1) {
        printf ("  * PCD to PICC, DR=4, bitrate 424 kbits/s supported\n");
      }
      if (TA & 1<<2) {
        printf ("  * PCD to PICC, DR=8, bitrate 847 kbits/s supported\n");
      }
      if (TA & 1<<3) {
        printf ("  * ERROR unknown value\n");
      }
    }
    if (nai.abtAts[0] & 0x20) { // TB(1) present
      byte_t TB= nai.abtAts[offset];
      offset++;
      printf ("* Frame Waiting Time: %.4g ms\n",256.0*16.0*(1<<((TB & 0xf0) >> 4))/13560.0);
      if ((TB & 0x0f) == 0) {
        printf ("* No Start-up Frame Guard Time required\n");
      } else {
        printf ("* Start-up Frame Guard Time: %.4g ms\n",256.0*16.0*(1<<(TB & 0x0f))/13560.0);
      }
    }
    if (nai.abtAts[0] & 0x40) { // TC(1) present
      byte_t TC = nai.abtAts[offset];
      offset++;
      if (TC & 0x1) {
        printf("* Node ADdress supported\n");
      } else {
        printf("* Node ADdress not supported\n");
      }
      if (TC & 0x2) {
        printf("* Card IDentifier supported\n");
      } else {
        printf("* Card IDentifier not supported\n");
      }
    }
    if (nai.szAtsLen > offset) {
      printf ("* Historical bytes Tk: " );
      print_hex (nai.abtAts + offset, (nai.szAtsLen - offset));
      byte_t CIB = nai.abtAts[offset];
      offset++;
      if (CIB != 0x00 && CIB != 0x10 && (CIB & 0xf0) != 0x80) {
        printf("  * Proprietary format\n");
        if (CIB == 0xc1) {
          printf("    * Tag byte: Mifare or virtual cards of various types\n");
          byte_t L = nai.abtAts[offset];
          offset++;
          if (L != (nai.szAtsLen - offset)) {
            printf("    * Warning: Type Identification Coding length (%i)", L);
            printf(" not matching Tk length (%zi)\n", (nai.szAtsLen - offset));
          }
          if ((nai.szAtsLen - offset - 2) > 0) { // Omit 2 CRC bytes
            byte_t CTC = nai.abtAts[offset];
            offset++;
            printf("    * Chip Type: ");
            switch (CTC & 0xf0) {
              case 0x00:
                printf("(Multiple) Virtual Cards\n");
              break;
              case 0x10:
                printf("Mifare DESFire\n");
              break;
              case 0x20:
                printf("Mifare Plus\n");
              break;
              default:
                printf("RFU\n");
              break;
            }
            printf("    * Memory size: ");
            switch (CTC & 0x0f) {
              case 0x00:
                printf("<1 kbyte\n");
              break;
              case 0x01:
                printf("1 kbyte\n");
              break;
              case 0x02:
                printf("2 kbyte\n");
              break;
              case 0x03:
                printf("4 kbyte\n");
              break;
              case 0x04:
                printf("8 kbyte\n");
              break;
              case 0x0f:
                printf("Unspecified\n");
              break;
              default:
                printf("RFU\n");
              break;
            }
          }
          if ((nai.szAtsLen - offset) > 0) { // Omit 2 CRC bytes
            byte_t CVC = nai.abtAts[offset];
            offset++;
            printf("    * Chip Status: ");
            switch (CVC & 0xf0) {
              case 0x00:
                printf("Engineering sample\n");
              break;
              case 0x20:
                printf("Released\n");
              break;
              default:
                printf("RFU\n");
              break;
            }
            printf("    * Chip Generation: ");
            switch (CVC & 0x0f) {
              case 0x00:
                printf("Generation 1\n");
              break;
              case 0x01:
                printf("Generation 2\n");
              break;
              case 0x02:
                printf("Generation 3\n");
              break;
              case 0x0f:
                printf("Unspecified\n");
              break;
              default:
                printf("RFU\n");
              break;
            }
          }
          if ((nai.szAtsLen - offset) > 0) { // Omit 2 CRC bytes
            byte_t VCS = nai.abtAts[offset];
            offset++;
            printf("    * Specifics (Virtual Card Selection):\n");
            if ((VCS & 0x09) == 0x00) {
              printf("      * Only VCSL supported\n");
            } else if ((VCS & 0x09) == 0x01) {
              printf("      * VCS, VCSL and SVC supported\n");
            }
            if ((VCS & 0x0e) == 0x00) {
              printf("      * SL1, SL2(?), SL3 supported\n");
            } else if ((VCS & 0x0e) == 0x02) {
              printf("      * SL3 only card\n");
            } else if ((VCS & 0x0f) == 0x0e) {
              printf("      * No VCS command supported\n");
            } else if ((VCS & 0x0f) == 0x0f) {
              printf("      * Unspecified\n");
            } else {
              printf("      * RFU\n");
            }
          }
        }
      } else {
        if (CIB == 0x00) {
          printf("  * Tk after 0x00 consist of optional consecutive COMPACT-TLV data objects\n");
          printf("    followed by a mandatory status indicator (the last three bytes, not in TLV)\n");
          printf("    See ISO/IEC 7816-4 8.1.1.3 for more info\n");
        }
        if (CIB == 0x10) {
          printf("  * DIR data reference: %02x\n", nai.abtAts[offset]);
        }
        if (CIB == 0x80) {
          if (nai.szAtsLen == offset) {
            printf("  * No COMPACT-TLV objects found, no status found\n");
          } else {
            printf("  * Tk after 0x80 consist of optional consecutive COMPACT-TLV data objects;\n");
            printf("    the last data object may carry a status indicator of one, two or three bytes.\n");
            printf("    See ISO/IEC 7816-4 8.1.1.3 for more info\n");
          }
        }
      }
    }
  }
  if (verbose) {
    printf("Fingerprinting based on ATQA & SAK values:\n");
    uint32_t atqasak = 0;
    atqasak += (((uint32_t)nai.abtAtqa[0] & 0xff)<<16);
    atqasak += (((uint32_t)nai.abtAtqa[1] & 0xff)<<8);
    atqasak += ((uint32_t)nai.btSak & 0xff);
    bool found_possible_match = false;
    switch (atqasak) {
      case 0x000218:
        printf("* Mifare Classic 4K\n");
        found_possible_match = true;
      break;
      case 0x000408:
        printf("* Mifare Classic 1K\n");
        printf("* Mifare Plus (4-byte UID) 2K SL1\n");
        found_possible_match = true;
      break;
      case 0x000409:
        printf("* Mifare MINI\n");
        found_possible_match = true;
      break;
      case 0x000410:
        printf("* Mifare Plus (4-byte UID) 2K SL2\n");
        found_possible_match = true;
      break;
      case 0x000411:
        printf("* Mifare Plus (4-byte UID) 4K SL2\n");
        found_possible_match = true;
      break;
      case 0x000418:
        printf("* Mifare Plus (4-byte UID) 4K SL1\n");
        found_possible_match = true;
      break;
      case 0x000420:
        printf("* Mifare Plus (4-byte UID) 2K/4K SL3\n");
        found_possible_match = true;
      break;
      case 0x004400:
        printf("* Mifare Ultralight\n");
        printf("* Mifare UltralightC\n");
        found_possible_match = true;
      break;
      case 0x004208:
      case 0x004408:
        printf("* Mifare Plus (7-byte UID) 2K SL1\n");
        found_possible_match = true;
      break;
      case 0x004218:
      case 0x004418:
        printf("* Mifare Plus (7-byte UID) 4K SL1\n");
        found_possible_match = true;
      break;
      case 0x004210:
      case 0x004410:
        printf("* Mifare Plus (7-byte UID) 2K SL2\n");
        found_possible_match = true;
      break;
      case 0x004211:
      case 0x004411:
        printf("* Mifare Plus (7-byte UID) 4K SL2\n");
        found_possible_match = true;
      break;
      case 0x004220:
      case 0x004420:
        printf("* Mifare Plus (7-byte UID) 2K/4K SL3\n");
        found_possible_match = true;
      break;
      case 0x034420:
        printf("* Mifare DESFire / Desfire EV1\n");
        found_possible_match = true;
      break;
    }
    // Other matches not described in
    // AN MIFARE Type Identification Procedure
    // but seen in the field:
    switch (atqasak) {
      case 0x000488:
        printf("* Mifare Classic 1K Infineon\n");
        found_possible_match = true;
      break;
      case 0x000298:
        printf("* Gemplus MPCOS\n");
        found_possible_match = true;
      break;
      case 0x030428:
        printf("* JCOP31\n");
        found_possible_match = true;
      break;
      case 0x004820:
        printf("* JCOP31 v2.4.1\n");
        printf("* JCOP31 v2.2\n");
        found_possible_match = true;
      break;
      case 0x000428:
        printf("* JCOP31 v2.3.1\n");
        found_possible_match = true;
      break;
      case 0x000453:
        printf("* Fudan FM1208SH01\n");
        found_possible_match = true;
      break;
      case 0x000820:
        printf("* Fudan FM1208\n");
        found_possible_match = true;
      break;
      case 0x000238:
        printf("* MFC 4K emulated by Nokia 6212 Classic\n");
        found_possible_match = true;
      break;
      case 0x000838:
        printf("* MFC 4K emulated by Nokia 6131 NFC\n");
        found_possible_match = true;
      break;
    }
    if ((nai.abtAtqa[0] & 0xf0) == 0) {
      switch (nai.abtAtqa[1]) {
        case 0x02:
          printf("* SmartMX with Mifare 4K emulation\n");
          found_possible_match = true;
        break;
        case 0x04:
          printf("* SmartMX with Mifare 1K emulation\n");
          found_possible_match = true;
        break;
        case 0x48:
          printf("* SmartMX with 7-byte UID\n");
          found_possible_match = true;
        break;
      }
    }
    if (! found_possible_match) {
      printf("* Unknown card, sorry\n");
    }
  }
  printf("\n");
 }
 void
-print_nfc_felica_info (const nfc_felica_info_t nfi, bool verbose)
+print_nfc_target(const nfc_target *pnt, bool verbose)
 {
-  (void) verbose;
+  char *s;
-  printf ("        ID (NFCID2): ");
+  str_nfc_target(&s, pnt, verbose);
-  print_hex (nfi.abtId, 8);
+  printf("%s", s);
-  printf ("    Parameter (PAD): ");
+  nfc_free(s);
  print_hex (nfi.abtPad, 8);
  printf ("   System Code (SC): ");
  print_hex (nfi.abtSysCode, 2);
 }
 void
 print_nfc_jewel_info (const nfc_jewel_info_t nji, bool verbose)
 {
  (void) verbose;
  printf ("    ATQA (SENS_RES): ");
  print_hex (nji.btSensRes, 2);
  printf ("      4-LSB JEWELID: ");
  print_hex (nji.btId, 4);
 }
 #define PI_ISO14443_4_SUPPORTED 0x01
 #define PI_NAD_SUPPORTED        0x01
 #define PI_CID_SUPPORTED        0x02
 void
 print_nfc_iso14443b_info (const nfc_iso14443b_info_t nbi, bool verbose)
 {
  const int iMaxFrameSizes[] = { 16, 24, 32, 40, 48, 64, 96, 128, 256 };
  printf ("               PUPI: ");
  print_hex (nbi.abtPupi, 4);
  printf ("   Application Data: ");
  print_hex (nbi.abtApplicationData, 4);
  printf ("      Protocol Info: ");
  print_hex (nbi.abtProtocolInfo, 3);
  if (verbose) {
    printf ("* Bit Rate Capability:\n");
    if (nbi.abtProtocolInfo[0] == 0) {
      printf (" * PICC supports only 106 kbits/s in both directions\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<7) {
      printf (" * Same bitrate in both directions mandatory\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<4) {
      printf (" * PICC to PCD, 1etu=64/fc, bitrate 212 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<5) {
      printf (" * PICC to PCD, 1etu=32/fc, bitrate 424 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<6) {
      printf (" * PICC to PCD, 1etu=16/fc, bitrate 847 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<0) {
      printf (" * PCD to PICC, 1etu=64/fc, bitrate 212 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<1) {
      printf (" * PCD to PICC, 1etu=32/fc, bitrate 424 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<2) {
      printf (" * PCD to PICC, 1etu=16/fc, bitrate 847 kbits/s supported\n");
    }
    if (nbi.abtProtocolInfo[0] & 1<<3) {
      printf (" * ERROR unknown value\n");
    }
    if( (nbi.abtProtocolInfo[1] & 0xf0) <= 0x80 ) {
      printf ("* Maximum frame sizes: %d bytes\n", iMaxFrameSizes[((nbi.abtProtocolInfo[1] & 0xf0) >> 4)]);
    }
    if((nbi.abtProtocolInfo[1] & 0x0f) == PI_ISO14443_4_SUPPORTED) {
      printf ("* Protocol types supported: ISO/IEC 14443-4\n");
    }
    printf ("* Frame Waiting Time: %.4g ms\n",256.0*16.0*(1<<((nbi.abtProtocolInfo[2] & 0xf0) >> 4))/13560.0);
    if((nbi.abtProtocolInfo[2] & (PI_NAD_SUPPORTED|PI_CID_SUPPORTED)) != 0) {
      printf ("* Frame options supported: ");
      if ((nbi.abtProtocolInfo[2] & PI_NAD_SUPPORTED) != 0) printf ("NAD ");
      if ((nbi.abtProtocolInfo[2] & PI_CID_SUPPORTED) != 0) printf ("CID ");
      printf("\n");
    }
  }
 }
 void
 print_nfc_iso14443bi_info (const nfc_iso14443bi_info_t nii, bool verbose)
 {
  printf ("                DIV: ");
  print_hex (nii.abtDIV, 4);
  if (verbose) {
    int version = (nii.btVerLog & 0x1e)>>1;
    printf ("   Software Version: ");
    if (version == 15) {
      printf ("Undefined\n");
    } else {
      printf ("%i\n", version);
    }
    if ((nii.btVerLog & 0x80) && (nii.btConfig & 0x80)){
      printf ("        Wait Enable: yes");
    }
  }
  if ((nii.btVerLog & 0x80) && (nii.btConfig & 0x40)) {
    printf ("                ATS: ");
    print_hex (nii.abtAtr, nii.szAtrLen);
  }
 }
 void
 print_nfc_iso14443b2sr_info (const nfc_iso14443b2sr_info_t nsi, bool verbose)
 {
  (void) verbose;
  printf ("                UID: ");
  print_hex (nsi.abtUID, 8);
 }
 void
 print_nfc_iso14443b2ct_info (const nfc_iso14443b2ct_info_t nci, bool verbose)
 {
  (void) verbose;
  uint32_t uid;
  uid = (nci.abtUID[3] << 24) + (nci.abtUID[2] << 16) + (nci.abtUID[1] << 8) + nci.abtUID[0];
  printf ("                UID: ");
  print_hex (nci.abtUID, sizeof(nci.abtUID));
  printf ("      UID (decimal): %010u\n", uid);
  printf ("       Product Code: %02X\n", nci.btProdCode);
  printf ("           Fab Code: %02X\n", nci.btFabCode);
 }
 void
 print_nfc_dep_info (const nfc_dep_info_t ndi, bool verbose)
 {
  (void) verbose;
  printf ("       NFCID3: ");
  print_hex (ndi.abtNFCID3, 10);
  printf ("           BS: %02x\n", ndi.btBS);
  printf ("           BR: %02x\n", ndi.btBR);
  printf ("           TO: %02x\n", ndi.btTO);
  printf ("           PP: %02x\n", ndi.btPP);
  if (ndi.szGB) {
    printf ("General Bytes: ");
    print_hex (ndi.abtGB, ndi.szGB);
  }
 }
 const char *
 str_nfc_baud_rate (const nfc_baud_rate_t nbr)
 {
  switch(nbr) {
    case NBR_UNDEFINED:
      return "undefined baud rate";
    break;
    case NBR_106:
      return "106 kbps";
    break;
    case NBR_212:
      return "212 kbps";
    break;
    case NBR_424:
      return "424 kbps";
    break;
    case NBR_847:
      return "847 kbps";
    break;
  }
  return "";
 }
 void
 print_nfc_target (const nfc_target_t nt, bool verbose)
 {
  switch(nt.nm.nmt) {
    case NMT_ISO14443A:
      printf ("ISO/IEC 14443A (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_iso14443a_info (nt.nti.nai, verbose);
    break;
    case NMT_JEWEL:
      printf ("Innovision Jewel (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_jewel_info (nt.nti.nji, verbose);
    break;
    case NMT_FELICA:
      printf ("FeliCa (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_felica_info (nt.nti.nfi, verbose);
    break;
    case NMT_ISO14443B:
      printf ("ISO/IEC 14443-4B (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_iso14443b_info (nt.nti.nbi, verbose);
    break;
    case NMT_ISO14443BI:
      printf ("ISO/IEC 14443-4B' (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_iso14443bi_info (nt.nti.nii, verbose);
    break;
    case NMT_ISO14443B2SR:
      printf ("ISO/IEC 14443-2B ST SRx (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_iso14443b2sr_info (nt.nti.nsi, verbose);
    break;
    case NMT_ISO14443B2CT:
      printf ("ISO/IEC 14443-2B ASK CTx (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_iso14443b2ct_info (nt.nti.nci, verbose);
    break;
    case NMT_DEP:
      printf ("D.E.P. (%s) target:\n", str_nfc_baud_rate(nt.nm.nbr));
      print_nfc_dep_info (nt.nti.ndi, verbose);
    break;
  }
 }
--- a/src/nfc-utils.h
+++ b/src/nfc-utils.h
@@ -1,13 +1,18 @@
 /*-
- * Public platform independent Near Field Communication (NFC) library examples
+ * Free/Libre Near Field Communication (NFC) library
- * 
+ *
- * Copyright (C) 2009, Roel Verdult
+ * Libnfc historical contributors:
- * Copyright (C) 2010, Romuald Conty, Romain Tartière
+ * Copyright (C) 2009      Roel Verdult
- * 
+ * Copyright (C) 2009-2013 Romuald Conty
 * Copyright (C) 2010-2012 Romain Tartière
 * Copyright (C) 2010-2013 Philippe Teuwen
 * Copyright (C) 2012-2013 Ludovic Rousseau
 * Additional contributors of this file:
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *  1) Redistributions of source code must retain the above copyright notice,
- *  this list of conditions and the following disclaimer. 
+ *  this list of conditions and the following disclaimer.
 *  2 )Redistributions in binary form must reproduce the above copyright
 *  notice, this list of conditions and the following disclaimer in the
 *  documentation and/or other materials provided with the distribution.
@@ -23,7 +28,7 @@
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
- * 
+ *
 * Note that this license only applies on the examples, NFC library itself is under LGPL
 *
 */
@@ -79,22 +84,20 @@
 #  define ERR(...)  warnx ("ERROR: " __VA_ARGS__ )
 #endif
-byte_t  oddparity (const byte_t bt);
+#ifndef MIN
-void    oddparity_byte_ts (const byte_t * pbtData, const size_t szLen, byte_t * pbtPar);
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
 #endif
 #ifndef MAX
 #define MAX(a,b) (((a) > (b)) ? (a) : (b))
 #endif
-void    print_hex (const byte_t * pbtData, const size_t szLen);
+uint8_t  oddparity(const uint8_t bt);
-void    print_hex_bits (const byte_t * pbtData, const size_t szBits);
+void    oddparity_bytes_ts(const uint8_t *pbtData, const size_t szLen, uint8_t *pbtPar);
 void    print_hex_par (const byte_t * pbtData, const size_t szBits, const byte_t * pbtDataPar);
-void    print_nfc_iso14443a_info (const nfc_iso14443a_info_t nai, bool verbose);
+void    print_hex(const uint8_t *pbtData, const size_t szLen);
-void    print_nfc_iso14443b_info (const nfc_iso14443b_info_t nbi, bool verbose);
+void    print_hex_bits(const uint8_t *pbtData, const size_t szBits);
-void    print_nfc_iso14443bi_info (const nfc_iso14443bi_info_t nii, bool verbose);
+void    print_hex_par(const uint8_t *pbtData, const size_t szBits, const uint8_t *pbtDataPar);
 void    print_nfc_iso14443b2sr_info (const nfc_iso14443b2sr_info_t nsi, bool verbose);
 void    print_nfc_iso14443b2ct_info (const nfc_iso14443b2ct_info_t nci, bool verbose);
 void    print_nfc_felica_info (const nfc_felica_info_t nfi, bool verbose);
 void    print_nfc_jewel_info (const nfc_jewel_info_t nji, bool verbose);
 void    print_nfc_dep_info (const nfc_dep_info_t ndi, bool verbose);
-void    print_nfc_target (const nfc_target_t nt, bool verbose);
+void    print_nfc_target(const nfc_target *pnt, bool verbose);
 #endif
--- a/src/xgetopt.c
+++ b/src/xgetopt.c
@@ -1,223 +1,214 @@
-// XGetopt.cpp  Version 1.2 
+// XGetopt.cpp  Version 1.2
-// 
+//
-// Author:  Hans Dietrich 
+// Author:  Hans Dietrich
-//          hdietrich2@hotmail.com 
+//          hdietrich2@hotmail.com
-// 
+//
-// Description: 
+// Description:
-//     XGetopt.cpp implements getopt(), a function to parse command lines. 
+//     XGetopt.cpp implements getopt(), a function to parse command lines.
-// 
+//
-// History 
+// History
-//     Version 1.2 - 2003 May 17 
+//     Version 1.2 - 2003 May 17
-//     - Added Unicode support 
+//     - Added Unicode support
-// 
+//
-//     Version 1.1 - 2002 March 10 
+//     Version 1.1 - 2002 March 10
-//     - Added example to XGetopt.cpp module header  
+//     - Added example to XGetopt.cpp module header
-// 
+//
-// This software is released into the public domain. 
+// This software is released into the public domain.
-// You are free to use it in any way you like. 
+// You are free to use it in any way you like.
-// 
+//
-// This software is provided "as is" with no expressed 
+// This software is provided "as is" with no expressed
-// or implied warranty.  I accept no liability for any 
+// or implied warranty.  I accept no liability for any
-// damage or loss of business that this software may cause. 
+// damage or loss of business that this software may cause.
-// 
+//
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
- 
+
- 
+
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
-// if you are using precompiled headers then include this line: 
+// if you are using precompiled headers then include this line:
-//#include "stdafx.h" 
+//#include "stdafx.h"
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
- 
+
- 
+
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
-// if you are not using precompiled headers then include these lines: 
+// if you are not using precompiled headers then include these lines:
-//#include  
+//#include
-//#include  
+//#include
-//#include  
+//#include
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
- 
+
-#include <stdio.h>
+#include <stdio.h>
-#include <string.h>
+#include <string.h>
-#include "xgetopt.h" 
+#include "xgetopt.h"
-
+
- 
+
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
-// 
+//
-//  X G e t o p t . c p p 
+//  X G e t o p t . c p p
-// 
+//
-// 
+//
-//  NAME 
+//  NAME
-//       getopt -- parse command line options 
+//       getopt -- parse command line options
-// 
+//
-//  SYNOPSIS 
+//  SYNOPSIS
-//       int getopt(int argc, char *argv[], char *optstring) 
+//       int getopt(int argc, char *argv[], char *optstring)
-// 
+//
-//       extern char *optarg; 
+//       extern char *optarg;
-//       extern int optind; 
+//       extern int optind;
-// 
+//
-//  DESCRIPTION 
+//  DESCRIPTION
-//       The getopt() function parses the command line arguments. Its 
+//       The getopt() function parses the command line arguments. Its
-//       arguments argc and argv are the argument count and array as 
+//       arguments argc and argv are the argument count and array as
-//       passed into the application on program invocation.  In the case 
+//       passed into the application on program invocation.  In the case
-//       of Visual C++ programs, argc and argv are available via the 
+//       of Visual C++ programs, argc and argv are available via the
-//       variables __argc and __argv (double underscores), respectively. 
+//       variables __argc and __argv (double underscores), respectively.
-//       getopt returns the next option letter in argv that matches a 
+//       getopt returns the next option letter in argv that matches a
-//       letter in optstring.  (Note:  Unicode programs should use 
+//       letter in optstring.  (Note:  Unicode programs should use
-//       __targv instead of __argv.  Also, all character and string 
+//       __targv instead of __argv.  Also, all character and string
-//       literals should be enclosed in _T( ) ). 
+//       literals should be enclosed in _T( ) ).
-// 
+//
-//       optstring is a string of recognized option letters;  if a letter 
+//       optstring is a string of recognized option letters;  if a letter
-//       is followed by a colon, the option is expected to have an argument 
+//       is followed by a colon, the option is expected to have an argument
-//       that may or may not be separated from it by white space.  optarg 
+//       that may or may not be separated from it by white space.  optarg
-//       is set to point to the start of the option argument on return from 
+//       is set to point to the start of the option argument on return from
-//       getopt. 
+//       getopt.
-// 
+//
-//       Option letters may be combined, e.g., "-ab" is equivalent to 
+//       Option letters may be combined, e.g., "-ab" is equivalent to
-//       "-a -b".  Option letters are case sensitive. 
+//       "-a -b".  Option letters are case sensitive.
-// 
+//
-//       getopt places in the external variable optind the argv index 
+//       getopt places in the external variable optind the argv index
-//       of the next argument to be processed.  optind is initialized 
+//       of the next argument to be processed.  optind is initialized
-//       to 0 before the first call to getopt. 
+//       to 0 before the first call to getopt.
-// 
+//
-//       When all options have been processed (i.e., up to the first 
+//       When all options have been processed (i.e., up to the first
-//       non-option argument), getopt returns EOF, optarg will point 
+//       non-option argument), getopt returns EOF, optarg will point
-//       to the argument, and optind will be set to the argv index of 
+//       to the argument, and optind will be set to the argv index of
-//       the argument.  If there are no non-option arguments, optarg 
+//       the argument.  If there are no non-option arguments, optarg
-//       will be set to NULL. 
+//       will be set to NULL.
-// 
+//
-//       The special option "--" may be used to delimit the end of the 
+//       The special option "--" may be used to delimit the end of the
-//       options;  EOF will be returned, and "--" (and everything after it) 
+//       options;  EOF will be returned, and "--" (and everything after it)
-//       will be skipped. 
+//       will be skipped.
-// 
+//
-//  RETURN VALUE 
+//  RETURN VALUE
-//       For option letters contained in the string optstring, getopt 
+//       For option letters contained in the string optstring, getopt
-//       will return the option letter.  getopt returns a question mark (?) 
+//       will return the option letter.  getopt returns a question mark (?)
-//       when it encounters an option letter not included in optstring. 
+//       when it encounters an option letter not included in optstring.
-//       EOF is returned when processing is finished. 
+//       EOF is returned when processing is finished.
-// 
+//
-//  BUGS 
+//  BUGS
-//       1)  Long options are not supported. 
+//       1)  Long options are not supported.
-//       2)  The GNU double-colon extension is not supported. 
+//       2)  The GNU double-colon extension is not supported.
-//       3)  The environment variable POSIXLY_CORRECT is not supported. 
+//       3)  The environment variable POSIXLY_CORRECT is not supported.
-//       4)  The + syntax is not supported. 
+//       4)  The + syntax is not supported.
-//       5)  The automatic permutation of arguments is not supported. 
+//       5)  The automatic permutation of arguments is not supported.
-//       6)  This implementation of getopt() returns EOF if an error is 
+//       6)  This implementation of getopt() returns EOF if an error is
-//           encountered, instead of -1 as the latest standard requires. 
+//           encountered, instead of -1 as the latest standard requires.
-// 
+//
-//  EXAMPLE 
+//  EXAMPLE
-//       BOOL CMyApp::ProcessCommandLine(int argc, char *argv[]) 
+//       BOOL CMyApp::ProcessCommandLine(int argc, char *argv[])
-//       { 
+//       {
-//           int c; 
+//           int c;
-// 
+//
-//           while ((c = getopt(argc, argv, _T("aBn:"))) != EOF) 
+//           while ((c = getopt(argc, argv, _T("aBn:"))) != EOF)
-//           { 
+//           {
-//               switch (c) 
+//               switch (c)
-//               { 
+//               {
-//                   case _T('a'): 
+//                   case _T('a'):
-//                       TRACE(_T("option a\n")); 
+//                       TRACE(_T("option a\n"));
-//                       // 
+//                       //
-//                       // set some flag here 
+//                       // set some flag here
-//                       // 
+//                       //
-//                       break; 
+//                       break;
-// 
+//
-//                   case _T('B'): 
+//                   case _T('B'):
-//                       TRACE( _T("option B\n")); 
+//                       TRACE( _T("option B\n"));
-//                       // 
+//                       //
-//                       // set some other flag here 
+//                       // set some other flag here
-//                       // 
+//                       //
-//                       break; 
+//                       break;
-// 
+//
-//                   case _T('n'): 
+//                   case _T('n'):
-//                       TRACE(_T("option n: value=%d\n"), atoi(optarg)); 
+//                       TRACE(_T("option n: value=%d\n"), atoi(optarg));
-//                       // 
+//                       //
-//                       // do something with value here 
+//                       // do something with value here
-//                       // 
+//                       //
-//                       break; 
+//                       break;
-// 
+//
-//                   case _T('?'): 
+//                   case _T('?'):
-//                       TRACE(_T("ERROR: illegal option %s\n"), argv[optind-1]); 
+//                       TRACE(_T("ERROR: illegal option %s\n"), argv[optind-1]);
-//                       return FALSE; 
+//                       return FALSE;
-//                       break; 
+//                       break;
-// 
+//
-//                   default: 
+//                   default:
-//                       TRACE(_T("WARNING: no handler for option %c\n"), c); 
+//                       TRACE(_T("WARNING: no handler for option %c\n"), c);
-//                       return FALSE; 
+//                       return FALSE;
-//                       break; 
+//                       break;
-//               } 
+//               }
-//           } 
+//           }
-//           // 
+//           //
-//           // check for non-option args here 
+//           // check for non-option args here
-//           // 
+//           //
-//           return TRUE; 
+//           return TRUE;
-//       } 
+//       }
-// 
+//
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
- 
+
-char	*optarg;		// global argument pointer 
+char	*optarg;		// global argument pointer
-int		optind = 0; 	// global argv index 
+int		optind = 0; 	// global argv index
- 
+
-int getopt(int argc, char *argv[], char *optstring) 
+int getopt(int argc, char *argv[], char *optstring)
-{ 
+{
-    char c = 0;
+  char c = 0;
-    char *cp = NULL;
+  char *cp = NULL;
-
+
-	static char *next = NULL; 
+  static char *next = NULL;
-	if (optind == 0) 
+  if (optind == 0)
-		next = NULL; 
+    next = NULL;
- 
+
-	optarg = NULL; 
+  optarg = NULL;
- 
+
-	if (next == NULL || *next == '\0') 
+  if (next == NULL || *next == '\0') {
-	{ 
+    if (optind == 0)
-		if (optind == 0) 
+      optind++;
-			optind++; 
+
- 
+    if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') {
-		if (optind >= argc || argv[optind][0] != '-' || argv[optind][1] == '\0') 
+      optarg = NULL;
-		{ 
+      if (optind < argc)
-			optarg = NULL; 
+        optarg = argv[optind];
-			if (optind < argc) 
+      return EOF;
-				optarg = argv[optind]; 
+    }
-			return EOF; 
+
-		} 
+    if (strcmp(argv[optind], "--") == 0) {
- 
+      optind++;
-		if (strcmp(argv[optind], "--") == 0) 
+      optarg = NULL;
-		{ 
+      if (optind < argc)
-			optind++; 
+        optarg = argv[optind];
-			optarg = NULL; 
+      return EOF;
-			if (optind < argc) 
+    }
-				optarg = argv[optind]; 
+
-			return EOF; 
+    next = argv[optind];
-		} 
+    next++;		// skip past -
- 
+    optind++;
-		next = argv[optind]; 
+  }
-		next++;		// skip past - 
+
-		optind++; 
+  c = *next++;
-	} 
+  cp = strchr(optstring, c);
- 
+
-	c = *next++; 
+  if (cp == NULL || c == ':')
-	cp = strchr(optstring, c); 
+    return '?';
- 
+
-	if (cp == NULL || c == ':') 
+  cp++;
-		return '?'; 
+  if (*cp == ':') {
- 
+    if (*next != '\0') {
-	cp++; 
+      optarg = next;
-	if (*cp == ':') 
+      next = NULL;
-	{ 
+    } else if (optind < argc) {
-		if (*next != '\0') 
+      optarg = argv[optind];
-		{ 
+      optind++;
-			optarg = next; 
+    } else {
-			next = NULL; 
+      return '?';
-		} 
+    }
-		else if (optind < argc) 
+  }
-		{ 
+
-			optarg = argv[optind]; 
+  return c;
-			optind++; 
+}
 		} 
 		else 
 		{ 
 			return '?'; 
 		} 
 	} 
 	return c; 
 } 
--- a/src/xgetopt.h
+++ b/src/xgetopt.h
@@ -1,23 +1,29 @@
-// XGetopt.h  Version 1.2 
+// XGetopt.h  Version 1.2
-// 
+//
-// Author:  Hans Dietrich 
+// Author:  Hans Dietrich
-//          hdietrich2@hotmail.com 
+//          hdietrich2@hotmail.com
-// 
+//
-// This software is released into the public domain. 
+// This software is released into the public domain.
-// You are free to use it in any way you like. 
+// You are free to use it in any way you like.
-// 
+//
-// This software is provided "as is" with no expressed 
+// This software is provided "as is" with no expressed
-// or implied warranty.  I accept no liability for any 
+// or implied warranty.  I accept no liability for any
-// damage or loss of business that this software may cause. 
+// damage or loss of business that this software may cause.
-// 
+//
-/////////////////////////////////////////////////////////////////////////////// 
+///////////////////////////////////////////////////////////////////////////////
- 
+
-#ifndef XGETOPT_H 
+#ifndef XGETOPT_H
-#define XGETOPT_H 
+#define XGETOPT_H
- 
+
-extern int optind, opterr; 
+#if HAVE_UNISTD_H
-extern char *optarg; 
+#include <unistd.h>
- 
+#else
-int getopt(int argc, char *argv[], char *optstring); 
+
- 
+extern int optind, opterr;
-#endif //XGETOPT_H 
+extern char *optarg;
 int getopt(int argc, char *argv[], char *optstring);
 #endif
 #endif //XGETOPT_H
Author	SHA1	Message	Date
j8048188	b333a7925a	Fix typos in usage examples	2018-07-14 12:31:54 +02:00
Marcos Vives Del Sol	30df7f5a28	Fix configure warnings about missing stuff	2018-05-09 16:11:51 +02:00
Marcos Vives Del Sol	a8a605e1b4	Removed xor swaps to fix GCC warnings	2018-05-09 16:11:51 +02:00
Marcos Vives Del Sol	92f7413beb	Improve system-dependent compilation	2018-05-09 16:11:51 +02:00
Marcos Vives Del Sol	1fb6a02359	Added .gitignore	2018-05-09 16:11:51 +02:00
Julius Putra Tanu Setiaji	e04aaa8a96	Update compilation instruction According to #35	2018-05-09 16:02:44 +02:00
Romuald Conty	f67b812be6	Merge pull request #52 from unlimitedsola/patch-1 Fix typo	2018-01-07 23:50:25 +01:00
Sola	4f1a01f7fe	Update README	2017-11-25 15:27:14 +08:00
romuald@libnfc.org	5acc9f40a0	Attempt to fix key recovering This patch may fix the keys recovering problem explained in Issue 21.	2014-01-10 01:00:19 +00:00
romuald@libnfc.org	444dd2a765	Bump version	2013-06-12 13:13:35 +00:00
romuald@libnfc.org	445b281277	Sync nfc-utils.[hc] with devel libnfc files	2013-04-04 21:50:18 +00:00
romuald@libnfc.org	d43410c0cb	Supress clang warning: implicit declaration of function 'lfsr_common_prefix' is invalid in C99	2013-04-04 21:41:50 +00:00
romuald@libnfc.org	afd7fdb295	Bump version	2013-01-30 15:03:00 +00:00
romuald@libnfc.org	58a8d3af88	Sync crapto1.* with MFOC Fixes issue 18 Fixes issue 19	2013-01-30 14:56:33 +00:00
romuald@libnfc.org	df22a2ce1b	Sync nfc-utils.* and mifare.* with libnfc	2013-01-30 14:55:25 +00:00
romuald@libnfc.org	776b0d3f79	Applies make style	2013-01-30 14:54:27 +00:00
romuald@libnfc.org	22fa583429	Adds make style	2013-01-30 14:54:03 +00:00
romuald@libnfc.org	8521f43051	Updates source code to use libnfc 1.7.0 This commit also fix some warnings.	2013-01-20 17:21:45 +00:00
romuald@libnfc.org	41a5a300ef	Fix target selection	2012-09-28 08:42:39 +00:00
romuald@libnfc.org	03da52138f	Fixes Issue 11. (thanks to maxx.h2)	2012-09-26 20:03:56 +00:00
romuald@libnfc.org	1d35e85a3b	Suppress some warnings (discards ‘const’ qualifier from pointer target type): functions that manipulate filename does not overwrite it	2012-09-26 19:53:58 +00:00
romuald@libnfc.org	0de043935d	Fix dirty prototypes: crapto1 3.2 version now exposes these functions.	2012-09-26 19:48:20 +00:00
romuald@libnfc.org	eddd55c6fc	Suppress warning: function declaration isn’t a prototype, old-style function definition	2012-09-26 19:44:22 +00:00
romuald@libnfc.org	24964bb77a	Suppress warning: function declaration isn’t a prototype	2012-09-26 19:39:32 +00:00
romuald@libnfc.org	925ea523e7	Remove some unused functions	2012-09-26 19:33:28 +00:00
romuald@libnfc.org	4a8cd8914e	Upgrade code to use libnfc 1.6.x	2012-09-26 19:32:43 +00:00
romuald@libnfc.org	6865db5ad0	Remove some unused variables	2012-09-26 19:28:45 +00:00
romuald@libnfc.org	9d83e8a254	Update autotools files to use libnfc >= 1.6.0	2012-09-26 19:15:46 +00:00
romuald@libnfc.org	bb64564cad	Sync crapto1 files with official crapto1 3.2	2012-09-26 19:14:01 +00:00
romuald@libnfc.org	7fe60310b0	Fix always true comparisons: pm3_log_multisect_decrypted (uint8_t) is always >= 0 and is always <= 256	2012-09-26 15:38:35 +00:00
romuald@libnfc.org	6c8b6190cb	Removes some remaining ^M chars.	2012-09-23 10:44:23 +00:00
romuald@libnfc.org	91e4c89302	Enhance usage information.	2012-09-23 10:35:37 +00:00
romuald@libnfc.org	1026af5d3f	Sync nfc-utils.* and mifare.* with current libnfc devel version	2012-09-23 10:34:32 +00:00
romuald@libnfc.org	1b6d022668	Convert all remaining dos files to unix format.	2012-09-23 10:29:36 +00:00