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

FIX: 'hf iclass reader' marshmellows fixes.

Browse source 
CHG:  removing some #define TRUE
This commit is contained in:
iceman1001 2017-07-07 12:38:49 +02:00
commit 5f18400cbe
13 changed files with 167 additions and 142 deletions
Download patch file Download diff file Expand all files Collapse all files

4
armsrc/BigBuf.c
View file

@ -196,7 +196,7 @@ bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_
} }
traceLen += num_paritybytes; traceLen += num_paritybytes;
return TRUE; return true;
} }
@ -239,7 +239,7 @@ int LogTraceHitag(const uint8_t * btBytes, int iBits, int iSamples, uint32_t dwP
memcpy(trace + traceLen, btBytes, iLen); memcpy(trace + traceLen, btBytes, iLen);
traceLen += iLen; traceLen += iLen;
return TRUE; return true;
} }

14
armsrc/emvcmd.c
View file

@ -458,7 +458,7 @@ void EMVTransaction()
//setup stuff //setup stuff
BigBuf_free(); BigBuf_Clear_ext(false); BigBuf_free(); BigBuf_Clear_ext(false);
clear_trace(); clear_trace();
set_tracing(TRUE); set_tracing(true);
uint8_t *resp = BigBuf_malloc(256); uint8_t *resp = BigBuf_malloc(256);
@ -777,7 +777,7 @@ void SimulateEMVcard()
BigBuf_malloc((allocatedtaglen*8) +(allocatedtaglen) + (TAG_RESPONSE_COUNT * 3)); BigBuf_malloc((allocatedtaglen*8) +(allocatedtaglen) + (TAG_RESPONSE_COUNT * 3));
// clear trace // clear trace
clear_trace(); clear_trace();
set_tracing(TRUE); set_tracing(true);
// Prepare the responses of the anticollision phase // Prepare the responses of the anticollision phase
// there will be not enough time to do this at the moment the reader sends it REQA // there will be not enough time to do this at the moment the reader sends it REQA
@ -854,7 +854,7 @@ void SimulateEMVcard()
//we're an EMV card - so no read commands //we're an EMV card - so no read commands
p_response = NULL; p_response = NULL;
} else if(receivedCmd[0] == 0x50) { // Received a HALT } else if(receivedCmd[0] == 0x50) { // Received a HALT
LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE); LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, true);
p_response = NULL; p_response = NULL;
order = HLTA; order = HLTA;
} else if(receivedCmd[0] == 0x60 || receivedCmd[0] == 0x61) { // Received an authentication request } else if(receivedCmd[0] == 0x60 || receivedCmd[0] == 0x61) { // Received an authentication request
@ -865,7 +865,7 @@ void SimulateEMVcard()
p_response = &responses[ATS]; p_response = &responses[ATS];
order = RATS; order = RATS;
} else if (order == AUTH && len == 8) { // Received {nr] and {ar} (part of authentication) } else if (order == AUTH && len == 8) { // Received {nr] and {ar} (part of authentication)
LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE); LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, true);
uint32_t nr = bytes_to_num(receivedCmd,4); uint32_t nr = bytes_to_num(receivedCmd,4);
uint32_t ar = bytes_to_num(receivedCmd+4,4); uint32_t ar = bytes_to_num(receivedCmd+4,4);
Dbprintf("Auth attempt {nr}{ar}: %08x %08x",nr,ar); Dbprintf("Auth attempt {nr}{ar}: %08x %08x",nr,ar);
@ -935,7 +935,7 @@ void SimulateEMVcard()
default: { default: {
// Never seen this command before // Never seen this command before
LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE); LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, true);
Dbprintf("Received unknown command (len=%d):",len); Dbprintf("Received unknown command (len=%d):",len);
Dbhexdump(len,receivedCmd,false); Dbhexdump(len,receivedCmd,false);
// Do not respond // Do not respond
@ -952,12 +952,12 @@ void SimulateEMVcard()
dynamic_response_info.response_n += 2; dynamic_response_info.response_n += 2;
if(dynamic_response_info.response_n > readerPacketLen){ //throw error if our reader doesn't support the send packet length if(dynamic_response_info.response_n > readerPacketLen){ //throw error if our reader doesn't support the send packet length
Dbprintf("Error: tag response is longer then what the reader supports, TODO:implement command chaining"); Dbprintf("Error: tag response is longer then what the reader supports, TODO:implement command chaining");
LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE); LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, true);
break; break;
} }
if (prepare_tag_modulation(&dynamic_response_info,DYNAMIC_MODULATION_BUFFER_SIZE) == false) { if (prepare_tag_modulation(&dynamic_response_info,DYNAMIC_MODULATION_BUFFER_SIZE) == false) {
Dbprintf("Error preparing tag response"); Dbprintf("Error preparing tag response");
LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, TRUE); LogTrace(receivedCmd, Uart.len, Uart.startTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.endTime*16 - DELAY_AIR2ARM_AS_TAG, Uart.parity, true);
break; break;
} }
p_response = &dynamic_response_info; p_response = &dynamic_response_info;

19
armsrc/fpgaloader.c
View file

@ -143,7 +143,7 @@ void FpgaSetupSscExt(uint8_t clearPCER) {
AT91C_BASE_SSC->SSC_CR = AT91C_SSC_RXEN | AT91C_SSC_TXEN; AT91C_BASE_SSC->SSC_CR = AT91C_SSC_RXEN | AT91C_SSC_TXEN;
} }
void FpgaSetupSsc(void) { void FpgaSetupSsc(void) {
FpgaSetupSscExt(TRUE); FpgaSetupSscExt(true);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Set up DMA to receive samples from the FPGA. We will use the PDC, with // Set up DMA to receive samples from the FPGA. We will use the PDC, with
@ -183,7 +183,7 @@ static int get_from_fpga_combined_stream(z_streamp compressed_fpga_stream, uint8
return res; return res;
} }
++uncompressed_bytes_cnt; uncompressed_bytes_cnt++;
return *fpga_image_ptr++; return *fpga_image_ptr++;
} }
@ -547,10 +547,15 @@ void SetAdcMuxFor(uint32_t whichGpio)
HIGH(whichGpio); HIGH(whichGpio);
} }
void Fpga_print_status(void) void Fpga_print_status(void) {
{
Dbprintf("Fgpa"); Dbprintf("Fgpa");
if(downloaded_bitstream == FPGA_BITSTREAM_HF) Dbprintf(" mode.............HF"); switch(downloaded_bitstream) {
else if(downloaded_bitstream == FPGA_BITSTREAM_LF) Dbprintf(" mode.............LF"); case FPGA_BITSTREAM_HF: Dbprintf(" mode....................HF"); break;
else Dbprintf(" mode.............%d", downloaded_bitstream); case FPGA_BITSTREAM_LF: Dbprintf(" mode....................LF"); break;
default: Dbprintf(" mode....................%d", downloaded_bitstream); break;
}
}
int FpgaGetCurrent() {
return downloaded_bitstream;
} }

2
armsrc/fpgaloader.h
View file

