FIX: The input handling for "hf 14b write" is now correct. Thanks Asper for spotting...

[proxmark3-svn] / client / cmdhfmf.c

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 6d0bebd7f15f6cfbc7d30288710abdff033780ab..7ad6e0a1eee9e5cff32b1b76a7d86804d5b82a1e 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -36,7 +36,6 @@ start:
        //flush queue\r
        while (ukbhit())        getchar();\r
 \r
        //flush queue\r
        while (ukbhit())        getchar();\r
 \r

-       \r

        // wait cycle\r
        while (true) {\r
         printf(".");\r
        // wait cycle\r
        while (true) {\r
         printf(".");\r


@@ -67,8 +66,7 @@ start:
        if (isOK != 1) return 1;\r
        \r
        // execute original function from util nonce2key\r
        if (isOK != 1) return 1;\r
        \r
        // execute original function from util nonce2key\r

-       if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key))\r
-       {\r
+       if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key)) {\r

                isOK = 2;\r
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    \r
        } else {\r
                isOK = 2;\r
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    \r
        } else {\r


@@ -78,6 +76,7 @@ start:
                num_to_bytes(r_key, 6, keyBlock);\r
                isOK = mfCheckKeys(0, 0, 1, keyBlock, &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
                PrintAndLog("Found valid key:%012"llx, r_key);\r
        else\r
        if (!isOK) \r
                PrintAndLog("Found valid key:%012"llx, r_key);\r
        else\r


@@ -88,6 +87,7 @@ start:
                goto start;\r
        }\r
        \r
                goto start;\r
        }\r
        \r

+       PrintAndLog("");\r

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


@@ -437,7 +437,6 @@ int CmdHF14AMfRdSc(const char *Cmd)
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r

