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

Browse source
This commit is contained in:
micki.held@gmx.de 2013-07-08 17:56:05 +00:00
commit 1c611bbd26
9 changed files with 376 additions and 409 deletions
Download patch file Download diff file Expand all files Collapse all files

92
armsrc/appmain.c
View file

@ -626,7 +626,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
#ifdef WITH_LF
case CMD_ACQUIRE_RAW_ADC_SAMPLES_125K:
AcquireRawAdcSamples125k(c->arg[0]);
cmd_send(CMD_ACK,0,0,0,0,0);
cmd_send(CMD_ACK,0,0,0,0,0);
break;
case CMD_MOD_THEN_ACQUIRE_RAW_ADC_SAMPLES_125K:
ModThenAcquireRawAdcSamples125k(c->arg[0],c->arg[1],c->arg[2],c->d.asBytes);
@ -638,7 +638,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
CmdHIDsimTAG(c->arg[0], c->arg[1], 1); // Simulate HID tag by ID
break;
case CMD_HID_CLONE_TAG: // Clone HID tag by ID to T55x7
CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
CopyHIDtoT55x7(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
break;
case CMD_EM410X_WRITE_TAG:
WriteEM410x(c->arg[0], c->arg[1], c->arg[2]);
@ -663,26 +663,26 @@ void UsbPacketReceived(uint8_t *packet, int len)
case CMD_INDALA_CLONE_TAG_L: // Clone Indala 224-bit tag by UID to T55x7
CopyIndala224toT55x7(c->d.asDwords[0], c->d.asDwords[1], c->d.asDwords[2], c->d.asDwords[3], c->d.asDwords[4], c->d.asDwords[5], c->d.asDwords[6]);
break;
case CMD_T55XX_READ_BLOCK:
T55xxReadBlock(c->arg[1], c->arg[2],c->d.asBytes[0]);
break;
case CMD_T55XX_WRITE_BLOCK:
T55xxWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
break;
case CMD_T55XX_READ_TRACE: // Clone HID tag by ID to T55x7
T55xxReadTrace();
break;
case CMD_PCF7931_READ: // Read PCF7931 tag
ReadPCF7931();
cmd_send(CMD_ACK,0,0,0,0,0);
// UsbSendPacket((uint8_t*)&ack, sizeof(ack));
break;
case CMD_EM4X_READ_WORD:
EM4xReadWord(c->arg[1], c->arg[2],c->d.asBytes[0]);
break;
case CMD_EM4X_WRITE_WORD:
EM4xWriteWord(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
break;
case CMD_T55XX_READ_BLOCK:
T55xxReadBlock(c->arg[1], c->arg[2],c->d.asBytes[0]);
break;
case CMD_T55XX_WRITE_BLOCK:
T55xxWriteBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
break;
case CMD_T55XX_READ_TRACE: // Clone HID tag by ID to T55x7
T55xxReadTrace();
break;
case CMD_PCF7931_READ: // Read PCF7931 tag
ReadPCF7931();
cmd_send(CMD_ACK,0,0,0,0,0);
// UsbSendPacket((uint8_t*)&ack, sizeof(ack));
break;
case CMD_EM4X_READ_WORD:
EM4xReadWord(c->arg[1], c->arg[2],c->d.asBytes[0]);
break;
case CMD_EM4X_WRITE_WORD:
EM4xWriteWord(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes[0]);
break;
#endif
#ifdef WITH_HITAG
@ -772,7 +772,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
break;
case CMD_READER_MIFARE:
ReaderMifare(c);
ReaderMifare(c->arg[0]);
break;
case CMD_MIFARE_READBL:
MifareReadBlock(c->arg[0], c->arg[1], c->arg[2], c->d.asBytes);
@ -863,7 +863,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
LED_D_OFF(); // LED D indicates field ON or OFF
break;
case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K: {
case CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K:
// UsbCommand n;
// if(c->cmd == CMD_DOWNLOAD_RAW_ADC_SAMPLES_125K) {
// n.cmd = CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K;
@ -877,24 +877,24 @@ void UsbPacketReceived(uint8_t *packet, int len)
// UsbSendPacket((uint8_t *)&n, sizeof(n));
// LED_B_OFF();
LED_B_ON();
for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
}
// Trigger a finish downloading signal with an ACK frame
cmd_send(CMD_ACK,0,0,0,0,0);
LED_B_ON();
for(size_t i=0; i<c->arg[1]; i += USB_CMD_DATA_SIZE) {
size_t len = MIN((c->arg[1] - i),USB_CMD_DATA_SIZE);
cmd_send(CMD_DOWNLOADED_RAW_ADC_SAMPLES_125K,i,len,0,((byte_t*)BigBuf)+c->arg[0]+i,len);
}
// Trigger a finish downloading signal with an ACK frame
cmd_send(CMD_ACK,0,0,0,0,0);
LED_B_OFF();
} break;
break;
case CMD_DOWNLOADED_SIM_SAMPLES_125K: {
uint8_t *b = (uint8_t *)BigBuf;
memcpy(b+c->arg[0], c->d.asBytes, 48);
//Dbprintf("copied 48 bytes to %i",b+c->arg[0]);
// UsbSendPacket((uint8_t*)&ack, sizeof(ack));
cmd_send(CMD_ACK,0,0,0,0,0);
} break;
cmd_send(CMD_ACK,0,0,0,0,0);
break;
}
case CMD_READ_MEM:
ReadMem(c->arg[0]);
break;
@ -926,35 +926,35 @@ void UsbPacketReceived(uint8_t *packet, int len)
#endif
case CMD_SETUP_WRITE:
case CMD_FINISH_WRITE:
case CMD_HARDWARE_RESET: {
usb_disable();
case CMD_HARDWARE_RESET:
usb_disable();
SpinDelay(1000);
SpinDelay(1000);
AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
for(;;) {
// We're going to reset, and the bootrom will take control.
}
} break;
break;
case CMD_START_FLASH: {
case CMD_START_FLASH:
if(common_area.flags.bootrom_present) {
common_area.command = COMMON_AREA_COMMAND_ENTER_FLASH_MODE;
}
usb_disable();
usb_disable();
AT91C_BASE_RSTC->RSTC_RCR = RST_CONTROL_KEY | AT91C_RSTC_PROCRST;
for(;;);
} break;
break;
case CMD_DEVICE_INFO: {
uint32_t dev_info = DEVICE_INFO_FLAG_OSIMAGE_PRESENT | DEVICE_INFO_FLAG_CURRENT_MODE_OS;
if(common_area.flags.bootrom_present) dev_info |= DEVICE_INFO_FLAG_BOOTROM_PRESENT;
// UsbSendPacket((uint8_t*)&c, sizeof(c));
cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
} break;
default: {
cmd_send(CMD_DEVICE_INFO,dev_info,0,0,0,0);
break;
}
default:
Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
} break;
break;
}
}