@ -28,6 +28,7 @@ void FpgaSetupSsc(void);
void SetupSpi(int mode); void SetupSpi(int mode);
bool FpgaSetupSscDma(uint8_t *buf, int len); bool FpgaSetupSscDma(uint8_t *buf, int len);
void Fpga_print_status(); void Fpga_print_status();
int FpgaGetCurrent();
#define FpgaDisableSscDma(void) AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTDIS; #define FpgaDisableSscDma(void) AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTDIS;
#define FpgaEnableSscDma(void) AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTEN; #define FpgaEnableSscDma(void) AT91C_BASE_PDC_SSC->PDC_PTCR = AT91C_PDC_RXTEN;
void SetAdcMuxFor(uint32_t whichGpio); void SetAdcMuxFor(uint32_t whichGpio);
@ -66,7 +67,6 @@ void SetAdcMuxFor(uint32_t whichGpio);
// Options for the HF reader, correlating against rx from tag // Options for the HF reader, correlating against rx from tag
#define FPGA_HF_READER_RX_XCORR_848_KHZ (1<<0) #define FPGA_HF_READER_RX_XCORR_848_KHZ (1<<0)
#define FPGA_HF_READER_RX_XCORR_SNOOP (1<<1) #define FPGA_HF_READER_RX_XCORR_SNOOP (1<<1)
#define FPGA_HF_READER_RX_XCORR_QUARTER_FREQ (1<<2)
// Options for the HF simulated tag, how to modulate // Options for the HF simulated tag, how to modulate
#define FPGA_HF_SIMULATOR_NO_MODULATION (0<<0) // 0000 #define FPGA_HF_SIMULATOR_NO_MODULATION (0<<0) // 0000
#define FPGA_HF_SIMULATOR_MODULATE_BPSK (1<<0) // 0001 #define FPGA_HF_SIMULATOR_MODULATE_BPSK (1<<0) // 0001

109
armsrc/iclass.c
View file

