prepare to update the LF T55XX commands

[proxmark3-svn] / client / cmdhfmf.c

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 748e9c45fbf4e5a42af13c1d2cf0c31ff49c06a1..f225359d7d8801cfb4e053f0d47bce73e1f831e1 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -7,7 +7,7 @@
 //-----------------------------------------------------------------------------\r
 // High frequency MIFARE commands\r
 //-----------------------------------------------------------------------------\r
 //-----------------------------------------------------------------------------\r
 // High frequency MIFARE commands\r
 //-----------------------------------------------------------------------------\r

-#include "../include/mifare.h"\r
+\r

 #include "cmdhfmf.h"\r
 \r
 static int CmdHelp(const char *Cmd);\r
 #include "cmdhfmf.h"\r
 \r
 static int CmdHelp(const char *Cmd);\r


@@ -34,7 +34,7 @@ start:
     SendCommand(&c);\r
        \r
        //flush queue\r
     SendCommand(&c);\r
        \r
        //flush queue\r

-       while (ukbhit()) getchar();\r
+       while (ukbhit())        getchar();\r

 \r
        // wait cycle\r
        while (true) {\r
 \r
        // wait cycle\r
        while (true) {\r


@@ -71,14 +71,14 @@ start:
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    \r
        } else {\r
                printf("------------------------------------------------------------------\n");\r
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    \r
        } else {\r
                printf("------------------------------------------------------------------\n");\r

-               PrintAndLog("Key found :%012"llx" \n", r_key);\r
+               PrintAndLog("Key found:%012"llx" \n", r_key);\r

 \r
                num_to_bytes(r_key, 6, keyBlock);\r
                isOK = mfCheckKeys(0, 0, 1, keyBlock, &r_key);\r
        }\r
        \r
        if (!isOK) \r
 \r
                num_to_bytes(r_key, 6, keyBlock);\r
                isOK = mfCheckKeys(0, 0, 1, keyBlock, &r_key);\r
        }\r
        \r
        if (!isOK) \r

-               PrintAndLog("Found valid key :%012"llx, r_key);\r
+               PrintAndLog("Found valid key:%012"llx, r_key);\r

        else\r
        {\r
                if (isOK != 2) PrintAndLog("Found invalid key. ");      \r
        else\r
        {\r
                if (isOK != 2) PrintAndLog("Found invalid key. ");      \r


@@ -278,14 +278,7 @@ int CmdHF14AMfDump(const char *Cmd)
        \r
        UsbCommand resp;\r
 \r
        \r
        UsbCommand resp;\r
 \r

-       int size = GetCardSize();               \r

        char cmdp = param_getchar(Cmd, 0);\r
        char cmdp = param_getchar(Cmd, 0);\r

-\r
-       if  ( size > -1) \r
-               cmdp = (char)(48+size);\r
-\r
-       PrintAndLog("Got %d",cmdp);\r
-               \r

        switch (cmdp) {\r
                case '0' : numSectors = 5; break;\r
                case '1' : \r
        switch (cmdp) {\r
                case '0' : numSectors = 5; break;\r
                case '1' : \r


@@ -305,7 +298,7 @@ int CmdHF14AMfDump(const char *Cmd)
        }\r
        \r
        if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r
        }\r
        \r
        if ((fin = fopen("dumpkeys.bin","rb")) == NULL) {\r

-               PrintAndLog("Could not find file dumpkeys.bin");                \r
+               PrintAndLog("Could not find file dumpkeys.bin");\r

                return 1;\r
        }\r
        \r
                return 1;\r
        }\r
        \r


@@ -328,7 +321,7 @@ int CmdHF14AMfDump(const char *Cmd)
        }\r
        \r
        fclose(fin);\r
        }\r
        \r
        fclose(fin);\r

-       \r
+\r

        PrintAndLog("|-----------------------------------------|");\r
        PrintAndLog("|------ Reading sector access bits...-----|");\r
        PrintAndLog("|-----------------------------------------|");\r
        PrintAndLog("|-----------------------------------------|");\r
        PrintAndLog("|------ Reading sector access bits...-----|");\r
        PrintAndLog("|-----------------------------------------|");\r


@@ -381,12 +374,12 @@ int CmdHF14AMfDump(const char *Cmd)
                                        received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                } else if (rights[sectorNo][data_area] == 0x07) {                                                                               // no key would work\r
                                        isOK = false;\r
                                        received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                } else if (rights[sectorNo][data_area] == 0x07) {                                                                               // no key would work\r
                                        isOK = false;\r

-                                               PrintAndLog("Access rights do not allow reading of sector %2d block %3d", sectorNo, blockNo);\r
+                                       PrintAndLog("Access rights do not allow reading of sector %2d block %3d", sectorNo, blockNo);\r

                                } else {                                                                                                                                                                // key A would work\r
                                } else {                                                                                                                                                                // key A would work\r

-                                               UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
-                                               memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
-                                               SendCommand(&c);\r
-                                               received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+                                       UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
+                                       memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+                                       SendCommand(&c);\r
+                                       received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r

                                }\r
                        }\r
 \r
                                }\r
                        }\r
 \r


@@ -433,7 +426,7 @@ int CmdHF14AMfDump(const char *Cmd)
                fclose(fout);\r
                PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);\r
        }\r
                fclose(fout);\r
                PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);\r
        }\r

-       \r
+               \r

        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r


@@ -460,7 +453,7 @@ int CmdHF14AMfRestore(const char *Cmd)
                default:   numSectors = 16;\r
        }       \r
 \r
                default:   numSectors = 16;\r
        }       \r
 \r

