CHG: missing file extension.

[proxmark3-svn] / client / cmdhficlass.c

diff --git a/client/cmdhficlass.c b/client/cmdhficlass.c
index ec1b2c8ac697eb9cc33a6281b0e613225cb3b1d5..ab527cc66addd8f77a7376a0b316432edcb6552b 100644 (file)
--- a/client/cmdhficlass.c
+++ b/client/cmdhficlass.c
@@ -34,8 +34,6 @@
 #include "cmdhfmfu.h"
 #include "cmdhf.h"
 
 #include "cmdhfmfu.h"
 #include "cmdhf.h"
 

-#define llX PRIx64
-

 static int CmdHelp(const char *Cmd);
 
 #define ICLASS_KEYS_MAX 8
 static int CmdHelp(const char *Cmd);
 
 #define ICLASS_KEYS_MAX 8


@@ -93,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)


@@ -107,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);


@@ -137,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");


@@ -161,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...");


@@ -206,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");


@@ -240,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;
 }


@@ -263,8 +257,7 @@ 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;
 
        //File handling and reading
        FILE *f;


@@ -298,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;


@@ -312,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;


@@ -332,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;
        }


@@ -361,15 +354,13 @@ 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;
 
        //Open the tagdump-file
        FILE *f;


@@ -378,8 +369,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
                if ( (f = fopen(filename, "rb")) == NULL) {
                        PrintAndLog("Could not find file %s", filename);
                        return 1;
                if ( (f = fopen(filename, "rb")) == NULL) {
                        PrintAndLog("Could not find file %s", filename);
                        return 1;

-               }
-               
+               }               

        } else {
                return usage_hf_iclass_decrypt();
        }       
        } else {
                return usage_hf_iclass_decrypt();
        }       


@@ -402,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);


@@ -413,9 +402,7 @@ 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;
 }
        free(decrypted);
        return 0;
 }


@@ -433,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;
        }


@@ -455,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;
        }


@@ -488,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;
        }


@@ -498,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;


@@ -521,7 +507,8 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
        if(rawkey)
                memcpy(div_key, KEY, 8);
        else
        if(rawkey)
                memcpy(div_key, KEY, 8);
        else

-       HFiClassCalcDivKey(CSN, KEY, div_key, elite);
+               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);
        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);


@@ -530,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;


@@ -554,7 +540,7 @@ int usage_hf_iclass_dump(void) {
        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("                 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("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");


@@ -678,21 +664,23 @@ 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
        if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, false)){
        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, rawkey, false)){


@@ -780,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",


@@ -812,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;
        }


@@ -828,13 +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("  r         : If 'r' is specified, no 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");


@@ -1057,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;


@@ -1090,9 +1082,9 @@ 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;
        }
                PrintAndLog("Command execute timeout");
                return 0;
        }


@@ -1110,11 +1102,11 @@ static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite,
        UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
        clearCommandBuffer();
        SendCommand(&w);
        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");


@@ -1128,12 +1120,12 @@ static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite,
 int usage_hf_iclass_readblock(void) {
        PrintAndLog("Usage:  hf iclass readblk b <Block> k <Key> c e|r\n");
        PrintAndLog("Options:");
 int usage_hf_iclass_readblock(void) {
        PrintAndLog("Usage:  hf iclass readblk b <Block> k <Key> c e|r\n");
        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("  r         : If 'r' is specified, no 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");


@@ -1224,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>");


@@ -1232,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() {


@@ -1301,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


@@ -1310,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) {


@@ -1327,13 +1318,13 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
        }
 
        uint8_t *dump = malloc(fsize);
        }
 
        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;
 }


@@ -1391,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));         

        }
 }
 
        }
 }
 


@@ -1411,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;
 }
 


@@ -1534,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;


@@ -1561,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;
 }


@@ -1679,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" },


@@ -1692,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"},


@@ -1701,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;
 }