]> git.zerfleddert.de Git - proxmark3-svn/blobdiff - client/cmdhficlass.c
fixed #541
[proxmark3-svn] / client / cmdhficlass.c
index ace506984192a07adfe58af16cf387f52cb6078b..d42f7eef6badf6d3d53dd21de7d81ec1f50e2e3b 100644 (file)
@@ -14,6 +14,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/stat.h>
+#include <ctype.h>
 #include "iso14443crc.h" // Can also be used for iClass, using 0xE012 as CRC-type
 #include "data.h"
 #include "proxmark3.h"
 #include "iso14443crc.h" // Can also be used for iClass, using 0xE012 as CRC-type
 #include "data.h"
 #include "proxmark3.h"
@@ -23,7 +24,7 @@
 #include "common.h"
 #include "util.h"
 #include "cmdmain.h"
 #include "common.h"
 #include "util.h"
 #include "cmdmain.h"
-#include "loclass/des.h"
+#include "polarssl/des.h"
 #include "loclass/cipherutils.h"
 #include "loclass/cipher.h"
 #include "loclass/ikeys.h"
 #include "loclass/cipherutils.h"
 #include "loclass/cipher.h"
 #include "loclass/ikeys.h"
@@ -32,8 +33,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 "util_posix.h"
 
 static int CmdHelp(const char *Cmd);
 
 
 static int CmdHelp(const char *Cmd);
 
@@ -53,6 +53,20 @@ typedef struct iclass_block {
     uint8_t d[8];
 } iclass_block_t;
 
     uint8_t d[8];
 } iclass_block_t;
 