-       if (cmdp == 'h' || cmdp == 'H') {\r
+       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r

                PrintAndLog("Usage:   hf mf restore [card memory]");\r
                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
                PrintAndLog("");\r
                PrintAndLog("Usage:   hf mf restore [card memory]");\r
                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
                PrintAndLog("");\r


@@ -468,7 +461,7 @@ int CmdHF14AMfRestore(const char *Cmd)
                PrintAndLog("         hf mf restore 4");\r
                return 0;\r
        }\r
                PrintAndLog("         hf mf restore 4");\r
                return 0;\r
        }\r

-       \r
+\r

        if ((fkeys = fopen("dumpkeys.bin","rb")) == NULL) {\r
                PrintAndLog("Could not find file dumpkeys.bin");\r
                return 1;\r
        if ((fkeys = fopen("dumpkeys.bin","rb")) == NULL) {\r
                PrintAndLog("Could not find file dumpkeys.bin");\r
                return 1;\r


@@ -477,6 +470,8 @@ int CmdHF14AMfRestore(const char *Cmd)
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyA[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyA[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r

+\r
+                       fclose(fkeys);\r

                        return 2;\r
                }\r
        }\r
                        return 2;\r
                }\r
        }\r


@@ -484,12 +479,13 @@ int CmdHF14AMfRestore(const char *Cmd)
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyB[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyB[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r

+                       fclose(fkeys);\r

                        return 2;\r
                }\r
        }\r
 \r
        fclose(fkeys);\r
                        return 2;\r
                }\r
        }\r
 \r
        fclose(fkeys);\r

-       \r
+\r

        if ((fdump = fopen("dumpdata.bin","rb")) == NULL) {\r
                PrintAndLog("Could not find file dumpdata.bin");\r
                return 1;\r
        if ((fdump = fopen("dumpdata.bin","rb")) == NULL) {\r
                PrintAndLog("Could not find file dumpdata.bin");\r
                return 1;\r


@@ -697,13 +693,6 @@ int CmdHF14AMfNested(const char *Cmd)
                bool calibrate = true;\r
                for (i = 0; i < NESTED_SECTOR_RETRY; i++) {\r
                        for (uint8_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r
                bool calibrate = true;\r
                for (i = 0; i < NESTED_SECTOR_RETRY; i++) {\r
                        for (uint8_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {\r

-\r
-                               if (ukbhit()) {\r
-                                       printf("\naborted via keyboard!\n");\r
-                                       free(e_sector);\r
-                                       return 2;\r
-                               }                       \r
-                       \r

                                for (trgKeyType = 0; trgKeyType < 2; trgKeyType++) { \r
                                        if (e_sector[sectorNo].foundKey[trgKeyType]) continue;\r
                                        PrintAndLog("-----------------------------------------------");\r
                                for (trgKeyType = 0; trgKeyType < 2; trgKeyType++) { \r
                                        if (e_sector[sectorNo].foundKey[trgKeyType]) continue;\r
                                        PrintAndLog("-----------------------------------------------");\r


@@ -780,7 +769,7 @@ int CmdHF14AMfNested(const char *Cmd)
                        }\r
                        fclose(fkeys);\r
                }\r
                        }\r
                        fclose(fkeys);\r
                }\r

-\r
+               \r

                free(e_sector);\r
        }\r
        return 0;\r
                free(e_sector);\r
        }\r
        return 0;\r


@@ -798,8 +787,8 @@ int CmdHF14AMfChk(const char *Cmd)
                PrintAndLog("              hf mf chk *1 ? t");\r
                PrintAndLog("              hf mf chk *1 ? d");\r
                return 0;\r
                PrintAndLog("              hf mf chk *1 ? t");\r
                PrintAndLog("              hf mf chk *1 ? d");\r
                return 0;\r

-       }\r
-       \r
+       }       \r
+\r

        FILE * f;\r
        char filename[FILE_PATH_SIZE]={0};\r
        char buf[13];\r
        FILE * f;\r
        char filename[FILE_PATH_SIZE]={0};\r
        char buf[13];\r


@@ -944,8 +933,8 @@ int CmdHF14AMfChk(const char *Cmd)
                PrintAndLog("No key specified, trying default keys");\r
                for (;keycnt < defaultKeysSize; keycnt++)\r
                        PrintAndLog("chk default key[%2d] %02x%02x%02x%02x%02x%02x", keycnt,\r
                PrintAndLog("No key specified, trying default keys");\r
                for (;keycnt < defaultKeysSize; keycnt++)\r
                        PrintAndLog("chk default key[%2d] %02x%02x%02x%02x%02x%02x", keycnt,\r

-                       (keyBlock + 6*keycnt)[0],(keyBlock + 6*keycnt)[1], (keyBlock + 6*keycnt)[2],\r
-                       (keyBlock + 6*keycnt)[3], (keyBlock + 6*keycnt)[4],     (keyBlock + 6*keycnt)[5], 6);\r
+                               (keyBlock + 6*keycnt)[0],(keyBlock + 6*keycnt)[1], (keyBlock + 6*keycnt)[2],\r
+                               (keyBlock + 6*keycnt)[3], (keyBlock + 6*keycnt)[4],     (keyBlock + 6*keycnt)[5], 6);\r

        }\r
        \r
        // initialize storage for found keys\r
        }\r
        \r
        // initialize storage for found keys\r


