emv/sc fixes and modifications: (#780)

[proxmark3-svn] / client / cmdhfmf.c

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index eb85b8c578f0ceaa5f3ff5f7465c5287f764de4c..5bf3324a86ab72312b70f67d0658aec254cb7b7e 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -29,7 +29,7 @@
 #include "hardnested/hardnested_bf_core.h"\r
 #include "cliparser/cliparser.h"\r
 #include "cmdhf14a.h"\r
 #include "hardnested/hardnested_bf_core.h"\r
 #include "cliparser/cliparser.h"\r
 #include "cmdhf14a.h"\r

-#include <polarssl/aes.h>\r
+#include "mifare4.h"\r

 \r
 #define NESTED_SECTOR_RETRY     10                     // how often we try mfested() until we give up\r
 \r
 \r
 #define NESTED_SECTOR_RETRY     10                     // how often we try mfested() until we give up\r
 \r


@@ -141,12 +141,26 @@ int CmdHF14AMfRdBl(const char *Cmd)
                uint8_t isOK  = resp.arg[0] & 0xff;\r
                uint8_t *data = resp.d.asBytes;\r
 \r
                uint8_t isOK  = resp.arg[0] & 0xff;\r
                uint8_t *data = resp.d.asBytes;\r
 \r

-               if (isOK)\r
+               if (isOK) {\r

                        PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 16));\r
                        PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 16));\r

-               else\r
+               } else {\r

                        PrintAndLog("isOk:%02x", isOK);\r
                        PrintAndLog("isOk:%02x", isOK);\r

+                       return 1;\r
+               }\r
+\r
+               if (mfIsSectorTrailer(blockNo) && (data[6] || data[7] || data[8])) {\r
+                       PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+                       int bln = mfFirstBlockOfSector(mfSectorNum(blockNo));\r
+                       int blinc = (mfNumBlocksPerSector(mfSectorNum(blockNo)) > 4) ? 5 : 1;\r
+                       for (int i = 0; i < 4; i++) {\r
+                               PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &data[6]));\r
+                               bln += blinc;\r
+                       }\r
+                       PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&data[9], 1));\r
+               }\r

        } else {\r
                PrintAndLog("Command execute timeout");\r
        } else {\r
                PrintAndLog("Command execute timeout");\r

+               return 2;\r

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


@@ -201,6 +215,15 @@ int CmdHF14AMfRdSc(const char *Cmd)
                                PrintAndLog("data   : %s", sprint_hex(data + i * 16, 16));\r
                        }\r
                        PrintAndLog("trailer: %s", sprint_hex(data + (sectorNo<32?3:15) * 16, 16));\r
                                PrintAndLog("data   : %s", sprint_hex(data + i * 16, 16));\r
                        }\r
                        PrintAndLog("trailer: %s", sprint_hex(data + (sectorNo<32?3:15) * 16, 16));\r

