buspirate config for debricking

[proxmark3-svn] / client / cmdhfmf.c

diff --git a/client/cmdhfmf.c b/client/cmdhfmf.c
index 05202ac5fb34f5a599554813056a1f2e0ab9f764..cdac64764dd33dd554c6dbd1a7c785f7038db7ef 100644 (file)
--- a/client/cmdhfmf.c
+++ b/client/cmdhfmf.c
@@ -1016,12 +1016,11 @@ int CmdHF14AMfChk(const char *Cmd)
        return 0;\r
 }\r
 \r
        return 0;\r
 }\r
 \r

-void readerAttack(nonces_t ar_resp[], bool setEmulatorMem) {\r
-       #define ATTACK_KEY_COUNT 8\r
+void readerAttack(nonces_t ar_resp[], bool setEmulatorMem, bool doStandardAttack) {\r
+       #define ATTACK_KEY_COUNT 8 // keep same as define in iso14443a.c -> Mifare1ksim()\r

        uint64_t key = 0;\r
        typedef struct {\r
                        uint64_t keyA;\r
        uint64_t key = 0;\r
        typedef struct {\r
                        uint64_t keyA;\r

-                       uint32_t security;\r

                        uint64_t keyB;\r
        } st_t;\r
        st_t sector_trailer[ATTACK_KEY_COUNT];\r
                        uint64_t keyB;\r
        } st_t;\r
        st_t sector_trailer[ATTACK_KEY_COUNT];\r


@@ -1034,9 +1033,9 @@ void readerAttack(nonces_t ar_resp[], bool setEmulatorMem) {
 \r
        for (uint8_t i = 0; i<ATTACK_KEY_COUNT; i++) {\r
                if (ar_resp[i].ar2 > 0) {\r
 \r
        for (uint8_t i = 0; i<ATTACK_KEY_COUNT; i++) {\r
                if (ar_resp[i].ar2 > 0) {\r

-                       //PrintAndLog("Trying sector %d, cuid %08x, nt %08x, ar %08x, nr %08x, ar2 %08x, nr2 %08x",ar_resp[i].sector, ar_resp[i].cuid,ar_resp[i].nonce,ar_resp[i].ar,ar_resp[i].nr,ar_resp[i].ar2,ar_resp[i].nr2);\r
-                       if (mfkey32(ar_resp[i], &key)) {\r
-                               PrintAndLog("Found Key%s for sector %02d: [%04x%08x]", (ar_resp[i].keytype) ? "B" : "A", ar_resp[i].sector, (uint32_t) (key>>32), (uint32_t) (key &0xFFFFFFFF));\r
+                       //PrintAndLog("DEBUG: Trying sector %d, cuid %08x, nt %08x, ar %08x, nr %08x, ar2 %08x, nr2 %08x",ar_resp[i].sector, ar_resp[i].cuid,ar_resp[i].nonce,ar_resp[i].ar,ar_resp[i].nr,ar_resp[i].ar2,ar_resp[i].nr2);\r
+                       if (doStandardAttack && mfkey32(ar_resp[i], &key)) {\r
+                               PrintAndLog("  Found Key%s for sector %02d: [%04x%08x]", (ar_resp[i].keytype) ? "B" : "A", ar_resp[i].sector, (uint32_t) (key>>32), (uint32_t) (key &0xFFFFFFFF));\r

 \r
                                for (uint8_t ii = 0; ii<ATTACK_KEY_COUNT; ii++) {\r
                                        if (key_cnt[ii]==0 || stSector[ii]==ar_resp[i].sector) {\r
 \r
                                for (uint8_t ii = 0; ii<ATTACK_KEY_COUNT; ii++) {\r
                                        if (key_cnt[ii]==0 || stSector[ii]==ar_resp[i].sector) {\r


@@ -1055,6 +1054,34 @@ void readerAttack(nonces_t ar_resp[], bool setEmulatorMem) {
                                                }\r
                                        }\r
                                }\r
                                                }\r
                                        }\r
                                }\r

+                       } else if (tryMfk32_moebius(ar_resp[i+ATTACK_KEY_COUNT], &key)) {\r
+                               uint8_t sectorNum = ar_resp[i+ATTACK_KEY_COUNT].sector;\r
+                               uint8_t keyType = ar_resp[i+ATTACK_KEY_COUNT].keytype;\r
+\r
+                               PrintAndLog("M-Found Key%s for sector %02d: [%012"llx"]"\r
+                                       , keyType ? "B" : "A"\r
+                                       , sectorNum\r
+                                       , key\r
+                               );\r
+\r
+                               for (uint8_t ii = 0; ii<ATTACK_KEY_COUNT; ii++) {\r
+                                       if (key_cnt[ii]==0 || stSector[ii]==sectorNum) {\r
+                                               if (keyType==0) {\r
+                                                       //keyA\r
+                                                       sector_trailer[ii].keyA = key;\r
+                                                       stSector[ii] = sectorNum;\r
+                                                       key_cnt[ii]++;\r
+                                                       break;\r
+                                               } else {\r
+                                                       //keyB\r
+                                                       sector_trailer[ii].keyB = key;\r
+                                                       stSector[ii] = sectorNum;\r
+                                                       key_cnt[ii]++;\r
+                                                       break;\r
+                                               }\r
+                                       }\r
+                               }\r
+                               continue;\r

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


@@ -1062,7 +1089,6 @@ void readerAttack(nonces_t ar_resp[], bool setEmulatorMem) {
        if (setEmulatorMem) {\r
                for (uint8_t i = 0; i<ATTACK_KEY_COUNT; i++) {\r
                        if (key_cnt[i]>0) {\r
        if (setEmulatorMem) {\r
                for (uint8_t i = 0; i<ATTACK_KEY_COUNT; i++) {\r
                        if (key_cnt[i]>0) {\r

-                               //PrintAndLog   ("block %d, keyA:%04x%08x, keyb:%04x%08x",stSector[i]*4+3, (uint32_t) (sector_trailer[i].keyA>>32), (uint32_t) (sector_trailer[i].keyA &0xFFFFFFFF),(uint32_t) (sector_trailer[i].keyB>>32), (uint32_t) (sector_trailer[i].keyB &0xFFFFFFFF));\r

                                uint8_t memBlock[16];\r
                                memset(memBlock, 0x00, sizeof(memBlock));\r
                                char cmd1[36];\r
                                uint8_t memBlock[16];\r
                                memset(memBlock, 0x00, sizeof(memBlock));\r
                                char cmd1[36];\r


@@ -1081,34 +1107,40 @@ void readerAttack(nonces_t ar_resp[], bool setEmulatorMem) {
                        }\r
                }\r
        }\r
                        }\r
                }\r
        }\r

-       //moebius attack\r
+       /*\r
+       //un-comment to use as well moebius attack\r

        for (uint8_t i = ATTACK_KEY_COUNT; i<ATTACK_KEY_COUNT*2; i++) {\r
                if (ar_resp[i].ar2 > 0) {\r
                        if (tryMfk32_moebius(ar_resp[i], &key)) {\r
                                PrintAndLog("M-Found Key%s for sector %02d: [%04x%08x]", (ar_resp[i].keytype) ? "B" : "A", ar_resp[i].sector, (uint32_t) (key>>32), (uint32_t) (key &0xFFFFFFFF));\r
                        }\r
                }\r
        for (uint8_t i = ATTACK_KEY_COUNT; i<ATTACK_KEY_COUNT*2; i++) {\r
                if (ar_resp[i].ar2 > 0) {\r
                        if (tryMfk32_moebius(ar_resp[i], &key)) {\r
                                PrintAndLog("M-Found Key%s for sector %02d: [%04x%08x]", (ar_resp[i].keytype) ? "B" : "A", ar_resp[i].sector, (uint32_t) (key>>32), (uint32_t) (key &0xFFFFFFFF));\r
                        }\r
                }\r

-       }\r
+       }*/\r

 }\r
 \r
 int usage_hf14_mf1ksim(void) {\r
 }\r
 \r
 int usage_hf14_mf1ksim(void) {\r

-       PrintAndLog("Usage:  hf mf sim  [h] u <uid (8,14 hex symbols)> n <numreads> i x");\r
+       PrintAndLog("Usage:  hf mf sim h u <uid (8, 14, or 20 hex symbols)> n <numreads> i x");\r

        PrintAndLog("options:");\r
        PrintAndLog("      h    this help");\r
        PrintAndLog("options:");\r
        PrintAndLog("      h    this help");\r

-       PrintAndLog("      u    (Optional) UID 4,7 bytes. If not specified, the UID 4b from emulator memory will be used");\r
+       PrintAndLog("      u    (Optional) UID 4,7 or 10 bytes. If not specified, the UID 4B 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("      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("      e    (Optional) set keys found from 'reader attack' to emulator memory");\r
-       PrintAndLog("      f    (Optional) get UIDs to use for 'reader attack' from file 'f <filename.txt>'");\r
+       PrintAndLog("      e    (Optional) set keys found from 'reader attack' to emulator memory (implies x and i)");\r
+       PrintAndLog("      f    (Optional) get UIDs to use for 'reader attack' from file 'f <filename.txt>' (implies x and i)");\r
+       PrintAndLog("      r    (Optional) Generate random nonces instead of sequential nonces. Standard reader attack won't work with this option, only moebius attack works.");\r

        PrintAndLog("samples:");\r
        PrintAndLog("           hf mf sim u 0a0a0a0a");\r
        PrintAndLog("           hf mf sim u 11223344556677");\r
        PrintAndLog("samples:");\r
        PrintAndLog("           hf mf sim u 0a0a0a0a");\r
        PrintAndLog("           hf mf sim u 11223344556677");\r

-       PrintAndLog("           hf mf sim u 112233445566778899AA");     \r
+       PrintAndLog("           hf mf sim u 112233445566778899AA");\r
+       PrintAndLog("           hf mf sim f uids.txt");\r
+       PrintAndLog("           hf mf sim u 0a0a0a0a e");\r
+               \r

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

+       UsbCommand resp;\r

        uint8_t uid[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
        uint8_t exitAfterNReads = 0;\r
        uint8_t flags = 0;\r
        uint8_t uid[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};\r
        uint8_t exitAfterNReads = 0;\r
        uint8_t flags = 0;\r


@@ -1121,7 +1153,6 @@ int CmdHF14AMf1kSim(const char *Cmd) {
        memset(filename, 0x00, sizeof(filename));\r
        int len = 0;\r
        char buf[64];\r
        memset(filename, 0x00, sizeof(filename));\r
        int len = 0;\r
        char buf[64];\r

-       uint8_t uidBuffer[64];\r

 \r
        uint8_t cmdp = 0;\r
        bool errors = false;\r
 \r
        uint8_t cmdp = 0;\r
        bool errors = false;\r


@@ -1131,6 +1162,9 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                case 'e':\r
                case 'E':\r
                        setEmulatorMem = true;\r
                case 'e':\r
                case 'E':\r
                        setEmulatorMem = true;\r

+                       //implies x and i\r
+                       flags |= FLAG_INTERACTIVE;\r
+                       flags |= FLAG_NR_AR_ATTACK;\r

                        cmdp++;\r
                        break;\r
                case 'f':\r
                        cmdp++;\r
                        break;\r
                case 'f':\r


@@ -1141,7 +1175,10 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                                return 0;\r
                        }\r
                        attackFromFile = true;\r
                                return 0;\r
                        }\r
                        attackFromFile = true;\r

-                       cmdp+=2;\r
+                       //implies x and i\r
+                       flags |= FLAG_INTERACTIVE;\r
+                       flags |= FLAG_NR_AR_ATTACK;\r
+                       cmdp += 2;\r

                        break;\r
                case 'h':\r
                case 'H':\r
                        break;\r
                case 'h':\r
                case 'H':\r


@@ -1156,6 +1193,11 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                        exitAfterNReads = param_get8(Cmd, pnr+1);\r
                        cmdp += 2;\r
                        break;\r
                        exitAfterNReads = param_get8(Cmd, pnr+1);\r
                        cmdp += 2;\r
                        break;\r

+               case 'r':\r
+               case 'R':\r
+                       flags |= FLAG_RANDOM_NONCE;\r
+                       cmdp++;\r
+                       break;\r

                case 'u':\r
                case 'U':\r
                        param_gethex_ex(Cmd, cmdp+1, uid, &uidlen);\r
                case 'u':\r
                case 'U':\r
                        param_gethex_ex(Cmd, cmdp+1, uid, &uidlen);\r


@@ -1165,7 +1207,7 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                                case  8: flags = FLAG_4B_UID_IN_DATA; break;\r
                                default: return usage_hf14_mf1ksim();\r
                        }\r
                                case  8: flags = FLAG_4B_UID_IN_DATA; break;\r
                                default: return usage_hf14_mf1ksim();\r
                        }\r

-                       cmdp +=2;\r
+                       cmdp += 2;\r

                        break;\r
                case 'x':\r
                case 'X':\r
                        break;\r
                case 'x':\r
                case 'X':\r


@@ -1182,12 +1224,6 @@ int CmdHF14AMf1kSim(const char *Cmd) {
        //Validations\r
        if(errors) return usage_hf14_mf1ksim();\r
 \r
        //Validations\r
        if(errors) return usage_hf14_mf1ksim();\r
 \r

-       // attack from file implies nr ar attack...\r
-       if (!(flags & FLAG_NR_AR_ATTACK) && attackFromFile) flags |= FLAG_NR_AR_ATTACK;\r
-       \r
-       UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};\r
-       UsbCommand resp;\r
-\r

        //get uid from file\r
        if (attackFromFile) {\r
                int count = 0;\r
        //get uid from file\r
        if (attackFromFile) {\r
                int count = 0;\r


@@ -1197,9 +1233,10 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                        PrintAndLog("File %s not found or locked", filename);\r
                        return 1;\r
                }\r
                        PrintAndLog("File %s not found or locked", filename);\r
                        return 1;\r
                }\r

-               while(!feof(f)){\r
+               PrintAndLog("Loading file and simulating. Press keyboard to abort");\r
+               while(!feof(f) && !ukbhit()){\r

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

-                       memset(uidBuffer, 0, sizeof(uidBuffer));\r
+                       memset(uid, 0, sizeof(uid));\r

 \r
                        if (fgets(buf, sizeof(buf), f) == NULL) {                       \r
                                if (count > 0) break;\r
 \r
                        if (fgets(buf, sizeof(buf), f) == NULL) {                       \r
                                if (count > 0) break;\r


@@ -1208,47 +1245,52 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                                fclose(f);\r
                                return 2;\r
                        }\r
                                fclose(f);\r
                                return 2;\r
                        }\r

-                       \r
-                       if (strlen(buf) < uidlen) {\r
-                               if(strlen(buf) && feof(f))\r
-                                       break;\r
-                               PrintAndLog("File content error. Block data must include %d HEX symbols", uidlen);\r
-                               fclose(f);\r
-                               return 2;\r
+                       if(!strlen(buf) && feof(f)) break;\r
+\r
+                       uidlen = strlen(buf)-1;\r
+                       switch(uidlen) {\r
+                               case 20: flags |= FLAG_10B_UID_IN_DATA; break; //not complete\r
+                               case 14: flags |= FLAG_7B_UID_IN_DATA; break;\r
+                               case  8: flags |= FLAG_4B_UID_IN_DATA; break;\r
+                               default: \r
+                                       PrintAndLog("uid in file wrong length at %d (length: %d) [%s]",count, uidlen, buf);\r
+                                       fclose(f);\r
+                                       return 2;\r

                        }\r
                        }\r

-                       \r
+\r

                        for (uint8_t i = 0; i < uidlen; i += 2) {\r
                        for (uint8_t i = 0; i < uidlen; i += 2) {\r

-                               sscanf(&buf[i], "%02x", (unsigned int *)&uidBuffer[i / 2]);\r
+                               sscanf(&buf[i], "%02x", (unsigned int *)&uid[i / 2]);\r

                        }\r
                        \r
                        }\r
                        \r

-                       PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) ",\r
+                       PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) - press button to abort",\r

                                        flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):\r
                                                flags & FLAG_7B_UID_IN_DATA     ? sprint_hex(uid,7): \r
                                                        flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"\r
                                        , exitAfterNReads, flags, flags);\r
 \r
                                        flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):\r
                                                flags & FLAG_7B_UID_IN_DATA     ? sprint_hex(uid,7): \r
                                                        flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"\r
                                        , exitAfterNReads, flags, flags);\r
 \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
                        memcpy(c.d.asBytes, uid, sizeof(uid));\r
                        clearCommandBuffer();\r
                        SendCommand(&c);\r
 \r

-                       if(flags & FLAG_INTERACTIVE) {\r
-                               PrintAndLog("Press pm3-button 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
-                               //got a response\r
-                               if (flags & FLAG_NR_AR_ATTACK) {\r
-                                       nonces_t ar_resp[ATTACK_KEY_COUNT*2];\r
-                                       memcpy(ar_resp, resp.d.asBytes, sizeof(ar_resp));\r
-                                       readerAttack(ar_resp, setEmulatorMem);\r
-                               }\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
+                       //got a response\r
+                       nonces_t ar_resp[ATTACK_KEY_COUNT*2];\r
+                       memcpy(ar_resp, resp.d.asBytes, sizeof(ar_resp));\r
+                       // We can skip the standard attack if we have RANDOM_NONCE set.\r
+                       readerAttack(ar_resp, setEmulatorMem, !(flags & FLAG_RANDOM_NONCE));\r
+                       if ((bool)resp.arg[1]) {\r
+                               PrintAndLog("Device button pressed - quitting");\r
+                               fclose(f);\r
+                               return 4;\r

                        }\r
                        }\r

-\r

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

-       } else {\r
+       } else { //not from file\r

 \r
                PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) ",\r
                                flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):\r
 \r
                PrintAndLog("mf 1k sim uid: %s, numreads:%d, flags:%d (0x%02x) ",\r
                                flags & FLAG_4B_UID_IN_DATA ? sprint_hex(uid,4):\r


@@ -1256,6 +1298,7 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                                                flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"\r
                                , exitAfterNReads, flags, flags);\r
 \r
                                                flags & FLAG_10B_UID_IN_DATA ? sprint_hex(uid,10): "N/A"\r
                                , exitAfterNReads, flags, flags);\r
 \r

+               UsbCommand c = {CMD_SIMULATE_MIFARE_CARD, {flags, exitAfterNReads,0}};\r

                memcpy(c.d.asBytes, uid, sizeof(uid));\r
                clearCommandBuffer();\r
                SendCommand(&c);\r
                memcpy(c.d.asBytes, uid, sizeof(uid));\r
                clearCommandBuffer();\r
                SendCommand(&c);\r


@@ -1270,7 +1313,8 @@ int CmdHF14AMf1kSim(const char *Cmd) {
                        if (flags & FLAG_NR_AR_ATTACK) {\r
                                nonces_t ar_resp[ATTACK_KEY_COUNT*2];\r
                                memcpy(ar_resp, resp.d.asBytes, sizeof(ar_resp));\r
                        if (flags & FLAG_NR_AR_ATTACK) {\r
                                nonces_t ar_resp[ATTACK_KEY_COUNT*2];\r
                                memcpy(ar_resp, resp.d.asBytes, sizeof(ar_resp));\r

-                               readerAttack(ar_resp, setEmulatorMem);\r
+                               // We can skip the standard attack if we have RANDOM_NONCE set.\r
+                               readerAttack(ar_resp, setEmulatorMem, !(flags & FLAG_RANDOM_NONCE));\r

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