github/proxmark3
1
0
Fork 0
mirror of https://github.com/Proxmark/proxmark3.git synced 2025-08-19 04:49:38 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #23 from holiman/master

Browse source 
LF operations fixes, and coverity code scan fixes
This commit is contained in:
Martin Holst Swende 2014-10-30 20:08:29 +01:00
commit 0ce5620254
17 changed files with 437 additions and 675 deletions
Download patch file Download diff file Expand all files Collapse all files

2
armsrc/epa.c
View file

@ -419,7 +419,7 @@ int EPA_Setup()
// return code // return code
int return_code = 0; int return_code = 0;
// card UID // card UID
uint8_t uid[8]; uint8_t uid[10];
// card select information // card select information
iso14a_card_select_t card_select_info; iso14a_card_select_t card_select_info;
// power up the field // power up the field

4
armsrc/hitag2.c
View file

@ -1140,7 +1140,7 @@ void ReaderHitag(hitag_function htf, hitag_data* htd) {
case RHT2F_PASSWORD: { case RHT2F_PASSWORD: {
Dbprintf("List identifier in password mode"); Dbprintf("List identifier in password mode");
memcpy(password,htd->pwd.password,4); memcpy(password,htd->pwd.password,4);
blocknr = 0; blocknr = 0;
bQuitTraceFull = false; bQuitTraceFull = false;
bQuiet = false; bQuiet = false;
bPwd = false; bPwd = false;
@ -1158,7 +1158,7 @@ void ReaderHitag(hitag_function htf, hitag_data* htd) {
case RHT2F_CRYPTO: { case RHT2F_CRYPTO: {
DbpString("Authenticating using key:"); DbpString("Authenticating using key:");
memcpy(key,htd->crypto.key,6); memcpy(key,htd->crypto.key,4);
Dbhexdump(6,key,false); Dbhexdump(6,key,false);
blocknr = 0; blocknr = 0;
bQuiet = false; bQuiet = false;

29
armsrc/iclass.c
View file

@ -1295,20 +1295,23 @@ static void TransmitIClassCommand(const uint8_t *cmd, int len, int *samples, int
FpgaSetupSsc(); FpgaSetupSsc();
if (wait) if (wait)
if(*wait < 10) {
*wait = 10; if(*wait < 10) *wait = 10;
for(c = 0; c < *wait;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x00; // For exact timing!
c++;
}
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r;
}
WDT_HIT();
}
}
for(c = 0; c < *wait;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x00; // For exact timing!
c++;
}
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
volatile uint32_t r = AT91C_BASE_SSC->SSC_RHR;
(void)r;
}
WDT_HIT();
}
uint8_t sendbyte; uint8_t sendbyte;
bool firstpart = TRUE; bool firstpart = TRUE;

11
armsrc/iso14443a.c
View file

@ -1726,7 +1726,13 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) { if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) {
// Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of: // Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of:
// http://www.nxp.com/documents/application_note/AN10927.pdf // http://www.nxp.com/documents/application_note/AN10927.pdf
memcpy(uid_resp, uid_resp + 1, 3); // This was earlier:
//memcpy(uid_resp, uid_resp + 1, 3);
// But memcpy should not be used for overlapping arrays,
// and memmove appears to not be available in the arm build.
// So this has been replaced with a for-loop:
for(int xx = 0; xx < 3; xx++) uid_resp[xx] = uid_resp[xx+1];
uid_resp_len = 3; uid_resp_len = 3;
} }
@ -1936,7 +1942,8 @@ void ReaderMifare(bool first_try)
uint8_t uid[10]; uint8_t uid[10];
uint32_t cuid; uint32_t cuid;
uint32_t nt, previous_nt; uint32_t nt =0 ;
uint32_t previous_nt = 0;
static uint32_t nt_attacked = 0; static uint32_t nt_attacked = 0;
byte_t par_list[8] = {0,0,0,0,0,0,0,0}; byte_t par_list[8] = {0,0,0,0,0,0,0,0};
byte_t ks_list[8] = {0,0,0,0,0,0,0,0}; byte_t ks_list[8] = {0,0,0,0,0,0,0,0};

858
armsrc/lfops.c
View file

@ -15,40 +15,14 @@
#include "crc16.h" #include "crc16.h"
#include "string.h" #include "string.h"
void LFSetupFPGAForADC(int divisor, bool lf_field)
{
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
if ( (divisor == 1) || (divisor < 0) || (divisor > 255) )
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
else if (divisor == 0)
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
else
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | (lf_field ? FPGA_LF_ADC_READER_FIELD : 0)); /**
* Does the sample acquisition. If threshold is specified, the actual sampling
// Connect the A/D to the peak-detected low-frequency path. * is not commenced until the threshold has been reached.
SetAdcMuxFor(GPIO_MUXSEL_LOPKD); * @param trigger_threshold - the threshold
// Give it a bit of time for the resonant antenna to settle. * @param silent - is true, now outputs are made. If false, dbprints the status
SpinDelay(50); */
// Now set up the SSC to get the ADC samples that are now streaming at us. void DoAcquisition125k_internal(int trigger_threshold,bool silent)
FpgaSetupSsc();
}
void AcquireRawAdcSamples125k(int divisor)
{
LFSetupFPGAForADC(divisor, true);
DoAcquisition125k(-1);
}
void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
{
LFSetupFPGAForADC(divisor, false);
DoAcquisition125k(trigger_threshold);
}
// split into two routines so we can avoid timing issues after sending commands //
void DoAcquisition125k(int trigger_threshold)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int n = sizeof(BigBuf); int n = sizeof(BigBuf);
@ -71,34 +45,87 @@ void DoAcquisition125k(int trigger_threshold)
if (++i >= n) break; if (++i >= n) break;
} }
} }
Dbprintf("buffer samples: %02x %02x %02x %02x %02x %02x %02x %02x ...", if(!silent)
dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]); {
Dbprintf("buffer samples: %02x %02x %02x %02x %02x %02x %02x %02x ...",
dest[0], dest[1], dest[2], dest[3], dest[4], dest[5], dest[6], dest[7]);
}
}
/**
* Perform sample aquisition.
*/
void DoAcquisition125k(int trigger_threshold)
{
DoAcquisition125k_internal(trigger_threshold, false);
}
/**
* Setup the FPGA to listen for samples. This method downloads the FPGA bitstream
* if not already loaded, sets divisor and starts up the antenna.
* @param divisor : 1, 88> 255 or negative ==> 134.8 KHz
* 0 or 95 ==> 125 KHz
*
**/
void LFSetupFPGAForADC(int divisor, bool lf_field)
{
FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
if ( (divisor == 1) || (divisor < 0) || (divisor > 255) )
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
else if (divisor == 0)
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
else
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | (lf_field ? FPGA_LF_ADC_READER_FIELD : 0));
// Connect the A/D to the peak-detected low-frequency path.
SetAdcMuxFor(GPIO_MUXSEL_LOPKD);
// Give it a bit of time for the resonant antenna to settle.
SpinDelay(50);
// Now set up the SSC to get the ADC samples that are now streaming at us.
FpgaSetupSsc();
}
/**
* Initializes the FPGA, and acquires the samples.
**/
void AcquireRawAdcSamples125k(int divisor)
{
LFSetupFPGAForADC(divisor, true);
// Now call the acquisition routine
DoAcquisition125k_internal(-1,false);
}
/**
* Initializes the FPGA for snoop-mode, and acquires the samples.
**/
void SnoopLFRawAdcSamples(int divisor, int trigger_threshold)
{
LFSetupFPGAForADC(divisor, false);
DoAcquisition125k(trigger_threshold);
} }
void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1, uint8_t *command) void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1, uint8_t *command)
{ {
int at134khz;
/* Make sure the tag is reset */ /* Make sure the tag is reset */
FpgaDownloadAndGo(FPGA_BITSTREAM_LF); FpgaDownloadAndGo(FPGA_BITSTREAM_LF);
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
SpinDelay(2500); SpinDelay(2500);
int divisor_used = 95; // 125 KHz
// see if 'h' was specified // see if 'h' was specified
if (command[strlen((char *) command) - 1] == 'h') if (command[strlen((char *) command) - 1] == 'h')
at134khz = TRUE; divisor_used = 88; // 134.8 KHz
else
at134khz = FALSE;
if (at134khz)
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
else
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor_used);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
// Give it a bit of time for the resonant antenna to settle. // Give it a bit of time for the resonant antenna to settle.
SpinDelay(50); SpinDelay(50);
// And a little more time for the tag to fully power up // And a little more time for the tag to fully power up
SpinDelay(2000); SpinDelay(2000);
@ -110,10 +137,7 @@ void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1,
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF(); LED_D_OFF();
SpinDelayUs(delay_off); SpinDelayUs(delay_off);
if (at134khz) FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor_used);
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
else
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
LED_D_ON(); LED_D_ON();
@ -125,10 +149,7 @@ void ModThenAcquireRawAdcSamples125k(int delay_off, int period_0, int period_1,
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF); FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LED_D_OFF(); LED_D_OFF();
SpinDelayUs(delay_off); SpinDelayUs(delay_off);
if (at134khz) FpgaSendCommand(FPGA_CMD_SET_DIVISOR, divisor_used);
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 88); //134.8Khz
else
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD); FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
@ -609,416 +630,214 @@ void CmdHIDsimTAG(int hi, int lo, int ledcontrol)
LED_A_OFF(); LED_A_OFF();
} }
size_t fsk_demod(uint8_t * dest, size_t size)
{
uint32_t last_transition = 0;
uint32_t idx = 1;
// we don't care about actual value, only if it's more or less than a
// threshold essentially we capture zero crossings for later analysis
uint8_t threshold_value = 127;
// sync to first lo-hi transition, and threshold
//Need to threshold first sample
if(dest[0] < threshold_value) dest[0] = 0;
else dest[0] = 1;
size_t numBits = 0;
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
for(idx = 1; idx < size; idx++) {
// threshold current value
if (dest[idx] < threshold_value) dest[idx] = 0;
else dest[idx] = 1;
// Check for 0->1 transition
if (dest[idx-1] < dest[idx]) { // 0 -> 1 transition
if (idx-last_transition < 9) {
dest[numBits]=1;
} else {
dest[numBits]=0;
}
last_transition = idx;
numBits++;
}
}
return numBits; //Actually, it returns the number of bytes, but each byte represents a bit: 1 or 0
}
size_t aggregate_bits(uint8_t *dest,size_t size, uint8_t h2l_crossing_value,uint8_t l2h_crossing_value, uint8_t maxConsequtiveBits )
{
uint8_t lastval=dest[0];
uint32_t idx=0;
size_t numBits=0;
uint32_t n=1;
for( idx=1; idx < size; idx++) {
if (dest[idx]==lastval) {
n++;
continue;
}
//if lastval was 1, we have a 1->0 crossing
if ( dest[idx-1] ) {
n=(n+1) / h2l_crossing_value;
} else {// 0->1 crossing
n=(n+1) / l2h_crossing_value;
}
if (n == 0) n = 1;
if(n < maxConsequtiveBits)
{
memset(dest+numBits, dest[idx-1] , n);
numBits += n;
}
n=0;
lastval=dest[idx];
}//end for
return numBits;
}
// loop to capture raw HID waveform then FSK demodulate the TAG ID from it // loop to capture raw HID waveform then FSK demodulate the TAG ID from it
void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol) void CmdHIDdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int m=0, n=0, i=0, idx=0, found=0, lastval=0;
uint32_t hi2=0, hi=0, lo=0;
FpgaDownloadAndGo(FPGA_BITSTREAM_LF); size_t size=0,idx=0; //, found=0;
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz uint32_t hi2=0, hi=0, lo=0;
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
// Connect the A/D to the peak-detected low-frequency path. // Configure to go in 125Khz listen mode
SetAdcMuxFor(GPIO_MUXSEL_LOPKD); LFSetupFPGAForADC(95, true);
// Give it a bit of time for the resonant antenna to settle. while(!BUTTON_PRESS()) {
SpinDelay(50);
// Now set up the SSC to get the ADC samples that are now streaming at us.
FpgaSetupSsc();
for(;;) {
WDT_HIT(); WDT_HIT();
if (ledcontrol) if (ledcontrol) LED_A_ON();
LED_A_ON();
if(BUTTON_PRESS()) {
DbpString("Stopped");
if (ledcontrol)
LED_A_OFF();
return;
}
i = 0; DoAcquisition125k_internal(-1,true);
m = sizeof(BigBuf); size = sizeof(BigBuf);
memset(dest,128,m);
for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x43;
if (ledcontrol)
LED_D_ON();
}
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
// we don't care about actual value, only if it's more or less than a
// threshold essentially we capture zero crossings for later analysis
if(dest[i] < 127) dest[i] = 0; else dest[i] = 1;
i++;
if (ledcontrol)
LED_D_OFF();
if(i >= m) {
break;
}
}
}
// FSK demodulator // FSK demodulator
size = fsk_demod(dest, size);
// sync to first lo-hi transition
for( idx=1; idx<m; idx++) {
if (dest[idx-1]<dest[idx])
lastval=idx;
break;
}
WDT_HIT();
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
for( i=0; idx<m; idx++) {
if (dest[idx-1]<dest[idx]) {
dest[i]=idx-lastval;
if (dest[i] <= 8) {
dest[i]=1;
} else {
dest[i]=0;
}
lastval=idx;
i++;
}
}
m=i;
WDT_HIT();
// we now have a set of cycle counts, loop over previous results and aggregate data into bit patterns // we now have a set of cycle counts, loop over previous results and aggregate data into bit patterns
lastval=dest[0]; // 1->0 : fc/8 in sets of 6
idx=0; // 0->1 : fc/10 in sets of 5
i=0; size = aggregate_bits(dest,size, 6,5,5);
n=0;
for( idx=0; idx<m; idx++) {
if (dest[idx]==lastval) {
n++;
} else {
// a bit time is five fc/10 or six fc/8 cycles so figure out how many bits a pattern width represents,
// an extra fc/8 pattern preceeds every 4 bits (about 200 cycles) just to complicate things but it gets
// swallowed up by rounding
// expected results are 1 or 2 bits, any more and it's an invalid manchester encoding
// special start of frame markers use invalid manchester states (no transitions) by using sequences
// like 111000
if (dest[idx-1]) {
n=(n+1)/6; // fc/8 in sets of 6
} else {
n=(n+1)/5; // fc/10 in sets of 5
}
switch (n) { // stuff appropriate bits in buffer
case 0:
case 1: // one bit
dest[i++]=dest[idx-1];
break;
case 2: // two bits
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
break;
case 3: // 3 bit start of frame markers
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
break;
// When a logic 0 is immediately followed by the start of the next transmisson
// (special pattern) a pattern of 4 bit duration lengths is created.
case 4:
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
dest[i++]=dest[idx-1];
break;
default: // this shouldn't happen, don't stuff any bits
break;
}
n=0;
lastval=dest[idx];
}
}
m=i;
WDT_HIT(); WDT_HIT();
// final loop, go over previously decoded manchester data and decode into usable tag ID // final loop, go over previously decoded manchester data and decode into usable tag ID
// 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0 // 111000 bit pattern represent start of frame, 01 pattern represents a 1 and 10 represents a 0
for( idx=0; idx<m-6; idx++) { uint8_t frame_marker_mask[] = {1,1,1,0,0,0};
int numshifts = 0;
idx = 0;
while( idx + sizeof(frame_marker_mask) < size) {
// search for a start of frame marker // search for a start of frame marker
if ( dest[idx] && dest[idx+1] && dest[idx+2] && (!dest[idx+3]) && (!dest[idx+4]) && (!dest[idx+5]) ) if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ { // frame marker found
found=1; idx+=sizeof(frame_marker_mask);
idx+=6;
if (found && (hi2|hi|lo)) { while(dest[idx] != dest[idx+1] && idx < size-2)
if (hi2 != 0){ {
Dbprintf("TAG ID: %x%08x%08x (%d)", // Keep going until next frame marker (or error)
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); // Shift in a bit. Start by shifting high registers
} hi2 = (hi2<<1)|(hi>>31);
else { hi = (hi<<1)|(lo>>31);
Dbprintf("TAG ID: %x%08x (%d)", //Then, shift in a 0 or one into low
(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF); if (dest[idx] && !dest[idx+1]) // 1 0
} lo=(lo<<1)|0;
/* if we're only looking for one tag */ else // 0 1
if (findone) lo=(lo<<1)|
1;
numshifts ++;
idx += 2;
}
//Dbprintf("Num shifts: %d ", numshifts);
// Hopefully, we read a tag and hit upon the next frame marker
if(idx + sizeof(frame_marker_mask) < size)
{
if ( memcmp(dest+idx, frame_marker_mask, sizeof(frame_marker_mask)) == 0)
{ {
*high = hi; if (hi2 != 0){
*low = lo; Dbprintf("TAG ID: %x%08x%08x (%d)",
return; (unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
}
else {
Dbprintf("TAG ID: %x%08x (%d)",
(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
}
} }
hi2=0;
hi=0;
lo=0;
found=0;
}
}
if (found) {
if (dest[idx] && (!dest[idx+1]) ) {
hi2=(hi2<<1)|(hi>>31);
hi=(hi<<1)|(lo>>31);
lo=(lo<<1)|0;
} else if ( (!dest[idx]) && dest[idx+1]) {
hi2=(hi2<<1)|(hi>>31);
hi=(hi<<1)|(lo>>31);
lo=(lo<<1)|1;
} else {
found=0;
hi2=0;
hi=0;
lo=0;
} }
// reset
hi2 = hi = lo = 0;
numshifts = 0;
}else
{
idx++; idx++;
} }
if ( dest[idx] && dest[idx+1] && dest[idx+2] && (!dest[idx+3]) && (!dest[idx+4]) && (!dest[idx+5]) )
{
found=1;
idx+=6;
if (found && (hi|lo)) {
if (hi2 != 0){
Dbprintf("TAG ID: %x%08x%08x (%d)",
(unsigned int) hi2, (unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
}
else {
Dbprintf("TAG ID: %x%08x (%d)",
(unsigned int) hi, (unsigned int) lo, (unsigned int) (lo>>1) & 0xFFFF);
}
/* if we're only looking for one tag */
if (findone)
{
*high = hi;
*low = lo;
return;
}
hi2=0;
hi=0;
lo=0;
found=0;
}
}
} }
WDT_HIT(); WDT_HIT();
} }
DbpString("Stopped");
if (ledcontrol) LED_A_OFF();
} }
uint32_t bytebits_to_byte(uint8_t* src, int numbits)
{
uint32_t num = 0;
for(int i = 0 ; i < numbits ; i++)
{
num = (num << 1) | (*src);
src++;
}
return num;
}
void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol) void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
{ {
uint8_t *dest = (uint8_t *)BigBuf; uint8_t *dest = (uint8_t *)BigBuf;
int m=0, n=0, i=0, idx=0, lastval=0;
int found=0; size_t size=0, idx=0;
uint32_t code=0, code2=0; uint32_t code=0, code2=0;
//uint32_t hi2=0, hi=0, lo=0;
FpgaDownloadAndGo(FPGA_BITSTREAM_LF); // Configure to go in 125Khz listen mode
FpgaSendCommand(FPGA_CMD_SET_DIVISOR, 95); //125Khz LFSetupFPGAForADC(95, true);
FpgaWriteConfWord(FPGA_MAJOR_MODE_LF_ADC | FPGA_LF_ADC_READER_FIELD);
// Connect the A/D to the peak-detected low-frequency path. while(!BUTTON_PRESS()) {
SetAdcMuxFor(GPIO_MUXSEL_LOPKD);
// Give it a bit of time for the resonant antenna to settle.
SpinDelay(50);
// Now set up the SSC to get the ADC samples that are now streaming at us.
FpgaSetupSsc();
for(;;) {
WDT_HIT(); WDT_HIT();
if (ledcontrol) if (ledcontrol) LED_A_ON();
LED_A_ON();
if(BUTTON_PRESS()) {
DbpString("Stopped");
if (ledcontrol)
LED_A_OFF();
return;
}
i = 0; DoAcquisition125k_internal(-1,true);
m = sizeof(BigBuf); size = sizeof(BigBuf);
memset(dest,128,m);
for(;;) {
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
AT91C_BASE_SSC->SSC_THR = 0x43;
if (ledcontrol)
LED_D_ON();
}
if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
dest[i] = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
// we don't care about actual value, only if it's more or less than a
// threshold essentially we capture zero crossings for later analysis
if(dest[i] < 127) dest[i] = 0; else dest[i] = 1;
i++;
if (ledcontrol)
LED_D_OFF();
if(i >= m) {
break;
}
}
}
// FSK demodulator // FSK demodulator
size = fsk_demod(dest, size);
// sync to first lo-hi transition
for( idx=1; idx<m; idx++) {
if (dest[idx-1]<dest[idx])
lastval=idx;
break;
}
WDT_HIT();
// count cycles between consecutive lo-hi transitions, there should be either 8 (fc/8)
// or 10 (fc/10) cycles but in practice due to noise etc we may end up with with anywhere
// between 7 to 11 cycles so fuzz it by treat anything <9 as 8 and anything else as 10
for( i=0; idx<m; idx++) {
if (dest[idx-1]<dest[idx]) {
dest[i]=idx-lastval;
if (dest[i] <= 8) {
dest[i]=1;
} else {
dest[i]=0;
}
lastval=idx;
i++;
}
}
m=i;
WDT_HIT();
// we now have a set of cycle counts, loop over previous results and aggregate data into bit patterns // we now have a set of cycle counts, loop over previous results and aggregate data into bit patterns
lastval=dest[0]; // 1->0 : fc/8 in sets of 7
idx=0; // 0->1 : fc/10 in sets of 6
i=0; size = aggregate_bits(dest, size, 7,6,13);
n=0;
for( idx=0; idx<m; idx++) {
if (dest[idx]==lastval) {
n++;
} else {
// a bit time is five fc/10 or six fc/8 cycles so figure out how many bits a pattern width represents,
// an extra fc/8 pattern preceeds every 4 bits (about 200 cycles) just to complicate things but it gets
// swallowed up by rounding
// expected results are 1 or 2 bits, any more and it's an invalid manchester encoding
// special start of frame markers use invalid manchester states (no transitions) by using sequences
// like 111000
if (dest[idx-1]) {
n=(n+1)/7; // fc/8 in sets of 7
} else {
n=(n+1)/6; // fc/10 in sets of 6
}
switch (n) { // stuff appropriate bits in buffer
case 0:
case 1: // one bit
dest[i++]=dest[idx-1]^1;
//Dbprintf("%d",dest[idx-1]);
break;
case 2: // two bits
dest[i++]=dest[idx-1]^1;
dest[i++]=dest[idx-1]^1;
//Dbprintf("%d",dest[idx-1]);
//Dbprintf("%d",dest[idx-1]);
break;
case 3: // 3 bit start of frame markers
for(int j=0; j<3; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 4:
for(int j=0; j<4; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 5:
for(int j=0; j<5; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 6:
for(int j=0; j<6; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 7:
for(int j=0; j<7; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 8:
for(int j=0; j<8; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 9:
for(int j=0; j<9; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 10:
for(int j=0; j<10; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 11:
for(int j=0; j<11; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
case 12:
for(int j=0; j<12; j++){
dest[i++]=dest[idx-1]^1;
// Dbprintf("%d",dest[idx-1]);
}
break;
default: // this shouldn't happen, don't stuff any bits
//Dbprintf("%d",dest[idx-1]);
break;
}
n=0;
lastval=dest[idx];
}
}//end for
/*for(int j=0; j<64;j+=8){
Dbprintf("%d%d%d%d%d%d%d%d",dest[j],dest[j+1],dest[j+2],dest[j+3],dest[j+4],dest[j+5],dest[j+6],dest[j+7]);
}
Dbprintf("\n");*/
m=i;
WDT_HIT(); WDT_HIT();
for( idx=0; idx<m-9; idx++) { //Handle the data
if ( !(dest[idx]) && !(dest[idx+1]) && !(dest[idx+2]) && !(dest[idx+3]) && !(dest[idx+4]) && !(dest[idx+5]) && !(dest[idx+6]) && !(dest[idx+7]) && !(dest[idx+8])&& (dest[idx+9])){ uint8_t mask[] = {0,0,0,0,0,0,0,0,0,1};
found=1; for( idx=0; idx < size - 64; idx++) {
//idx+=9;
if (found) { if ( memcmp(dest + idx, mask, sizeof(mask)) ) continue;
Dbprintf("%d%d%d%d%d%d%d%d",dest[idx], dest[idx+1], dest[idx+2],dest[idx+3],dest[idx+4],dest[idx+5],dest[idx+6],dest[idx+7]); Dbprintf("%d%d%d%d%d%d%d%d",dest[idx], dest[idx+1], dest[idx+2],dest[idx+3],dest[idx+4],dest[idx+5],dest[idx+6],dest[idx+7]);
Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+8], dest[idx+9], dest[idx+10],dest[idx+11],dest[idx+12],dest[idx+13],dest[idx+14],dest[idx+15]); Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+8], dest[idx+9], dest[idx+10],dest[idx+11],dest[idx+12],dest[idx+13],dest[idx+14],dest[idx+15]);
Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+16],dest[idx+17],dest[idx+18],dest[idx+19],dest[idx+20],dest[idx+21],dest[idx+22],dest[idx+23]); Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+16],dest[idx+17],dest[idx+18],dest[idx+19],dest[idx+20],dest[idx+21],dest[idx+22],dest[idx+23]);
@ -1028,58 +847,26 @@ void CmdIOdemodFSK(int findone, int *high, int *low, int ledcontrol)
Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+48],dest[idx+49],dest[idx+50],dest[idx+51],dest[idx+52],dest[idx+53],dest[idx+54],dest[idx+55]); Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+48],dest[idx+49],dest[idx+50],dest[idx+51],dest[idx+52],dest[idx+53],dest[idx+54],dest[idx+55]);
Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+56],dest[idx+57],dest[idx+58],dest[idx+59],dest[idx+60],dest[idx+61],dest[idx+62],dest[idx+63]); Dbprintf("%d%d%d%d%d%d%d%d",dest[idx+56],dest[idx+57],dest[idx+58],dest[idx+59],dest[idx+60],dest[idx+61],dest[idx+62],dest[idx+63]);
short version='\x00'; code = bytebits_to_byte(dest+idx,32);
char unknown='\x00'; code2 = bytebits_to_byte(dest+idx+32,32);
uint16_t number=0;
for(int j=14;j<18;j++){ short version = bytebits_to_byte(dest+idx+14,4);
//Dbprintf("%d",dest[idx+j]); char unknown = bytebits_to_byte(dest+idx+19,8) ;
version <<=1; uint16_t number = bytebits_to_byte(dest+idx+36,9);
if (dest[idx+j]) version |= 1;
}
for(int j=19;j<27;j++){
//Dbprintf("%d",dest[idx+j]);
unknown <<=1;
if (dest[idx+j]) unknown |= 1;
}
for(int j=36;j<45;j++){
//Dbprintf("%d",dest[idx+j]);
number <<=1;
if (dest[idx+j]) number |= 1;
}
for(int j=46;j<53;j++){
//Dbprintf("%d",dest[idx+j]);
number <<=1;
if (dest[idx+j]) number |= 1;
}
for(int j=0; j<32; j++){
code <<=1;
if(dest[idx+j]) code |= 1;
}
for(int j=32; j<64; j++){
code2 <<=1;
if(dest[idx+j]) code2 |= 1;
}
Dbprintf("XSF(%02d)%02x:%d (%08x%08x)",version,unknown,number,code,code2); Dbprintf("XSF(%02d)%02x:%d (%08x%08x)",version,unknown,number,code,code2);
if (ledcontrol) if (ledcontrol) LED_D_OFF();
LED_D_OFF();
}
// if we're only looking for one tag
if (findone){
//*high = hi;
//*low = lo;
LED_A_OFF();
return;
}
//hi=0;
//lo=0;
found=0;
}
// if we're only looking for one tag
if (findone){
LED_A_OFF();
return;
}
}
WDT_HIT();
} }
} DbpString("Stopped");
WDT_HIT(); if (ledcontrol) LED_A_OFF();
} }
/*------------------------------ /*------------------------------
@ -1669,78 +1456,81 @@ int DemodPCF7931(uint8_t **outBlocks) {
for (bitidx = 0; i < GraphTraceLen; i++) for (bitidx = 0; i < GraphTraceLen; i++)
{ {
if ( (GraphBuffer[i-1] > GraphBuffer[i] && dir == 1 && GraphBuffer[i] > lmax) || (GraphBuffer[i-1] < GraphBuffer[i] && dir == 0 && GraphBuffer[i] < lmin)) if ( (GraphBuffer[i-1] > GraphBuffer[i] && dir == 1 && GraphBuffer[i] > lmax) || (GraphBuffer[i-1] < GraphBuffer[i] && dir == 0 && GraphBuffer[i] < lmin))
{ {
lc = i - lastval; lc = i - lastval;
lastval = i; lastval = i;
// Switch depending on lc length: // Switch depending on lc length:
// Tolerance is 1/8 of clock rate (arbitrary) // Tolerance is 1/8 of clock rate (arbitrary)
if (abs(lc-clock/4) < tolerance) { if (abs(lc-clock/4) < tolerance) {
// 16T0 // 16T0
if((i - pmc) == lc) { /* 16T0 was previous one */ if((i - pmc) == lc) { /* 16T0 was previous one */
/* It's a PMC ! */ /* It's a PMC ! */
i += (128+127+16+32+33+16)-1; i += (128+127+16+32+33+16)-1;
lastval = i; lastval = i;
pmc = 0; pmc = 0;
block_done = 1; block_done = 1;
} }
else { else {
pmc = i; pmc = i;
} }
} else if (abs(lc-clock/2) < tolerance) { } else if (abs(lc-clock/2) < tolerance) {
// 32TO // 32TO
if((i - pmc) == lc) { /* 16T0 was previous one */ if((i - pmc) == lc) { /* 16T0 was previous one */
/* It's a PMC ! */ /* It's a PMC ! */
i += (128+127+16+32+33)-1; i += (128+127+16+32+33)-1;
lastval = i; lastval = i;
pmc = 0; pmc = 0;
block_done = 1; block_done = 1;
} }
else if(half_switch == 1) { else if(half_switch == 1) {
BitStream[bitidx++] = 0; BitStream[bitidx++] = 0;
half_switch = 0; half_switch = 0;
} }
else else
half_switch++; half_switch++;
} else if (abs(lc-clock) < tolerance) { } else if (abs(lc-clock) < tolerance) {
// 64TO // 64TO
BitStream[bitidx++] = 1; BitStream[bitidx++] = 1;
} else { } else {
// Error // Error
warnings++; warnings++;
if (warnings > 10) if (warnings > 10)
{ {
Dbprintf("Error: too many detection errors, aborting."); Dbprintf("Error: too many detection errors, aborting.");
return 0; return 0;
} }
} }
if(block_done == 1) { if(block_done == 1) {
if(bitidx == 128) { if(bitidx == 128) {
for(j=0; j<16; j++) { for(j=0; j<16; j++) {
Blocks[num_blocks][j] = 128*BitStream[j*8+7]+ Blocks[num_blocks][j] = 128*BitStream[j*8+7]+
64*BitStream[j*8+6]+ 64*BitStream[j*8+6]+
32*BitStream[j*8+5]+ 32*BitStream[j*8+5]+
16*BitStream[j*8+4]+ 16*BitStream[j*8+4]+
8*BitStream[j*8+3]+ 8*BitStream[j*8+3]+
4*BitStream[j*8+2]+ 4*BitStream[j*8+2]+
2*BitStream[j*8+1]+ 2*BitStream[j*8+1]+
BitStream[j*8]; BitStream[j*8];
} }
num_blocks++; num_blocks++;
} }
bitidx = 0; bitidx = 0;
block_done = 0; block_done = 0;
half_switch = 0; half_switch = 0;
} }
if (GraphBuffer[i-1] > GraphBuffer[i]) dir=0; if(i < GraphTraceLen)
else dir = 1; {
} if (GraphBuffer[i-1] > GraphBuffer[i]) dir=0;
if(bitidx==255) else dir = 1;
bitidx=0; }
warnings = 0; }
if(num_blocks == 4) break; if(bitidx==255)
bitidx=0;
warnings = 0;
if(num_blocks == 4) break;
} }
memcpy(outBlocks, Blocks, 16*num_blocks); memcpy(outBlocks, Blocks, 16*num_blocks);
return num_blocks; return num_blocks;

