ADD: another key found

[proxmark3-svn] / client / cmdhfmf.c

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 5b5be6f2066f2d7a6c5d12286b5a5bcf3c39e14d..177d263266dbbdcbe98a69190d1a737159066d90 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -29,6 +29,7 @@ int CmdHF14AMifare(const char *Cmd)
        printf("Press button on the proxmark3 device to abort both proxmark3 and client.\n");\r
        printf("-------------------------------------------------------------------------\n");\r
 \r
        printf("Press button on the proxmark3 device to abort both proxmark3 and client.\n");\r
        printf("-------------------------------------------------------------------------\n");\r
 \r

+       time_t time1 = clock();\r

        \r
 start:\r
     clearCommandBuffer();\r
        \r
 start:\r
     clearCommandBuffer();\r


@@ -61,7 +62,7 @@ start:
                                case -2 : PrintAndLog("Card is not vulnerable to Darkside attack (doesn't send NACK on authentication requests).\n"); break;\r
                                case -3 : PrintAndLog("Card is not vulnerable to Darkside attack (its random number generator is not predictable).\n"); break;\r
                                case -4 : PrintAndLog("Card is not vulnerable to Darkside attack (its random number generator seems to be based on the wellknown");\r
                                case -2 : PrintAndLog("Card is not vulnerable to Darkside attack (doesn't send NACK on authentication requests).\n"); break;\r
                                case -3 : PrintAndLog("Card is not vulnerable to Darkside attack (its random number generator is not predictable).\n"); break;\r
                                case -4 : PrintAndLog("Card is not vulnerable to Darkside attack (its random number generator seems to be based on the wellknown");\r

-                                                       PrintAndLog("generating polynomial with 16 effective bits only, but shows unexpected behaviour.\n"); break;\r
+                                                 PrintAndLog("generating polynomial with 16 effective bits only, but shows unexpected behaviour.\n"); break;\r

                                default: ;\r
                        }\r
                        break;\r
                                default: ;\r
                        }\r
                        break;\r


@@ -86,6 +87,7 @@ start:
                PrintAndLog("Found valid key: %012"llx" \n", r_key);\r
        }\r
        \r
                PrintAndLog("Found valid key: %012"llx" \n", r_key);\r
        }\r
        \r

+       PrintAndLog("Time in darkside: %1.0f seconds", (float)(clock() - time1)/CLOCKS_PER_SEC);\r

        PrintAndLog("");\r
        return 0;\r
 }\r
        PrintAndLog("");\r
        return 0;\r
 }\r


@@ -662,8 +664,7 @@ int CmdHF14AMfNested(const char *Cmd)
                }\r
        }\r
        else { // ------------------------------------  multiple sectors working\r
                }\r
        }\r
        else { // ------------------------------------  multiple sectors working\r

-               clock_t time1;\r
-               time1 = clock();\r
+               clock_t time1 = clock();\r

 \r
                e_sector = calloc(SectorsCnt, sizeof(sector));\r
                if (e_sector == NULL) return 1;\r
 \r
                e_sector = calloc(SectorsCnt, sizeof(sector));\r
                if (e_sector == NULL) return 1;\r


@@ -733,7 +734,38 @@ int CmdHF14AMfNested(const char *Cmd)
                        }\r
                }\r
 \r
                        }\r
                }\r
 \r

