ADD: @marshmellow42 's 14b fixes.

FIX: 14b sim changes in  iso14443b.c ,  *experimental*   I took some timing loops from "14a sim" armsrc/iso14443a.c  and merged it into the "14b sim".   Now using two pm3's I can have one simulating and the other reading and it works.  Ask @pwpiwi if you want to know more of what those timing loops does.  Something about waiting for the fpga delay queue...

diff --git a/armsrc/iso14443a.c b/armsrc/iso14443a.c
index 9f2b6d9477d14764cf88a0c07f01f68d16b39974..027703ec40497499482021d0ae6d4441dc46baf0 100644 (file)
--- a/armsrc/iso14443a.c
+++ b/armsrc/iso14443a.c
@@ -1685,9 +1685,7 @@ static int EmSendCmd14443aRaw(uint8_t *resp, uint16_t respLen, bool correctionNe
                        FpgaSendQueueDelay = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
                }
        
-               if(BUTTON_PRESS()) {
-                       break;
-               }
+               if(BUTTON_PRESS()) break;
        }
 
        // Ensure that the FPGA Delay Queue is empty before we switch to TAGSIM_LISTEN again:

diff --git a/armsrc/iso14443b.c b/armsrc/iso14443b.c
index 67e4ccddb7d304505413ed5cbb34198859cdb403..a8a6460932d32f223bb3076c30b0defbab66a718 100644 (file)
--- a/armsrc/iso14443b.c
+++ b/armsrc/iso14443b.c
@@ -321,6 +321,9 @@ static int GetIso14443bCommandFromReader(uint8_t *received, uint16_t *len)
 //-----------------------------------------------------------------------------
 void SimulateIso14443bTag(void)
 {
+       FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+       BigBuf_free();
+       
        // the only commands we understand is REQB, AFI=0, Select All, N=0:
        static const uint8_t cmd1[] = { 0x05, 0x00, 0x08, 0x39, 0x73 };
        // ... and REQB, AFI=0, Normal Request, N=0:
@@ -340,18 +343,16 @@ void SimulateIso14443bTag(void)
        const uint8_t *resp;
        uint8_t *respCode;
        uint16_t respLen, respCodeLen;
-
-       // allocate command receive buffer
-       BigBuf_free();
-       uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
-
        uint16_t len;
        uint16_t cmdsRecvd = 0;
 
-       FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+
+       // allocate command receive buffer
+       uint8_t *receivedCmd = BigBuf_malloc(MAX_FRAME_SIZE);
 
        // prepare the (only one) tag answer:
        CodeIso14443bAsTag(response1, sizeof(response1));
+
        uint8_t *resp1Code = BigBuf_malloc(ToSendMax);
        memcpy(resp1Code, ToSend, ToSendMax); 
        uint16_t resp1CodeLen = ToSendMax;
@@ -411,22 +412,34 @@ void SimulateIso14443bTag(void)
                AT91C_BASE_SSC->SSC_THR = 0xff;
                FpgaSetupSsc();
 
+               uint8_t c;
+               // clear receiving shift register and holding register
+               while(!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY));
+               c = AT91C_BASE_SSC->SSC_RHR; (void) c;
+               while(!(AT91C_BASE_SSC->SSC_SR & AT91C_SSC_RXRDY));
+               c = AT91C_BASE_SSC->SSC_RHR; (void) c;
+               
+               // Clear TXRDY:
+               AT91C_BASE_SSC->SSC_THR = 0x00;
+               
                // Transmit the response.
+               uint16_t FpgaSendQueueDelay = 0;
                uint16_t i = 0;