+                       \r
+                       PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+                        int bln = mfFirstBlockOfSector(sectorNo);\r
+                        int blinc = (mfNumBlocksPerSector(sectorNo) > 4) ? 5 : 1;\r
+                        for (i = 0; i < 4; i++) {\r
+                                PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &(data + (sectorNo<32?3:15) * 16)[6]));\r
+                                bln += blinc;\r
+                        }\r
+                        PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&(data + (sectorNo<32?3:15) * 16)[9], 1));\r

                }\r
        } else {\r
                PrintAndLog("Command execute timeout");\r
                }\r
        } else {\r
                PrintAndLog("Command execute timeout");\r


@@ -253,8 +276,7 @@ int CmdHF14AMfDump(const char *Cmd)
 {\r
        uint8_t sectorNo, blockNo;\r
 \r
 {\r
        uint8_t sectorNo, blockNo;\r
 \r

-       uint8_t keyA[40][6];\r
-       uint8_t keyB[40][6];\r
+       uint8_t keys[2][40][6];\r

        uint8_t rights[40][4];\r
        uint8_t carddata[256][16];\r
        uint8_t numSectors = 16;\r
        uint8_t rights[40][4];\r
        uint8_t carddata[256][16];\r
        uint8_t numSectors = 16;\r


@@ -267,38 +289,39 @@ int CmdHF14AMfDump(const char *Cmd)
        char cmdp = param_getchar(Cmd, 0);\r
        numSectors = ParamCardSizeSectors(cmdp);\r
 \r
        char cmdp = param_getchar(Cmd, 0);\r
        numSectors = ParamCardSizeSectors(cmdp);\r
 \r

-       if (strlen(Cmd) > 1 || cmdp == 'h' || cmdp == 'H') {\r
-               PrintAndLog("Usage:   hf mf dump [card memory]");\r
+       if (strlen(Cmd) > 3 || cmdp == 'h' || cmdp == 'H') {\r
+               PrintAndLog("Usage:   hf mf dump [card memory] [k|m]");\r

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

+               PrintAndLog("  k: Always try using both Key A and Key B for each sector, even if access bits would prohibit it");\r
+               PrintAndLog("  m: When missing access bits or keys, replace that block with NULL");\r

                PrintAndLog("");\r
                PrintAndLog("Samples: hf mf dump");\r
                PrintAndLog("         hf mf dump 4");\r
                PrintAndLog("");\r
                PrintAndLog("Samples: hf mf dump");\r
                PrintAndLog("         hf mf dump 4");\r

+               PrintAndLog("         hf mf dump 4 m");\r

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

+       char opts = param_getchar(Cmd, 1);\r
+       bool useBothKeysAlways = false;\r
+       if (opts == 'k' || opts == 'K') useBothKeysAlways = true;\r
+       bool nullMissingKeys = false;\r
+       if (opts == 'm' || opts == 'M') nullMissingKeys = true;\r
+\r

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

-       // Read keys A from file\r
-       for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
-               size_t bytes_read = fread(keyA[sectorNo], 1, 6, fin);\r
-               if (bytes_read != 6) {\r
-                       PrintAndLog("File reading error.");\r
-                       fclose(fin);\r
-                       return 2;\r
-               }\r
-       }\r
-\r
-       // Read keys B from file\r
-       for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
-               size_t bytes_read = fread(keyB[sectorNo], 1, 6, fin);\r
-               if (bytes_read != 6) {\r
-                       PrintAndLog("File reading error.");\r
-                       fclose(fin);\r
-                       return 2;\r
-               }\r
+       // Read keys from file\r
+       for (int group=0; group<=1; group++) {\r
+               for (sectorNo=0; sectorNo<numSectors; sectorNo++) {\r
+                       size_t bytes_read = fread(keys[group][sectorNo], 1, 6, fin);\r
+                       if (bytes_read != 6) {\r
+                               PrintAndLog("File reading error.");\r
+                               fclose(fin);\r
+                               return 2;\r
+                       }\r
+               }               \r

        }\r
 \r
        fclose(fin);\r
        }\r
 \r
        fclose(fin);\r


@@ -310,7 +333,8 @@ int CmdHF14AMfDump(const char *Cmd)
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                for (tries = 0; tries < 3; tries++) {\r
                        UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 0, 0}};\r
        for (sectorNo = 0; sectorNo < numSectors; sectorNo++) {\r
                for (tries = 0; tries < 3; tries++) {\r
                        UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + NumBlocksPerSector(sectorNo) - 1, 0, 0}};\r

-                       memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+                       // At least the Access Conditions can always be read with key A.\r
+                       memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r

                        SendCommand(&c);\r
 \r
                        if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r
                        SendCommand(&c);\r
 \r
                        if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {\r


@@ -346,23 +370,41 @@ int CmdHF14AMfDump(const char *Cmd)
                        for (tries = 0; tries < 3; tries++) {\r
                                if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. At least the Access Conditions can always be read with key A.\r
                                        UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r
                        for (tries = 0; tries < 3; tries++) {\r
                                if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. At least the Access Conditions can always be read with key A.\r
                                        UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\r

-                                       memcpy(c.d.asBytes, keyA[sectorNo], 6);\r
+                                       memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r

                                        SendCommand(&c);\r
                                        received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                        SendCommand(&c);\r
                                        received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r

+                               } else if (useBothKeysAlways) {\r
+                                       // Always try both keys, even if access conditions wouldn't work.\r
+                                       for (int k=0; k<=1; k++) {\r
+                                               UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r
+                                               memcpy(c.d.asBytes, keys[k][sectorNo], 6);\r
+                                               SendCommand(&c);\r
+                                               received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
+\r
+                                               // Don't try the other one on success.\r
+                                               if (resp.arg[0] & 0xff) break;\r
+                                       }\r

                                } else {                                                                                                // data block. Check if it can be read with key A or key B\r
                                        uint8_t data_area = sectorNo<32?blockNo:blockNo/5;\r
                                        if ((rights[sectorNo][data_area] == 0x03) || (rights[sectorNo][data_area] == 0x05)) {   // only key B would work\r
                                                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r
                                } else {                                                                                                // data block. Check if it can be read with key A or key B\r
                                        uint8_t data_area = sectorNo<32?blockNo:blockNo/5;\r
                                        if ((rights[sectorNo][data_area] == 0x03) || (rights[sectorNo][data_area] == 0x05)) {   // only key B would work\r
                                                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 1, 0}};\r

-                                               memcpy(c.d.asBytes, keyB[sectorNo], 6);\r
+                                               memcpy(c.d.asBytes, keys[1][sectorNo], 6);\r

                                                SendCommand(&c);\r
                                                received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                        } else if (rights[sectorNo][data_area] == 0x07) {                                                                               // no key would work\r
                                                SendCommand(&c);\r
                                                received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                        } else if (rights[sectorNo][data_area] == 0x07) {                                                                               // no key would work\r

-                                               isOK = false;\r

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

-                                               tries = 2;\r
+                                               if (nullMissingKeys) {\r
+                                                       memset(resp.d.asBytes, 0, 16);\r
+                                                       resp.arg[0] = 1;\r
+                                                       PrintAndLog("  ... filling the block with NULL");\r
+                                                       received = true;\r
+                                               } else {\r
+                                                       isOK = false;\r
+                                                       tries = 2;\r
+                                               }\r

                                        } else {                                                                                                                                                                // key A would work\r
                                                UsbCommand c = {CMD_MIFARE_READBL, {FirstBlockOfSector(sectorNo) + blockNo, 0, 0}};\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
+                                               memcpy(c.d.asBytes, keys[0][sectorNo], 6);\r

                                                SendCommand(&c);\r
                                                received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                        }\r
                                                SendCommand(&c);\r
                                                received = WaitForResponseTimeout(CMD_ACK,&resp,1500);\r
                                        }\r


@@ -377,18 +419,8 @@ int CmdHF14AMfDump(const char *Cmd)
                                isOK  = resp.arg[0] & 0xff;\r
                                uint8_t *data  = resp.d.asBytes;\r
                                if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. Fill in the keys.\r
                                isOK  = resp.arg[0] & 0xff;\r
                                uint8_t *data  = resp.d.asBytes;\r
                                if (blockNo == NumBlocksPerSector(sectorNo) - 1) {              // sector trailer. Fill in the keys.\r

-                                       data[0]  = (keyA[sectorNo][0]);\r
-                                       data[1]  = (keyA[sectorNo][1]);\r
-                                       data[2]  = (keyA[sectorNo][2]);\r
-                                       data[3]  = (keyA[sectorNo][3]);\r
-                                       data[4]  = (keyA[sectorNo][4]);\r
-                                       data[5]  = (keyA[sectorNo][5]);\r
-                                       data[10] = (keyB[sectorNo][0]);\r
-                                       data[11] = (keyB[sectorNo][1]);\r
-                                       data[12] = (keyB[sectorNo][2]);\r
-                                       data[13] = (keyB[sectorNo][3]);\r
-                                       data[14] = (keyB[sectorNo][4]);\r
-                                       data[15] = (keyB[sectorNo][5]);\r
+                                       memcpy(data, keys[0][sectorNo], 6);\r
+                                       memcpy(data + 10, keys[1][sectorNo], 6);\r

                                }\r
                                if (isOK) {\r
                                        memcpy(carddata[FirstBlockOfSector(sectorNo) + blockNo], data, 16);\r
                                }\r
                                if (isOK) {\r
                                        memcpy(carddata[FirstBlockOfSector(sectorNo) + blockNo], data, 16);\r


@@ -534,7 +566,7 @@ int CmdHF14AMfRestore(const char *Cmd)
 //----------------------------------------------\r
 \r
 static void parseParamTDS(const char *Cmd, const uint8_t indx, bool *paramT, bool *paramD, uint8_t *timeout) {\r
 //----------------------------------------------\r
 \r
 static void parseParamTDS(const char *Cmd, const uint8_t indx, bool *paramT, bool *paramD, uint8_t *timeout) {\r

-       char ctmp3[3] = {0};\r
+       char ctmp3[4] = {0};\r

        int len = param_getlength(Cmd, indx);\r
        if (len > 0 && len < 4){\r
                param_getstr(Cmd, indx, ctmp3, sizeof(ctmp3));\r
        int len = param_getlength(Cmd, indx);\r
        if (len > 0 && len < 4){\r
                param_getstr(Cmd, indx, ctmp3, sizeof(ctmp3));\r


@@ -1018,10 +1050,10 @@ int CmdHF14AMfChk(const char *Cmd)
                PrintAndLog("Usage:  hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t|d|s|ss] [<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("Usage:  hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t|d|s|ss] [<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("s - slow execute. timeout 1ms");\r
-               PrintAndLog("ss- very slow execute. timeout 5ms");\r
+               PrintAndLog("d  - write keys to binary file\n");\r
+               PrintAndLog("t  - write keys to emulator memory");\r
+               PrintAndLog("s  - slow execute. timeout 1ms");\r
+               PrintAndLog("ss - very slow execute. timeout 5ms");\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
                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


@@ -1040,16 +1072,16 @@ int CmdHF14AMfChk(const char *Cmd)
        int     keycnt = 0;\r
        char ctmp       = 0x00;\r
        int clen = 0;\r
        int     keycnt = 0;\r
        char ctmp       = 0x00;\r
        int clen = 0;\r

-       char ctmp3[3]   = {0x00};\r

        uint8_t blockNo = 0;\r
        uint8_t SectorsCnt = 0;\r
        uint8_t keyType = 0;\r
        uint64_t key64 = 0;\r
        uint8_t blockNo = 0;\r
        uint8_t SectorsCnt = 0;\r
        uint8_t keyType = 0;\r
        uint64_t key64 = 0;\r

-       uint32_t timeout14a = 0; // timeout in us\r
+       // timeout in units. (ms * 106)/10 or us*0.0106\r
+       uint8_t btimeout14a = MF_CHKKEYS_DEFTIMEOUT; // fast by default\r

        bool param3InUse = false;\r
 \r
        bool param3InUse = false;\r
 \r

-       int transferToEml = 0;\r
-       int createDumpFile = 0;\r
+       bool transferToEml = 0;\r
+       bool createDumpFile = 0;\r

        \r
        sector_t *e_sector = NULL;\r
 \r
        \r
        sector_t *e_sector = NULL;\r
 \r


@@ -1087,33 +1119,13 @@ int CmdHF14AMfChk(const char *Cmd)
                };\r
        }\r
 \r
                };\r
        }\r
 \r

-       // transfer to emulator & create dump file\r
-       ctmp = param_getchar(Cmd, 2);\r
-       clen = param_getlength(Cmd, 2);\r
-       if (clen == 1 && (ctmp == 't' || ctmp == 'T')) transferToEml = 1;\r
-       if (clen == 1 && (ctmp == 'd' || ctmp == 'D')) createDumpFile = 1;\r
-       \r
-       param3InUse = transferToEml | createDumpFile;\r
+       parseParamTDS(Cmd, 2, &transferToEml, &createDumpFile, &btimeout14a);\r

        \r
        \r

-       timeout14a = 500; // fast by default\r
-       // double parameters - ts, ds\r
-       clen = param_getlength(Cmd, 2);\r
-       if (clen == 2 || clen == 3){\r
-               param_getstr(Cmd, 2, ctmp3, sizeof(ctmp3));\r
-               ctmp = ctmp3[1];\r
-       }\r
-       //parse\r
-       if (ctmp == 's' || ctmp == 'S') {\r
-               timeout14a = 1000; // slow\r
-               if (!param3InUse && clen == 2 && (ctmp3[1] == 's' || ctmp3[1] == 'S')) {\r
-                       timeout14a = 5000; // very slow\r
-               }\r
-               if (param3InUse && clen == 3 && (ctmp3[2] == 's' || ctmp3[2] == 'S')) {\r
-                       timeout14a = 5000; // very slow\r
-               }\r
-               param3InUse = true;\r
-       }\r
+       param3InUse = transferToEml | createDumpFile | (btimeout14a != MF_CHKKEYS_DEFTIMEOUT);\r

 \r
 \r

+       PrintAndLog("--chk keys. sectors:%2d, block no:%3d, key type:%c, eml:%c, dmp=%c checktimeout=%d us", \r
+                       SectorsCnt, blockNo, keyType?'B':'A', transferToEml?'y':'n', createDumpFile?'y':'n', ((int)btimeout14a * 10000) / 106);\r
+       \r

        for (i = param3InUse; param_getchar(Cmd, 2 + i); i++) {\r
                if (!param_gethex(Cmd, 2 + i, keyBlock + 6 * keycnt, 12)) {\r
                        if ( stKeyBlock - keycnt < 2) {\r
        for (i = param3InUse; param_getchar(Cmd, 2 + i); i++) {\r
                if (!param_gethex(Cmd, 2 + i, keyBlock + 6 * keycnt, 12)) {\r
                        if ( stKeyBlock - keycnt < 2) {\r


@@ -1210,7 +1222,7 @@ int CmdHF14AMfChk(const char *Cmd)
                for (uint32_t c = 0; c < keycnt; c += max_keys) {\r
 \r
                        uint32_t size = keycnt-c > max_keys ? max_keys : keycnt-c;\r
                for (uint32_t c = 0; c < keycnt; c += max_keys) {\r
 \r
                        uint32_t size = keycnt-c > max_keys ? max_keys : keycnt-c;\r

-                       res = mfCheckKeysSec(SectorsCnt, keyType, timeout14a * 1.06 / 100, true, size, &keyBlock[6 * c], e_sector); // timeout is (ms * 106)/10 or us*0.0106\r
+                       res = mfCheckKeysSec(SectorsCnt, keyType, btimeout14a, true, size, &keyBlock[6 * c], e_sector); // timeout is (ms * 106)/10 or us*0.0106\r

 \r
                        if (res != 1) {\r
                                if (!res) {\r
 \r
                        if (res != 1) {\r
                                if (!res) {\r


@@ -2292,6 +2304,20 @@ int CmdHF14AMfCGetBlk(const char *Cmd) {
                }\r
 \r
        PrintAndLog("block data:%s", sprint_hex(memBlock, 16));\r
                }\r
 \r
        PrintAndLog("block data:%s", sprint_hex(memBlock, 16));\r

+       \r
+       if (mfIsSectorTrailer(blockNo)) {\r
+               PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+               PrintAndLogEx(NORMAL, "Key A: %s", sprint_hex_inrow(memBlock, 6));\r
+               PrintAndLogEx(NORMAL, "Key B: %s", sprint_hex_inrow(&memBlock[10], 6));\r
+               int bln = mfFirstBlockOfSector(mfSectorNum(blockNo));\r
+               int blinc = (mfNumBlocksPerSector(mfSectorNum(blockNo)) > 4) ? 5 : 1;\r
+               for (int i = 0; i < 4; i++) {\r
+                       PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &memBlock[6]));\r
+                       bln += blinc;\r
+               }\r
+               PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&memBlock[9], 1));\r
+       }\r
+       \r

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


@@ -2342,6 +2368,19 @@ int CmdHF14AMfCGetSc(const char *Cmd) {
                }\r
 \r
                PrintAndLog("block %3d data:%s", baseblock + i, sprint_hex(memBlock, 16));\r
                }\r
 \r
                PrintAndLog("block %3d data:%s", baseblock + i, sprint_hex(memBlock, 16));\r

+               \r
+               if (mfIsSectorTrailer(baseblock + i)) {\r
+                PrintAndLogEx(NORMAL, "Trailer decoded:");\r
+                PrintAndLogEx(NORMAL, "Key A: %s", sprint_hex_inrow(memBlock, 6));\r
+                PrintAndLogEx(NORMAL, "Key B: %s", sprint_hex_inrow(&memBlock[10], 6));\r
+                int bln = baseblock;\r
+                int blinc = (mfNumBlocksPerSector(sectorNo) > 4) ? 5 : 1;\r
+                for (int i = 0; i < 4; i++) {\r
+                        PrintAndLogEx(NORMAL, "Access block %d%s: %s", bln, ((blinc > 1) && (i < 3) ? "+" : "") , mfGetAccessConditionsDesc(i, &memBlock[6]));\r
+                        bln += blinc;\r
+                }\r
+                PrintAndLogEx(NORMAL, "UserData: %s", sprint_hex_inrow(&memBlock[9], 1));\r
+        }\r

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


@@ -2637,50 +2676,12 @@ int CmdDecryptTraceCmds(const char *Cmd){
        return tryDecryptWord(param_get32ex(Cmd,0,0,16),param_get32ex(Cmd,1,0,16),param_get32ex(Cmd,2,0,16),data,len/2);\r
 }\r
 \r
        return tryDecryptWord(param_get32ex(Cmd,0,0,16),param_get32ex(Cmd,1,0,16),param_get32ex(Cmd,2,0,16),data,len/2);\r
 }\r
 \r

-int aes_encode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length){\r
-       uint8_t iiv[16] = {0};\r
-       if (iv)\r
-               memcpy(iiv, iv, 16);\r
-       \r
-       aes_context aes;\r
-       aes_init(&aes);\r
-       if (aes_setkey_enc(&aes, key, 128))\r
-               return 1;\r
-       if (aes_crypt_cbc(&aes, AES_ENCRYPT, length, iiv, input, output))\r
-               return 2;\r
-       aes_free(&aes);\r
-\r
-       return 0;\r
-}\r
-\r
-int aes_decode(uint8_t *iv, uint8_t *key, uint8_t *input, uint8_t *output, int length){\r
-       uint8_t iiv[16] = {0};\r
-       if (iv)\r
-               memcpy(iiv, iv, 16);\r
-       \r
-       aes_context aes;\r
-       aes_init(&aes);\r
-       if (aes_setkey_dec(&aes, key, 128))\r
-               return 1;\r
-       if (aes_crypt_cbc(&aes, AES_DECRYPT, length, iiv, input, output))\r
-               return 2;\r
-       aes_free(&aes);\r
-\r
-       return 0;\r
-}\r
-\r

 int CmdHF14AMfAuth4(const char *cmd) {\r
        uint8_t keyn[20] = {0};\r
        int keynlen = 0;\r
        uint8_t key[16] = {0};\r
        int keylen = 0;\r
 int CmdHF14AMfAuth4(const char *cmd) {\r
        uint8_t keyn[20] = {0};\r
        int keynlen = 0;\r
        uint8_t key[16] = {0};\r
        int keylen = 0;\r

-       uint8_t data[257] = {0};\r
-       int datalen = 0;\r
-       \r
-       uint8_t Rnd1[17] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x00};\r
-       uint8_t Rnd2[17] = {0};\r
-       \r
-       \r
+\r

        CLIParserInit("hf mf auth4", \r
                "Executes AES authentication command in ISO14443-4", \r
                "Usage:\n\thf mf auth4 4000 000102030405060708090a0b0c0d0e0f -> executes authentication\n"\r
        CLIParserInit("hf mf auth4", \r
                "Executes AES authentication command in ISO14443-4", \r
                "Usage:\n\thf mf auth4 4000 000102030405060708090a0b0c0d0e0f -> executes authentication\n"\r


@@ -2694,8 +2695,8 @@ int CmdHF14AMfAuth4(const char *cmd) {
        };\r
        CLIExecWithReturn(cmd, argtable, true);\r
        \r
        };\r
        CLIExecWithReturn(cmd, argtable, true);\r
        \r

-       CLIGetStrWithReturn(1, keyn, &keynlen);\r
-       CLIGetStrWithReturn(2, key, &keylen);\r
+       CLIGetHexWithReturn(1, keyn, &keynlen);\r
+       CLIGetHexWithReturn(2, key, &keylen);\r

        CLIParserFree();\r
        \r
        if (keynlen != 2) {\r
        CLIParserFree();\r
        \r
        if (keynlen != 2) {\r


@@ -2708,73 +2709,7 @@ int CmdHF14AMfAuth4(const char *cmd) {
                return 1;\r
        }\r
 \r
                return 1;\r
        }\r
 \r

-       uint8_t cmd1[] = {0x70, keyn[1], keyn[0], 0x00};\r
-       int res = ExchangeRAW14a(cmd1, sizeof(cmd1), true, true, data, sizeof(data), &datalen);\r
-       if (res) {\r
-               PrintAndLog("ERROR exchande raw error: %d", res);\r
-               DropField();\r
-               return 2;\r
-       }\r
-       \r
-       PrintAndLog("<phase1: %s", sprint_hex(data, datalen));\r
-               \r
-       if (datalen < 1) {\r
-               PrintAndLog("ERROR: card response length: %d", datalen);\r
-               DropField();\r
-               return 3;\r
-       }\r
-       \r
-       if (data[0] != 0x90) {\r
-               PrintAndLog("ERROR: card response error: %02x", data[2]);\r
-               DropField();\r
-               return 3;\r
-       }\r
-\r
-       if (datalen != 19) { // code 1b + 16b + crc 2b\r
-               PrintAndLog("ERROR: card response must be 19 bytes long instead of: %d", datalen);\r
-               DropField();\r
-               return 3;\r
-       }\r
-       \r
-    aes_decode(NULL, key, &data[1], Rnd2, 16);\r
-       Rnd2[16] = Rnd2[0];\r
-       PrintAndLog("Rnd2: %s", sprint_hex(Rnd2, 16));\r
-\r
-       uint8_t cmd2[33] = {0};\r
-       cmd2[0] = 0x72;\r
-\r
-       uint8_t raw[32] = {0};\r
-       memmove(raw, Rnd1, 16);\r
-       memmove(&raw[16], &Rnd2[1], 16);\r
-\r
-    aes_encode(NULL, key, raw, &cmd2[1], 32);\r
-       PrintAndLog(">phase2: %s", sprint_hex(cmd2, 33));\r
-       \r
-       res = ExchangeRAW14a(cmd2, sizeof(cmd2), false, false, data, sizeof(data), &datalen);\r
-       if (res) {\r
-               PrintAndLog("ERROR exchande raw error: %d", res);\r
-               DropField();\r
-               return 4;\r
-       }\r
-       \r
-       PrintAndLog("<phase2: %s", sprint_hex(data, datalen));\r
-\r
-    aes_decode(NULL, key, &data[1], raw, 32);\r
-       PrintAndLog("res: %s", sprint_hex(raw, 32));\r
-       \r
-       PrintAndLog("Rnd1`: %s", sprint_hex(&raw[4], 16));\r
-       if (memcmp(&raw[4], &Rnd1[1], 16)) {\r
-               PrintAndLog("\nERROR: Authentication FAILED. rnd not equal");\r
-               PrintAndLog("rnd1 reader: %s", sprint_hex(&Rnd1[1], 16));\r
-               PrintAndLog("rnd1   card: %s", sprint_hex(&raw[4], 16));\r
-               DropField();\r
-               return 5;\r
-       }\r
-\r
-       DropField();\r
-       PrintAndLog("\nAuthentication OK");\r
-       \r
-       return 0;\r
+       return MifareAuth4(NULL, keyn, key, true, false, true);\r

 }\r
 \r
 static command_t CommandTable[] =\r
 }\r
 \r
 static command_t CommandTable[] =\r