github/RRG-Proxmark3
1
0
Fork 0
mirror of https://github.com/RfidResearchGroup/proxmark3.git synced 2025-08-21 13:53:55 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

CHG: syntax suger

Browse source
This commit is contained in:
iceman1001 2016-01-19 19:31:34 +01:00
commit 67d78d0cde
1 changed files with 90 additions and 105 deletions
Download patch file Download diff file Expand all files Collapse all files

195
client/cmdhficlass.c
View file

@ -91,9 +91,8 @@ int CmdHFiClassSim(const char *Cmd) {
uint8_t simType = 0; uint8_t simType = 0;
uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0}; uint8_t CSN[8] = {0, 0, 0, 0, 0, 0, 0, 0};
if (strlen(Cmd)<1) { if (strlen(Cmd)<1) return usage_hf_iclass_sim();
return usage_hf_iclass_sim();
}
simType = param_get8ex(Cmd, 0, 0, 10); simType = param_get8ex(Cmd, 0, 0, 10);
if(simType == 0) if(simType == 0)
@ -105,6 +104,7 @@ int CmdHFiClassSim(const char *Cmd) {
PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8)); PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
} }
if(simType > 3) if(simType > 3)
{ {
PrintAndLog("Undefined simptype %d", simType); PrintAndLog("Undefined simptype %d", simType);
@ -135,7 +135,7 @@ int CmdHFiClassSim(const char *Cmd) {
0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 }; 0x00, 0x05, 0x01, 0x21, 0xF7, 0xFF, 0x12, 0xE0 };
memcpy(c.d.asBytes, csns, 8*NUM_CSNS); memcpy(c.d.asBytes, csns, 8*NUM_CSNS);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) { if (!WaitForResponseTimeout(CMD_ACK, &resp, -1)) {
PrintAndLog("Command timed out"); PrintAndLog("Command timed out");
@ -159,42 +159,39 @@ int CmdHFiClassSim(const char *Cmd) {
void* dump = malloc(datalen); void* dump = malloc(datalen);
memset(dump,0,datalen);//<-- Need zeroes for the CC-field memset(dump,0,datalen);//<-- Need zeroes for the CC-field
uint8_t i = 0; uint8_t i = 0;
for(i = 0 ; i < NUM_CSNS ; i++) for(i = 0 ; i < NUM_CSNS ; i++) {
{ memcpy(dump+i*24, csns+i*8, 8); //CSN
memcpy(dump+i*24, csns+i*8,8); //CSN
//8 zero bytes here... //8 zero bytes here...
//Then comes NR_MAC (eight bytes from the response) //Then comes NR_MAC (eight bytes from the response)
memcpy(dump+i*24+16,resp.d.asBytes+i*8,8); memcpy(dump+i*24+16, resp.d.asBytes+i*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}}; UsbCommand c = {CMD_SIMULATE_TAG_ICLASS, {simType,numberOfCSNs}};
memcpy(c.d.asBytes, CSN, 8); memcpy(c.d.asBytes, CSN, 8);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
} }
return 0; return 0;
} }
int HFiClassReader(const char *Cmd, bool loop, bool verbose) { int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
bool tagFound = false; bool tagFound = false;
UsbCommand c = {CMD_READER_ICLASS, {FLAG_ICLASS_READER_CSN| UsbCommand c = {CMD_READER_ICLASS, {FLAG_ICLASS_READER_CSN |
FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_AA}}; FLAG_ICLASS_READER_CONF | FLAG_ICLASS_READER_AA}};
// 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; c.arg[0] |= FLAG_ICLASS_READER_ONLY_ONCE | FLAG_ICLASS_READER_ONE_TRY;
UsbCommand resp; UsbCommand resp;
while(!ukbhit()){ while(!ukbhit()){
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (WaitForResponseTimeout(CMD_ACK,&resp, 4500)) { 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) if (verbose) PrintAndLog("Readstatus:%02x", readStatus);
PrintAndLog("Readstatus:%02x", readStatus);
if( readStatus == 0){ if( readStatus == 0){
//Aborted //Aborted
if (verbose) PrintAndLog("Quitting..."); if (verbose) PrintAndLog("Quitting...");
@ -204,10 +201,8 @@ int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
PrintAndLog("CSN: %s",sprint_hex(data,8)); 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_CC) PrintAndLog("CC: %s", sprint_hex(data+16, 8));
if( readStatus & FLAG_ICLASS_READER_CONF){ if( readStatus & FLAG_ICLASS_READER_CONF) printIclassDumpInfo(data);
printIclassDumpInfo(data);
}
if (tagFound && !loop) return 1; if (tagFound && !loop) return 1;
} else { } else {
if (verbose) PrintAndLog("Command execute timeout"); if (verbose) PrintAndLog("Command execute timeout");
@ -238,14 +233,15 @@ int CmdHFiClassReader_Replay(const char *Cmd) {
UsbCommand c = {CMD_READER_ICLASS_REPLAY, {readerType}}; UsbCommand c = {CMD_READER_ICLASS_REPLAY, {readerType}};
memcpy(c.d.asBytes, MAC, 4); memcpy(c.d.asBytes, MAC, 4);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) { int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}}; UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
memcpy(c.d.asBytes, data, blocksCount * 16); memcpy(c.d.asBytes, data, blocksCount * 16);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
@ -261,8 +257,7 @@ int hf_iclass_eload_usage(void) {
int CmdHFiClassELoad(const char *Cmd) { int CmdHFiClassELoad(const char *Cmd) {
char opt = param_getchar(Cmd, 0); char opt = param_getchar(Cmd, 0);
if (strlen(Cmd)<1 || opt == 'h') if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return hf_iclass_eload_usage();
return hf_iclass_eload_usage();
//File handling and reading //File handling and reading
FILE *f; FILE *f;
@ -296,8 +291,7 @@ int CmdHFiClassELoad(const char *Cmd) {
printIclassDumpInfo(dump); printIclassDumpInfo(dump);
//Validate //Validate
if (bytes_read < fsize) if (bytes_read < fsize) {
{
prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize ); prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize );
free(dump); free(dump);
return 1; return 1;
@ -310,6 +304,7 @@ int CmdHFiClassELoad(const char *Cmd) {
uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining); uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}}; UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}};
memcpy(c.d.asBytes, dump, bytes_in_packet); memcpy(c.d.asBytes, dump, bytes_in_packet);
clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
bytes_remaining -= bytes_in_packet; bytes_remaining -= bytes_in_packet;
bytes_sent += bytes_in_packet; bytes_sent += bytes_in_packet;
@ -330,13 +325,13 @@ static int readKeyfile(const char *filename, size_t len, uint8_t* buffer) {
fseek(f, 0, SEEK_SET); fseek(f, 0, SEEK_SET);
size_t bytes_read = fread(buffer, 1, len, f); size_t bytes_read = fread(buffer, 1, len, f);
fclose(f); fclose(f);
if(fsize != len)
{ if(fsize != len) {
PrintAndLog("Warning, file size is %d, expected %d", fsize, len); PrintAndLog("Warning, file size is %d, expected %d", fsize, len);
return 1; return 1;
} }
if(bytes_read != len)
{ if(bytes_read != len) {
PrintAndLog("Warning, could only read %d bytes, expected %d" ,bytes_read, len); PrintAndLog("Warning, could only read %d bytes, expected %d" ,bytes_read, len);
return 1; return 1;
} }
@ -359,15 +354,13 @@ int usage_hf_iclass_decrypt(void) {
int CmdHFiClassDecrypt(const char *Cmd) { int CmdHFiClassDecrypt(const char *Cmd) {
uint8_t key[16] = { 0 }; uint8_t key[16] = { 0 };
if(readKeyfile("iclass_decryptionkey.bin", 16, key)) if(readKeyfile("iclass_decryptionkey.bin", 16, key)) {
{
usage_hf_iclass_decrypt(); usage_hf_iclass_decrypt();
return 1; return 1;
} }
PrintAndLog("Decryption file found... "); PrintAndLog("Decryption file found... ");
char opt = param_getchar(Cmd, 0); char opt = param_getchar(Cmd, 0);
if (strlen(Cmd)<1 || opt == 'h') if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return usage_hf_iclass_decrypt();
return usage_hf_iclass_decrypt();
//Open the tagdump-file //Open the tagdump-file
FILE *f; FILE *f;
@ -376,8 +369,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
if ( (f = fopen(filename, "rb")) == NULL) { if ( (f = fopen(filename, "rb")) == NULL) {
PrintAndLog("Could not find file %s", filename); PrintAndLog("Could not find file %s", filename);
return 1; return 1;
} }
} else { } else {
return usage_hf_iclass_decrypt(); return usage_hf_iclass_decrypt();
} }
@ -400,10 +392,9 @@ int CmdHFiClassDecrypt(const char *Cmd) {
size_t blocknum =0; size_t blocknum =0;
while(bytes_read == 8) 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) ); des3_crypt_ecb(&ctx, enc_dump,decrypted +(blocknum*8) );
} }
printvar("decrypted block", decrypted +(blocknum*8), 8); printvar("decrypted block", decrypted +(blocknum*8), 8);
@ -411,9 +402,7 @@ int CmdHFiClassDecrypt(const char *Cmd) {
blocknum++; blocknum++;
} }
fclose(f); fclose(f);
saveFile(outfilename,"bin", decrypted, blocknum*8); saveFile(outfilename,"bin", decrypted, blocknum*8);
free(decrypted); free(decrypted);
return 0; return 0;
} }
@ -431,8 +420,7 @@ int usage_hf_iclass_encrypt(void) {
static int iClassEncryptBlkData(uint8_t *blkData) { static int iClassEncryptBlkData(uint8_t *blkData) {
uint8_t key[16] = { 0 }; uint8_t key[16] = { 0 };
if(readKeyfile("iclass_decryptionkey.bin", 16, key)) if(readKeyfile("iclass_decryptionkey.bin", 16, key)) {
{
usage_hf_iclass_encrypt(); usage_hf_iclass_encrypt();
return 1; return 1;
} }
@ -453,12 +441,10 @@ static int iClassEncryptBlkData(uint8_t *blkData) {
int CmdHFiClassEncryptBlk(const char *Cmd) { int CmdHFiClassEncryptBlk(const char *Cmd) {
uint8_t blkData[8] = {0}; uint8_t blkData[8] = {0};
char opt = param_getchar(Cmd, 0); char opt = param_getchar(Cmd, 0);
if (strlen(Cmd)<1 || opt == 'h') if (strlen(Cmd)<1 || opt == 'h' || opt == 'H') return usage_hf_iclass_encrypt();
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"); PrintAndLog("BlockData must include 16 HEX symbols");
return 0; return 0;
} }
@ -486,8 +472,7 @@ static bool select_only(uint8_t *CSN, uint8_t *CCNR, bool use_credit_key, bool v
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
{
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
return false; return false;
} }
@ -496,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; uint8_t *data = resp.d.asBytes;
memcpy(CSN,data,8); 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){ if(isOK <= 1){
PrintAndLog("Failed to obtain CC! Aborting"); PrintAndLog("Failed to obtain CC! Aborting");
return false; return false;
@ -519,7 +507,8 @@ static bool select_and_auth(uint8_t *KEY, uint8_t *MAC, uint8_t *div_key, bool u
if(rawkey) if(rawkey)
memcpy(div_key, KEY, 8); memcpy(div_key, KEY, 8);
else 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]); 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); doMAC(CCNR, div_key, MAC);
@ -528,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); memcpy(d.d.asBytes, MAC, 4);
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&d); SendCommand(&d);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
{
PrintAndLog("Auth Command execute timeout"); PrintAndLog("Auth Command execute timeout");
return false; return false;
} }
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
if (!isOK) { if (!isOK) {
PrintAndLog("Authentication error"); PrintAndLog("Authentication error");
return false; return false;
@ -552,7 +540,7 @@ int usage_hf_iclass_dump(void) {
PrintAndLog(" See 'hf iclass sim 2'. This key should be on iclass-format"); 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(" r : If 'r' is specified, the key is interpreted as raw block 3/4");
PrintAndLog(" NOTE: * = required"); PrintAndLog(" NOTE: * = required");
PrintAndLog("Samples:"); PrintAndLog("Samples:");
PrintAndLog(" hf iclass dump k 001122334455667B"); PrintAndLog(" hf iclass dump k 001122334455667B");
PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA c 001122334455667B"); PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA c 001122334455667B");
PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA e"); PrintAndLog(" hf iclass dump k AAAAAAAAAAAAAAAA e");
@ -676,13 +664,14 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
return 0; return 0;
} }
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(readStatus == 0){ if(readStatus == 0){
PrintAndLog("No tag found..."); PrintAndLog("No tag found...");
ul_switch_off_field(); ul_switch_off_field();
return 0; return 0;
} }
if( readStatus & (FLAG_ICLASS_READER_CSN|FLAG_ICLASS_READER_CONF|FLAG_ICLASS_READER_CC)){ 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..)
@ -691,6 +680,7 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
// large memory - not able to dump pages currently // large memory - not able to dump pages currently
if (numblks > maxBlk) numblks = maxBlk; if (numblks > maxBlk) numblks = maxBlk;
} }
ul_switch_off_field(); ul_switch_off_field();
// 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, rawkey, false)){ if (!select_and_auth(KEY, MAC, div_key, use_credit_key, elite, rawkey, false)){
@ -779,8 +769,8 @@ int CmdHFiClassReader_Dump(const char *Cmd) {
if (have_debit_key) memcpy(tag_data+(3*8),div_key,8); 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); if (have_credit_key) memcpy(tag_data+(4*8),c_div_key,8);
// 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] printf("CSN |00| %s |\n", sprint_hex(tag_data, 8));
,tag_data[3],tag_data[4],tag_data[5],tag_data[6],tag_data[7]); 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)-1, gotBytes-8);
if (filename[0] == 0){ if (filename[0] == 0){
@ -810,8 +800,7 @@ static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_c
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&w); SendCommand(&w);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
{
PrintAndLog("Write Command execute timeout"); PrintAndLog("Write Command execute timeout");
return 0; return 0;
} }
@ -826,13 +815,13 @@ static int WriteBlock(uint8_t blockno, uint8_t *bldata, uint8_t *KEY, bool use_c
int usage_hf_iclass_writeblock(void) { int usage_hf_iclass_writeblock(void) {
PrintAndLog("Options:"); PrintAndLog("Options:");
PrintAndLog(" b <Block> : The block number as 2 hex symbols"); PrintAndLog(" b <Block> : The block number as 2 hex symbols");
PrintAndLog(" d <data> : Set the Data to write as 16 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(" 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(" e : If 'e' is specified, elite computations applied to key");
PrintAndLog(" r : If 'r' is specified, no computations applied to key"); PrintAndLog(" r : If 'r' is specified, no computations applied to key");
PrintAndLog("Samples:"); PrintAndLog("Samples:");
PrintAndLog(" hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA k 001122334455667B"); 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 1B d AAAAAAAAAAAAAAAA k 001122334455667B c");
PrintAndLog(" hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA n 0"); PrintAndLog(" hf iclass writeblk b 0A d AAAAAAAAAAAAAAAA n 0");
@ -1088,9 +1077,9 @@ int CmdHFiClassCloneTag(const char *Cmd) {
printf(" MAC |%02x%02x%02x%02x|\n",p[8],p[9],p[10],p[11]); printf(" MAC |%02x%02x%02x%02x|\n",p[8],p[9],p[10],p[11]);
} }
UsbCommand resp; UsbCommand resp;
clearCommandBuffer();
SendCommand(&w); SendCommand(&w);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
{
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
return 0; return 0;
} }
@ -1108,11 +1097,11 @@ static int ReadBlock(uint8_t *KEY, uint8_t blockno, uint8_t keyType, bool elite,
UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}}; UsbCommand w = {CMD_ICLASS_READBLOCK, {blockno}};
clearCommandBuffer(); clearCommandBuffer();
SendCommand(&w); SendCommand(&w);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) if (!WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
{
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
return 0; return 0;
} }
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
if (!isOK) { if (!isOK) {
PrintAndLog("Read Block Failed"); PrintAndLog("Read Block Failed");
@ -1126,12 +1115,12 @@ 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|r\n"); PrintAndLog("Usage: hf iclass readblk b <Block> k <Key> c e|r\n");
PrintAndLog("Options:"); PrintAndLog("Options:");
PrintAndLog(" b <Block> : The block number as 2 hex symbols"); PrintAndLog(" b <Block> : The block number as 2 hex symbols");
PrintAndLog(" k <Key> : Access Key as 16 hex symbols or 1 hex to select key from memory"); PrintAndLog(" k <Key> : Access Key as 16 hex symbols or 1 hex to select key from memory");
PrintAndLog(" c : If 'c' is specified, the key set is assumed to be the credit key\n"); PrintAndLog(" 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(" e : If 'e' is specified, elite computations applied to key");
PrintAndLog(" r : If 'r' is specified, no computations applied to key"); PrintAndLog(" r : If 'r' is specified, no computations applied to key");
PrintAndLog("Samples:"); PrintAndLog("Samples:");
PrintAndLog(" hf iclass readblk b 06 k 0011223344556677"); PrintAndLog(" hf iclass readblk b 06 k 0011223344556677");
PrintAndLog(" hf iclass readblk b 1B k 0011223344556677 c"); PrintAndLog(" hf iclass readblk b 1B k 0011223344556677 c");
PrintAndLog(" hf iclass readblk b 0A k 0"); PrintAndLog(" hf iclass readblk b 0A k 0");
@ -1230,29 +1219,22 @@ int CmdHFiClass_loclass(const char *Cmd) {
return 0; return 0;
} }
char fileName[255] = {0}; char fileName[255] = {0};
if(opt == 'f') if(opt == 'f') {
{ if(param_getstr(Cmd, 1, fileName) > 0) {
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(); int errors = testCipherUtils();
errors += testMAC(); errors += testMAC();
errors += doKeyTests(0); errors += doKeyTests(0);
errors += testElite(); errors += testElite();
if(errors) if(errors) prnlog("OBS! There were errors!!!");
{
prnlog("OBS! There were errors!!!");
}
return errors; return errors;
} }
return 0; return 0;
} }
@ -1262,6 +1244,7 @@ void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t e
memcpy(&mem_config, iclass_dump + 13,1); memcpy(&mem_config, iclass_dump + 13,1);
uint8_t maxmemcount; uint8_t maxmemcount;
uint8_t filemaxblock = filesize / 8; uint8_t filemaxblock = filesize / 8;
if (mem_config & 0x80) if (mem_config & 0x80)
maxmemcount = 255; maxmemcount = 255;
else else
@ -1270,17 +1253,20 @@ void printIclassDumpContents(uint8_t *iclass_dump, uint8_t startblock, uint8_t e
if (startblock == 0) if (startblock == 0)
startblock = 6; startblock = 6;
if ((endblock > maxmemcount) || (endblock == 0)) if ((endblock > maxmemcount) || (endblock == 0))
endblock = maxmemcount; endblock = maxmemcount;
if (endblock > filemaxblock) if (endblock > filemaxblock)
endblock = filemaxblock; endblock = filemaxblock;
int i = startblock; int i = startblock;
int j; int j;
while (i <= endblock){ while (i <= endblock){
printf("Block |%02X| ",i); printf("Block |%02X| ",i);
memcpy(blockdata,iclass_dump + (i * 8),8); memcpy(blockdata, iclass_dump + (i * 8), 8);
for (j = 0;j < 8;j++) for (j = 0;j < 8;j++)
printf("%02X ",blockdata[j]); printf("%02X ", blockdata[j]);
printf("|\n"); printf("|\n");
i++; i++;
} }
@ -1299,6 +1285,7 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
char filename[FILE_PATH_SIZE]; char filename[FILE_PATH_SIZE];
if (param_getstr(Cmd, 0, filename) < 1) if (param_getstr(Cmd, 0, 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,(char *)&tempnum) < 1)
startblock = 0; startblock = 0;
else else
@ -1308,6 +1295,7 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
endblock = 0; endblock = 0;
else else
sscanf(tempnum,"%d",&endblock); sscanf(tempnum,"%d",&endblock);
// file handling and reading // file handling and reading
f = fopen(filename,"rb"); f = fopen(filename,"rb");
if(!f) { if(!f) {
@ -1325,12 +1313,11 @@ int CmdHFiClassReadTagFile(const char *Cmd) {
} }
uint8_t *dump = malloc(fsize); uint8_t *dump = malloc(fsize);
size_t bytes_read = fread(dump, 1, fsize, f); size_t bytes_read = fread(dump, 1, fsize, f);
fclose(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]); printf("CSN [00] | %s |\n", sprint_hex(csn, 8) );
// printIclassDumpInfo(dump);
printIclassDumpContents(dump,startblock,endblock,bytes_read); printIclassDumpContents(dump,startblock,endblock,bytes_read);
free(dump); free(dump);
return 0; return 0;
@ -1560,7 +1547,7 @@ static int saveKeys(char *filename) {
static int printKeys(void) { static int printKeys(void) {
PrintAndLog(""); PrintAndLog("");
for (uint8_t i = 0; i < ICLASS_KEYS_MAX; i++){ for (uint8_t i = 0; i < ICLASS_KEYS_MAX; i++){
PrintAndLog("%u: %s",i,sprint_hex(iClass_Key_Table[i],8)); PrintAndLog("%u: %s", i, sprint_hex(iClass_Key_Table[i],8));
} }
PrintAndLog(""); PrintAndLog("");
return 0; return 0;
@ -1677,8 +1664,7 @@ int CmdHFiClassManageKeys(const char *Cmd) {
return 0; return 0;
} }
static command_t CommandTable[] = static command_t CommandTable[] = {
{
{"help", CmdHelp, 1, "This help"}, {"help", CmdHelp, 1, "This help"},
{"calcnewkey", CmdHFiClassCalcNewKey, 1, "[options..] Calc Diversified keys (blocks 3 & 4) to write new keys"}, {"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"}, {"clone", CmdHFiClassCloneTag, 0, "[options..] Authenticate and Clone from iClass bin file"},
@ -1699,14 +1685,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); CmdsParse(CommandTable, Cmd);
return 0; return 0;
} }
int CmdHelp(const char *Cmd) int CmdHelp(const char *Cmd) {
{
CmdsHelp(CommandTable); CmdsHelp(CommandTable);
return 0; return 0;
} }