]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhfmf.c
Merge branch 'master' of https://github.com/iceman1001/proxmark3
[proxmark3-svn] / client / cmdhfmf.c
index 0229c9477489137e9c722f786bac6c44ffc53f51..272f1ade2d2c47a619f90a81a1a27fa0afa240c4 100644 (file)
@@ -7,8 +7,10 @@
 //-----------------------------------------------------------------------------\r
 // High frequency MIFARE commands\r
 //-----------------------------------------------------------------------------\r
-#include "../include/mifare.h"\r
+\r
 #include "cmdhfmf.h"\r
+#include "cmdhfmfhard.h"\r
+#include "nonce2key/nonce2key.h"\r
 \r
 static int CmdHelp(const char *Cmd);\r
 \r
@@ -17,15 +19,14 @@ int CmdHF14AMifare(const char *Cmd)
        uint32_t uid = 0;\r
        uint32_t nt = 0, nr = 0;\r
        uint64_t par_list = 0, ks_list = 0, r_key = 0;\r
-       uint8_t isOK = 0;\r
-       uint8_t keyBlock[8] = {0};\r
+       int16_t isOK = 0;\r
 \r
        UsbCommand c = {CMD_READER_MIFARE, {true, 0, 0}};\r
 \r
        // message\r
        printf("-------------------------------------------------------------------------\n");\r
        printf("Executing command. Expected execution time: 25sec on average  :-)\n");\r
-       printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");\r
+       printf("Press button on the proxmark3 device to abort both proxmark3 and client.\n");\r
        printf("-------------------------------------------------------------------------\n");\r
 \r
        \r
@@ -48,14 +49,21 @@ start:
                \r
                UsbCommand resp;\r
                if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {\r
-                       isOK  = resp.arg[0] & 0xff;\r
+                       isOK  = resp.arg[0];\r
                        uid = (uint32_t)bytes_to_num(resp.d.asBytes +  0, 4);\r
                        nt =  (uint32_t)bytes_to_num(resp.d.asBytes +  4, 4);\r
                        par_list = bytes_to_num(resp.d.asBytes +  8, 8);\r
                        ks_list = bytes_to_num(resp.d.asBytes +  16, 8);\r
                        nr = bytes_to_num(resp.d.asBytes + 24, 4);\r
                        printf("\n\n");\r
-                       if (!isOK) PrintAndLog("Proxmark can't get statistic info. Execution aborted.\n");\r
+                       switch (isOK) {\r
+                               case -1 : PrintAndLog("Button pressed. Aborted.\n"); break;\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
+                               default: ;\r
+                       }\r
                        break;\r
                }\r
        }       \r
@@ -69,22 +77,13 @@ start:
        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
-               printf("------------------------------------------------------------------\n");\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
-               PrintAndLog("Found valid key :%012"llx, r_key);\r
-       else\r
-       {\r
-               if (isOK != 2) PrintAndLog("Found invalid key. ");      \r
                PrintAndLog("Failing is expected to happen in 25%% of all cases. Trying again with a different reader nonce...");\r
                c.arg[0] = false;\r
                goto start;\r
+       } else {\r
+               isOK = 0;\r
+               printf("------------------------------------------------------------------\n");\r
+               PrintAndLog("Found valid key: %012"llx" \n", r_key);\r
        }\r
        \r
        PrintAndLog("");\r
@@ -127,6 +126,7 @@ int CmdHF14AMfWrBl(const char *Cmd)
        UsbCommand c = {CMD_MIFARE_WRITEBL, {blockNo, keyType, 0}};\r
        memcpy(c.d.asBytes, key, 6);\r
        memcpy(c.d.asBytes + 10, bldata, 16);\r
+       clearCommandBuffer();\r
        SendCommand(&c);\r
 \r
        UsbCommand resp;\r
@@ -170,6 +170,7 @@ int CmdHF14AMfRdBl(const char *Cmd)
        \r
        UsbCommand c = {CMD_MIFARE_READBL, {blockNo, keyType, 0}};\r
        memcpy(c.d.asBytes, key, 6);\r
+       clearCommandBuffer();\r
        SendCommand(&c);\r
 \r
        UsbCommand resp;\r
@@ -223,6 +224,7 @@ int CmdHF14AMfRdSc(const char *Cmd)
        \r
        UsbCommand c = {CMD_MIFARE_READSC, {sectorNo, keyType, 0}};\r
        memcpy(c.d.asBytes, key, 6);\r
+       clearCommandBuffer();\r
        SendCommand(&c);\r
        PrintAndLog(" ");\r
 \r
@@ -278,14 +280,7 @@ int CmdHF14AMfDump(const char *Cmd)
        \r
        UsbCommand resp;\r
 \r
-       int size = GetCardSize();               \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
@@ -305,7 +300,7 @@ int CmdHF14AMfDump(const char *Cmd)
        }\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
@@ -328,7 +323,7 @@ int CmdHF14AMfDump(const char *Cmd)
        }\r
        \r
        fclose(fin);\r
-       \r
+\r
        PrintAndLog("|-----------------------------------------|");\r
        PrintAndLog("|------ Reading sector access bits...-----|");\r
        PrintAndLog("|-----------------------------------------|");\r
@@ -336,6 +331,7 @@ int CmdHF14AMfDump(const char *Cmd)
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 0, 0}};\r
                memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+               clearCommandBuffer();\r
                SendCommand(&c);\r
 \r
                if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
@@ -370,6 +366,7 @@ int CmdHF14AMfDump(const char *Cmd)
                        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
