]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhficlass.c
fix hf iclass sim
[proxmark3-svn] / client / cmdhficlass.c
index d42f7eef6badf6d3d53dd21de7d81ec1f50e2e3b..ee0dd16eda99a1856978f6f0a220d99702050bc1 100644 (file)
 #include <sys/stat.h>
 #include <ctype.h>
 #include "iso14443crc.h" // Can also be used for iClass, using 0xE012 as CRC-type
 #include <sys/stat.h>
 #include <ctype.h>
 #include "iso14443crc.h" // Can also be used for iClass, using 0xE012 as CRC-type
-#include "data.h"
-#include "proxmark3.h"
+#include "comms.h"
 #include "ui.h"
 #include "cmdparser.h"
 #include "cmdhficlass.h"
 #include "common.h"
 #include "util.h"
 #include "cmdmain.h"
 #include "ui.h"
 #include "cmdparser.h"
 #include "cmdhficlass.h"
 #include "common.h"
 #include "util.h"
 #include "cmdmain.h"
-#include "polarssl/des.h"
+#include "mbedtls/des.h"
 #include "loclass/cipherutils.h"
 #include "loclass/cipher.h"
 #include "loclass/ikeys.h"
 #include "loclass/cipherutils.h"
 #include "loclass/cipher.h"
 #include "loclass/ikeys.h"
@@ -34,6 +33,7 @@
 #include "usb_cmd.h"
 #include "cmdhfmfu.h"
 #include "util_posix.h"
 #include "usb_cmd.h"
 #include "cmdhfmfu.h"
 #include "util_posix.h"
+#include "cmdhf14a.h" // DropField()
 
 static int CmdHelp(const char *Cmd);
 
 
 static int CmdHelp(const char *Cmd);
 
@@ -110,28 +110,20 @@ int CmdHFiClassSim(const char *Cmd) {
        }
        simType = param_get8ex(Cmd, 0, 0, 10);
 
        }
        simType = param_get8ex(Cmd, 0, 0, 10);
 
-       if(simType == 0)
-       {
+       if (simType == ICLASS_SIM_MODE_CSN) {
                if (param_gethex(Cmd, 1, CSN, 16)) {
                        PrintAndLog("A CSN should consist of 16 HEX symbols");
                        return usage_hf_iclass_sim();
                }
                if (param_gethex(Cmd, 1, CSN, 16)) {
                        PrintAndLog("A CSN should consist of 16 HEX symbols");
                        return usage_hf_iclass_sim();
                }
-
                PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
        }
                PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
        }
-       if(simType > 3)
-       {
-               PrintAndLog("Undefined simptype %d", simType);
-               return usage_hf_iclass_sim();
-       }
 
 
-       uint8_t numberOfCSNs=0;
-       if(simType == 2)
-       {
-               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,NUM_CSNS}};
+       uint8_t numberOfCSNs = 0;
+       if (simType == ICLASS_SIM_MODE_READER_ATTACK) {
+               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType, NUM_CSNS}};
                UsbCommand resp = {0};
 
                UsbCommand resp = {0};
 