2
armsrc/util.c
View file

@ -225,7 +225,7 @@ void FormatVersionInformation(char *dst, int len, const char *prefix, void *vers
{ {
struct version_information *v = (struct version_information*)version_information; struct version_information *v = (struct version_information*)version_information;
dst[0] = 0; dst[0] = 0;
strncat(dst, prefix, len); strncat(dst, prefix, len-1);
if(v->magic != VERSION_INFORMATION_MAGIC) { if(v->magic != VERSION_INFORMATION_MAGIC) {
strncat(dst, "Missing/Invalid version information", len - strlen(dst) - 1); strncat(dst, "Missing/Invalid version information", len - strlen(dst) - 1);
return; return;

2
client/cmddata.c
View file

@ -556,7 +556,7 @@ int CmdManchesterDemod(const char *Cmd)
/* But it does not work if compiling on WIndows: therefore we just allocate a */ /* But it does not work if compiling on WIndows: therefore we just allocate a */
/* large array */ /* large array */
uint8_t BitStream[MAX_GRAPH_TRACE_LEN]; uint8_t BitStream[MAX_GRAPH_TRACE_LEN] = {0};
/* Detect high and lows */ /* Detect high and lows */
for (i = 0; i < GraphTraceLen; i++) for (i = 0; i < GraphTraceLen; i++)

3
client/cmdhf15.c
View file

@ -535,7 +535,8 @@ int CmdHF15CmdRaw (const char *cmd) {
*/ */
int prepareHF15Cmd(char **cmd, UsbCommand *c, uint8_t iso15cmd[], int iso15cmdlen) { int prepareHF15Cmd(char **cmd, UsbCommand *c, uint8_t iso15cmd[], int iso15cmdlen) {
int temp; int temp;
uint8_t *req=c->d.asBytes, uid[8]; uint8_t *req=c->d.asBytes;
uint8_t uid[8] = {0};
uint32_t reqlen=0; uint32_t reqlen=0;
// strip // strip

4
client/cmdhficlass.c
View file

@ -502,6 +502,8 @@ int CmdHFiClassReader_Dump(const char *Cmd)
SendCommand(&c); SendCommand(&c);
UsbCommand resp; UsbCommand resp;
uint8_t key_sel[8] = {0};
uint8_t key_sel_p[8] = { 0 };
if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) { if (WaitForResponseTimeout(CMD_ACK,&resp,4500)) {
uint8_t isOK = resp.arg[0] & 0xff; uint8_t isOK = resp.arg[0] & 0xff;
@ -520,8 +522,6 @@ int CmdHFiClassReader_Dump(const char *Cmd)
{ {
if(elite) if(elite)
{ {
uint8_t key_sel[8] = {0};
uint8_t key_sel_p[8] = { 0 };
//Get the key index (hash1) //Get the key index (hash1)
uint8_t key_index[8] = {0}; uint8_t key_index[8] = {0};

112
client/cmdhfmf.c
View file

@ -343,10 +343,6 @@ int CmdHF14AMfURdCard(const char *Cmd)
uint8_t isOK = 0; uint8_t isOK = 0;
uint8_t * data = NULL; uint8_t * data = NULL;
if (sectorNo > 15) {
PrintAndLog("Sector number must be less than 16");
return 1;
}
PrintAndLog("Attempting to Read Ultralight... "); PrintAndLog("Attempting to Read Ultralight... ");
UsbCommand c = {CMD_MIFAREU_READCARD, {sectorNo}}; UsbCommand c = {CMD_MIFAREU_READCARD, {sectorNo}};
@ -359,64 +355,24 @@ int CmdHF14AMfURdCard(const char *Cmd)
PrintAndLog("isOk:%02x", isOK); PrintAndLog("isOk:%02x", isOK);
if (isOK) if (isOK)
for (i = 0; i < 16; i++) { { // bit 0 and 1
switch(i){ PrintAndLog("Block %3d:%s ", 0,sprint_hex(data + 0 * 4, 4));
case 2: PrintAndLog("Block %3d:%s ", 1,sprint_hex(data + 1 * 4, 4));
//process lock bytes // bit 2
lockbytes_t=data+(i*4); //process lock bytes
lockbytes[0]=lockbytes_t[2]; lockbytes_t=data+(2*4);
lockbytes[1]=lockbytes_t[3]; lockbytes[0]=lockbytes_t[2];
for(int j=0; j<16; j++){ lockbytes[1]=lockbytes_t[3];
bit[j]=lockbytes[j/8] & ( 1 <<(7-j%8)); for(int j=0; j<16; j++){
} bit[j]=lockbytes[j/8] & ( 1 <<(7-j%8));
//PrintAndLog("LB %02x %02x", lockbytes[0],lockbytes[1]);
//PrintAndLog("LB2b %02x %02x %02x %02x %02x %02x %02x %02x",bit[8],bit[9],bit[10],bit[11],bit[12],bit[13],bit[14],bit[15]);
PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));
break;
case 3:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[4]);
break;
case 4:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[3]);
break;
case 5:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[2]);
break;
case 6:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[1]);
break;
case 7:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[0]);
break;
case 8:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[15]);
break;
case 9:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[14]);
break;
case 10:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[13]);
break;
case 11:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[12]);
break;
case 12:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[11]);
break;
case 13:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[10]);
break;
case 14:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[9]);
break;
case 15:
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[8]);
break;
default:
PrintAndLog("Block %3d:%s ", i,sprint_hex(data + i * 4, 4));
break;
} }
} //remaining
for (i = 3; i < 16; i++) {
int bitnum = (23-i) % 16;
PrintAndLog("Block %3d:%s [%d]", i,sprint_hex(data + i * 4, 4),bit[bitnum]);
}
}
} else { } else {
PrintAndLog("Command execute timeout"); PrintAndLog("Command execute timeout");
} }
@ -546,6 +502,7 @@ int CmdHF14AMfDump(const char *Cmd)
for (sectorNo=0; sectorNo<numSectors; sectorNo++) { for (sectorNo=0; sectorNo<numSectors; sectorNo++) {
if (fread( keyA[sectorNo], 1, 6, fin ) == 0) { if (fread( keyA[sectorNo], 1, 6, fin ) == 0) {
PrintAndLog("File reading error."); PrintAndLog("File reading error.");
fclose(fin);
return 2; return 2;
} }
} }
@ -553,10 +510,11 @@ int CmdHF14AMfDump(const char *Cmd)
for (sectorNo=0; sectorNo<numSectors; sectorNo++) { for (sectorNo=0; sectorNo<numSectors; sectorNo++) {
if (fread( keyB[sectorNo], 1, 6, fin ) == 0) { if (fread( keyB[sectorNo], 1, 6, fin ) == 0) {
PrintAndLog("File reading error."); PrintAndLog("File reading error.");
fclose(fin);
return 2; return 2;
} }
} }
fclose(fin);
// Read access rights to sectors // Read access rights to sectors
PrintAndLog("|-----------------------------------------|"); PrintAndLog("|-----------------------------------------|");
@ -666,7 +624,6 @@ int CmdHF14AMfDump(const char *Cmd)
PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks); PrintAndLog("Dumped %d blocks (%d bytes) to file dumpdata.bin", numblocks, 16*numblocks);
} }
fclose(fin);
return 0; return 0;
} }
@ -1004,6 +961,16 @@ int CmdHF14AMfNested(const char *Cmd)
int CmdHF14AMfChk(const char *Cmd) int CmdHF14AMfChk(const char *Cmd)
{ {
if (strlen(Cmd)<3) {
PrintAndLog("Usage: hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");
PrintAndLog(" * - all sectors");
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");
PrintAndLog("d - write keys to binary file\n");
PrintAndLog(" sample: hf mf chk 0 A 1234567890ab keys.dic");
PrintAndLog(" hf mf chk *1 ? t");
return 0;
}
FILE * f; FILE * f;
char filename[256]={0}; char filename[256]={0};
char buf[13]; char buf[13];
@ -1021,6 +988,7 @@ int CmdHF14AMfChk(const char *Cmd)
int transferToEml = 0; int transferToEml = 0;
int createDumpFile = 0; int createDumpFile = 0;
keyBlock = calloc(stKeyBlock, 6); keyBlock = calloc(stKeyBlock, 6);
if (keyBlock == NULL) return 1; if (keyBlock == NULL) return 1;
@ -1047,15 +1015,6 @@ int CmdHF14AMfChk(const char *Cmd)
num_to_bytes(defaultKeys[defaultKeyCounter], 6, (uint8_t*)(keyBlock + defaultKeyCounter * 6)); num_to_bytes(defaultKeys[defaultKeyCounter], 6, (uint8_t*)(keyBlock + defaultKeyCounter * 6));
} }
if (strlen(Cmd)<3) {
PrintAndLog("Usage: hf mf chk <block number>|<*card memory> <key type (A/B/?)> [t] [<key (12 hex symbols)>] [<dic (*.dic)>]");
PrintAndLog(" * - all sectors");
PrintAndLog("card memory - 0 - MINI(320 bytes), 1 - 1K, 2 - 2K, 4 - 4K, <other> - 1K");
PrintAndLog("d - write keys to binary file\n");
PrintAndLog(" sample: hf mf chk 0 A 1234567890ab keys.dic");
PrintAndLog(" hf mf chk *1 ? t");
return 0;
}
if (param_getchar(Cmd, 0)=='*') { if (param_getchar(Cmd, 0)=='*') {
blockNo = 3; blockNo = 3;
@ -1144,11 +1103,11 @@ int CmdHF14AMfChk(const char *Cmd)
keycnt++; keycnt++;
memset(buf, 0, sizeof(buf)); memset(buf, 0, sizeof(buf));
} }
fclose(f);
} else { } else {
PrintAndLog("File: %s: not found or locked.", filename); PrintAndLog("File: %s: not found or locked.", filename);
free(keyBlock); free(keyBlock);
return 1; return 1;
fclose(f);
} }
} }
} }
@ -1430,12 +1389,14 @@ int CmdHF14AMfELoad(const char *Cmd)
break; break;
} }
PrintAndLog("File reading error."); PrintAndLog("File reading error.");
fclose(f);
return 2; return 2;
} }
if (strlen(buf) < 32){ if (strlen(buf) < 32){
if(strlen(buf) && feof(f)) if(strlen(buf) && feof(f))
break; break;
PrintAndLog("File content error. Block data must include 32 HEX symbols"); PrintAndLog("File content error. Block data must include 32 HEX symbols");
fclose(f);
return 2; return 2;
} }
for (i = 0; i < 32; i += 2) { for (i = 0; i < 32; i += 2) {
@ -1444,6 +1405,7 @@ int CmdHF14AMfELoad(const char *Cmd)
} }
if (mfEmlSetMem(buf8, blockNum, 1)) { if (mfEmlSetMem(buf8, blockNum, 1)) {
PrintAndLog("Cant set emul block: %3d", blockNum); PrintAndLog("Cant set emul block: %3d", blockNum);
fclose(f);
return 3; return 3;
} }
blockNum++; blockNum++;
@ -1586,8 +1548,8 @@ int CmdHF14AMfEKeyPrn(const char *Cmd)
int CmdHF14AMfCSetUID(const char *Cmd) int CmdHF14AMfCSetUID(const char *Cmd)
{ {
uint8_t wipeCard = 0; uint8_t wipeCard = 0;
uint8_t uid[8]; uint8_t uid[8] = {0};
uint8_t oldUid[8]; uint8_t oldUid[8]= {0};
int res; int res;
if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') { if (strlen(Cmd) < 1 || param_getchar(Cmd, 0) == 'h') {

2
client/cmdlfem4x.c
View file

@ -319,7 +319,7 @@ int CmdEM4x50Read(const char *Cmd)
++i; ++i;
while ((GraphBuffer[i] > low) && (i<GraphTraceLen)) while ((GraphBuffer[i] > low) && (i<GraphTraceLen))
++i; ++i;
if (j>(MAX_GRAPH_TRACE_LEN/64)) { if (j>=(MAX_GRAPH_TRACE_LEN/64)) {
break; break;
} }
tmpbuff[j++]= i - start; tmpbuff[j++]= i - start;

22
client/cmdlfhitag.c
View file

@ -41,9 +41,6 @@ int CmdLFHitagList(const char *Cmd)
int i = 0; int i = 0;
int prev = -1; int prev = -1;
char filename[256];
FILE* pf = NULL;
for (;;) { for (;;) {
if(i >= 1900) { if(i >= 1900) {
break; break;
@ -107,22 +104,18 @@ int CmdLFHitagList(const char *Cmd)
line); line);
if (pf) { // if (pf) {
fprintf(pf," +%7d: %3d: %s %s\n", // fprintf(pf," +%7d: %3d: %s %s\n",
(prev < 0 ? 0 : (timestamp - prev)), // (prev < 0 ? 0 : (timestamp - prev)),
bits, // bits,
(isResponse ? "TAG" : " "), // (isResponse ? "TAG" : " "),
line); // line);
} // }
prev = timestamp; prev = timestamp;
i += (len + 9); i += (len + 9);
} }
if (pf) {
PrintAndLog("Recorded activity succesfully written to file: %s", filename);
fclose(pf);
}
return 0; return 0;
} }
@ -149,6 +142,7 @@ int CmdLFHitagSim(const char *Cmd) {
tag_mem_supplied = true; tag_mem_supplied = true;
if (fread(c.d.asBytes,48,1,pf) == 0) { if (fread(c.d.asBytes,48,1,pf) == 0) {
PrintAndLog("Error: File reading error"); PrintAndLog("Error: File reading error");
fclose(pf);
return 1; return 1;
} }
fclose(pf); fclose(pf);

3
client/cmdmain.c
View file

@ -134,8 +134,9 @@ int getCommand(UsbCommand* response)
*/ */
bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) { bool WaitForResponseTimeout(uint32_t cmd, UsbCommand* response, size_t ms_timeout) {
UsbCommand resp;
if (response == NULL) { if (response == NULL) {
UsbCommand resp;
response = &resp; response = &resp;
} }

10
client/loclass/ikeys.c
View file

@ -727,13 +727,17 @@ int readKeyFile(uint8_t key[8])
{ {
FILE *f; FILE *f;
int retval = 1;
f = fopen("iclass_key.bin", "rb"); f = fopen("iclass_key.bin", "rb");
if (f) if (f)
{ {
if(fread(key, sizeof(key), 1, f) == 1) return 0; if(fread(key, sizeof(uint8_t), 8, f) == 1)
{
retval = 0;
}
fclose(f);
} }
return 1; return retval;
} }

28
client/mifarehost.c
View file

@ -296,7 +296,7 @@ static uint8_t trailerAccessBytes[4] = {0x08, 0x77, 0x8F, 0x00};
// variables // variables
char logHexFileName[200] = {0x00}; char logHexFileName[200] = {0x00};
static uint8_t traceCard[4096] = {0x00}; static uint8_t traceCard[4096] = {0x00};
static char traceFileName[20]; static char traceFileName[200] = {0};
static int traceState = TRACE_IDLE; static int traceState = TRACE_IDLE;
static uint8_t traceCurBlock = 0; static uint8_t traceCurBlock = 0;
static uint8_t traceCurKey = 0; static uint8_t traceCurKey = 0;
@ -497,7 +497,7 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
break; break;
case TRACE_WRITE_OK: case TRACE_WRITE_OK:
if ((len == 1) && (data[0] = 0x0a)) { if ((len == 1) && (data[0] == 0x0a)) {
traceState = TRACE_WRITE_DATA; traceState = TRACE_WRITE_DATA;
return 0; return 0;
@ -555,23 +555,13 @@ int mfTraceDecode(uint8_t *data_src, int len, uint32_t parity, bool wantSaveToEm
at_par = parity; at_par = parity;
// decode key here) // decode key here)
if (!traceCrypto1) { ks2 = ar_enc ^ prng_successor(nt, 64);
ks2 = ar_enc ^ prng_successor(nt, 64); ks3 = at_enc ^ prng_successor(nt, 96);
ks3 = at_enc ^ prng_successor(nt, 96); revstate = lfsr_recovery64(ks2, ks3);
revstate = lfsr_recovery64(ks2, ks3); lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, 0, 0); lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, 0, 0); lfsr_rollback_word(revstate, nr_enc, 1);
lfsr_rollback_word(revstate, nr_enc, 1); lfsr_rollback_word(revstate, uid ^ nt, 0);
lfsr_rollback_word(revstate, uid ^ nt, 0);
}else{
ks2 = ar_enc ^ prng_successor(nt, 64);
ks3 = at_enc ^ prng_successor(nt, 96);
revstate = lfsr_recovery64(ks2, ks3);
lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, 0, 0);
lfsr_rollback_word(revstate, nr_enc, 1);
lfsr_rollback_word(revstate, uid ^ nt, 0);
}
crypto1_get_lfsr(revstate, &lfsr); crypto1_get_lfsr(revstate, &lfsr);
printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF)); printf("key> %x%x\n", (unsigned int)((lfsr & 0xFFFFFFFF00000000) >> 32), (unsigned int)(lfsr & 0xFFFFFFFF));
AddLogUint64(logHexFileName, "key> ", lfsr); AddLogUint64(logHexFileName, "key> ", lfsr);