+                               clearCommandBuffer();\r
                                SendCommand(&c);\r
                                received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                        } else {                                                                                                // data block. Check if it can be read with key A or key B\r
@@ -381,12 +378,13 @@ 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
-                                               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
-                                               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
+                                       clearCommandBuffer();\r
+                                       SendCommand(&c);\r
+                                       received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                }\r
                        }\r
 \r
@@ -433,7 +431,7 @@ int CmdHF14AMfDump(const char *Cmd)
                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
@@ -441,7 +439,7 @@ int CmdHF14AMfRestore(const char *Cmd)
 {\r
        uint8_t sectorNo,blockNo;\r
        uint8_t keyType = 0;\r
-       uint8_t key[6] = {0xFF};\r
+       uint8_t key[6] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};\r
        uint8_t bldata[16] = {0x00};\r
        uint8_t keyA[40][6];\r
        uint8_t keyB[40][6];\r
@@ -460,7 +458,7 @@ int CmdHF14AMfRestore(const char *Cmd)
                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
@@ -468,7 +466,7 @@ int CmdHF14AMfRestore(const char *Cmd)
                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
@@ -477,6 +475,7 @@ 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
+                       fclose(fkeys);\r
                        return 2;\r
                }\r
        }\r
@@ -484,12 +483,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
+                       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
@@ -525,6 +525,7 @@ int CmdHF14AMfRestore(const char *Cmd)
                        PrintAndLog("Writing to block %3d: %s", FirstBlockOfSector(sectorNo) + blockNo, sprint_hex(bldata, 16));\r
                        \r
                        memcpy(c.d.asBytes + 10, bldata, 16);\r
+                       clearCommandBuffer();\r
                        SendCommand(&c);\r
 \r
                        UsbCommand resp;\r
@@ -551,7 +552,7 @@ int CmdHF14AMfNested(const char *Cmd)
        uint8_t trgKeyType = 0;\r
        uint8_t SectorsCnt = 0;\r
        uint8_t key[6] = {0, 0, 0, 0, 0, 0};\r
-       uint8_t keyBlock[13*6];\r
+       uint8_t keyBlock[14*6];\r
        uint64_t key64 = 0;\r
        bool transferToEml = false;\r
        \r