-               for(;;) {
+               for(;i < respCodeLen; ) {
                        if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
-                               uint8_t b = respCode[i];
-
-                               AT91C_BASE_SSC->SSC_THR = b;
-
-                               i++;
-                               if(i > respCodeLen) {
-                                       break;
-                               }
+                               AT91C_BASE_SSC->SSC_THR = respCode[i++];
+                               FpgaSendQueueDelay = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
                        }
-                       if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_RXRDY)) {
-                               volatile uint8_t b = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
-                               (void)b;
+                               if(BUTTON_PRESS()) break;
+               }
+               
+               // Ensure that the FPGA Delay Queue is empty before we switch to TAGSIM_LISTEN again:
+               uint8_t fpga_queued_bits = FpgaSendQueueDelay >> 3;
+               for (i = 0; i <= fpga_queued_bits/8 + 1; ) {
+                       if(AT91C_BASE_SSC->SSC_SR & (AT91C_SSC_TXRDY)) {
+                               AT91C_BASE_SSC->SSC_THR = 0x00;
+                               FpgaSendQueueDelay = (uint8_t)AT91C_BASE_SSC->SSC_RHR;
+                               i++;
                        }
                }
                
@@ -908,18 +921,17 @@ static void CodeAndTransmit14443bAsReader(const uint8_t *cmd, int len)
 //-----------------------------------------------------------------------------
 void ReadSTMemoryIso14443b(uint32_t dwLast)
 {
+       FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+       
        clear_trace();
        set_tracing(TRUE);
 
        uint8_t i = 0x00;
 
-       FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
        // Make sure that we start from off, since the tags are stateful;
        // confusing things will happen if we don't reset them between reads.
        LED_D_OFF();
        FpgaWriteConfWord(FPGA_MAJOR_MODE_OFF);
-       SpinDelay(200);
-
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc();
 
@@ -1014,9 +1026,10 @@ void ReadSTMemoryIso14443b(uint32_t dwLast)
                // Now print out the memory location:
                Dbprintf("Address=%02x, Contents=%08x, CRC=%04x", i,
                                (Demod.output[3]<<24) + (Demod.output[2]<<16) + (Demod.output[1]<<8) + Demod.output[0],
-                       (Demod.output[4]<<8)+Demod.output[5]
-               );
-               if (i == 0xff) break;
+                               (Demod.output[4]<<8)+Demod.output[5]);
+               if (i == 0xff) {
+                       break;
+               }
                i++;
        }
 }
@@ -1090,9 +1103,6 @@ void RAMFUNC SnoopIso14443b(void)
        bool TagIsActive = FALSE;
        bool ReaderIsActive = FALSE;
                