@@ -990,13 +979,13 @@ int CmdHF14AMfChk(const char *Cmd)
                                for (uint16_t t = 0; t < 2; t++) {\r
                                        if (validKey[t][sectorNo]) {\r
                                                memcpy(block + t*10, foundKey[t][sectorNo], 6);\r
                                for (uint16_t t = 0; t < 2; t++) {\r
                                        if (validKey[t][sectorNo]) {\r
                                                memcpy(block + t*10, foundKey[t][sectorNo], 6);\r

-               }\r
-                       }\r
+                                       }\r
+                               }\r

                                mfEmlSetMem(block, FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 1);\r
                        }\r
                }\r
                PrintAndLog("Found keys have been transferred to the emulator memory");\r
                                mfEmlSetMem(block, FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 1);\r
                        }\r
                }\r
                PrintAndLog("Found keys have been transferred to the emulator memory");\r

-                       }\r
+       }\r

 \r
        if (createDumpFile) {\r
                FILE *fkeys = fopen("dumpkeys.bin","wb");\r
 \r
        if (createDumpFile) {\r
                FILE *fkeys = fopen("dumpkeys.bin","wb");\r


@@ -1004,7 +993,7 @@ int CmdHF14AMfChk(const char *Cmd)
                        PrintAndLog("Could not create file dumpkeys.bin");\r
                        free(keyBlock);\r
                        return 1;\r
                        PrintAndLog("Could not create file dumpkeys.bin");\r
                        free(keyBlock);\r
                        return 1;\r

-                       }\r
+               }\r

                for (uint16_t t = 0; t < 2; t++) {\r
                        fwrite(foundKey[t], 1, 6*SectorsCnt, fkeys);\r
                }\r
                for (uint16_t t = 0; t < 2; t++) {\r
                        fwrite(foundKey[t], 1, 6*SectorsCnt, fkeys);\r
                }\r


@@ -1014,7 +1003,7 @@ int CmdHF14AMfChk(const char *Cmd)
 \r
        free(keyBlock);\r
        PrintAndLog("");\r
 \r
        free(keyBlock);\r
        PrintAndLog("");\r

-  return 0;\r
+       return 0;\r

 }\r
 \r
 int CmdHF14AMf1kSim(const char *Cmd)\r
 }\r
 \r
 int CmdHF14AMf1kSim(const char *Cmd)\r


@@ -1023,12 +1012,16 @@ int CmdHF14AMf1kSim(const char *Cmd)
        uint8_t exitAfterNReads = 0;\r
        uint8_t flags = 0;\r
 \r
        uint8_t exitAfterNReads = 0;\r
        uint8_t flags = 0;\r
 \r

-       if (param_getchar(Cmd, 0) == 'h') {\r
+       uint8_t cmdp = param_getchar(Cmd, 0);\r
+       \r
+       if (cmdp == 'h' || cmdp == 'H') {\r

                PrintAndLog("Usage:  hf mf sim  u <uid (8 hex symbols)> n <numreads> i x");\r
                PrintAndLog("Usage:  hf mf sim  u <uid (8 hex symbols)> n <numreads> i x");\r

+               PrintAndLog("           h    this help");\r

                PrintAndLog("           u    (Optional) UID. If not specified, the UID from emulator memory will be used");\r
                PrintAndLog("           n    (Optional) Automatically exit simulation after <numreads> blocks have been read by reader. 0 = infinite");\r
                PrintAndLog("           i    (Optional) Interactive, means that console will not be returned until simulation finishes or is aborted");\r
                PrintAndLog("           x    (Optional) Crack, performs the 'reader attack', nr/ar attack against a legitimate reader, fishes out the key(s)");\r
                PrintAndLog("           u    (Optional) UID. If not specified, the UID from emulator memory will be used");\r
                PrintAndLog("           n    (Optional) Automatically exit simulation after <numreads> blocks have been read by reader. 0 = infinite");\r
                PrintAndLog("           i    (Optional) Interactive, means that console will not be returned until simulation finishes or is aborted");\r
                PrintAndLog("           x    (Optional) Crack, performs the 'reader attack', nr/ar attack against a legitimate reader, fishes out the key(s)");\r

+               PrintAndLog("");\r

                PrintAndLog("           sample: hf mf sim u 0a0a0a0a ");\r
                return 0;\r
        }\r
                PrintAndLog("           sample: hf mf sim u 0a0a0a0a ");\r
                return 0;\r
        }\r


@@ -1109,7 +1102,7 @@ int CmdHF14AMfDbg(const char *Cmd)
 int CmdHF14AMfEGet(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r
 int CmdHF14AMfEGet(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r

-       uint8_t data[16];\r
+       uint8_t data[16] = {0x00};\r

 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf eget <block number>");\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf eget <block number>");\r


@@ -1176,14 +1169,11 @@ int CmdHF14AMfELoad(const char *Cmd)
        FILE * f;\r
        char filename[FILE_PATH_SIZE];\r
        char *fnameptr = filename;\r
        FILE * f;\r
        char filename[FILE_PATH_SIZE];\r
        char *fnameptr = filename;\r

-       char buf[64];\r
-       uint8_t buf8[64];\r
+       char buf[64] = {0x00};\r
+       uint8_t buf8[64] = {0x00};\r

        int i, len, blockNum, numBlocks;\r
        int nameParamNo = 1;\r
        \r
        int i, len, blockNum, numBlocks;\r
        int nameParamNo = 1;\r
        \r

-       memset(filename, 0, sizeof(filename));\r
-       memset(buf, 0, sizeof(buf));\r
-\r

        char ctmp = param_getchar(Cmd, 0);\r
                \r
        if ( ctmp == 'h' || ctmp == 0x00) {\r
        char ctmp = param_getchar(Cmd, 0);\r
                \r
        if ( ctmp == 'h' || ctmp == 0x00) {\r


@@ -1223,9 +1213,6 @@ int CmdHF14AMfELoad(const char *Cmd)
                return 1;\r
        }\r
        \r
                return 1;\r
        }\r
        \r

-//             for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
-//             for(blockNo = 0; blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
-       \r

        blockNum = 0;\r
        while(!feof(f)){\r
                memset(buf, 0, sizeof(buf));\r
        blockNum = 0;\r
        while(!feof(f)){\r
                memset(buf, 0, sizeof(buf));\r


@@ -1243,6 +1230,7 @@ int CmdHF14AMfELoad(const char *Cmd)
                        if(strlen(buf) && feof(f))\r
                                break;\r
                        PrintAndLog("File content error. Block data must include 32 HEX symbols");\r
                        if(strlen(buf) && feof(f))\r
                                break;\r
                        PrintAndLog("File content error. Block data must include 32 HEX symbols");\r

+                       fclose(f);\r

                        return 2;\r
                }\r
                \r
                        return 2;\r
                }\r
                \r


@@ -1252,17 +1240,19 @@ int CmdHF14AMfELoad(const char *Cmd)
                \r
                if (mfEmlSetMem(buf8, blockNum, 1)) {\r
                        PrintAndLog("Cant set emul block: %3d", blockNum);\r
                \r
                if (mfEmlSetMem(buf8, blockNum, 1)) {\r
                        PrintAndLog("Cant set emul block: %3d", blockNum);\r

+                       fclose(f);\r

                        return 3;\r
                }\r
                        return 3;\r
                }\r

+               printf(".");\r

                blockNum++;\r
                \r
                if (blockNum >= numBlocks) break;\r
        }\r
        fclose(f);\r
                blockNum++;\r
                \r
                if (blockNum >= numBlocks) break;\r
        }\r
        fclose(f);\r

