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

Merge branch 'master' of https://github.com/Proxmark/proxmark3

Browse source 
Conflicts:
	armsrc/iclass.c
This commit is contained in:
iceman1001 2015-02-16 18:59:44 +01:00
commit d716ca2fc1
8 changed files with 329 additions and 239 deletions
Download patch file Download diff file Expand all files Collapse all files

13
armsrc/BigBuf.c
View file

@ -224,3 +224,16 @@ int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwP
return TRUE; return TRUE;
} }
// Emulator memory
uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length){
uint8_t* mem = BigBuf_get_EM_addr();
if(offset+length < CARD_MEMORY_SIZE)
{
memcpy(mem+offset, data, length);
return 0;
}else
{
Dbprintf("Error, trying to set memory outside of bounds! %d > %d", (offset+length), CARD_MEMORY_SIZE);
return 1;
}
}

1
armsrc/BigBuf.h
View file

@ -34,4 +34,5 @@ void clear_trace();
void set_tracing(bool enable); void set_tracing(bool enable);
bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag); bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag);
int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int bReader); int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwParity, int bReader);
uint8_t emlSet(uint8_t *data, uint32_t offset, uint32_t length);
#endif /* __BIGBUF_H */ #endif /* __BIGBUF_H */

3
armsrc/appmain.c
View file

@ -902,6 +902,9 @@ void UsbPacketReceived(uint8_t *packet, int len)
case CMD_READER_ICLASS_REPLAY: case CMD_READER_ICLASS_REPLAY:
ReaderIClass_Replay(c->arg[0], c->d.asBytes); ReaderIClass_Replay(c->arg[0], c->d.asBytes);
break; break;
case CMD_ICLASS_EML_MEMSET:
emlSet(c->d.asBytes,c->arg[0], c->arg[1]);
break;
#endif #endif
case CMD_SIMULATE_TAG_HF_LISTEN: case CMD_SIMULATE_TAG_HF_LISTEN:

4
armsrc/iclass.c
View file