@@ -626,8 +627,14 @@ int CmdHF14AMfNested(const char *Cmd)
        \r
        if (cmdp == 'o') {\r
                PrintAndLog("--target block no:%3d, target key type:%c ", trgBlockNo, trgKeyType?'B':'A');\r
-               if (mfnested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, true)) {\r
-                       PrintAndLog("Nested error.");\r
+               int16_t isOK = mfnested(blockNo, keyType, key, trgBlockNo, trgKeyType, keyBlock, true);\r
+               if (isOK) {\r
+                       switch (isOK) {\r
+                               case -1 : PrintAndLog("Error: No response from Proxmark.\n"); break;\r
+                               case -2 : PrintAndLog("Button pressed. Aborted.\n"); break;\r
+                               case -3 : PrintAndLog("Tag isn't vulnerable to Nested Attack (random numbers are not predictable).\n"); break;\r
+                               default : PrintAndLog("Unknown Error.\n");\r
+                       }\r
                        return 2;\r
                }\r
                key64 = bytes_to_num(keyBlock, 6);\r
@@ -682,7 +689,7 @@ int CmdHF14AMfNested(const char *Cmd)
                        for (j = 0; j < 2; j++) {\r
                                if (e_sector[i].foundKey[j]) continue;\r
                                \r
-                               res = mfCheckKeys(FirstBlockOfSector(i), j, 6, keyBlock, &key64);\r
+                               res = mfCheckKeys(FirstBlockOfSector(i), j, true, 6, keyBlock, &key64);\r
                                \r
                                if (!res) {\r
                                        e_sector[i].Key[j] = key64;\r
@@ -697,21 +704,20 @@ 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
-\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
-                                       if(mfnested(blockNo, keyType, key, FirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate)) {\r
-                                               PrintAndLog("Nested error.\n");\r
+                                       int16_t isOK = mfnested(blockNo, keyType, key, FirstBlockOfSector(sectorNo), trgKeyType, keyBlock, calibrate);\r
+                                       if(isOK) {\r
+                                               switch (isOK) {\r
+                                                       case -1 : PrintAndLog("Error: No response from Proxmark.\n"); break;\r
+                                                       case -2 : PrintAndLog("Button pressed. Aborted.\n"); break;\r
+                                                       case -3 : PrintAndLog("Tag isn't vulnerable to Nested Attack (random numbers are not predictable).\n"); break;\r
+                                                       default : PrintAndLog("Unknown Error.\n");\r
+                                               }\r
                                                free(e_sector);\r
-                                               return 2;                                       }\r
-                                       else {\r
+                                               return 2;\r
+                                       else {\r
                                                calibrate = false;\r
                                        }\r
                                        \r
@@ -780,26 +786,139 @@ int CmdHF14AMfNested(const char *Cmd)
                        }\r
                        fclose(fkeys);\r
                }\r
-\r
+               \r
                free(e_sector);\r
        }\r
        return 0;\r
 }\r
 \r
+int CmdHF14AMfNestedHard(const char *Cmd)\r
+{\r
+       uint8_t blockNo = 0;\r
+       uint8_t keyType = 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
+       if (ctmp != 'R' && ctmp != 'r' && strlen(Cmd) < 20) {\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> [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("      s: Slower acquisition (required by some non standard cards)");\r
+               PrintAndLog("      r: Read nonces.bin and start attack");\r
+               PrintAndLog(" ");\r
+               PrintAndLog("      sample1: hf mf hardnested 0 A FFFFFFFFFFFF 4 A");\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
+               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
+       bool know_target_key = false;\r
+       bool nonce_file_read = false;\r
+       bool nonce_file_write = false;\r
+       bool slow = false;\r
+       \r
+       if (ctmp == 'R' || ctmp == 'r') {\r
+               nonce_file_read = true;\r
+               if (!param_gethex(Cmd, 1, trgkey, 12)) {\r
+                       know_target_key = true;\r
+               }\r
+\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
+                       PrintAndLog("Key type must be A or B");\r
+                       return 1;\r
+               }\r
+               if (ctmp != 'A' && ctmp != 'a') { \r
+                       keyType = 1;\r
+               }\r
+               \r
+               if (param_gethex(Cmd, 2, key, 12)) {\r
+                       PrintAndLog("Key must include 12 HEX symbols");\r
+                       return 1;\r
+               }\r
+               \r
+               trgBlockNo = param_get8(Cmd, 3);\r
+               ctmp = param_getchar(Cmd, 4);\r
+               if (ctmp != 'a' && ctmp != 'A' && ctmp != 'b' && ctmp != 'B') {\r
+                       PrintAndLog("Target key type must be A or B");\r
+                       return 1;\r
+               }\r
+               if (ctmp != 'A' && ctmp != 'a') {\r
+                       trgKeyType = 1;\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
+                       } else if (ctmp == 'w' || ctmp == 'W') {\r
+                               nonce_file_write = true;\r
+                       } else {\r
+                               PrintAndLog("Possible options are w and/or s");\r
+                               return 1;\r
+                       }\r
+                       i++;\r
+               }\r
+       }\r
+\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 ", \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
+                       slow?"Yes":"No");\r
+\r
+       int16_t isOK = mfnestedhard(blockNo, keyType, key, trgBlockNo, trgKeyType, know_target_key?trgkey:NULL, nonce_file_read, nonce_file_write, slow);\r
+\r
+       if (isOK) {\r
+               switch (isOK) {\r
+                       case 1 : PrintAndLog("Error: No response from Proxmark.\n"); break;\r
+                       case 2 : PrintAndLog("Button pressed. Aborted.\n"); break;\r
+                       default : break;\r
+               }\r
+               return 2;\r
+       }\r
+\r
+       return 0;\r
+}\r
+\r
 int CmdHF14AMfChk(const char *Cmd)\r
 {\r
        if (strlen(Cmd)<3) {\r
                PrintAndLog("Usage:  hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t|d] [<key (12 hex symbols)>] [<dic (*.dic)>]");\r
                PrintAndLog("          * - all sectors");\r
                PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");\r
-               PrintAndLog("d - write keys to binary file\n");\r
-               PrintAndLog("t - write keys to emulator memory");\r
+               PrintAndLog("d - write keys to binary file");\r
+               PrintAndLog("t - write keys to emulator memory\n");\r
                PrintAndLog("      sample: hf mf chk 0 A 1234567890ab keys.dic");\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
@@ -944,8 +1063,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
-                       (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
@@ -967,7 +1086,7 @@ int CmdHF14AMfChk(const char *Cmd)
                        uint32_t max_keys = keycnt>USB_CMD_DATA_SIZE/6?USB_CMD_DATA_SIZE/6:keycnt;\r
                        for (uint32_t c = 0; c < keycnt; c+=max_keys) {\r
                                uint32_t size = keycnt-c>max_keys?max_keys:keycnt-c;\r
-                               res = mfCheckKeys(b, t, size, &keyBlock[6*c], &key64);\r
+                               res = mfCheckKeys(b, t, true, size, &keyBlock[6*c], &key64);\r
                                if (res != 1) {\r
                                        if (!res) {\r
                                                PrintAndLog("Found valid key:[%012"llx"]",key64);\r
@@ -990,13 +1109,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
-               }\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
-                       }\r
+       }\r
 \r
        if (createDumpFile) {\r
                FILE *fkeys = fopen("dumpkeys.bin","wb");\r
@@ -1004,7 +1123,7 @@ int CmdHF14AMfChk(const char *Cmd)
                        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
@@ -1014,7 +1133,7 @@ int CmdHF14AMfChk(const char *Cmd)
 \r
        free(keyBlock);\r
        PrintAndLog("");\r
-  return 0;\r
+       return 0;\r
 }\r
 \r
 int CmdHF14AMf1kSim(const char *Cmd)\r
@@ -1022,13 +1141,17 @@ int CmdHF14AMf1kSim(const char *Cmd)
        uint8_t uid[7] = {0, 0, 0, 0, 0, 0, 0};\r
        uint8_t exitAfterNReads = 0;\r
        uint8_t flags = 0;\r
+       \r
+       uint8_t cmdp = param_getchar(Cmd, 0);\r
 \r
-       if (param_getchar(Cmd, 0) == 'h') {\r
+       if (cmdp == 'h' || cmdp == 'H') {\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("");\r
                PrintAndLog("           sample: hf mf sim u 0a0a0a0a ");\r
                return 0;\r
        }\r
@@ -1067,17 +1190,49 @@ int CmdHF14AMf1kSim(const char *Cmd)
 \r
        UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};\r
        memcpy(c.d.asBytes, uid, sizeof(uid));\r
+       clearCommandBuffer();\r
        SendCommand(&c);\r
 \r
        if(flags & FLAG_INTERACTIVE)\r
-       {\r
-               UsbCommand resp;\r
-               PrintAndLog("Press pm3-button to abort simulation");\r
-               while(! WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
+       {               \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
-       }\r
+               //}\r
+               while(!ukbhit() ){\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
+                                       \r
+                                       memcpy(data, resp.d.asBytes, len);\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
+                               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 |= data[7] << 24;\r
+                                               corr_uid |= data[6] << 16;\r
+                                               corr_uid |= data[5] << 8;\r
+                                               corr_uid |= data[4];\r
+                               tryMfk64(corr_uid, data, key);\r
+                                       }\r
+                                       PrintAndLog("--");\r
+                               }\r
+                       }\r
        \r
        return 0;\r
 }\r
@@ -1100,16 +1255,16 @@ int CmdHF14AMfDbg(const char *Cmd)
                return 0;\r
        }       \r
 \r
-  UsbCommand c = {CMD_MIFARE_SET_DBGMODE, {dbgMode, 0, 0}};\r
-  SendCommand(&c);\r
+       UsbCommand c = {CMD_MIFARE_SET_DBGMODE, {dbgMode, 0, 0}};\r
+       SendCommand(&c);\r
 \r
-  return 0;\r
+       return 0;\r
 }\r
 \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
