ADD: marshmellows new lf command and DetectClock. (works great!)

[proxmark3-svn] / armsrc / iso14443a.c

diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index aed6a1fe302bb5598a477f39ba285324f7253a77..8399c6f84bb7e24eeeeee8258622dd7b60930d95 100644 (file)
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -310,10 +310,11 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
        if (Uart.state == STATE_UNSYNCD) {                                                                                      // not yet synced
        
                if (Uart.highCnt < 7) {                                                                                                 // wait for a stable unmodulated signal
        if (Uart.state == STATE_UNSYNCD) {                                                                                      // not yet synced
        
                if (Uart.highCnt < 7) {                                                                                                 // wait for a stable unmodulated signal

-                       if (Uart.twoBits == 0xffff)
+                       if (Uart.twoBits == 0xffff) {

                                Uart.highCnt++;
                                Uart.highCnt++;

-                       else
+                       } else {

                                Uart.highCnt = 0;
                                Uart.highCnt = 0;

+                       }

                } else {
                        Uart.syncBit = 0xFFFF; // not set
                        // look for 00xx1111 (the start bit)
                } else {
                        Uart.syncBit = 0xFFFF; // not set
                        // look for 00xx1111 (the start bit)


@@ -393,8 +394,12 @@ static RAMFUNC bool MillerDecoding(uint8_t bit, uint32_t non_real_time)
                                } else if (Uart.len & 0x0007) {                 // there are some parity bits to store
                                        Uart.parityBits <<= (8 - (Uart.len & 0x0007)); // left align remaining parity bits
                                        Uart.parity[Uart.parityLen++] = Uart.parityBits; // and store them
                                } else if (Uart.len & 0x0007) {                 // there are some parity bits to store
                                        Uart.parityBits <<= (8 - (Uart.len & 0x0007)); // left align remaining parity bits
                                        Uart.parity[Uart.parityLen++] = Uart.parityBits; // and store them

-                                       return TRUE;                                            // we are finished with decoding the raw data sequence

                                        }
                                        }

+                                       if ( Uart.len) {
+                                       return TRUE;                                            // we are finished with decoding the raw data sequence
+                                       } else {
+                                               UartReset();                                    // Nothing receiver - start over
+                                       }                                       

                                }
                                if (Uart.state == STATE_START_OF_COMMUNICATION) {                               // error - must not follow directly after SOC
                                        UartReset();
                                }
                                if (Uart.state == STATE_START_OF_COMMUNICATION) {                               // error - must not follow directly after SOC
                                        UartReset();


@@ -555,6 +560,8 @@ static RAMFUNC int ManchesterDecoding(uint8_t bit, uint16_t offset, uint32_t non
                                        } else if (Demod.len & 0x0007) { // there are some parity bits to store
                                                Demod.parityBits <<= (8 - (Demod.len & 0x0007)); // left align remaining parity bits
                                                Demod.parity[Demod.parityLen++] = Demod.parityBits; // and store them
                                        } else if (Demod.len & 0x0007) { // there are some parity bits to store
                                                Demod.parityBits <<= (8 - (Demod.len & 0x0007)); // left align remaining parity bits
                                                Demod.parity[Demod.parityLen++] = Demod.parityBits; // and store them

+                                       }
+                                       if (Demod.len) {

                                        return TRUE; // we are finished with decoding the raw data sequence
                                } else {                                                                                                // nothing received. Start over
                                        DemodReset();
                                        return TRUE; // we are finished with decoding the raw data sequence
                                } else {                                                                                                // nothing received. Start over
                                        DemodReset();


@@ -1602,8 +1609,7 @@ int EmSendCmdPar(uint8_t *resp, uint16_t respLen, uint8_t *par){
 bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_StartTime, uint32_t reader_EndTime, uint8_t *reader_Parity,
                                 uint8_t *tag_data, uint16_t tag_len, uint32_t tag_StartTime, uint32_t tag_EndTime, uint8_t *tag_Parity)
 {
 bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_StartTime, uint32_t reader_EndTime, uint8_t *reader_Parity,
                                 uint8_t *tag_data, uint16_t tag_len, uint32_t tag_StartTime, uint32_t tag_EndTime, uint8_t *tag_Parity)
 {

-       if (!tracing) return true;
-
+       if (tracing) {

        // we cannot exactly measure the end and start of a received command from reader. However we know that the delay from
        // end of the received command to start of the tag's (simulated by us) answer is n*128+20 or n*128+84 resp.
        // with n >= 9. The start of the tags answer can be measured and therefore the end of the received command be calculated:
        // we cannot exactly measure the end and start of a received command from reader. However we know that the delay from
        // end of the received command to start of the tag's (simulated by us) answer is n*128+20 or n*128+84 resp.
        // with n >= 9. The start of the tags answer can be measured and therefore the end of the received command be calculated:


@@ -1614,8 +1620,10 @@ bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_Start
        reader_StartTime = reader_EndTime - reader_modlen;
        if (!LogTrace(reader_data, reader_len, reader_StartTime, reader_EndTime, reader_Parity, TRUE)) {
                return FALSE;
        reader_StartTime = reader_EndTime - reader_modlen;
        if (!LogTrace(reader_data, reader_len, reader_StartTime, reader_EndTime, reader_Parity, TRUE)) {
                return FALSE;

-       } else 
-               return(!LogTrace(tag_data, tag_len, tag_StartTime, tag_EndTime, tag_Parity, FALSE));
+               } else return(!LogTrace(tag_data, tag_len, tag_StartTime, tag_EndTime, tag_Parity, FALSE));
+       } else {
+               return TRUE;
+       }

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -1625,7 +1633,7 @@ bool EmLogTrace(uint8_t *reader_data, uint16_t reader_len, uint32_t reader_Start
 //-----------------------------------------------------------------------------
 static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receivedResponsePar, uint16_t offset)
 {
 //-----------------------------------------------------------------------------
 static int GetIso14443aAnswerFromTag(uint8_t *receivedResponse, uint8_t *receivedResponsePar, uint16_t offset)
 {

-       uint16_t c;
+       uint32_t c;

        
        // Set FPGA mode to "reader listen mode", no modulation (listen
        // only, since we are receiving, not transmitting).
        
        // Set FPGA mode to "reader listen mode", no modulation (listen
        // only, since we are receiving, not transmitting).


@@ -1703,7 +1711,6 @@ int ReaderReceiveOffset(uint8_t* receivedAnswer, uint16_t offset, uint8_t *parit
 int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, 0)) return FALSE;
 int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
 {
        if (!GetIso14443aAnswerFromTag(receivedAnswer, parity, 0)) return FALSE;

-

        if (tracing) {
                LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, FALSE);
        }
        if (tracing) {
                LogTrace(receivedAnswer, Demod.len, Demod.startTime*16 - DELAY_AIR2ARM_AS_READER, Demod.endTime*16 - DELAY_AIR2ARM_AS_READER, parity, FALSE);
        }


@@ -1714,7 +1721,9 @@ int ReaderReceive(uint8_t *receivedAnswer, uint8_t *parity)
  * fills the uid pointer unless NULL
  * fills resp_data unless NULL */
 int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, uint32_t* cuid_ptr) {
  * fills the uid pointer unless NULL
  * fills resp_data unless NULL */
 int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, uint32_t* cuid_ptr) {

-       uint8_t halt[]       = { 0x50 };  // HALT
+       
+       //uint8_t deselect[]   = {0xc2};  //DESELECT
+       //uint8_t halt[]       = { 0x50, 0x00, 0x57, 0xCD };  // HALT

        uint8_t wupa[]       = { 0x52 };  // WAKE-UP
        //uint8_t reqa[]       = { 0x26 };  // REQUEST A
        uint8_t sel_all[]    = { 0x93,0x20 };
        uint8_t wupa[]       = { 0x52 };  // WAKE-UP
        //uint8_t reqa[]       = { 0x26 };  // REQUEST A
        uint8_t sel_all[]    = { 0x93,0x20 };


@@ -1725,30 +1734,30 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
 
        byte_t uid_resp[4];
        size_t uid_resp_len;
 
        byte_t uid_resp[4];
        size_t uid_resp_len;

-
-  uint8_t sak = 0x04; // cascade uid
-  int cascade_level = 0;
-  int len;
+       uint8_t sak = 0x04; // cascade uid
+       int cascade_level = 0;
+       int len =0;

        
        

-  ReaderTransmit(halt,sizeof(halt), NULL);
+       // test for the SKYLANDERS TOY.
+       // ReaderTransmit(deselect,sizeof(deselect), NULL);
+       // len = ReaderReceive(resp, resp_par);

        
        

-  // Broadcast for a card, WUPA (0x52) will force response from all cards in the field
-  ReaderTransmitBitsPar(wupa,7,0, NULL);
+       // Broadcast for a card, WUPA (0x52) will force response from all cards in the field
+       ReaderTransmitBitsPar(wupa,7,0, NULL);

        
        

-  // Receive the ATQA
-  if(!ReaderReceive(resp, resp_par)) 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;
-    memset(p_hi14a_card->uid,0,10);
-  }
+       // Receive the ATQA
+       if(!ReaderReceive(resp, resp_par)) return 0;
+       
+       if(p_hi14a_card) {
+               memcpy(p_hi14a_card->atqa, resp, 2);
+               p_hi14a_card->uidlen = 0;
+               memset(p_hi14a_card->uid,0,10);
+       }

 
 

-  // clear uid
-  if (uid_ptr) {
-    memset(uid_ptr,0,10);
-  }
+       // clear uid
+       if (uid_ptr) {
+               memset(uid_ptr,0,10);
+       }

 
   // OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in
   // which case we need to make a cascade 2 request and select - this is a long UID
 
   // OK we will select at least at cascade 1, lets see if first byte of UID was 0x88 in
   // which case we need to make a cascade 2 request and select - this is a long UID


@@ -1794,7 +1803,6 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
        }
        uid_resp_len = 4;
 
        }
        uid_resp_len = 4;
 

-

     // calculate crypto UID. Always use last 4 Bytes.
     if(cuid_ptr) {
         *cuid_ptr = bytes_to_num(uid_resp, 4);
     // calculate crypto UID. Always use last 4 Bytes.
     if(cuid_ptr) {
         *cuid_ptr = bytes_to_num(uid_resp, 4);


@@ -1808,20 +1816,17 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
     ReaderTransmit(sel_uid,sizeof(sel_uid), NULL);
 
     // Receive the SAK
     ReaderTransmit(sel_uid,sizeof(sel_uid), NULL);
 
     // Receive the SAK

-    if (!ReaderReceive(resp, resp_par)) return 0;
+    if (!ReaderReceive(resp, resp_par)){
+               return 0;
+       }
+       
+       

     sak = resp[0];
     sak = resp[0];

-
-       //Dbprintf("SAK: %02x",resp[0]);

        
        

-    // Test if more parts of the uid are comming
+    // Test if more parts of the uid are coming

     if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) {
                // Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of:
                // http://www.nxp.com/documents/application_note/AN10927.pdf
     if ((sak & 0x04) /* && uid_resp[0] == 0x88 */) {
                // Remove first byte, 0x88 is not an UID byte, it CT, see page 3 of:
                // http://www.nxp.com/documents/application_note/AN10927.pdf

-               // This was earlier:
-               //memcpy(uid_resp, uid_resp + 1, 3);
-               // But memcpy should not be used for overlapping arrays,
-               // and memmove appears to not be available in the arm build.
-               // Therefore:

                uid_resp[0] = uid_resp[1];
                uid_resp[1] = uid_resp[2];
                uid_resp[2] = uid_resp[3]; 
                uid_resp[0] = uid_resp[1];
                uid_resp[1] = uid_resp[2];
                uid_resp[2] = uid_resp[3]; 


@@ -1844,24 +1849,24 @@ int iso14443a_select_card(byte_t* uid_ptr, iso14a_card_select_t* p_hi14a_card, u
     p_hi14a_card->ats_len = 0;
   }
 
     p_hi14a_card->ats_len = 0;
   }
 

-  if( (sak & 0x20) == 0) {
-    return 2; // non iso14443a compliant tag
-  }
-
-  // Request for answer to select
-  AppendCrc14443a(rats, 2);
-  ReaderTransmit(rats, sizeof(rats), NULL);
-
-  if (!(len = ReaderReceive(resp,resp_par))) return 0;
+       // non iso14443a compliant tag
+       if( (sak & 0x20) == 0) return 2; 
+       
+       // Request for answer to select
+       AppendCrc14443a(rats, 2);
+       ReaderTransmit(rats, sizeof(rats), NULL);
+       
+       if (!(len = ReaderReceive(resp, resp_par))) return 0;

 
 

-  if(p_hi14a_card) {
-    memcpy(p_hi14a_card->ats, resp, sizeof(p_hi14a_card->ats));
-    p_hi14a_card->ats_len = len;
-  }
+       
+       if(p_hi14a_card) {
+               memcpy(p_hi14a_card->ats, resp, sizeof(p_hi14a_card->ats));
+               p_hi14a_card->ats_len = len;
+       }

 
 

-  // reset the PCB block number
-  iso14_pcb_blocknum = 0;
-  return 1;
+       // reset the PCB block number
+       iso14_pcb_blocknum = 0;
+       return 1;

 }
 
 void iso14443a_setup(uint8_t fpga_minor_mode) {
 }
 
 void iso14443a_setup(uint8_t fpga_minor_mode) {