@ -1706,7 +1706,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
//Set card_data to all zeroes, we'll fill it with data //Set card_data to all zeroes, we'll fill it with data
memset(card_data,0x0,USB_CMD_DATA_SIZE); memset(card_data,0x0,USB_CMD_DATA_SIZE);
uint8_t failedRead =0; uint8_t failedRead =0;
uint8_t stored_data_length =0; uint32_t stored_data_length =0;
//then loop around remaining blocks //then loop around remaining blocks
for(int block=0; block < cardsize; block++){ for(int block=0; block < cardsize; block++){
@ -1725,7 +1725,6 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
//Fill up the buffer //Fill up the buffer
memcpy(card_data+stored_data_length,resp,8); memcpy(card_data+stored_data_length,resp,8);
stored_data_length += 8; stored_data_length += 8;
if(stored_data_length +8 > USB_CMD_DATA_SIZE) if(stored_data_length +8 > USB_CMD_DATA_SIZE)
{//Time to send this off and start afresh {//Time to send this off and start afresh
cmd_send(CMD_ACK, cmd_send(CMD_ACK,
@ -1744,6 +1743,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
Dbprintf("Failed to dump block %d", block); Dbprintf("Failed to dump block %d", block);
} }
} }
//Send off any remaining data //Send off any remaining data
if(stored_data_length > 0) if(stored_data_length > 0)
{ {

20
armsrc/lfops.c
View file

@ -1286,9 +1286,10 @@ void CopyIndala224toT55x7(int uid1, int uid2, int uid3, int uid4, int uid5, int
#define max(x,y) ( x<y ? y:x) #define max(x,y) ( x<y ? y:x)
int DemodPCF7931(uint8_t **outBlocks) { int DemodPCF7931(uint8_t **outBlocks) {
uint8_t BitStream[256];
uint8_t Blocks[8][16]; uint8_t BitStream[256] = {0x00};
uint8_t *GraphBuffer = BigBuf_get_addr(); uint8_t Blocks[8][16] = [0x00};
uint8_t *dest = BigBuf_get_addr();
int GraphTraceLen = BigBuf_max_traceLen(); int GraphTraceLen = BigBuf_max_traceLen();
int i, j, lastval, bitidx, half_switch; int i, j, lastval, bitidx, half_switch;
int clock = 64; int clock = 64;
@ -1300,8 +1301,7 @@ int DemodPCF7931(uint8_t **outBlocks) {
uint8_t dir; uint8_t dir;
LFSetupFPGAForADC(95, true); LFSetupFPGAForADC(95, true);
DoAcquisition_default(0, 0); DoAcquisition_default(0, true);
lmin = 64; lmin = 64;
lmax = 192; lmax = 192;
@ -1309,9 +1309,9 @@ int DemodPCF7931(uint8_t **outBlocks) {
i = 2; i = 2;
/* Find first local max/min */ /* Find first local max/min */
if(GraphBuffer[1] > GraphBuffer[0]) { if(dest[1] > dest[0]) {
while(i < GraphTraceLen) { while(i < GraphTraceLen) {
if( !(GraphBuffer[i] > GraphBuffer[i-1]) && GraphBuffer[i] > lmax) if( !(dest[i] > dest[i-1]) && dest[i] > lmax)
break; break;
i++; i++;
} }
@ -1319,7 +1319,7 @@ int DemodPCF7931(uint8_t **outBlocks) {
} }
else { else {
while(i < GraphTraceLen) { while(i < GraphTraceLen) {
if( !(GraphBuffer[i] < GraphBuffer[i-1]) && GraphBuffer[i] < lmin) if( !(dest[i] < dest[i-1]) && v[i] < lmin)
break; break;
i++; i++;
} }
@ -1333,7 +1333,7 @@ int DemodPCF7931(uint8_t **outBlocks) {
for (bitidx = 0; i < GraphTraceLen; i++) for (bitidx = 0; i < GraphTraceLen; i++)
{ {
if ( (GraphBuffer[i-1] > GraphBuffer[i] && dir == 1 && GraphBuffer[i] > lmax) || (GraphBuffer[i-1] < GraphBuffer[i] && dir == 0 && GraphBuffer[i] < lmin)) if ( (dest[i-1] > dest[i] && dir == 1 && dest[i] > lmax) || (dest[i-1] < dest[i] && dir == 0 && dest[i] < lmin))
{ {
lc = i - lastval; lc = i - lastval;
lastval = i; lastval = i;
@ -1400,7 +1400,7 @@ int DemodPCF7931(uint8_t **outBlocks) {
} }
if(i < GraphTraceLen) if(i < GraphTraceLen)
{ {
if (GraphBuffer[i-1] > GraphBuffer[i]) dir=0; if (dest[i-1] > dest[i]) dir=0;
else dir = 1; else dir = 1;
} }
} }

2
armsrc/lfsampling.c
View file

@ -13,7 +13,7 @@
#include "lfsampling.h" #include "lfsampling.h"
sample_config config = { 1, 8, 1, 88, 0 } ; sample_config config = { 1, 8, 1, 95, 0 } ;
void printConfig() void printConfig()
{ {

524
client/cmdhficlass.c
View file

@ -34,11 +34,11 @@ static int CmdHelp(const char *Cmd);
int xorbits_8(uint8_t val) int xorbits_8(uint8_t val)
{ {
uint8_t res = val ^ (val >> 1); //1st pass uint8_t res = val ^ (val >> 1); //1st pass
res = res ^ (res >> 1); // 2nd pass res = res ^ (res >> 1); // 2nd pass
res = res ^ (res >> 2); // 3rd pass res = res ^ (res >> 2); // 3rd pass
res = res ^ (res >> 4); // 4th pass res = res ^ (res >> 4); // 4th pass
return res & 1; return res & 1;
} }
int CmdHFiClassList(const char *Cmd) int CmdHFiClassList(const char *Cmd)
@ -49,44 +49,44 @@ int CmdHFiClassList(const char *Cmd)
int CmdHFiClassSnoop(const char *Cmd) int CmdHFiClassSnoop(const char *Cmd)
{ {
UsbCommand c = {CMD_SNOOP_ICLASS}; UsbCommand c = {CMD_SNOOP_ICLASS};
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
#define NUM_CSNS 15 #define NUM_CSNS 15
int CmdHFiClassSim(const char *Cmd) 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) {
PrintAndLog("Usage: hf iclass sim [0 <CSN>] | x"); PrintAndLog("Usage: hf iclass sim [0 <CSN>] | x");
PrintAndLog(" options"); PrintAndLog(" options");
PrintAndLog(" 0 <CSN> simulate the given CSN"); PrintAndLog(" 0 <CSN> simulate the given CSN");
PrintAndLog(" 1 simulate default CSN"); PrintAndLog(" 1 simulate default CSN");
PrintAndLog(" 2 iterate CSNs, gather MACs"); PrintAndLog(" 2 iterate CSNs, gather MACs");
PrintAndLog(" sample: hf iclass sim 0 031FEC8AF7FF12E0"); PrintAndLog(" sample: hf iclass sim 0 031FEC8AF7FF12E0");
PrintAndLog(" sample: hf iclass sim 2"); PrintAndLog(" sample: hf iclass sim 2");
return 0; return 0;
} }
simType = param_get8(Cmd, 0); simType = param_get8(Cmd, 0);
if(simType == 0) if(simType == 0)
{ {
if (param_gethex(Cmd, 1, CSN, 16)) { if (param_gethex(Cmd, 1, CSN, 16)) {
PrintAndLog("A CSN should consist of 16 HEX symbols"); PrintAndLog("A CSN should consist of 16 HEX symbols");
return 1; return 1;
} }
PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8)); PrintAndLog("--simtype:%02x csn:%s", simType, sprint_hex(CSN, 8));
} }
if(simType > 2) if(simType > 2)
{ {
PrintAndLog("Undefined simptype %d", simType); PrintAndLog("Undefined simptype %d", simType);
return 1; return 1;
} }
uint8_t numberOfCSNs=0; uint8_t numberOfCSNs=0;
if(simType == 2) if(simType == 2)
{ {
@ -103,23 +103,23 @@ int CmdHFiClassSim(const char *Cmd)
0x00,0x73,0xd8,0x75,0x58,0xff,0x12,0xe0 , 0x00,0x73,0xd8,0x75,0x58,0xff,0x12,0xe0 ,
0x0c,0x90,0x32,0xf3,0x5d,0xff,0x12,0xe0 }; 0x0c,0x90,0x32,0xf3,0x5d,0xff,0x12,0xe0 };
*/ */
uint8_t csns[8*NUM_CSNS] = { uint8_t csns[8*NUM_CSNS] = {
0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x0B, 0x0F, 0xFF, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x04, 0x0E, 0x08, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x09, 0x0D, 0x05, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x0A, 0x0C, 0x06, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x0A, 0x0C, 0x06, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x0F, 0x0B, 0x03, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x0F, 0x0B, 0x03, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x08, 0x0A, 0x0C, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x08, 0x0A, 0x0C, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x0D, 0x09, 0x09, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x0D, 0x09, 0x09, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x0E, 0x08, 0x0A, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x0E, 0x08, 0x0A, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x03, 0x07, 0x17, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x03, 0x07, 0x17, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x3C, 0x06, 0xE0, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x3C, 0x06, 0xE0, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x01, 0x05, 0x1D, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x01, 0x05, 0x1D, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x02, 0x04, 0x1E, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x02, 0x04, 0x1E, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x07, 0x03, 0x1B, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x07, 0x03, 0x1B, 0xF7, 0xFF, 0x12, 0xE0,
0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0, 0x00, 0x00, 0x02, 0x24, 0xF7, 0xFF, 0x12, 0xE0,
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);
@ -164,124 +164,124 @@ int CmdHFiClassSim(const char *Cmd)
SendCommand(&c); SendCommand(&c);
} }
return 0; return 0;
} }
int CmdHFiClassReader(const char *Cmd) int CmdHFiClassReader(const char *Cmd)
{ {
UsbCommand c = {CMD_READER_ICLASS, {0}}; UsbCommand c = {CMD_READER_ICLASS, {0}};
SendCommand(&c); SendCommand(&c);
UsbCommand resp; UsbCommand resp;
while(!ukbhit()){ while(!ukbhit()){
if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes; uint8_t * data = resp.d.asBytes;
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk:%02x", isOK);
if( isOK == 0){ if( isOK == 0){
//Aborted //Aborted
PrintAndLog("Quitting..."); PrintAndLog("Quitting...");
return 0; return 0;
} }
if(isOK > 0) if(isOK > 0)
{ {
PrintAndLog("CSN: %s",sprint_hex(data,8)); PrintAndLog("CSN: %s",sprint_hex(data,8));
} }
if(isOK >= 1) if(isOK >= 1)
{ {
PrintAndLog("CC: %s",sprint_hex(data+8,8)); PrintAndLog("CC: %s",sprint_hex(data+8,8));
}else{ }else{
PrintAndLog("No CC obtained"); PrintAndLog("No CC obtained");
} }
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
} }
return 0; return 0;
} }
int CmdHFiClassReader_Replay(const char *Cmd) int CmdHFiClassReader_Replay(const char *Cmd)
{ {
uint8_t readerType = 0; uint8_t readerType = 0;
uint8_t MAC[4]={0x00, 0x00, 0x00, 0x00}; uint8_t MAC[4]={0x00, 0x00, 0x00, 0x00};
if (strlen(Cmd)<1) { if (strlen(Cmd)<1) {
PrintAndLog("Usage: hf iclass replay <MAC>"); PrintAndLog("Usage: hf iclass replay <MAC>");
PrintAndLog(" sample: hf iclass replay 00112233"); PrintAndLog(" sample: hf iclass replay 00112233");
return 0; return 0;
} }
if (param_gethex(Cmd, 0, MAC, 8)) { if (param_gethex(Cmd, 0, MAC, 8)) {
PrintAndLog("MAC must include 8 HEX symbols"); PrintAndLog("MAC must include 8 HEX symbols");
return 1; return 1;
} }
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);
SendCommand(&c); SendCommand(&c);
return 0; return 0;
} }
int CmdHFiClassReader_Dump(const char *Cmd) int CmdHFiClassReader_Dump(const char *Cmd)
{ {
uint8_t readerType = 0; uint8_t readerType = 0;
uint8_t MAC[4]={0x00,0x00,0x00,0x00}; uint8_t MAC[4]={0x00,0x00,0x00,0x00};
uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t CSN[8]={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}; uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
//uint8_t CC_temp[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; //uint8_t CC_temp[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t keytable[128] = {0}; uint8_t keytable[128] = {0};
int elite = 0; int elite = 0;
uint8_t *used_key; uint8_t *used_key;
int i; int i;
if (strlen(Cmd)<1) if (strlen(Cmd)<1)
{ {
PrintAndLog("Usage: hf iclass dump <Key> [e]"); PrintAndLog("Usage: hf iclass dump <Key> [e]");
PrintAndLog(" Key - A 16 byte master key"); PrintAndLog(" Key - A 16 byte master key");
PrintAndLog(" e - If 'e' is specified, the key is interpreted as the 16 byte"); 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(" Custom Key (KCus), which can be obtained via reader-attack");
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(" sample: hf iclass dump 0011223344556677"); PrintAndLog(" sample: hf iclass dump 0011223344556677");
return 0; return 0;
} }
if (param_gethex(Cmd, 0, KEY, 16)) if (param_gethex(Cmd, 0, KEY, 16))
{ {
PrintAndLog("KEY must include 16 HEX symbols"); PrintAndLog("KEY must include 16 HEX symbols");
return 1; return 1;
} }
if (param_getchar(Cmd, 1) == 'e') if (param_getchar(Cmd, 1) == 'e')
{ {
PrintAndLog("Elite switch on"); PrintAndLog("Elite switch on");
elite = 1; elite = 1;
//calc h2 //calc h2
hash2(KEY, keytable); hash2(KEY, keytable);
printarr_human_readable("keytable", keytable, 128); printarr_human_readable("keytable", keytable, 128);
} }
UsbCommand resp; UsbCommand resp;
uint8_t key_sel[8] = {0}; uint8_t key_sel[8] = {0};
uint8_t key_sel_p[8] = { 0 }; uint8_t key_sel_p[8] = { 0 };
UsbCommand c = {CMD_READER_ICLASS, {0}}; UsbCommand c = {CMD_READER_ICLASS, {0}};
c.arg[0] = FLAG_ICLASS_READER_ONLY_ONCE| FLAG_ICLASS_READER_GET_CC; c.arg[0] = FLAG_ICLASS_READER_ONLY_ONCE| FLAG_ICLASS_READER_GET_CC;
SendCommand(&c); SendCommand(&c);
if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
{ if (!WaitForResponseTimeout(CMD_ACK,&resp,4500))
PrintAndLog("Command execute timeout"); {
return 0; PrintAndLog("Command execute timeout");
} return 0;
}
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes; uint8_t * data = resp.d.asBytes;
@ -329,8 +329,8 @@ int CmdHFiClassReader_Dump(const char *Cmd)
printvar("MAC", MAC, 4); printvar("MAC", MAC, 4);
uint8_t iclass_data[32000] = {0}; uint8_t iclass_data[32000] = {0};
uint8_t iclass_datalen = 0; uint32_t iclass_datalen = 0;
uint8_t iclass_blocksFailed = 0;//Set to 1 if dump was incomplete uint32_t iclass_blocksFailed = 0;//Set to 1 if dump was incomplete
UsbCommand d = {CMD_READER_ICLASS_REPLAY, {readerType}}; UsbCommand d = {CMD_READER_ICLASS_REPLAY, {readerType}};
memcpy(d.d.asBytes, MAC, 4); memcpy(d.d.asBytes, MAC, 4);
@ -346,11 +346,11 @@ int CmdHFiClassReader_Dump(const char *Cmd)
} }
if(WaitForResponseTimeout(CMD_ACK,&resp,4500)) if(WaitForResponseTimeout(CMD_ACK,&resp,4500))
{ {
uint64_t dataLength = resp.arg[0]; uint32_t dataLength = resp.arg[0];
iclass_blocksFailed |= resp.arg[1]; iclass_blocksFailed |= resp.arg[1];
if(dataLength > 0) if(dataLength > 0)
{ {
PrintAndLog("Got %d bytes data (total so far %d)" ,dataLength,iclass_datalen);
memcpy(iclass_data, resp.d.asBytes,dataLength); memcpy(iclass_data, resp.d.asBytes,dataLength);
iclass_datalen += dataLength; iclass_datalen += dataLength;
}else }else
@ -366,9 +366,8 @@ int CmdHFiClassReader_Dump(const char *Cmd)
//create a preferred filename //create a preferred filename
snprintf(filename, 100,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x", snprintf(filename, 100,"iclass_tagdump-%02x%02x%02x%02x%02x%02x%02x%02x",
CSN[0],CSN[1],CSN[2],CSN[3], CSN[0],CSN[1],CSN[2],CSN[3],
CSN[4],CSN[5],CSN[6],CSN[7]); CSN[4],CSN[5],CSN[6],CSN[7]);
saveFile(filename,"bin",iclass_data, iclass_datalen ); saveFile(filename,"bin",iclass_data, iclass_datalen );
} }
//Aaaand we're finished //Aaaand we're finished
return 0; return 0;
@ -377,85 +376,157 @@ int CmdHFiClassReader_Dump(const char *Cmd)
} }
return 0; return 0;
} }
int hf_iclass_eload_usage()
{
PrintAndLog("Loads iclass tag-dump into emulator memory on device");
PrintAndLog("Usage: hf iclass eload f <filename>");
PrintAndLog("");
PrintAndLog("Example: hf iclass eload f iclass_tagdump-aa162d30f8ff12f1.bin");
return 0;
}
int iclassEmlSetMem(uint8_t *data, int blockNum, int blocksCount) {
UsbCommand c = {CMD_MIFARE_EML_MEMSET, {blockNum, blocksCount, 0}};
memcpy(c.d.asBytes, data, blocksCount * 16);
SendCommand(&c);
return 0;
}
int CmdHFiClassELoad(const char *Cmd)
{
char opt = param_getchar(Cmd, 0);
if (strlen(Cmd)<1 || opt == 'h')
return hf_iclass_eload_usage();
//File handling and reading
FILE *f;
char filename[FILE_PATH_SIZE];
if(opt == 'f' && param_getstr(Cmd, 1, filename) > 0)
{
f = fopen(filename, "rb");
}else{
return hf_iclass_eload_usage();
}
if(!f) {
PrintAndLog("Failed to read from file '%s'", filename);
return 1;
}
fseek(f, 0, SEEK_END);
long fsize = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t *dump = malloc(fsize);
size_t bytes_read = fread(dump, 1, fsize, f);
fclose(f);
//Validate
if (bytes_read < fsize)
{
prnlog("Error, could only read %d bytes (should be %d)",bytes_read, fsize );
free(dump);
return 1;
}
//Send to device
uint32_t bytes_sent = 0;
uint32_t bytes_remaining = bytes_read;
while(bytes_remaining > 0){
uint32_t bytes_in_packet = MIN(USB_CMD_DATA_SIZE, bytes_remaining);
UsbCommand c = {CMD_ICLASS_EML_MEMSET, {bytes_sent,bytes_in_packet,0}};
memcpy(c.d.asBytes, dump, bytes_in_packet);
SendCommand(&c);
bytes_remaining -= bytes_in_packet;
bytes_sent += bytes_in_packet;
}
free(dump);
PrintAndLog("Sent %d bytes of data to device emulator memory", bytes_sent);
return 0;
}
int CmdHFiClass_iso14443A_write(const char *Cmd) int CmdHFiClass_iso14443A_write(const char *Cmd)
{ {
uint8_t readerType = 0; uint8_t readerType = 0;
uint8_t MAC[4]={0x00,0x00,0x00,0x00}; uint8_t MAC[4]={0x00,0x00,0x00,0x00};
uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; uint8_t KEY[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t CSN[8]={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}; uint8_t CCNR[12]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; uint8_t div_key[8]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t blockNo=0; uint8_t blockNo=0;
uint8_t bldata[8]={0}; uint8_t bldata[8]={0};
if (strlen(Cmd)<3) if (strlen(Cmd)<3)
{ {
PrintAndLog("Usage: hf iclass write <Key> <Block> <Data>"); PrintAndLog("Usage: hf iclass write <Key> <Block> <Data>");
PrintAndLog(" sample: hf iclass write 0011223344556677 10 AAAAAAAAAAAAAAAA"); PrintAndLog(" sample: hf iclass write 0011223344556677 10 AAAAAAAAAAAAAAAA");
return 0; return 0;
} }
if (param_gethex(Cmd, 0, KEY, 16)) if (param_gethex(Cmd, 0, KEY, 16))
{ {
PrintAndLog("KEY must include 16 HEX symbols"); PrintAndLog("KEY must include 16 HEX symbols");
return 1; return 1;
} }
blockNo = param_get8(Cmd, 1);
if (blockNo>32)
{
PrintAndLog("Error: Maximum number of blocks is 32 for iClass 2K Cards!");
return 1;
}
if (param_gethex(Cmd, 2, bldata, 8))
{
PrintAndLog("Block data must include 8 HEX symbols");
return 1;
}
UsbCommand c = {CMD_ICLASS_ISO14443A_WRITE, {0}};
SendCommand(&c);
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) { blockNo = param_get8(Cmd, 1);
uint8_t isOK = resp.arg[0] & 0xff; if (blockNo>32)
uint8_t * data = resp.d.asBytes; {
PrintAndLog("Error: Maximum number of blocks is 32 for iClass 2K Cards!");
memcpy(CSN,data,8); return 1;
memcpy(CCNR,data+8,8); }
PrintAndLog("DEBUG: %s",sprint_hex(CSN,8)); if (param_gethex(Cmd, 2, bldata, 8))
PrintAndLog("DEBUG: %s",sprint_hex(CCNR,8)); {
PrintAndLog("isOk:%02x", isOK); PrintAndLog("Block data must include 8 HEX symbols");
} else { return 1;
PrintAndLog("Command execute timeout"); }
}
diversifyKey(CSN,KEY, div_key); UsbCommand c = {CMD_ICLASS_ISO14443A_WRITE, {0}};
SendCommand(&c);
UsbCommand resp;
PrintAndLog("Div Key: %s",sprint_hex(div_key,8)); if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
doMAC(CCNR, 12,div_key, MAC); uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes;
UsbCommand c2 = {CMD_ICLASS_ISO14443A_WRITE, {readerType,blockNo}}; memcpy(CSN,data,8);
memcpy(c2.d.asBytes, bldata, 8); memcpy(CCNR,data+8,8);
memcpy(c2.d.asBytes+8, MAC, 4); PrintAndLog("DEBUG: %s",sprint_hex(CSN,8));
SendCommand(&c2); PrintAndLog("DEBUG: %s",sprint_hex(CCNR,8));
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) { diversifyKey(CSN,KEY, div_key);
uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes;
if (isOK) PrintAndLog("Div Key: %s",sprint_hex(div_key,8));
PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4)); doMAC(CCNR, 12,div_key, MAC);
else
PrintAndLog("isOk:%02x", isOK); UsbCommand c2 = {CMD_ICLASS_ISO14443A_WRITE, {readerType,blockNo}};
} else { memcpy(c2.d.asBytes, bldata, 8);
PrintAndLog("Command execute timeout"); memcpy(c2.d.asBytes+8, MAC, 4);
} SendCommand(&c2);
return 0;
if (WaitForResponseTimeout(CMD_ACK,&resp,1500)) {
uint8_t isOK = resp.arg[0] & 0xff;
uint8_t * data = resp.d.asBytes;
if (isOK)
PrintAndLog("isOk:%02x data:%s", isOK, sprint_hex(data, 4));
else
PrintAndLog("isOk:%02x", isOK);
} else {
PrintAndLog("Command execute timeout");
}
return 0;
} }
int CmdHFiClass_loclass(const char *Cmd) int CmdHFiClass_loclass(const char *Cmd)
{ {
@ -479,13 +550,13 @@ int CmdHFiClass_loclass(const char *Cmd)
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");
} }
} }
else if(opt == 't') else if(opt == 't')
{ {
@ -512,19 +583,20 @@ static command_t CommandTable[] =
{"reader",CmdHFiClassReader, 0, "Read an iClass tag"}, {"reader",CmdHFiClassReader, 0, "Read an iClass tag"},
{"replay",CmdHFiClassReader_Replay, 0, "Read an iClass tag via Reply Attack"}, {"replay",CmdHFiClassReader_Replay, 0, "Read an iClass tag via Reply Attack"},
{"dump", CmdHFiClassReader_Dump, 0, "Authenticate and Dump iClass tag"}, {"dump", CmdHFiClassReader_Dump, 0, "Authenticate and Dump iClass tag"},
{"write", CmdHFiClass_iso14443A_write, 0, "Authenticate and Write iClass block"}, // {"write", CmdHFiClass_iso14443A_write, 0, "Authenticate and Write iClass block"},
{"loclass", CmdHFiClass_loclass, 1, "Use loclass to perform bruteforce of reader attack dump"}, {"loclass", CmdHFiClass_loclass, 1, "Use loclass to perform bruteforce of reader attack dump"},
{"eload", CmdHFiClassELoad, 0, "[experimental] Load data into iclass emulator memory"},
{NULL, NULL, 0, NULL} {NULL, NULL, 0, NULL}
}; };
int CmdHFiClass(const char *Cmd) int CmdHFiClass(const char *Cmd)
{ {
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;
} }

1
include/usb_cmd.h
View file

@ -132,6 +132,7 @@ typedef struct{
#define CMD_READER_ICLASS 0x0394 #define CMD_READER_ICLASS 0x0394
#define CMD_READER_ICLASS_REPLAY 0x0395 #define CMD_READER_ICLASS_REPLAY 0x0395
#define CMD_ICLASS_ISO14443A_WRITE 0x0397 #define CMD_ICLASS_ISO14443A_WRITE 0x0397
#define CMD_ICLASS_EML_MEMSET 0x0398
// For measurements of the antenna tuning // For measurements of the antenna tuning
#define CMD_MEASURE_ANTENNA_TUNING 0x0400 #define CMD_MEASURE_ANTENNA_TUNING 0x0400