+       printf("\n");\r

        \r
        if ((blockNum != numBlocks)) {\r
                PrintAndLog("File content error. Got %d must be %d blocks.",blockNum, numBlocks);\r
        \r
        if ((blockNum != numBlocks)) {\r
                PrintAndLog("File content error. Got %d must be %d blocks.",blockNum, numBlocks);\r

-               fclose(f);\r

                return 4;\r
        }\r
        PrintAndLog("Loaded %d blocks from file: %s", blockNum, filename);\r
                return 4;\r
        }\r
        PrintAndLog("Loaded %d blocks from file: %s", blockNum, filename);\r


@@ -1284,8 +1274,8 @@ int CmdHF14AMfESave(const char *Cmd)
 \r
        char ctmp = param_getchar(Cmd, 0);\r
        \r
 \r
        char ctmp = param_getchar(Cmd, 0);\r
        \r

-       if ( ctmp == 'h') {\r
-               PrintAndLog("It saves emul dump into the file `filename.eml` or `cardID.eml`");         \r
+       if ( ctmp == 'h' || ctmp == 'H') {\r
+               PrintAndLog("It saves emul dump into the file `filename.eml` or `cardID.eml`");\r

                PrintAndLog(" Usage:  hf mf esave [card memory] [file name w/o `.eml`]");\r
                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
                PrintAndLog("");\r
                PrintAndLog(" Usage:  hf mf esave [card memory] [file name w/o `.eml`]");\r
                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
                PrintAndLog("");\r


@@ -1294,7 +1284,7 @@ int CmdHF14AMfESave(const char *Cmd)
                PrintAndLog("         hf mf esave 4 filename");\r
                return 0;\r
        }       \r
                PrintAndLog("         hf mf esave 4 filename");\r
                return 0;\r
        }       \r

