Applies make style

src/crapto1.c

@@ -124,8 +124,7 @@ static inline void extend_table_simple(uint32_t *tbl, uint32_t **end, int bit)
 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,
-	struct Crypto1State *sl, uint32_t in)
+        struct Crypto1State *sl, uint32_t in) {
-{
   uint32_t *o, *e, i;
 
   if (rem == -1) {
@@ -164,8 +163,7 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
       e_tail = binsearch(e_head, e = e_tail);
       sl = recover(o_tail--, o, oks,
                    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;
     else
       e_tail = binsearch(e_head, e_tail) - 1;
@@ -177,8 +175,7 @@ recover(uint32_t *o_head, uint32_t *o_tail, uint32_t oks,
  * 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;
   uint32_t *odd_head = 0, *odd_tail = 0, oks = 0;
   uint32_t *even_head = 0, *even_tail = 0, eks = 0;
@@ -224,29 +221,32 @@ out:
 
 static const uint32_t S1[] = {     0x62141, 0x310A0, 0x18850, 0x0C428, 0x06214,
                                    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,
                                 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,
   0xC4006, 0x62003, 0xB56B4, 0x5AB5A, 0xA9318, 0xD0F39, 0x6879C, 0xB057B,
   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,
                                 0x42F53AB0, 0x217A9D58, 0x161DC528, 0x0DAE6910, 0x46D73488, 0x25CB11C0,
                                 0x52E588E0, 0x6972C470, 0x34B96238, 0x5CFC3A98, 0x28DE96C8, 0x12CFC0E0,
                                 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;
   uint8_t oks[32], eks[32], hi[32];
   uint32_t low = 0,  win = 0;
@@ -306,7 +306,8 @@ struct Crypto1State* lfsr_recovery64(uint32_t ks2, uint32_t ks3)
       sl->even = win;
       ++sl;
       sl->odd = sl->even = 0;
-			continue2:;
+continue2:
+      ;
     }
   }
   return statelist;
@@ -376,7 +377,8 @@ int nonce_distance(uint32_t from, uint32_t to)
 
 static uint32_t fastfwd[2][8] = {
   { 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
@@ -416,8 +418,7 @@ uint32_t *lfsr_prefix_ks(uint8_t ks[8], int isodd)
  */
 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;
 
   for (c = 0; good && c < 8; ++c) {
@@ -449,8 +450,7 @@ check_pfx_parity(uint32_t prefix, uint32_t rresp, uint8_t parities[8][8],
  * Implentation of the common prefix attack.
  */
 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;
   uint32_t *odd, *even, *o, *e, top;
 

src/crypto1.c

@@ -23,8 +23,7 @@
 #define SWAPENDIAN(x)\
   (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));
   int i;
 

src/mfcuk.h

@@ -92,8 +92,7 @@
 #define MFCUK_DARKSIDE_START_NR         0xDEADBEEF
 #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
   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
   uint32_t num_of_appearances; // For statistics, how many times this tag nonce appeared for the given SLEEP_ values

src/mfcuk_finger.c

@@ -38,8 +38,7 @@
 
 #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_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 },
@@ -49,8 +48,7 @@ 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");
     return 0;
   }
@@ -64,8 +62,7 @@ int mfcuk_finger_default_decoder(mifare_classic_tag *dump)
 // 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)
 {
-    if (!dump)
+  if (!dump) {
-    {
     fprintf(stderr, "ERROR: cannot decode a NULL pointer :)\n");
     return 0;
   }
@@ -87,45 +84,33 @@ int mfcuk_finger_default_comparator(mifare_classic_tag *dump, mfcuk_finger_templ
   int num_bytes_tomatch = 0;
   int num_bytes_matched = 0;
 
-    if ( (!dump) || (!tmpl) || (!score) )
+  if ((!dump) || (!tmpl) || (!score)) {
-    {
     return 0;
   }
 
-    if (IS_MIFARE_CLASSIC_1K_TAG(dump))
+  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)) {
-    else if (IS_MIFARE_CLASSIC_4K_TAG(dump))
-    {
     max_bytes = MIFARE_CLASSIC_BYTES_PER_BLOCK * MIFARE_CLASSIC_4K_MAX_BLOCKS;
-    }
+  } else {
-    else
-    {
     return 0;
   }
 
-    for (i=0; i<max_bytes; i++)
+  for (i = 0; i < max_bytes; i++) {
-    {
+    if (((char *)(&tmpl->mask))[i] == 0x0) {
-        if ( ((char *)(&tmpl->mask))[i] == 0x0 )
-        {
       continue;
     }
 
     num_bytes_tomatch++;
 
-        if ( ((char *)(&tmpl->values))[i] == ((char *)dump)[i] )
+    if (((char *)(&tmpl->values))[i] == ((char *)dump)[i]) {
-        {
       num_bytes_matched++;
     }
   }
 
-    if (num_bytes_tomatch == 0)
+  if (num_bytes_tomatch == 0) {
-    {
     return 0;
-    }
+  } else {
-    else
-    {
     *score = (float)(num_bytes_matched) / num_bytes_tomatch;
   }
 
@@ -142,36 +127,30 @@ int mfcuk_finger_load(void)
   mfcuk_finger_template *tmpl_new = NULL;
 
   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");
 
-        if (!fp)
+    if (!fp) {
-        {
       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)
+    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)
+    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 (mfcuk_finger_db[i].tmpl_data == NULL) {
-        {
+      if ((tmpl_new = (mfcuk_finger_template *) malloc(sizeof(mfcuk_finger_template))) == 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;
@@ -184,8 +163,7 @@ int mfcuk_finger_load(void)
       template_loaded_count++;
     }
 
-        if (fp)
+    if (fp) {
-        {
       fclose(fp);
       fp = NULL;
     }
@@ -198,10 +176,8 @@ int mfcuk_finger_unload(void)
 {
   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;
     }

src/mfcuk_finger.h

@@ -45,8 +45,7 @@
 #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 values;
 } mfcuk_finger_template;
@@ -56,8 +55,7 @@ typedef int (*mfcuk_finger_comparator) (mifare_classic_tag *dump, mfcuk_finger_t
 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;
   const char *tmpl_name;
   mfcuk_finger_comparator tmpl_comparison_func;

src/mfcuk_mifare.c

@@ -53,8 +53,7 @@
 #include "mfcuk_mifare.h"
 
 // Default keys used as a *BIG* mistake in many applications - especially System Integrators should pay attention!
-uint8_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH] =
+uint8_t mfcuk_default_keys[][MIFARE_CLASSIC_KEY_BYTELENGTH] = {
-{
   {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, // Place-holder for current key to verify
   {0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
   {0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5},
@@ -70,13 +69,11 @@ int mfcuk_default_keys_num = sizeof(mfcuk_default_keys)/sizeof(mfcuk_default_key
 
 bool is_valid_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( IS_MIFARE_CLASSIC_1K(bTagType) && (uiBlock < MIFARE_CLASSIC_1K_MAX_BLOCKS) )
+  if (IS_MIFARE_CLASSIC_1K(bTagType) && (uiBlock < MIFARE_CLASSIC_1K_MAX_BLOCKS)) {
-    {
     return true;
   }
 
-    if ( IS_MIFARE_CLASSIC_4K(bTagType) && (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS) )
+  if (IS_MIFARE_CLASSIC_4K(bTagType) && (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS)) {
-    {
     return true;
   }
 
@@ -85,13 +82,11 @@ bool is_valid_block(uint8_t bTagType, uint32_t uiBlock)
 
 bool is_valid_sector(uint8_t bTagType, uint32_t uiSector)
 {
-    if ( IS_MIFARE_CLASSIC_1K(bTagType) && (uiSector < MIFARE_CLASSIC_1K_MAX_SECTORS) )
+  if (IS_MIFARE_CLASSIC_1K(bTagType) && (uiSector < MIFARE_CLASSIC_1K_MAX_SECTORS)) {
-    {
     return true;
   }
 
-    if ( IS_MIFARE_CLASSIC_4K(bTagType) && (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS) )
+  if (IS_MIFARE_CLASSIC_4K(bTagType) && (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS)) {
-    {
     return true;
   }
 
@@ -100,19 +95,15 @@ bool is_valid_sector(uint8_t bTagType, uint32_t uiSector)
 
 bool is_first_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( !is_valid_block(bTagType, uiBlock) )
+  if (!is_valid_block(bTagType, uiBlock)) {
-    {
     return false;
   }
 
   // Test if we are in the small or big sectors
-    if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
+  if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
-    {
     // For Mifare Classic 1K, it will enter always here
     return ((uiBlock) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) == 0);
-    }
+  } else {
-    else
-    {
     // This branch will enter only for Mifare Classic 4K big sectors
     return ((uiBlock) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) == 0);
   }
@@ -123,19 +114,15 @@ bool is_first_block(uint8_t bTagType, uint32_t uiBlock)
 
 bool is_trailer_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( !is_valid_block(bTagType, uiBlock) )
+  if (!is_valid_block(bTagType, uiBlock)) {
-    {
     return false;
   }
 
   // Test if we are in the small or big sectors
-    if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
+  if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
-    {
     // For Mifare Classic 1K, it will enter always here
     return ((uiBlock + 1) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) == 0);
-    }
+  } else {
-    else
-    {
     // This branch will enter only for Mifare Classic 4K big sectors
     return ((uiBlock + 1) % (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) == 0);
   }
@@ -146,19 +133,15 @@ bool is_trailer_block(uint8_t bTagType, uint32_t uiBlock)
 
 uint32_t get_first_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( !is_valid_block(bTagType, uiBlock) )
+  if (!is_valid_block(bTagType, uiBlock)) {
-    {
     return MIFARE_CLASSIC_INVALID_BLOCK;
   }
 
   // Test if we are in the small or big sectors
-    if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
+  if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
-    {
     // Integer divide, then integer multiply
     return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1;
-    }
+  } else {
-    else
-    {
     uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
     return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2;
   }
@@ -169,19 +152,15 @@ uint32_t get_first_block(uint8_t bTagType, uint32_t uiBlock)
 
 uint32_t get_trailer_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( !is_valid_block(bTagType, uiBlock) )
+  if (!is_valid_block(bTagType, uiBlock)) {
-    {
     return MIFARE_CLASSIC_INVALID_BLOCK;
   }
 
   // Test if we are in the small or big sectors
-    if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
+  if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
-    {
     // Integer divide, then integer multiply
     return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 - 1);
-    }
+  } else {
-    else
-    {
     uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
     return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 - 1);
   }
@@ -192,13 +171,11 @@ uint32_t get_trailer_block(uint8_t bTagType, uint32_t uiBlock)
 
 bool is_big_sector(uint8_t bTagType, uint32_t uiSector)
 {
-    if ( !is_valid_sector(bTagType, uiSector) )
+  if (!is_valid_sector(bTagType, uiSector)) {
-    {
     return false;
   }
 
-    if (uiSector >= MIFARE_CLASSIC_4K_MAX_SECTORS1)
+  if (uiSector >= MIFARE_CLASSIC_4K_MAX_SECTORS1) {
-    {
     return true;
   }
 
@@ -207,18 +184,14 @@ bool is_big_sector(uint8_t bTagType, uint32_t uiSector)
 
 uint32_t get_first_block_for_sector(uint8_t bTagType, uint32_t uiSector)
 {
-    if ( !is_valid_sector(bTagType, uiSector) )
+  if (!is_valid_sector(bTagType, uiSector)) {
-    {
     return MIFARE_CLASSIC_INVALID_BLOCK;
   }
 
-    if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1)
+  if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1) {
-    {
     // For Mifare Classic 1K, it will enter always here
     return (uiSector * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1);
-    }
+  } else {
-    else
-    {
     // For Mifare Classic 4K big sectors it will enter always here
     uint32_t tmp = uiSector - MIFARE_CLASSIC_4K_MAX_SECTORS1;
     return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2);
@@ -230,18 +203,14 @@ uint32_t get_first_block_for_sector(uint8_t bTagType, uint32_t uiSector)
 
 uint32_t get_trailer_block_for_sector(uint8_t bTagType, uint32_t uiSector)
 {
-    if ( !is_valid_sector(bTagType, uiSector) )
+  if (!is_valid_sector(bTagType, uiSector)) {
-    {
     return MIFARE_CLASSIC_INVALID_BLOCK;
   }
 
-    if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1)
+  if (uiSector < MIFARE_CLASSIC_4K_MAX_SECTORS1) {
-    {
     // For Mifare Classic 1K, it will enter always here
     return (uiSector * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1) + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1 - 1);
-    }
+  } else {
-    else
-    {
     // For Mifare Classic 4K big sectors it will enter always here
     uint32_t tmp = uiSector - MIFARE_CLASSIC_4K_MAX_SECTORS1;
     return MIFARE_CLASSIC_4K_MAX_BLOCKS1 + (tmp * MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2) + (MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2 - 1);
@@ -253,19 +222,15 @@ uint32_t get_trailer_block_for_sector(uint8_t bTagType, uint32_t uiSector)
 
 uint32_t get_sector_for_block(uint8_t bTagType, uint32_t uiBlock)
 {
-    if ( !is_valid_block(bTagType, uiBlock) )
+  if (!is_valid_block(bTagType, uiBlock)) {
-    {
     return MIFARE_CLASSIC_INVALID_BLOCK;
   }
 
   // Test if we are in the small or big sectors
-    if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1)
+  if (uiBlock < MIFARE_CLASSIC_4K_MAX_BLOCKS1) {
-    {
     // For Mifare Classic 1K, it will enter always here
     return (uiBlock / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR1);
-    }
+  } else {
-    else
-    {
     uint32_t tmp = uiBlock - MIFARE_CLASSIC_4K_MAX_BLOCKS1;
     return MIFARE_CLASSIC_4K_MAX_SECTORS1 + (tmp / MIFARE_CLASSIC_4K_BLOCKS_PER_SECTOR2);
   }
@@ -280,26 +245,20 @@ void test_mifare_classic_blocks_sectors_functions(uint8_t bTagType)
   uint32_t i;
   uint32_t max_blocks, max_sectors;
 
-    if ( IS_MIFARE_CLASSIC_1K(bTagType) )
+  if (IS_MIFARE_CLASSIC_1K(bTagType)) {
-    {
     printf("\nMIFARE CLASSIC 1K\n");
     max_blocks = MIFARE_CLASSIC_1K_MAX_BLOCKS;
     max_sectors = MIFARE_CLASSIC_1K_MAX_SECTORS;
-    }
+  } else if (IS_MIFARE_CLASSIC_4K(bTagType)) {
-    else if ( IS_MIFARE_CLASSIC_4K(bTagType) )
-    {
     printf("\nMIFARE CLASSIC 4K\n");
     max_blocks = MIFARE_CLASSIC_4K_MAX_BLOCKS;
     max_sectors = MIFARE_CLASSIC_4K_MAX_SECTORS;
-    }
+  } else {
-    else
-    {
     return;
   }
 
   // Include one invalid block, that is why we add +1
-    for (i = 0; i<max_blocks+1; i++)
+  for (i = 0; i < max_blocks + 1; i++) {
-    {
     printf("BLOCK %d\n", i);
     printf("\t is_valid_block: %c\n", (is_valid_block(bTagType, i) ? 'Y' : 'N'));
     printf("\t is_first_block: %c\n", (is_first_block(bTagType, i) ? 'Y' : 'N'));
@@ -310,8 +269,7 @@ void test_mifare_classic_blocks_sectors_functions(uint8_t bTagType)
   }
 
   // Include one invalid sector, that is why we add +1
-    for (i = 0; i<max_sectors+1; i++)
+  for (i = 0; i < max_sectors + 1; i++) {
-    {
     printf("SECTOR %d\n", i);
     printf("\t is_valid_sector: %c\n", (is_valid_sector(bTagType, i) ? 'Y' : 'N'));
     printf("\t is_big_sector: %c\n", (is_big_sector(bTagType, i) ? 'Y' : 'N'));
@@ -327,8 +285,7 @@ bool mfcuk_save_tag_dump(const char *filename, mifare_classic_tag *tag)
   size_t result;
 
   fp = fopen(filename, "wb");
-    if (!fp)
+  if (!fp) {
-    {
     return false;
   }
 
@@ -336,8 +293,7 @@ bool mfcuk_save_tag_dump(const char *filename, mifare_classic_tag *tag)
   result = fwrite((void *) tag, sizeof(*tag), 1, fp);
 
   // If not written exactly 1 record, something is wrong
-    if (result != 1)
+  if (result != 1) {
-    {
     fclose(fp);
     return false;
   }
@@ -352,8 +308,7 @@ bool mfcuk_save_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
   size_t result;
 
   fp = fopen(filename, "wb");
-    if (!fp)
+  if (!fp) {
-    {
     return false;
   }
 
@@ -361,8 +316,7 @@ bool mfcuk_save_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
   result = fwrite((void *) tag_ext, sizeof(*tag_ext), 1, fp);
 
   // If not written exactly 1 record, something is wrong
-    if (result != 1)
+  if (result != 1) {
-    {
     fclose(fp);
     return false;
   }
@@ -377,8 +331,7 @@ bool mfcuk_load_tag_dump(const char *filename, mifare_classic_tag *tag)
   size_t result;
 
   fp = fopen(filename, "rb");
-    if (!fp)
+  if (!fp) {
-    {
     return false;
   }
 
@@ -386,8 +339,7 @@ bool mfcuk_load_tag_dump(const char *filename, mifare_classic_tag *tag)
   result = fread((void *) tag, sizeof(*tag), 1, fp);
 
   // If not read exactly 1 record, something is wrong
-    if (result != 1)
+  if (result != 1) {
-    {
     fclose(fp);
     return false;
   }
@@ -402,8 +354,7 @@ bool mfcuk_load_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
   size_t result;
 
   fp = fopen(filename, "rb");
-    if (!fp)
+  if (!fp) {
-    {
     return false;
   }
 
@@ -411,8 +362,7 @@ bool mfcuk_load_tag_dump_ext(const char *filename, mifare_classic_tag_ext *tag_e
   result = fread((void *) tag_ext, sizeof(*tag_ext), 1, fp);
 
   // If not read exactly 1 record, something is wrong
-    if (result != sizeof(*tag_ext))
+  if (result != sizeof(*tag_ext)) {
-    {
     fclose(fp);
     return false;
   }
@@ -427,15 +377,13 @@ void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag)
   uint8_t bTagType;
   mifare_classic_block_trailer *ptr_trailer = NULL;
 
-    if (!tag)
+  if (!tag) {
-    {
     return;
   }
 
   bTagType = tag->amb->mbm.btUnknown;
 
-    if ( !IS_MIFARE_CLASSIC_1K(bTagType) && !IS_MIFARE_CLASSIC_4K(bTagType) )
+  if (!IS_MIFARE_CLASSIC_1K(bTagType) && !IS_MIFARE_CLASSIC_4K(bTagType)) {
-    {
     return;
   }
 
@@ -447,21 +395,16 @@ void print_mifare_classic_tag_keys(const char *title, mifare_classic_tag *tag)
   printf("Sector\t|    Key A\t|    AC bits\t|    Key B\n");
   printf("-------------------------------------------------------\n");
 
-    if ( IS_MIFARE_CLASSIC_1K(tag->amb->mbm.btUnknown) )
+  if (IS_MIFARE_CLASSIC_1K(tag->amb->mbm.btUnknown)) {
-    {
     max_blocks = MIFARE_CLASSIC_1K_MAX_BLOCKS;
-    }
+  } else {
-    else
-    {
     max_blocks = MIFARE_CLASSIC_4K_MAX_BLOCKS;
   }
 
-    for (i=0; i<max_blocks; i++)
+  for (i = 0; i < max_blocks; i++) {
-    {
     trailer_block = get_trailer_block(bTagType, i);
 
-        if ( !is_valid_block(bTagType, trailer_block) )
+    if (!is_valid_block(bTagType, trailer_block)) {
-        {
       break;
     }
 
@@ -489,13 +432,11 @@ bool mfcuk_key_uint64_to_arr(const uint64_t *ui64Key, uint8_t *arr6Key)
 {
   int i;
 
-    if ( !ui64Key || !arr6Key )
+  if (!ui64Key || !arr6Key) {
-    {
     return false;
   }
 
-    for (i = 0; i<MIFARE_CLASSIC_KEY_BYTELENGTH; i++)
+  for (i = 0; i < MIFARE_CLASSIC_KEY_BYTELENGTH; i++) {
-    {
     arr6Key[i] = (uint8_t)(((*ui64Key) >> 8 * (MIFARE_CLASSIC_KEY_BYTELENGTH - i - 1)) & 0xFF);
   }
 
@@ -507,13 +448,11 @@ bool mfcuk_key_arr_to_uint64(const uint8_t *arr6Key, uint64_t *ui64Key)
   uint64_t key = 0;
   int i;
 
-    if ( !ui64Key || !arr6Key )
+  if (!ui64Key || !arr6Key) {
-    {
     return false;
   }
 
-    for (i = 0; i<MIFARE_CLASSIC_KEY_BYTELENGTH; i++, key <<= 8)
+  for (i = 0; i < MIFARE_CLASSIC_KEY_BYTELENGTH; i++, key <<= 8) {
-    {
     key |= arr6Key[i];
   }
   key >>= 8;

src/xgetopt.c

@@ -167,21 +167,18 @@ int getopt(int argc, char *argv[], char *optstring)
 
   optarg = NULL;
 
-	if (next == NULL || *next == '\0') 
+  if (next == NULL || *next == '\0') {
-	{ 
     if (optind == 0)
       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 = argv[optind];
       return EOF;
     }
 
-		if (strcmp(argv[optind], "--") == 0) 
+    if (strcmp(argv[optind], "--") == 0) {
-		{ 
       optind++;
       optarg = NULL;
       if (optind < argc)
@@ -201,20 +198,14 @@ int getopt(int argc, char *argv[], char *optstring)
     return '?';
 
   cp++;
-	if (*cp == ':') 
+  if (*cp == ':') {
-	{ 
+    if (*next != '\0') {
-		if (*next != '\0') 
-		{ 
       optarg = next;
       next = NULL;
-		} 
+    } else if (optind < argc) {
-		else if (optind < argc) 
-		{ 
       optarg = argv[optind];
       optind++;
-		} 
+    } else {
-		else 
-		{ 
       return '?';
     }
   }