-               printf("Time in nested: %1.3f (%1.3f sec per key)\n\n", ((float)clock() - time1)/CLOCKS_PER_SEC, ((float)clock() - time1)/iterations/CLOCKS_PER_SEC);\r
+               // 20160116 If Sector A is found, but not Sector B,  try just reading it of the tag?\r
+               PrintAndLog("testing to read B...");\r
+               for (i = 0; i < SectorsCnt; i++) {\r
+                       // KEY A  but not KEY B\r
+                       if ( e_sector[i].foundKey[0] && !e_sector[i].foundKey[1] ) {\r
+                               \r
+                               uint8_t sectrail = (FirstBlockOfSector(i) + NumBlocksPerSector(i) - 1);\r
+                               \r
+                               UsbCommand c = {CMD_MIFARE_READBL, {sectrail, 0, 0}};\r
+                               num_to_bytes(e_sector[i].Key[0], 6, c.d.asBytes); // KEY A\r
+                               clearCommandBuffer();\r
+                               SendCommand(&c);\r
+\r
+                               UsbCommand resp;\r
+                               if ( !WaitForResponseTimeout(CMD_ACK,&resp,1500)) continue;\r
+                                       \r
+                               uint8_t isOK  = resp.arg[0] & 0xff;\r
+                               uint8_t *data = resp.d.asBytes;\r
+\r
+                               if (isOK) {\r
+\r
+                                       key64 = bytes_to_num(data+10, 6);\r
+                                       if (key64) {\r
+                                               PrintAndLog("Data:%s", sprint_hex(data+10, 6));\r
+                                               e_sector[i].foundKey[1] = 1;\r
+                                               e_sector[i].Key[1] = key64;\r
+                                       }\r
+                               }\r
+                       }\r
+               }\r
+               \r
+               PrintAndLog("Time in nested: %1.3f (%1.3f sec per key)\n\n", ((float)clock() - time1)/CLOCKS_PER_SEC, ((float)clock() - time1)/iterations/CLOCKS_PER_SEC);\r

                \r
                PrintAndLog("-----------------------------------------------\nIterations count: %d\n\n", iterations);\r
                //print them\r
                \r
                PrintAndLog("-----------------------------------------------\nIterations count: %d\n\n", iterations);\r
                //print them\r


@@ -742,7 +774,11 @@ int CmdHF14AMfNested(const char *Cmd)
                PrintAndLog("|---|----------------|---|----------------|---|");\r
                for (i = 0; i < SectorsCnt; i++) {\r
                        PrintAndLog("|%03d|  %012"llx"  | %d |  %012"llx"  | %d |", i,\r
                PrintAndLog("|---|----------------|---|----------------|---|");\r
                for (i = 0; i < SectorsCnt; i++) {\r
                        PrintAndLog("|%03d|  %012"llx"  | %d |  %012"llx"  | %d |", i,\r

-                               e_sector[i].Key[0], e_sector[i].foundKey[0], e_sector[i].Key[1], e_sector[i].foundKey[1]);\r
+                               e_sector[i].Key[0], \r
+                               e_sector[i].foundKey[0], \r
+                               e_sector[i].Key[1], \r
+                               e_sector[i].foundKey[1]\r
+                       );\r

                }\r
                PrintAndLog("|---|----------------|---|----------------|---|");\r
                \r
                }\r
                PrintAndLog("|---|----------------|---|----------------|---|");\r
                \r


@@ -799,14 +835,16 @@ int CmdHF14AMfNestedHard(const char *Cmd)
        uint8_t trgBlockNo = 0;\r
        uint8_t trgKeyType = 0;\r
        uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r
        uint8_t trgBlockNo = 0;\r
        uint8_t trgKeyType = 0;\r
        uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r

+       uint8_t trgkey[6] = {0, 0, 0, 0, 0, 0};\r

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