6
client/nonce2key/crapto1.c
View file

@ -544,8 +544,14 @@ lfsr_common_prefix(uint32_t pfx, uint32_t rr, uint8_t ks[8], uint8_t par[8][8],
statelist = malloc((sizeof *statelist) << 21); //how large should be? statelist = malloc((sizeof *statelist) << 21); //how large should be?
if(!statelist || !odd || !even) if(!statelist || !odd || !even)
{
free(statelist);
free(odd);
free(even);
return 0; return 0;
}
s = statelist; s = statelist;
for(o = odd; *o != -1; ++o) for(o = odd; *o != -1; ++o)
for(e = even; *e != -1; ++e) for(e = even; *e != -1; ++e)

6
client/proxmark3.c
View file

@ -47,7 +47,11 @@ void SendCommand(UsbCommand *c) {
PrintAndLog("Sending bytes to proxmark failed - offline"); PrintAndLog("Sending bytes to proxmark failed - offline");
return; return;
} }
/**
The while-loop below causes hangups at times, when the pm3 unit is unresponsive
or disconnected. The main console thread is alive, but comm thread just spins here.
Not good.../holiman
**/
while(txcmd_pending); while(txcmd_pending);
txcmd = *c; txcmd = *c;
txcmd_pending = true; txcmd_pending = true;