+int usage_hf_iclass_chk(void) {
+       PrintAndLog("Checkkeys loads a dictionary text file with 8byte hex keys to test authenticating against a iClass tag");  
+       PrintAndLog("Usage: hf iclass chk [h|e|r] <f  (*.dic)>");
+       PrintAndLog("Options:");
+       PrintAndLog("h             Show this help");
+       PrintAndLog("f <filename>  Dictionary file with default iclass keys");
+       PrintAndLog("      e             target Elite / High security key scheme");
+       PrintAndLog("      r             interpret dictionary file as raw (diversified keys)");
+       PrintAndLog("Samples:");
+       PrintAndLog("            hf iclass chk f default_iclass_keys.dic");     
+       PrintAndLog("            hf iclass chk f default_iclass_keys.dic e");   
+       return 0;
+}
+
 int xorbits_8(uint8_t val) {
        uint8_t res = val ^ (val >> 1); //1st pass
        res = res ^ (res >> 1);                 // 2nd pass
 int xorbits_8(uint8_t val) {
        uint8_t res = val ^ (val >> 1); //1st pass
        res = res ^ (res >> 1);                 // 2nd pass
@@ -182,10 +196,10 @@ int CmdHFiClassSim(const char *Cmd) {
 
 int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
        bool tagFound = false;
 
 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_CC | FLAG_ICLASS_READER_CONF | FLAG_ICLASS_READER_AA |
+                   FLAG_ICLASS_READER_ONLY_ONCE | FLAG_ICLASS_READER_ONE_TRY } };
        // loop in client not device - else on windows have a communication error
        // 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()){
                SendCommand(&c);
        UsbCommand resp;
        while(!ukbhit()){
                SendCommand(&c);
@@ -193,21 +207,34 @@ int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
                        uint8_t readStatus = resp.arg[0] & 0xff;
                        uint8_t *data = resp.d.asBytes;
 
                        uint8_t readStatus = resp.arg[0] & 0xff;
                        uint8_t *data = resp.d.asBytes;
 
-                       if (verbose)
-                               PrintAndLog("Readstatus:%02x", readStatus);
-                       if( readStatus == 0){
-                               //Aborted
+                       // no tag found or button pressed
+                       if( (readStatus == 0 && !loop) || readStatus == 0xFF) {
+                               // abort
                                if (verbose) PrintAndLog("Quitting...");
                                return 0;
                        }
                                if (verbose) PrintAndLog("Quitting...");
                                return 0;
                        }
-                       if( readStatus & FLAG_ICLASS_READER_CSN){
-                               PrintAndLog("CSN: %s",sprint_hex(data,8));
+
+                       if( readStatus & FLAG_ICLASS_READER_CSN) {
+                               PrintAndLog("   CSN: %s",sprint_hex(data,8));
                                tagFound = true;
                        }
                                tagFound = true;
                        }
-                       if( readStatus & FLAG_ICLASS_READER_CC)  PrintAndLog("CC: %s",sprint_hex(data+16,8));
-                       if( readStatus & FLAG_ICLASS_READER_CONF){
+                       if( readStatus & FLAG_ICLASS_READER_CC) { 
+                               PrintAndLog("    CC: %s",sprint_hex(data+16,8));
+                       }
+                       if( readStatus & FLAG_ICLASS_READER_CONF) {
                                printIclassDumpInfo(data);
                        }
                                printIclassDumpInfo(data);
                        }
+                       if (readStatus & FLAG_ICLASS_READER_AA) {
+                               bool legacy = true;
+                               PrintAndLog(" AppIA: %s",sprint_hex(data+8*5,8));
+                               for (int i = 0; i<8; i++) {
+                                       if (data[8*5+i] != 0xFF) {
+                                               legacy = false;
+                                       } 
+                               }
+                               PrintAndLog("      : Possible iClass %s",(legacy) ? "(legacy tag)" : "(NOT legacy tag)");
+                       }
+
                        if (tagFound && !loop) return 1;
                } else {
                        if (verbose) PrintAndLog("Command execute timeout");
                        if (tagFound && !loop) return 1;
                } else {
                        if (verbose) PrintAndLog("Command execute timeout");
@@ -267,7 +294,7 @@ int CmdHFiClassELoad(const char *Cmd) {
        //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, sizeof(filename)) > 0)
        {
                f = fopen(filename, "rb");
        }else{
        {
                f = fopen(filename, "rb");
        }else{
@@ -283,8 +310,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) {
+               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);
@@ -368,10 +400,13 @@ int CmdHFiClassDecrypt(const char *Cmd) {
        //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)
-       {
+       if(opt == 'f' && param_getstr(Cmd, 1, filename, sizeof(filename)) > 0) {
                f = fopen(filename, "rb");
                f = fopen(filename, "rb");
-       }else{
+               if ( f == NULL ) {
+                       PrintAndLog("Could not find file %s", filename);
+                       return 1;
+               }
+       } else {
                return usage_hf_iclass_decrypt();
        }
 
                return usage_hf_iclass_decrypt();
        }
 
@@ -406,7 +441,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
        fclose(f);
 
        saveFile(outfilename,"bin", decrypted, blocknum*8);
        fclose(f);
 
        saveFile(outfilename,"bin", decrypted, blocknum*8);
-
+       free(decrypted);
        return 0;
 }
 
        return 0;
 }
 
@@ -500,7 +535,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 +543,11 @@ 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);
+        if (verbose) 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;
@@ -518,19 +557,19 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
        SendCommand(&d);
        if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
        {
        SendCommand(&d);
        if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
        {
-               PrintAndLog("Auth Command execute timeout");
+               if (verbose) PrintAndLog("Auth Command execute timeout");
                return false;
        }
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK) {
                return false;
        }
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK) {
-               PrintAndLog("Authentication error");
+               if (verbose) PrintAndLog("Authentication error");
                return false;
        }
        return true;
 }
 
 int usage_hf_iclass_dump(void) {
                return false;
        }
        return true;
 }
 
 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,6 +577,7 @@ 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("Samples:");
        PrintAndLog("  hf iclass dump k 001122334455667B");
        PrintAndLog("  NOTE: * = required");
   PrintAndLog("Samples:");
        PrintAndLog("  hf iclass dump k 001122334455667B");