2
armsrc/apps.h
View file

@ -156,7 +156,7 @@ void RAMFUNC SniffMifare(uint8_t param);
void EPA_PACE_Collect_Nonce(UsbCommand * c);
// mifarecmd.h
void ReaderMifare(UsbCommand *c);
void ReaderMifare(bool first_try);
void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *data);
void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain);
void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain);

556
armsrc/iso14443a.c
View file

@ -1612,7 +1612,7 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
int len;
// Broadcast for a card, WUPA (0x52) will force response from all cards in the field
ReaderTransmitBitsPar(wupa,7,0);
ReaderTransmitBitsPar(wupa,7,0);
// Receive the ATQA
if(!ReaderReceive(resp)) return 0;
// Dbprintf("atqa: %02x %02x",resp[0],resp[1]);
@ -1625,7 +1625,7 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
// clear uid
if (uid_ptr) {
memset(uid_ptr,0,8);
memset(uid_ptr,0,10);
}
// OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in
@ -1811,354 +1811,266 @@ void ReaderIso14443a(UsbCommand * c)
LEDsoff();
}
#define TEST_LENGTH 100
typedef struct mftest{
uint8_t nt[8];
uint8_t count;
}mftest ;
/**
*@brief Tunes the mifare attack settings. This method checks the nonce entropy when
*using a specified timeout.
*Different cards behave differently, some cards require up to a second to power down (and thus reset
*token generator), other cards are fine with 50 ms.
*
* @param time
* @return the entropy. A value of 100 (%) means that every nonce was unique, while a value close to
*zero indicates a low entropy: the given timeout is sufficient to power down the card.
*/
int TuneMifare(int time)
// prepare the Mifare AUTH transfer with an added necessary delay.
void PrepareDelayedAuthTransfer(uint8_t* frame, int len, uint16_t delay)
{
// Mifare AUTH
uint8_t mf_auth[] = { 0x60,0x00,0xf5,0x7b };
uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET);
CodeIso14443aBitsAsReaderPar(frame, len*8, GetParity(frame,len));
iso14443a_setup();
int TIME1=time;
int TIME2=2000;
uint8_t uid[8];
uint32_t cuid;
byte_t nt[4];
Dbprintf("Tuning... testing a delay of %d ms (press button to skip)",time);
uint8_t bitmask = 0;
uint8_t bits_to_shift = 0;
uint8_t bits_shifted = 0;
mftest nt_values[TEST_LENGTH];
int nt_size = 0;
int i = 0;
for(i = 0 ; i< 100 ; i++)
{
LED_C_OFF();
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
SpinDelay(TIME1);
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
LED_C_ON();
SpinDelayUs(TIME2);
if(!iso14443a_select_card(uid, NULL, &cuid)) continue;
// Transmit MIFARE_CLASSIC_AUTH
ReaderTransmit(mf_auth, sizeof(mf_auth));
// Receive the (16 bit) "random" nonce
if (!ReaderReceive(receivedAnswer)) continue;
memcpy(nt, receivedAnswer, 4);
//store it
int already_stored = 0;
for(int i = 0 ; i < nt_size && !already_stored; i++)
{
if( memcmp(nt, nt_values[i].nt, 4) == 0)
{
nt_values[i].count++;
already_stored = 1;
}
}
if(!already_stored)
{
mftest* ptr= &nt_values[nt_size++];
//Clear it before use
memset(ptr, 0, sizeof(mftest));
memcpy(ptr->nt, nt, 4);
ptr->count = 1;
}
if(BUTTON_PRESS())
{
Dbprintf("Tuning aborted prematurely");
break;
}
}
/*
for(int i = 0 ; i < nt_size;i++){
mftest x = nt_values[i];
Dbprintf("%d,%d,%d,%d : %d",x.nt[0],x.nt[1],x.nt[2],x.nt[3],x.count);
}
*/
int result = nt_size *100 / i;
Dbprintf(" ... results for %d ms : %d %",time, result);
return result;
if (delay) {
for (uint16_t i = 0; i < delay; i++) {
bitmask |= (0x01 << i);
}
ToSend[++ToSendMax] = 0x00;
for (uint16_t i = 0; i < ToSendMax; i++) {
bits_to_shift = ToSend[i] & bitmask;
ToSend[i] = ToSend[i] >> delay;
ToSend[i] = ToSend[i] | (bits_shifted << (8 - delay));
bits_shifted = bits_to_shift;
}
}
}
// Determine the distance between two nonces.
// Assume that the difference is small, but we don't know which is first.
// Therefore try in alternating directions.
int32_t dist_nt(uint32_t nt1, uint32_t nt2) {
uint16_t i;
uint32_t nttmp1, nttmp2;
if (nt1 == nt2) return 0;
nttmp1 = nt1;
nttmp2 = nt2;
for (i = 1; i < 32768; i++) {
nttmp1 = prng_successor(nttmp1, 1);
if (nttmp1 == nt2) return i;
nttmp2 = prng_successor(nttmp2, 1);
if (nttmp2 == nt1) return -i;
}
return(-99999); // either nt1 or nt2 are invalid nonces
}
//-----------------------------------------------------------------------------
// Read an ISO 14443a tag. Send out commands and store answers.
//
// Recover several bits of the cypher stream. This implements (first stages of)
// the algorithm described in "The Dark Side of Security by Obscurity and
// Cloning MiFare Classic Rail and Building Passes, Anywhere, Anytime"
// (article by Nicolas T. Courtois, 2009)
//-----------------------------------------------------------------------------
#define STATE_SIZE 100
typedef struct AttackState{
byte_t nt[4];
byte_t par_list[8];
byte_t ks_list[8];
byte_t par;
byte_t par_low;
byte_t nt_diff;
uint8_t mf_nr_ar[8];
} AttackState;
int continueAttack(AttackState* pState,uint8_t* receivedAnswer)
void ReaderMifare(bool first_try)
{
// Transmit reader nonce and reader answer
ReaderTransmitPar(pState->mf_nr_ar, sizeof(pState->mf_nr_ar),pState->par);
// Receive 4 bit answer
int len = ReaderReceive(receivedAnswer);
if (!len)
{
if (pState->nt_diff == 0)
{
pState->par++;
} else {
pState->par = (((pState->par >> 3) + 1) << 3) | pState->par_low;
}
return 2;
}
if(pState->nt_diff == 0)
{
pState->par_low = pState->par & 0x07;
}
//Dbprintf("answer received, parameter (%d), (memcmp(nt, nt_no)=%d",parameter,memcmp(nt, nt_noattack, 4));
//if ( (parameter != 0) && (memcmp(nt, nt_noattack, 4) == 0) ) continue;
//isNULL = 0;//|| !(nt_attacked[0] == 0) && (nt_attacked[1] == 0) && (nt_attacked[2] == 0) && (nt_attacked[3] == 0);
//
// if ( /*(isNULL != 0 ) && */(memcmp(nt, nt_attacked, 4) != 0) ) continue;
//led_on = !led_on;
//if(led_on) LED_B_ON(); else LED_B_OFF();
pState->par_list[pState->nt_diff] = pState->par;
pState->ks_list[pState->nt_diff] = receivedAnswer[0] ^ 0x05;
// Test if the information is complete
if (pState->nt_diff == 0x07) {
return 0;
}
pState->nt_diff = (pState->nt_diff + 1) & 0x07;
pState->mf_nr_ar[3] = pState->nt_diff << 5;
pState->par = pState->par_low;
return 1;
}
void reportResults(uint8_t uid[8],AttackState *pState, int isOK)
{
LogTrace(pState->nt, 4, 0, GetParity(pState->nt, 4), TRUE);
LogTrace(pState->par_list, 8, 0, GetParity(pState->par_list, 8), TRUE);
LogTrace(pState->ks_list, 8, 0, GetParity(pState->ks_list, 8), TRUE);
byte_t buf[48];
memcpy(buf + 0, uid, 4);
if(pState != NULL)
{
memcpy(buf + 4, pState->nt, 4);
memcpy(buf + 8, pState->par_list, 8);
memcpy(buf + 16, pState->ks_list, 8);
}
LED_B_ON();
cmd_send(CMD_ACK,isOK,0,0,buf,48);
LED_B_OFF();
// Thats it...
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff();
tracing = TRUE;
if (MF_DBGLEVEL >= 1) DbpString("COMMAND mifare FINISHED");
}
void ReaderMifareBegin(uint32_t offset_time, uint32_t powerdown_time);
/**
* @brief New implementation of ReaderMifare, the classic mifare attack.
* This implementation is backwards-compatible, but has some added parameters.
* @param c the usbcommand in complete
* c->arg[0] - nt_noattack (deprecated)
* c->arg[1] - offset_time us (0 => random)
* c->arg[2] - powerdown_time ms (0=> tuning)
*
*/
void ReaderMifare(UsbCommand *c)
{
/*
* The 'no-attack' is not used anymore, with the introduction of
* state tables. Instead, we use an offset which is random. This means that we
* should not get stuck on a 'bad' nonce, so no-attack is not needed.
* Anyway, arg[0] is reserved for backwards compatibility
uint32_t nt_noattack_uint = c->arg[0];
byte_t nt_noattack[4];
num_to_bytes(parameter, 4, nt_noattack_uint);
*/
/*
*IF, for some reason, you want to attack a specific nonce or whatever,
*you can specify the offset time yourself, in which case it won't be random.
*
* The offset time is microseconds, MICROSECONDS, not ms.
*/
uint32_t offset_time = c->arg[1];
if(offset_time == 0)
{
//[Martin:]I would like to have used rand(), but linking problems prevented it
//offset_time = rand() % 4000;
//So instead, I found this nifty thingy, which seems to fit the bill
offset_time = GetTickCount() % 2000;
}
/*
* There is an implementation of tuning. Tuning will try to determine
* a good power-down time, which is different for different cards.
* If a value is specified from the packet, we won't do any tuning.
* A value of zero will initialize a tuning.
* The power-down time is milliseconds, that MILLI-seconds .
*/
uint32_t powerdown_time = c->arg[2];
if(powerdown_time == 0)
{
//Tuning required
int entropy = 100;
int time = 25;
entropy = TuneMifare(time);
while(entropy > 50 && time < 2000){
//Increase timeout, but never more than 500ms at a time
time = MIN(time*2, time+500);
entropy = TuneMifare(time);
}
if(entropy > 50){
Dbprintf("OBS! This card has high entropy (%d) and slow power-down. This may take a while", entropy);
}
powerdown_time = time;
}
//The actual attack
ReaderMifareBegin(offset_time, powerdown_time);
}
void ReaderMifareBegin(uint32_t offset_time, uint32_t powerdown_time)
{
Dbprintf("Using power-down-time of %d ms, offset time %d us", powerdown_time, offset_time);
/**
*Allocate our state-table and initialize with zeroes
**/
AttackState states[STATE_SIZE] ;
//Dbprintf("Memory allocated ok! (%d bytes)",STATE_SIZE*sizeof(AttackState) );
memset(states, 0, STATE_SIZE*sizeof(AttackState));
// Mifare AUTH
// Mifare AUTH
uint8_t mf_auth[] = { 0x60,0x00,0xf5,0x7b };
uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET); // was 3560 - tied to other size changes
uint8_t mf_nr_ar[] = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
static uint8_t mf_nr_ar3;
traceLen = 0;
uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET);
traceLen = 0;
tracing = false;
iso14443a_setup();
byte_t nt_diff = 0;
byte_t par = 0;
//byte_t par_mask = 0xff;
static byte_t par_low = 0;
bool led_on = TRUE;
uint8_t uid[10];
uint32_t cuid;
uint32_t nt, previous_nt;
static uint32_t nt_attacked = 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};
static uint32_t sync_time;
static uint32_t sync_cycles;
int catch_up_cycles = 0;
int last_catch_up = 0;
uint16_t consecutive_resyncs = 0;
int isOK = 0;
if (first_try) {
StartCountMifare();
mf_nr_ar3 = 0;
iso14443a_setup();
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_TAGSIM_LISTEN); // resets some FPGA internal registers
while((GetCountMifare() & 0xffff0000) != 0x10000); // wait for counter to reset and "warm up"
while(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME); // wait for ssp_frame to be low
while(!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_FRAME)); // sync on rising edge of ssp_frame
sync_time = GetCountMifare();
sync_cycles = 65536; // theory: Mifare Classic's random generator repeats every 2^16 cycles (and so do the nonces).
nt_attacked = 0;
nt = 0;
par = 0;
}
else {
// we were unsuccessful on a previous call. Try another READER nonce (first 3 parity bits remain the same)
// nt_attacked = prng_successor(nt_attacked, 1);
mf_nr_ar3++;
mf_nr_ar[3] = mf_nr_ar3;
par = par_low;
}
LED_A_ON();
LED_B_OFF();
LED_C_OFF();
LED_A_OFF();
uint8_t uid[8];
uint32_t cuid;
byte_t nt[4];
int nts_attacked= 0;
//Keeps track of progress (max value of nt_diff for our states)
int progress = 0;
int high_entropy_warning_issued = 0;
while(!BUTTON_PRESS())
{
LED_C_OFF();
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
SpinDelay(powerdown_time);
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
for(uint16_t i = 0; TRUE; i++) {
WDT_HIT();
// Test if the action was cancelled
if(BUTTON_PRESS()) {
break;
}
LED_C_ON();
SpinDelayUs(offset_time);
if(!iso14443a_select_card(uid, NULL, &cuid)) continue;
if(!iso14443a_select_card(uid, NULL, &cuid)) {
continue;
}
//keep the card active
FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
PrepareDelayedAuthTransfer(mf_auth, sizeof(mf_auth), (sync_cycles + catch_up_cycles) & 0x00000007);
sync_time = sync_time + ((sync_cycles + catch_up_cycles) & 0xfffffff8);
catch_up_cycles = 0;
// if we missed the sync time already, advance to the next nonce repeat
while(GetCountMifare() > sync_time) {
sync_time = sync_time + (sync_cycles & 0xfffffff8);
}
// now sync. After syncing, the following Classic Auth will return the same tag nonce (mostly)
while(GetCountMifare() < sync_time);
// Transmit MIFARE_CLASSIC_AUTH
ReaderTransmit(mf_auth, sizeof(mf_auth));
int samples = 0;
int wait = 0;
TransmitFor14443a(ToSend, ToSendMax, &samples, &wait);
// Receive the (16 bit) "random" nonce
if (!ReaderReceive(receivedAnswer)) continue;
memcpy(nt, receivedAnswer, 4);
// Receive the (4 Byte) "random" nonce
if (!ReaderReceive(receivedAnswer)) {
continue;
}
//Now we have the NT. Check if this NT is already under attack
AttackState* pState = NULL;
int i = 0;
for(i = 0 ; i < nts_attacked && pState == NULL; i++)
{
if( memcmp(nt, states[i].nt, 4) == 0)
{
//we have it
pState = &states[i];
//Dbprintf("Existing state found (%d)", i);
}
}
if(pState == NULL){
if(nts_attacked < STATE_SIZE )
{
//Initialize a new state
pState = &states[nts_attacked++];
//Clear it before use
memset(pState, 0, sizeof(AttackState));
memcpy(pState->nt, nt, 4);
i = nts_attacked;
//Dbprintf("New state created, nt=");
}else if(!high_entropy_warning_issued){
/**
*If we wound up here, it means that the state table was eaten up by potential nonces. This could be fixed by
*increasing the size of the state buffer, however, it points to some other problem. Ideally, we should get the same nonce
*every time. Realistically we should get a few different nonces, but if we get more than 50, there is probably somehting
*else that is wrong. An attack using too high nonce entropy will take **LONG** time to finish.
*/
DbpString("WARNING: Nonce entropy is suspiciously high, something is wrong. Check timeouts (and perhaps increase STATE_SIZE)");
high_entropy_warning_issued = 1;
}
}
if(pState == NULL) continue;
previous_nt = nt;
nt = bytes_to_num(receivedAnswer, 4);
int result = continueAttack(pState, receivedAnswer);
// Transmit reader nonce with fake par
ReaderTransmitPar(mf_nr_ar, sizeof(mf_nr_ar), par);
if(result == 1){
//One state progressed another step
if(pState->nt_diff > progress)
{
progress = pState->nt_diff;
//Alert the user
Dbprintf("Recovery progress: %d/8, NTs attacked: %d ", progress,nts_attacked );
}
//Dbprintf("State increased to %d in state %d", pState->nt_diff, i);
}
else if(result == 2){
//Dbprintf("Continue attack no answer, par is now %d", pState->par);
}
else if(result == 0){
reportResults(uid,pState,1);
return;
}
}
reportResults(uid,NULL,0);
if (first_try && previous_nt && !nt_attacked) { // we didn't calibrate our clock yet
int nt_distance = dist_nt(previous_nt, nt);
if (nt_distance == 0) {
nt_attacked = nt;
}
else {
if (nt_distance == -99999) { // invalid nonce received, try again
continue;
}
sync_cycles = (sync_cycles - nt_distance);
// Dbprintf("calibrating in cycle %d. nt_distance=%d, Sync_cycles: %d\n", i, nt_distance, sync_cycles);
continue;
}
}
if ((nt != nt_attacked) && nt_attacked) { // we somehow lost sync. Try to catch up again...
catch_up_cycles = -dist_nt(nt_attacked, nt);
if (catch_up_cycles == 99999) { // invalid nonce received. Don't resync on that one.
catch_up_cycles = 0;
continue;
}
if (catch_up_cycles == last_catch_up) {
consecutive_resyncs++;
}
else {
last_catch_up = catch_up_cycles;
consecutive_resyncs = 0;
}
if (consecutive_resyncs < 3) {
Dbprintf("Lost sync in cycle %d. nt_distance=%d. Consecutive Resyncs = %d. Trying one time catch up...\n", i, -catch_up_cycles, consecutive_resyncs);
}
else {
sync_cycles = sync_cycles + catch_up_cycles;
Dbprintf("Lost sync in cycle %d for the fourth time consecutively (nt_distance = %d). Adjusting sync_cycles to %d.\n", i, -catch_up_cycles, sync_cycles);
}
continue;
}
consecutive_resyncs = 0;
// Receive answer. This will be a 4 Bit NACK when the 8 parity bits are OK after decoding
if (ReaderReceive(receivedAnswer))
{
catch_up_cycles = 8; // the PRNG doesn't run during data transfers. 4 Bit = 8 cycles
if (nt_diff == 0)
{
par_low = par & 0x07; // there is no need to check all parities for other nt_diff. Parity Bits for mf_nr_ar[0..2] won't change
}
led_on = !led_on;
if(led_on) LED_B_ON(); else LED_B_OFF();
par_list[nt_diff] = par;
ks_list[nt_diff] = receivedAnswer[0] ^ 0x05;
// Test if the information is complete
if (nt_diff == 0x07) {
isOK = 1;
break;
}
nt_diff = (nt_diff + 1) & 0x07;
mf_nr_ar[3] = (mf_nr_ar[3] & 0x1F) | (nt_diff << 5);
par = par_low;
} else {
if (nt_diff == 0 && first_try)
{
par++;
} else {
par = (((par >> 3) + 1) << 3) | par_low;
}
}
}
LogTrace((const uint8_t *)&nt, 4, 0, GetParity((const uint8_t *)&nt, 4), TRUE);
LogTrace(par_list, 8, 0, GetParity(par_list, 8), TRUE);
LogTrace(ks_list, 8, 0, GetParity(ks_list, 8), TRUE);
mf_nr_ar[3] &= 0x1F;
byte_t buf[28];
memcpy(buf + 0, uid, 4);
num_to_bytes(nt, 4, buf + 4);
memcpy(buf + 8, par_list, 8);
memcpy(buf + 16, ks_list, 8);
memcpy(buf + 24, mf_nr_ar, 4);
cmd_send(CMD_ACK,isOK,0,0,buf,28);
// Thats it...
FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
LEDsoff();
tracing = TRUE;
}
//-----------------------------------------------------------------------------
// MIFARE 1K simulate.
//