-       if (ctmp != 'R' && ctmp != 'r' && strlen(Cmd) < 20) {\r
+\r
+       if (ctmp != 'R' && ctmp != 'r' && ctmp != 'T' && ctmp != 't' && strlen(Cmd) < 20) {\r

                PrintAndLog("Usage:");\r
                PrintAndLog("      hf mf hardnested <block number> <key A|B> <key (12 hex symbols)>");\r
                PrintAndLog("Usage:");\r
                PrintAndLog("      hf mf hardnested <block number> <key A|B> <key (12 hex symbols)>");\r

-               PrintAndLog("                       <target block number> <target key A|B> [w] [s]");\r
-               PrintAndLog("  or  hf mf hardnested r");\r
+               PrintAndLog("                       <target block number> <target key A|B> [known target key (12 hex symbols)] [w] [s]");\r
+               PrintAndLog("  or  hf mf hardnested r [known target key]");\r

                PrintAndLog(" ");\r
                PrintAndLog("Options: ");\r
                PrintAndLog("      w: Acquire nonces and write them to binary file nonces.bin");\r
                PrintAndLog(" ");\r
                PrintAndLog("Options: ");\r
                PrintAndLog("      w: Acquire nonces and write them to binary file nonces.bin");\r


@@ -817,20 +855,27 @@ int CmdHF14AMfNestedHard(const char *Cmd)
                PrintAndLog("      sample2: hf mf hardnested 0 A FFFFFFFFFFFF 4 A w");\r
                PrintAndLog("      sample3: hf mf hardnested 0 A FFFFFFFFFFFF 4 A w s");\r
                PrintAndLog("      sample4: hf mf hardnested r");\r
                PrintAndLog("      sample2: hf mf hardnested 0 A FFFFFFFFFFFF 4 A w");\r
                PrintAndLog("      sample3: hf mf hardnested 0 A FFFFFFFFFFFF 4 A w s");\r
                PrintAndLog("      sample4: hf mf hardnested r");\r

-\r
+               PrintAndLog(" ");\r
+               PrintAndLog("Add the known target key to check if it is present in the remaining key space:");\r
+               PrintAndLog("      sample5: hf mf hardnested 0 A A0A1A2A3A4A5 4 A FFFFFFFFFFFF");\r

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

+       bool know_target_key = false;\r

        bool nonce_file_read = false;\r
        bool nonce_file_write = false;\r
        bool slow = false;\r
        bool nonce_file_read = false;\r
        bool nonce_file_write = false;\r
        bool slow = false;\r

+       int tests = 0;\r
+       \r

        \r
        if (ctmp == 'R' || ctmp == 'r') {\r
        \r
        if (ctmp == 'R' || ctmp == 'r') {\r

-\r

                nonce_file_read = true;\r
                nonce_file_read = true;\r

-\r
+               if (!param_gethex(Cmd, 1, trgkey, 12)) {\r
+                       know_target_key = true;\r
+               }\r
+       } else if (ctmp == 'T' || ctmp == 't') {\r
+               tests = param_get32ex(Cmd, 1, 100, 10);\r

        } else {\r
        } else {\r

-\r

                blockNo = param_get8(Cmd, 0);\r
                ctmp = param_getchar(Cmd, 1);\r
                if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
                blockNo = param_get8(Cmd, 0);\r
                ctmp = param_getchar(Cmd, 1);\r
                if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r


@@ -857,6 +902,12 @@ int CmdHF14AMfNestedHard(const char *Cmd)
                }\r
 \r
                uint16_t i = 5;\r
                }\r
 \r
                uint16_t i = 5;\r

+\r
+               if (!param_gethex(Cmd, 5, trgkey, 12)) {\r
+                       know_target_key = true;\r
+                       i++;\r
+               }\r
+\r

                while ((ctmp = param_getchar(Cmd, i))) {\r
                        if (ctmp == 's' || ctmp == 'S') {\r
                                slow = true;\r
                while ((ctmp = param_getchar(Cmd, i))) {\r
                        if (ctmp == 's' || ctmp == 'S') {\r
                                slow = true;\r


@@ -870,12 +921,17 @@ int CmdHF14AMfNestedHard(const char *Cmd)
                }\r
        }\r
 \r
                }\r
        }\r
 \r

-       PrintAndLog("--target block no:%3d, target key type:%c, file action: %s, Slow: %s ", \r
+       PrintAndLog("--target block no:%3d, target key type:%c, known target key: 0x%02x%02x%02x%02x%02x%02x%s, file action: %s, Slow: %s, Tests: %d ", \r

                        trgBlockNo, \r
                        trgKeyType?'B':'A', \r
                        trgBlockNo, \r
                        trgKeyType?'B':'A', \r

+                       trgkey[0], trgkey[1], trgkey[2], trgkey[3], trgkey[4], trgkey[5],\r
+                       know_target_key?"":" (not set)",\r

                        nonce_file_write?"write":nonce_file_read?"read":"none",\r
                        nonce_file_write?"write":nonce_file_read?"read":"none",\r

-                       slow?"Yes":"No");\r
-       int16_t isOK = mfnestedhard(blockNo, keyType, key, trgBlockNo, trgKeyType, nonce_file_read, nonce_file_write, slow);\r
+                       slow?"Yes":"No",\r
+                       tests);\r
+\r
+       int16_t isOK = mfnestedhard(blockNo, keyType, key, trgBlockNo, trgKeyType, know_target_key?trgkey:NULL, nonce_file_read, nonce_file_write, slow, tests);\r
+\r

        if (isOK) {\r
                switch (isOK) {\r
                        case 1 : PrintAndLog("Error: No response from Proxmark.\n"); break;\r
        if (isOK) {\r
                switch (isOK) {\r
                        case 1 : PrintAndLog("Error: No response from Proxmark.\n"); break;\r


@@ -971,6 +1027,7 @@ int CmdHF14AMfChk(const char *Cmd)
                break;\r
        default:\r
                PrintAndLog("Key type must be A , B or ?");\r
                break;\r
        default:\r
                PrintAndLog("Key type must be A , B or ?");\r

+               free(keyBlock);\r

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


@@ -1022,6 +1079,7 @@ int CmdHF14AMfChk(const char *Cmd)
                                                if (!p) {\r
                                                        PrintAndLog("Cannot allocate memory for defKeys");\r
                                                        free(keyBlock);\r
                                                if (!p) {\r
                                                        PrintAndLog("Cannot allocate memory for defKeys");\r
                                                        free(keyBlock);\r

+                                                       fclose(f);\r

                                                        return 2;\r
                                                }\r
                                                keyBlock = p;\r
                                                        return 2;\r
                                                }\r
                                                keyBlock = p;\r


@@ -1061,7 +1119,9 @@ int CmdHF14AMfChk(const char *Cmd)
                        }\r
                }\r
        }\r
                        }\r
                }\r
        }\r