-       \r
+\r

        switch (ctmp) {\r
                case '0' : numBlocks = 5*4; break;\r
                case '1' : \r
        switch (ctmp) {\r
                case '0' : numBlocks = 5*4; break;\r
                case '1' : \r


@@ -1330,6 +1320,11 @@ int CmdHF14AMfESave(const char *Cmd)
        // open file\r
        f = fopen(filename, "w+");\r
 \r
        // open file\r
        f = fopen(filename, "w+");\r
 \r

+       if ( !f ) {\r
+               PrintAndLog("Can't open file %s ", filename);\r
+               return 1;\r
+       }\r
+       \r

        // put hex\r
        for (i = 0; i < numBlocks; i++) {\r
                if (mfEmlGetMem(buf, i, 1)) {\r
        // put hex\r
        for (i = 0; i < numBlocks; i++) {\r
                if (mfEmlGetMem(buf, i, 1)) {\r


@@ -1456,7 +1451,7 @@ int CmdHF14AMfCSetUID(const char *Cmd)
        char ctmp = param_getchar(Cmd, 1);\r
        if (ctmp == 'w' || ctmp == 'W') wipeCard = 1;\r
        \r
        char ctmp = param_getchar(Cmd, 1);\r
        if (ctmp == 'w' || ctmp == 'W') wipeCard = 1;\r
        \r

-       PrintAndLog("--wipe card:%02x uid:%s", wipeCard, sprint_hex(uid, 4));\r
+       PrintAndLog("--wipe card:%s  uid:%s", (wipeCard)?"YES":"NO", sprint_hex(uid, 4));\r

 \r
        res = mfCSetUID(uid, oldUid, wipeCard);\r
        if (res) {\r
 \r
        res = mfCSetUID(uid, oldUid, wipeCard);\r
        if (res) {\r


@@ -1465,16 +1460,16 @@ int CmdHF14AMfCSetUID(const char *Cmd)
                }\r
        \r
        PrintAndLog("old UID:%s", sprint_hex(oldUid, 4));\r
                }\r
        \r
        PrintAndLog("old UID:%s", sprint_hex(oldUid, 4));\r

+       PrintAndLog("new UID:%s", sprint_hex(uid, 4));\r

        return 0;\r
 }\r
 \r
 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r
        return 0;\r
 }\r
 \r
 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r

-       uint8_t uid[8];\r
-       uint8_t memBlock[16];\r
+       uint8_t uid[8] = {0x00};\r
+       uint8_t memBlock[16] = {0x00};\r

        uint8_t blockNo = 0;\r
        int res;\r
        uint8_t blockNo = 0;\r
        int res;\r

-       memset(memBlock, 0x00, sizeof(memBlock));\r

 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf csetblk <block number> <block data (32 hex symbols)>");\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf csetblk <block number> <block data (32 hex symbols)>");\r


@@ -1499,7 +1494,6 @@ int CmdHF14AMfCSetBlk(const char *Cmd)
                        return 1;\r
                }\r
        \r
                        return 1;\r
                }\r
        \r

-       PrintAndLog("UID:%s", sprint_hex(uid, 4));\r

        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r


@@ -1507,18 +1501,15 @@ int CmdHF14AMfCSetBlk(const char *Cmd)
 int CmdHF14AMfCLoad(const char *Cmd)\r
 {\r
        FILE * f;\r
 int CmdHF14AMfCLoad(const char *Cmd)\r
 {\r
        FILE * f;\r

-       char filename[FILE_PATH_SIZE];\r
+       char filename[FILE_PATH_SIZE] = {0x00};\r

        char * fnameptr = filename;\r
        char * fnameptr = filename;\r

-       char buf[64];\r
-       uint8_t buf8[64];\r
+       char buf[64] = {0x00};\r
+       uint8_t buf8[64] = {0x00};\r

        uint8_t fillFromEmulator = 0;\r
        int i, len, blockNum, flags;\r
        \r
        uint8_t fillFromEmulator = 0;\r
        int i, len, blockNum, flags;\r
        \r

-       memset(filename, 0, sizeof(filename));\r
-       memset(buf, 0, sizeof(buf));\r
-\r

        if (param_getchar(Cmd, 0) == 'h' || param_getchar(Cmd, 0)== 0x00) {\r
        if (param_getchar(Cmd, 0) == 'h' || param_getchar(Cmd, 0)== 0x00) {\r

-               PrintAndLog("It loads magic Chinese card (only works with!!!) from the file `filename.eml`");\r
+               PrintAndLog("It loads magic Chinese card from the file `filename.eml`");\r

                PrintAndLog("or from emulator memory (option `e`)");\r
                PrintAndLog("Usage:  hf mf cload <file name w/o `.eml`>");\r
                PrintAndLog("   or:  hf mf cload e ");\r
                PrintAndLog("or from emulator memory (option `e`)");\r
                PrintAndLog("Usage:  hf mf cload <file name w/o `.eml`>");\r
                PrintAndLog("   or:  hf mf cload e ");\r


@@ -1565,7 +1556,9 @@ int CmdHF14AMfCLoad(const char *Cmd)
                blockNum = 0;\r
                flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                while(!feof(f)){\r
                blockNum = 0;\r
                flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                while(!feof(f)){\r

+               \r

                        memset(buf, 0, sizeof(buf));\r
                        memset(buf, 0, sizeof(buf));\r

+                       \r

                        if (fgets(buf, sizeof(buf), f) == NULL) {\r
                                PrintAndLog("File reading error.");\r
                                return 2;\r
                        if (fgets(buf, sizeof(buf), f) == NULL) {\r
                                PrintAndLog("File reading error.");\r
                                return 2;\r


@@ -1600,6 +1593,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                PrintAndLog("Loaded from file: %s", filename);\r
                return 0;\r
        }\r
                PrintAndLog("Loaded from file: %s", filename);\r
                return 0;\r
        }\r

+       return 0;\r

 }\r
 \r
 int CmdHF14AMfCGetBlk(const char *Cmd) {\r
 }\r
 \r
 int CmdHF14AMfCGetBlk(const char *Cmd) {\r


@@ -1631,10 +1625,9 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
 \r
 \r
 int CmdHF14AMfCGetSc(const char *Cmd) {\r
 \r
 \r
 int CmdHF14AMfCGetSc(const char *Cmd) {\r

-       uint8_t memBlock[16];\r
+       uint8_t memBlock[16] = {0x00};\r

        uint8_t sectorNo = 0;\r
        int i, res, flags;\r
        uint8_t sectorNo = 0;\r
        int i, res, flags;\r

-       memset(memBlock, 0x00, sizeof(memBlock));\r

 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf cgetsc <sector number>");\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("Usage:  hf mf cgetsc <sector number>");\r


@@ -1671,14 +1664,14 @@ int CmdHF14AMfCGetSc(const char *Cmd) {
 int CmdHF14AMfCSave(const char *Cmd) {\r
 \r
        FILE * f;\r
 int CmdHF14AMfCSave(const char *Cmd) {\r
 \r
        FILE * f;\r

-       char filename[FILE_PATH_SIZE];\r
+       char filename[FILE_PATH_SIZE] = {0x00};\r

        char * fnameptr = filename;\r
        uint8_t fillFromEmulator = 0;\r
        char * fnameptr = filename;\r
        uint8_t fillFromEmulator = 0;\r

-       uint8_t buf[64];\r
+       uint8_t buf[64] = {0x00};\r

        int i, j, len, flags;\r
        \r
        int i, j, len, flags;\r
        \r

-       memset(filename, 0, sizeof(filename));\r
-       memset(buf, 0, sizeof(buf));\r
+       // memset(filename, 0, sizeof(filename));\r
+       // memset(buf, 0, sizeof(buf));\r

 \r
        if (param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("It saves `magic Chinese` card dump into the file `filename.eml` or `cardID.eml`");\r
 \r
        if (param_getchar(Cmd, 0) == 'h') {\r
                PrintAndLog("It saves `magic Chinese` card dump into the file `filename.eml` or `cardID.eml`");\r


@@ -1733,6 +1726,11 @@ int CmdHF14AMfCSave(const char *Cmd) {
                // open file\r
                f = fopen(filename, "w+");\r
 \r
                // open file\r
                f = fopen(filename, "w+");\r
 \r

+               if (f == NULL) {\r
+                       PrintAndLog("File not found or locked.");\r
+                       return 1;\r
+               }\r
+\r

                // put hex\r
                flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                for (i = 0; i < 16 * 4; i++) {\r
                // put hex\r
                flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                for (i = 0; i < 16 * 4; i++) {\r


@@ -1767,18 +1765,19 @@ int CmdHF14AMfSniff(const char *Cmd){
        int res = 0;\r
        int len = 0;\r
        int blockLen = 0;\r
        int res = 0;\r
        int len = 0;\r
        int blockLen = 0;\r

-       int num = 0;\r

        int pckNum = 0;\r
        int pckNum = 0;\r

+       int num = 0;\r

        uint8_t uid[7];\r
        uint8_t uid_len;\r
        uint8_t uid[7];\r
        uint8_t uid_len;\r

-       uint8_t atqa[2];\r
+       uint8_t atqa[2] = {0x00};\r

        uint8_t sak;\r
        bool isTag;\r
        uint8_t sak;\r
        bool isTag;\r

-       uint8_t buf[3000];\r
-       uint8_t * bufPtr = buf;\r
-       memset(buf, 0x00, 3000);\r
+       uint8_t *buf = NULL;\r
+       uint16_t bufsize = 0;\r
+       uint8_t *bufPtr = NULL;\r

        \r
        \r

-       if (param_getchar(Cmd, 0) == 'h') {\r
+       char ctmp = param_getchar(Cmd, 0);\r
+       if ( ctmp == 'h' || ctmp == 'H' ) {\r

                PrintAndLog("It continuously gets data from the field and saves it to: log, emulator, emulator file.");\r
                PrintAndLog("You can specify:");\r
                PrintAndLog("    l - save encrypted sequence to logfile `uid.log`");\r
                PrintAndLog("It continuously gets data from the field and saves it to: log, emulator, emulator file.");\r
                PrintAndLog("You can specify:");\r
                PrintAndLog("    l - save encrypted sequence to logfile `uid.log`");\r


@@ -1791,7 +1790,7 @@ int CmdHF14AMfSniff(const char *Cmd){
        }       \r
        \r
        for (int i = 0; i < 4; i++) {\r
        }       \r
        \r
        for (int i = 0; i < 4; i++) {\r

-               char ctmp = param_getchar(Cmd, i);\r
+               ctmp = param_getchar(Cmd, i);\r

                if (ctmp == 'l' || ctmp == 'L') wantLogToFile = true;\r
                if (ctmp == 'd' || ctmp == 'D') wantDecrypt = true;\r
                //if (ctmp == 'e' || ctmp == 'E') wantSaveToEml = true; TODO\r
                if (ctmp == 'l' || ctmp == 'L') wantLogToFile = true;\r
                if (ctmp == 'd' || ctmp == 'D') wantDecrypt = true;\r
                //if (ctmp == 'e' || ctmp == 'E') wantSaveToEml = true; TODO\r


@@ -1818,32 +1817,47 @@ int CmdHF14AMfSniff(const char *Cmd){
                        break;\r
                }\r
                \r
                        break;\r
                }\r
                \r

-    UsbCommand resp;\r
-    if (WaitForResponseTimeout(CMD_ACK,&resp,2000)) {\r
+               UsbCommand resp;\r
+               if (WaitForResponseTimeout(CMD_ACK,&resp,2000)) {\r

                        res = resp.arg[0] & 0xff;\r
                        res = resp.arg[0] & 0xff;\r

-                       len = resp.arg[1];\r
-                       num = resp.arg[2];\r
-                       \r
-                       if (res == 0) return 0;\r
-                       if (res == 1) {\r
-                               if (num ==0) {\r
+                       uint16_t traceLen = resp.arg[1];\r
+                       len = resp.arg[2];\r
+\r
+                       if (res == 0) return 0;                                         // we are done\r
+\r
+                       if (res == 1) {                                                         // there is (more) data to be transferred\r
+                               if (pckNum == 0) {                                              // first packet, (re)allocate necessary buffer\r
+                                       if (traceLen > bufsize) {\r
+                                               uint8_t *p;\r
+                                               if (buf == NULL) {                              // not yet allocated\r
+                                                       p = malloc(traceLen);\r
+                                               } else {                                                // need more memory\r
+                                                       p = realloc(buf, traceLen);\r
+                                               }\r
+                                               if (p == NULL) {\r
+                                                       PrintAndLog("Cannot allocate memory for trace");\r
+                                                       free(buf);\r
+                                                       return 2;\r
+                                               }\r
+                                               buf = p;\r
+                                       }\r

                                        bufPtr = buf;\r
                                        bufPtr = buf;\r

-                                       memset(buf, 0x00, 3000);\r
+                                       bufsize = traceLen;\r
+                                       memset(buf, 0x00, traceLen);\r

                                }\r
                                memcpy(bufPtr, resp.d.asBytes, len);\r
                                bufPtr += len;\r
                                pckNum++;\r
                        }\r
                                }\r
                                memcpy(bufPtr, resp.d.asBytes, len);\r
                                bufPtr += len;\r
                                pckNum++;\r
                        }\r

-                       if (res == 2) {\r
+\r
+                       if (res == 2) {                                                         // received all data, start displaying\r

                                blockLen = bufPtr - buf;\r
                                bufPtr = buf;\r
                                printf(">\n");\r
                                PrintAndLog("received trace len: %d packages: %d", blockLen, pckNum);\r
                                blockLen = bufPtr - buf;\r
                                bufPtr = buf;\r
                                printf(">\n");\r
                                PrintAndLog("received trace len: %d packages: %d", blockLen, pckNum);\r

-                               num = 0;\r

                                while (bufPtr - buf < blockLen) {\r
                                while (bufPtr - buf < blockLen) {\r

-                                       bufPtr += 6;\r
+                                       bufPtr += 6;                                            // skip (void) timing information\r

                                        len = *((uint16_t *)bufPtr);\r
                                        len = *((uint16_t *)bufPtr);\r

-\r

                                        if(len & 0x8000) {\r
                                                isTag = true;\r
                                                len &= 0x7fff;\r
                                        if(len & 0x8000) {\r
                                                isTag = true;\r
                                                len &= 0x7fff;\r


@@ -1852,12 +1866,10 @@ int CmdHF14AMfSniff(const char *Cmd){
                                        }\r
                                        bufPtr += 2;\r
                                        if ((len == 14) && (bufPtr[0] == 0xff) && (bufPtr[1] == 0xff) && (bufPtr[12] == 0xff) && (bufPtr[13] == 0xff)) {\r
                                        }\r
                                        bufPtr += 2;\r
                                        if ((len == 14) && (bufPtr[0] == 0xff) && (bufPtr[1] == 0xff) && (bufPtr[12] == 0xff) && (bufPtr[13] == 0xff)) {\r

-                                       \r

                                                memcpy(uid, bufPtr + 2, 7);\r
                                                memcpy(atqa, bufPtr + 2 + 7, 2);\r
                                                uid_len = (atqa[0] & 0xC0) == 0x40 ? 7 : 4;\r
                                                sak = bufPtr[11];\r
                                                memcpy(uid, bufPtr + 2, 7);\r
                                                memcpy(atqa, bufPtr + 2 + 7, 2);\r
                                                uid_len = (atqa[0] & 0xC0) == 0x40 ? 7 : 4;\r
                                                sak = bufPtr[11];\r

-                                               \r

                                                PrintAndLog("tag select uid:%s atqa:0x%02x%02x sak:0x%02x", \r
                                                        sprint_hex(uid + (7 - uid_len), uid_len),\r
                                                        atqa[1], \r
                                                PrintAndLog("tag select uid:%s atqa:0x%02x%02x sak:0x%02x", \r
                                                        sprint_hex(uid + (7 - uid_len), uid_len),\r
                                                        atqa[1], \r


@@ -1875,118 +1887,26 @@ int CmdHF14AMfSniff(const char *Cmd){
                                                        AddLogHex(logHexFileName, isTag ? "TAG: ":"RDR: ", bufPtr, len);\r
                                                if (wantDecrypt) \r
                                                        mfTraceDecode(bufPtr, len, wantSaveToEmlFile);\r
                                                        AddLogHex(logHexFileName, isTag ? "TAG: ":"RDR: ", bufPtr, len);\r
                                                if (wantDecrypt) \r
                                                        mfTraceDecode(bufPtr, len, wantSaveToEmlFile);\r

+                                               num++;  \r

                                        }\r
                                        bufPtr += len;\r
                                        }\r
                                        bufPtr += len;\r

-                                       bufPtr += ((len-1)/8+1); // ignore parity\r
-                                       num++;\r
+                                       bufPtr += ((len-1)/8+1);        // ignore parity\r

                                }\r
                                }\r

+                               pckNum = 0;\r

                        }\r
                } // resp not NULL\r
        } // while (true)\r
                        }\r
                } // resp not NULL\r
        } // while (true)\r

-       \r
+\r
+       free(buf);\r

        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-// Tries to identify cardsize.\r
-// Returns <num>  where num is:\r
-// -1  unidentified\r
-//  0 - MINI (320bytes)\r
-//  1 - 1K\r
-//  2 - 2K\r
-//  4 - 4K\r
-int GetCardSize()\r
-{\r
-       UsbCommand c = {CMD_READER_ISO_14443a, {ISO14A_CONNECT, 0, 0}};\r
-       SendCommand(&c);\r
-\r
-       UsbCommand resp;\r
-       WaitForResponse(CMD_ACK,&resp);\r
-\r
-       if(resp.arg[0] == 0) {\r
-               PrintAndLog("iso14443a card select failed");\r
-               return -1;\r
-       }\r
-       \r
-       iso14a_card_select_t *card = (iso14a_card_select_t *)resp.d.asBytes;\r
-\r
-       PrintAndLog("Trying to detect card size.");\r
-       \r
-       uint16_t atqa = 0;\r
-       uint8_t sak = 0;\r
-       atqa = (card->atqa[1] & 0xff) << 8;\r
-    atqa += card->atqa[0] & 0xff;\r
-       sak = card->sak;\r
-       \r
-       // https://code.google.com/p/libnfc/source/browse/libnfc/target-subr.c\r
-       \r
-       PrintAndLog("found ATAQ: %04X SAK: %02X", atqa, sak);\r
-       \r
-       \r
-       // NXP MIFARE Mini 0.3k\r
-       if ( ( (atqa & 0xff0f) == 0x0004) && (sak == 0x09) ) return 0;\r
-       \r
-       // MIFARE Classic 1K\r
-       if ( ((atqa & 0xff0f) == 0x0004) && (sak == 0x08) ) return 1;\r
-       \r
-       // MIFARE Classik 4K\r
-       if ( ((atqa & 0xff0f) == 0x0002) && (sak == 0x18) ) return 4;\r
-       \r
-       // SmartMX with MIFARE 1K emulation \r
-       if ( ((atqa & 0xf0ff) == 0x0004) ) return 1;\r
-\r
-       // SmartMX with MIFARE 4K emulation \r
-       if ( ((atqa & 0xf0ff) == 0x0002) ) return 4;    \r
-       \r
-       // Infineon MIFARE CLASSIC 1K\r
-       if ( ((atqa & 0xffff) == 0x0004) && (sak == 0x88) ) return 1;\r
-       \r
-       // MFC 4K emulated by Nokia 6212 Classic\r
-       if ( ((atqa & 0xffff) == 0x0002) && (sak == 0x38) ) return 4;\r
-\r
-       // MFC 4K emulated by Nokia 6131 NFC\r
-       if ( ((atqa & 0xffff) == 0x0008) && (sak == 0x38) ) return 4;\r
-\r
-       \r
-       PrintAndLog("BEFOOO  1K %02X",  (atqa & 0xff0f));\r
-       \r
-       // MIFARE Plus (4 Byte UID or 4 Byte RID)\r
-       // MIFARE Plus (7 Byte UID)\r
-       if (\r
-                       ((atqa & 0xffff) == 0x0002) |\r
-                       ((atqa & 0xffff) == 0x0004) |\r
-                       ((atqa & 0xffff) == 0x0042) |   \r
-                       ((atqa & 0xffff) == 0x0044) \r
-               )\r
-       {\r
-               switch(sak){\r
-                       case 0x08:\r
-                       case 0x10: {\r
-                       //case 0x20:\r
-                               PrintAndLog("2");\r
-                               return 2;\r
-                               break;\r
-                               }\r
-                       case 0x11:\r
-                       case 0x18:{\r
-                       //case 0x20:\r
-                               PrintAndLog("4");\r
-                               return 4;\r
-                               break;\r
-                               }\r
-               }\r
-       }\r
-       \r
-       return -1;\r
-}\r

 \r
 static command_t CommandTable[] =\r
 {\r
   {"help",             CmdHelp,                                1, "This help"},\r
   {"dbg",              CmdHF14AMfDbg,                  0, "Set default debug mode"},\r
   {"rdbl",             CmdHF14AMfRdBl,                 0, "Read MIFARE classic block"},\r
 \r
 static command_t CommandTable[] =\r
 {\r
   {"help",             CmdHelp,                                1, "This help"},\r
   {"dbg",              CmdHF14AMfDbg,                  0, "Set default debug mode"},\r
   {"rdbl",             CmdHF14AMfRdBl,                 0, "Read MIFARE classic block"},\r

-  //{"urdbl",              CmdHF14AMfURdBl,                 0, "Read MIFARE Ultralight block"},\r
-  //{"urdcard",           CmdHF14AMfURdCard,               0,"Read MIFARE Ultralight Card"},\r
-  //{"uwrbl",          CmdHF14AMfUWrBl,                0,"Write MIFARE Ultralight block"},\r

   {"rdsc",             CmdHF14AMfRdSc,                 0, "Read MIFARE classic sector"},\r
   {"dump",             CmdHF14AMfDump,                 0, "Dump MIFARE classic tag to binary file"},\r
   {"restore",  CmdHF14AMfRestore,              0, "Restore MIFARE classic binary file to BLANK tag"},\r
   {"rdsc",             CmdHF14AMfRdSc,                 0, "Read MIFARE classic sector"},\r
   {"dump",             CmdHF14AMfDump,                 0, "Dump MIFARE classic tag to binary file"},\r
   {"restore",  CmdHF14AMfRestore,              0, "Restore MIFARE classic binary file to BLANK tag"},\r


@@ -2004,9 +1924,9 @@ static command_t CommandTable[] =
   {"ecfill",   CmdHF14AMfECFill,               0, "Fill simulator memory with help of keys from simulator"},\r
   {"ekeyprn",  CmdHF14AMfEKeyPrn,              0, "Print keys from simulator memory"},\r
   {"csetuid",  CmdHF14AMfCSetUID,              0, "Set UID for magic Chinese card"},\r
   {"ecfill",   CmdHF14AMfECFill,               0, "Fill simulator memory with help of keys from simulator"},\r
   {"ekeyprn",  CmdHF14AMfEKeyPrn,              0, "Print keys from simulator memory"},\r
   {"csetuid",  CmdHF14AMfCSetUID,              0, "Set UID for magic Chinese card"},\r

-  {"csetblk",  CmdHF14AMfCSetBlk,              0, "Write block into magic Chinese card"},\r
-  {"cgetblk",  CmdHF14AMfCGetBlk,              0, "Read block from magic Chinese card"},\r
-  {"cgetsc",   CmdHF14AMfCGetSc,               0, "Read sector from magic Chinese card"},\r
+  {"csetblk",  CmdHF14AMfCSetBlk,              0, "Write block - Magic Chinese card"},\r
+  {"cgetblk",  CmdHF14AMfCGetBlk,              0, "Read block - Magic Chinese card"},\r
+  {"cgetsc",   CmdHF14AMfCGetSc,               0, "Read sector - Magic Chinese card"},\r

   {"cload",            CmdHF14AMfCLoad,                0, "Load dump into magic Chinese card"},\r
   {"csave",            CmdHF14AMfCSave,                0, "Save dump from magic Chinese card into file or emulator"},\r
   {NULL, NULL, 0, NULL}\r
   {"cload",            CmdHF14AMfCLoad,                0, "Load dump into magic Chinese card"},\r
   {"csave",            CmdHF14AMfCSave,                0, "Save dump from magic Chinese card into file or emulator"},\r
   {NULL, NULL, 0, NULL}\r