18
armsrc/mifarecmd.c
View file

@ -28,7 +28,7 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables
byte_t isOK = 0;
byte_t dataoutbuf[16];
uint8_t uid[8];
uint8_t uid[10];
uint32_t cuid;
struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs;
@ -109,7 +109,7 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables
byte_t isOK = 0;
byte_t dataoutbuf[16 * 4];
uint8_t uid[8];
uint8_t uid[10];
uint32_t cuid;
struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs;
@ -208,7 +208,7 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables
byte_t isOK = 0;
uint8_t uid[8];
uint8_t uid[10];
uint32_t cuid;
struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs;
@ -298,7 +298,7 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
// variables
int rtr, i, j, m, len;
int davg, dmin, dmax;
uint8_t uid[8];
uint8_t uid[10];
uint32_t cuid, nt1, nt2, nttmp, nttest, par, ks1;
uint8_t par_array[4];
nestedVector nvector[NES_MAX_INFO + 1][11];
@ -493,7 +493,6 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
}
LED_B_ON();
SpinDelay(100);
cmd_send(CMD_ACK,0,ncount,targetBlockNo + (targetKeyType * 0x100),buf,48);
// UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
LED_B_OFF();
@ -507,7 +506,6 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
// memset(ack.d.asBytes, 0x00, sizeof(ack.d.asBytes));
LED_B_ON();
SpinDelay(300);
// UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));
cmd_send(CMD_ACK,1,0,0,0,0);
LED_B_OFF();
@ -536,7 +534,7 @@ void MifareChkKeys(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
// variables
int i;
byte_t isOK = 0;
uint8_t uid[8];
uint8_t uid[10];
uint32_t cuid;
struct Crypto1State mpcs = {0, 0};
struct Crypto1State *pcs;
@ -649,7 +647,7 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
// variables
byte_t dataoutbuf[16];
byte_t dataoutbuf2[16];
uint8_t uid[8];
uint8_t uid[10];
// clear trace
iso14a_clear_trace();
@ -761,11 +759,11 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
// variables
byte_t isOK = 0;
uint8_t uid[8];
uint8_t uid[10];
uint8_t d_block[18];
uint32_t cuid;
memset(uid, 0x00, 8);
memset(uid, 0x00, 10);
uint8_t* receivedAnswer = mifare_get_bigbufptr();
if (workFlags & 0x08) {

59
armsrc/util.c
View file

@ -298,7 +298,7 @@ void StartCountUS()
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN;
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN;
AT91C_BASE_TCB->TCB_BCR = 1;
}
}
uint32_t RAMFUNC GetCountUS(){
return (AT91C_BASE_TC1->TC_CV * 0x8000) + ((AT91C_BASE_TC0->TC_CV / 15) * 10);
@ -314,3 +314,60 @@ uint32_t RAMFUNC GetDeltaCountUS(){
}
// -------------------------------------------------------------------------
// Mifare timer. Uses ssp_clk from FPGA
// -------------------------------------------------------------------------
void StartCountMifare()
{
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0) | (1 << AT91C_ID_TC1) | (1 << AT91C_ID_TC2); // Enable Clock to all timers
AT91C_BASE_TCB->TCB_BMR = AT91C_TCB_TC0XC0S_TIOA1 // XC0 Clock = TIOA1
| AT91C_TCB_TC1XC1S_NONE // XC1 Clock = none
| AT91C_TCB_TC2XC2S_TIOA0; // XC2 Clock = TIOA0
// configure TC1 to create a short pulse on TIOA1 when a rising edge on TIOB1 (= ssp_clk from FPGA) occurs:
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // disable TC1
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV1_CLOCK // TC1 Clock = MCK(48MHz)/2 = 24MHz
| AT91C_TC_CPCSTOP // Stop clock on RC compare
| AT91C_TC_EEVTEDG_RISING // Trigger on rising edge of Event
| AT91C_TC_EEVT_TIOB // Event-Source: TIOB1 (= ssc_clk from FPGA = 13,56MHz / 16)
| AT91C_TC_ENETRG // Enable external trigger event
| AT91C_TC_WAVESEL_UP // Upmode without automatic trigger on RC compare
| AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_AEEVT_SET // Set TIOA1 on external event
| AT91C_TC_ACPC_CLEAR; // Clear TIOA1 on RC Compare
AT91C_BASE_TC1->TC_RC = 0x04; // RC Compare value = 0x04
// use TC0 to count TIOA1 pulses
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS; // disable TC0
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_XC0 // TC0 clock = XC0 clock = TIOA1
| AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_WAVESEL_UP // just count
| AT91C_TC_ACPA_CLEAR // Clear TIOA0 on RA Compare
| AT91C_TC_ACPC_SET; // Set TIOA0 on RC Compare
AT91C_BASE_TC0->TC_RA = 1; // RA Compare value = 1; pulse width to TC2
AT91C_BASE_TC0->TC_RC = 0; // RC Compare value = 0; increment TC2 on overflow
// use TC2 to count TIOA0 pulses (giving us a 32bit counter (TC0/TC2) clocked by ssp_clk)
AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKDIS; // disable TC2
AT91C_BASE_TC2->TC_CMR = AT91C_TC_CLKS_XC2 // TC2 clock = XC2 clock = TIOA0
| AT91C_TC_WAVE // Waveform Mode
| AT91C_TC_WAVESEL_UP; // just count
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN; // enable TC0
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN; // enable TC1
AT91C_BASE_TC2->TC_CCR = AT91C_TC_CLKEN; // enable TC2
AT91C_BASE_TCB->TCB_BCR = 1; // assert Sync (set all timers to 0 on next active clock edge)
}
uint32_t RAMFUNC GetCountMifare(){
uint32_t tmp_count;
tmp_count = (AT91C_BASE_TC2->TC_CV << 16) | AT91C_BASE_TC0->TC_CV;
if ((tmp_count & 0xffff) == 0) { //small chance that we may have missed an increment in TC2
return (AT91C_BASE_TC2->TC_CV << 16);
}
else {
return tmp_count;
}
}