@@ -554,6 +594,8 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        uint8_t blockno = 0;
        uint8_t numblks = 0;
        uint8_t maxBlk = 31;
        uint8_t blockno = 0;
        uint8_t numblks = 0;
        uint8_t maxBlk = 31;
+       uint8_t app_areas = 1;
+       uint8_t kb = 2;
        uint8_t KEY[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t CreditKEY[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t keyNbr = 0;
        uint8_t KEY[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t CreditKEY[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
        uint8_t keyNbr = 0;
@@ -565,6 +607,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;
 
@@ -578,12 +621,12 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                case 'c':
                case 'C':
                        have_credit_key = true;
                case 'c':
                case 'C':
                        have_credit_key = true;
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) {
                                errors = param_gethex(tempStr, 0, CreditKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) {
                                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");
@@ -602,7 +645,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                        break;
                case 'f':
                case 'F':
                        break;
                case 'f':
                case 'F':
-                       fileNameLen = param_getstr(Cmd, cmdp+1, filename); 
+                       fileNameLen = param_getstr(Cmd, cmdp+1, filename, sizeof(filename)); 
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
@@ -612,12 +655,12 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                case 'k':
                case 'K':
                        have_debit_key = true;
                case 'k':
                case 'K':
                        have_debit_key = true;
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -629,6 +672,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;
@@ -651,7 +699,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        SendCommand(&c);
        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                PrintAndLog("Command execute timeout");
        SendCommand(&c);
        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                PrintAndLog("Command execute timeout");
-               ul_switch_off_field();
+               DropField();
                return 0;
        }
        uint8_t readStatus = resp.arg[0] & 0xff;
                return 0;
        }
        uint8_t readStatus = resp.arg[0] & 0xff;
@@ -659,28 +707,23 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
 
        if(readStatus == 0){
                PrintAndLog("No tag found...");
 
        if(readStatus == 0){
                PrintAndLog("No tag found...");
-               ul_switch_off_field();
+               DropField();
                return 0;
        }
        if( readStatus & (FLAG_ICLASS_READER_CSN|FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_CC)){
                memcpy(tag_data, data, 8*3);
                blockno+=2; // 2 to force re-read of block 2 later. (seems to respond differently..)
                numblks = data[8];
                return 0;
        }
        if( readStatus & (FLAG_ICLASS_READER_CSN|FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_CC)){
                memcpy(tag_data, data, 8*3);
                blockno+=2; // 2 to force re-read of block 2 later. (seems to respond differently..)
                numblks = data[8];
-
-               if (data[13] & 0x80) {
-                       // large memory - not able to dump pages currently
-                       maxBlk = 255;
-               }       else {
-                       maxBlk = 31;
-               }
+               getMemConfig(data[13], data[12], &maxBlk, &app_areas, &kb);
+               // large memory - not able to dump pages currently
                if (numblks > maxBlk) numblks = maxBlk;
        }
                if (numblks > maxBlk) numblks = maxBlk;
        }
-       ul_switch_off_field();
+       DropField();
        // authenticate debit key and get div_key - later store in dump block 3
        // 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)){
-                       ul_switch_off_field();
+               if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, false)){
+                       DropField();
                        return 0;
                }
        }
                        return 0;
                }
        }
@@ -691,14 +734,14 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        SendCommand(&w);
        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                PrintAndLog("Command execute time-out 1");
        SendCommand(&w);
        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                PrintAndLog("Command execute time-out 1");
-               ul_switch_off_field();
+               DropField();
                return 1;
        }
        uint32_t blocksRead = resp.arg[1];
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK && !blocksRead) {
                PrintAndLog("Read Block Failed");
                return 1;
        }
        uint32_t blocksRead = resp.arg[1];
        uint8_t isOK = resp.arg[0] & 0xff;
        if (!isOK && !blocksRead) {
                PrintAndLog("Read Block Failed");
-               ul_switch_off_field();
+               DropField();
                return 0;
        }
        uint32_t startindex = resp.arg[2];
                return 0;
        }
        uint32_t startindex = resp.arg[2];
