]> cvs.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhficlass.c
projects / proxmark3-svn / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
syntax suger, some tabs fixed
[proxmark3-svn] / client / cmdhficlass.c
diff --git a/client/cmdhficlass.c b/client/cmdhficlass.c
index 7f0779b640a421c373b54bd39f32bcdddf799b67..ab527cc66addd8f77a7376a0b316432edcb6552b 100644 (file)
--- a/client/cmdhficlass.c
+++ b/client/cmdhficlass.c
@@ -32,8 +32,7 @@
 #include "protocols.h"
 #include "usb_cmd.h"
 #include "cmdhfmfu.h"
 #include "protocols.h"
 #include "usb_cmd.h"
 #include "cmdhfmfu.h"
-
-#define llX PRIx64
+#include "cmdhf.h"
 
 static int CmdHelp(const char *Cmd);
 
 
 static int CmdHelp(const char *Cmd);
 
@@ -62,7 +61,8 @@ int xorbits_8(uint8_t val) {
 }
 
 int CmdHFiClassList(const char *Cmd) {
 }
 
 int CmdHFiClassList(const char *Cmd) {
-       PrintAndLog("Deprecated command, use 'hf list iclass' instead");
+       //PrintAndLog("Deprecated command, use 'hf list iclass' instead");
+       CmdHFList("iclass");
        return 0;
 }
 
        return 0;
 }
 
@@ -91,9 +91,8 @@ int CmdHFiClassSim(const char *Cmd) {
        uint8_t simType = 0;
        uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
        uint8_t simType = 0;
        uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
-       if (strlen(Cmd)<1) {
-               return usage_hf_iclass_sim();
-       }
+       if (strlen(Cmd)<1) return usage_hf_iclass_sim();
+
        simType = param_get8ex(Cmd, 0, 0, 10);
 
        if(simType == 0)
        simType = param_get8ex(Cmd, 0, 0, 10);
 
        if(simType == 0)
@@ -105,6 +104,7 @@ int CmdHFiClassSim(const char *Cmd) {
 
                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);
        if(simType > 3)
        {
                PrintAndLog("Undefined simptype %d", simType);
@@ -135,7 +135,7 @@ int CmdHFiClassSim(const char *Cmd) {
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 
                memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
                        0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
 
                memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
-
+               clearCommandBuffer();
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
                        PrintAndLog("Command timed out");
                SendCommand(&c);
                if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
                        PrintAndLog("Command timed out");
@@ -159,42 +159,39 @@ int CmdHFiClassSim(const char *Cmd) {
                void* dump = malloc(datalen);
                memset(dump,0,datalen);//<-- Need zeroes for the CC-field
                uint8_t i = 0;
                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
+               for(i = 0 ; i < NUM_CSNS ; i++) {
+                       memcpy(dump+i*24, csns+i*8, 8); //CSN
                        //8 zero bytes here...
                        //Then comes NR_MAC (eight bytes from the response)
                        //8 zero bytes here...
                        //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*8, 8);
                }
                /** Now, save to dumpfile **/
                }
                /** Now, save to dumpfile **/
-               saveFile("iclass_mac_attack", "bin", dump,datalen);
+               saveFile("iclass_mac_attack", "bin", dump, datalen);
                free(dump);
                free(dump);
-       }else
-       {
+       } else {
                UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
                memcpy(c.d.asBytes, CSN, 8);
                UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
                memcpy(c.d.asBytes, CSN, 8);
+               clearCommandBuffer();
                SendCommand(&c);
        }
                SendCommand(&c);
        }
-
        return 0;
 }
 
 int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
        bool tagFound = false;
        return 0;
 }
 
 int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
        bool tagFound = false;