-       \r
+       // time\r
+       time_t time1 = clock();\r
+               \r

        for ( int t = !keyType; t < 2; keyType==2?(t++):(t=2) ) {\r
                int b=blockNo;\r
                for (int i = 0; i < SectorsCnt; ++i) {\r
        for ( int t = !keyType; t < 2; keyType==2?(t++):(t=2) ) {\r
                int b=blockNo;\r
                for (int i = 0; i < SectorsCnt; ++i) {\r


@@ -1083,6 +1143,8 @@ int CmdHF14AMfChk(const char *Cmd)
                        b<127?(b+=4):(b+=16);   \r
                }\r
        }\r
                        b<127?(b+=4):(b+=16);   \r
                }\r
        }\r

+       printf("Time in checkkeys: %1.3f (%1.3f sec per key)\n\n", ((float)clock() - time1)/CLOCKS_PER_SEC, ((float)clock() - time1)/keycnt/CLOCKS_PER_SEC);\r
+               \r

 \r
        if (transferToEml) {\r
                uint8_t block[16];\r
 \r
        if (transferToEml) {\r
                uint8_t block[16];\r


@@ -1178,15 +1240,21 @@ int CmdHF14AMf1kSim(const char *Cmd)
 \r
        if(flags & FLAG_INTERACTIVE)\r
        {               \r
 \r
        if(flags & FLAG_INTERACTIVE)\r
        {               \r

-               PrintAndLog("Press pm3-button to abort simulation");\r
-               \r

                uint8_t data[40];\r
                uint8_t key[6];\r
 \r
                UsbCommand resp;                \r
                uint8_t data[40];\r
                uint8_t key[6];\r
 \r
                UsbCommand resp;                \r

+               PrintAndLog("Press pm3-button or send another cmd to abort simulation");\r
+               //while(! WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+                       //We're waiting only 1.5 s at a time, otherwise we get the\r
+                       // annoying message about "Waiting for a response... "\r
+               //}\r

                while(!ukbhit() ){\r
                while(!ukbhit() ){\r

-                       if ( WaitForResponseTimeout(CMD_ACK,&resp,1500) ) {\r
-                               if ( (resp.arg[0] & 0xffff) == CMD_SIMULATE_MIFARE_CARD ){\r
+                       if (!WaitForResponseTimeout(CMD_ACK,&resp,1500) ) continue;\r
+\r
+                       if ( !(flags & FLAG_NR_AR_ATTACK) ) break;\r
+                       if ( (resp.arg[0] & 0xffff) != CMD_SIMULATE_MIFARE_CARD ) break;\r
+\r

                                        memset(data, 0x00, sizeof(data));\r
                                        memset(key, 0x00, sizeof(key));\r
                                        int len = (resp.arg[1] > sizeof(data)) ? sizeof(data) : resp.arg[1];\r
                                        memset(data, 0x00, sizeof(data));\r
                                        memset(key, 0x00, sizeof(key));\r
                                        int len = (resp.arg[1] > sizeof(data)) ? sizeof(data) : resp.arg[1];\r


@@ -1195,24 +1263,22 @@ int CmdHF14AMf1kSim(const char *Cmd)
                                        \r
                                        uint64_t corr_uid = 0;\r
                                        if ( memcmp(data, "\x00\x00\x00\x00", 4) == 0 ) {\r
                                        \r
                                        uint64_t corr_uid = 0;\r
                                        if ( memcmp(data, "\x00\x00\x00\x00", 4) == 0 ) {\r

-                                               corr_uid = (data[3] << 24) | (data[2] << 16) | (data[1] << 8) | data[0];\r
-                                       }\r
-                                       else {\r
+                                               corr_uid = ((uint64_t)(data[3] << 24)) | (data[2] << 16) | (data[1] << 8) | data[0];\r
+                               tryMfk32(corr_uid, data, key);\r
+                       } else {\r

                                                corr_uid |= (uint64_t)data[2] << 48; \r
                                                corr_uid |= (uint64_t)data[1] << 40; \r
                                                corr_uid |= (uint64_t)data[0] << 32;\r
                                                corr_uid |= (uint64_t)data[2] << 48; \r
                                                corr_uid |= (uint64_t)data[1] << 40; \r
                                                corr_uid |= (uint64_t)data[0] << 32;\r

-                                               corr_uid |= data[7] << 24;\r
-                                               corr_uid |= data[6] << 16;\r
-                                               corr_uid |= data[5] << 8;\r
-                                               corr_uid |= data[4];\r
+                                               corr_uid |= (uint64_t)data[7] << 24;\r
+                                               corr_uid |= (uint64_t)data[6] << 16;\r
+                                               corr_uid |= (uint64_t)data[5] << 8;\r
+                                               corr_uid |= (uint64_t)data[4];\r
+                               tryMfk64(corr_uid, data, key);\r

                                        }\r
                                        }\r

-                                       tryMfk32(corr_uid, data, key);\r
-                                       //tryMfk64(corr_uid, data, key);\r

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

-               }\r
-       }\r
+       \r

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


@@ -1317,7 +1383,7 @@ int CmdHF14AMfELoad(const char *Cmd)
                \r
        if ( ctmp == 'h' || ctmp == 'H' || ctmp == 0x00) {\r
                PrintAndLog("It loads emul dump from the file `filename.eml`");\r
                \r
        if ( ctmp == 'h' || ctmp == 'H' || ctmp == 0x00) {\r
                PrintAndLog("It loads emul dump from the file `filename.eml`");\r

-               PrintAndLog("Usage:  hf mf eload [card memory] <file name w/o `.eml`>");\r
+               PrintAndLog("Usage:  hf mf eload [card memory] <file name w/o `.eml`> [numblocks]");\r

                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K, u = UL");\r
                PrintAndLog("");\r
                PrintAndLog(" sample: hf mf eload filename");\r
                PrintAndLog("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K, u = UL");\r
                PrintAndLog("");\r
                PrintAndLog(" sample: hf mf eload filename");\r


@@ -1331,17 +1397,19 @@ int CmdHF14AMfELoad(const char *Cmd)
                case '\0': numBlocks = 16*4; break;\r
                case '2' : numBlocks = 32*4; break;\r
                case '4' : numBlocks = 256; break;\r
                case '\0': numBlocks = 16*4; break;\r
                case '2' : numBlocks = 32*4; break;\r
                case '4' : numBlocks = 256; break;\r

-               case 'U' : // fall through  ,  NTAG 215 has 135blocks a 540 bytes.\r
-               case 'u' : numBlocks = 135; blockWidth = 8; break;\r
+               case 'U' : // fall through\r
+               case 'u' : numBlocks = 255; blockWidth = 8; break;\r

                default:  {\r
                        numBlocks = 16*4;\r
                        nameParamNo = 0;\r
                }\r
        }\r
                default:  {\r
                        numBlocks = 16*4;\r
                        nameParamNo = 0;\r
                }\r
        }\r

+       uint32_t numblk2 = param_get32ex(Cmd,2,0,10);\r
+       if (numblk2 > 0) numBlocks = numblk2;   \r

 \r
        len = param_getstr(Cmd,nameParamNo,filename);\r
        \r
 \r
        len = param_getstr(Cmd,nameParamNo,filename);\r
        \r

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

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


@@ -1438,7 +1506,7 @@ int CmdHF14AMfESave(const char *Cmd)
 \r
        len = param_getstr(Cmd,nameParamNo,filename);\r
        \r
 \r
        len = param_getstr(Cmd,nameParamNo,filename);\r
        \r

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

        \r
        // user supplied filename?\r
        if (len < 1) {\r
        \r
        // user supplied filename?\r
        if (len < 1) {\r


@@ -1715,7 +1783,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 > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
+               if (len > FILE_PATH_SIZE - 5) len = FILE_PATH_SIZE - 5;\r

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


@@ -1756,6 +1824,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
 \r
                        if (mfCSetBlock(blockNum, buf8, NULL, flags)) {\r
                                PrintAndLog("Can't set magic card block: %d", blockNum);\r
 \r
                        if (mfCSetBlock(blockNum, buf8, NULL, flags)) {\r
                                PrintAndLog("Can't set magic card block: %d", blockNum);\r

+                               fclose(f);\r

                                return 3;\r
                        }\r
                        blockNum++;\r
                                return 3;\r
                        }\r
                        blockNum++;\r


@@ -1799,7 +1868,7 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
                return 1;\r
        }\r
        \r
                return 1;\r
        }\r
        \r

-       PrintAndLog("data:%s", sprint_hex(data, sizeof(data)));\r
+       PrintAndLog("data: %s", sprint_hex(data, sizeof(data)));\r

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


@@ -1885,7 +1954,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 > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
+               if (len > FILE_PATH_SIZE - 5) len = FILE_PATH_SIZE - 5;\r

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


@@ -2004,7 +2073,10 @@ int CmdHF14AMfSniff(const char *Cmd){
                        uint16_t traceLen = resp.arg[1];\r
                        len = resp.arg[2];\r
 \r
                        uint16_t traceLen = resp.arg[1];\r
                        len = resp.arg[2];\r
 \r

-                       if (res == 0) return 0;                                         // we are done\r
+                       if (res == 0) {\r
+                               free(buf);\r
+                               return 0;                                               // we are done\r
+                       }\r

 \r
                        if (res == 1) {                                                         // there is (more) data to be transferred\r
                                if (pckNum == 0) {                                              // first packet, (re)allocate necessary buffer\r
 \r
                        if (res == 1) {                                                         // there is (more) data to be transferred\r
                                if (pckNum == 0) {                                              // first packet, (re)allocate necessary buffer\r


@@ -2026,6 +2098,11 @@ int CmdHF14AMfSniff(const char *Cmd){
                                        bufsize = traceLen;\r
                                        memset(buf, 0x00, traceLen);\r
                                }\r
                                        bufsize = traceLen;\r
                                        memset(buf, 0x00, traceLen);\r
                                }\r

+                               if (bufPtr == NULL) {\r
+                                       PrintAndLog("Cannot allocate memory for trace");\r
+                                       free(buf);\r
+                                       return 2;\r
+                               }\r

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


@@ -2102,48 +2179,46 @@ int CmdHf14MfDecryptBytes(const char *Cmd){
        return tryDecryptWord( nt, ar_enc, at_enc, data, len);\r
 }\r
 \r
        return tryDecryptWord( nt, ar_enc, at_enc, data, len);\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
-  {"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
-  {"wrbl",             CmdHF14AMfWrBl,                 0, "Write MIFARE classic block"},\r
-  {"chk",              CmdHF14AMfChk,                  0, "Test block keys"},\r
-  {"mifare",   CmdHF14AMifare,                 0, "Read parity error messages."},\r
-  {"nested",   CmdHF14AMfNested,               0, "Test nested authentication"},\r
+static command_t CommandTable[] = {\r
+       {"help",                CmdHelp,                                1, "This help"},\r
+       {"dbg",                 CmdHF14AMfDbg,                  0, "Set default debug mode"},\r
+       {"rdbl",                CmdHF14AMfRdBl,                 0, "Read MIFARE classic 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
+       {"wrbl",                CmdHF14AMfWrBl,                 0, "Write MIFARE classic block"},\r
+       {"chk",                 CmdHF14AMfChk,                  0, "Test block keys"},\r
+       {"mifare",              CmdHF14AMifare,                 0, "Read parity error messages."},\r
+       {"nested",              CmdHF14AMfNested,               0, "Test nested authentication"},\r

        {"hardnested",  CmdHF14AMfNestedHard,   0, "Nested attack for hardened Mifare cards"},\r
        {"hardnested",  CmdHF14AMfNestedHard,   0, "Nested attack for hardened Mifare cards"},\r

-  {"sniff",            CmdHF14AMfSniff,                0, "Sniff card-reader communication"},\r
-  {"sim",              CmdHF14AMf1kSim,                0, "Simulate MIFARE card"},\r
-  {"eclr",             CmdHF14AMfEClear,               0, "Clear simulator memory block"},\r
-  {"eget",             CmdHF14AMfEGet,                 0, "Get simulator memory block"},\r
-  {"eset",             CmdHF14AMfESet,                 0, "Set simulator memory block"},\r
-  {"eload",            CmdHF14AMfELoad,                0, "Load from file emul dump"},\r
-  {"esave",            CmdHF14AMfESave,                0, "Save to file emul dump"},\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 - 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
-  {"decrypt",   CmdHf14MfDecryptBytes,  1, "[nt] [ar_enc] [at_enc] [data] - to decrypt snoop or trace"},\r
-  {NULL, NULL, 0, NULL}\r
+       {"sniff",               CmdHF14AMfSniff,                0, "Sniff card-reader communication"},\r
+       {"sim",                 CmdHF14AMf1kSim,                0, "Simulate MIFARE card"},\r
+       {"eclr",                CmdHF14AMfEClear,               0, "Clear simulator memory block"},\r
+       {"eget",                CmdHF14AMfEGet,                 0, "Get simulator memory block"},\r
+       {"eset",                CmdHF14AMfESet,                 0, "Set simulator memory block"},\r
+       {"eload",               CmdHF14AMfELoad,                0, "Load from file emul dump"},\r
+       {"esave",               CmdHF14AMfESave,                0, "Save to file emul dump"},\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 - 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
+       {"decrypt",             CmdHf14MfDecryptBytes,  1, "[nt] [ar_enc] [at_enc] [data] - to decrypt snoop or trace"},\r
+       {NULL, NULL, 0, NULL}\r

 };\r
 \r
 };\r
 \r

-int CmdHFMF(const char *Cmd)\r
-{\r
+int CmdHFMF(const char *Cmd) {\r

        // flush\r
        // flush\r

-       WaitForResponseTimeout(CMD_ACK,NULL,100);\r
+       clearCommandBuffer();\r
+       //WaitForResponseTimeout(CMD_ACK,NULL,100);\r

        CmdsParse(CommandTable, Cmd);\r
        return 0;\r
 }\r
 \r
        CmdsParse(CommandTable, Cmd);\r
        return 0;\r
 }\r
 \r

-int CmdHelp(const char *Cmd)\r
-{\r
+int CmdHelp(const char *Cmd) {\r

        CmdsHelp(CommandTable);\r
        return 0;\r
 }\r
        CmdsHelp(CommandTable);\r
        return 0;\r
 }\r