@@ -714,13 +757,13 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        // try AA2
        if (have_credit_key) {
                //turn off hf field before authenticating with different key
        // try AA2
        if (have_credit_key) {
                //turn off hf field before authenticating with different key
-               ul_switch_off_field();
+               DropField();
                memset(MAC,0,4);
                // AA2 authenticate credit key and git c_div_key - later store in dump block 4
                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)){
-                               ul_switch_off_field();
+                       if (!select_and_auth(CreditKEY, MAC, c_div_key, true, false, false, false)){
+                               DropField();
                                return 0;
                        }
                }
                                return 0;
                        }
                }
@@ -733,14 +776,14 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
                        SendCommand(&w);
                        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                                PrintAndLog("Command execute timeout 2");
                        SendCommand(&w);
                        if (!WaitForResponseTimeout(CMD_ACK, &resp, 4500)) {
                                PrintAndLog("Command execute timeout 2");
-                               ul_switch_off_field();
+                               DropField();
                                return 0;
                        }
                        uint8_t isOK = resp.arg[0] & 0xff;
                        blocksRead = resp.arg[1];
                        if (!isOK && !blocksRead) {
                                PrintAndLog("Read Block Failed 2");
                                return 0;
                        }
                        uint8_t isOK = resp.arg[0] & 0xff;
                        blocksRead = resp.arg[1];
                        if (!isOK && !blocksRead) {
                                PrintAndLog("Read Block Failed 2");
-                               ul_switch_off_field();
+                               DropField();
                                return 0;
                        }               
 
                                return 0;
                        }               
 
@@ -755,7 +798,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
 
                        gotBytes += blocksRead*8;                       
                } else { //field is still on - turn it off...
 
                        gotBytes += blocksRead*8;                       
                } else { //field is still on - turn it off...
-                       ul_switch_off_field();
+                       DropField();
                }
        }
 
                }
        }
 
@@ -763,10 +806,10 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
        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);
        // print the 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);
        // 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), gotBytes);
+       
        if (filename[0] == 0){
                snprintf(filename, FILE_PATH_SIZE,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
                    tag_data[0],tag_data[1],tag_data[2],tag_data[3],
        if (filename[0] == 0){
                snprintf(filename, FILE_PATH_SIZE,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
                    tag_data[0],tag_data[1],tag_data[2],tag_data[3],
@@ -779,10 +822,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;
@@ -815,6 +858,7 @@ int usage_hf_iclass_writeblock(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 writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B");
        PrintAndLog("  hf iclass writeblk b 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
   PrintAndLog("Samples:");
        PrintAndLog("  hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B");
        PrintAndLog("  hf iclass writeblk b 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
@@ -831,6 +875,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)
@@ -869,12 +914,12 @@ int CmdHFiClass_WriteBlock(const char *Cmd) {
                        break;
                case 'k':
                case 'K':
                        break;
                case 'k':
                case 'K':
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -886,6 +931,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;
@@ -895,13 +945,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);
-       ul_switch_off_field();
+       int ans = WriteBlock(blockno, bldata, KEY, use_credit_key, elite, rawkey, true);
+       DropField();
        return ans;
 }
 
 int usage_hf_iclass_clone(void) {
        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");
@@ -909,6 +959,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");
@@ -917,7 +968,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] = {0};
        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;
@@ -927,6 +978,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)
@@ -956,7 +1008,7 @@ int CmdHFiClassCloneTag(const char *Cmd) {
                        break;
                case 'f':
                case 'F':
                        break;
                case 'f':
                case 'F':
-                       fileNameLen = param_getstr(Cmd, cmdp+1, filename); 
+                       fileNameLen = param_getstr(Cmd, cmdp+1, filename, sizeof(filename)); 
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
@@ -965,12 +1017,12 @@ int CmdHFiClassCloneTag(const char *Cmd) {
                        break;
                case 'k':
                case 'K':
                        break;
                case 'k':
                case 'K':
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -990,6 +1042,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;
@@ -1016,6 +1073,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
@@ -1024,12 +1082,16 @@ 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);
-       fread(tag_data,sizeof(iclass_block_t),endblock - startblock + 1,f);
+       if ( fread(tag_data,sizeof(iclass_block_t),endblock - startblock + 1,f) == 0 ) {
+               PrintAndLog("File reading error.");
+               fclose(f);
+               return 2;
+       }
 
        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}};
@@ -1062,12 +1124,19 @@ int CmdHFiClassCloneTag(const char *Cmd) {
        return 1;
 }
 
        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, bool auth) {
        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))
-               return 0;
+       if (auth) {
+               if (!select_and_auth(KEY, MAC, div_key, (keyType==0x18), elite, rawkey, verbose))
+                       return 0;
+       } else {
+               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};
+               if (!select_only(CSN, CCNR, (keyType==0x18), verbose))
+                       return 0;
+       }
 
        UsbCommand resp;
        UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
 
        UsbCommand resp;
        UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