-       UsbCommand c = {CMD_READER_ICLASS, {FLAG_ICLASS_READER_CSN|
-                                       FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_AA}};
+       UsbCommand c = {CMD_READER_ICLASS, {FLAG_ICLASS_READER_CSN |
+                                       FLAG_ICLASS_READER_CONF | FLAG_ICLASS_READER_AA}};
        // loop in client not device - else on windows have a communication error
        c.arg[0] |= FLAG_ICLASS_READER_ONLY_ONCE | FLAG_ICLASS_READER_ONE_TRY;
        UsbCommand resp;
        while(!ukbhit()){
        // loop in client not device - else on windows have a communication error
        c.arg[0] |= FLAG_ICLASS_READER_ONLY_ONCE | FLAG_ICLASS_READER_ONE_TRY;
        UsbCommand resp;
        while(!ukbhit()){
+               clearCommandBuffer();
                SendCommand(&c);
                if (WaitForResponseTimeout(CMD_ACK,&resp, 4500)) {
                SendCommand(&c);
                if (WaitForResponseTimeout(CMD_ACK,&resp, 4500)) {
-                       uint8_t readStatus    = resp.arg[0] & 0xff;
+                       uint8_t readStatus = resp.arg[0] & 0xff;
                        uint8_t *data = resp.d.asBytes;
 
                        uint8_t *data = resp.d.asBytes;
 
-                       if (verbose)
-                       PrintAndLog("Readstatus:%02x", readStatus);
+                       if (verbose) PrintAndLog("Readstatus:%02x", readStatus);
                        if( readStatus == 0){
                                //Aborted
                                if (verbose) PrintAndLog("Quitting...");
                        if( readStatus == 0){
                                //Aborted
                                if (verbose) PrintAndLog("Quitting...");
@@ -204,10 +201,8 @@ int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
                                PrintAndLog("CSN: %s",sprint_hex(data,8));
                                tagFound = true;
                        }
                                PrintAndLog("CSN: %s",sprint_hex(data,8));
                                tagFound = true;
                        }
-                       if( readStatus & FLAG_ICLASS_READER_CC)  PrintAndLog("CC: %s",sprint_hex(data+16,8));
-                       if( readStatus & FLAG_ICLASS_READER_CONF){
-                               printIclassDumpInfo(data);
-                       }
+                       if( readStatus & FLAG_ICLASS_READER_CC)   PrintAndLog("CC: %s", sprint_hex(data+16, 8));
+                       if( readStatus & FLAG_ICLASS_READER_CONF) printIclassDumpInfo(data);                    
                        if (tagFound && !loop) return 1;
                } else {
                        if (verbose) PrintAndLog("Command execute timeout");
                        if (tagFound && !loop) return 1;
                } else {
                        if (verbose) PrintAndLog("Command execute timeout");
@@ -238,14 +233,15 @@ int CmdHFiClassReader_Replay(const char *Cmd) {
 
        UsbCommand c = {CMD_READER_ICLASS_REPLAY, {readerType}};
        memcpy(c.d.asBytes, MAC, 4);
 
        UsbCommand c = {CMD_READER_ICLASS_REPLAY, {readerType}};
        memcpy(c.d.asBytes, MAC, 4);
+       clearCommandBuffer();
        SendCommand(&c);
        SendCommand(&c);
-
        return 0;
 }
 
 int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
        UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
        memcpy(c.d.asBytes, data, blocksCount * 16);
        return 0;
 }
 
 int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
        UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
        memcpy(c.d.asBytes, data, blocksCount * 16);
+       clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
        SendCommand(&c);
        return 0;
 }
@@ -261,16 +257,14 @@ int hf_iclass_eload_usage(void) {
 int CmdHFiClassELoad(const char *Cmd) {
 
        char opt = param_getchar(Cmd, 0);
 int CmdHFiClassELoad(const char *Cmd) {
 
        char opt = param_getchar(Cmd, 0);
-       if (strlen(Cmd)<1 || opt == 'h')
-               return hf_iclass_eload_usage();
+       if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return hf_iclass_eload_usage();
 
        //File handling and reading
        FILE *f;
        char filename[FILE_PATH_SIZE];
 
        //File handling and reading
        FILE *f;
        char filename[FILE_PATH_SIZE];
-       if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0)
-       {
+       if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0) {
                f = fopen(filename, "rb");
                f = fopen(filename, "rb");
-       }else{
+       } else {
                return hf_iclass_eload_usage();
        }
 
                return hf_iclass_eload_usage();
        }
 
@@ -283,8 +277,13 @@ int CmdHFiClassELoad(const char *Cmd) {
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
-       uint8_t *dump = malloc(fsize);
+       if (fsize < 0)  {
+               prnlog("Error, when getting filesize");
+               fclose(f);
+               return 1;
+       }
 
 
+       uint8_t *dump = malloc(fsize);
 
        size_t bytes_read = fread(dump, 1, fsize, f);
        fclose(f);
 
        size_t bytes_read = fread(dump, 1, fsize, f);
        fclose(f);
@@ -292,8 +291,7 @@ int CmdHFiClassELoad(const char *Cmd) {
        printIclassDumpInfo(dump);
        //Validate
 
        printIclassDumpInfo(dump);
        //Validate
 
-       if (bytes_read < fsize)
-       {
+       if (bytes_read < fsize) {
                prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize );
                free(dump);
                return 1;
                prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize );
                free(dump);
                return 1;
@@ -306,6 +304,7 @@ int CmdHFiClassELoad(const char *Cmd) {
                uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
                UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}};
                memcpy(c.d.asBytes, dump, bytes_in_packet);
                uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
                UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}};
                memcpy(c.d.asBytes, dump, bytes_in_packet);
+               clearCommandBuffer();
                SendCommand(&c);
                bytes_remaining -= bytes_in_packet;
                bytes_sent += bytes_in_packet;
                SendCommand(&c);
                bytes_remaining -= bytes_in_packet;
                bytes_sent += bytes_in_packet;
@@ -326,13 +325,13 @@ static int readKeyfile(const char *filename, size_t len, uint8_t* buffer) {
        fseek(f, 0, SEEK_SET);
        size_t bytes_read = fread(buffer, 1, len, f);
        fclose(f);
        fseek(f, 0, SEEK_SET);
        size_t bytes_read = fread(buffer, 1, len, f);
        fclose(f);
-       if(fsize != len)
-       {
+       
+       if(fsize != len) {
                PrintAndLog("Warning, file size is %d, expected %d", fsize, len);
                return 1;
        }
                PrintAndLog("Warning, file size is %d, expected %d", fsize, len);
                return 1;
        }
-       if(bytes_read != len)
-       {
+       
+       if(bytes_read != len) {
                PrintAndLog("Warning, could only read %d bytes, expected %d" ,bytes_read, len);
                return 1;
        }
                PrintAndLog("Warning, could only read %d bytes, expected %d" ,bytes_read, len);
                return 1;
        }
@@ -355,25 +354,25 @@ int usage_hf_iclass_decrypt(void) {
 
 int CmdHFiClassDecrypt(const char *Cmd) {
        uint8_t key[16] = { 0 };
 
 int CmdHFiClassDecrypt(const char *Cmd) {
        uint8_t key[16] = { 0 };
-       if(readKeyfile("iclass_decryptionkey.bin", 16, key))
-       {
+       if(readKeyfile("iclass_decryptionkey.bin", 16, key)) {
                usage_hf_iclass_decrypt();
                return 1;
        }
        PrintAndLog("Decryption file found... ");
        char opt = param_getchar(Cmd, 0);
                usage_hf_iclass_decrypt();
                return 1;
        }
        PrintAndLog("Decryption file found... ");
        char opt = param_getchar(Cmd, 0);
-       if (strlen(Cmd)<1 || opt == 'h')
-               return usage_hf_iclass_decrypt();
+       if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return usage_hf_iclass_decrypt();
 
        //Open the tagdump-file
        FILE *f;
        char filename[FILE_PATH_SIZE];
 
        //Open the tagdump-file
        FILE *f;
        char filename[FILE_PATH_SIZE];
-       if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0)
-       {
-               f = fopen(filename, "rb");
-       }else{
+       if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0) {
+               if ( (f = fopen(filename, "rb")) == NULL) {
+                       PrintAndLog("Could not find file %s", filename);
+                       return 1;
+               }               
+       } else {
                return usage_hf_iclass_decrypt();
                return usage_hf_iclass_decrypt();
-       }
+       }       
 
        fseek(f, 0, SEEK_END);
        long fsize = ftell(f);
 
        fseek(f, 0, SEEK_END);
        long fsize = ftell(f);
@@ -393,10 +392,9 @@ int CmdHFiClassDecrypt(const char *Cmd) {
        size_t blocknum =0;
        while(bytes_read == 8)
        {
        size_t blocknum =0;
        while(bytes_read == 8)
        {
-               if(blocknum < 7)
-               {
+               if(blocknum < 7) {
                        memcpy(decrypted+(blocknum*8), enc_dump, 8);
                        memcpy(decrypted+(blocknum*8), enc_dump, 8);
-               }else{
+               } else {
                        des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
                }
                printvar("decrypted block", decrypted +(blocknum*8), 8);
                        des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
                }
                printvar("decrypted block", decrypted +(blocknum*8), 8);
@@ -404,9 +402,8 @@ int CmdHFiClassDecrypt(const char *Cmd) {
                blocknum++;
        }
        fclose(f);
                blocknum++;
        }
        fclose(f);
-
        saveFile(outfilename,"bin", decrypted, blocknum*8);
        saveFile(outfilename,"bin", decrypted, blocknum*8);
-
+       free(decrypted);
        return 0;
 }
 
        return 0;
 }
 
@@ -423,8 +420,7 @@ int usage_hf_iclass_encrypt(void) {
 
 static int iClassEncryptBlkData(uint8_t *blkData) {
        uint8_t key[16] = { 0 };
 
 static int iClassEncryptBlkData(uint8_t *blkData) {
        uint8_t key[16] = { 0 };
-       if(readKeyfile("iclass_decryptionkey.bin", 16, key))
-       {
+       if(readKeyfile("iclass_decryptionkey.bin", 16, key)) {
                usage_hf_iclass_encrypt();
                return 1;
        }
                usage_hf_iclass_encrypt();
                return 1;
        }
@@ -445,12 +441,10 @@ static int iClassEncryptBlkData(uint8_t *blkData) {
 int CmdHFiClassEncryptBlk(const char *Cmd) {
        uint8_t blkData[8] = {0};
        char opt = param_getchar(Cmd, 0);
 int CmdHFiClassEncryptBlk(const char *Cmd) {
        uint8_t blkData[8] = {0};
        char opt = param_getchar(Cmd, 0);
-       if (strlen(Cmd)<1 || opt == 'h')
-               return usage_hf_iclass_encrypt();
+       if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return usage_hf_iclass_encrypt();
 
        //get the bytes to encrypt
 
        //get the bytes to encrypt
-       if (param_gethex(Cmd, 0, blkData, 16))
-       {
+       if (param_gethex(Cmd, 0, blkData, 16)) {
                PrintAndLog("BlockData must include 16 HEX symbols");
                return 0;
        }
                PrintAndLog("BlockData must include 16 HEX symbols");
                return 0;
        }
@@ -478,8 +472,7 @@ static bool select_only(uint8_t *CSN, uint8_t *CCNR, bool use_credit_key, bool v
 
        clearCommandBuffer();
        SendCommand(&c);
 
        clearCommandBuffer();
        SendCommand(&c);
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
-       {
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
                PrintAndLog("Command execute timeout");
                return false;
        }
                PrintAndLog("Command execute timeout");
                return false;
        }
@@ -488,11 +481,14 @@ static bool select_only(uint8_t *CSN, uint8_t *CCNR, bool use_credit_key, bool v
        uint8_t *data = resp.d.asBytes;
 
        memcpy(CSN,data,8);
        uint8_t *data = resp.d.asBytes;
 
        memcpy(CSN,data,8);
-       if (CCNR!=NULL)memcpy(CCNR,data+16,8);
-       if(isOK > 0)
-       {
+       
+       if (CCNR!=NULL) 
+               memcpy(CCNR,data+16,8);
+       
+       if(isOK > 0) {
                if (verbose) PrintAndLog("CSN: %s",sprint_hex(CSN,8));
        }
                if (verbose) PrintAndLog("CSN: %s",sprint_hex(CSN,8));
        }
+       
        if(isOK <= 1){
                PrintAndLog("Failed to obtain CC! Aborting");
                return false;
        if(isOK <= 1){
                PrintAndLog("Failed to obtain CC! Aborting");
                return false;
@@ -500,7 +496,7 @@ static bool select_only(uint8_t *CSN, uint8_t *CCNR, bool use_credit_key, bool v
        return true;    
 }
 
        return true;    
 }
 
-static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool use_credit_key, bool elite, bool verbose) {
+static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool use_credit_key, bool elite, bool rawkey, bool verbose) {
        uint8_t CSN[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
        uint8_t CSN[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
@@ -508,7 +504,12 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
                return false;
 
        //get div_key
                return false;
 
        //get div_key
-       HFiClassCalcDivKey(CSN, KEY, div_key, elite);
+       if(rawkey)
+               memcpy(div_key, KEY, 8);
+       else
+               HFiClassCalcDivKey(CSN, KEY, div_key, elite);
+       
+       PrintAndLog("Authing with %s: %02x%02x%02x%02x%02x%02x%02x%02x", rawkey ? "raw key" : "diversified key", div_key[0],div_key[1],div_key[2],div_key[3],div_key[4],div_key[5],div_key[6],div_key[7]);
 
        doMAC(CCNR, div_key, MAC);
        UsbCommand resp;
 
        doMAC(CCNR, div_key, MAC);
        UsbCommand resp;
@@ -516,12 +517,11 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
        memcpy(d.d.asBytes, MAC, 4);
        clearCommandBuffer();
        SendCommand(&d);
        memcpy(d.d.asBytes, MAC, 4);
        clearCommandBuffer();
        SendCommand(&d);
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
-       {
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
                PrintAndLog("Auth Command execute timeout");
                return false;
        }
                PrintAndLog("Auth Command execute timeout");
                return false;
        }
-               uint8_t isOK    = resp.arg[0] & 0xff;
+       uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK) {
                PrintAndLog("Authentication error");
                return false;
        if (!isOK) {
                PrintAndLog("Authentication error");
                return false;
@@ -530,7 +530,7 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
 }
 
 int usage_hf_iclass_dump(void) {
 }
 
 int usage_hf_iclass_dump(void) {
-       PrintAndLog("Usage:  hf iclass dump f <fileName> k <Key> c <CreditKey> e\n");
+       PrintAndLog("Usage:  hf iclass dump f <fileName> k <Key> c <CreditKey> e|r\n");
        PrintAndLog("Options:");
        PrintAndLog("  f <filename> : specify a filename to save dump to");
        PrintAndLog("  k <Key>      : *Access Key as 16 hex symbols or 1 hex to select key from memory");
        PrintAndLog("Options:");
        PrintAndLog("  f <filename> : specify a filename to save dump to");
        PrintAndLog("  k <Key>      : *Access Key as 16 hex symbols or 1 hex to select key from memory");
@@ -538,8 +538,9 @@ int usage_hf_iclass_dump(void) {
        PrintAndLog("  e            : If 'e' is specified, the key is interpreted as the 16 byte");
        PrintAndLog("                 Custom Key (KCus), which can be obtained via reader-attack");
        PrintAndLog("                 See 'hf iclass sim 2'. This key should be on iclass-format");
        PrintAndLog("  e            : If 'e' is specified, the key is interpreted as the 16 byte");
        PrintAndLog("                 Custom Key (KCus), which can be obtained via reader-attack");
        PrintAndLog("                 See 'hf iclass sim 2'. This key should be on iclass-format");
+       PrintAndLog("  r            : If 'r' is specified, the key is interpreted as raw block 3/4");
        PrintAndLog("  NOTE: * = required");
        PrintAndLog("  NOTE: * = required");
-  PrintAndLog("Samples:");
+       PrintAndLog("Samples:");
        PrintAndLog("  hf iclass dump k 001122334455667B");
        PrintAndLog("  hf iclass dump k AAAAAAAAAAAAAAAA c 001122334455667B");
        PrintAndLog("  hf iclass dump k AAAAAAAAAAAAAAAA e");
        PrintAndLog("  hf iclass dump k 001122334455667B");
        PrintAndLog("  hf iclass dump k AAAAAAAAAAAAAAAA c 001122334455667B");
        PrintAndLog("  hf iclass dump k AAAAAAAAAAAAAAAA e");
@@ -567,6 +568,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        bool have_credit_key = false;
        bool use_credit_key = false;
        bool elite = false;
        bool have_credit_key = false;
        bool use_credit_key = false;
        bool elite = false;
+       bool rawkey = false;
        bool errors = false;
        uint8_t cmdp = 0;
 
        bool errors = false;
        uint8_t cmdp = 0;
 
@@ -585,7 +587,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, CreditKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, CreditKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(CreditKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(CreditKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -619,7 +621,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -631,6 +633,11 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                        }
                        cmdp += 2;
                        break;
                        }
                        cmdp += 2;
                        break;
+               case 'r':
+               case 'R':
+                       rawkey = true;
+                       cmdp++;
+                       break;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
@@ -657,26 +664,28 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                return 0;
        }
        uint8_t readStatus = resp.arg[0] & 0xff;
                return 0;
        }
        uint8_t readStatus = resp.arg[0] & 0xff;
-               uint8_t * data  = resp.d.asBytes;
+       uint8_t * data  = resp.d.asBytes;
 
        if(readStatus == 0){
                PrintAndLog("No tag found...");
                ul_switch_off_field();
 
        if(readStatus == 0){
                PrintAndLog("No tag found...");
                ul_switch_off_field();
-       return 0;
-}
-       if( readStatus & (FLAG_ICLASS_READER_CSN|FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_CC)){
+               return 0;
+       }
+       
+       if( readStatus & (FLAG_ICLASS_READER_CSN | FLAG_ICLASS_READER_CONF | FLAG_ICLASS_READER_CC)){
                memcpy(tag_data, data, 8*3);
                memcpy(tag_data, data, 8*3);
-               blockno+=2; // 2 to force re-read of block 2 later. (seems to respond differently..)
+               blockno += 2; // 2 to force re-read of block 2 later. (seems to respond differently..)
                numblks = data[8];
                getMemConfig(data[13], data[12], &maxBlk, &app_areas, &kb);
                // large memory - not able to dump pages currently
                if (numblks > maxBlk) numblks = maxBlk;
        }
                numblks = data[8];
                getMemConfig(data[13], data[12], &maxBlk, &app_areas, &kb);
                // large memory - not able to dump pages currently
                if (numblks > maxBlk) numblks = maxBlk;
        }
+       
        ul_switch_off_field();
        // authenticate debit key and get div_key - later store in dump block 3
        ul_switch_off_field();
        // authenticate debit key and get div_key - later store in dump block 3
-       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, false)){
+       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, false)){
                //try twice - for some reason it sometimes fails the first time...
                //try twice - for some reason it sometimes fails the first time...
-               if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, false)){
+               if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, false)){
                        ul_switch_off_field();
                        return 0;
                }
                        ul_switch_off_field();
                        return 0;
                }
@@ -714,9 +723,9 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                ul_switch_off_field();
                memset(MAC,0,4);
                // AA2 authenticate credit key and git c_div_key - later store in dump block 4
                ul_switch_off_field();
                memset(MAC,0,4);
                // AA2 authenticate credit key and git c_div_key - later store in dump block 4
-               if (!select_and_auth(CreditKEY, MAC, c_div_key, true, false, false)){
+               if (!select_and_auth(CreditKEY, MAC, c_div_key, true, false, false, false)){
                        //try twice - for some reason it sometimes fails the first time...
                        //try twice - for some reason it sometimes fails the first time...
-                       if (!select_and_auth(CreditKEY, MAC, c_div_key, true, false, false)){
+                       if (!select_and_auth(CreditKEY, MAC, c_div_key, true, false, false, false)){
                                ul_switch_off_field();
                                return 0;
                        }
                                ul_switch_off_field();
                                return 0;
                        }
@@ -759,10 +768,14 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        // add diversified keys to dump
        if (have_debit_key) memcpy(tag_data+(3*8),div_key,8);
        if (have_credit_key) memcpy(tag_data+(4*8),c_div_key,8);
        // add diversified keys to dump
        if (have_debit_key) memcpy(tag_data+(3*8),div_key,8);
        if (have_credit_key) memcpy(tag_data+(4*8),c_div_key,8);
+       
+       printf("Num of bytes:  %lu\n", gotBytes);
+       
        // print the dump
        // print the dump
-       printf("CSN   |00| %02X %02X %02X %02X %02X %02X %02X %02X |\n",tag_data[0],tag_data[1],tag_data[2]
-                 ,tag_data[3],tag_data[4],tag_data[5],tag_data[6],tag_data[7]);
-       printIclassDumpContents(tag_data, 1, (gotBytes/8)-1, gotBytes-8);
+       printf("------+--+-------------------------+\n");
+       printf("CSN   |00| %s|\n", sprint_hex(tag_data, 8));    
+       //printIclassDumpContents(tag_data, 1, (gotBytes/8)-1, gotBytes-8);
+       printIclassDumpContents(tag_data, 1, (gotBytes/8), gotBytes);
 
        if (filename[0] == 0){
                snprintf(filename, FILE_PATH_SIZE,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
 
        if (filename[0] == 0){
                snprintf(filename, FILE_PATH_SIZE,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
@@ -776,10 +789,10 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        return 1;
 }
 
        return 1;
 }
 
-static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_credit_key, bool elite, bool verbose) {
+static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_credit_key, bool elite, bool rawkey, bool verbose) {
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
-       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, verbose))
+       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, verbose))
                return 0;
 
        UsbCommand resp;
                return 0;
 
        UsbCommand resp;
@@ -791,8 +804,7 @@ static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_c
        
        clearCommandBuffer();
        SendCommand(&w);
        
        clearCommandBuffer();
        SendCommand(&w);
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
-       {
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
                PrintAndLog("Write Command execute timeout");
                return 0;
        }
                PrintAndLog("Write Command execute timeout");
                return 0;
        }
@@ -807,12 +819,13 @@ static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_c
 
 int usage_hf_iclass_writeblock(void) {
        PrintAndLog("Options:");
 
 int usage_hf_iclass_writeblock(void) {
        PrintAndLog("Options:");
-  PrintAndLog("  b <Block> : The block number as 2 hex symbols");
-  PrintAndLog("  d <data>  : Set the Data to write as 16 hex symbols");
+       PrintAndLog("  b <Block> : The block number as 2 hex symbols");
+       PrintAndLog("  d <data>  : Set the Data to write as 16 hex symbols");
        PrintAndLog("  k <Key>   : Access Key as 16 hex symbols or 1 hex to select key from memory");
        PrintAndLog("  k <Key>   : Access Key as 16 hex symbols or 1 hex to select key from memory");
-  PrintAndLog("  c         : If 'c' is specified, the key set is assumed to be the credit key\n");
-  PrintAndLog("  e         : If 'e' is specified, elite computations applied to key");
-  PrintAndLog("Samples:");
+       PrintAndLog("  c         : If 'c' is specified, the key set is assumed to be the credit key\n");
+       PrintAndLog("  e         : If 'e' is specified, elite computations applied to key");
+       PrintAndLog("  r         : If 'r' is specified, no computations applied to key");
+       PrintAndLog("Samples:");
        PrintAndLog("  hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B");
        PrintAndLog("  hf iclass writeblk b 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
        PrintAndLog("  hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA n 0");
        PrintAndLog("  hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B");
        PrintAndLog("  hf iclass writeblk b 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
        PrintAndLog("  hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA n 0");
@@ -828,6 +841,7 @@ int CmdHFiClass_WriteBlock(const char *Cmd) {
        char tempStr[50] = {0};
        bool use_credit_key = false;
        bool elite = false;
        char tempStr[50] = {0};
        bool use_credit_key = false;
        bool elite = false;
+       bool rawkey= false;
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
@@ -871,7 +885,7 @@ int CmdHFiClass_WriteBlock(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -883,6 +897,11 @@ int CmdHFiClass_WriteBlock(const char *Cmd) {
                        }
                        cmdp += 2;
                        break;
                        }
                        cmdp += 2;
                        break;
+               case 'r':
+               case 'R':
+                       rawkey = true;
+                       cmdp++;
+                       break;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
@@ -892,13 +911,13 @@ int CmdHFiClass_WriteBlock(const char *Cmd) {
        }
 
        if (cmdp < 6) return usage_hf_iclass_writeblock();
        }
 
        if (cmdp < 6) return usage_hf_iclass_writeblock();
-       int ans = WriteBlock(blockno, bldata, KEY, use_credit_key, elite, true);
+       int ans = WriteBlock(blockno, bldata, KEY, use_credit_key, elite, rawkey, true);
        ul_switch_off_field();
        return ans;
 }
 
 int usage_hf_iclass_clone(void) {
        ul_switch_off_field();
        return ans;
 }
 
 int usage_hf_iclass_clone(void) {
-       PrintAndLog("Usage:  hf iclass clone f <tagfile.bin> b <first block> l <last block> k <KEY> e c");
+       PrintAndLog("Usage:  hf iclass clone f <tagfile.bin> b <first block> l <last block> k <KEY> c e|r");
        PrintAndLog("Options:");
        PrintAndLog("  f <filename>: specify a filename to clone from");
        PrintAndLog("  b <Block>   : The first block to clone as 2 hex symbols");
        PrintAndLog("Options:");
        PrintAndLog("  f <filename>: specify a filename to clone from");
        PrintAndLog("  b <Block>   : The first block to clone as 2 hex symbols");
@@ -906,6 +925,7 @@ int usage_hf_iclass_clone(void) {
        PrintAndLog("  k <Key>     : Access Key as 16 hex symbols or 1 hex to select key from memory");
        PrintAndLog("  c           : If 'c' is specified, the key set is assumed to be the credit key\n");
        PrintAndLog("  e           : If 'e' is specified, elite computations applied to key");
        PrintAndLog("  k <Key>     : Access Key as 16 hex symbols or 1 hex to select key from memory");
        PrintAndLog("  c           : If 'c' is specified, the key set is assumed to be the credit key\n");
        PrintAndLog("  e           : If 'e' is specified, elite computations applied to key");
+       PrintAndLog("  r           : If 'r' is specified, no computations applied to key");
        PrintAndLog("Samples:");
        PrintAndLog("  hf iclass clone f iclass_tagdump-121345.bin b 06 l 1A k 1122334455667788 e");
        PrintAndLog("  hf iclass clone f iclass_tagdump-121345.bin b 05 l 19 k 0");
        PrintAndLog("Samples:");
        PrintAndLog("  hf iclass clone f iclass_tagdump-121345.bin b 06 l 1A k 1122334455667788 e");
        PrintAndLog("  hf iclass clone f iclass_tagdump-121345.bin b 05 l 19 k 0");
@@ -914,7 +934,7 @@ int usage_hf_iclass_clone(void) {
 }
 
 int CmdHFiClassCloneTag(const char *Cmd) {
 }
 
 int CmdHFiClassCloneTag(const char *Cmd) {
-       char filename[FILE_PATH_SIZE];
+       char filename[FILE_PATH_SIZE] = { 0x00 };
        char tempStr[50]={0};
        uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t keyNbr = 0;
        char tempStr[50]={0};
        uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t keyNbr = 0;
@@ -924,6 +944,7 @@ int CmdHFiClassCloneTag(const char *Cmd) {
        uint8_t dataLen = 0;
        bool use_credit_key = false;
        bool elite = false;
        uint8_t dataLen = 0;
        bool use_credit_key = false;
        bool elite = false;
+       bool rawkey = false;
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
@@ -967,7 +988,7 @@ int CmdHFiClassCloneTag(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -987,6 +1008,11 @@ int CmdHFiClassCloneTag(const char *Cmd) {
                        }
                        cmdp += 2;
                        break;
                        }
                        cmdp += 2;
                        break;
+               case 'r':
+               case 'R':
+                       rawkey = true;
+                       cmdp++;
+                       break;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
@@ -1013,6 +1039,7 @@ int CmdHFiClassCloneTag(const char *Cmd) {
 
        if (startblock<5) {
                PrintAndLog("You cannot write key blocks this way. yet... make your start block > 4");
 
        if (startblock<5) {
                PrintAndLog("You cannot write key blocks this way. yet... make your start block > 4");
+               fclose(f);      
                return 0;
        }
        // now read data from the file from block 6 --- 19
                return 0;
        }
        // now read data from the file from block 6 --- 19
@@ -1021,7 +1048,8 @@ int CmdHFiClassCloneTag(const char *Cmd) {
        // else we have to create a share memory
        int i;
        fseek(f,startblock*8,SEEK_SET);
        // else we have to create a share memory
        int i;
        fseek(f,startblock*8,SEEK_SET);
-       if ( fread(tag_data,sizeof(iclass_block_t),endblock - startblock + 1,f) == 0){
+       size_t bytes_read = fread(tag_data,sizeof(iclass_block_t),endblock - startblock + 1,f);
+       if ( bytes_read == 0){
                PrintAndLog("File reading error.");
                fclose(f);
                return 2;
                PrintAndLog("File reading error.");
                fclose(f);
                return 2;
@@ -1030,7 +1058,7 @@ int CmdHFiClassCloneTag(const char *Cmd) {
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
-       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, true))
+       if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, true))
                return 0;
 
        UsbCommand w = {CMD_ICLASS_CLONE,{startblock,endblock}};
                return 0;
 
        UsbCommand w = {CMD_ICLASS_CLONE,{startblock,endblock}};
@@ -1054,31 +1082,31 @@ int CmdHFiClassCloneTag(const char *Cmd) {
            printf(" MAC |%02x%02x%02x%02x|\n",p[8],p[9],p[10],p[11]);
        }
        UsbCommand resp;
            printf(" MAC |%02x%02x%02x%02x|\n",p[8],p[9],p[10],p[11]);
        }
        UsbCommand resp;
+       clearCommandBuffer();
        SendCommand(&w);
        SendCommand(&w);
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
-       {
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
                PrintAndLog("Command execute timeout");
                return 0;
        }
        return 1;
 }
 
                PrintAndLog("Command execute timeout");
                return 0;
        }
        return 1;
 }
 
-static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite, bool verbose) {
+static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite, bool rawkey, bool verbose) {
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
        uint8_t MAC[4]={0x00,0x00,0x00,0x00};
        uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
 
-       if (!select_and_auth(KEY, MAC, div_key, (keyType==0x18), elite, verbose))
+       if (!select_and_auth(KEY, MAC, div_key, (keyType==0x18), elite, rawkey, verbose))
                return 0;
 
        UsbCommand resp;
        UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
        clearCommandBuffer();
        SendCommand(&w);
                return 0;
 
        UsbCommand resp;
        UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
        clearCommandBuffer();
        SendCommand(&w);
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
-       {
+       if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
                PrintAndLog("Command execute timeout");
                return 0;
        }
                PrintAndLog("Command execute timeout");
                return 0;
        }
+       
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK) {
                PrintAndLog("Read Block Failed");
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK) {
                PrintAndLog("Read Block Failed");
@@ -1090,13 +1118,14 @@ static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite,
 }
 
 int usage_hf_iclass_readblock(void) {
 }
 
 int usage_hf_iclass_readblock(void) {
-       PrintAndLog("Usage:  hf iclass readblk b <Block> k <Key> c e\n");
+       PrintAndLog("Usage:  hf iclass readblk b <Block> k <Key> c e|r\n");
        PrintAndLog("Options:");
        PrintAndLog("Options:");
-  PrintAndLog("  b <Block> : The block number as 2 hex symbols");
+       PrintAndLog("  b <Block> : The block number as 2 hex symbols");
        PrintAndLog("  k <Key>   : Access Key as 16 hex symbols or 1 hex to select key from memory");
        PrintAndLog("  k <Key>   : Access Key as 16 hex symbols or 1 hex to select key from memory");
-  PrintAndLog("  c         : If 'c' is specified, the key set is assumed to be the credit key\n");
-  PrintAndLog("  e         : If 'e' is specified, elite computations applied to key");
-  PrintAndLog("Samples:");
+       PrintAndLog("  c         : If 'c' is specified, the key set is assumed to be the credit key\n");
+       PrintAndLog("  e         : If 'e' is specified, elite computations applied to key");
+       PrintAndLog("  r         : If 'r' is specified, no computations applied to key");
+       PrintAndLog("Samples:");
        PrintAndLog("  hf iclass readblk b 06 k 0011223344556677");
        PrintAndLog("  hf iclass readblk b 1B k 0011223344556677 c");
        PrintAndLog("  hf iclass readblk b 0A k 0");
        PrintAndLog("  hf iclass readblk b 06 k 0011223344556677");
        PrintAndLog("  hf iclass readblk b 1B k 0011223344556677 c");
        PrintAndLog("  hf iclass readblk b 0A k 0");
@@ -1111,6 +1140,7 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
        uint8_t dataLen = 0;
        char tempStr[50] = {0};
        bool elite = false;
        uint8_t dataLen = 0;
        char tempStr[50] = {0};
        bool elite = false;
+       bool rawkey = false;
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
        bool errors = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
@@ -1145,7 +1175,7 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(KEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -1157,6 +1187,11 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
                        }
                        cmdp += 2;
                        break;
                        }
                        cmdp += 2;
                        break;
+               case 'r':
+               case 'R':
+                       rawkey = true;
+                       cmdp++;
+                       break;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
                default:
                        PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
                        errors = true;
@@ -1167,7 +1202,7 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
 
        if (cmdp < 4) return usage_hf_iclass_readblock();
 
 
        if (cmdp < 4) return usage_hf_iclass_readblock();
 
-       return ReadBlock(KEY, blockno, keyType, elite, true);
+       return ReadBlock(KEY, blockno, keyType, elite, rawkey, true);
 }
 
 int CmdHFiClass_loclass(const char *Cmd) {
 }
 
 int CmdHFiClass_loclass(const char *Cmd) {
@@ -1181,7 +1216,7 @@ int CmdHFiClass_loclass(const char *Cmd) {
                PrintAndLog("f <filename>  Bruteforce iclass dumpfile");
                PrintAndLog("                   An iclass dumpfile is assumed to consist of an arbitrary number of");
                PrintAndLog("                   malicious CSNs, and their protocol responses");
                PrintAndLog("f <filename>  Bruteforce iclass dumpfile");
                PrintAndLog("                   An iclass dumpfile is assumed to consist of an arbitrary number of");
                PrintAndLog("                   malicious CSNs, and their protocol responses");
-               PrintAndLog("                   The the binary format of the file is expected to be as follows: ");
+               PrintAndLog("                   The binary format of the file is expected to be as follows: ");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
                PrintAndLog("                   <8 byte CSN><8 byte CC><4 byte NR><4 byte MAC>");
@@ -1189,60 +1224,57 @@ 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) > 0)
-               {
+       if(opt == 'f')  {
+               if(param_getstr(Cmd, 1, fileName) > 0) {
                        return bruteforceFileNoKeys(fileName);
                        return bruteforceFileNoKeys(fileName);
-               }else
-               {
+               } else {
                        PrintAndLog("You must specify a filename");
                        PrintAndLog("You must specify a filename");
+                       // no return?
                }
        }
                }
        }
-       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)
-               {
-                       prnlog("OBS! There were errors!!!");
-               }
+               if(errors) prnlog("OBS! There were errors!!!");
                return errors;
        }
                return errors;
        }
-
        return 0;
 }
 
 void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t endblock, size_t filesize) {
        return 0;
 }
 
 void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t endblock, size_t filesize) {
-       uint8_t blockdata[8];
        uint8_t mem_config;
        memcpy(&mem_config, iclass_dump + 13,1);
        uint8_t maxmemcount;
        uint8_t mem_config;
        memcpy(&mem_config, iclass_dump + 13,1);
        uint8_t maxmemcount;
+       
        uint8_t filemaxblock = filesize / 8;
        uint8_t filemaxblock = filesize / 8;
+
        if (mem_config & 0x80)
                maxmemcount = 255;
        else
                maxmemcount = 31;
        if (mem_config & 0x80)
                maxmemcount = 255;
        else
                maxmemcount = 31;
-       //PrintAndLog   ("endblock: %d, filesize: %d, maxmemcount: %d, filemaxblock: %d", endblock,filesize, maxmemcount, filemaxblock);
 
        if (startblock == 0)
                startblock = 6;
 
        if (startblock == 0)
                startblock = 6;
+       
        if ((endblock > maxmemcount) || (endblock == 0))
                endblock = maxmemcount;
        if ((endblock > maxmemcount) || (endblock == 0))
                endblock = maxmemcount;
-       if (endblock > filemaxblock)
-               endblock = filemaxblock;
+       
+       // remember endblock needs to relate to zero-index arrays.
+       if (endblock > filemaxblock-1)
+               endblock = filemaxblock-1;
+
+       //PrintAndLog   ("startblock: %d, endblock: %d, filesize: %d, maxmemcount: %d, filemaxblock: %d",startblock, endblock,filesize, maxmemcount, filemaxblock);
+       
        int i = startblock;
        int i = startblock;
-       int j;
+       printf("------+--+-------------------------+\n");
        while (i <= endblock){
        while (i <= endblock){
-               printf("Block |%02X| ",i);
-               memcpy(blockdata,iclass_dump + (i * 8),8);
-               for (j = 0;j < 8;j++)
-                       printf("%02X ",blockdata[j]);
-               printf("|\n");
+               uint8_t *blk = iclass_dump + (i * 8);
+               printf("Block |%02X| %s|\n", i, sprint_hex(blk, 8) );   
                i++;
        }
                i++;
        }
+       printf("------+--+-------------------------+\n");
 }
 
 int usage_hf_iclass_readtagfile() {
 }
 
 int usage_hf_iclass_readtagfile() {
@@ -1258,6 +1290,7 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
        char filename[FILE_PATH_SIZE];
        if (param_getstr(Cmd, 0, filename) < 1)
                return usage_hf_iclass_readtagfile();
        char filename[FILE_PATH_SIZE];
        if (param_getstr(Cmd, 0, filename) < 1)
                return usage_hf_iclass_readtagfile();
+       
        if (param_getstr(Cmd,1,(char *)&tempnum) < 1)
                startblock = 0;
        else
        if (param_getstr(Cmd,1,(char *)&tempnum) < 1)
                startblock = 0;
        else
@@ -1267,6 +1300,7 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
                endblock = 0;
        else
                sscanf(tempnum,"%d",&endblock);
                endblock = 0;
        else
                sscanf(tempnum,"%d",&endblock);
+       
        // file handling and reading
        f = fopen(filename,"rb");
        if(!f) {
        // file handling and reading
        f = fopen(filename,"rb");
        if(!f) {
@@ -1277,15 +1311,20 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
-       uint8_t *dump = malloc(fsize);
-
+       if ( fsize < 0 ) {
+               PrintAndLog("Error, when getting filesize");
+               fclose(f);
+               return 1;
+       }
 
 
+       uint8_t *dump = malloc(fsize);
        size_t bytes_read = fread(dump, 1, fsize, f);
        fclose(f);
        size_t bytes_read = fread(dump, 1, fsize, f);
        fclose(f);
+       
        uint8_t *csn = dump;
        uint8_t *csn = dump;
-       printf("CSN   [00] | %02X %02X %02X %02X %02X %02X %02X %02X |\n",csn[0],csn[1],csn[2],csn[3],csn[4],csn[5],csn[6],csn[7]);
-       //    printIclassDumpInfo(dump);
-       printIclassDumpContents(dump,startblock,endblock,bytes_read);
+       printf("------+--+-------------------------+\n");
+       printf("CSN   |00| %s|\n", sprint_hex(csn, 8) );
+       printIclassDumpContents(dump, startblock, endblock, bytes_read);
        free(dump);
        return 0;
 }
        free(dump);
        return 0;
 }
@@ -1343,9 +1382,9 @@ static void HFiClassCalcNewKey(uint8_t *CSN, uint8_t *OLDKEY, uint8_t *NEWKEY, u
                xor_div_key[i] = old_div_key[i] ^ new_div_key[i];
        }
        if (verbose) {
                xor_div_key[i] = old_div_key[i] ^ new_div_key[i];
        }
        if (verbose) {
-               printf("Old Div Key : %s\n",sprint_hex(old_div_key,8));
-               printf("New Div Key : %s\n",sprint_hex(new_div_key,8));
-               printf("Xor Div Key : %s\n",sprint_hex(xor_div_key,8));         
+               printf("Old div key : %s\n",sprint_hex(old_div_key,8));
+               printf("New div key : %s\n",sprint_hex(new_div_key,8));
+               printf("Xor div key : %s\n",sprint_hex(xor_div_key,8));         
        }
 }
 
        }
 }
 