@@ -1137,12 +1292,11 @@ int CmdHF14AMfEClear(const char *Cmd)
                return 0;\r
        }       \r
 \r
-  UsbCommand c = {CMD_MIFARE_EML_MEMCLR, {0, 0, 0}};\r
-  SendCommand(&c);\r
-  return 0;\r
+       UsbCommand c = {CMD_MIFARE_EML_MEMCLR, {0, 0, 0}};\r
+       SendCommand(&c);\r
+       return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfESet(const char *Cmd)\r
 {\r
        uint8_t memBlock[16];\r
@@ -1170,26 +1324,22 @@ int CmdHF14AMfESet(const char *Cmd)
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfELoad(const char *Cmd)\r
 {\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
-       memset(filename, 0, sizeof(filename));\r
-       memset(buf, 0, sizeof(buf));\r
-\r
+       uint8_t blockWidth = 32;\r
        char ctmp = param_getchar(Cmd, 0);\r
                \r
-       if ( ctmp == 'h' || ctmp == 0x00) {\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("  [card memory]: 0 = 320 bytes (Mifare Mini), 1 = 1K (default), 2 = 2K, 4 = 4K");\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("         hf mf eload 4 filename");\r
@@ -1202,15 +1352,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 'U' : // fall through\r
+               case 'u' : numBlocks = 255; blockWidth = 8; break;\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
-       if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r
+       if (len > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
 \r
        fnameptr += len;\r
 \r
@@ -1236,28 +1390,29 @@ int CmdHF14AMfELoad(const char *Cmd)
                        return 2;\r
                }\r
                \r
-               if (strlen(buf) < 32){\r
+               if (strlen(buf) < blockWidth){\r
                        if(strlen(buf) && feof(f))\r
                                break;\r
-                       PrintAndLog("File content error. Block data must include 32 HEX symbols");\r
+                       PrintAndLog("File content error. Block data must include %d HEX symbols", blockWidth);\r
                        fclose(f);\r
                        return 2;\r
                }\r
                \r
-               for (i = 0; i < 32; i += 2) {\r
+               for (i = 0; i < blockWidth; i += 2) {\r
                        sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
                }\r
-               \r
-               if (mfEmlSetMem(buf8, blockNum, 1)) {\r
+               if (mfEmlSetMem_xt(buf8, blockNum, 1, blockWidth/2)) {\r
                        PrintAndLog("Cant set emul block: %3d", blockNum);\r
                        fclose(f);\r
                        return 3;\r
                }\r
+               printf(".");\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
@@ -1267,7 +1422,6 @@ int CmdHF14AMfELoad(const char *Cmd)
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfESave(const char *Cmd)\r
 {\r
        FILE * f;\r
@@ -1283,7 +1437,7 @@ int CmdHF14AMfESave(const char *Cmd)
        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 [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
@@ -1292,7 +1446,7 @@ int CmdHF14AMfESave(const char *Cmd)
                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
@@ -1307,17 +1461,20 @@ int CmdHF14AMfESave(const char *Cmd)
 \r
        len = param_getstr(Cmd,nameParamNo,filename);\r
        \r
-       if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r
+       if (len > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
        \r
        // user supplied filename?\r
        if (len < 1) {\r
                // get filename (UID from memory)\r
                if (mfEmlGetMem(buf, 0, 1)) {\r
                        PrintAndLog("Can\'t get UID from block: %d", 0);\r
-                       sprintf(filename, "dump.eml"); \r
+                       len = sprintf(fnameptr, "dump");\r
+                       fnameptr += len;\r
+               }\r
+               else {\r
+                       for (j = 0; j < 7; j++, fnameptr += 2)\r
+                               sprintf(fnameptr, "%02X", buf[j]);\r
                }\r
-               for (j = 0; j < 7; j++, fnameptr += 2)\r
-                       sprintf(fnameptr, "%02X", buf[j]); \r
        } else {\r
                fnameptr += len;\r
        }\r
@@ -1327,7 +1484,7 @@ int CmdHF14AMfESave(const char *Cmd)
        \r
        // open file\r
        f = fopen(filename, "w+");\r
-       \r
+\r
        if ( !f ) {\r
                PrintAndLog("Can't open file %s ", filename);\r
                return 1;\r
@@ -1350,7 +1507,6 @@ int CmdHF14AMfESave(const char *Cmd)
   return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfECFill(const char *Cmd)\r
 {\r
        uint8_t keyType = 0;\r
@@ -1390,15 +1546,16 @@ int CmdHF14AMfECFill(const char *Cmd)
        return 0;\r
 }\r
 \r
-\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
+       char cmdp = param_getchar(Cmd, 0);\r
        \r
-       if (param_getchar(Cmd, 0) == 'h') {\r
+       if ( cmdp == 'h' || cmdp == '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
@@ -1407,8 +1564,6 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
                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
@@ -1435,37 +1590,69 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfCSetUID(const char *Cmd)\r
 {\r
        uint8_t wipeCard = 0;\r
        uint8_t uid[8] = {0x00};\r
        uint8_t oldUid[8] = {0x00};\r
+       uint8_t atqa[2] = {0x00};\r
+       uint8_t sak[1] = {0x00};\r
+       uint8_t atqaPresent = 1;\r
        int res;\r
-\r
-       if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
-               PrintAndLog("Usage:  hf mf csetuid <UID 8 hex symbols> <w>");\r
-               PrintAndLog("sample:  hf mf csetuid 01020304 w");\r
-               PrintAndLog("Set UID for magic Chinese card (only works with!!!)");\r
-               PrintAndLog("If you want wipe card then add 'w' into command line. \n");\r
+       char ctmp;\r
+       int argi=0;\r
+\r
+       if (strlen(Cmd) < 1 || param_getchar(Cmd, argi) == 'h') {\r
+               PrintAndLog("Usage:  hf mf csetuid <UID 8 hex symbols> [ATQA 4 hex symbols SAK 2 hex symbols] [w]");\r
+               PrintAndLog("sample:  hf mf csetuid 01020304");\r
+               PrintAndLog("sample:  hf mf csetuid 01020304 0004 08 w");\r
+               PrintAndLog("Set UID, ATQA, and SAK for magic Chinese card (only works with such cards)");\r
+               PrintAndLog("If you also want to wipe the card then add 'w' at the end of the command line.");\r
                return 0;\r
-       }       \r
+       }\r
 \r
-       if (param_getchar(Cmd, 0) && param_gethex(Cmd, 0, uid, 8)) {\r
+       if (param_getchar(Cmd, argi) && param_gethex(Cmd, argi, uid, 8)) {\r
                PrintAndLog("UID must include 8 HEX symbols");\r
                return 1;\r
        }\r
+       argi++;\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
+       ctmp = param_getchar(Cmd, argi);\r
+       if (ctmp == 'w' || ctmp == 'W') {\r
+               wipeCard = 1;\r
+               atqaPresent = 0;\r
+       }\r
 \r
-       res = mfCSetUID(uid, oldUid, wipeCard);\r
-       if (res) {\r
-               PrintAndLog("Can't set UID. error=%d", res);\r
-               return 1;\r
+       if (atqaPresent) {\r
+               if (param_getchar(Cmd, argi)) {\r
+                       if (param_gethex(Cmd, argi, atqa, 4)) {\r
+                               PrintAndLog("ATQA must include 4 HEX symbols");\r
+                               return 1;\r
+                       }\r
+                       argi++;\r
+                       if (!param_getchar(Cmd, argi) || param_gethex(Cmd, argi, sak, 2)) {\r
+                               PrintAndLog("SAK must include 2 HEX symbols");\r
+                               return 1;\r
+                       }\r
+                       argi++;\r
+               } else\r
+                       atqaPresent = 0;\r
        }\r
+\r
+       if(!wipeCard) {\r
+               ctmp = param_getchar(Cmd, argi);\r
+               if (ctmp == 'w' || ctmp == 'W') {\r
+                       wipeCard = 1;\r
+               }\r
+       }\r
+\r
+       PrintAndLog("--wipe card:%s  uid:%s", (wipeCard)?"YES":"NO", sprint_hex(uid, 4));\r
+\r
+       res = mfCSetUID(uid, (atqaPresent)?atqa:NULL, (atqaPresent)?sak:NULL, oldUid, wipeCard);\r
+       if (res) {\r
+                       PrintAndLog("Can't set UID. error=%d", res);\r
+                       return 1;\r
+               }\r
        \r
        PrintAndLog("old UID:%s", sprint_hex(oldUid, 4));\r
        PrintAndLog("new UID:%s", sprint_hex(uid, 4));\r
@@ -1474,55 +1661,56 @@ int CmdHF14AMfCSetUID(const char *Cmd)
 \r
 int CmdHF14AMfCSetBlk(const char *Cmd)\r
 {\r
-       uint8_t uid[8];\r
-       uint8_t memBlock[16];\r
+       uint8_t block[16] = {0x00};\r
        uint8_t blockNo = 0;\r
+       uint8_t params = MAGIC_SINGLE;\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
+               PrintAndLog("Usage:  hf mf csetblk <block number> <block data (32 hex symbols)> [w]");\r
                PrintAndLog("sample:  hf mf csetblk 1 01020304050607080910111213141516");\r
-               PrintAndLog("Set block data for magic Chinese card (only works with!!!)");\r
-               PrintAndLog("If you want wipe card then add 'w' into command line. \n");\r
+               PrintAndLog("Set block data for magic Chinese card (only works with such cards)");\r
+               PrintAndLog("If you also want wipe the card then add 'w' at the end of the command line");\r
                return 0;\r
        }       \r
 \r
        blockNo = param_get8(Cmd, 0);\r
 \r
-       if (param_gethex(Cmd, 1, memBlock, 32)) {\r
+       if (param_gethex(Cmd, 1, block, 32)) {\r
                PrintAndLog("block data must include 32 HEX symbols");\r
                return 1;\r
        }\r
 \r
-       PrintAndLog("--block number:%2d data:%s", blockNo, sprint_hex(memBlock, 16));\r
+       char ctmp = param_getchar(Cmd, 2);\r
+       if (ctmp == 'w' || ctmp == 'W')\r
+               params |= MAGIC_WIPE;\r
+       \r
+       PrintAndLog("--block number:%2d data:%s", blockNo, sprint_hex(block, 16));\r
 \r
-       res = mfCSetBlock(blockNo, memBlock, uid, 0, CSETBLOCK_SINGLE_OPER);\r
+       res = mfCSetBlock(blockNo, block, NULL, params);\r
        if (res) {\r
-                       PrintAndLog("Can't write block. error=%d", res);\r
-                       return 1;\r
-               }\r
-       \r
-       PrintAndLog("UID:%s", sprint_hex(uid, 4));\r
+               PrintAndLog("Can't write block. error=%d", res);\r
+               return 1;\r
+       }\r
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfCLoad(const char *Cmd)\r
 {\r
        FILE * f;\r
-       char filename[FILE_PATH_SIZE] = {0x00};\r
+       char filename[FILE_PATH_SIZE];\r
        char * fnameptr = filename;\r
        char buf[64] = {0x00};\r
        uint8_t buf8[64] = {0x00};\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
+       int i, len, blockNum, flags=0;\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
+       memset(filename, 0, sizeof(filename));\r
+       \r
+       char ctmp = param_getchar(Cmd, 0);\r
+       \r
+       if (ctmp == 'h' || ctmp == 'H' || ctmp == 0x00) {\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
@@ -1530,21 +1718,19 @@ int CmdHF14AMfCLoad(const char *Cmd)
                return 0;\r
        }       \r
 \r
-       char ctmp = param_getchar(Cmd, 0);\r
        if (ctmp == 'e' || ctmp == 'E') fillFromEmulator = 1;\r
        \r
        if (fillFromEmulator) {\r
-               flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                for (blockNum = 0; blockNum < 16 * 4; blockNum += 1) {\r
                        if (mfEmlGetMem(buf8, blockNum, 1)) {\r
                                PrintAndLog("Cant get block: %d", blockNum);\r
                                return 2;\r
                        }\r
-                       \r
-                       if (blockNum == 2) flags = 0;\r
-                       if (blockNum == 16 * 4 - 1) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
+                       if (blockNum == 0) flags = MAGIC_INIT + MAGIC_WUPC;                             // switch on field and send magic sequence\r
+                       if (blockNum == 1) flags = 0;                                                                                                   // just write\r
+                       if (blockNum == 16 * 4 - 1) flags = MAGIC_HALT + MAGIC_OFF;             // Done. Magic Halt and switch off field.\r
 \r
-                       if (mfCSetBlock(blockNum, buf8, NULL, 0, flags)) {\r
+                       if (mfCSetBlock(blockNum, buf8, NULL, flags)) {\r
                                PrintAndLog("Cant set magic card block: %d", blockNum);\r
                                return 3;\r
                        }\r
@@ -1552,7 +1738,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r
-               if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r
+               if (len > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
 \r
                memcpy(filename, Cmd, len);\r
                fnameptr += len;\r
@@ -1567,27 +1753,31 @@ int CmdHF14AMfCLoad(const char *Cmd)
                }\r
        \r
                blockNum = 0;\r
-               flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
                while(!feof(f)){\r
+               \r
                        memset(buf, 0, sizeof(buf));\r
+                       \r
                        if (fgets(buf, sizeof(buf), f) == NULL) {\r
+                               fclose(f);\r
                                PrintAndLog("File reading error.");\r
                                return 2;\r
                        }\r
 \r
-                       if (strlen(buf) < 32){\r
+                       if (strlen(buf) < 32) {\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
                        for (i = 0; i < 32; i += 2)\r
                                sscanf(&buf[i], "%02x", (unsigned int *)&buf8[i / 2]);\r
 \r
-                       if (blockNum == 2) flags = 0;\r
-                       if (blockNum == 16 * 4 - 1) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
+                       if (blockNum == 0) flags = MAGIC_INIT + MAGIC_WUPC;                             // switch on field and send magic sequence\r
+                       if (blockNum == 1) flags = 0;                                                                                                   // just write\r
+                       if (blockNum == 16 * 4 - 1) flags = MAGIC_HALT + MAGIC_OFF;             // Done. Switch off field.\r
 \r
-                       if (mfCSetBlock(blockNum, buf8, NULL, 0, flags)) {\r
+                       if (mfCSetBlock(blockNum, buf8, NULL, flags)) {\r
                                PrintAndLog("Can't set magic card block: %d", blockNum);\r
                                return 3;\r
                        }\r
@@ -1597,6 +1787,7 @@ int CmdHF14AMfCLoad(const char *Cmd)
                }\r
                fclose(f);\r
        \r
+               // 64 or 256blocks.\r
                if (blockNum != 16 * 4 && blockNum != 32 * 4 + 8 * 16){\r
                        PrintAndLog("File content error. There must be 64 blocks");\r
                        return 4;\r
@@ -1604,18 +1795,20 @@ int CmdHF14AMfCLoad(const char *Cmd)
                PrintAndLog("Loaded from file: %s", filename);\r
                return 0;\r
        }\r
+       return 0;\r
 }\r
 \r
 int CmdHF14AMfCGetBlk(const char *Cmd) {\r
-       uint8_t memBlock[16];\r
+       uint8_t data[16];\r
        uint8_t blockNo = 0;\r
        int res;\r
-       memset(memBlock, 0x00, sizeof(memBlock));\r
+       memset(data, 0x00, sizeof(data));\r
+       char ctmp = param_getchar(Cmd, 0);\r
 \r
-       if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {\r
+       if (strlen(Cmd) < 1 || ctmp == 'h' || ctmp == 'H') {\r
                PrintAndLog("Usage:  hf mf cgetblk <block number>");\r
                PrintAndLog("sample:  hf mf cgetblk 1");\r
-               PrintAndLog("Get block data from magic Chinese card (only works with!!!)\n");\r
+               PrintAndLog("Get block data from magic Chinese card (only works with such cards)\n");\r
                return 0;\r
        }       \r
 \r
@@ -1623,27 +1816,27 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
 \r
        PrintAndLog("--block number:%2d ", blockNo);\r
 \r
-       res = mfCGetBlock(blockNo, memBlock, CSETBLOCK_SINGLE_OPER);\r
+       res = mfCGetBlock(blockNo, data, MAGIC_SINGLE);\r
        if (res) {\r
-                       PrintAndLog("Can't read block. error=%d", res);\r
-                       return 1;\r
-               }\r
+               PrintAndLog("Can't read block. error=%d", res);\r
+               return 1;\r
+       }\r
        \r
-       PrintAndLog("block data:%s", sprint_hex(memBlock, 16));\r
+       PrintAndLog("data: %s", sprint_hex(data, sizeof(data)));\r
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfCGetSc(const char *Cmd) {\r
-       uint8_t memBlock[16];\r
+       uint8_t data[16];\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
+       memset(data, 0x00, sizeof(data));\r
+       char ctmp = param_getchar(Cmd, 0);\r
+       \r
+       if (strlen(Cmd) < 1 || ctmp == 'h' || ctmp == 'H') {\r
                PrintAndLog("Usage:  hf mf cgetsc <sector number>");\r
                PrintAndLog("sample:  hf mf cgetsc 0");\r
-               PrintAndLog("Get sector data from magic Chinese card (only works with!!!)\n");\r
+               PrintAndLog("Get sector data from magic Chinese card (only works with such cards)\n");\r
                return 0;\r
        }       \r
 \r
@@ -1654,37 +1847,37 @@ int CmdHF14AMfCGetSc(const char *Cmd) {
        }\r
 \r
        PrintAndLog("--sector number:%d ", sectorNo);\r
+       PrintAndLog("block | data");\r
 \r
-       flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
+       flags = MAGIC_INIT + MAGIC_WUPC;\r
        for (i = 0; i < 4; i++) {\r
                if (i == 1) flags = 0;\r
-               if (i == 3) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
+               if (i == 3) flags = MAGIC_HALT + MAGIC_OFF;\r
 \r
-               res = mfCGetBlock(sectorNo * 4 + i, memBlock, flags);\r
+               res = mfCGetBlock(sectorNo * 4 + i, data, flags);\r
                if (res) {\r
                        PrintAndLog("Can't read block. %d error=%d", sectorNo * 4 + i, res);\r
                        return 1;\r
-               }\r
-       \r
-               PrintAndLog("block %3d data:%s", sectorNo * 4 + i, sprint_hex(memBlock, 16));\r
+               }       \r
+               PrintAndLog(" %3d | %s", sectorNo * 4 + i, sprint_hex(data, sizeof(data)));\r
        }\r
        return 0;\r
 }\r
 \r
-\r
 int CmdHF14AMfCSave(const char *Cmd) {\r
 \r
        FILE * f;\r
-       char filename[FILE_PATH_SIZE] = {0x00};\r
+       char filename[FILE_PATH_SIZE];\r
        char * fnameptr = filename;\r
        uint8_t fillFromEmulator = 0;\r
-       uint8_t buf[64] = {0x00};\r
+       uint8_t buf[64];\r
        int i, j, len, flags;\r
        \r
-       // memset(filename, 0, sizeof(filename));\r
-       // memset(buf, 0, sizeof(buf));\r
-\r
-       if (param_getchar(Cmd, 0) == 'h') {\r
+       memset(filename, 0, sizeof(filename));\r
+       memset(buf, 0, sizeof(buf));\r
+       char ctmp = param_getchar(Cmd, 0);\r
+       \r
+       if ( ctmp == 'h' || ctmp == 'H' ) {\r
                PrintAndLog("It saves `magic Chinese` card dump into the file `filename.eml` or `cardID.eml`");\r
                PrintAndLog("or into emulator memory (option `e`)");\r
                PrintAndLog("Usage:  hf mf esave [file name w/o `.eml`][e]");\r
@@ -1693,16 +1886,14 @@ int CmdHF14AMfCSave(const char *Cmd) {
                PrintAndLog("         hf mf esave e \n");\r
                return 0;\r
        }       \r
-\r
-       char ctmp = param_getchar(Cmd, 0);\r
        if (ctmp == 'e' || ctmp == 'E') fillFromEmulator = 1;\r
 \r
        if (fillFromEmulator) {\r
                // put into emulator\r
-               flags = CSETBLOCK_INIT_FIELD + CSETBLOCK_WUPC;\r
+               flags = MAGIC_INIT + MAGIC_WUPC;\r
                for (i = 0; i < 16 * 4; i++) {\r
                        if (i == 1) flags = 0;\r
-                       if (i == 16 * 4 - 1) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
+                       if (i == 16 * 4 - 1) flags = MAGIC_HALT + MAGIC_OFF;\r
                \r
                        if (mfCGetBlock(i, buf, flags)) {\r
                                PrintAndLog("Cant get block: %d", i);\r
@@ -1717,36 +1908,40 @@ int CmdHF14AMfCSave(const char *Cmd) {
                return 0;\r
        } else {\r
                len = strlen(Cmd);\r
-               if (len > FILE_PATH_SIZE) len = FILE_PATH_SIZE;\r
+               if (len > FILE_PATH_SIZE - 4) len = FILE_PATH_SIZE - 4;\r
        \r
+               // get filename based on UID\r
                if (len < 1) {\r
-                       // get filename\r
-                       if (mfCGetBlock(0, buf, CSETBLOCK_SINGLE_OPER)) {\r
+               \r
+                       if (mfCGetBlock(0, buf, MAGIC_SINGLE)) {\r
                                PrintAndLog("Cant get block: %d", 0);\r
-                               return 1;\r
+                               len = sprintf(fnameptr, "dump");\r
+                               fnameptr += len;\r
+                       } else {\r
+                               for (j = 0; j < 7; j++, fnameptr += 2)\r
+                                       sprintf(fnameptr, "%02x", buf[j]); \r
                        }\r
-                       for (j = 0; j < 7; j++, fnameptr += 2)\r
-                               sprintf(fnameptr, "%02x", buf[j]); \r
                } else {\r
                        memcpy(filename, Cmd, len);\r
                        fnameptr += len;\r
                }\r
 \r
+               // add .eml extension\r
                sprintf(fnameptr, ".eml"); \r
        \r
                // open file\r
                f = fopen(filename, "w+");\r
-               \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
+               flags = MAGIC_INIT + MAGIC_WUPC;\r
                for (i = 0; i < 16 * 4; i++) {\r
                        if (i == 1) flags = 0;\r
-                       if (i == 16 * 4 - 1) flags = CSETBLOCK_HALT + CSETBLOCK_RESET_FIELD;\r
+                       if (i == 16 * 4 - 1) flags = MAGIC_HALT + MAGIC_OFF;\r
                \r
                        if (mfCGetBlock(i, buf, flags)) {\r
                                PrintAndLog("Cant get block: %d", i);\r
@@ -1756,15 +1951,13 @@ int CmdHF14AMfCSave(const char *Cmd) {
                                fprintf(f, "%02x", buf[j]); \r
                        fprintf(f,"\n");\r
                }\r
+               fflush(f);\r
                fclose(f);\r
-       \r
                PrintAndLog("Saved to file: %s", filename);\r
-       \r
                return 0;\r
        }\r
 }\r
 \r
-\r
 int CmdHF14AMfSniff(const char *Cmd){\r
 \r
        bool wantLogToFile = 0;\r
@@ -1776,18 +1969,19 @@ int CmdHF14AMfSniff(const char *Cmd){
        int res = 0;\r
        int len = 0;\r
        int blockLen = 0;\r
-       int num = 0;\r
        int pckNum = 0;\r
+       int num = 0;\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 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
-       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
@@ -1800,7 +1994,7 @@ int CmdHF14AMfSniff(const char *Cmd){
        }       \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
@@ -1827,32 +2021,50 @@ int CmdHF14AMfSniff(const char *Cmd){
                        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
-                       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) {\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
+                                       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
-                                       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
-                       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
-                               num = 0;\r
                                while (bufPtr - buf < blockLen) {\r
-                                       bufPtr += 6;\r
+                                       bufPtr += 6;                                            // skip (void) timing information\r
                                        len = *((uint16_t *)bufPtr);\r
-\r
                                        if(len & 0x8000) {\r
                                                isTag = true;\r
                                                len &= 0x7fff;\r
@@ -1861,12 +2073,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
                                                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
@@ -1884,108 +2094,38 @@ int CmdHF14AMfSniff(const char *Cmd){
                                                        AddLogHex(logHexFileName, isTag ? "TAG: ":"RDR: ", bufPtr, len);\r
                                                if (wantDecrypt) \r
                                                        mfTraceDecode(bufPtr, len, wantSaveToEmlFile);\r
+                                               num++;  \r
                                        }\r
                                        bufPtr += len;\r
-                                       bufPtr += ((len-1)/8+1); // ignore parity\r
-                                       num++;\r
+                                       bufPtr += ((len-1)/8+1);        // ignore parity\r
                                }\r
+                               pckNum = 0;\r
                        }\r
                } // resp not NULL\r
        } // while (true)\r
-       \r
+\r
+       free(buf);\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
+//needs nt, ar, at, Data to decrypt\r
+int CmdHf14MfDecryptBytes(const char *Cmd){\r
+       uint8_t data[50];\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
+       uint32_t nt     = param_get32ex(Cmd,0,0,16);\r
+       uint32_t ar_enc = param_get32ex(Cmd,1,0,16);\r
+       uint32_t at_enc = param_get32ex(Cmd,2,0,16);\r
 \r
+       int len = 0;\r
+       param_gethex_ex(Cmd, 3, data, &len);\r
        \r
-       //PrintAndLog("BEFOOO  1K %02X",  (atqa & 0xff0f));\r
+       len /= 2;       \r
+       int limit = sizeof(data) / 2;\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
+       if ( len >= limit )\r
+               len = limit;\r
        \r
-       return -1;\r
+       return tryDecryptWord( nt, ar_enc, at_enc, data, len);\r
 }\r
 \r
 static command_t CommandTable[] =\r
@@ -2000,6 +2140,7 @@ static command_t CommandTable[] =
   {"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
   {"sniff",            CmdHF14AMfSniff,                0, "Sniff card-reader communication"},\r
   {"sim",              CmdHF14AMf1kSim,                0, "Simulate MIFARE card"},\r
   {"eclr",             CmdHF14AMfEClear,               0, "Clear simulator memory block"},\r
@@ -2015,6 +2156,7 @@ static command_t CommandTable[] =
   {"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
@@ -2022,13 +2164,12 @@ int CmdHFMF(const char *Cmd)
 {\r
        // flush\r
        WaitForResponseTimeout(CMD_ACK,NULL,100);\r
-\r
-  CmdsParse(CommandTable, Cmd);\r
-  return 0;\r
+       CmdsParse(CommandTable, Cmd);\r
+       return 0;\r
 }\r
 \r
 int CmdHelp(const char *Cmd)\r
 {\r
-  CmdsHelp(CommandTable);\r
-  return 0;\r
+       CmdsHelp(CommandTable);\r
+       return 0;\r
 }\r
Impressum, Datenschutz