mirror of
https://github.com/Proxmark/proxmark3.git
synced 2025-02-23 18:27:28 -08:00
Code cleanup (#616)
* coverity fixes (including a real bug in cmdhftopaz.c) * Typo fix * replace TRUE/FALSE by stdbool true/false
This commit is contained in:
parent
2bb7f7e327
commit
44964fd181
112
armsrc/appmain.c
112
armsrc/appmain.c
@ -394,8 +394,8 @@ void StandAloneMode14a()
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
|
||||
int selected = 0;
|
||||
int playing = 0, iGotoRecord = 0, iGotoClone = 0;
|
||||
int cardRead[OPTS] = {0};
|
||||
bool playing = false, GotoRecord = false, GotoClone = false;
|
||||
bool cardRead[OPTS] = {false};
|
||||
uint8_t readUID[10] = {0};
|
||||
uint32_t uid_1st[OPTS]={0};
|
||||
uint32_t uid_2nd[OPTS]={0};
|
||||
@ -411,9 +411,9 @@ void StandAloneMode14a()
|
||||
WDT_HIT();
|
||||
SpinDelay(300);
|
||||
|
||||
if (iGotoRecord == 1 || cardRead[selected] == 0)
|
||||
if (GotoRecord || !cardRead[selected])
|
||||
{
|
||||
iGotoRecord = 0;
|
||||
GotoRecord = false;
|
||||
LEDsoff();
|
||||
LED(selected + 1, 0);
|
||||
LED(LED_RED2, 0);
|
||||
@ -438,7 +438,7 @@ void StandAloneMode14a()
|
||||
else if (cardRead[(selected+1)%OPTS]) {
|
||||
Dbprintf("Button press detected but no card in bank[%d] so playing from bank[%d]", selected, (selected+1)%OPTS);
|
||||
selected = (selected+1)%OPTS;
|
||||
break; // playing = 1;
|
||||
break;
|
||||
}
|
||||
else {
|
||||
Dbprintf("Button press detected but no stored tag to play. (Ignoring button)");
|
||||
@ -488,14 +488,14 @@ void StandAloneMode14a()
|
||||
LED(selected + 1, 0);
|
||||
|
||||
// Next state is replay:
|
||||
playing = 1;
|
||||
playing = true;
|
||||
|
||||
cardRead[selected] = 1;
|
||||
cardRead[selected] = true;
|
||||
}
|
||||
/* MF Classic UID clone */
|
||||
else if (iGotoClone==1)
|
||||
else if (GotoClone)
|
||||
{
|
||||
iGotoClone=0;
|
||||
GotoClone=false;
|
||||
LEDsoff();
|
||||
LED(selected + 1, 0);
|
||||
LED(LED_ORANGE, 250);
|
||||
@ -546,7 +546,7 @@ void StandAloneMode14a()
|
||||
MifareCGetBlock(0x3F, 1, 0, oldBlock0);
|
||||
if (oldBlock0[0] == 0 && oldBlock0[0] == oldBlock0[1] && oldBlock0[1] == oldBlock0[2] && oldBlock0[2] == oldBlock0[3]) {
|
||||
Dbprintf("No changeable tag detected. Returning to replay mode for bank[%d]", selected);
|
||||
playing = 1;
|
||||
playing = true;
|
||||
}
|
||||
else {
|
||||
Dbprintf("UID from target tag: %02X%02X%02X%02X", oldBlock0[0],oldBlock0[1],oldBlock0[2],oldBlock0[3]);
|
||||
@ -564,14 +564,14 @@ void StandAloneMode14a()
|
||||
if (memcmp(testBlock0,newBlock0,16)==0)
|
||||
{
|
||||
DbpString("Cloned successfull!");
|
||||
cardRead[selected] = 0; // Only if the card was cloned successfully should we clear it
|
||||
playing = 0;
|
||||
iGotoRecord = 1;
|
||||
cardRead[selected] = false; // Only if the card was cloned successfully should we clear it
|
||||
playing = false;
|
||||
GotoRecord = true;
|
||||
selected = (selected+1) % OPTS;
|
||||
}
|
||||
else {
|
||||
Dbprintf("Clone failed. Back to replay mode on bank[%d]", selected);
|
||||
playing = 1;
|
||||
playing = true;
|
||||
}
|
||||
}
|
||||
LEDsoff();
|
||||
@ -579,61 +579,55 @@ void StandAloneMode14a()
|
||||
|
||||
}
|
||||
// Change where to record (or begin playing)
|
||||
else if (playing==1) // button_pressed == BUTTON_SINGLE_CLICK && cardRead[selected])
|
||||
else if (playing) // button_pressed == BUTTON_SINGLE_CLICK && cardRead[selected])
|
||||
{
|
||||
LEDsoff();
|
||||
LED(selected + 1, 0);
|
||||
|
||||
// Begin transmitting
|
||||
if (playing)
|
||||
{
|
||||
LED(LED_GREEN, 0);
|
||||
DbpString("Playing");
|
||||
for ( ; ; ) {
|
||||
WDT_HIT();
|
||||
int button_action = BUTTON_HELD(1000);
|
||||
if (button_action == 0) { // No button action, proceed with sim
|
||||
uint8_t data[512] = {0}; // in case there is a read command received we shouldn't break
|
||||
Dbprintf("Simulating ISO14443a tag with uid[0]: %08x, uid[1]: %08x [Bank: %u]", uid_1st[selected],uid_2nd[selected],selected);
|
||||
if (hi14a_card[selected].sak == 8 && hi14a_card[selected].atqa[0] == 4 && hi14a_card[selected].atqa[1] == 0) {
|
||||
DbpString("Mifare Classic");
|
||||
SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data); // Mifare Classic
|
||||
}
|
||||
else if (hi14a_card[selected].sak == 0 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 0) {
|
||||
DbpString("Mifare Ultralight");
|
||||
SimulateIso14443aTag(2,uid_1st[selected],uid_2nd[selected],data); // Mifare Ultralight
|
||||
}
|
||||
else if (hi14a_card[selected].sak == 20 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 3) {
|
||||
DbpString("Mifare DESFire");
|
||||
SimulateIso14443aTag(3,uid_1st[selected],uid_2nd[selected],data); // Mifare DESFire
|
||||
}
|
||||
else {
|
||||
Dbprintf("Unrecognized tag type -- defaulting to Mifare Classic emulation");
|
||||
SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data);
|
||||
}
|
||||
LED(LED_GREEN, 0);
|
||||
DbpString("Playing");
|
||||
for ( ; ; ) {
|
||||
WDT_HIT();
|
||||
int button_action = BUTTON_HELD(1000);
|
||||
if (button_action == 0) { // No button action, proceed with sim
|
||||
uint8_t data[512] = {0}; // in case there is a read command received we shouldn't break
|
||||
Dbprintf("Simulating ISO14443a tag with uid[0]: %08x, uid[1]: %08x [Bank: %u]", uid_1st[selected],uid_2nd[selected],selected);
|
||||
if (hi14a_card[selected].sak == 8 && hi14a_card[selected].atqa[0] == 4 && hi14a_card[selected].atqa[1] == 0) {
|
||||
DbpString("Mifare Classic");
|
||||
SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data); // Mifare Classic
|
||||
}
|
||||
else if (button_action == BUTTON_SINGLE_CLICK) {
|
||||
selected = (selected + 1) % OPTS;
|
||||
Dbprintf("Done playing. Switching to record mode on bank %d",selected);
|
||||
iGotoRecord = 1;
|
||||
break;
|
||||
else if (hi14a_card[selected].sak == 0 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 0) {
|
||||
DbpString("Mifare Ultralight");
|
||||
SimulateIso14443aTag(2,uid_1st[selected],uid_2nd[selected],data); // Mifare Ultralight
|
||||
}
|
||||
else if (button_action == BUTTON_HOLD) {
|
||||
Dbprintf("Playtime over. Begin cloning...");
|
||||
iGotoClone = 1;
|
||||
break;
|
||||
else if (hi14a_card[selected].sak == 20 && hi14a_card[selected].atqa[0] == 0x44 && hi14a_card[selected].atqa[1] == 3) {
|
||||
DbpString("Mifare DESFire");
|
||||
SimulateIso14443aTag(3,uid_1st[selected],uid_2nd[selected],data); // Mifare DESFire
|
||||
}
|
||||
else {
|
||||
Dbprintf("Unrecognized tag type -- defaulting to Mifare Classic emulation");
|
||||
SimulateIso14443aTag(1,uid_1st[selected], uid_2nd[selected], data);
|
||||
}
|
||||
WDT_HIT();
|
||||
}
|
||||
|
||||
/* We pressed a button so ignore it here with a delay */
|
||||
SpinDelay(300);
|
||||
LEDsoff();
|
||||
LED(selected + 1, 0);
|
||||
else if (button_action == BUTTON_SINGLE_CLICK) {
|
||||
selected = (selected + 1) % OPTS;
|
||||
Dbprintf("Done playing. Switching to record mode on bank %d",selected);
|
||||
GotoRecord = true;
|
||||
break;
|
||||
}
|
||||
else if (button_action == BUTTON_HOLD) {
|
||||
Dbprintf("Playtime over. Begin cloning...");
|
||||
GotoClone = true;
|
||||
break;
|
||||
}
|
||||
WDT_HIT();
|
||||
}
|
||||
else
|
||||
while(BUTTON_PRESS())
|
||||
WDT_HIT();
|
||||
|
||||
/* We pressed a button so ignore it here with a delay */
|
||||
SpinDelay(300);
|
||||
LEDsoff();
|
||||
LED(selected + 1, 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -813,13 +813,13 @@ void SnoopHitag(uint32_t type) {
|
||||
int lastbit;
|
||||
bool bSkip;
|
||||
int tag_sof;
|
||||
byte_t rx[HITAG_FRAME_LEN];
|
||||
byte_t rx[HITAG_FRAME_LEN] = {0};
|
||||
size_t rxlen=0;
|
||||
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
auth_table_len = 0;
|
||||
@ -1032,7 +1032,7 @@ void SimulateHitagTag(bool tag_mem_supplied, byte_t* data) {
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
auth_table_len = 0;
|
||||
@ -1225,7 +1225,7 @@ void ReaderHitag(hitag_function htf, hitag_data* htd) {
|
||||
bSuccessful = false;
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
//DbpString("Starting Hitag reader family");
|
||||
@ -1548,7 +1548,7 @@ void WriterHitag(hitag_function htf, hitag_data* htd, int page) {
|
||||
bSuccessful = false;
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
//DbpString("Starting Hitag reader family");
|
||||
|
@ -210,7 +210,7 @@ static void hitag_send_bit(int bit) {
|
||||
;
|
||||
LOW(GPIO_SSC_DOUT);
|
||||
while (AT91C_BASE_TC0->TC_CV < T0 * 32)
|
||||
;;
|
||||
;
|
||||
}
|
||||
LED_A_OFF();
|
||||
break;
|
||||
@ -945,7 +945,6 @@ void SimulateHitagSTag(bool tag_mem_supplied, byte_t* data) {
|
||||
int i, j;
|
||||
byte_t rx[HITAG_FRAME_LEN];
|
||||
size_t rxlen = 0;
|
||||
//bool bQuitTraceFull = false;
|
||||
bQuiet = false;
|
||||
byte_t txbuf[HITAG_FRAME_LEN];
|
||||
byte_t* tx = txbuf;
|
||||
@ -953,7 +952,7 @@ void SimulateHitagSTag(bool tag_mem_supplied, byte_t* data) {
|
||||
BigBuf_free();
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
DbpString("Starting HitagS simulation");
|
||||
@ -1216,7 +1215,7 @@ void ReadHitagS(hitag_function htf, hitag_data* htd) {
|
||||
bSuccessful = false;
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
bQuiet = false;
|
||||
@ -1560,7 +1559,7 @@ void WritePageHitagS(hitag_function htf, hitag_data* htd,int page_) {
|
||||
tag.tstate = NO_OP;
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
bQuiet = false;
|
||||
@ -1847,7 +1846,7 @@ void check_challenges(bool file_given, byte_t* data) {
|
||||
bSuccessful = false;
|
||||
|
||||
// Clean up trace and prepare it for storing frames
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
bQuiet = false;
|
||||
|
@ -91,7 +91,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
|
||||
|
||||
if(!Uart.bitBuffer) {
|
||||
Uart.bitBuffer = bit ^ 0xFF0;
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
else {
|
||||
Uart.bitBuffer <<= 4;
|
||||
@ -102,7 +102,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
|
||||
Uart.output[Uart.byteCnt] = Uart.bitBuffer & 0xFF;
|
||||
Uart.byteCnt++;
|
||||
Uart.swapper = 0;
|
||||
if(Uart.byteCnt > 15) { return TRUE; }
|
||||
if(Uart.byteCnt > 15) { return true; }
|
||||
}
|
||||
else {
|
||||
Uart.swapper = 1;
|
||||
@ -139,12 +139,12 @@ static RAMFUNC int OutOfNDecoding(int bit)
|
||||
Uart.highCnt = 0;
|
||||
if(Uart.byteCnt == 0) {
|
||||
// Its not straightforward to show single EOFs
|
||||
// So just leave it and do not return TRUE
|
||||
// So just leave it and do not return true
|
||||
Uart.output[0] = 0xf0;
|
||||
Uart.byteCnt++;
|
||||
}
|
||||
else {
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else if(Uart.state != STATE_START_OF_COMMUNICATION) {
|
||||
@ -263,7 +263,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
|
||||
Uart.byteCnt++;
|
||||
Uart.output[Uart.byteCnt] = 0xAA;
|
||||
Uart.byteCnt++;
|
||||
return TRUE;
|
||||
return true;
|
||||
}*/
|
||||
}
|
||||
|
||||
@ -318,7 +318,7 @@ static RAMFUNC int OutOfNDecoding(int bit)
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
@ -371,7 +371,7 @@ static RAMFUNC int ManchesterDecoding(int v)
|
||||
|
||||
if(Demod.buff < 3) {
|
||||
Demod.buff++;
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
if(Demod.state==DEMOD_UNSYNCD) {
|
||||
@ -473,7 +473,7 @@ static RAMFUNC int ManchesterDecoding(int v)
|
||||
Demod.len++;
|
||||
Demod.state = DEMOD_UNSYNCD;
|
||||
// error = 0x0f;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
Demod.state = DEMOD_ERROR_WAIT;
|
||||
@ -557,7 +557,7 @@ static RAMFUNC int ManchesterDecoding(int v)
|
||||
}
|
||||
|
||||
Demod.state = DEMOD_UNSYNCD;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
Demod.output[Demod.len] = 0xad;
|
||||
@ -612,14 +612,14 @@ static RAMFUNC int ManchesterDecoding(int v)
|
||||
Demod.len++;
|
||||
Demod.output[Demod.len] = 0xBB;
|
||||
Demod.len++;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} // end (state != UNSYNCED)
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
//=============================================================================
|
||||
@ -639,7 +639,7 @@ void RAMFUNC SnoopIClass(void)
|
||||
// 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
|
||||
// response from the tag.
|
||||
//int triggered = FALSE; // FALSE to wait first for card
|
||||
//int triggered = false; // false to wait first for card
|
||||
|
||||
// The command (reader -> tag) that we're receiving.
|
||||
// The length of a received command will in most cases be no more than 18 bytes.
|
||||
@ -656,9 +656,9 @@ void RAMFUNC SnoopIClass(void)
|
||||
// The DMA buffer, used to stream samples from the FPGA
|
||||
uint8_t *dmaBuf = BigBuf_malloc(DMA_BUFFER_SIZE);
|
||||
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
iso14a_set_trigger(FALSE);
|
||||
iso14a_set_trigger(false);
|
||||
|
||||
int lastRxCounter;
|
||||
uint8_t *upTo;
|
||||
@ -749,12 +749,12 @@ void RAMFUNC SnoopIClass(void)
|
||||
time_stop = (GetCountSspClk()-time_0) << 4;
|
||||
LED_C_ON();
|
||||
|
||||
//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(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(tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
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);
|
||||
}
|
||||
|
||||
|
||||
@ -782,7 +782,7 @@ void RAMFUNC SnoopIClass(void)
|
||||
if(tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
GetParity(Demod.output, Demod.len, parity);
|
||||
LogTrace(Demod.output, Demod.len, time_start, time_stop, parity, FALSE);
|
||||
LogTrace(Demod.output, Demod.len, time_start, time_stop, parity, false);
|
||||
}
|
||||
|
||||
// And ready to receive another response.
|
||||
@ -830,7 +830,7 @@ void rotateCSN(uint8_t* originalCSN, uint8_t* rotatedCSN) {
|
||||
//-----------------------------------------------------------------------------
|
||||
// Wait for commands from reader
|
||||
// Stop when button is pressed
|
||||
// Or return TRUE when command is captured
|
||||
// Or return true when command is captured
|
||||
//-----------------------------------------------------------------------------
|
||||
static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen)
|
||||
{
|
||||
@ -848,7 +848,7 @@ static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen)
|
||||
for(;;) {
|
||||
WDT_HIT();
|
||||
|
||||
if(BUTTON_PRESS()) return FALSE;
|
||||
if(BUTTON_PRESS()) return false;
|
||||
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x00;
|
||||
@ -858,7 +858,7 @@ static int GetIClassCommandFromReader(uint8_t *received, int *len, int maxLen)
|
||||
|
||||
if(OutOfNDecoding(b & 0x0f)) {
|
||||
*len = Uart.byteCnt;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -993,7 +993,7 @@ void SimulateIClass(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
|
||||
// Enable and clear the trace
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
//Use the emulator memory for SIM
|
||||
uint8_t *emulator = BigBuf_get_EM_addr();
|
||||
@ -1325,11 +1325,11 @@ int doIClassSimulation( int simulationMode, uint8_t *reader_mac_buf)
|
||||
if (tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
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) {
|
||||
GetParity(trace_data, trace_data_size, parity);
|
||||
LogTrace(trace_data, trace_data_size, (t2r_time-time_0) << 4, (t2r_time-time_0) << 4, parity, FALSE);
|
||||
LogTrace(trace_data, trace_data_size, (t2r_time-time_0) << 4, (t2r_time-time_0) << 4, parity, false);
|
||||
}
|
||||
if(!tracing) {
|
||||
DbpString("Trace full");
|
||||
@ -1420,7 +1420,7 @@ static void TransmitIClassCommand(const uint8_t *cmd, int len, int *samples, int
|
||||
|
||||
|
||||
uint8_t sendbyte;
|
||||
bool firstpart = TRUE;
|
||||
bool firstpart = true;
|
||||
c = 0;
|
||||
for(;;) {
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
@ -1512,14 +1512,14 @@ void ReaderTransmitIClass(uint8_t* frame, int len)
|
||||
if (tracing) {
|
||||
uint8_t par[MAX_PARITY_SIZE];
|
||||
GetParity(frame, len, par);
|
||||
LogTrace(frame, len, rsamples, rsamples, par, TRUE);
|
||||
LogTrace(frame, len, rsamples, rsamples, par, true);
|
||||
}
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Wait a certain time for tag response
|
||||
// If a response is captured return TRUE
|
||||
// If it takes too long return FALSE
|
||||
// If a response is captured return true
|
||||
// If it takes too long return false
|
||||
//-----------------------------------------------------------------------------
|
||||
static int GetIClassAnswer(uint8_t *receivedResponse, int maxLen, int *samples, int *elapsed) //uint8_t *buffer
|
||||
{
|
||||
@ -1538,27 +1538,27 @@ static int GetIClassAnswer(uint8_t *receivedResponse, int maxLen, int *samples,
|
||||
uint8_t b;
|
||||
if (elapsed) *elapsed = 0;
|
||||
|
||||
bool skip = FALSE;
|
||||
bool skip = false;
|
||||
|
||||
c = 0;
|
||||
for(;;) {
|
||||
WDT_HIT();
|
||||
|
||||
if(BUTTON_PRESS()) return FALSE;
|
||||
if(BUTTON_PRESS()) return false;
|
||||
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x00; // To make use of exact timing of next command from reader!!
|
||||
if (elapsed) (*elapsed)++;
|
||||
}
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
|
||||
if(c < timeout) { c++; } else { return FALSE; }
|
||||
if(c < timeout) { c++; } else { return false; }
|
||||
b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
|
||||
skip = !skip;
|
||||
if(skip) continue;
|
||||
|
||||
if(ManchesterDecoding(b & 0x0f)) {
|
||||
*samples = c << 3;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1567,14 +1567,14 @@ static int GetIClassAnswer(uint8_t *receivedResponse, int maxLen, int *samples,
|
||||
int ReaderReceiveIClass(uint8_t* receivedAnswer)
|
||||
{
|
||||
int samples = 0;
|
||||
if (!GetIClassAnswer(receivedAnswer,160,&samples,0)) return FALSE;
|
||||
if (!GetIClassAnswer(receivedAnswer,160,&samples,0)) return false;
|
||||
rsamples += samples;
|
||||
if (tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
GetParity(receivedAnswer, Demod.len, parity);
|
||||
LogTrace(receivedAnswer,Demod.len,rsamples,rsamples,parity,FALSE);
|
||||
LogTrace(receivedAnswer,Demod.len,rsamples,rsamples,parity,false);
|
||||
}
|
||||
if(samples == 0) return FALSE;
|
||||
if(samples == 0) return false;
|
||||
return Demod.len;
|
||||
}
|
||||
|
||||
@ -1582,7 +1582,7 @@ void setupIclassReader()
|
||||
{
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
// Reset trace buffer
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
clear_trace();
|
||||
|
||||
// Setup SSC
|
||||
@ -1822,7 +1822,7 @@ void ReaderIClass_Replay(uint8_t arg0, uint8_t *MAC) {
|
||||
uint8_t resp[ICLASS_BUFFER_SIZE];
|
||||
|
||||
setupIclassReader();
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
|
||||
while(!BUTTON_PRESS()) {
|
||||
|
||||
|
@ -243,7 +243,7 @@ static RAMFUNC int Handle14443bUartBit(uint8_t bit)
|
||||
LED_A_OFF(); // Finished receiving
|
||||
Uart.state = STATE_UNSYNCD;
|
||||
if (Uart.byteCnt != 0) {
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
// this is an error
|
||||
@ -259,7 +259,7 @@ static RAMFUNC int Handle14443bUartBit(uint8_t bit)
|
||||
break;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -283,7 +283,7 @@ static void UartInit(uint8_t *data)
|
||||
// Receive a command (from the reader to us, where we are the simulated tag),
|
||||
// and store it in the given buffer, up to the given maximum length. Keeps
|
||||
// spinning, waiting for a well-framed command, until either we get one
|
||||
// (returns TRUE) or someone presses the pushbutton on the board (FALSE).
|
||||
// (returns true) or someone presses the pushbutton on the board (false).
|
||||
//
|
||||
// Assume that we're called with the SSC (to the FPGA) and ADC path set
|
||||
// correctly.
|
||||
@ -302,20 +302,20 @@ static int GetIso14443bCommandFromReader(uint8_t *received, uint16_t *len)
|
||||
for(;;) {
|
||||
WDT_HIT();
|
||||
|
||||
if(BUTTON_PRESS()) return FALSE;
|
||||
if(BUTTON_PRESS()) return false;
|
||||
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
|
||||
uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
|
||||
for(uint8_t mask = 0x80; mask != 0x00; mask >>= 1) {
|
||||
if(Handle14443bUartBit(b & mask)) {
|
||||
*len = Uart.byteCnt;
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
@ -347,7 +347,7 @@ void SimulateIso14443bTag(void)
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
|
||||
clear_trace();
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
|
||||
const uint8_t *resp;
|
||||
uint8_t *respCode;
|
||||
@ -387,7 +387,7 @@ void SimulateIso14443bTag(void)
|
||||
|
||||
if (tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
LogTrace(receivedCmd, len, 0, 0, parity, TRUE);
|
||||
LogTrace(receivedCmd, len, 0, 0, parity, true);
|
||||
}
|
||||
|
||||
// Good, look at the command now.
|
||||
@ -464,7 +464,7 @@ void SimulateIso14443bTag(void)
|
||||
// trace the response:
|
||||
if (tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
LogTrace(resp, respLen, 0, 0, parity, FALSE);
|
||||
LogTrace(resp, respLen, 0, 0, parity, false);
|
||||
}
|
||||
|
||||
}
|
||||
@ -702,7 +702,7 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
|
||||
LED_C_OFF();
|
||||
if(s == 0x000) {
|
||||
// This is EOF (start, stop and all data bits == '0'
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -716,7 +716,7 @@ static RAMFUNC int Handle14443bSamplesDemod(int ci, int cq)
|
||||
break;
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
@ -739,12 +739,12 @@ static void DemodInit(uint8_t *data)
|
||||
|
||||
/*
|
||||
* Demodulate the samples we received from the tag, also log to tracebuffer
|
||||
* quiet: set to 'TRUE' to disable debug output
|
||||
* quiet: set to 'true' to disable debug output
|
||||
*/
|
||||
static void GetSamplesFor14443bDemod(int n, bool quiet)
|
||||
{
|
||||
int max = 0;
|
||||
bool gotFrame = FALSE;
|
||||
bool gotFrame = false;
|
||||
int lastRxCounter, ci, cq, samples = 0;
|
||||
|
||||
// Allocate memory from BigBuf for some buffers
|
||||
@ -792,7 +792,7 @@ static void GetSamplesFor14443bDemod(int n, bool quiet)
|
||||
samples += 2;
|
||||
|
||||
if(Handle14443bSamplesDemod(ci, cq)) {
|
||||
gotFrame = TRUE;
|
||||
gotFrame = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@ -808,7 +808,7 @@ static void GetSamplesFor14443bDemod(int n, bool quiet)
|
||||
//Tracing
|
||||
if (tracing && Demod.len > 0) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
LogTrace(Demod.output, Demod.len, 0, 0, parity, FALSE);
|
||||
LogTrace(Demod.output, Demod.len, 0, 0, parity, false);
|
||||
}
|
||||
}
|
||||
|
||||
@ -929,7 +929,7 @@ static void CodeAndTransmit14443bAsReader(const uint8_t *cmd, int len)
|
||||
TransmitFor14443b();
|
||||
if (tracing) {
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
LogTrace(cmd,len, 0, 0, parity, TRUE);
|
||||
LogTrace(cmd,len, 0, 0, parity, true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -951,7 +951,7 @@ int iso14443b_apdu(uint8_t const *message, size_t message_length, uint8_t *respo
|
||||
// send
|
||||
CodeAndTransmit14443bAsReader(message_frame, message_length + 4);
|
||||
// get response
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT*100, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT*100, true);
|
||||
if(Demod.len < 3)
|
||||
{
|
||||
return 0;
|
||||
@ -981,7 +981,7 @@ int iso14443b_select_card()
|
||||
|
||||
// first, wake up the tag
|
||||
CodeAndTransmit14443bAsReader(wupb, sizeof(wupb));
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
// ATQB too short?
|
||||
if (Demod.len < 14)
|
||||
{
|
||||
@ -996,7 +996,7 @@ int iso14443b_select_card()
|
||||
attrib[7] = Demod.output[10] & 0x0F;
|
||||
ComputeCrc14443(CRC_14443_B, attrib, 9, attrib + 9, attrib + 10);
|
||||
CodeAndTransmit14443bAsReader(attrib, sizeof(attrib));
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
// Answer to ATTRIB too short?
|
||||
if(Demod.len < 3)
|
||||
{
|
||||
@ -1056,12 +1056,12 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
|
||||
SpinDelay(200);
|
||||
|
||||
clear_trace();
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
|
||||
// First command: wake up the tag using the INITIATE command
|
||||
uint8_t cmd1[] = {0x06, 0x00, 0x97, 0x5b};
|
||||
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
|
||||
if (Demod.len == 0) {
|
||||
DbpString("No response from tag");
|
||||
@ -1077,7 +1077,7 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
|
||||
cmd1[1] = Demod.output[0];
|
||||
ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]);
|
||||
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
if (Demod.len != 3) {
|
||||
Dbprintf("Expected 3 bytes from tag, got %d", Demod.len);
|
||||
return;
|
||||
@ -1099,7 +1099,7 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
|
||||
cmd1[0] = 0x0B;
|
||||
ComputeCrc14443(CRC_14443_B, cmd1, 1 , &cmd1[1], &cmd1[2]);
|
||||
CodeAndTransmit14443bAsReader(cmd1, 3); // Only first three bytes for this one
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
if (Demod.len != 10) {
|
||||
Dbprintf("Expected 10 bytes from tag, got %d", Demod.len);
|
||||
return;
|
||||
@ -1128,7 +1128,7 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
|
||||
cmd1[1] = i;
|
||||
ComputeCrc14443(CRC_14443_B, cmd1, 2, &cmd1[2], &cmd1[3]);
|
||||
CodeAndTransmit14443bAsReader(cmd1, sizeof(cmd1));
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
if (Demod.len != 6) { // Check if we got an answer from the tag
|
||||
DbpString("Expected 6 bytes from tag, got less...");
|
||||
return;
|
||||
@ -1174,13 +1174,13 @@ void RAMFUNC SnoopIso14443b(void)
|
||||
// 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
|
||||
// response from the tag.
|
||||
int triggered = TRUE; // TODO: set and evaluate trigger condition
|
||||
int triggered = true; // TODO: set and evaluate trigger condition
|
||||
|
||||
FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
|
||||
BigBuf_free();
|
||||
|
||||
clear_trace();
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
|
||||
// The DMA buffer, used to stream samples from the FPGA
|
||||
int8_t *dmaBuf = (int8_t*) BigBuf_malloc(ISO14443B_DMA_BUFFER_SIZE);
|
||||
@ -1217,8 +1217,8 @@ void RAMFUNC SnoopIso14443b(void)
|
||||
FpgaSetupSscDma((uint8_t*) dmaBuf, ISO14443B_DMA_BUFFER_SIZE);
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
|
||||
bool TagIsActive = FALSE;
|
||||
bool ReaderIsActive = FALSE;
|
||||
bool TagIsActive = false;
|
||||
bool ReaderIsActive = false;
|
||||
|
||||
// And now we loop, receiving samples.
|
||||
for(;;) {
|
||||
@ -1259,7 +1259,7 @@ void RAMFUNC SnoopIso14443b(void)
|
||||
if (!TagIsActive) { // no need to try decoding reader data if the tag is sending
|
||||
if(Handle14443bUartBit(ci & 0x01)) {
|
||||
if(triggered && tracing) {
|
||||
LogTrace(Uart.output, Uart.byteCnt, samples, samples, parity, TRUE);
|
||||
LogTrace(Uart.output, Uart.byteCnt, samples, samples, parity, true);
|
||||
}
|
||||
/* And ready to receive another command. */
|
||||
UartReset();
|
||||
@ -1269,7 +1269,7 @@ void RAMFUNC SnoopIso14443b(void)
|
||||
}
|
||||
if(Handle14443bUartBit(cq & 0x01)) {
|
||||
if(triggered && tracing) {
|
||||
LogTrace(Uart.output, Uart.byteCnt, samples, samples, parity, TRUE);
|
||||
LogTrace(Uart.output, Uart.byteCnt, samples, samples, parity, true);
|
||||
}
|
||||
/* And ready to receive another command. */
|
||||
UartReset();
|
||||
@ -1287,9 +1287,9 @@ void RAMFUNC SnoopIso14443b(void)
|
||||
if(tracing)
|
||||
{
|
||||
uint8_t parity[MAX_PARITY_SIZE];
|
||||
LogTrace(Demod.output, Demod.len, samples, samples, parity, FALSE);
|
||||
LogTrace(Demod.output, Demod.len, samples, samples, parity, false);
|
||||
}
|
||||
triggered = TRUE;
|
||||
triggered = true;
|
||||
|
||||
// And ready to receive another response.
|
||||
DemodReset();
|
||||
@ -1330,12 +1330,12 @@ void SendRawCommand14443B(uint32_t datalen, uint32_t recv, uint8_t powerfield, u
|
||||
FpgaSetupSsc();
|
||||
|
||||
if (datalen){
|
||||
set_tracing(TRUE);
|
||||
set_tracing(true);
|
||||
|
||||
CodeAndTransmit14443bAsReader(data, datalen);
|
||||
|
||||
if(recv) {
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, TRUE);
|
||||
GetSamplesFor14443bDemod(RECEIVE_SAMPLES_TIMEOUT, true);
|
||||
uint16_t iLen = MIN(Demod.len, USB_CMD_DATA_SIZE);
|
||||
cmd_send(CMD_ACK, iLen, 0, 0, Demod.output, iLen);
|
||||
}
|
||||
|
@ -305,7 +305,7 @@ static int GetIso15693AnswerFromTag(uint8_t *receivedResponse, int maxLen, int *
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
|
||||
//spindelay(60); // greg - experiment to get rid of some of the 0 byte/failed reads
|
||||
c = 0;
|
||||
getNext = FALSE;
|
||||
getNext = false;
|
||||
for(;;) {
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x43;
|
||||
@ -444,7 +444,7 @@ static int GetIso15693AnswerFromSniff(uint8_t *receivedResponse, int maxLen, int
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
|
||||
//spindelay(60); // greg - experiment to get rid of some of the 0 byte/failed reads
|
||||
c = 0;
|
||||
getNext = FALSE;
|
||||
getNext = false;
|
||||
for(;;) {
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x43;
|
||||
@ -612,7 +612,7 @@ void AcquireRawAdcSamplesIso15693(void)
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
|
||||
|
||||
c = 0;
|
||||
getNext = FALSE;
|
||||
getNext = false;
|
||||
for(;;) {
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x43;
|
||||
@ -666,7 +666,7 @@ void RecordRawAdcSamplesIso15693(void)
|
||||
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_READER_RX_XCORR);
|
||||
|
||||
c = 0;
|
||||
getNext = FALSE;
|
||||
getNext = false;
|
||||
for(;;) {
|
||||
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
|
||||
AT91C_BASE_SSC->SSC_THR = 0x43;
|
||||
|
@ -568,7 +568,7 @@ static void fcAll(uint8_t fc, int *n, uint8_t clock, uint16_t *modCnt)
|
||||
uint8_t wavesPerClock = clock/fc;
|
||||
uint8_t mod = clock % fc; //modifier
|
||||
uint8_t modAdj = fc/mod; //how often to apply modifier
|
||||
bool modAdjOk = !(fc % mod); //if (fc % mod==0) modAdjOk=TRUE;
|
||||
bool modAdjOk = !(fc % mod); //if (fc % mod==0) modAdjOk=true;
|
||||
// loop through clock - step field clock
|
||||
for (uint8_t idx=0; idx < wavesPerClock; idx++){
|
||||
// put 1/2 FC length 1's and 1/2 0's per field clock wave (to create the wave)
|
||||
@ -820,9 +820,9 @@ void CmdPSKsimTag(uint16_t arg1, uint16_t arg2, size_t size, uint8_t *BitStream)
|
||||
|
||||
for (i=0; i<size; i++){
|
||||
if (BitStream[i] == curPhase){
|
||||
pskSimBit(carrier, &n, clk, &curPhase, FALSE);
|
||||
pskSimBit(carrier, &n, clk, &curPhase, false);
|
||||
} else {
|
||||
pskSimBit(carrier, &n, clk, &curPhase, TRUE);
|
||||
pskSimBit(carrier, &n, clk, &curPhase, true);
|
||||
}
|
||||
}
|
||||
Dbprintf("Simulating with Carrier: %d, clk: %d, invert: %d, n: %d",carrier, clk, invert, n);
|
||||
|
@ -1149,7 +1149,7 @@ static bool isBlockTrailer(int blockN) {
|
||||
if (blockN >= 128 && blockN <= 256) {
|
||||
return ((blockN & 0x0F) == 0x0F);
|
||||
}
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
void MifareCWipe(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain){
|
||||
|
@ -35,7 +35,7 @@ bool MfSniffInit(void){
|
||||
sniffSAK = 0;
|
||||
sniffUIDType = SNF_UID_4;
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool MfSniffEnd(void){
|
||||
@ -43,7 +43,7 @@ bool MfSniffEnd(void){
|
||||
cmd_send(CMD_ACK,0,0,0,0,0);
|
||||
LED_B_OFF();
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RAMFUNC MfSniffLogic(const uint8_t *data, uint16_t len, uint8_t *parity, uint16_t bitCnt, bool reader) {
|
||||
@ -112,7 +112,7 @@ bool RAMFUNC MfSniffLogic(const uint8_t *data, uint16_t len, uint8_t *parity, ui
|
||||
sniffBuf[11] = sniffSAK;
|
||||
sniffBuf[12] = 0xFF;
|
||||
sniffBuf[13] = 0xFF;
|
||||
LogTrace(sniffBuf, 14, 0, 0, NULL, TRUE);
|
||||
LogTrace(sniffBuf, 14, 0, 0, NULL, true);
|
||||
sniffState = SNF_CARD_CMD;
|
||||
} // intentionally no break;
|
||||
case SNF_CARD_CMD:{
|
||||
@ -127,14 +127,14 @@ bool RAMFUNC MfSniffLogic(const uint8_t *data, uint16_t len, uint8_t *parity, ui
|
||||
}
|
||||
|
||||
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool RAMFUNC MfSniffSend(uint16_t maxTimeoutMs) {
|
||||
if (BigBuf_get_traceLen() && (GetTickCount() > timerData + maxTimeoutMs)) {
|
||||
return intMfSniffSend();
|
||||
}
|
||||
return FALSE;
|
||||
return false;
|
||||
}
|
||||
|
||||
// internal sending function. not a RAMFUNC.
|
||||
@ -162,5 +162,5 @@ bool intMfSniffSend() {
|
||||
|
||||
clear_trace();
|
||||
|
||||
return TRUE;
|
||||
return true;
|
||||
}
|
||||
|
@ -175,6 +175,7 @@ reswitch: switch (ch = (u_char)*fmt++) {
|
||||
padc = '0';
|
||||
goto reswitch;
|
||||
}
|
||||
// intentionally fall through to next case
|
||||
case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
for (n = 0;; ++fmt) {
|
||||
|
@ -361,7 +361,7 @@ int CmdHFList(const char *Cmd)
|
||||
char param2 = '\0';
|
||||
char param3 = '\0';
|
||||
char type[40] = {0};
|
||||
char filename[FILE_PATH_SIZE];
|
||||
char filename[FILE_PATH_SIZE] = {0};
|
||||
uint8_t protocol = 0;
|
||||
|
||||
// parse command line
|
||||
|
@ -486,12 +486,12 @@ int CmdHF14AInfo(const char *Cmd)
|
||||
|
||||
|
||||
// try to see if card responses to "chinese magic backdoor" commands.
|
||||
mfCIdentify();
|
||||
(void)mfCIdentify();
|
||||
|
||||
if (isMifareClassic) {
|
||||
switch(DetectClassicPrng()) {
|
||||
case 0:
|
||||
PrintAndLog("Prng detection: HARDEND (hardnested)");
|
||||
PrintAndLog("Prng detection: HARDENED (hardnested)");
|
||||
break;
|
||||
case 1:
|
||||
PrintAndLog("Prng detection: WEAK");
|
||||
@ -1032,12 +1032,9 @@ static command_t CommandTable[] =
|
||||
};
|
||||
|
||||
int CmdHF14A(const char *Cmd) {
|
||||
// flush
|
||||
WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
|
||||
// parse
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdHelp(const char *Cmd)
|
||||
|
@ -202,10 +202,7 @@ int CmdHelp(const char *Cmd)
|
||||
|
||||
int CmdHFEPA(const char *Cmd)
|
||||
{
|
||||
// flush
|
||||
WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
|
||||
// parse
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
@ -559,8 +559,10 @@ bool NestedCheckKey(uint64_t key, TAuthData *ad, uint8_t *cmd, uint8_t cmdsize,
|
||||
uint32_t ar1 = crypto1_word(pcs, 0, 0) ^ ad->ar_enc;
|
||||
uint32_t at1 = crypto1_word(pcs, 0, 0) ^ ad->at_enc;
|
||||
|
||||
if (!(ar == ar1 && at == at1 && NTParityChk(ad, nt1)))
|
||||
if (!(ar == ar1 && at == at1 && NTParityChk(ad, nt1))) {
|
||||
crypto1_destroy(pcs);
|
||||
return false;
|
||||
}
|
||||
|
||||
memcpy(buf, cmd, cmdsize);
|
||||
mf_crypto1_decrypt(pcs, buf, cmdsize, 0);
|
||||
|
@ -726,7 +726,6 @@ int CmdHF14AMfNested(const char *Cmd)
|
||||
blockNo = i * 4;
|
||||
keyType = j;
|
||||
num_to_bytes(e_sector[i].Key[j], 6, key);
|
||||
|
||||
keyFound = true;
|
||||
break;
|
||||
}
|
||||
@ -737,6 +736,7 @@ int CmdHF14AMfNested(const char *Cmd)
|
||||
// Can't found a key....
|
||||
if (!keyFound) {
|
||||
PrintAndLog("Can't found any of the known keys.");
|
||||
free(e_sector);
|
||||
return 4;
|
||||
}
|
||||
PrintAndLog("--auto key. block no:%3d, key type:%c key:%s", blockNo, keyType?'B':'A', sprint_hex(key, 6));
|
||||
@ -1187,7 +1187,10 @@ int CmdHF14AMfChk(const char *Cmd)
|
||||
|
||||
// initialize storage for found keys
|
||||
e_sector = calloc(SectorsCnt, sizeof(sector_t));
|
||||
if (e_sector == NULL) return 1;
|
||||
if (e_sector == NULL) {
|
||||
free(keyBlock);
|
||||
return 1;
|
||||
}
|
||||
for (uint8_t keyAB = 0; keyAB < 2; keyAB++) {
|
||||
for (uint16_t sectorNo = 0; sectorNo < SectorsCnt; sectorNo++) {
|
||||
e_sector[sectorNo].Key[keyAB] = 0xffffffffffff;
|
||||
@ -2666,11 +2669,9 @@ static command_t CommandTable[] =
|
||||
|
||||
int CmdHFMF(const char *Cmd)
|
||||
{
|
||||
// flush
|
||||
WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int CmdHelp(const char *Cmd)
|
||||
|
@ -276,7 +276,6 @@ static void init_bitflip_bitarrays(void)
|
||||
if (bytesread != filesize) {
|
||||
printf("File read error with %s. Aborting...\n", state_file_name);
|
||||
fclose(statesfile);
|
||||
inflateEnd(&compressed_stream);
|
||||
exit(5);
|
||||
}
|
||||
fclose(statesfile);
|
||||
|
@ -1834,7 +1834,7 @@ static command_t CommandTable[] =
|
||||
};
|
||||
|
||||
int CmdHFMFUltra(const char *Cmd){
|
||||
WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
@ -455,7 +455,7 @@ int CmdHFTopazReader(const char *Cmd)
|
||||
PrintAndLog("HR0 : %02x (%sa Topaz tag (%scapable of carrying a NDEF message), %s memory map)", rid_response[0],
|
||||
(rid_response[0] & 0xF0) == 0x10 ? "" : "not ",
|
||||
(rid_response[0] & 0xF0) == 0x10 ? "" : "not ",
|
||||
(rid_response[0] & 0x0F) == 0x10 ? "static" : "dynamic");
|
||||
(rid_response[0] & 0x0F) == 0x01 ? "static" : "dynamic");
|
||||
PrintAndLog("HR1 : %02x", rid_response[1]);
|
||||
|
||||
status = topaz_rall(uid_echo, rall_response);
|
||||
@ -554,10 +554,7 @@ static command_t CommandTable[] =
|
||||
|
||||
|
||||
int CmdHFTopaz(const char *Cmd) {
|
||||
// flush
|
||||
WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
|
||||
// parse
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
CmdsParse(CommandTable, Cmd);
|
||||
return 0;
|
||||
}
|
||||
|
@ -66,6 +66,7 @@ int CmdLFHitagList(const char *Cmd)
|
||||
if (strlen(filename) > 0) {
|
||||
if ((pf = fopen(filename,"wb")) == NULL) {
|
||||
PrintAndLog("Error: Could not open file [%s]",filename);
|
||||
free(got);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
@ -166,11 +167,11 @@ int CmdLFHitagSim(const char *Cmd) {
|
||||
return 1;
|
||||
}
|
||||
tag_mem_supplied = true;
|
||||
if (fread(c.d.asBytes,48,1,pf) == 0) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
if (fread(c.d.asBytes,1,48,pf) != 48) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
fclose(pf);
|
||||
} else {
|
||||
tag_mem_supplied = false;
|
||||
@ -289,7 +290,7 @@ int CmdLFHitagSimS(const char *Cmd) {
|
||||
return 1;
|
||||
}
|
||||
tag_mem_supplied = true;
|
||||
if (fread(c.d.asBytes, 4*64, 1, pf) == 0) {
|
||||
if (fread(c.d.asBytes, 1, 4*64, pf) != 4*64) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
return 1;
|
||||
@ -321,9 +322,9 @@ int CmdLFHitagCheckChallenges(const char *Cmd) {
|
||||
return 1;
|
||||
}
|
||||
file_given = true;
|
||||
if (fread(c.d.asBytes,8*60,1,pf) == 0) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
if (fread(c.d.asBytes,1,8*60,pf) != 8*60) {
|
||||
PrintAndLog("Error: File reading error");
|
||||
fclose(pf);
|
||||
return 1;
|
||||
}
|
||||
fclose(pf);
|
||||
|
@ -287,7 +287,7 @@ int CmdIndalaDemod(const char *Cmd) {
|
||||
}
|
||||
|
||||
int CmdIndalaClone(const char *Cmd) {
|
||||
UsbCommand c;
|
||||
UsbCommand c = {0};
|
||||
unsigned int uid1, uid2, uid3, uid4, uid5, uid6, uid7;
|
||||
|
||||
uid1 = uid2 = uid3 = uid4 = uid5 = uid6 = uid7 = 0;
|
||||
|
@ -105,7 +105,7 @@ static struct crypto_pk *crypto_pk_polarssl_open_rsa(va_list vl)
|
||||
int res = rsa_check_pubkey(&cp->ctx);
|
||||
if(res != 0) {
|
||||
fprintf(stderr, "PolarSSL public key error res=%x exp=%d mod=%d.\n", res * -1, explen, modlen);
|
||||
|
||||
free(cp);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -150,6 +150,7 @@ static struct crypto_pk *crypto_pk_polarssl_open_priv_rsa(va_list vl)
|
||||
int res = rsa_check_privkey(&cp->ctx);
|
||||
if(res != 0) {
|
||||
fprintf(stderr, "PolarSSL private key error res=%x exp=%d mod=%d.\n", res * -1, explen, modlen);
|
||||
free(cp);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -184,6 +185,7 @@ static struct crypto_pk *crypto_pk_polarssl_genkey_rsa(va_list vl)
|
||||
int res = rsa_gen_key(&cp->ctx, &myrand, NULL, nbits, exp);
|
||||
if (res) {
|
||||
fprintf(stderr, "PolarSSL private key generation error res=%x exp=%d nbits=%d.\n", res * -1, exp, nbits);
|
||||
free(cp);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -216,6 +218,7 @@ static unsigned char *crypto_pk_polarssl_encrypt(const struct crypto_pk *_cp, co
|
||||
res = rsa_public(&cp->ctx, buf, result);
|
||||
if(res) {
|
||||
printf("RSA encrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
|
||||
free(result);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
@ -242,6 +245,7 @@ static unsigned char *crypto_pk_polarssl_decrypt(const struct crypto_pk *_cp, co
|
||||
res = rsa_private(&cp->ctx, buf, result); // CHECK???
|
||||
if(res) {
|
||||
printf("RSA decrypt failed. Error: %x data len: %zd key len: %zd\n", res * -1, len, keylen);
|
||||
free(result);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ static const uint8_t elf_ident[] = {
|
||||
|
||||
// Turn PHDRs into flasher segments, checking for PHDR sanity and merging adjacent
|
||||
// unaligned segments if needed
|
||||
static int build_segs_from_phdrs(flash_file_t *ctx, FILE *fd, Elf32_Phdr *phdrs, int num_phdrs)
|
||||
static int build_segs_from_phdrs(flash_file_t *ctx, FILE *fd, Elf32_Phdr *phdrs, uint16_t num_phdrs)
|
||||
{
|
||||
Elf32_Phdr *phdr = phdrs;
|
||||
flash_seg_t *seg;
|
||||
@ -191,7 +191,7 @@ int flash_load(flash_file_t *ctx, const char *name, bool can_write_bl)
|
||||
FILE *fd = NULL;
|
||||
Elf32_Ehdr ehdr;
|
||||
Elf32_Phdr *phdrs = NULL;
|
||||
int num_phdrs;
|
||||
uint16_t num_phdrs;
|
||||
int res;
|
||||
|
||||
fd = fopen(name, "rb");
|
||||
@ -270,7 +270,7 @@ fail:
|
||||
// Get the state of the proxmark, backwards compatible
|
||||
static int get_proxmark_state(uint32_t *state)
|
||||
{
|
||||
UsbCommand c;
|
||||
UsbCommand c = {0};
|
||||
c.cmd = CMD_DEVICE_INFO;
|
||||
SendCommand(&c);
|
||||
UsbCommand resp;
|
||||
|
@ -108,7 +108,7 @@ int zlib_compress(FILE *infile[], uint8_t num_infiles, FILE *outfile, bool hardn
|
||||
|
||||
for(uint16_t j = 0; j < num_infiles; j++) {
|
||||
for(uint16_t k = 0; k < FPGA_INTERLEAVE_SIZE; k++) {
|
||||
c = fgetc(infile[j]);
|
||||
c = (uint8_t)fgetc(infile[j]);
|
||||
if (!feof(infile[j])) {
|
||||
fpga_config[i++] = c;
|
||||
} else if (num_infiles > 1) {
|
||||
|
@ -328,7 +328,7 @@ int mfnested(uint8_t blockNo, uint8_t keyType, uint8_t *key, uint8_t trgBlockNo,
|
||||
struct Crypto1State *p1, *p2, *p3, *p4;
|
||||
|
||||
// flush queue
|
||||
WaitForResponseTimeout(CMD_ACK, NULL, 100);
|
||||
(void)WaitForResponseTimeout(CMD_ACK,NULL,100);
|
||||
|
||||
UsbCommand c = {CMD_MIFARE_NESTED, {blockNo + keyType * 0x100, trgBlockNo + trgKeyType * 0x100, calibrate}};
|
||||
memcpy(c.d.asBytes, key, 6);
|
||||
@ -910,6 +910,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint8_t parity, bool wantSaveToEml
|
||||
uint32_t nr1 = crypto1_word(pcs, nr_enc, 1) ^ nr_enc;
|
||||
uint32_t ar1 = crypto1_word(pcs, 0, 0) ^ ar_enc;
|
||||
uint32_t at1 = crypto1_word(pcs, 0, 0) ^ at_enc;
|
||||
crypto1_destroy(pcs);
|
||||
printf("key> the same key test. nr1: %08x ar1: %08x at1: %08x \n", nr1, ar1, at1);
|
||||
|
||||
if (NTParityCheck(nt1))
|
||||
|
@ -62,12 +62,9 @@ extern "C" void MainGraphics(void)
|
||||
extern "C" void InitGraphics(int argc, char **argv, char *script_cmds_file, char *script_cmd, bool usb_present)
|
||||
{
|
||||
#ifdef Q_WS_X11
|
||||
bool useGUI = getenv("DISPLAY") != 0;
|
||||
#else
|
||||
bool useGUI = true;
|
||||
#endif
|
||||
if (!useGUI)
|
||||
if (getenv("DISPLAY") == NULL)
|
||||
return;
|
||||
#endif
|
||||
|
||||
main_loop_thread = new WorkerThread(script_cmds_file, script_cmd, usb_present);
|
||||
gui = new ProxGuiQT(argc, argv, main_loop_thread);
|
||||
|
@ -110,7 +110,6 @@ class ProxGuiQT : public QObject
|
||||
ProxWidget *plotwidget;
|
||||
int argc;
|
||||
char **argv;
|
||||
void (*main_func)(void);
|
||||
WorkerThread *proxmarkThread;
|
||||
|
||||
public:
|
||||
|
@ -221,7 +221,7 @@ static int l_iso14443b_crc(lua_State *L)
|
||||
unsigned char buf[USB_CMD_DATA_SIZE];
|
||||
size_t len = 0;
|
||||
const char *data = luaL_checklstring(L, 1, &len);
|
||||
if (USB_CMD_DATA_SIZE < len)
|
||||
if (len > USB_CMD_DATA_SIZE-2)
|
||||
len = USB_CMD_DATA_SIZE-2;
|
||||
|
||||
for (int i = 0; i < len; i += 2) {
|
||||
|
@ -117,7 +117,7 @@ uint64_t msclock() {
|
||||
#include <sys/timeb.h>
|
||||
struct _timeb t;
|
||||
_ftime(&t);
|
||||
return 1000 * t.time + t.millitm;
|
||||
return 1000 * (uint64_t)t.time + t.millitm;
|
||||
|
||||
// NORMAL CODE (use _ftime_s)
|
||||
//struct _timeb t;
|
||||
|
@ -61,9 +61,6 @@
|
||||
#define SPI_FPGA_MODE 0
|
||||
#define SPI_LCD_MODE 1
|
||||
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
|
||||
//#define PACKED __attribute__((__packed__))
|
||||
|
||||
#define LED_A_ON() HIGH(GPIO_LED_A)
|
||||
|
@ -10,7 +10,7 @@
|
||||
// 32 bit recover key from 2 nonces
|
||||
int main (int argc, char *argv[]) {
|
||||
|
||||
nonces_t data;
|
||||
nonces_t data = {0};
|
||||
uint32_t ks2; // keystream used to encrypt reader response
|
||||
uint64_t key; // recovered key
|
||||
|
||||
|
Loading…
x
Reference in New Issue
Block a user