-               uint8_t csns[8*NUM_CSNS] = {
+               uint8_t csns[8 * NUM_CSNS] = {
                        0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,
@@ -148,7 +140,7 @@ int CmdHFiClassSim(const char *Cmd) {
                        0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 
                        0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 
-               memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
+               memcpy(c.d.asBytes, csns, 8 * NUM_CSNS);
 
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
 
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
@@ -157,9 +149,9 @@ int CmdHFiClassSim(const char *Cmd) {
                }
 
                uint8_t num_mac_responses  = resp.arg[1];
                }
 
                uint8_t num_mac_responses  = resp.arg[1];
-               PrintAndLog("Mac responses: %d MACs obtained (should be %d)", num_mac_responses,NUM_CSNS);
+               PrintAndLog("Mac responses: %d MACs obtained (should be %d)", num_mac_responses, NUM_CSNS);
 
 
-               size_t datalen = NUM_CSNS*24;
+               size_t datalen = NUM_CSNS * 24;
                /*
                 * Now, time to dump to file. We'll use this format:
                 * <8-byte CSN><8-byte CC><4 byte NR><4 byte MAC>....
                /*
                 * Now, time to dump to file. We'll use this format:
                 * <8-byte CSN><8-byte CC><4 byte NR><4 byte MAC>....
@@ -167,28 +159,29 @@ int CmdHFiClassSim(const char *Cmd) {
                 * 8 * 24 bytes.
                 *
                 * The returndata from the pm3 is on the following format
                 * 8 * 24 bytes.
                 *
                 * The returndata from the pm3 is on the following format
-                * <4 byte NR><4 byte MAC>
-                * CC are all zeroes, CSN is the same as was sent in
+                * <8 byte CC><4 byte NR><4 byte MAC>
+                * CSN is the same as was sent in
                 **/
                void* dump = malloc(datalen);
                 **/
                void* dump = malloc(datalen);
-               memset(dump,0,datalen);//<-- Need zeroes for the CC-field
-               uint8_t i = 0;
-               for(i = 0 ; i < NUM_CSNS ; i++)
-               {
-                       memcpy(dump+i*24, csns+i*8,8); //CSN
-                       //8 zero bytes here...
+               for(int i = 0; i < NUM_CSNS; i++) {
+                       memcpy(dump + i*24, csns+i*8, 8); //CSN
+            //copy CC from response
+            memcpy(dump + i*24 + 8, resp.d.asBytes + i*16, 8);
                        //Then comes NR_MAC (eight bytes from the response)
                        //Then comes NR_MAC (eight bytes from the response)
-                       memcpy(dump+i*24+16,resp.d.asBytes+i*8,8);
-
+                       memcpy(dump + i*24 + 16, resp.d.asBytes + i*16 + 8, 8);
                }
                /** Now, save to dumpfile **/
                saveFile("iclass_mac_attack", "bin", dump,datalen);
                free(dump);
                }
                /** Now, save to dumpfile **/
                saveFile("iclass_mac_attack", "bin", dump,datalen);
                free(dump);
-       }else
-       {
-               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
+
+       } else if (simType == ICLASS_SIM_MODE_CSN || simType == ICLASS_SIM_MODE_CSN_DEFAULT) {
+               UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType, numberOfCSNs}};
                memcpy(c.d.asBytes, CSN, 8);
                SendCommand(&c);
                memcpy(c.d.asBytes, CSN, 8);
                SendCommand(&c);
+
+       } else {
+               PrintAndLog("Undefined simtype %d", simType);
+               return usage_hf_iclass_sim();
        }
 
        return 0;
        }
 
        return 0;