@@ -1363,7 +1402,6 @@ int usage_hf_iclass_calc_newkey(void) {
        PrintAndLog(" std key to e key read csn: hf iclass calcnewkey o 1122334455667788 n 2233445566778899 e");
        PrintAndLog(" std to std read csn      : hf iclass calcnewkey o 1122334455667788 n 2233445566778899");
        PrintAndLog("NOTE: * = required\n");
        PrintAndLog(" std key to e key read csn: hf iclass calcnewkey o 1122334455667788 n 2233445566778899 e");
        PrintAndLog(" std to std read csn      : hf iclass calcnewkey o 1122334455667788 n 2233445566778899");
        PrintAndLog("NOTE: * = required\n");
-
        return 1;
 }
 
        return 1;
 }
 
@@ -1403,7 +1441,7 @@ int CmdHFiClassCalcNewKey(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, NEWKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, NEWKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(NEWKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: NewKey Nbr is invalid\n");
                                        memcpy(NEWKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: NewKey Nbr is invalid\n");
@@ -1422,7 +1460,7 @@ int CmdHFiClassCalcNewKey(const char *Cmd) {
                                errors = param_gethex(tempStr, 0, OLDKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                                errors = param_gethex(tempStr, 0, OLDKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
-                               if (keyNbr <= ICLASS_KEYS_MAX) {
+                               if (keyNbr < ICLASS_KEYS_MAX) {
                                        memcpy(OLDKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
                                        memcpy(OLDKEY, iClass_Key_Table[keyNbr], 8);
                                } else {
                                        PrintAndLog("\nERROR: Credit KeyNbr is invalid\n");
@@ -1470,6 +1508,12 @@ static int loadKeys(char *filename) {
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
        long fsize = ftell(f);
        fseek(f, 0, SEEK_SET);
 
+       if ( fsize < 0 ) {
+               PrintAndLog("Error, when getting filesize");
+               fclose(f);
+               return 1;
+       }
+
        uint8_t *dump = malloc(fsize);
 
        size_t bytes_read = fread(dump, 1, fsize, f);
        uint8_t *dump = malloc(fsize);
 
        size_t bytes_read = fread(dump, 1, fsize, f);
@@ -1480,9 +1524,9 @@ static int loadKeys(char *filename) {
                return 0;
        }
        uint8_t i = 0;
                return 0;
        }
        uint8_t i = 0;
-       for (; i < bytes_read/8; i++){
+       for (; i < bytes_read/8; i++)
                memcpy(iClass_Key_Table[i],dump+(i*8),8);
                memcpy(iClass_Key_Table[i],dump+(i*8),8);
-       }
+       
        free(dump);
        PrintAndLog("%u keys loaded", i);
        return 1;
        free(dump);
        PrintAndLog("%u keys loaded", i);
        return 1;
@@ -1507,9 +1551,8 @@ static int saveKeys(char *filename) {
 
 static int printKeys(void) {
        PrintAndLog("");
 
 static int printKeys(void) {
        PrintAndLog("");
-       for (uint8_t i = 0; i < ICLASS_KEYS_MAX; i++){
-               PrintAndLog("%u: %s",i,sprint_hex(iClass_Key_Table[i],8));
-       }
+       for (uint8_t i = 0; i < ICLASS_KEYS_MAX; i++)
+               PrintAndLog("%u: %s", i, sprint_hex(iClass_Key_Table[i],8));
        PrintAndLog("");        
        return 0;
 }
        PrintAndLog("");        
        return 0;
 }
@@ -1562,7 +1605,7 @@ int CmdHFiClassManageKeys(const char *Cmd) {
                case 'n':
                case 'N':
                        keyNbr = param_get8(Cmd, cmdp+1);
                case 'n':
                case 'N':
                        keyNbr = param_get8(Cmd, cmdp+1);
-                       if (keyNbr < 0) {
+                       if (keyNbr == 0) {
                                PrintAndLog("Wrong block number");
                                errors = true;
                        }
                                PrintAndLog("Wrong block number");
                                errors = true;
                        }
@@ -1625,9 +1668,8 @@ int CmdHFiClassManageKeys(const char *Cmd) {
        return 0;
 }
 
        return 0;
 }
 
-static command_t CommandTable[] = 
-{
-       {"help",        CmdHelp,                        1,      "This help"},
+static command_t CommandTable[] = {
+       {"help",                CmdHelp,                                                1,      "This help"},
        {"calcnewkey",  CmdHFiClassCalcNewKey,          1,      "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"},
        {"clone",       CmdHFiClassCloneTag,            0,      "[options..] Authenticate and Clone from iClass bin file"},
        {"decrypt",     CmdHFiClassDecrypt,             1,      "[f <fname>] Decrypt tagdump" },
        {"calcnewkey",  CmdHFiClassCalcNewKey,          1,      "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"},
        {"clone",       CmdHFiClassCloneTag,            0,      "[options..] Authenticate and Clone from iClass bin file"},
        {"decrypt",     CmdHFiClassDecrypt,             1,      "[f <fname>] Decrypt tagdump" },
@@ -1638,7 +1680,7 @@ static command_t CommandTable[] =
        {"loclass",     CmdHFiClass_loclass,            1,      "[options..] Use loclass to perform bruteforce of reader attack dump"},
        {"managekeys",  CmdHFiClassManageKeys,          1,      "[options..] Manage the keys to use with iClass"},
        {"readblk",     CmdHFiClass_ReadBlock,          0,      "[options..] Authenticate and Read iClass block"},
        {"loclass",     CmdHFiClass_loclass,            1,      "[options..] Use loclass to perform bruteforce of reader attack dump"},
        {"managekeys",  CmdHFiClassManageKeys,          1,      "[options..] Manage the keys to use with iClass"},
        {"readblk",     CmdHFiClass_ReadBlock,          0,      "[options..] Authenticate and Read iClass block"},
-       {"reader",CmdHFiClassReader,    0,      "Read an iClass tag"},
+       {"reader",              CmdHFiClassReader,                              0,      "Read an iClass tag"},
        {"readtagfile", CmdHFiClassReadTagFile,         1,      "[options..] Display Content from tagfile"},
        {"replay",      CmdHFiClassReader_Replay,       0,      "<mac>       Read an iClass tag via Reply Attack"},
        {"sim",         CmdHFiClassSim,                 0,      "[options..] Simulate iClass tag"},
        {"readtagfile", CmdHFiClassReadTagFile,         1,      "[options..] Display Content from tagfile"},
        {"replay",      CmdHFiClassReader_Replay,       0,      "<mac>       Read an iClass tag via Reply Attack"},
        {"sim",         CmdHFiClassSim,                 0,      "[options..] Simulate iClass tag"},
@@ -1647,14 +1689,13 @@ static command_t CommandTable[] =
        {NULL, NULL, 0, NULL}
 };
 
        {NULL, NULL, 0, NULL}
 };
 
-int CmdHFiClass(const char *Cmd)
-{
+int CmdHFiClass(const char *Cmd) {
+       clearCommandBuffer();
        CmdsParse(CommandTable, Cmd);
        return 0;
 }
 
        CmdsParse(CommandTable, Cmd);
        return 0;
 }
 
-int CmdHelp(const char *Cmd)
-{
+int CmdHelp(const char *Cmd) {
        CmdsHelp(CommandTable);
        return 0;
 }
        CmdsHelp(CommandTable);
        return 0;
 }
Proxmark3 GIT tracking
Impressum, Datenschutz