@@ -1089,12 +1158,13 @@ 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("  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("  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("Options:");
   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("  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("Samples:");
        PrintAndLog("  hf iclass readblk b 06 k 0011223344556677");
        PrintAndLog("  hf iclass readblk b 1B k 0011223344556677 c");
@@ -1110,7 +1180,9 @@ 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;
        bool errors = false;
+       bool auth = false;
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
        {
        uint8_t cmdp = 0;
        while(param_getchar(Cmd, cmdp) != 0x00)
        {
@@ -1139,12 +1211,13 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
                        break;
                case 'k':
                case 'K':
                        break;
                case 'k':
                case 'K':
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       auth = true;
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -1156,6 +1229,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;
@@ -1164,9 +1242,10 @@ int CmdHFiClass_ReadBlock(const char *Cmd) {
                if(errors) return usage_hf_iclass_readblock();
        }
 
                if(errors) return usage_hf_iclass_readblock();
        }
 
-       if (cmdp < 4) return usage_hf_iclass_readblock();
-
-       return ReadBlock(KEY, blockno, keyType, elite, true);
+       if (cmdp < 2) return usage_hf_iclass_readblock();
+       if (!auth)
+               PrintAndLog("warning: no authentication used with read, only a few specific blocks can be read accurately without authentication.");
+       return ReadBlock(KEY, blockno, keyType, elite, rawkey, true, auth);
 }
 
 int CmdHFiClass_loclass(const char *Cmd) {
 }
 
 int CmdHFiClass_loclass(const char *Cmd) {
@@ -1180,7 +1259,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>");
@@ -1190,7 +1269,7 @@ int CmdHFiClass_loclass(const char *Cmd) {
        char fileName[255] = {0};
        if(opt == 'f')
        {
        char fileName[255] = {0};
        if(opt == 'f')
        {
-               if(param_getstr(Cmd, 1, fileName) > 0)
+               if(param_getstr(Cmd, 1, fileName, sizeof(fileName)) > 0)
                {
                        return bruteforceFileNoKeys(fileName);
                }else
                {
                        return bruteforceFileNoKeys(fileName);
                }else
@@ -1215,7 +1294,6 @@ int CmdHFiClass_loclass(const char *Cmd) {
 }
 
 void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t endblock, size_t filesize) {
 }
 
 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;
@@ -1230,18 +1308,19 @@ void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t e
                startblock = 6;
        if ((endblock > maxmemcount) || (endblock == 0))
                endblock = maxmemcount;
                startblock = 6;
        if ((endblock > maxmemcount) || (endblock == 0))
                endblock = maxmemcount;
-       if (endblock > filemaxblock)
+
+       // remember endblock need to relate to zero-index arrays.
+       if (endblock > filemaxblock-1)
                endblock = filemaxblock;
                endblock = filemaxblock;
+       
        int i = startblock;
        int i = startblock;
-       int j;
-       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");
+       printf("------+--+-------------------------+\n");
+       while (i <= endblock) {
+               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() {
@@ -1255,14 +1334,14 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
        char tempnum[5];
        FILE *f;
        char filename[FILE_PATH_SIZE];
        char tempnum[5];
        FILE *f;
        char filename[FILE_PATH_SIZE];
-       if (param_getstr(Cmd, 0, filename) < 1)
+       if (param_getstr(Cmd, 0, filename, sizeof(filename)) < 1)
                return usage_hf_iclass_readtagfile();
                return usage_hf_iclass_readtagfile();
-       if (param_getstr(Cmd,1,(char *)&tempnum) < 1)
+       if (param_getstr(Cmd, 1, tempnum, sizeof(tempnum)) < 1)
                startblock = 0;
        else
                sscanf(tempnum,"%d",&startblock);
 
                startblock = 0;
        else
                sscanf(tempnum,"%d",&startblock);
 
-       if (param_getstr(Cmd,2,(char *)&tempnum) < 1)
+       if (param_getstr(Cmd,2, tempnum, sizeof(tempnum)) < 1)
                endblock = 0;
        else
                sscanf(tempnum,"%d",&endblock);
                endblock = 0;
        else
                sscanf(tempnum,"%d",&endblock);
@@ -1276,13 +1355,19 @@ 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);
        uint8_t *csn = dump;
 
        size_t bytes_read = fread(dump, 1, fsize, f);
        fclose(f);
        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]);
+       printf("------+--+-------------------------+\n");
+       printf("CSN   |00| %s|\n", sprint_hex(csn, 8) );
        //    printIclassDumpInfo(dump);
        printIclassDumpContents(dump,startblock,endblock,bytes_read);
        free(dump);
        //    printIclassDumpInfo(dump);
        printIclassDumpContents(dump,startblock,endblock,bytes_read);
        free(dump);
@@ -1303,7 +1388,7 @@ uint64_t hexarray_to_uint64(uint8_t *key) {
        for (int i = 0;i < 8;i++)
                sprintf(&temp[(i *2)],"%02X",key[i]);
        temp[16] = '\0';
        for (int i = 0;i < 8;i++)
                sprintf(&temp[(i *2)],"%02X",key[i]);
        temp[16] = '\0';
-       if (sscanf(temp,"%016"llX,&uint_key) < 1)
+       if (sscanf(temp,"%016" SCNx64,&uint_key) < 1)
                return 0;
        return uint_key;
 }
                return 0;
        return uint_key;
 }
@@ -1389,7 +1474,7 @@ int CmdHFiClassCalcNewKey(const char *Cmd) {
                        return usage_hf_iclass_calc_newkey();
                case 'e':
                case 'E':
                        return usage_hf_iclass_calc_newkey();
                case 'e':
                case 'E':
-                       dataLen = param_getstr(Cmd, cmdp, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp, tempStr, sizeof(tempStr));
                        if (dataLen==2)
                                oldElite = true;
                        elite = true;
                        if (dataLen==2)
                                oldElite = true;
                        elite = true;
@@ -1397,12 +1482,12 @@ int CmdHFiClassCalcNewKey(const char *Cmd) {
                        break;
                case 'n':
                case 'N':
                        break;
                case 'n':
                case 'N':
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, NEWKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -1416,12 +1501,12 @@ int CmdHFiClassCalcNewKey(const char *Cmd) {
                        break;
                case 'o':
                case 'O':
                        break;
                case 'o':
                case 'O':
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { 
                                errors = param_gethex(tempStr, 0, OLDKEY, dataLen);
                        } else if (dataLen == 1) {
                                keyNbr = param_get8(Cmd, cmdp+1);
                        if (dataLen == 16) { 
                                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");
@@ -1469,6 +1554,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);
@@ -1551,7 +1642,7 @@ int CmdHFiClassManageKeys(const char *Cmd) {
                        return usage_hf_iclass_managekeys();
                case 'f':
                case 'F':
                        return usage_hf_iclass_managekeys();
                case 'f':
                case 'F':
-                       fileNameLen = param_getstr(Cmd, cmdp+1, filename); 
+                       fileNameLen = param_getstr(Cmd, cmdp+1, filename, sizeof(filename)); 
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
                        if (fileNameLen < 1) {
                                PrintAndLog("No filename found after f");
                                errors = true;
@@ -1561,8 +1652,8 @@ 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) {
-                               PrintAndLog("Wrong block number");
+                       if (keyNbr >= ICLASS_KEYS_MAX) {
+                               PrintAndLog("Invalid block number");
                                errors = true;
                        }
                        cmdp += 2;
                                errors = true;
                        }
                        cmdp += 2;
@@ -1570,7 +1661,7 @@ int CmdHFiClassManageKeys(const char *Cmd) {
                case 'k':
                case 'K':
                        operation += 3; //set key 
                case 'k':
                case 'K':
                        operation += 3; //set key 
-                       dataLen = param_getstr(Cmd, cmdp+1, tempStr);
+                       dataLen = param_getstr(Cmd, cmdp+1, tempStr, sizeof(tempStr));
                        if (dataLen == 16) { //ul-c or ev1/ntag key length
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else {
                        if (dataLen == 16) { //ul-c or ev1/ntag key length
                                errors = param_gethex(tempStr, 0, KEY, dataLen);
                        } else {
@@ -1624,10 +1715,152 @@ int CmdHFiClassManageKeys(const char *Cmd) {
        return 0;
 }
 
        return 0;
 }
 
+int CmdHFiClassCheckKeys(const char *Cmd) {
+
+       uint8_t mac[4] = {0x00,0x00,0x00,0x00};
+       uint8_t key[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+       uint8_t div_key[8] = {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
+
+       // elite key,  raw key, standard key
+       bool use_elite = false;
+       bool use_raw = false;   
+       bool found_debit = false;
+       bool found_credit = false;      
+       bool errors = false;
+       uint8_t cmdp = 0x00;
+       FILE * f;
+       char filename[FILE_PATH_SIZE] = {0};
+       uint8_t fileNameLen = 0;
+       char buf[17];
+       uint8_t *keyBlock = NULL, *p;
+       int keyitems = 0, keycnt = 0;
+
+       while (param_getchar(Cmd, cmdp) != 0x00 && !errors) {
+               switch (param_getchar(Cmd, cmdp)) {
+               case 'h':
+               case 'H':
+                       return usage_hf_iclass_chk();
+               case 'f':
+               case 'F':
+                       fileNameLen = param_getstr(Cmd, cmdp+1, filename, sizeof(filename)); 
+                       if (fileNameLen < 1) {
+                               PrintAndLog("No filename found after f");
+                               errors = true;
+                       }
+                       cmdp += 2;
+                       break;
+               case 'e':
+               case 'E':
+                       use_elite = true;
+                       cmdp++;
+                       break;
+               case 'r':
+               case 'R':
+                       use_raw = true;
+                       cmdp++;
+                       break;
+               default:
+                       PrintAndLog("Unknown parameter '%c'\n", param_getchar(Cmd, cmdp));
+                       errors = true;
+                       break;
+               }
+       }
+       if (errors) return usage_hf_iclass_chk();       
+                       
+       if ( !(f = fopen( filename , "r")) ) {
+               PrintAndLog("File: %s: not found or locked.", filename);
+               return 1;
+       }
+
+       while( fgets(buf, sizeof(buf), f) ){
+               if (strlen(buf) < 16 || buf[15] == '\n')
+                       continue;
+       
+               while (fgetc(f) != '\n' && !feof(f)) ;  //goto next line
+               
+               if( buf[0]=='#' ) continue;     //The line start with # is comment, skip
+
+               if (!isxdigit(buf[0])){
+                       PrintAndLog("File content error. '%s' must include 16 HEX symbols",buf);
+                       continue;
+               }
+               
+               buf[16] = 0;
+
+               p = realloc(keyBlock, 8 * (keyitems += 64));
+               if (!p) {
+                       PrintAndLog("Cannot allocate memory for default keys");
+                       free(keyBlock);
+                       fclose(f);
+                       return 2;
+               }
+               keyBlock = p;
+
+               memset(keyBlock + 8 * keycnt, 0, 8);
+               num_to_bytes(strtoull(buf, NULL, 16), 8, keyBlock + 8 * keycnt);
+
+               //PrintAndLog("check key[%2d] %016" PRIx64, keycnt, bytes_to_num(keyBlock + 8*keycnt, 8));
+               keycnt++;
+               memset(buf, 0, sizeof(buf));
+       }
+       fclose(f);
+       PrintAndLog("Loaded %2d keys from %s", keycnt, filename);
+       
+       // time
+       uint64_t t1 = msclock();
+                               
+       for (uint32_t c = 0; c < keycnt; c += 1) {
+                       printf("."); fflush(stdout);                    
+                       if (ukbhit()) {
+                               int gc = getchar(); (void)gc;
+                               printf("\naborted via keyboard!\n");
+                               break;
+                       }
+                       
+                       memcpy(key, keyBlock + 8 * c , 8); 
+
+                       // debit key. try twice
+                       for (int foo = 0; foo < 2 && !found_debit; foo++) {
+                               if (!select_and_auth(key, mac, div_key, false, use_elite, use_raw, false))
+                                       continue;
+
+                               // key found.
+                               PrintAndLog("\n--------------------------------------------------------");
+                       PrintAndLog("   Found AA1 debit key\t\t[%s]", sprint_hex(key, 8));
+                               found_debit = true;
+                       }
+                       
+                       // credit key. try twice
+                       for (int foo = 0; foo < 2 && !found_credit; foo++) {
+                               if (!select_and_auth(key, mac, div_key, true, use_elite, use_raw, false))
+                                       continue;
+                               
+                               // key found
+                               PrintAndLog("\n--------------------------------------------------------");
+                               PrintAndLog("   Found AA2 credit key\t\t[%s]", sprint_hex(key, 8));
+                               found_credit = true;
+                       }
+                       
+                       // both keys found.
+                       if ( found_debit && found_credit )
+                               break;
+       }
+
+       t1 = msclock() - t1;
+
+       PrintAndLog("\nTime in iclass checkkeys: %.0f seconds\n", (float)t1/1000.0);
+       
+       DropField();
+       free(keyBlock);
+       PrintAndLog("");
+       return 0;
+}
+
 static command_t CommandTable[] = 
 {
        {"help",        CmdHelp,                        1,      "This help"},
        {"calcnewkey",  CmdHFiClassCalcNewKey,          1,      "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"},
 static command_t CommandTable[] = 
 {
        {"help",        CmdHelp,                        1,      "This help"},
        {"calcnewkey",  CmdHFiClassCalcNewKey,          1,      "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"},
+       {"chk",         CmdHFiClassCheckKeys,           0,      "            Check keys"},      
        {"clone",       CmdHFiClassCloneTag,            0,      "[options..] Authenticate and Clone from iClass bin file"},
        {"decrypt",     CmdHFiClassDecrypt,             1,      "[f <fname>] Decrypt tagdump" },
        {"dump",        CmdHFiClassReader_Dump,         0,      "[options..] Authenticate and Dump iClass tag's AA1"},
        {"clone",       CmdHFiClassCloneTag,            0,      "[options..] Authenticate and Clone from iClass bin file"},
        {"decrypt",     CmdHFiClassDecrypt,             1,      "[f <fname>] Decrypt tagdump" },
        {"dump",        CmdHFiClassReader_Dump,         0,      "[options..] Authenticate and Dump iClass tag's AA1"},
@@ -1637,7 +1870,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,      "            Look for iClass tags until a key or the pm3 button is pressed"},
        {"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"},
@@ -1648,6 +1881,7 @@ static command_t CommandTable[] =
 
 int CmdHFiClass(const char *Cmd)
 {
 
 int CmdHFiClass(const char *Cmd)
 {
+       clearCommandBuffer();   
        CmdsParse(CommandTable, Cmd);
        return 0;
 }
        CmdsParse(CommandTable, Cmd);
        return 0;
 }
Impressum, Datenschutz