@@ -415,8 +408,8 @@ int CmdHFiClassDecrypt(const char *Cmd) {
        fseek(f, 0, SEEK_SET);
        uint8_t enc_dump[8] = {0};
        uint8_t *decrypted = malloc(fsize);
        fseek(f, 0, SEEK_SET);
        uint8_t enc_dump[8] = {0};
        uint8_t *decrypted = malloc(fsize);
-       des3_context ctx = { DES_DECRYPT ,{ 0 } };
-       des3_set2key_dec( &ctx, key);
+       mbedtls_des3_context ctx = { {0} };
+       mbedtls_des3_set2key_dec( &ctx, key);
        size_t bytes_read = fread(enc_dump, 1, 8, f);
 
        //Use the first block (CSN) for filename
        size_t bytes_read = fread(enc_dump, 1, 8, f);
 
        //Use the first block (CSN) for filename
@@ -432,7 +425,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
                {
                        memcpy(decrypted+(blocknum*8), enc_dump, 8);
                }else{
                {
                        memcpy(decrypted+(blocknum*8), enc_dump, 8);
                }else{
-                       des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
+                       mbedtls_des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
                }
                printvar("decrypted block", decrypted +(blocknum*8), 8);
                bytes_read = fread(enc_dump, 1, 8, f);
                }
                printvar("decrypted block", decrypted +(blocknum*8), 8);
                bytes_read = fread(enc_dump, 1, 8, f);
@@ -467,10 +460,10 @@ static int iClassEncryptBlkData(uint8_t *blkData) {
 
        uint8_t encryptedData[16];
        uint8_t *encrypted = encryptedData;
 
        uint8_t encryptedData[16];
        uint8_t *encrypted = encryptedData;
-       des3_context ctx = { DES_DECRYPT ,{ 0 } };
-       des3_set2key_enc( &ctx, key);
+       mbedtls_des3_context ctx = { {0} };
+       mbedtls_des3_set2key_enc( &ctx, key);
        
        
-       des3_crypt_ecb(&ctx, blkData,encrypted);
+       mbedtls_des3_crypt_ecb(&ctx, blkData,encrypted);
        //printvar("decrypted block", decrypted, 8);
        memcpy(blkData,encrypted,8);
 
        //printvar("decrypted block", decrypted, 8);
        memcpy(blkData,encrypted,8);
 
@@ -750,8 +743,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                blocksRead = (sizeof(tag_data)/8) - blockno;
        }
        // response ok - now get bigbuf content of the dump
                blocksRead = (sizeof(tag_data)/8) - blockno;
        }
        // response ok - now get bigbuf content of the dump
-       GetFromBigBuf(tag_data+(blockno*8), blocksRead*8, startindex);
-       WaitForResponse(CMD_ACK,NULL);
+       GetFromBigBuf(tag_data+(blockno*8), blocksRead*8, startindex, NULL, -1, false);
        size_t gotBytes = blocksRead*8 + blockno*8;
 
        // try AA2
        size_t gotBytes = blocksRead*8 + blockno*8;
 
        // try AA2
@@ -793,8 +785,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                                blocksRead = (sizeof(tag_data) - gotBytes)/8;
                        }
                        // get dumped data from bigbuf
                                blocksRead = (sizeof(tag_data) - gotBytes)/8;
                        }
                        // get dumped data from bigbuf
-                       GetFromBigBuf(tag_data+gotBytes, blocksRead*8, startindex);
-                       WaitForResponse(CMD_ACK,NULL);
+                       GetFromBigBuf(tag_data+gotBytes, blocksRead*8, startindex, NULL, -1, false);
 
                        gotBytes += blocksRead*8;                       
                } else { //field is still on - turn it off...
 
                        gotBytes += blocksRead*8;                       
                } else { //field is still on - turn it off...
@@ -1267,24 +1258,18 @@ int CmdHFiClass_loclass(const char *Cmd) {
                return 0;
        }
        char fileName[255] = {0};
                return 0;
        }
        char fileName[255] = {0};
-       if(opt == 'f')
-       {
-               if(param_getstr(Cmd, 1, fileName, sizeof(fileName)) > 0)
-               {
+       if(opt == 'f') {
+               if(param_getstr(Cmd, 1, fileName, sizeof(fileName)) > 0) {
                        return bruteforceFileNoKeys(fileName);
                        return bruteforceFileNoKeys(fileName);
-               }else
-               {
+               } else {
                        PrintAndLog("You must specify a filename");
                }
                        PrintAndLog("You must specify a filename");
                }
-       }
-       else if(opt == 't')
-       {
+       } else if(opt == 't') {
                int errors = testCipherUtils();
                errors += testMAC();
                errors += doKeyTests(0);
                errors += testElite();
                int errors = testCipherUtils();
                errors += testMAC();
                errors += doKeyTests(0);
                errors += testElite();
-               if(errors)
-               {
+               if(errors) {
                        prnlog("OBS! There were errors!!!");
                }
                return errors;
                        prnlog("OBS! There were errors!!!");
                }
                return errors;
Impressum, Datenschutz