-       bool TagIsActive = FALSE;
-       bool ReaderIsActive = FALSE;
-       
        // And now we loop, receiving samples.
        for(;;) {
                int behindBy = (lastRxCounter - AT91C_BASE_PDC_SSC->PDC_RCR) &
@@ -1116,10 +1126,6 @@ void RAMFUNC SnoopIso14443b(void)
                        if(behindBy > (9*ISO14443B_DMA_BUFFER_SIZE/10)) { // TODO: understand whether we can increase/decrease as we want or not?
                                Dbprintf("blew circular buffer! behindBy=%d", behindBy);
                                break;
-                       WDT_HIT();
-                       if(behindBy > (9*DMA_BUFFER_SIZE/10)) { // TODO: understand whether we can increase/decrease as we want or not?
-                               Dbprintf("blew circular buffer! behindBy=%d", behindBy);
-                               break;
                        }
                        if(!tracing) {
                                DbpString("Reached trace limit");
@@ -1203,6 +1209,7 @@ void RAMFUNC SnoopIso14443b(void)
 void SendRawCommand14443B(uint32_t datalen, uint32_t recv, uint8_t powerfield, uint8_t data[])
 {
        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+       BigBuf_free();
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc();
 

diff --git a/client/cmdhf14b.c b/client/cmdhf14b.c
index f9b1313b368922c6a30ae0dba15baa6169ee590a..d3b86488e59ea8f4538fe1124be3cd37f1e9003e 100644 (file)
--- a/client/cmdhf14b.c
+++ b/client/cmdhf14b.c
@@ -11,7 +11,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
-#include <string.h>
+//#include <string.h>
 #include <stdint.h>
 #include "iso14443crc.h"
 #include "proxmark3.h"
@@ -36,6 +36,7 @@ int CmdHF14BList(const char *Cmd)
 int CmdHF14BSim(const char *Cmd)
 {
   UsbCommand c={CMD_SIMULATE_TAG_ISO_14443B};
+       clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
@@ -43,6 +44,7 @@ int CmdHF14BSim(const char *Cmd)
 int CmdHF14BSnoop(const char *Cmd)
 {
   UsbCommand c = {CMD_SNOOP_ISO_14443B};
+       clearCommandBuffer();
        SendCommand(&c);
        return 0;
 }
@@ -103,26 +105,29 @@ int HF14BCmdRaw(bool reply, bool *crc, bool power, uint8_t *data, uint8_t *datal
 
        if (!reply) return 1; 
 
-       if (!WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
+       if (!WaitForResponseTimeout(CMD_ACK, &resp, 2000)) {
                if (verbose) PrintAndLog("timeout while waiting for reply.");
-                       return 0;
-               }
-               *datalen = resp.arg[0];
-               if (verbose) PrintAndLog("received %u octets", *datalen);
-               if(*datalen<2) return 0;
+               return 0;
+       }
 
-               memcpy(data, resp.d.asBytes, *datalen);
-               if (verbose) PrintAndLog("%s", sprint_hex(data, *datalen));
+       int len = resp.arg[0];
+       if (verbose) {
+               PrintAndLog("received %u octets", len);
+       }
+       if ( len < 2 ) return 0;
 
-               uint8_t first, second;
-               ComputeCrc14443(CRC_14443_B, data, *datalen-2, &first, &second);
-               if(data[*datalen-2] == first && data[*datalen-1] == second) {
-                       if (verbose) PrintAndLog("CRC OK");
-                       *crc = true;
-               } else {
-                       if (verbose) PrintAndLog("CRC failed");
-                       *crc = false;
-               }
+       memcpy(data, resp.d.asBytes, len);
+       if (verbose) PrintAndLog("%s", sprint_hex(data, len));
+
+       uint8_t first, second;
+       ComputeCrc14443(CRC_14443_B, data, len-2, &first, &second);
+       if(data[len-2] == first && data[len-1] == second) {
+               if (verbose) PrintAndLog("CRC OK");
+               *crc = true;
+       } else {
+               if (verbose) PrintAndLog("CRC failed");
+               *crc = false;
+       }
        return 1;
 }
 
@@ -131,7 +136,7 @@ int CmdHF14BCmdRaw (const char *Cmd) {
     bool crc = false;
        bool power = false;
     char buf[5]="";
-    uint8_t data[100] = {0x00};
+    uint8_t data[USB_CMD_DATA_SIZE] = {0x00};
     uint8_t datalen = 0;
     unsigned int temp;
     int i = 0;
@@ -244,38 +249,109 @@ char *get_ST_Chip_Model(uint8_t data){
                case 0xC: sprintf(retStr, "SRT512"); break;
                default: sprintf(retStr, "Unknown"); break;
        }
-    
-    c.arg[0] = datalen;
-    c.arg[1] = reply;
-    c.arg[2] = power;
-    memcpy(c.d.asBytes,data,datalen);
-    
-    SendCommand(&c);
-    
-    if (reply) {
-        if (WaitForResponseTimeout(CMD_ACK,&resp,1000)) {
-            recv = resp.d.asBytes;
-            PrintAndLog("received %i octets",resp.arg[0]);
-            if(resp.arg[0] == 0)
-                return 0;
-            hexout = (char *)malloc(resp.arg[0] * 3 + 1);
-            if (hexout != NULL) {
-                uint8_t first, second;
-                for (int i = 0; i < resp.arg[0]; i++) { // data in hex
-                    sprintf(&hexout[i * 3], "%02X ", recv[i]);
-       }
-                PrintAndLog("%s", hexout);
-                free(hexout);
-                               if (resp.arg[0] > 2) {
-                                       ComputeCrc14443(CRC_14443_B, recv, resp.arg[0]-2, &first, &second);
-                                       if(recv[resp.arg[0]-2]==first && recv[resp.arg[0]-1]==second) {
-                                               PrintAndLog("CRC OK");
-                                       } else {
-                                               PrintAndLog("CRC failed");
-                                       }
-                }
-            } else {
-                PrintAndLog("malloc failed your client has low memory?");
+       return retStr;
+}
+
+static void print_st_info(uint8_t *data){
+       //uid = first 8 bytes in data
+       PrintAndLog(" UID: %s", sprint_hex(SwapEndian64(data,8,8),8));
+       PrintAndLog(" MFG: %02X, %s", data[6], getTagInfo(data[6]));
+       PrintAndLog("Chip: %02X, %s", data[5]>>2, get_ST_Chip_Model(data[5]>>2));
+       return;
+}
+
+int HF14BStdInfo(uint8_t *data, uint8_t *datalen){
+
+       //05 00 00 = find one tag in field
+       //1d xx xx xx xx 20 00 08 01 00 = attrib xx=crc
+       //a3 = ?  (resp 03 e2 c2)
+       //02 = ?  (resp 02 6a d3)
+       // 022b (resp 02 67 00 [29  5b])
+       // 0200a40400 (resp 02 67 00 [29 5b])
+       // 0200a4040c07a0000002480300 (resp 02 67 00 [29 5b])
+       // 0200a4040c07a0000002480200 (resp 02 67 00 [29 5b])
+       // 0200a4040006a0000000010100 (resp 02 6a 82 [4b 4c])
+       // 0200a4040c09d27600002545500200 (resp 02 67 00 [29 5b])
+       // 0200a404000cd2760001354b414e4d30310000 (resp 02 6a 82 [4b 4c])
+       // 0200a404000ca000000063504b43532d313500 (resp 02 6a 82 [4b 4c])
+       // 0200a4040010a000000018300301000000000000000000 (resp 02 6a 82 [4b 4c])
+       //03 = ?  (resp 03 [e3 c2])
+       //c2 = ?  (resp c2 [66 15])
+       //b2 = ?  (resp a3 [e9 67])
+       bool crc = true;
+       *datalen = 3;
+       //std read cmd
+       data[0] = 0x05;
+       data[1] = 0x00;
+       data[2] = 0x00;
+
+       if (HF14BCmdRaw(true, &crc, false, data, datalen, false)==0) return 0;
+
+       if (data[0] != 0x50  || *datalen != 14 || !crc) return 0;
+
+       PrintAndLog ("\n14443-3b tag found:");
+       print_atqb_resp(data);
+
+       return 1;
+}
+
+int HF14B_ST_Info(uint8_t *data, uint8_t *datalen){
+       bool crc = true;
+       *datalen = 2;
+       //wake cmd
+       data[0] = 0x06;
+       data[1] = 0x00;
+
+       //leave power on
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose();
+
+       if (*datalen != 3 || !crc) return rawClose();
+
+       uint8_t chipID = data[0];
+       // select
+       data[0] = 0x0E;
+       data[1] = chipID;
+       *datalen = 2;
+
+       //leave power on
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return rawClose();
+
+       if (*datalen != 3 || !crc || data[0] != chipID) return rawClose();
+
+       // get uid
+       data[0] = 0x0B;
+       *datalen = 1;
+
+       //power off
+       // verbose on for now for testing - turn off when functional
+       if (HF14BCmdRaw(true, &crc, true, data, datalen, false)==0) return 0;
+       rawClose();
+       if (*datalen != 10 || !crc) return 0;
+
+       PrintAndLog("\n14443-3b ST tag found:");
+       print_st_info(data);
+       return 1;
+}
+
+// test for other 14b type tags (mimic another reader - don't have tags to identify)
+int HF14B_Other_Info(uint8_t *data, uint8_t *datalen){
+       bool crc = true;
+       *datalen = 4;
+       //std read cmd
+       data[0] = 0x00;
+       data[1] = 0x0b;
+       data[2] = 0x3f;
+       data[3] = 0x80;
+
+       if (HF14BCmdRaw(true, &crc, false, data, datalen, false)!=0) {
+               if (*datalen > 2 || !crc) {
+                       PrintAndLog ("\n14443-3b tag found:");
+                       PrintAndLog ("Unknown tag type answered to a 0x000b3f80 command ans:");
+                       PrintAndLog ("%s",sprint_hex(data,*datalen));
+                       return 1;
+               }
        }
 
        crc = false;
@@ -308,29 +384,29 @@ char *get_ST_Chip_Model(uint8_t data){
 
 }
 
-int HF14BReader(bool verbose){
+int HF14BInfo(bool verbose){
        uint8_t data[100];
        uint8_t datalen = 5;
 
        // try std 14b (atqb)
-       if (HF14BStdReader(data, &datalen)) return 1;
+       if (HF14BStdInfo(data, &datalen)) return 1;
 
        // try st 14b
-       if (HF14B_ST_Reader(data, &datalen)) return 1;
+       if (HF14B_ST_Info(data, &datalen)) return 1;
 
        // try unknown 14b read commands (to be identified later)
        //   could be read of calypso, CEPAS, moneo, or pico pass.
-       if (HF14B_Other_Reader(data, &datalen)) return 1;
+       if (HF14B_Other_Info(data, &datalen)) return 1;
 
        if (verbose) PrintAndLog("no 14443B tag found");
        return 0;
 }
 
-int CmdHF14BReader(const char *Cmd){
-       return HF14BReader(true);
+int CmdHF14Binfo(const char *Cmd){
+       return HF14BInfo(true);
 }
 
-int CmdHF14BWrite( const char *Cmd){
+int CmdSriWrite( const char *Cmd){
 /*
  * For SRIX4K  blocks 00 - 7F
  * hf 14b raw -c -p 09 $srix4kwblock $srix4kwdata
@@ -400,13 +476,14 @@ int CmdHF14BWrite( const char *Cmd){
 static command_t CommandTable[] = 
 {
        {"help",        CmdHelp,        1, "This help"},
+       {"info",        CmdHF14Binfo,   0, "Find and print info about a 14b type tag (HF ISO 14443b)"},
        {"list",        CmdHF14BList,   0, "[Deprecated] List ISO 14443b history"},
   {"sim",         CmdHF14BSim,    0, "Fake ISO 14443B tag"},
   {"snoop",       CmdHF14BSnoop,  0, "Eavesdrop ISO 14443B"},
        {"sri512read",  CmdSri512Read,  0, "Read contents of a SRI512 tag"},
        {"srix4kread",  CmdSrix4kRead,  0, "Read contents of a SRIX4K tag"},
+  {"sriwrite",    CmdSriWrite,    0, "Write data to a SRI512 | SRIX4K tag"},
        {"raw",         CmdHF14BCmdRaw, 0, "Send raw hex data to tag"},
-       {"write",       CmdHF14BWrite,  0, "Write data to a SRI512 | SRIX4K tag"},
        {NULL, NULL, 0, NULL}
 };
 

diff --git a/client/cmdhf14b.h b/client/cmdhf14b.h
index ef79317a56cba2b4571a6fa363ed7fd21795f57e..a45b74341ced2cd82a733472f7abd4939fc29744 100644 (file)
--- a/client/cmdhf14b.h
+++ b/client/cmdhf14b.h
@@ -13,12 +13,12 @@
 
 int CmdHF14B(const char *Cmd);
 int CmdHF14BList(const char *Cmd);
-int CmdHF14BReader(const char *Cmd);
+int CmdHF14BInfo(const char *Cmd);
 int CmdHF14BSim(const char *Cmd);
 int CmdHF14BSnoop(const char *Cmd);
 int CmdSri512Read(const char *Cmd);
 int CmdSrix4kRead(const char *Cmd);
 int CmdHF14BWrite( const char *cmd);
-int HF14BReader(bool verbose);
+int HF14BInfo(bool verbose);
 
 #endif