3
armsrc/util.h
View file

@ -47,4 +47,7 @@ void StartCountUS();
uint32_t RAMFUNC GetCountUS();
uint32_t RAMFUNC GetDeltaCountUS();
void StartCountMifare();
uint32_t RAMFUNC GetCountMifare();
#endif

35
client/cmdhfmf.c
View file

@ -15,18 +15,20 @@ static int CmdHelp(const char *Cmd);
int CmdHF14AMifare(const char *Cmd)
{
uint32_t uid = 0;
uint32_t nt = 0;
uint32_t nt = 0, nr = 0;
uint64_t par_list = 0, ks_list = 0, r_key = 0;
uint8_t isOK = 0;
uint8_t keyBlock[8] = {0};
if (param_getchar(Cmd, 0) && param_gethex(Cmd, 0, keyBlock, 8)) {
PrintAndLog("Nt must include 8 HEX symbols");
return 1;
}
UsbCommand c = {CMD_READER_MIFARE, {true, 0, 0}};
// message
printf("-------------------------------------------------------------------------\n");
printf("Executing command. Expected execution time: 25sec on average :-)\n");
printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");
printf("-------------------------------------------------------------------------\n");
UsbCommand c = {CMD_READER_MIFARE, {(uint32_t)bytes_to_num(keyBlock, 4), 0, 0}};
start:
clearCommandBuffer();
SendCommand(&c);
@ -34,15 +36,10 @@ start:
//flush queue
while (ukbhit()) getchar();
// message
printf("-------------------------------------------------------------------------\n");
printf("Executing command. It may take up to 30 min.\n");
printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");
printf("-------------------------------------------------------------------------\n");
// wait cycle
while (true) {
//printf(".");
printf(".");
fflush(stdout);
if (ukbhit()) {
getchar();
@ -51,27 +48,26 @@ start:
}
UsbCommand resp;
if (WaitForResponseTimeout(CMD_ACK,&resp,2000)) {
if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
isOK = resp.arg[0] & 0xff;
uid = (uint32_t)bytes_to_num(resp.d.asBytes + 0, 4);
nt = (uint32_t)bytes_to_num(resp.d.asBytes + 4, 4);
par_list = bytes_to_num(resp.d.asBytes + 8, 8);
ks_list = bytes_to_num(resp.d.asBytes + 16, 8);
nr = bytes_to_num(resp.d.asBytes + 24, 4);
printf("\n\n");
PrintAndLog("isOk:%02x", isOK);
if (!isOK) PrintAndLog("Proxmark can't get statistic info. Execution aborted.\n");
break;
}
}
printf("\n");
// error
if (isOK != 1) return 1;
// execute original function from util nonce2key
if (nonce2key(uid, nt, par_list, ks_list, &r_key))
if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key))
{
isOK = 2;
PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);
@ -86,8 +82,9 @@ start:
PrintAndLog("Found valid key:%012"llx, r_key);
else
{
if (isOK != 2) PrintAndLog("Found invalid key. ( Nt=%08x ,Trying use it to run again...", nt);
c.arg[0] = nt;
if (isOK != 2) PrintAndLog("Found invalid key. ");
PrintAndLog("Failing is expected to happen in 25%% of all cases. Trying again with a different reader nonce...");
c.arg[0] = false;
goto start;
}

6
client/nonce2key/nonce2key.c
View file

@ -17,12 +17,12 @@
#include "nonce2key.h"
#include "ui.h"
int nonce2key(uint32_t uid, uint32_t nt, uint64_t par_info, uint64_t ks_info, uint64_t * key) {
int nonce2key(uint32_t uid, uint32_t nt, uint32_t nr, uint64_t par_info, uint64_t ks_info, uint64_t * key) {
struct Crypto1State *state, *state_s;
uint32_t pos, nr, rr, nr_diff;//, ks1, ks2;
uint32_t pos, rr, nr_diff;//, ks1, ks2;
byte_t bt, i, ks3x[8], par[8][8];
uint64_t key_recovered;
nr = rr = 0;
rr = 0;
// Reset the last three significant bits of the reader nonce
nr &= 0xffffff1f;

2
client/nonce2key/nonce2key.h
View file

@ -18,6 +18,6 @@
#include "crapto1.h"
#include "common.h"
int nonce2key(uint32_t uid, uint32_t nt, uint64_t par_info, uint64_t ks_info, uint64_t * key);
int nonce2key(uint32_t uid, uint32_t nt, uint32_t nr, uint64_t par_info, uint64_t ks_info, uint64_t * key);
#endif