@ -45,6 +45,7 @@
#include "iso15693tools.h" #include "iso15693tools.h"
#include "protocols.h" #include "protocols.h"
#include "optimized_cipher.h" #include "optimized_cipher.h"
#include "usb_cdc.h" // for usb_poll_validate_length
static int timeout = 4096; static int timeout = 4096;
@ -95,7 +96,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
Uart.output[Uart.byteCnt] = Uart.bitBuffer & 0xFF; Uart.output[Uart.byteCnt] = Uart.bitBuffer & 0xFF;
Uart.byteCnt++; Uart.byteCnt++;
Uart.swapper = 0; Uart.swapper = 0;
if(Uart.byteCnt > 15) { return TRUE; } if(Uart.byteCnt > 15) { return true; }
} }
else { else {
Uart.swapper = 1; Uart.swapper = 1;
@ -137,7 +138,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
Uart.byteCnt++; Uart.byteCnt++;
} }
else { else {
return TRUE; return true;
} }
} }
else if(Uart.state != STATE_START_OF_COMMUNICATION) { else if(Uart.state != STATE_START_OF_COMMUNICATION) {
@ -256,7 +257,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
Uart.byteCnt++; Uart.byteCnt++;
Uart.output[Uart.byteCnt] = 0xAA; Uart.output[Uart.byteCnt] = 0xAA;
Uart.byteCnt++; Uart.byteCnt++;
return TRUE; return true;
}*/ }*/
} }
@ -468,7 +469,7 @@ static RAMFUNC int ManchesterDecoding(int v)
Demod.len++; Demod.len++;
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
// error = 0x0f; // error = 0x0f;
return TRUE; return true;
} }
else { else {
Demod.state = DEMOD_ERROR_WAIT; Demod.state = DEMOD_ERROR_WAIT;
@ -552,7 +553,7 @@ static RAMFUNC int ManchesterDecoding(int v)
} }
Demod.state = DEMOD_UNSYNCD; Demod.state = DEMOD_UNSYNCD;
return TRUE; return true;
} }
else { else {
Demod.output[Demod.len] = 0xad; Demod.output[Demod.len] = 0xad;
@ -607,7 +608,7 @@ static RAMFUNC int ManchesterDecoding(int v)
Demod.len++; Demod.len++;
Demod.output[Demod.len] = 0xBB; Demod.output[Demod.len] = 0xBB;
Demod.len++; Demod.len++;
return TRUE; return true;
} }
} }
@ -650,7 +651,7 @@ void RAMFUNC SnoopIClass(void)
uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE); uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE);
clear_trace(); clear_trace();
set_tracing(TRUE); set_tracing(true);
iso14a_set_trigger(FALSE); iso14a_set_trigger(FALSE);
@ -747,12 +748,12 @@ void RAMFUNC SnoopIClass(void)
time_stop = (GetCountSspClk()-time_0) << 4; time_stop = (GetCountSspClk()-time_0) << 4;
LED_C_ON(); LED_C_ON();
//if(!LogTrace(Uart.output,Uart.byteCnt, rsamples, Uart.parityBits,TRUE)) break; //if(!LogTrace(Uart.output,Uart.byteCnt, rsamples, Uart.parityBits,true)) break;
//if(!LogTrace(NULL, 0, Uart.endTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER, 0, TRUE)) break; //if(!LogTrace(NULL, 0, Uart.endTime*16 - DELAY_READER_AIR2ARM_AS_SNIFFER, 0, true)) break;
if(tracing) { if(tracing) {
uint8_t parity[MAX_PARITY_SIZE]; uint8_t parity[MAX_PARITY_SIZE];
GetParity(Uart.output, Uart.byteCnt, parity); GetParity(Uart.output, Uart.byteCnt, parity);
LogTrace(Uart.output,Uart.byteCnt, time_start, time_stop, parity, TRUE); LogTrace(Uart.output,Uart.byteCnt, time_start, time_stop, parity, true);
} }
/* And ready to receive another command. */ /* And ready to receive another command. */
@ -851,7 +852,7 @@ static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen)
if(OutOfNDecoding(b & 0x0f)) { if(OutOfNDecoding(b & 0x0f)) {
*len = Uart.byteCnt; *len = Uart.byteCnt;
return TRUE; return true;
} }
} }
} }
@ -987,7 +988,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
// Enable and clear the trace // Enable and clear the trace
clear_trace(); clear_trace();
set_tracing(TRUE); set_tracing(true);
//Use the emulator memory for SIM //Use the emulator memory for SIM
uint8_t *emulator = BigBuf_get_EM_addr(); uint8_t *emulator = BigBuf_get_EM_addr();
@ -1320,7 +1321,7 @@ int doIClassSimulation( int simulationMode, uint8_t *reader_mac_buf)
if (tracing) { if (tracing) {
uint8_t parity[MAX_PARITY_SIZE]; uint8_t parity[MAX_PARITY_SIZE];
GetParity(receivedCmd, len, parity); GetParity(receivedCmd, len, parity);
LogTrace(receivedCmd,len, (r2t_time-time_0)<< 4, (r2t_time-time_0) << 4, parity, TRUE); LogTrace(receivedCmd,len, (r2t_time-time_0)<< 4, (r2t_time-time_0) << 4, parity, true);
if (trace_data != NULL) { if (trace_data != NULL) {
GetParity(trace_data, trace_data_size, parity); GetParity(trace_data, trace_data_size, parity);
@ -1408,7 +1409,7 @@ static void TransmitIClassCommand(const uint8_t *cmd, int len, int *samples, int
uint8_t sendbyte; uint8_t sendbyte;
bool firstpart = TRUE; bool firstpart = true;
c = 0; c = 0;
for(;;) { for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
@ -1500,7 +1501,7 @@ void ReaderTransmitIClass(uint8_t* frame, int len)
if (tracing) { if (tracing) {
uint8_t par[MAX_PARITY_SIZE]; uint8_t par[MAX_PARITY_SIZE];
GetParity(frame, len, par); GetParity(frame, len, par);
LogTrace(frame, len, rsamples, rsamples, par, TRUE); LogTrace(frame, len, rsamples, rsamples, par, true);
} }
} }
@ -1552,7 +1553,7 @@ static int GetIClassAnswer(uint8_t *receivedResponse, int maxLen, int *samples,
if(ManchesterDecoding(b & 0x0f)) { if(ManchesterDecoding(b & 0x0f)) {
*samples = c << 3; *samples = c << 3;
return TRUE; return true;
} }
} }
} }
@ -1577,7 +1578,7 @@ void setupIclassReader()
FpgaDownloadAndGo(FPGA_BITSTREAM_HF); FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
// Reset trace buffer // Reset trace buffer
clear_trace(); clear_trace();
set_tracing(TRUE); set_tracing(true);
// Setup SSC // Setup SSC
FpgaSetupSsc(); FpgaSetupSsc();
@ -1675,34 +1676,37 @@ uint8_t handshakeIclassTag(uint8_t *card_data){
// Reader iClass Anticollission // Reader iClass Anticollission
void ReaderIClass(uint8_t arg0) { void ReaderIClass(uint8_t arg0) {
uint8_t card_data[6 * 8]={0}; uint8_t card_data[6 * 8] = {0};
memset(card_data, 0xFF, sizeof(card_data)); memset(card_data, 0xFF, sizeof(card_data));
uint8_t last_csn[8]={0}; uint8_t last_csn[8] = {0};
//Read conf block CRC(0x01) => 0xfa 0x22 //Read conf block CRC(0x01) => 0xfa 0x22
uint8_t readConf[] = { ICLASS_CMD_READ_OR_IDENTIFY,0x01, 0xfa, 0x22}; uint8_t readConf[] = { ICLASS_CMD_READ_OR_IDENTIFY, 0x01, 0xfa, 0x22};
//Read conf block CRC(0x05) => 0xde 0x64 //Read conf block CRC(0x05) => 0xde 0x64
uint8_t readAA[] = { ICLASS_CMD_READ_OR_IDENTIFY,0x05, 0xde, 0x64}; uint8_t readAA[] = { ICLASS_CMD_READ_OR_IDENTIFY, 0x05, 0xde, 0x64};
int read_status= 0; int read_status= 0;
uint8_t result_status = 0; uint8_t result_status = 0;
bool abort_after_read = arg0 & FLAG_ICLASS_READER_ONLY_ONCE; bool abort_after_read = arg0 & FLAG_ICLASS_READER_ONLY_ONCE;
bool try_once = arg0 & FLAG_ICLASS_READER_ONE_TRY; bool try_once = arg0 & FLAG_ICLASS_READER_ONE_TRY;
bool use_credit_key = false; bool use_credit_key = false;
if (arg0 & FLAG_ICLASS_READER_CEDITKEY) uint16_t tryCnt = 0;
if ((arg0 & FLAG_ICLASS_READER_CEDITKEY) == FLAG_ICLASS_READER_CEDITKEY)
use_credit_key = true; use_credit_key = true;
set_tracing(TRUE);
set_tracing(true);
setupIclassReader(); setupIclassReader();
uint16_t tryCnt=0; bool userCancelled = BUTTON_PRESS() || usb_poll_validate_length();
while(!BUTTON_PRESS()) while (!userCancelled) {
{ // if only looking for one card try 2 times if we missed it the first time
if (try_once && tryCnt > 5) break; if (try_once && tryCnt > 2) break;
tryCnt++; tryCnt++;
if(!tracing) { if (!tracing) {
DbpString("Trace full"); DbpString("Trace full");
break; break;
} }
@ -1710,19 +1714,17 @@ void ReaderIClass(uint8_t arg0) {
read_status = handshakeIclassTag_ext(card_data, use_credit_key); read_status = handshakeIclassTag_ext(card_data, use_credit_key);
if(read_status == 0) continue; if (read_status == 0) continue;
if(read_status == 1) result_status = FLAG_ICLASS_READER_CSN; if (read_status == 1) result_status = FLAG_ICLASS_READER_CSN;
if(read_status == 2) result_status = FLAG_ICLASS_READER_CSN|FLAG_ICLASS_READER_CC; if (read_status == 2) result_status = FLAG_ICLASS_READER_CSN | FLAG_ICLASS_READER_CC;
// handshakeIclass returns CSN|CC, but the actual block // handshakeIclass returns CSN|CC, but the actual block
// layout is CSN|CONFIG|CC, so here we reorder the data, // layout is CSN|CONFIG|CC, so here we reorder the data,
// moving CC forward 8 bytes // moving CC forward 8 bytes
memcpy(card_data+16,card_data+8, 8); memcpy(card_data+16, card_data+8, 8);
//Read block 1, config //Read block 1, config
if(arg0 & FLAG_ICLASS_READER_CONF) if ( (arg0 & FLAG_ICLASS_READER_CONF) == FLAG_ICLASS_READER_CONF ) {
{ if (sendCmdGetResponseWithRetries(readConf, sizeof(readConf), card_data+8, 10, 10)) {
if(sendCmdGetResponseWithRetries(readConf, sizeof(readConf),card_data+8, 10, 10))
{
result_status |= FLAG_ICLASS_READER_CONF; result_status |= FLAG_ICLASS_READER_CONF;
} else { } else {
Dbprintf("Failed to dump config block"); Dbprintf("Failed to dump config block");
@ -1730,9 +1732,8 @@ void ReaderIClass(uint8_t arg0) {
} }
//Read block 5, AA //Read block 5, AA
if(arg0 & FLAG_ICLASS_READER_AA){ if ( (arg0 & FLAG_ICLASS_READER_AA) == FLAG_ICLASS_READER_AA ) {
if(sendCmdGetResponseWithRetries(readAA, sizeof(readAA),card_data+(8*4), 10, 10)) if (sendCmdGetResponseWithRetries(readAA, sizeof(readAA), card_data+(8*5), 10, 10)) {
{
result_status |= FLAG_ICLASS_READER_AA; result_status |= FLAG_ICLASS_READER_AA;
} else { } else {
//Dbprintf("Failed to dump AA block"); //Dbprintf("Failed to dump AA block");
@ -1748,16 +1749,16 @@ void ReaderIClass(uint8_t arg0) {
//Then we can 'ship' back the 8 * 5 bytes of data, //Then we can 'ship' back the 8 * 5 bytes of data,
// with 0xFF:s in block 3 and 4. // with 0xFF:s in block 3 and 4.
LED_B_ON(); LED_B_ON();
//Send back to client, but don't bother if we already sent this //Send back to client, but don't bother if we already sent this
if(memcmp(last_csn, card_data, 8) != 0) if(memcmp(last_csn, card_data, 8) != 0) {
{
// If caller requires that we get CC, continue until we got it // If caller requires that we get CC, continue until we got it
// only useful if looping in arm (not try_once && not abort_after_read)
if( (arg0 & read_status & FLAG_ICLASS_READER_CC) || !(arg0 & FLAG_ICLASS_READER_CC)) if( (arg0 & read_status & FLAG_ICLASS_READER_CC) || !(arg0 & FLAG_ICLASS_READER_CC))
{ {
cmd_send(CMD_ACK,result_status,0,0,card_data,sizeof(card_data)); cmd_send(CMD_ACK, result_status, 0, 0, card_data, sizeof(card_data) );
if(abort_after_read) { if (abort_after_read) {
LED_A_OFF(); LEDsoff();
set_tracing(FALSE); set_tracing(FALSE);
return; return;
} }
@ -1766,9 +1767,15 @@ void ReaderIClass(uint8_t arg0) {
} }
} }
LED_B_OFF(); LED_B_OFF();
} userCancelled = BUTTON_PRESS() || usb_poll_validate_length();
cmd_send(CMD_ACK,0,0,0,card_data, 0); }
LED_A_OFF();
if (userCancelled)
cmd_send(CMD_ACK, 0xFF, 0, 0, card_data, 0);
else
cmd_send(CMD_ACK, 0, 0, 0, card_data, 0);
LEDsoff();
set_tracing(FALSE); set_tracing(FALSE);
} }
@ -1803,7 +1810,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
uint8_t resp[ICLASS_BUFFER_SIZE]; uint8_t resp[ICLASS_BUFFER_SIZE];
setupIclassReader(); setupIclassReader();
set_tracing(TRUE); set_tracing(true);
while(!BUTTON_PRESS()) { while(!BUTTON_PRESS()) {

90
armsrc/iso14443a.c
View file

@ -1,4 +1,4 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Merlok - June 2011, 2012 // Merlok - June 2011, 2012
// Gerhard de Koning Gans - May 2008 // Gerhard de Koning Gans - May 2008
// Hagen Fritsch - June 2010 // Hagen Fritsch - June 2010
@ -242,10 +242,8 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time) {
// Sequence X followed by Sequence Y followed by Sequence Z (111100x1 11111111 00x11111) // Sequence X followed by Sequence Y followed by Sequence Z (111100x1 11111111 00x11111)
// we therefore look for a ...xx1111 11111111 00x11111xxxxxx... pattern // we therefore look for a ...xx1111 11111111 00x11111xxxxxx... pattern
// (12 '1's followed by 2 '0's, eventually followed by another '0', followed by 5 '1's) // (12 '1's followed by 2 '0's, eventually followed by another '0', followed by 5 '1's)
// #define ISO14443A_STARTBIT_MASK 0x07FFEF80 // mask is 00000111 11111111 11101111 10000000
#define ISO14443A_STARTBIT_MASK 0x07FFEF80 // mask is 00001111 11111111 1110 1111 10000000 #define ISO14443A_STARTBIT_PATTERN 0x07FF8F80 // pattern is 00000111 11111111 10001111 10000000
#define ISO14443A_STARTBIT_PATTERN 0x07FF8F80 // pattern is 00001111 11111111 1000 1111 10000000
if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 0)) == ISO14443A_STARTBIT_PATTERN >> 0) Uart.syncBit = 7; if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 0)) == ISO14443A_STARTBIT_PATTERN >> 0) Uart.syncBit = 7;
else if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 1)) == ISO14443A_STARTBIT_PATTERN >> 1) Uart.syncBit = 6; else if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 1)) == ISO14443A_STARTBIT_PATTERN >> 1) Uart.syncBit = 6;
else if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 2)) == ISO14443A_STARTBIT_PATTERN >> 2) Uart.syncBit = 5; else if ((Uart.fourBits & (ISO14443A_STARTBIT_MASK >> 2)) == ISO14443A_STARTBIT_PATTERN >> 2) Uart.syncBit = 5;
@ -714,7 +712,7 @@ static void CodeIso14443aAsTagPar(const uint8_t *cmd, uint16_t len, uint8_t *par
ToSend[++ToSendMax] = SEC_F; ToSend[++ToSendMax] = SEC_F;
// Convert from last byte pos to length // Convert from last byte pos to length
++ToSendMax; ToSendMax++;
} }
static void CodeIso14443aAsTag(const uint8_t *cmd, uint16_t len) { static void CodeIso14443aAsTag(const uint8_t *cmd, uint16_t len) {
@ -1409,12 +1407,12 @@ void PrepareDelayedTransfer(uint16_t delay) {
uint8_t bits_shifted = 0; uint8_t bits_shifted = 0;
uint16_t i = 0; uint16_t i = 0;
for (i = 0; i < delay; ++i) for (i = 0; i < delay; i++)
bitmask |= (0x01 << i); bitmask |= (0x01 << i);
ToSend[ToSendMax++] = 0x00; ToSend[ToSendMax++] = 0x00;
for (i = 0; i < ToSendMax; ++i) { for (i = 0; i < ToSendMax; i++) {
bits_to_shift = ToSend[i] & bitmask; bits_to_shift = ToSend[i] & bitmask;
ToSend[i] = ToSend[i] >> delay; ToSend[i] = ToSend[i] >> delay;
ToSend[i] = ToSend[i] | (bits_shifted << (8 - delay)); ToSend[i] = ToSend[i] | (bits_shifted << (8 - delay));
@ -1432,6 +1430,7 @@ void PrepareDelayedTransfer(uint16_t delay) {
// if != 0: delay transfer until time specified // if != 0: delay transfer until time specified
//------------------------------------------------------------------------------------- //-------------------------------------------------------------------------------------
static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing) { static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing) {
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD); FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
uint32_t ThisTransferTime = 0; uint32_t ThisTransferTime = 0;
@ -1460,7 +1459,7 @@ static void TransmitFor14443a(const uint8_t *cmd, uint16_t len, uint32_t *timing
for(;;) { for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) { if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = cmd[c]; AT91C_BASE_SSC->SSC_THR = cmd[c];
++c; c++;
if(c >= len) if(c >= len)
break; break;
} }
@ -1770,9 +1769,9 @@ static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receive
for(;;) { for(;;) {
WDT_HIT(); WDT_HIT();
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) { if (AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
b = (uint8_t)AT91C_BASE_SSC->SSC_RHR; b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
if(ManchesterDecoding(b, offset, 0)) { if (ManchesterDecoding(b, offset, 0)) {
NextTransferTime = MAX(NextTransferTime, Demod.endTime - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/16 + FRAME_DELAY_TIME_PICC_TO_PCD); NextTransferTime = MAX(NextTransferTime, Demod.endTime - (DELAY_AIR2ARM_AS_READER + DELAY_ARM2AIR_AS_READER)/16 + FRAME_DELAY_TIME_PICC_TO_PCD);
return true; return true;
} else if (c++ > iso14a_timeout && Demod.state == DEMOD_UNSYNCD) { } else if (c++ > iso14a_timeout && Demod.state == DEMOD_UNSYNCD) {
@ -1829,14 +1828,14 @@ int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity) {
// fills the card info record unless NULL // fills the card info record unless NULL
// if anticollision is false, then the UID must be provided in uid_ptr[] // if anticollision is false, then the UID must be provided in uid_ptr[]
// and num_cascades must be set (1: 4 Byte UID, 2: 7 Byte UID, 3: 10 Byte UID) // and num_cascades must be set (1: 4 Byte UID, 2: 7 Byte UID, 3: 10 Byte UID)
int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, uint32_t *cuid_ptr, bool anticollision, uint8_t num_cascades) { int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_card, uint32_t *cuid_ptr, bool anticollision, uint8_t num_cascades) {
uint8_t wupa[] = { ISO14443A_CMD_WUPA }; // 0x26 - ISO14443A_CMD_REQA 0x52 - ISO14443A_CMD_WUPA uint8_t wupa[] = { ISO14443A_CMD_WUPA }; // 0x26 - ISO14443A_CMD_REQA 0x52 - ISO14443A_CMD_WUPA
uint8_t sel_all[] = { ISO14443A_CMD_ANTICOLL_OR_SELECT,0x20 }; uint8_t sel_all[] = { ISO14443A_CMD_ANTICOLL_OR_SELECT,0x20 };
uint8_t sel_uid[] = { ISO14443A_CMD_ANTICOLL_OR_SELECT,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00}; uint8_t sel_uid[] = { ISO14443A_CMD_ANTICOLL_OR_SELECT,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
uint8_t rats[] = { ISO14443A_CMD_RATS,0x80,0x00,0x00 }; // FSD=256, FSDI=8, CID=0 uint8_t rats[] = { ISO14443A_CMD_RATS,0x80,0x00,0x00 }; // FSD=256, FSDI=8, CID=0
uint8_t resp[MAX_FRAME_SIZE] = {0}; // theoretically. A usual RATS will be much smaller uint8_t resp[MAX_FRAME_SIZE] = {0}; // theoretically. A usual RATS will be much smaller
uint8_t resp_par[MAX_PARITY_SIZE] = {0}; uint8_t resp_par[MAX_PARITY_SIZE] = {0};
byte_t uid_resp[4] = {0}; uint8_t uid_resp[4] = {0};
size_t uid_resp_len = 0; size_t uid_resp_len = 0;
uint8_t sak = 0x04; // cascade uid uint8_t sak = 0x04; // cascade uid
@ -1849,10 +1848,10 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
// Receive the ATQA // Receive the ATQA
if(!ReaderReceive(resp, resp_par)) return 0; if(!ReaderReceive(resp, resp_par)) return 0;
if(p_hi14a_card) { if(p_card) {
memcpy(p_hi14a_card->atqa, resp, 2); memcpy(p_card->atqa, resp, 2);
p_hi14a_card->uidlen = 0; p_card->uidlen = 0;
memset(p_hi14a_card->uid,0,10); memset(p_card->uid,0,10);
} }
if (anticollision) { if (anticollision) {
@ -1950,15 +1949,15 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
if(uid_ptr && anticollision) if(uid_ptr && anticollision)
memcpy(uid_ptr + (cascade_level*3), uid_resp, uid_resp_len); memcpy(uid_ptr + (cascade_level*3), uid_resp, uid_resp_len);
if(p_hi14a_card) { if(p_card) {
memcpy(p_hi14a_card->uid + (cascade_level*3), uid_resp, uid_resp_len); memcpy(p_card->uid + (cascade_level*3), uid_resp, uid_resp_len);
p_hi14a_card->uidlen += uid_resp_len; p_card->uidlen += uid_resp_len;
} }
} }
if(p_hi14a_card) { if(p_card) {
p_hi14a_card->sak = sak; p_card->sak = sak;
p_hi14a_card->ats_len = 0; p_card->ats_len = 0;
} }
// non iso14443a compliant tag // non iso14443a compliant tag
@ -1970,9 +1969,9 @@ int iso14443a_select_card(byte_t *uid_ptr, iso14a_card_select_t *p_hi14a_card, u
if (!(len = ReaderReceive(resp, resp_par))) return 0; if (!(len = ReaderReceive(resp, resp_par))) return 0;
if(p_hi14a_card) { if(p_card) {
memcpy(p_hi14a_card->ats, resp, sizeof(p_hi14a_card->ats)); memcpy(p_card->ats, resp, sizeof(p_card->ats));
p_hi14a_card->ats_len = len; p_card->ats_len = len;
} }
// set default timeout based on ATS // set default timeout based on ATS
@ -2035,7 +2034,6 @@ int iso14_apdu(uint8_t *cmd, uint16_t cmd_len, void *data) {
return len; return len;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Read an ISO 14443a tag. Send out commands and store answers. // Read an ISO 14443a tag. Send out commands and store answers.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -2051,46 +2049,45 @@ void ReaderIso14443a(UsbCommand *c) {
uint32_t timeout = c->arg[2]; uint32_t timeout = c->arg[2];
uint8_t *cmd = c->d.asBytes; uint8_t *cmd = c->d.asBytes;
uint32_t arg0 = 0; uint32_t arg0 = 0;
byte_t buf[USB_CMD_DATA_SIZE] = {0x00}; uint8_t buf[USB_CMD_DATA_SIZE] = {0x00};
uint8_t par[MAX_PARITY_SIZE] = {0x00}; uint8_t par[MAX_PARITY_SIZE] = {0x00};
if ((param & ISO14A_CONNECT) == ISO14A_CONNECT) if ((param & ISO14A_CONNECT))
clear_trace(); clear_trace();
set_tracing(true); set_tracing(true);
if ((param & ISO14A_REQUEST_TRIGGER) == ISO14A_REQUEST_TRIGGER) if ((param & ISO14A_REQUEST_TRIGGER))
iso14a_set_trigger(TRUE); iso14a_set_trigger(true);
if ((param & ISO14A_CONNECT) == ISO14A_CONNECT) { if ((param & ISO14A_CONNECT)) {
iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN); iso14443a_setup(FPGA_HF_ISO14443A_READER_LISTEN);
// notify client selecting status. // notify client selecting status.
// if failed selecting, turn off antenna and quite. // if failed selecting, turn off antenna and quite.
if((param & ISO14A_NO_SELECT) != ISO14A_NO_SELECT) { if( !(param & ISO14A_NO_SELECT) ) {
iso14a_card_select_t *card = (iso14a_card_select_t*)buf; iso14a_card_select_t *card = (iso14a_card_select_t*)buf;
arg0 = iso14443a_select_card(NULL, card, NULL, true, 0); arg0 = iso14443a_select_card(NULL, card, NULL, true, 0);
cmd_send(CMD_ACK, arg0, card->uidlen, 0, buf, sizeof(iso14a_card_select_t)); cmd_send(CMD_ACK, arg0, card->uidlen, 0, buf, sizeof(iso14a_card_select_t));
if ( arg0 == 0 ) if ( arg0 == 0 )
goto OUT; goto OUT;
} }
} }
if ((param & ISO14A_SET_TIMEOUT) == ISO14A_SET_TIMEOUT) if ((param & ISO14A_SET_TIMEOUT))
iso14a_set_timeout(timeout); iso14a_set_timeout(timeout);
if ((param & ISO14A_APDU) == ISO14A_APDU) { if ((param & ISO14A_APDU)) {
arg0 = iso14_apdu(cmd, len, buf); arg0 = iso14_apdu(cmd, len, buf);
cmd_send(CMD_ACK, arg0, 0, 0, buf, sizeof(buf)); cmd_send(CMD_ACK, arg0, 0, 0, buf, sizeof(buf));
} }
if ((param & ISO14A_RAW) == ISO14A_RAW) { if ((param & ISO14A_RAW)) {
if ((param & ISO14A_APPEND_CRC) == ISO14A_APPEND_CRC) { if ((param & ISO14A_APPEND_CRC)) {
// Don't append crc on empty bytearray... // Don't append crc on empty bytearray...
if ( len > 0 ) { if ( len > 0 ) {
if ((param & ISO14A_TOPAZMODE) == ISO14A_TOPAZMODE) if ((param & ISO14A_TOPAZMODE))
AppendCrc14443b(cmd, len); AppendCrc14443b(cmd, len);
else else
AppendCrc14443a(cmd, len); AppendCrc14443a(cmd, len);
@ -2101,7 +2098,7 @@ void ReaderIso14443a(UsbCommand *c) {
} }
if (lenbits > 0) { // want to send a specific number of bits (e.g. short commands) if (lenbits > 0) { // want to send a specific number of bits (e.g. short commands)
if ((param & ISO14A_TOPAZMODE) == ISO14A_TOPAZMODE) { if ((param & ISO14A_TOPAZMODE)) {
int bits_to_send = lenbits; int bits_to_send = lenbits;
uint16_t i = 0; uint16_t i = 0;
ReaderTransmitBitsPar(&cmd[i++], MIN(bits_to_send, 7), NULL, NULL); // first byte is always short (7bits) and no parity ReaderTransmitBitsPar(&cmd[i++], MIN(bits_to_send, 7), NULL, NULL); // first byte is always short (7bits) and no parity
@ -2115,7 +2112,7 @@ void ReaderIso14443a(UsbCommand *c) {
ReaderTransmitBitsPar(cmd, lenbits, par, NULL); // bytes are 8 bit with odd parity ReaderTransmitBitsPar(cmd, lenbits, par, NULL); // bytes are 8 bit with odd parity
} }
} else { // want to send complete bytes only } else { // want to send complete bytes only
if ((param & ISO14A_TOPAZMODE) == ISO14A_TOPAZMODE) { if ((param & ISO14A_TOPAZMODE)) {
uint16_t i = 0; uint16_t i = 0;
ReaderTransmitBitsPar(&cmd[i++], 7, NULL, NULL); // first byte: 7 bits, no paritiy ReaderTransmitBitsPar(&cmd[i++], 7, NULL, NULL); // first byte: 7 bits, no paritiy
while (i < len) { while (i < len) {
@ -2129,14 +2126,15 @@ void ReaderIso14443a(UsbCommand *c) {
cmd_send(CMD_ACK, arg0, 0, 0, buf, sizeof(buf)); cmd_send(CMD_ACK, arg0, 0, 0, buf, sizeof(buf));
} }
if ((param & ISO14A_REQUEST_TRIGGER) == ISO14A_REQUEST_TRIGGER) if ((param & ISO14A_REQUEST_TRIGGER))
iso14a_set_trigger(false); iso14a_set_trigger(false);
if ((param & ISO14A_NO_DISCONNECT) == ISO14A_NO_DISCONNECT) if ((param & ISO14A_NO_DISCONNECT))
return; return;
OUT: OUT:
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
SpinDelay(200);
set_tracing(false); set_tracing(false);
LEDsoff(); LEDsoff();
} }
@ -2192,7 +2190,7 @@ void ReaderMifare(bool first_try, uint8_t block, uint8_t keytype ) {
uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00}; uint8_t receivedAnswer[MAX_MIFARE_FRAME_SIZE] = {0x00};
uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00}; uint8_t receivedAnswerPar[MAX_MIFARE_PARITY_SIZE] = {0x00};
uint8_t par[1] = {0}; // maximum 8 Bytes to be sent here, 1 byte parity is therefore enough uint8_t par[1] = {0}; // maximum 8 Bytes to be sent here, 1 byte parity is therefore enough
byte_t nt_diff = 0; uint8_t nt_diff = 0;
uint32_t nt = 0; uint32_t nt = 0;
uint32_t previous_nt = 0; uint32_t previous_nt = 0;
uint32_t cuid = 0; uint32_t cuid = 0;

30
armsrc/iso14443b.c
View file

@ -420,7 +420,7 @@ static RAMFUNC int Handle14443bReaderUartBit(uint8_t bit) {
LED_A_OFF(); // Finished receiving LED_A_OFF(); // Finished receiving
Uart.state = STATE_UNSYNCD; Uart.state = STATE_UNSYNCD;
if (Uart.byteCnt != 0) if (Uart.byteCnt != 0)
return TRUE; return true;
} else { } else {
// this is an error // this is an error
@ -479,7 +479,7 @@ static int GetIso14443bCommandFromReader(uint8_t *received, uint16_t *len) {
for ( mask = 0x80; mask != 0; mask >>= 1) { for ( mask = 0x80; mask != 0; mask >>= 1) {
if ( Handle14443bReaderUartBit(b & mask)) { if ( Handle14443bReaderUartBit(b & mask)) {
*len = Uart.byteCnt; *len = Uart.byteCnt;
return TRUE; return true;
} }
} }
} }
@ -564,7 +564,7 @@ void SimulateIso14443bTag(uint32_t pupi) {
BigBuf_free(); BigBuf_free();
BigBuf_Clear_ext(false); BigBuf_Clear_ext(false);
clear_trace(); //sim clear_trace(); //sim
set_tracing(TRUE); set_tracing(true);
// connect Demodulated Signal to ADC: // connect Demodulated Signal to ADC:
SetAdcMuxFor(GPIO_MUXSEL_HIPKD); SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
@ -643,7 +643,7 @@ void SimulateIso14443bTag(uint32_t pupi) {
if (len == 5 ) { if (len == 5 ) {
if ( (receivedCmd[0] == ISO14443B_REQB && (receivedCmd[2] & 0x8)== 0x8 && cardSTATE == SIM_HALTED) || if ( (receivedCmd[0] == ISO14443B_REQB && (receivedCmd[2] & 0x8)== 0x8 && cardSTATE == SIM_HALTED) ||
receivedCmd[0] == ISO14443B_REQB ){ receivedCmd[0] == ISO14443B_REQB ){
LogTrace(receivedCmd, len, 0, 0, NULL, TRUE); LogTrace(receivedCmd, len, 0, 0, NULL, true);
cardSTATE = SIM_SELECTING; cardSTATE = SIM_SELECTING;
} }
} }
@ -662,7 +662,7 @@ void SimulateIso14443bTag(uint32_t pupi) {
//case SIM_NOFIELD: //case SIM_NOFIELD:
case SIM_HALTED: case SIM_HALTED:
case SIM_IDLE: { case SIM_IDLE: {
LogTrace(receivedCmd, len, 0, 0, NULL, TRUE); LogTrace(receivedCmd, len, 0, 0, NULL, true);
break; break;
} }
case SIM_SELECTING: { case SIM_SELECTING: {
@ -928,7 +928,7 @@ static RAMFUNC int Handle14443bTagSamplesDemod(int ci, int cq) {
LED_C_OFF(); LED_C_OFF();
// This is EOF (start, stop and all data bits == '0' // This is EOF (start, stop and all data bits == '0'
if (s == 0) return TRUE; if (s == 0) return true;
} }
} }
Demod.posCount = 0; Demod.posCount = 0;
@ -1168,7 +1168,7 @@ static void CodeAndTransmit14443bAsReader(const uint8_t *cmd, int len) {
if(trigger) LED_A_ON(); if(trigger) LED_A_ON();
LogTrace(cmd, len, time_start, GetCountSspClk()-time_start, NULL, TRUE); LogTrace(cmd, len, time_start, GetCountSspClk()-time_start, NULL, true);
} }
/* Sends an APDU to the tag /* Sends an APDU to the tag
@ -1388,7 +1388,7 @@ void ReadSTMemoryIso14443b(uint8_t numofblocks)
// confusing things will happen if we don't reset them between reads. // confusing things will happen if we don't reset them between reads.
switch_off(); // before ReadStMemory switch_off(); // before ReadStMemory
set_tracing(TRUE); set_tracing(true);
uint8_t i = 0x00; uint8_t i = 0x00;
@ -1510,7 +1510,7 @@ static void iso1444b_setup_snoop(void){
BigBuf_free(); BigBuf_free();
BigBuf_Clear_ext(false); BigBuf_Clear_ext(false);
clear_trace();//setup snoop clear_trace();//setup snoop
set_tracing(TRUE); set_tracing(true);
// Initialize Demod and Uart structs // Initialize Demod and Uart structs
DemodInit(BigBuf_malloc(MAX_FRAME_SIZE)); DemodInit(BigBuf_malloc(MAX_FRAME_SIZE));
@ -1566,7 +1566,7 @@ void RAMFUNC SnoopIso14443b(void) {
// We won't start recording the frames that we acquire until we trigger; // We won't start recording the frames that we acquire until we trigger;
// a good trigger condition to get started is probably when we see a // a good trigger condition to get started is probably when we see a
// response from the tag. // response from the tag.
bool triggered = TRUE; // TODO: set and evaluate trigger condition bool triggered = true; // TODO: set and evaluate trigger condition
bool TagIsActive = FALSE; bool TagIsActive = FALSE;
bool ReaderIsActive = FALSE; bool ReaderIsActive = FALSE;
@ -1622,7 +1622,7 @@ void RAMFUNC SnoopIso14443b(void) {
time_stop = GetCountSspClk() - time_0; time_stop = GetCountSspClk() - time_0;
if (triggered) if (triggered)
LogTrace(Uart.output, Uart.byteCnt, time_start, time_stop, NULL, TRUE); LogTrace(Uart.output, Uart.byteCnt, time_start, time_stop, NULL, true);
/* And ready to receive another command. */ /* And ready to receive another command. */
UartReset(); UartReset();
@ -1638,7 +1638,7 @@ void RAMFUNC SnoopIso14443b(void) {
time_stop = GetCountSspClk() - time_0; time_stop = GetCountSspClk() - time_0;
if (triggered) if (triggered)
LogTrace(Uart.output, Uart.byteCnt, time_start, time_stop, NULL, TRUE); LogTrace(Uart.output, Uart.byteCnt, time_start, time_stop, NULL, true);
/* And ready to receive another command. */ /* And ready to receive another command. */
UartReset(); UartReset();
@ -1662,7 +1662,7 @@ void RAMFUNC SnoopIso14443b(void) {
LogTrace(Demod.output, Demod.len, time_start, time_stop, NULL, FALSE); LogTrace(Demod.output, Demod.len, time_start, time_stop, NULL, FALSE);
triggered = TRUE; triggered = true;
// And ready to receive another response. // And ready to receive another response.
DemodReset(); DemodReset();
@ -1713,7 +1713,7 @@ void SendRawCommand14443B_Ex(UsbCommand *c)
// turn on trigger (LED_A) // turn on trigger (LED_A)
if ((param & ISO14B_REQUEST_TRIGGER) == ISO14B_REQUEST_TRIGGER) if ((param & ISO14B_REQUEST_TRIGGER) == ISO14B_REQUEST_TRIGGER)
iso14b_set_trigger(TRUE); iso14b_set_trigger(true);
if ((param & ISO14B_CONNECT) == ISO14B_CONNECT) { if ((param & ISO14B_CONNECT) == ISO14B_CONNECT) {
// Make sure that we start from off, since the tags are stateful; // Make sure that we start from off, since the tags are stateful;
@ -1722,7 +1722,7 @@ void SendRawCommand14443B_Ex(UsbCommand *c)
iso14443b_setup(); iso14443b_setup();
} }
set_tracing(TRUE); set_tracing(true);
if ((param & ISO14B_SELECT_STD) == ISO14B_SELECT_STD) { if ((param & ISO14B_SELECT_STD) == ISO14B_SELECT_STD) {
iso14b_card_select_t *card = (iso14b_card_select_t*)buf; iso14b_card_select_t *card = (iso14b_card_select_t*)buf;

14
client/cmdhficlass.c
View file

@ -173,7 +173,7 @@ int usage_hf_iclass_managekeys(void) {
return 0; return 0;
} }
int usage_hf_iclass_reader(void) { int usage_hf_iclass_reader(void) {
PrintAndLog("HELP : Act as a Iclass reader:\n"); PrintAndLog("HELP : Act as a Iclass reader. Look for iClass tags until a key or the pm3 button is pressed\n");
PrintAndLog("Usage: hf iclass reader [h] [1]\n"); PrintAndLog("Usage: hf iclass reader [h] [1]\n");
PrintAndLog("Options:"); PrintAndLog("Options:");
PrintAndLog(" h This help text"); PrintAndLog(" h This help text");
@ -314,12 +314,11 @@ int CmdHFiClassSim(const char *Cmd) {
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(); clearCommandBuffer();
SendCommand(&c); SendCommand(&c);
if (WaitForResponseTimeout(CMD_ACK,&resp, 4500)) { if (WaitForResponseTimeout(CMD_ACK,&resp, 4500)) {
@ -327,8 +326,9 @@ int HFiClassReader(const char *Cmd, bool loop, bool verbose) {
uint8_t *data = resp.d.asBytes; uint8_t *data = resp.d.asBytes;
if (verbose) PrintAndLog("Readstatus:%02x", readStatus); if (verbose) PrintAndLog("Readstatus:%02x", readStatus);
if( readStatus == 0){ // no tag found or button pressed
//Aborted if( (readStatus == 0 && !loop) || readStatus == 0xFF) {
// abort
if (verbose) PrintAndLog("Quitting..."); if (verbose) PrintAndLog("Quitting...");
return 0; return 0;
} }
@ -1692,7 +1692,7 @@ static command_t CommandTable[] = {
{"loclass", CmdHFiClass_loclass, 1, "[options..] Use loclass to perform bruteforce of reader attack dump"}, {"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"}, {"managekeys", CmdHFiClassManageKeys, 1, "[options..] Manage the keys to use with iClass"},
{"readblk", CmdHFiClass_ReadBlock, 0, "[options..] Authenticate and Read iClass block"}, {"readblk", CmdHFiClass_ReadBlock, 0, "[options..] Authenticate and Read iClass block"},
{"reader", CmdHFiClassReader, 0, "Read an iClass tag"}, {"reader", CmdHFiClassReader, 0, "Act like an iClass reader"},
{"readtagfile", CmdHFiClassReadTagFile, 1, "[options..] Display Content from tagfile"}, {"readtagfile", CmdHFiClassReadTagFile, 1, "[options..] Display Content from tagfile"},
{"replay", CmdHFiClassReader_Replay, 0, "<mac> Read an iClass tag via Reply Attack"}, {"replay", CmdHFiClassReader_Replay, 0, "<mac> Read an iClass tag via Reply Attack"},
{"sim", CmdHFiClassSim, 0, "[options..] Simulate iClass tag"}, {"sim", CmdHFiClassSim, 0, "[options..] Simulate iClass tag"},

1
client/cmdhficlass.h
View file

@ -35,6 +35,7 @@
#include "cmdhfmfu.h" #include "cmdhfmfu.h"
#include "cmdhf.h" #include "cmdhf.h"
#include "protocols.h" // picopass structs, #include "protocols.h" // picopass structs,
#include "usb_cdc.h" // for usb_poll_validate_length
int CmdHFiClass(const char *Cmd); int CmdHFiClass(const char *Cmd);

2
client/flasher.c
View file

@ -17,6 +17,8 @@
#ifdef _WIN32 #ifdef _WIN32
# define unlink(x) # define unlink(x)
#else
# include <unistd.h>
#endif #endif
static serial_port sp; static serial_port sp;

2
client/graph.c
View file

@ -274,7 +274,7 @@ bool graphJustNoise(int *BitStream, int size)
{ {
//might not be high enough for noisy environments //might not be high enough for noisy environments
#define THRESHOLD 15; #define THRESHOLD 15;
bool isNoise = TRUE; bool isNoise = true;
for(int i=0; i < size && isNoise; i++){ for(int i=0; i < size && isNoise; i++){
isNoise = BitStream[i] < THRESHOLD; isNoise = BitStream[i] < THRESHOLD;
} }

12
client/mifarehost.c
View file

@ -701,4 +701,16 @@ bool detect_classic_prng(){
uint32_t nonce = bytes_to_num(respA.d.asBytes, respA.arg[0]); uint32_t nonce = bytes_to_num(respA.d.asBytes, respA.arg[0]);
return validate_prng_nonce(nonce); return validate_prng_nonce(nonce);
}
/* Detect Mifare Classic NACK bug
*
*/
bool detect_classic_nackbug(){
// get nonce?
// loop max 256 times,
// fixed nonce, different parity every call
return false;
} }

10
common/crc.c
View file

@ -93,7 +93,7 @@ static void print_crc(crc_t *crc) {
// width=8 poly=0x31 init=0x00 refin=true refout=true xorout=0x00 check=0xA1 name="CRC-8/MAXIM" // width=8 poly=0x31 init=0x00 refin=true refout=true xorout=0x00 check=0xA1 name="CRC-8/MAXIM"
uint32_t CRC8Maxim(uint8_t *buff, size_t size) { uint32_t CRC8Maxim(uint8_t *buff, size_t size) {
crc_t crc; crc_t crc;
crc_init_ref(&crc, 8, 0x31, 0, 0, TRUE, TRUE); crc_init_ref(&crc, 8, 0x31, 0, 0, true, true);
for ( int i=0; i < size; ++i) for ( int i=0; i < size; ++i)
crc_update2(&crc, buff[i], 8); crc_update2(&crc, buff[i], 8);
return crc_finish(&crc); return crc_finish(&crc);
@ -102,7 +102,7 @@ uint32_t CRC8Maxim(uint8_t *buff, size_t size) {
// width=4 poly=0xC, reversed poly=0x7 init=0x5 refin=true refout=true xorout=0x0000 check= name="CRC-4/LEGIC" // width=4 poly=0xC, reversed poly=0x7 init=0x5 refin=true refout=true xorout=0x0000 check= name="CRC-4/LEGIC"
uint32_t CRC4Legic(uint8_t *cmd, size_t size) { uint32_t CRC4Legic(uint8_t *cmd, size_t size) {
crc_t crc; crc_t crc;
crc_init_ref(&crc, 4, 0x19 >> 1, 0x5, 0, TRUE, TRUE); crc_init_ref(&crc, 4, 0x19 >> 1, 0x5, 0, true, true);
crc_update2(&crc, 1, 1); /* CMD_READ */ crc_update2(&crc, 1, 1); /* CMD_READ */
crc_update2(&crc, cmd[0], 8); crc_update2(&crc, cmd[0], 8);
crc_update2(&crc, cmd[1], 8); crc_update2(&crc, cmd[1], 8);
@ -112,7 +112,7 @@ uint32_t CRC4Legic(uint8_t *cmd, size_t size) {
// the CRC needs to be reversed before returned. // the CRC needs to be reversed before returned.
uint32_t CRC8Legic(uint8_t *buff, size_t size) { uint32_t CRC8Legic(uint8_t *buff, size_t size) {
crc_t crc; crc_t crc;
crc_init_ref(&crc, 8, 0x63, 0x55, 0, TRUE, TRUE); crc_init_ref(&crc, 8, 0x63, 0x55, 0, true, true);
for ( int i = 0; i < size; ++i) for ( int i = 0; i < size; ++i)
crc_update2(&crc, buff[i], 8); crc_update2(&crc, buff[i], 8);
return reflect(crc_finish(&crc), 8); return reflect(crc_finish(&crc), 8);
@ -127,7 +127,7 @@ uint32_t CRC16Legic(uint8_t *buff, size_t size, uint8_t uidcrc) {
//uint16_t initial = uidcrc; //uint16_t initial = uidcrc;
initial |= initial << 8; initial |= initial << 8;
crc_t crc; crc_t crc;
crc_init_ref(&crc, 16, CRC16_POLY_LEGIC, initial, 0, TRUE, TRUE); crc_init_ref(&crc, 16, CRC16_POLY_LEGIC, initial, 0, true, true);
for ( int i=0; i < size; ++i) for ( int i=0; i < size; ++i)
crc_update(&crc, buff[i], 8); crc_update(&crc, buff[i], 8);
return reflect(crc_finish(&crc), 16); return reflect(crc_finish(&crc), 16);
@ -136,7 +136,7 @@ uint32_t CRC16Legic(uint8_t *buff, size_t size, uint8_t uidcrc) {
//w=16 poly=0x3d65 init=0x0000 refin=true refout=true xorout=0xffff check=0xea82 name="CRC-16/DNP" //w=16 poly=0x3d65 init=0x0000 refin=true refout=true xorout=0xffff check=0xea82 name="CRC-16/DNP"
uint32_t CRC16_DNP(uint8_t *buff, size_t size) { uint32_t CRC16_DNP(uint8_t *buff, size_t size) {
crc_t crc; crc_t crc;
crc_init_ref(&crc, 16, 0x3d65, 0, 0xffff, TRUE, TRUE); crc_init_ref(&crc, 16, 0x3d65, 0, 0xffff, true, true);
for ( int i=0; i < size; ++i) for ( int i=0; i < size; ++i)
crc_update2(&crc, buff[i], 8); crc_update2(&crc, buff[i], 8);