-\r

 uint8_t FirstBlockOfSector(uint8_t sectorNo)\r
 {\r
        if (sectorNo < 32) {\r
 uint8_t FirstBlockOfSector(uint8_t sectorNo)\r
 {\r
        if (sectorNo < 32) {\r


@@ -447,7 +446,6 @@ uint8_t FirstBlockOfSector(uint8_t sectorNo)
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-\r

 uint8_t NumBlocksPerSector(uint8_t sectorNo)\r
 {\r
        if (sectorNo < 32) {\r
 uint8_t NumBlocksPerSector(uint8_t sectorNo)\r
 {\r
        if (sectorNo < 32) {\r


@@ -457,7 +455,6 @@ uint8_t NumBlocksPerSector(uint8_t sectorNo)
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-\r

 int CmdHF14AMfDump(const char *Cmd)\r
 {\r
        uint8_t sectorNo, blockNo;\r
 int CmdHF14AMfDump(const char *Cmd)\r
 {\r
        uint8_t sectorNo, blockNo;\r


@@ -497,8 +494,7 @@ int CmdHF14AMfDump(const char *Cmd)
                return 1;\r
        }\r
        \r
                return 1;\r
        }\r
        \r

-       // Read key file\r
-\r
+       // Read keys A from file\r

        for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
                if (fread( keyA[sectorNo], 1, 6, fin ) == 0) {\r
                        PrintAndLog("File reading error.");\r
        for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
                if (fread( keyA[sectorNo], 1, 6, fin ) == 0) {\r
                        PrintAndLog("File reading error.");\r


@@ -507,6 +503,7 @@ int CmdHF14AMfDump(const char *Cmd)
                }\r
        }\r
        \r
                }\r
        }\r
        \r

+       // Read keys B from file\r

        for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
                if (fread( keyB[sectorNo], 1, 6, fin ) == 0) {\r
                        PrintAndLog("File reading error.");\r
        for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
                if (fread( keyB[sectorNo], 1, 6, fin ) == 0) {\r
                        PrintAndLog("File reading error.");\r


@@ -514,6 +511,7 @@ int CmdHF14AMfDump(const char *Cmd)
                        return 2;\r
                }\r
        }\r
                        return 2;\r
                }\r
        }\r

+       \r

        fclose(fin);\r
        // Read access rights to sectors\r
 \r
        fclose(fin);\r
        // Read access rights to sectors\r
 \r


@@ -556,6 +554,7 @@ int CmdHF14AMfDump(const char *Cmd)
        for (sectorNo = 0; isOK && sectorNo < numSectors; sectorNo++) {\r
                for (blockNo = 0; isOK && blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
                        bool received = false;\r
        for (sectorNo = 0; isOK && sectorNo < numSectors; sectorNo++) {\r
                for (blockNo = 0; isOK && blockNo < NumBlocksPerSector(sectorNo); blockNo++) {\r
                        bool received = false;\r

+                       \r

                        if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. At least the Access Conditions can always be read with key A. \r
                                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
                                memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
                        if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. At least the Access Conditions can always be read with key A. \r
                                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
                                memcpy(c.d.asBytes, keyA[sectorNo], 6);\r


@@ -610,7 +609,6 @@ int CmdHF14AMfDump(const char *Cmd)
                                break;\r
                        }\r
                }\r
                                break;\r
                        }\r
                }\r

-\r

        }\r
 \r
        if (isOK) {\r
        }\r
 \r
        if (isOK) {\r


@@ -627,14 +625,12 @@ int CmdHF14AMfDump(const char *Cmd)
        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfRestore(const char *Cmd)\r
 {\r
 int CmdHF14AMfRestore(const char *Cmd)\r
 {\r

-\r

        uint8_t sectorNo,blockNo;\r
        uint8_t keyType = 0;\r
        uint8_t sectorNo,blockNo;\r
        uint8_t keyType = 0;\r

-       uint8_t key[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};\r
-       uint8_t bldata[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
+       uint8_t key[6] = {0xFF};\r
+       uint8_t bldata[16] = {0x00};\r

        uint8_t keyA[40][6];\r
        uint8_t keyB[40][6];\r
        uint8_t numSectors;\r
        uint8_t keyA[40][6];\r
        uint8_t keyB[40][6];\r
        uint8_t numSectors;\r


@@ -661,21 +657,14 @@ int CmdHF14AMfRestore(const char *Cmd)
                return 0;\r
        }\r
 \r
                return 0;\r
        }\r
 \r

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

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

-               fclose(fdump);\r

                return 1;\r
        }\r
        \r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyA[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r
                return 1;\r
        }\r
        \r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                if (fread(keyA[sectorNo], 1, 6, fkeys) == 0) {\r
                        PrintAndLog("File reading error (dumpkeys.bin).");\r

-                       fclose(fdump);\r
-                       fclose(fkeys);\r

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


@@ -683,13 +672,16 @@ 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(fdump);\r
-                       fclose(fkeys);\r

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

+\r

        fclose(fkeys);\r
 \r
        fclose(fkeys);\r
 \r

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

        PrintAndLog("Restoring dumpdata.bin to card");\r
 \r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
        PrintAndLog("Restoring dumpdata.bin to card");\r
 \r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r


@@ -737,7 +729,6 @@ int CmdHF14AMfRestore(const char *Cmd)
        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfNested(const char *Cmd)\r
 {\r
        int i, j, res, iterations;\r
 int CmdHF14AMfNested(const char *Cmd)\r
 {\r
        int i, j, res, iterations;\r


@@ -778,11 +769,15 @@ int CmdHF14AMfNested(const char *Cmd)
        cmdp = param_getchar(Cmd, 0);\r
        blockNo = param_get8(Cmd, 1);\r
        ctmp = param_getchar(Cmd, 2);\r
        cmdp = param_getchar(Cmd, 0);\r
        blockNo = param_get8(Cmd, 1);\r
        ctmp = param_getchar(Cmd, 2);\r

+       \r

        if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                PrintAndLog("Key type must be A or B");\r
                return 1;\r
        }\r
        if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                PrintAndLog("Key type must be A or B");\r
                return 1;\r
        }\r

-       if (ctmp != 'A' && ctmp != 'a') keyType = 1;\r
+       \r
+       if (ctmp != 'A' && ctmp != 'a') \r
+               keyType = 1;\r
+               \r

        if (param_gethex(Cmd, 3, key, 12)) {\r
                PrintAndLog("Key must include 12 HEX symbols");\r
                return 1;\r
        if (param_gethex(Cmd, 3, key, 12)) {\r
                PrintAndLog("Key must include 12 HEX symbols");\r
                return 1;\r


@@ -796,8 +791,10 @@ int CmdHF14AMfNested(const char *Cmd)
                        PrintAndLog("Target key type must be A or B");\r
                        return 1;\r
                }\r
                        PrintAndLog("Target key type must be A or B");\r
                        return 1;\r
                }\r

-               if (ctmp != 'A' && ctmp != 'a') trgKeyType = 1;\r
+               if (ctmp != 'A' && ctmp != 'a') \r
+                       trgKeyType = 1;\r

        } else {\r
        } else {\r

+                               \r

                switch (cmdp) {\r
                        case '0': SectorsCnt = 05; break;\r
                        case '1': SectorsCnt = 16; break;\r
                switch (cmdp) {\r
                        case '0': SectorsCnt = 05; break;\r
                        case '1': SectorsCnt = 16; break;\r


@@ -874,7 +871,6 @@ int CmdHF14AMfNested(const char *Cmd)
                        }\r
                }\r
                \r
                        }\r
                }\r
                \r

-               \r

                // nested sectors\r
                iterations = 0;\r
                PrintAndLog("nested...");\r
                // nested sectors\r
                iterations = 0;\r
                PrintAndLog("nested...");\r


@@ -886,6 +882,7 @@ int CmdHF14AMfNested(const char *Cmd)
                                        PrintAndLog("-----------------------------------------------");\r
                                        if(mfnested(blockNo, keyType, key, FirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate)) {\r
                                                PrintAndLog("Nested error.\n");\r
                                        PrintAndLog("-----------------------------------------------");\r
                                        if(mfnested(blockNo, keyType, key, FirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate)) {\r
                                                PrintAndLog("Nested error.\n");\r

+                                               free(e_sector);\r

                                                return 2;\r
                                        }\r
                                        else {\r
                                                return 2;\r
                                        }\r
                                        else {\r


@@ -960,11 +957,9 @@ int CmdHF14AMfNested(const char *Cmd)
                \r
                free(e_sector);\r
        }\r
                \r
                free(e_sector);\r
        }\r

-\r

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

-\r

 int CmdHF14AMfChk(const char *Cmd)\r
 {\r
        if (strlen(Cmd)<3) {\r
 int CmdHF14AMfChk(const char *Cmd)\r
 {\r
        if (strlen(Cmd)<3) {\r


@@ -978,7 +973,7 @@ int CmdHF14AMfChk(const char *Cmd)
        }       \r
 \r
        FILE * f;\r
        }       \r
 \r
        FILE * f;\r

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

        char buf[13];\r
        uint8_t *keyBlock = NULL, *p;\r
        uint8_t stKeyBlock = 20;\r
        char buf[13];\r
        uint8_t *keyBlock = NULL, *p;\r
        uint8_t stKeyBlock = 20;\r


@@ -994,7 +989,6 @@ int CmdHF14AMfChk(const char *Cmd)
        int transferToEml = 0;\r
        int createDumpFile = 0;\r
 \r
        int transferToEml = 0;\r
        int createDumpFile = 0;\r
 \r

-\r

        keyBlock = calloc(stKeyBlock, 6);\r
        if (keyBlock == NULL) return 1;\r
 \r
        keyBlock = calloc(stKeyBlock, 6);\r
        if (keyBlock == NULL) return 1;\r
 \r


@@ -1021,7 +1015,6 @@ int CmdHF14AMfChk(const char *Cmd)
                num_to_bytes(defaultKeys[defaultKeyCounter], 6, (uint8_t*)(keyBlock + defaultKeyCounter * 6));\r
        }\r
        \r
                num_to_bytes(defaultKeys[defaultKeyCounter], 6, (uint8_t*)(keyBlock + defaultKeyCounter * 6));\r
        }\r
        \r

-       \r

        if (param_getchar(Cmd, 0)=='*') {\r
                blockNo = 3;\r
                switch(param_getchar(Cmd+1, 0)) {\r
        if (param_getchar(Cmd, 0)=='*') {\r
                blockNo = 3;\r
                switch(param_getchar(Cmd+1, 0)) {\r


@@ -1072,7 +1065,7 @@ int CmdHF14AMfChk(const char *Cmd)
                        keycnt++;\r
                } else {\r
                        // May be a dic file\r
                        keycnt++;\r
                } else {\r
                        // May be a dic file\r

-                       if ( param_getstr(Cmd, 2 + i,filename) > 255 ) {\r
+                       if ( param_getstr(Cmd, 2 + i,filename) >= FILE_PATH_SIZE ) {\r

                                PrintAndLog("File name too long");\r
                                free(keyBlock);\r
                                return 2;\r
                                PrintAndLog("File name too long");\r
                                free(keyBlock);\r
                                return 2;\r


@@ -1114,6 +1107,7 @@ int CmdHF14AMfChk(const char *Cmd)
                                PrintAndLog("File: %s: not found or locked.", filename);\r
                                free(keyBlock);\r
                                return 1;\r
                                PrintAndLog("File: %s: not found or locked.", filename);\r
                                free(keyBlock);\r
                                return 1;\r

+                       \r

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


@@ -1191,11 +1185,10 @@ int CmdHF14AMfChk(const char *Cmd)
        }\r
 \r
        free(keyBlock);\r
        }\r
 \r
        free(keyBlock);\r

-\r
+       PrintAndLog("");\r

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

-\r

 int CmdHF14AMf1kSim(const char *Cmd)\r
 {\r
        uint8_t uid[7] = {0, 0, 0, 0, 0, 0, 0};\r
 int CmdHF14AMf1kSim(const char *Cmd)\r
 {\r
        uint8_t uid[7] = {0, 0, 0, 0, 0, 0, 0};\r


@@ -1261,7 +1254,6 @@ int CmdHF14AMf1kSim(const char *Cmd)
        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfDbg(const char *Cmd)\r
 {\r
        int dbgMode = param_get32ex(Cmd, 0, 0, 10);\r
 int CmdHF14AMfDbg(const char *Cmd)\r
 {\r
        int dbgMode = param_get32ex(Cmd, 0, 0, 10);\r


@@ -1286,7 +1278,6 @@ int CmdHF14AMfDbg(const char *Cmd)
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfEGet(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r
 int CmdHF14AMfEGet(const char *Cmd)\r
 {\r
        uint8_t blockNo = 0;\r


@@ -1310,7 +1301,6 @@ int CmdHF14AMfEGet(const char *Cmd)
   return 0;\r
 }\r
 \r
   return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfEClear(const char *Cmd)\r
 {\r
        if (param_getchar(Cmd, 0) == 'h') {\r
 int CmdHF14AMfEClear(const char *Cmd)\r
 {\r
        if (param_getchar(Cmd, 0) == 'h') {\r


@@ -1356,26 +1346,44 @@ int CmdHF14AMfESet(const char *Cmd)
 int CmdHF14AMfELoad(const char *Cmd)\r
 {\r
        FILE * f;\r
 int CmdHF14AMfELoad(const char *Cmd)\r
 {\r
        FILE * f;\r

-       char filename[20];\r
+       char filename[FILE_PATH_SIZE];\r

        char *fnameptr = filename;\r
        char buf[64];\r
        uint8_t buf8[64];\r
        char *fnameptr = filename;\r
        char buf[64];\r
        uint8_t buf8[64];\r

-       int i, len, blockNum;\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
        \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
+       char ctmp = param_getchar(Cmd, 0);\r
+               \r
+       if ( ctmp == 'h' || ctmp == 0x00) {\r

                PrintAndLog("It loads emul dump from the file `filename.eml`");\r
                PrintAndLog("It loads emul dump from the file `filename.eml`");\r

-               PrintAndLog("Usage:  hf mf eload <file name w/o `.eml`>");\r
+               PrintAndLog("Usage:  hf mf eload [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(" sample: hf mf eload filename");\r
                PrintAndLog(" sample: hf mf eload filename");\r

+               PrintAndLog("         hf mf eload 4 filename");\r

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

-       len = strlen(Cmd);\r
-       if (len > 14) len = 14;\r
+       switch (ctmp) {\r
+               case '0' : numBlocks = 5*4; break;\r
+               case '1' : \r
+               case '\0': numBlocks = 16*4; break;\r
+               case '2' : numBlocks = 32*4; break;\r
+               case '4' : numBlocks = 256; break;\r
+               default:  {\r
+                       numBlocks = 16*4;\r
+                       nameParamNo = 0;\r
+               }\r
+       }\r
+\r
+       len = param_getstr(Cmd,nameParamNo,filename);\r
+       \r
+       if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r

 \r
 \r

-       memcpy(filename, Cmd, len);\r

        fnameptr += len;\r
 \r
        sprintf(fnameptr, ".eml"); \r
        fnameptr += len;\r
 \r
        sprintf(fnameptr, ".eml"); \r


@@ -1383,21 +1391,23 @@ int CmdHF14AMfELoad(const char *Cmd)
        // open file\r
        f = fopen(filename, "r");\r
        if (f == NULL) {\r
        // open file\r
        f = fopen(filename, "r");\r
        if (f == NULL) {\r

-               PrintAndLog("File not found or locked.");\r
+               PrintAndLog("File %s not found or locked", filename);\r

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

+               \r

                if (fgets(buf, sizeof(buf), f) == NULL) {\r
                if (fgets(buf, sizeof(buf), f) == NULL) {\r

-                       if((blockNum == 16*4) || (blockNum == 32*4 + 8*16)) {   // supports both old (1K) and new (4K) .eml files)\r
-                               break;\r
-                       }\r
+                       \r
+                       if (blockNum >= numBlocks) break;\r
+                       \r

                        PrintAndLog("File reading error.");\r
                        fclose(f);\r
                        return 2;\r
                }\r
                        PrintAndLog("File reading error.");\r
                        fclose(f);\r
                        return 2;\r
                }\r

+               \r

                if (strlen(buf) < 32){\r
                        if(strlen(buf) && feof(f))\r
                                break;\r
                if (strlen(buf) < 32){\r
                        if(strlen(buf) && feof(f))\r
                                break;\r


@@ -1405,10 +1415,11 @@ int CmdHF14AMfELoad(const char *Cmd)
                        fclose(f);\r
                        return 2;\r
                }\r
                        fclose(f);\r
                        return 2;\r
                }\r

+               \r

                for (i = 0; i < 32; i += 2) {\r
                        sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
                for (i = 0; i < 32; i += 2) {\r
                        sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r

-//                     PrintAndLog("data[%02d]:%s", blockNum, sprint_hex(buf8, 16));\r

                }\r
                }\r

+               \r

                if (mfEmlSetMem(buf8, blockNum, 1)) {\r
                        PrintAndLog("Cant set emul block: %3d", blockNum);\r
                        fclose(f);\r
                if (mfEmlSetMem(buf8, blockNum, 1)) {\r
                        PrintAndLog("Cant set emul block: %3d", blockNum);\r
                        fclose(f);\r


@@ -1416,12 +1427,12 @@ int CmdHF14AMfELoad(const char *Cmd)
                }\r
                blockNum++;\r
                \r
                }\r
                blockNum++;\r
                \r

-               if (blockNum >= 32*4 + 8*16) break;\r
+               if (blockNum >= numBlocks) break;\r

        }\r
        fclose(f);\r
        \r
        }\r
        fclose(f);\r
        \r

-       if ((blockNum != 16*4) && (blockNum != 32*4 + 8*16)) {\r
-               PrintAndLog("File content error. There must be 64 or 256 blocks.");\r
+       if ((blockNum != numBlocks)) {\r
+               PrintAndLog("File content error. Got %d must be %d blocks.",blockNum, numBlocks);\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


@@ -1432,56 +1443,81 @@ int CmdHF14AMfELoad(const char *Cmd)
 int CmdHF14AMfESave(const char *Cmd)\r
 {\r
        FILE * f;\r
 int CmdHF14AMfESave(const char *Cmd)\r
 {\r
        FILE * f;\r

-       char filename[20];\r
+       char filename[FILE_PATH_SIZE];\r

        char * fnameptr = filename;\r
        uint8_t buf[64];\r
        char * fnameptr = filename;\r
        uint8_t buf[64];\r

-       int i, j, len;\r
+       int i, j, len, numBlocks;\r
+       int nameParamNo = 1;\r

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

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

                PrintAndLog("It saves emul dump into the file `filename.eml` or `cardID.eml`");\r
                PrintAndLog("It saves emul dump into the file `filename.eml` or `cardID.eml`");\r

-               PrintAndLog("Usage:  hf mf esave [file name w/o `.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(" sample: hf mf esave ");\r
                PrintAndLog(" sample: hf mf esave ");\r

-               PrintAndLog("         hf mf esave filename");\r
+               PrintAndLog("         hf mf esave 4");\r
+               PrintAndLog("         hf mf esave 4 filename");\r

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

-       len = strlen(Cmd);\r
-       if (len > 14) len = 14;\r
+       switch (ctmp) {\r
+               case '0' : numBlocks = 5*4; break;\r
+               case '1' : \r
+               case '\0': numBlocks = 16*4; break;\r
+               case '2' : numBlocks = 32*4; break;\r
+               case '4' : numBlocks = 256; break;\r
+               default:  {\r
+                       numBlocks = 16*4;\r
+                       nameParamNo = 0;\r
+               }\r
+       }\r
+\r
+       len = param_getstr(Cmd,nameParamNo,filename);\r
+       \r
+       if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r

        \r
        \r

+       // user supplied filename?\r

        if (len < 1) {\r
        if (len < 1) {\r

-               // get filename\r
+               // get filename (UID from memory)\r

                if (mfEmlGetMem(buf, 0, 1)) {\r
                if (mfEmlGetMem(buf, 0, 1)) {\r

-                       PrintAndLog("Cant get block: %d", 0);\r
-                       return 1;\r
+                       PrintAndLog("Can\'t get UID from block: %d", 0);\r
+                       sprintf(filename, "dump.eml"); \r

                }\r
                for (j = 0; j < 7; j++, fnameptr += 2)\r
                }\r
                for (j = 0; j < 7; j++, fnameptr += 2)\r

-                       sprintf(fnameptr, "%02x", buf[j]); \r
+                       sprintf(fnameptr, "%02X", buf[j]); \r

        } else {\r
        } else {\r

-               memcpy(filename, Cmd, len);\r

                fnameptr += len;\r
        }\r
 \r
                fnameptr += len;\r
        }\r
 \r

+       // add file extension\r

        sprintf(fnameptr, ".eml"); \r
        \r
        // open file\r
        f = fopen(filename, "w+");\r
 \r
        sprintf(fnameptr, ".eml"); \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
        // put hex\r

-       for (i = 0; i < 32*4 + 8*16; i++) {\r
+       for (i = 0; i < numBlocks; i++) {\r

                if (mfEmlGetMem(buf, i, 1)) {\r
                        PrintAndLog("Cant get block: %d", i);\r
                        break;\r
                }\r
                for (j = 0; j < 16; j++)\r
                if (mfEmlGetMem(buf, i, 1)) {\r
                        PrintAndLog("Cant get block: %d", i);\r
                        break;\r
                }\r
                for (j = 0; j < 16; j++)\r

-                       fprintf(f, "%02x", buf[j]); \r
+                       fprintf(f, "%02X", buf[j]); \r

                fprintf(f,"\n");\r
        }\r
        fclose(f);\r
        \r
                fprintf(f,"\n");\r
        }\r
        fclose(f);\r
        \r

-       PrintAndLog("Saved to file: %s", filename);\r
+       PrintAndLog("Saved %d blocks to file: %s", numBlocks, filename);\r

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


@@ -1530,13 +1566,34 @@ int CmdHF14AMfECFill(const char *Cmd)
 int CmdHF14AMfEKeyPrn(const char *Cmd)\r
 {\r
        int i;\r
 int CmdHF14AMfEKeyPrn(const char *Cmd)\r
 {\r
        int i;\r

+       uint8_t numSectors;\r

        uint8_t data[16];\r
        uint64_t keyA, keyB;\r
        \r
        uint8_t data[16];\r
        uint64_t keyA, keyB;\r
        \r

+       if (param_getchar(Cmd, 0) == 'h') {\r
+               PrintAndLog("It prints the keys loaded in the emulator memory");\r
+               PrintAndLog("Usage:  hf mf ekeyprn [card memory]");\r
+               PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\r
+               PrintAndLog("");\r
+               PrintAndLog(" sample: hf mf ekeyprn 1");\r
+               return 0;\r
+       }       \r
+\r
+       char cmdp = param_getchar(Cmd, 0);\r
+       \r
+       switch (cmdp) {\r
+               case '0' : numSectors = 5; break;\r
+               case '1' : \r
+               case '\0': numSectors = 16; break;\r
+               case '2' : numSectors = 32; break;\r
+               case '4' : numSectors = 40; break;\r
+               default:   numSectors = 16;\r
+       }               \r
+       \r

        PrintAndLog("|---|----------------|----------------|");\r
        PrintAndLog("|sec|key A           |key B           |");\r
        PrintAndLog("|---|----------------|----------------|");\r
        PrintAndLog("|---|----------------|----------------|");\r
        PrintAndLog("|sec|key A           |key B           |");\r
        PrintAndLog("|---|----------------|----------------|");\r

-       for (i = 0; i < 40; i++) {\r
+       for (i = 0; i < numSectors; i++) {\r

                if (mfEmlGetMem(data, FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1, 1)) {\r
                        PrintAndLog("error get block %d", FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1);\r
                        break;\r
                if (mfEmlGetMem(data, FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1, 1)) {\r
                        PrintAndLog("error get block %d", FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1);\r
                        break;\r


@@ -1554,8 +1611,8 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
 int CmdHF14AMfCSetUID(const char *Cmd)\r
 {\r
        uint8_t wipeCard = 0;\r
 int CmdHF14AMfCSetUID(const char *Cmd)\r
 {\r
        uint8_t wipeCard = 0;\r

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

        int res;\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
        int res;\r
 \r
        if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r


@@ -1583,10 +1640,10 @@ 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
        return 0;\r
 }\r
 \r

-\r

 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r
        uint8_t uid[8];\r
 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r
        uint8_t uid[8];\r


@@ -1626,15 +1683,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[20];\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
+       // 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
                PrintAndLog("It loads magic Chinese card (only works with!!!) from the file `filename.eml`");\r
 \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


@@ -1667,7 +1724,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r

-               if (len > 14) len = 14;\r
+               if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r

 \r
                memcpy(filename, Cmd, len);\r
                fnameptr += len;\r
 \r
                memcpy(filename, Cmd, len);\r
                fnameptr += len;\r


@@ -1712,7 +1769,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                }\r
                fclose(f);\r
        \r
                }\r
                fclose(f);\r
        \r

-               if (blockNum != 16 * 4){\r
+               if (blockNum != 16 * 4 && blockNum != 32 * 4 + 8 * 16){\r

                        PrintAndLog("File content error. There must be 64 blocks");\r
                        return 4;\r
                }\r
                        PrintAndLog("File content error. There must be 64 blocks");\r
                        return 4;\r
                }\r


@@ -1721,7 +1778,6 @@ int CmdHF14AMfCLoad(const char *Cmd)
        }\r
 }\r
 \r
        }\r
 }\r
 \r

-\r

 int CmdHF14AMfCGetBlk(const char *Cmd) {\r
        uint8_t memBlock[16];\r
        uint8_t blockNo = 0;\r
 int CmdHF14AMfCGetBlk(const char *Cmd) {\r
        uint8_t memBlock[16];\r
        uint8_t blockNo = 0;\r


@@ -1791,14 +1847,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[20];\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


@@ -1833,7 +1889,7 @@ int CmdHF14AMfCSave(const char *Cmd) {
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r

-               if (len > 14) len = 14;\r
+               if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r

        \r
                if (len < 1) {\r
                        // get filename\r
        \r
                if (len < 1) {\r
                        // get filename\r


@@ -1853,6 +1909,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


@@ -1877,7 +1938,7 @@ int CmdHF14AMfCSave(const char *Cmd) {
 \r
 \r
 int CmdHF14AMfSniff(const char *Cmd){\r
 \r
 \r
 int CmdHF14AMfSniff(const char *Cmd){\r

-       // params\r
+\r

        bool wantLogToFile = 0;\r
        bool wantDecrypt = 0;\r
        //bool wantSaveToEml = 0; TODO\r
        bool wantLogToFile = 0;\r
        bool wantDecrypt = 0;\r
        //bool wantSaveToEml = 0; TODO\r


@@ -1904,8 +1965,8 @@ int CmdHF14AMfSniff(const char *Cmd){
                PrintAndLog("    l - save encrypted sequence to logfile `uid.log`");\r
                PrintAndLog("    d - decrypt sequence and put it to log file `uid.log`");\r
                PrintAndLog(" n/a   e - decrypt sequence, collect read and write commands and save the result of the sequence to emulator memory");\r
                PrintAndLog("    l - save encrypted sequence to logfile `uid.log`");\r
                PrintAndLog("    d - decrypt sequence and put it to log file `uid.log`");\r
                PrintAndLog(" n/a   e - decrypt sequence, collect read and write commands and save the result of the sequence to emulator memory");\r

-               PrintAndLog("    r - decrypt sequence, collect read and write commands and save the result of the sequence to emulator dump file `uid.eml`");\r
-               PrintAndLog("Usage:  hf mf sniff [l][d][e][r]");\r
+               PrintAndLog("    f - decrypt sequence, collect read and write commands and save the result of the sequence to emulator dump file `uid.eml`");\r
+               PrintAndLog("Usage:  hf mf sniff [l][d][e][f]");\r

                PrintAndLog("  sample: hf mf sniff l d e");\r
                return 0;\r
        }       \r
                PrintAndLog("  sample: hf mf sniff l d e");\r
                return 0;\r
        }       \r


@@ -1961,8 +2022,9 @@ int CmdHF14AMfSniff(const char *Cmd){
                                PrintAndLog("received trace len: %d packages: %d", blockLen, pckNum);\r
                                num = 0;\r
                                while (bufPtr - buf < blockLen) {\r
                                PrintAndLog("received trace len: %d packages: %d", blockLen, pckNum);\r
                                num = 0;\r
                                while (bufPtr - buf < blockLen) {\r

-                                       bufPtr += 6;    // ignore void timing information\r
+                                       bufPtr += 6;\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


@@ -1971,6 +2033,7 @@ 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
                                                memcpy(uid, bufPtr + 2, 7);\r
                                                memcpy(atqa, bufPtr + 2 + 7, 2);\r
                                                uid_len = (atqa[0] & 0xC0) == 0x40 ? 7 : 4;\r


@@ -1985,18 +2048,21 @@ int CmdHF14AMfSniff(const char *Cmd){
                                                        FillFileNameByUID(logHexFileName, uid + (7 - uid_len), ".log", uid_len);\r
                                                        AddLogCurrentDT(logHexFileName);\r
                                                }                                               \r
                                                        FillFileNameByUID(logHexFileName, uid + (7 - uid_len), ".log", uid_len);\r
                                                        AddLogCurrentDT(logHexFileName);\r
                                                }                                               \r

-                                               if (wantDecrypt) mfTraceInit(uid, atqa, sak, wantSaveToEmlFile);\r
+                                               if (wantDecrypt) \r
+                                                       mfTraceInit(uid, atqa, sak, wantSaveToEmlFile);\r

                                        } else {\r
                                                PrintAndLog("%s(%d):%s", isTag ? "TAG":"RDR", num, sprint_hex(bufPtr, len));\r
                                        } else {\r
                                                PrintAndLog("%s(%d):%s", isTag ? "TAG":"RDR", num, sprint_hex(bufPtr, len));\r

-                                               if (wantLogToFile) AddLogHex(logHexFileName, isTag ? "TAG: ":"RDR: ", bufPtr, len);\r
-                                               if (wantDecrypt) mfTraceDecode(bufPtr, len, wantSaveToEmlFile);\r
+                                               if (wantLogToFile) \r
+                                                       AddLogHex(logHexFileName, isTag ? "TAG: ":"RDR: ", bufPtr, len);\r
+                                               if (wantDecrypt) \r
+                                                       mfTraceDecode(bufPtr, len, wantSaveToEmlFile);\r

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

-               } // resp not NILL\r
+               } // resp not NULL\r

        } // while (true)\r
        \r
        return 0;\r
        } // while (true)\r
        \r
        return 0;\r


@@ -2027,9 +2093,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