ADD: started to add tracelog in legic

ADD: remake of legic codebase.
ADD: started with a annotation for LEGIC in 'hf list'

diff --git a/armsrc/BigBuf.c b/armsrc/BigBuf.c
index 7d7a76d16323e1f34f6bba43178a24a4bc7639c3..cf0c26b2b176c1dc8da7be8eab8fa19ab70520ed 100644 (file)
--- a/armsrc/BigBuf.c
+++ b/armsrc/BigBuf.c
@@ -139,7 +139,6 @@ uint16_t BigBuf_get_traceLen(void)
   The traces produced by calling this function can be fetched on the client-side
   by 'hf list raw', alternatively 'hf list <proto>' for protocol-specific
   annotation of commands/responses.
   The traces produced by calling this function can be fetched on the client-side
   by 'hf list raw', alternatively 'hf list <proto>' for protocol-specific
   annotation of commands/responses.

-

 **/
 bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag)
 {
 **/
 bool RAMFUNC LogTrace(const uint8_t *btBytes, uint16_t iLen, uint32_t timestamp_start, uint32_t timestamp_end, uint8_t *parity, bool readerToTag)
 {

diff --git a/armsrc/legicrf.c b/armsrc/legicrf.c
index 26863d71a32cfdf69374c60bbb34701241d8d3a2..5ee4d667c926beed5c5ce05ab9289372152012cd 100644 (file)
--- a/armsrc/legicrf.c
+++ b/armsrc/legicrf.c
@@ -8,14 +8,7 @@
 // LEGIC RF simulation code
 //-----------------------------------------------------------------------------
 
 // LEGIC RF simulation code
 //-----------------------------------------------------------------------------
 

-#include "proxmark3.h"
-#include "apps.h"
-#include "util.h"
-#include "string.h"
-

 #include "legicrf.h"
 #include "legicrf.h"

-#include "legic_prng.h"
-#include "crc.h"

 
 static struct legic_frame {
        int bits;
 
 static struct legic_frame {
        int bits;


@@ -37,11 +30,12 @@ static int      legic_phase_drift;
 static int      legic_frame_drift;
 static int      legic_reqresp_drift;
 
 static int      legic_frame_drift;
 static int      legic_reqresp_drift;
 

+int timestamp;
+

 AT91PS_TC timer;
 AT91PS_TC prng_timer;
 
 AT91PS_TC timer;
 AT91PS_TC prng_timer;
 

-static void setup_timer(void)
-{
+static void setup_timer(void) {

        /* Set up Timer 1 to use for measuring time between pulses. Since we're bit-banging
         * this it won't be terribly accurate but should be good enough.
         */
        /* Set up Timer 1 to use for measuring time between pulses. Since we're bit-banging
         * this it won't be terribly accurate but should be good enough.
         */


@@ -78,35 +72,59 @@ static void setup_timer(void)
 
 #define FUZZ_EQUAL(value, target, fuzz) ((value) > ((target)-(fuzz)) && (value) < ((target)+(fuzz)))
 
 
 #define FUZZ_EQUAL(value, target, fuzz) ((value) > ((target)-(fuzz)) && (value) < ((target)+(fuzz)))
 

+// ~ 258us + 100us*delay
+#define WAIT_387       WAIT(387)
+#define WAIT(delay)    while(timer->TC_CV < (delay) );
+
+
+// ToDo: define a meaningful maximum size for auth_table. The bigger this is, the lower will be the available memory for traces. 
+// Historically it used to be FREE_BUFFER_SIZE, which was 2744.
+#define LEGIC_CARD_MEMSIZE 1024
+static uint8_t* cardmem;
+
+/*
+The new tracelog..
+       // Traceformat:
+       // 32 bits timestamp (little endian)
+       // 16 bits duration (little endian)
+       // 16 bits data length (little endian, Highest Bit used as readerToTag flag)
+       // y Bytes data
+       // x Bytes parity (one byte per 8 bytes data)
+*/
+ 

 /* Generate Keystream */
 static uint32_t get_key_stream(int skip, int count)
 {
 /* Generate Keystream */
 static uint32_t get_key_stream(int skip, int count)
 {

-       uint32_t key=0; int i;
+       uint32_t key = 0;
+       int i;

 
 

-       /* Use int to enlarge timer tc to 32bit */
+       // Use int to enlarge timer tc to 32bit

        legic_prng_bc += prng_timer->TC_CV;
        legic_prng_bc += prng_timer->TC_CV;

+
+       // reset the prng timer.

        prng_timer->TC_CCR = AT91C_TC_SWTRG;
        prng_timer->TC_CCR = AT91C_TC_SWTRG;

+       while(prng_timer->TC_CV > 1) ;

 
        /* If skip == -1, forward prng time based */
        if(skip == -1) {
 
        /* If skip == -1, forward prng time based */
        if(skip == -1) {

-               i  = (legic_prng_bc+SIM_SHIFT)/SIM_DIVISOR; /* Calculate Cycles based on timer */
+               i  = (legic_prng_bc + SIM_SHIFT)/SIM_DIVISOR; /* Calculate Cycles based on timer */

                i -= legic_prng_count(); /* substract cycles of finished frames */
                i -= legic_prng_count(); /* substract cycles of finished frames */

-               i -= count; /* substract current frame length, rewidn to bedinning */
+               i -= count; /* substract current frame length, rewind to beginning */

                legic_prng_forward(i);
        } else {
                legic_prng_forward(skip);
        }
 
                legic_prng_forward(i);
        } else {
                legic_prng_forward(skip);
        }
 

-       /* Write Time Data into LOG */
-       uint8_t *BigBuf = BigBuf_get_addr();

        i = (count == 6) ? -1 : legic_read_count;
 
        i = (count == 6) ? -1 : legic_read_count;
 

-       BigBuf[OFFSET_LOG+128+i] = legic_prng_count();
-       BigBuf[OFFSET_LOG+256+i*4]   = (legic_prng_bc >> 0) & 0xff;
-       BigBuf[OFFSET_LOG+256+i*4+1] = (legic_prng_bc >> 8) & 0xff;
-       BigBuf[OFFSET_LOG+256+i*4+2] = (legic_prng_bc >>16) & 0xff;
-       BigBuf[OFFSET_LOG+256+i*4+3] = (legic_prng_bc >>24) & 0xff;
-       BigBuf[OFFSET_LOG+384+i] = count;
+       /* Write Time Data into LOG */
+       // uint8_t *BigBuf = BigBuf_get_addr();
+       // BigBuf[OFFSET_LOG+128+i] = legic_prng_count();
+       // BigBuf[OFFSET_LOG+256+i*4]   = (legic_prng_bc >> 0) & 0xff;
+       // BigBuf[OFFSET_LOG+256+i*4+1] = (legic_prng_bc >> 8) & 0xff;
+       // BigBuf[OFFSET_LOG+256+i*4+2] = (legic_prng_bc >>16) & 0xff;
+       // BigBuf[OFFSET_LOG+256+i*4+3] = (legic_prng_bc >>24) & 0xff;
+       // BigBuf[OFFSET_LOG+384+i] = count;

 
        /* Generate KeyStream */
        for(i=0; i<count; i++) {
 
        /* Generate KeyStream */
        for(i=0; i<count; i++) {


@@ -129,48 +147,55 @@ static void frame_send_tag(uint16_t response, int bits, int crypt)
    /* Use time to crypt frame */
    if(crypt) {
       legic_prng_forward(2); /* TAG_TIME_WAIT -> shift by 2 */
    /* Use time to crypt frame */
    if(crypt) {
       legic_prng_forward(2); /* TAG_TIME_WAIT -> shift by 2 */

-      int i; int key = 0;
-      for(i=0; i<bits; i++) {
+      int key = 0;
+      for(int i = 0; i < bits; i++) {

          key |= legic_prng_get_bit() << i;
          legic_prng_forward(1);
       }
          key |= legic_prng_get_bit() << i;
          legic_prng_forward(1);
       }

-      //Dbprintf("key = 0x%x", key);

       response = response ^ key;
    }
 
    /* Wait for the frame start */
       response = response ^ key;
    }
 
    /* Wait for the frame start */

-   while(timer->TC_CV < (TAG_TIME_WAIT - 30)) ;
-       
-   int i;
-   for(i=0; i<bits; i++) {
+   //while(timer->TC_CV < (TAG_TIME_WAIT - 30)) ;
+   WAIT( TAG_TIME_WAIT - 30)
+
+   uint8_t bit = 0;
+   for(int i = 0; i < bits; i++) {

       int nextbit = timer->TC_CV + TAG_TIME_BIT;
       int nextbit = timer->TC_CV + TAG_TIME_BIT;

-      int bit = response & 1;
-      response = response >> 1;
-      if(bit)
+      bit = response & 1;
+      response >>= 1;
+         
+      if (bit)

          AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
       else
          AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
       
          AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
       else
          AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
       

-      while(timer->TC_CV < nextbit) ;
+      //while(timer->TC_CV < nextbit) ;
+         WAIT(nextbit)

    }
    AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
 }
 
    }
    AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
 }
 

+// Starts Clock and waits until its reset
+static void ResetClock(void){
+       timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
+       while(timer->TC_CV > 1) ;
+}
+

 /* Send a frame in reader mode, the FPGA must have been set up by
  * LegicRfReader
  */
 /* Send a frame in reader mode, the FPGA must have been set up by
  * LegicRfReader
  */

-static void frame_send_rwd(uint32_t data, int bits)
-{
-       /* Start clock */
-       timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-       while(timer->TC_CV > 1) ; /* Wait till the clock has reset */
+static void frame_send_rwd(uint32_t data, int bits){

 
 

-       int i;
-       for(i=0; i<bits; i++) {
-               int starttime = timer->TC_CV;
-               int pause_end = starttime + RWD_TIME_PAUSE, bit_end;
-               int bit = data & 1;
-               data = data >> 1;
+       ResetClock();
+       int starttime = 0, pause_end = 0, bit = 0, bit_end = 0;
+       
+       for(int i = 0; i<bits; i++) {
+
+               starttime = timer->TC_CV;               
+               pause_end = starttime + RWD_TIME_PAUSE;
+               bit = data & 1;
+               data >>= 1;

 
                if(bit ^ legic_prng_get_bit())
                        bit_end = starttime + RWD_TIME_1;
 
                if(bit ^ legic_prng_get_bit())
                        bit_end = starttime + RWD_TIME_1;


@@ -181,23 +206,27 @@ static void frame_send_rwd(uint32_t data, int bits)
                /* RWD_TIME_PAUSE time off, then some time on, so that the complete bit time is
                 * RWD_TIME_x, where x is the bit to be transmitted */
                AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
                /* RWD_TIME_PAUSE time off, then some time on, so that the complete bit time is
                 * RWD_TIME_x, where x is the bit to be transmitted */
                AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;

-               while(timer->TC_CV < pause_end) ;
+
+               WAIT( pause_end )
+               

                AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
                AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;

+

                legic_prng_forward(1); /* bit duration is longest. use this time to forward the lfsr */
 
                legic_prng_forward(1); /* bit duration is longest. use this time to forward the lfsr */
 

-               while(timer->TC_CV < bit_end);
+               WAIT( bit_end )

        }
 
        /* One final pause to mark the end of the frame */
        }
 
        /* One final pause to mark the end of the frame */

-       int pause_end = timer->TC_CV + RWD_TIME_PAUSE;
+       pause_end = timer->TC_CV + RWD_TIME_PAUSE;
+       

        AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
        AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;

-       while(timer->TC_CV < pause_end) ;
+       
+       WAIT(pause_end)
+       

        AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
 
        AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
 

-

        /* Reset the timer, to measure time until the start of the tag frame */
        /* Reset the timer, to measure time until the start of the tag frame */

-       timer->TC_CCR = AT91C_TC_SWTRG;
-       while(timer->TC_CV > 1) ; /* Wait till the clock has reset */
+       ResetClock();

 }
 
 /* Receive a frame from the card in reader emulation mode, the FPGA and
 }
 
 /* Receive a frame from the card in reader emulation mode, the FPGA and


@@ -224,13 +253,11 @@ static void frame_send_rwd(uint32_t data, int bits)
 static void frame_receive_rwd(struct legic_frame * const f, int bits, int crypt)
 {
        uint32_t the_bit = 1;  /* Use a bitmask to save on shifts */
 static void frame_receive_rwd(struct legic_frame * const f, int bits, int crypt)
 {
        uint32_t the_bit = 1;  /* Use a bitmask to save on shifts */

-       uint32_t data=0;
-       int i, old_level=0, edges=0;
+       uint32_t data = 0;
+       int i, old_level = 0, edges = 0;

        int next_bit_at = TAG_TIME_WAIT;
        
        int next_bit_at = TAG_TIME_WAIT;
        

-       if(bits > 32) {
-               bits = 32;
-    }
+       if(bits > 32) bits = 32;

 
        AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
 
        AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;


@@ -246,7 +273,7 @@ static void frame_receive_rwd(struct legic_frame * const f, int bits, int crypt)
                }
        }
 
                }
        }
 

-       while(timer->TC_CV < next_bit_at) ;
+       WAIT(next_bit_at)

 
        next_bit_at += TAG_TIME_BIT;
 
 
        next_bit_at += TAG_TIME_BIT;
 


@@ -260,7 +287,8 @@ static void frame_receive_rwd(struct legic_frame * const f, int bits, int crypt)
                }
                next_bit_at += TAG_TIME_BIT;
                
                }
                next_bit_at += TAG_TIME_BIT;
                

-               if(edges > 20 && edges < 60) { /* expected are 42 edges */
+               // We expect 42 edges 
+               if(edges > 20 && edges < 60) { 

                        data ^= the_bit;
                }
                the_bit <<= 1;
                        data ^= the_bit;
                }
                the_bit <<= 1;


@@ -269,47 +297,51 @@ static void frame_receive_rwd(struct legic_frame * const f, int bits, int crypt)
        f->data = data;
        f->bits = bits;
 
        f->data = data;
        f->bits = bits;
 

-       /* Reset the timer, to synchronize the next frame */
-       timer->TC_CCR = AT91C_TC_SWTRG;
-       while(timer->TC_CV > 1) ; /* Wait till the clock has reset */
+       // Reset the timer, to synchronize the next frame
+       ResetClock();

 }
 
 }
 

-static void frame_append_bit(struct legic_frame * const f, int bit)
-{
-   if (f->bits >= 31)
-       return; /* Overflow, won't happen */
+static void frame_append_bit(struct legic_frame * const f, int bit) {
+       // Overflow, won't happen
+   if (f->bits >= 31) return;

   
    f->data |= (bit << f->bits);
    f->bits++;
 }
 
   
    f->data |= (bit << f->bits);
    f->bits++;
 }
 

-static void frame_clean(struct legic_frame * const f)
-{
+static void frame_clean(struct legic_frame * const f) {

        f->data = 0;
        f->bits = 0;
 }
 
        f->data = 0;
        f->bits = 0;
 }
 

-static uint32_t perform_setup_phase_rwd(int iv)
-{
-
+// Setup pm3 as a Legic Reader
+static uint32_t perform_setup_phase_rwd(int iv) {

        /* Switch on carrier and let the tag charge for 1ms */
        AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;
        /* Switch on carrier and let the tag charge for 1ms */
        AT91C_BASE_PIOA->PIO_SODR = GPIO_SSC_DOUT;

-       SpinDelay(1);
+       SpinDelay(20);  // was 1ms before. 
+
+       /* no keystream yet */
+       legic_prng_init(0);

 
 

-       legic_prng_init(0); /* no keystream yet */
+       // IV

        frame_send_rwd(iv, 7);
        legic_prng_init(iv);
 
        frame_clean(&current_frame);
        frame_receive_rwd(&current_frame, 6, 1);
        frame_send_rwd(iv, 7);
        legic_prng_init(iv);
 
        frame_clean(&current_frame);
        frame_receive_rwd(&current_frame, 6, 1);

-       legic_prng_forward(3); /* we wait anyways */
-       while(timer->TC_CV < 387) ; /* ~ 258us */
+
+        // we wait anyways
+       legic_prng_forward(3);
+       
+       WAIT_387
+

        frame_send_rwd(0x39, 6);
 
        return current_frame.data;
 }
 
 static void LegicCommonInit(void) {
        frame_send_rwd(0x39, 6);
 
        return current_frame.data;
 }
 
 static void LegicCommonInit(void) {

+       

        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc();
        FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
        SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
        FpgaSetupSsc();


@@ -320,18 +352,25 @@ static void LegicCommonInit(void) {
        AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 
        AT91C_BASE_PIOA->PIO_OER = GPIO_SSC_DOUT;
        AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DOUT;
 

+       // reserve a cardmem,  meaning we can use the tracelog function in bigbuff easier.
+       cardmem = BigBuf_malloc(LEGIC_CARD_MEMSIZE);
+       memset(cardmem, 0x00, LEGIC_CARD_MEMSIZE);
+
+       clear_trace();
+       set_tracing(TRUE);
+       

        setup_timer();
 
        crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
 }
 
 /* Switch off carrier, make sure tag is reset */
        setup_timer();
 
        crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
 }
 
 /* Switch off carrier, make sure tag is reset */

-static void switch_off_tag_rwd(void)
-{
+static void switch_off_tag_rwd(void) {

        AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
        SpinDelay(10);
        WDT_HIT();
 }
        AT91C_BASE_PIOA->PIO_CODR = GPIO_SSC_DOUT;
        SpinDelay(10);
        WDT_HIT();
 }

+

 /* calculate crc for a legic command */
 static int LegicCRC(int byte_index, int value, int cmd_sz) {
        crc_clear(&legic_crc);
 /* calculate crc for a legic command */
 static int LegicCRC(int byte_index, int value, int cmd_sz) {
        crc_clear(&legic_crc);


@@ -342,48 +381,69 @@ static int LegicCRC(int byte_index, int value, int cmd_sz) {
 }
 
 int legic_read_byte(int byte_index, int cmd_sz) {
 }
 
 int legic_read_byte(int byte_index, int cmd_sz) {

-       int byte;

 
 

-       while(timer->TC_CV < 387) ; /* ~ 258us + 100us*delay */
+       int byte = 0, calcCrc = 0, crc = 0;
+       int cmd = 1 | (byte_index << 1);

 
 

-       frame_send_rwd(1 | (byte_index << 1), cmd_sz);
-       frame_clean(&current_frame);
+       uint8_t cmdbytes[2] = {cmd && 0xff, (cmd >> 8 ) & 0xFF};
+       uint32_t starttime = timer->TC_CV, endtime = 0;
+
+       WAIT_387

 
 

+       // send
+       frame_send_rwd(cmd, cmd_sz);
+
+       // log
+       endtime = timer->TC_CV;
+       LogTrace(cmdbytes, 2, starttime, endtime, NULL, TRUE);
+       
+       // clean
+       frame_clean(&current_frame);
+       
+       starttime = timer->TC_CV;
+       
+       // read

        frame_receive_rwd(&current_frame, 12, 1);
 
        frame_receive_rwd(&current_frame, 12, 1);
 

+       // log
+       endtime = timer->TC_CV;  
+       cmdbytes[0] = current_frame.data & 0xff; 
+       cmdbytes[1] = (current_frame.data >> 8) & 0xFF;
+       LogTrace(cmdbytes, 2, starttime, endtime, NULL, FALSE);
+       

        byte = current_frame.data & 0xff;
        byte = current_frame.data & 0xff;

+       calcCrc = LegicCRC(byte_index, byte, cmd_sz);
+       crc = (current_frame.data >> 8);

 
 

-       if( LegicCRC(byte_index, byte, cmd_sz) != (current_frame.data >> 8) ) {
-               Dbprintf("!!! crc mismatch: expected %x but got %x !!!", 
-                       LegicCRC(byte_index, current_frame.data & 0xff, cmd_sz),
-                       current_frame.data >> 8);
+       if( calcCrc != crc ) {
+               Dbprintf("!!! crc mismatch: expected %x but got %x !!!",  calcCrc, crc);

                return -1;
        }
 
                return -1;
        }
 

-       legic_prng_forward(4); /* we wait anyways */
+       // we wait anyways
+       legic_prng_forward(4); 

        return byte;
 }
 
        return byte;
 }
 

-/* legic_write_byte() is not included, however it's trivial to implement
- * and here are some hints on what remains to be done:
- *
- *  * assemble a write_cmd_frame with crc and send it
- *  * wait until the tag sends back an ACK ('1' bit unencrypted)
- *  * forward the prng based on the timing
+/* 
+ * - assemble a write_cmd_frame with crc and send it
+ * - wait until the tag sends back an ACK ('1' bit unencrypted)
+ * - forward the prng based on the timing

  */
 //int legic_write_byte(int byte, int addr, int addr_sz, int PrngCorrection) {
 int legic_write_byte(int byte, int addr, int addr_sz) {
  */
 //int legic_write_byte(int byte, int addr, int addr_sz, int PrngCorrection) {
 int legic_write_byte(int byte, int addr, int addr_sz) {

-    //do not write UID, CRC
-       if(addr <= 0x04) { 
-               return 0;
-               }
-       //== send write command ==============================
+
+    //do not write UID, CRC at offset 0-4.
+       if(addr <= 0x04) return 0;
+
+       // crc

        crc_clear(&legic_crc);
        crc_update(&legic_crc, 0, 1); /* CMD_WRITE */
        crc_update(&legic_crc, addr, addr_sz);
        crc_update(&legic_crc, byte, 8);
        crc_clear(&legic_crc);
        crc_update(&legic_crc, 0, 1); /* CMD_WRITE */
        crc_update(&legic_crc, addr, addr_sz);
        crc_update(&legic_crc, byte, 8);

-

        uint32_t crc = crc_finish(&legic_crc);
        uint32_t crc = crc_finish(&legic_crc);

+
+       // send write command

        uint32_t cmd = ((crc     <<(addr_sz+1+8)) //CRC
                    |(byte    <<(addr_sz+1))   //Data
                    |(addr    <<1)             //Address
        uint32_t cmd = ((crc     <<(addr_sz+1+8)) //CRC
                    |(byte    <<(addr_sz+1))   //Data
                    |(addr    <<1)             //Address


@@ -391,17 +451,22 @@ int legic_write_byte(int byte, int addr, int addr_sz) {
     uint32_t cmd_sz = addr_sz+1+8+4;          //crc+data+cmd
 
     legic_prng_forward(2); /* we wait anyways */
     uint32_t cmd_sz = addr_sz+1+8+4;          //crc+data+cmd
 
     legic_prng_forward(2); /* we wait anyways */

+       

     while(timer->TC_CV < 387) ; /* ~ 258us */
     while(timer->TC_CV < 387) ; /* ~ 258us */

+       

        frame_send_rwd(cmd, cmd_sz);
        frame_send_rwd(cmd, cmd_sz);

+  
+// wllm-rbnt doesnt have these
+//     AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
+//     AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;

 
 

-       AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
-       AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
+       // wait for ack
+    int t, old_level = 0, edges = 0;
+    int next_bit_at = 0;

 
 

-       //== wait for ack ====================================
-    int t, old_level=0, edges=0;
-    int next_bit_at =0;

        while(timer->TC_CV < 387) ; /* ~ 258us */
        while(timer->TC_CV < 387) ; /* ~ 258us */

-    for(t=0; t<80; t++) {
+
+    for( t = 0; t < 80; t++) {

         edges = 0;
                next_bit_at += TAG_TIME_BIT;
         while(timer->TC_CV < next_bit_at) {
         edges = 0;
                next_bit_at += TAG_TIME_BIT;
         while(timer->TC_CV < next_bit_at) {


@@ -413,15 +478,15 @@ int legic_write_byte(int byte, int addr, int addr_sz) {
         }
         if(edges > 20 && edges < 60) { /* expected are 42 edges */
                        int t = timer->TC_CV;
         }
         if(edges > 20 && edges < 60) { /* expected are 42 edges */
                        int t = timer->TC_CV;

-                       int c = t/TAG_TIME_BIT;
-                       timer->TC_CCR = AT91C_TC_SWTRG;
-                       while(timer->TC_CV > 1) ; /* Wait till the clock has reset */
+                       int c = t / TAG_TIME_BIT;
+                       
+                       ResetClock();

                        legic_prng_forward(c);
                return 0;
         }
     }
                        legic_prng_forward(c);
                return 0;
         }
     }

-    timer->TC_CCR = AT91C_TC_SWTRG;
-    while(timer->TC_CV > 1) ; /* Wait till the clock has reset */
+
+       ResetClock();

        return -1;
 }
 
        return -1;
 }
 


@@ -431,43 +496,44 @@ int LegicRfReader(int offset, int bytes, int iv) {
        // ice_legic_select_card();
        // return 0;
        
        // ice_legic_select_card();
        // return 0;
        

-       int byte_index=0, cmd_sz=0, card_sz=0;
+       int byte_index = 0, cmd_sz = 0, card_sz = 0;

 
        iv = (iv <= 0 ) ? SESSION_IV : iv;                                                                                                         
 
        LegicCommonInit();
 
 
        iv = (iv <= 0 ) ? SESSION_IV : iv;                                                                                                         
 
        LegicCommonInit();
 

-       uint8_t *BigBuf = BigBuf_get_addr();
-       memset(BigBuf, 0, 1024);
+       if ( MF_DBGLEVEL >= 2) DbpString("setting up legic card");

 
 

-       DbpString("setting up legic card");

        uint32_t tag_type = perform_setup_phase_rwd(iv);
        uint32_t tag_type = perform_setup_phase_rwd(iv);

-       switch_off_tag_rwd(); //we lose to mutch time with dprintf
+
+        //we lose to mutch time with dprintf
+       switch_off_tag_rwd();
+

        switch(tag_type) {
                case 0x0d:
        switch(tag_type) {
                case 0x0d:

-                       DbpString("MIM22 card found, reading card ...");
+                       if ( MF_DBGLEVEL >= 2) DbpString("MIM22 card found, reading card ...");

             cmd_sz = 6;
                        card_sz = 22;
                        break;
                case 0x1d:
             cmd_sz = 6;
                        card_sz = 22;
                        break;
                case 0x1d:

-                       DbpString("MIM256 card found, reading card ...");
+                       if ( MF_DBGLEVEL >= 2) DbpString("MIM256 card found, reading card ...");

             cmd_sz = 9;
                        card_sz = 256;
                        break;
                case 0x3d:
             cmd_sz = 9;
                        card_sz = 256;
                        break;
                case 0x3d:

-                       DbpString("MIM1024 card found, reading card ...");
+                       if ( MF_DBGLEVEL >= 2) DbpString("MIM1024 card found, reading card ...");

             cmd_sz = 11;
                        card_sz = 1024;
                        break;
                default:
             cmd_sz = 11;
                        card_sz = 1024;
                        break;
                default:

-                       Dbprintf("Unknown card format: %x",tag_type);
+                       if ( MF_DBGLEVEL >= 1) Dbprintf("Unknown card format: %x",tag_type);

                        return -1;
        }
        if(bytes == -1)
                bytes = card_sz;
 
        if(bytes+offset >= card_sz)
                        return -1;
        }
        if(bytes == -1)
                bytes = card_sz;
 
        if(bytes+offset >= card_sz)

-               bytes = card_sz-offset;
+               bytes = card_sz - offset;

 
        perform_setup_phase_rwd(iv);
 
 
        perform_setup_phase_rwd(iv);
 


@@ -476,23 +542,22 @@ int LegicRfReader(int offset, int bytes, int iv) {
        LED_B_ON();
        while(byte_index < bytes) {
                int r = legic_read_byte(byte_index+offset, cmd_sz);
        LED_B_ON();
        while(byte_index < bytes) {
                int r = legic_read_byte(byte_index+offset, cmd_sz);

-               if(r == -1 ||BUTTON_PRESS()) {
-               DbpString("operation aborted");
-                       switch_off_tag_rwd();
-               LED_B_OFF();
-                       LED_C_OFF();
-               return -1;
+               if(r == -1 || BUTTON_PRESS()) {                 
+               switch_off_tag_rwd();
+               LEDsoff();
+               if ( MF_DBGLEVEL >= 2) DbpString("operation aborted");
+                       return -1;

                }
                }

-               BigBuf[byte_index] = r;
+               cardmem[byte_index] = r;

         WDT_HIT();
         WDT_HIT();

-               byte_index++;
-               if (byte_index & 0x10) LED_C_ON(); else LED_C_OFF();
+               byte_index++;           

        }
        }

-       LED_B_OFF();
-    LED_C_OFF();
+

        switch_off_tag_rwd();
        switch_off_tag_rwd();

-       Dbprintf("Card read, use 'hf legic decode' or");
-    Dbprintf("'data hexsamples %d' to view results", (bytes+7) & ~7);
+       LEDsoff();
+       
+       if ( MF_DBGLEVEL >= 1) Dbprintf("Card read, use 'hf legic decode' or");
+    if ( MF_DBGLEVEL >= 1) Dbprintf("'data hexsamples %d' to view results", (bytes+7) & ~7);

     return 0;
 }
 
     return 0;
 }
 


@@ -539,15 +604,18 @@ int LegicRfReader(int offset, int bytes, int iv) {
 
 void LegicRfWriter(int offset, int bytes, int iv) {
 
 
 void LegicRfWriter(int offset, int bytes, int iv) {
 

-       int byte_index=0, addr_sz=0;
-       uint8_t *BigBuf = BigBuf_get_addr();
+       int byte_index = 0, addr_sz = 0;
+       

        iv = (iv <=0 ) ? SESSION_IV : iv;                                                                                 
 
        LegicCommonInit();
        
        iv = (iv <=0 ) ? SESSION_IV : iv;                                                                                 
 
        LegicCommonInit();
        

-       DbpString("setting up legic card");
+       if ( MF_DBGLEVEL >= 2)  DbpString("setting up legic card");
+       

        uint32_t tag_type = perform_setup_phase_rwd(iv);
        uint32_t tag_type = perform_setup_phase_rwd(iv);

+       

        switch_off_tag_rwd();
        switch_off_tag_rwd();

+       

        switch(tag_type) {
                case 0x0d:
                        if(offset+bytes > 22) {
        switch(tag_type) {
                case 0x0d:
                        if(offset+bytes > 22) {


@@ -555,7 +623,7 @@ void LegicRfWriter(int offset, int bytes, int iv) {
                                return;
                        }
                        addr_sz = 5;
                                return;
                        }
                        addr_sz = 5;

-                       Dbprintf("MIM22 card found, writing 0x%02.2x - 0x%02.2x ...", offset, offset+bytes);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM22 card found, writing 0x%02.2x - 0x%02.2x ...", offset, offset+bytes);

                        break;
                case 0x1d:
                        if(offset+bytes > 0x100) {
                        break;
                case 0x1d:
                        if(offset+bytes > 0x100) {


@@ -563,7 +631,7 @@ void LegicRfWriter(int offset, int bytes, int iv) {
                                return;
                        }
                        addr_sz = 8;
                                return;
                        }
                        addr_sz = 8;

-                       Dbprintf("MIM256 card found, writing 0x%02.2x - 0x%02.2x ...", offset, offset+bytes);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM256 card found, writing 0x%02.2x - 0x%02.2x ...", offset, offset+bytes);

                        break;
                case 0x3d:
                        if(offset+bytes > 0x400) {
                        break;
                case 0x3d:
                        if(offset+bytes > 0x400) {


@@ -571,14 +639,13 @@ void LegicRfWriter(int offset, int bytes, int iv) {
                        return;
                }
                        addr_sz = 10;
                        return;
                }
                        addr_sz = 10;

-                       Dbprintf("MIM1024 card found, writing 0x%03.3x - 0x%03.3x ...", offset, offset+bytes);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM1024 card found, writing 0x%03.3x - 0x%03.3x ...", offset, offset+bytes);

                        break;
                default:
                        Dbprintf("No or unknown card found, aborting");
             return;
        }
 
                        break;
                default:
                        Dbprintf("No or unknown card found, aborting");
             return;
        }
 

-#if 1

     LED_B_ON();
        perform_setup_phase_rwd(iv);
        while(byte_index < bytes) {
     LED_B_ON();
        perform_setup_phase_rwd(iv);
        while(byte_index < bytes) {


@@ -587,53 +654,46 @@ void LegicRfWriter(int offset, int bytes, int iv) {
                //check if the DCF should be changed
                if ( ((byte_index+offset) == 0x05) && (bytes >= 0x02) ) {
                        //write DCF in reverse order (addr 0x06 before 0x05)
                //check if the DCF should be changed
                if ( ((byte_index+offset) == 0x05) && (bytes >= 0x02) ) {
                        //write DCF in reverse order (addr 0x06 before 0x05)

-                       r = legic_write_byte(BigBuf[(0x06-byte_index)], (0x06-byte_index), addr_sz);
+                       r = legic_write_byte(cardmem[(0x06-byte_index)], (0x06-byte_index), addr_sz);

 
                        // write second byte on success...
                        if(r == 0) {
                                byte_index++;
 
                        // write second byte on success...
                        if(r == 0) {
                                byte_index++;

-                               r = legic_write_byte(BigBuf[(0x06-byte_index)], (0x06-byte_index), addr_sz);
+                               r = legic_write_byte(cardmem[(0x06-byte_index)], (0x06-byte_index), addr_sz);

                        }
                }
                else {
                        }
                }
                else {

-                       r = legic_write_byte(BigBuf[byte_index+offset], byte_index+offset, addr_sz);
+                       r = legic_write_byte(cardmem[byte_index+offset], byte_index+offset, addr_sz);

                }
                }

+               

                if((r != 0) || BUTTON_PRESS()) {
                        Dbprintf("operation aborted @ 0x%03.3x", byte_index);
                        switch_off_tag_rwd();
                if((r != 0) || BUTTON_PRESS()) {
                        Dbprintf("operation aborted @ 0x%03.3x", byte_index);
                        switch_off_tag_rwd();

-                       LED_B_OFF();
-                       LED_C_OFF();
+                       LEDsoff();

                        return;
                }
 
         WDT_HIT();
                byte_index++;
                        return;
                }
 
         WDT_HIT();
                byte_index++;

-        if(byte_index & 0x10) LED_C_ON(); else LED_C_OFF();
-       }
-    LED_B_OFF();
-    LED_C_OFF();
-    DbpString("write successful");
-#else
-       for(byte_index = -2; byte_index < 200; byte_index++)
-       {
-               Dbprintf("+ Try RndValue %d...", byte_index);
-               if(_LegicRfWriter(bytes, offset, addr_sz, BigBuf, byte_index) == 0)
-                       break;

        }
        }

-#endif
-
+       LEDsoff();
+    if ( MF_DBGLEVEL >= 1) DbpString("write successful");

 }
 
 void LegicRfRawWriter(int address, int byte, int iv) {
 }
 
 void LegicRfRawWriter(int address, int byte, int iv) {

-       int byte_index=0, addr_sz=0;
+
+       int byte_index = 0, addr_sz = 0;

                                                                                                  
        iv = (iv <= 0) ? SESSION_IV : iv;
        
        LegicCommonInit();
        
                                                                                                  
        iv = (iv <= 0) ? SESSION_IV : iv;
        
        LegicCommonInit();
        

-       DbpString("setting up legic card");
+       if ( MF_DBGLEVEL >= 2) DbpString("setting up legic card");
+       

        uint32_t tag_type = perform_setup_phase_rwd(iv);
        uint32_t tag_type = perform_setup_phase_rwd(iv);

+       

        switch_off_tag_rwd();
        switch_off_tag_rwd();

+       

        switch(tag_type) {
                case 0x0d:
                        if(address > 22) {
        switch(tag_type) {
                case 0x0d:
                        if(address > 22) {


@@ -641,7 +701,7 @@ void LegicRfRawWriter(int address, int byte, int iv) {
                                return;
                        }
                        addr_sz = 5;
                                return;
                        }
                        addr_sz = 5;

-                       Dbprintf("MIM22 card found, writing at addr 0x%02.2x - value 0x%02.2x ...", address, byte);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM22 card found, writing at addr 0x%02.2x - value 0x%02.2x ...", address, byte);

                        break;
                case 0x1d:
                        if(address > 0x100) {
                        break;
                case 0x1d:
                        if(address > 0x100) {


@@ -649,7 +709,7 @@ void LegicRfRawWriter(int address, int byte, int iv) {
                                return;
                        }
                        addr_sz = 8;
                                return;
                        }
                        addr_sz = 8;

-                       Dbprintf("MIM256 card found, writing at addr 0x%02.2x - value 0x%02.2x ...", address, byte);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM256 card found, writing at addr 0x%02.2x - value 0x%02.2x ...", address, byte);

                        break;
                case 0x3d:
                        if(address > 0x400) {
                        break;
                case 0x3d:
                        if(address > 0x400) {


@@ -657,14 +717,16 @@ void LegicRfRawWriter(int address, int byte, int iv) {
                        return;
                }
                        addr_sz = 10;
                        return;
                }
                        addr_sz = 10;

-                       Dbprintf("MIM1024 card found, writing at addr 0x%03.3x - value 0x%03.3x ...", address, byte);
+                       if ( MF_DBGLEVEL >= 2) Dbprintf("MIM1024 card found, writing at addr 0x%03.3x - value 0x%03.3x ...", address, byte);

                        break;
                default:
                        Dbprintf("No or unknown card found, aborting");
             return;
        }
                        break;
                default:
                        Dbprintf("No or unknown card found, aborting");
             return;
        }

+       

        Dbprintf("integer value: %d address: %d  addr_sz: %d", byte, address, addr_sz);
     LED_B_ON();
        Dbprintf("integer value: %d address: %d  addr_sz: %d", byte, address, addr_sz);
     LED_B_ON();

+       

        perform_setup_phase_rwd(iv);
     //legic_prng_forward(2);
                
        perform_setup_phase_rwd(iv);
     //legic_prng_forward(2);
                


@@ -673,28 +735,29 @@ void LegicRfRawWriter(int address, int byte, int iv) {
        if((r != 0) || BUTTON_PRESS()) {
                Dbprintf("operation aborted @ 0x%03.3x (%1d)", byte_index, r);
                switch_off_tag_rwd();
        if((r != 0) || BUTTON_PRESS()) {
                Dbprintf("operation aborted @ 0x%03.3x (%1d)", byte_index, r);
                switch_off_tag_rwd();

-               LED_B_OFF();
-               LED_C_OFF();
+               LEDsoff();

                return;
        }
                return;
        }

-       
-    LED_B_OFF();
-    LED_C_OFF();
-    DbpString("write successful");
-}

 
 

-int timestamp;
+    LEDsoff();
+    if ( MF_DBGLEVEL >= 1) DbpString("write successful");
+}

 
 

-/* Handle (whether to respond) a frame in tag mode */
+/* Handle (whether to respond) a frame in tag mode
+ * Only called when simulating a tag.
+ */

 static void frame_handle_tag(struct legic_frame const * const f)
 {
        uint8_t *BigBuf = BigBuf_get_addr();
 
    /* First Part of Handshake (IV) */
    if(f->bits == 7) {
 static void frame_handle_tag(struct legic_frame const * const f)
 {
        uint8_t *BigBuf = BigBuf_get_addr();
 
    /* First Part of Handshake (IV) */
    if(f->bits == 7) {

-//     if(f->data == SESSION_IV) {
+

         LED_C_ON();
         LED_C_ON();

-        prng_timer->TC_CCR = AT91C_TC_SWTRG;
+        
+               prng_timer->TC_CCR = AT91C_TC_SWTRG;
+               while(prng_timer->TC_CV > 1) ;
+               

         legic_prng_init(f->data);
         frame_send_tag(0x3d, 6, 1); /* 0x3d^0x26 = 0x1b */
         legic_state = STATE_IV;
         legic_prng_init(f->data);
         frame_send_tag(0x3d, 6, 1); /* 0x3d^0x26 = 0x1b */
         legic_state = STATE_IV;


@@ -703,16 +766,11 @@ static void frame_handle_tag(struct legic_frame const * const f)
         legic_prng_iv = f->data;
  
         /* TIMEOUT */
         legic_prng_iv = f->data;
  
         /* TIMEOUT */

-        timer->TC_CCR = AT91C_TC_SWTRG;
-        while(timer->TC_CV > 1);
-        while(timer->TC_CV < 280);
+               ResetClock();
+               
+        //while(timer->TC_CV < 280);
+               WAIT(280)

         return;
         return;

-//      } else if((prng_timer->TC_CV % 50) > 40) {
-//        legic_prng_init(f->data);
-//        frame_send_tag(0x3d, 6, 1);
-//        SpinDelay(20);
-//        return;
-//     }

    }
 
    /* 0x19==??? */
    }
 
    /* 0x19==??? */


@@ -723,9 +781,11 @@ static void frame_handle_tag(struct legic_frame const * const f)
          legic_state = STATE_CON;
 
          /* TIMEOUT */
          legic_state = STATE_CON;
 
          /* TIMEOUT */

-         timer->TC_CCR = AT91C_TC_SWTRG;
-         while(timer->TC_CV > 1);
-         while(timer->TC_CV < 200);
+                ResetClock();
+                
+         //while(timer->TC_CV < 200);
+                WAIT(200)
+                

          return;
       } else {
          legic_state = STATE_DISCON;
          return;
       } else {
          legic_state = STATE_DISCON;


@@ -750,11 +810,13 @@ static void frame_handle_tag(struct legic_frame const * const f)
 
          frame_send_tag(hash | data, 12, 1);
 
 
          frame_send_tag(hash | data, 12, 1);
 

-         /* SHORT TIMEOUT */
-         timer->TC_CCR = AT91C_TC_SWTRG;
-         while(timer->TC_CV > 1);
+         /* TIMEOUT */
+                ResetClock();
+                

          legic_prng_forward(2);
          legic_prng_forward(2);

-         while(timer->TC_CV < 180);
+         //while(timer->TC_CV < 180);
+                WAIT(180)
+                

          return;
       }
    }
          return;
       }
    }


@@ -803,21 +865,25 @@ static void frame_handle_tag(struct legic_frame const * const f)
 /* Read bit by bit untill full frame is received
  * Call to process frame end answer
  */
 /* Read bit by bit untill full frame is received
  * Call to process frame end answer
  */

-static void emit(int bit)
-{
-  if(bit == -1) {
-     if(current_frame.bits <= 4) {
-        frame_clean(&current_frame);
-     } else {
-        frame_handle_tag(&current_frame);
-        frame_clean(&current_frame);
-     }
-     WDT_HIT();
-  } else if(bit == 0) {
-    frame_append_bit(&current_frame, 0);
-  } else if(bit == 1) {
-    frame_append_bit(&current_frame, 1);
-  }
+static void emit(int bit) {
+
+       switch (bit) {
+               case 1:
+                       frame_append_bit(&current_frame, 1);
+                       break;                  
+               case 0:
+                       frame_append_bit(&current_frame, 0);
+                       break;
+               default: 
+                       if(current_frame.bits <= 4) {
+                               frame_clean(&current_frame);
+                       } else {
+                               frame_handle_tag(&current_frame);
+                               frame_clean(&current_frame);
+                       }
+                       WDT_HIT();
+                       break;
+       } 

 }
 
 void LegicRfSimulate(int phase, int frame, int reqresp)
 }
 
 void LegicRfSimulate(int phase, int frame, int reqresp)


@@ -833,83 +899,73 @@ void LegicRfSimulate(int phase, int frame, int reqresp)
    * seems to be 300us-ish.
    */
 
    * seems to be 300us-ish.
    */
 

-//   if(phase < 0) {
-//      int i;
-//      for(i=0; i<=reqresp; i++) {
-//         legic_prng_init(SESSION_IV);
-//         Dbprintf("i=%u, key 0x%3.3x", i, get_key_stream(i, frame));
-//      }
-//      return;
-//   }
-
-   legic_phase_drift = phase;
-   legic_frame_drift = frame;
-   legic_reqresp_drift = reqresp;
-
-   FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
-   SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
-   FpgaSetupSsc();
-   FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_MODULATE_212K);
-   
-   /* Bitbang the receiver */
-   AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
-   AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
-   
-   setup_timer();
-   crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
+       legic_phase_drift = phase;
+       legic_frame_drift = frame;
+       legic_reqresp_drift = reqresp;
+
+       FpgaDownloadAndGo(FPGA_BITSTREAM_HF);
+       SetAdcMuxFor(GPIO_MUXSEL_HIPKD);
+       FpgaSetupSsc();
+       FpgaWriteConfWord(FPGA_MAJOR_MODE_HF_SIMULATOR | FPGA_HF_SIMULATOR_MODULATE_212K);
+
+       /* Bitbang the receiver */
+       AT91C_BASE_PIOA->PIO_ODR = GPIO_SSC_DIN;
+       AT91C_BASE_PIOA->PIO_PER = GPIO_SSC_DIN;
+
+       setup_timer();
+       crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
+
+       int old_level = 0;
+       int active = 0;
+       legic_state = STATE_DISCON;
+
+       LED_B_ON();
+       DbpString("Starting Legic emulator, press button to end");

    
    

-   int old_level = 0;
-   int active = 0;
-   legic_state = STATE_DISCON;
-
-   LED_B_ON();
-   DbpString("Starting Legic emulator, press button to end");
-   while(!BUTTON_PRESS() && !usb_poll_validate_length()) {
-      int level = !!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
-      int time = timer->TC_CV;
-                
-      if(level != old_level) {
-         if(level == 1) {
-            timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
-            if(FUZZ_EQUAL(time, RWD_TIME_1, RWD_TIME_FUZZ)) {
-               /* 1 bit */
-               emit(1);
-               active = 1;
-               LED_A_ON();
-            } else if(FUZZ_EQUAL(time, RWD_TIME_0, RWD_TIME_FUZZ)) {
-               /* 0 bit */
-               emit(0);
-               active = 1;
-               LED_A_ON();
-            } else if(active) {
-               /* invalid */
-               emit(-1);
-               active = 0;
-               LED_A_OFF();
-            }
-         }
-      }
+       while(!BUTTON_PRESS() && !usb_poll_validate_length()) {
+               int level = !!(AT91C_BASE_PIOA->PIO_PDSR & GPIO_SSC_DIN);
+               int time = timer->TC_CV;

 
 

-      if(time >= (RWD_TIME_1+RWD_TIME_FUZZ) && active) {
-         /* Frame end */
-         emit(-1);
-         active = 0;
-         LED_A_OFF();
-      }
-                
-      if(time >= (20*RWD_TIME_1) && (timer->TC_SR & AT91C_TC_CLKSTA)) {
-         timer->TC_CCR = AT91C_TC_CLKDIS;
-      }
-                
-      old_level = level;
-      WDT_HIT();
-   }
-   DbpString("Stopped");
-   LED_B_OFF();
-   LED_A_OFF();
-   LED_C_OFF();
-}
+               if(level != old_level) {
+                       if(level == 1) {
+                               timer->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
+                               
+                               if (FUZZ_EQUAL(time, RWD_TIME_1, RWD_TIME_FUZZ)) {
+                                       /* 1 bit */
+                                       emit(1);
+                                       active = 1;
+                                       LED_A_ON();
+                               } else if (FUZZ_EQUAL(time, RWD_TIME_0, RWD_TIME_FUZZ)) {
+                                       /* 0 bit */
+                                       emit(0);
+                                       active = 1;
+                                       LED_A_ON();
+                               } else if (active) {
+                                       /* invalid */
+                                       emit(-1);
+                                       active = 0;
+                                       LED_A_OFF();
+                               }
+                       }
+               }

 
 

+               /* Frame end */
+               if(time >= (RWD_TIME_1+RWD_TIME_FUZZ) && active) {
+                       emit(-1);
+                       active = 0;
+                       LED_A_OFF();
+               }
+
+               if(time >= (20*RWD_TIME_1) && (timer->TC_SR & AT91C_TC_CLKSTA)) {
+                       timer->TC_CCR = AT91C_TC_CLKDIS;
+               }
+
+               old_level = level;
+               WDT_HIT();
+       }
+       if ( MF_DBGLEVEL >= 1) DbpString("Stopped");
+       LEDsoff();
+}

 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------
 
 //-----------------------------------------------------------------------------
 //-----------------------------------------------------------------------------

diff --git a/armsrc/legicrf.h b/armsrc/legicrf.h
index 4dd5e5b82e76561de146698016520eb3adda5bd3..e00de6ac42f92b12fcd18291f5a4f02766318598 100644 (file)
--- a/armsrc/legicrf.h
+++ b/armsrc/legicrf.h
@@ -11,6 +11,14 @@
 #ifndef __LEGICRF_H
 #define __LEGICRF_H
 
 #ifndef __LEGICRF_H
 #define __LEGICRF_H
 

+#include "proxmark3.h" //
+#include "apps.h"
+#include "util.h"              //
+#include "string.h"            
+#include "legic_prng.h"        // legic PRNG impl
+#include "crc.h"               // legic crc-4
+
+

 extern void LegicRfSimulate(int phase, int frame, int reqresp);
 extern int  LegicRfReader(int offset, int bytes, int iv);
 extern void LegicRfWriter(int offset, int bytes, int iv);
 extern void LegicRfSimulate(int phase, int frame, int reqresp);
 extern int  LegicRfReader(int offset, int bytes, int iv);
 extern void LegicRfWriter(int offset, int bytes, int iv);

diff --git a/client/cmdhf.c b/client/cmdhf.c
index 0cbca7514f59afd0175f36286c382ea1dda7743b..025a83d4087796657df6a975d3bbd8b5d4489e1d 100644 (file)
--- a/client/cmdhf.c
+++ b/client/cmdhf.c
@@ -37,161 +37,149 @@ int CmdHFTune(const char *Cmd) {
        return 0;
 }
 
        return 0;
 }
 

-
-int applyIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-       switch(cmd[0])
-       {
-       case ISO14443A_CMD_WUPA:        snprintf(exp,size,"WUPA"); break;
-       case ISO14443A_CMD_ANTICOLL_OR_SELECT:{
-               // 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor)
-               // 93 70 = Select (usage: 9370+5bytes 9320 answer - answer: 1byte SAK)
-               if(cmd[1] == 0x70)
-                       snprintf(exp,size,"SELECT_UID");
-               else
-                       snprintf(exp,size,"ANTICOLL");
-               break;
-       }
-       case ISO14443A_CMD_ANTICOLL_OR_SELECT_2:{
-               //95 20 = Anticollision of cascade level2
-               //95 70 = Select of cascade level2
-               if(cmd[2] == 0x70)
-                       snprintf(exp,size,"SELECT_UID-2");
-               else
-                       snprintf(exp,size,"ANTICOLL-2");
-               break;
-       }
-       case ISO14443A_CMD_REQA:                snprintf(exp,size,"REQA"); break;
-       case ISO14443A_CMD_READBLOCK:   snprintf(exp,size,"READBLOCK(%d)",cmd[1]); break;
-       case ISO14443A_CMD_WRITEBLOCK:  snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); break;
-       case ISO14443A_CMD_HALT:                snprintf(exp,size,"HALT"); break;
-       case ISO14443A_CMD_RATS:                snprintf(exp,size,"RATS"); break;
-       case MIFARE_CMD_INC:                    snprintf(exp,size,"INC(%d)",cmd[1]); break;
-       case MIFARE_CMD_DEC:                    snprintf(exp,size,"DEC(%d)",cmd[1]); break;
-       case MIFARE_CMD_RESTORE:                snprintf(exp,size,"RESTORE(%d)",cmd[1]); break;
-       case MIFARE_CMD_TRANSFER:               snprintf(exp,size,"TRANSFER(%d)",cmd[1]); break;
-       case MIFARE_AUTH_KEYA:{
-               if ( cmdsize > 3)
-                       snprintf(exp,size,"AUTH-A(%d)",cmd[1]); 
-               else
-                       //      case MIFARE_ULEV1_VERSION :  both 0x60.
-                       snprintf(exp,size,"EV1 VERSION");
-               break;
-       }
-       case MIFARE_AUTH_KEYB:                  snprintf(exp,size,"AUTH-B(%d)",cmd[1]); break;
-       case MIFARE_MAGICWUPC1:                 snprintf(exp,size,"MAGIC WUPC1"); break;
-       case MIFARE_MAGICWUPC2:                 snprintf(exp,size,"MAGIC WUPC2"); break;
-       case MIFARE_MAGICWIPEC:                 snprintf(exp,size,"MAGIC WIPEC"); break;
-       case MIFARE_ULC_AUTH_1 :                snprintf(exp,size,"AUTH "); break;
-       case MIFARE_ULC_AUTH_2 :                snprintf(exp,size,"AUTH_ANSW"); break;
-       case MIFARE_ULEV1_AUTH :        
-               if ( cmdsize == 7 )
-                       snprintf(exp,size,"PWD-AUTH KEY: 0x%02x%02x%02x%02x", cmd[1], cmd[2], cmd[3], cmd[4] );
-               else
-                       snprintf(exp,size,"PWD-AUTH");
-               break;
-       case MIFARE_ULEV1_FASTREAD : {
-               if ( cmdsize >=3 && cmd[2] <= 0xE6)
-                       snprintf(exp,size,"READ RANGE (%d-%d)",cmd[1],cmd[2]); 
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULC_WRITE : {
-               if ( cmd[1] < 0x21 )
-                       snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); 
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_READ_CNT :{
-               if ( cmd[1] < 5 )
-                       snprintf(exp,size,"READ CNT(%d)",cmd[1]);
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_INCR_CNT : {
-               if ( cmd[1] < 5 )
-                       snprintf(exp,size,"INCR(%d)",cmd[1]);
-               else
-                       snprintf(exp,size,"?");
-               break;
-       }
-       case MIFARE_ULEV1_READSIG :             snprintf(exp,size,"READ_SIG"); break;
-       case MIFARE_ULEV1_CHECKTEAR :   snprintf(exp,size,"CHK_TEARING(%d)",cmd[1]); break;
-       case MIFARE_ULEV1_VCSL :                snprintf(exp,size,"VCSL"); break;
-       default:                                                return 0;
+int applyIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       switch ( cmd[0] ){
+               case ISO14443A_CMD_WUPA:        snprintf(exp,size,"WUPA"); break;
+               case ISO14443A_CMD_ANTICOLL_OR_SELECT:{
+                       // 93 20 = Anticollision (usage: 9320 - answer: 4bytes UID+1byte UID-bytes-xor)
+                       // 93 70 = Select (usage: 9370+5bytes 9320 answer - answer: 1byte SAK)
+                       if(cmd[1] == 0x70)
+                               snprintf(exp,size,"SELECT_UID");
+                       else
+                               snprintf(exp,size,"ANTICOLL");
+                       break;
+               }
+               case ISO14443A_CMD_ANTICOLL_OR_SELECT_2:{
+                       //95 20 = Anticollision of cascade level2
+                       //95 70 = Select of cascade level2
+                       if(cmd[2] == 0x70)
+                               snprintf(exp,size,"SELECT_UID-2");
+                       else
+                               snprintf(exp,size,"ANTICOLL-2");
+                       break;
+               }
+               case ISO14443A_CMD_REQA:                snprintf(exp,size,"REQA"); break;
+               case ISO14443A_CMD_READBLOCK:   snprintf(exp,size,"READBLOCK(%d)",cmd[1]); break;
+               case ISO14443A_CMD_WRITEBLOCK:  snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); break;
+               case ISO14443A_CMD_HALT:                snprintf(exp,size,"HALT"); break;
+               case ISO14443A_CMD_RATS:                snprintf(exp,size,"RATS"); break;
+               case MIFARE_CMD_INC:                    snprintf(exp,size,"INC(%d)",cmd[1]); break;
+               case MIFARE_CMD_DEC:                    snprintf(exp,size,"DEC(%d)",cmd[1]); break;
+               case MIFARE_CMD_RESTORE:                snprintf(exp,size,"RESTORE(%d)",cmd[1]); break;
+               case MIFARE_CMD_TRANSFER:               snprintf(exp,size,"TRANSFER(%d)",cmd[1]); break;
+               case MIFARE_AUTH_KEYA:{
+                       if ( cmdsize > 3)
+                               snprintf(exp,size,"AUTH-A(%d)",cmd[1]); 
+                       else
+                               //      case MIFARE_ULEV1_VERSION :  both 0x60.
+                               snprintf(exp,size,"EV1 VERSION");
+                       break;
+               }
+               case MIFARE_AUTH_KEYB:                  snprintf(exp,size,"AUTH-B(%d)",cmd[1]); break;
+               case MIFARE_MAGICWUPC1:                 snprintf(exp,size,"MAGIC WUPC1"); break;
+               case MIFARE_MAGICWUPC2:                 snprintf(exp,size,"MAGIC WUPC2"); break;
+               case MIFARE_MAGICWIPEC:                 snprintf(exp,size,"MAGIC WIPEC"); break;
+               case MIFARE_ULC_AUTH_1 :                snprintf(exp,size,"AUTH "); break;
+               case MIFARE_ULC_AUTH_2 :                snprintf(exp,size,"AUTH_ANSW"); break;
+               case MIFARE_ULEV1_AUTH :        
+                       if ( cmdsize == 7 )
+                               snprintf(exp,size,"PWD-AUTH KEY: 0x%02x%02x%02x%02x", cmd[1], cmd[2], cmd[3], cmd[4] );
+                       else
+                               snprintf(exp,size,"PWD-AUTH");
+                       break;
+               case MIFARE_ULEV1_FASTREAD : {
+                       if ( cmdsize >=3 && cmd[2] <= 0xE6)
+                               snprintf(exp,size,"READ RANGE (%d-%d)",cmd[1],cmd[2]); 
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULC_WRITE : {
+                       if ( cmd[1] < 0x21 )
+                               snprintf(exp,size,"WRITEBLOCK(%d)",cmd[1]); 
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_READ_CNT :{
+                       if ( cmd[1] < 5 )
+                               snprintf(exp,size,"READ CNT(%d)",cmd[1]);
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_INCR_CNT : {
+                       if ( cmd[1] < 5 )
+                               snprintf(exp,size,"INCR(%d)",cmd[1]);
+                       else
+                               snprintf(exp,size,"?");
+                       break;
+               }
+               case MIFARE_ULEV1_READSIG :             snprintf(exp,size,"READ_SIG"); break;
+               case MIFARE_ULEV1_CHECKTEAR :   snprintf(exp,size,"CHK_TEARING(%d)",cmd[1]); break;
+               case MIFARE_ULEV1_VCSL :                snprintf(exp,size,"VCSL"); break;
+               default:                                                return 0;

        }
        return 1;
 }
 
        }
        return 1;
 }
 

-void annotateIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
+void annotateIso14443a(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {

        applyIso14443a(exp, size, cmd, cmdsize);
 }
 
        applyIso14443a(exp, size, cmd, cmdsize);
 }
 

-void annotateIclass(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-       switch(cmd[0])
-       {
-       case ICLASS_CMD_ACTALL:      snprintf(exp,size,"ACTALL"); break;
-       case ICLASS_CMD_READ_OR_IDENTIFY:{
-               if(cmdsize > 1){
-                       snprintf(exp,size,"READ(%d)",cmd[1]);
-               }else{
-                       snprintf(exp,size,"IDENTIFY");
+void annotateIclass(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       switch (cmd[0]) {
+               case ICLASS_CMD_ACTALL:      snprintf(exp,size,"ACTALL"); break;
+               case ICLASS_CMD_READ_OR_IDENTIFY:{
+                       if(cmdsize > 1){
+                               snprintf(exp,size,"READ(%d)",cmd[1]);
+                       }else{
+                               snprintf(exp,size,"IDENTIFY");
+                       }
+                       break;

                }
                }

-               break;
-       }
-       case ICLASS_CMD_SELECT:      snprintf(exp,size,"SELECT"); break;
-       case ICLASS_CMD_PAGESEL:     snprintf(exp,size,"PAGESEL(%d)", cmd[1]); break;
-       case ICLASS_CMD_READCHECK_KC:snprintf(exp,size,"READCHECK[Kc](%d)", cmd[1]); break;
-       case ICLASS_CMD_READCHECK_KD:snprintf(exp,size,"READCHECK[Kd](%d)", cmd[1]); break;
-       case ICLASS_CMD_CHECK:       snprintf(exp,size,"CHECK"); break;
-       case ICLASS_CMD_DETECT:      snprintf(exp,size,"DETECT"); break;
-       case ICLASS_CMD_HALT:        snprintf(exp,size,"HALT"); break;
-       case ICLASS_CMD_UPDATE:      snprintf(exp,size,"UPDATE(%d)",cmd[1]); break;
-       case ICLASS_CMD_ACT:         snprintf(exp,size,"ACT"); break;
-       case ICLASS_CMD_READ4:       snprintf(exp,size,"READ4(%d)",cmd[1]); break;
-       default:                     snprintf(exp,size,"?"); break;
+               case ICLASS_CMD_SELECT:      snprintf(exp,size,"SELECT"); break;
+               case ICLASS_CMD_PAGESEL:     snprintf(exp,size,"PAGESEL(%d)", cmd[1]); break;
+               case ICLASS_CMD_READCHECK_KC:snprintf(exp,size,"READCHECK[Kc](%d)", cmd[1]); break;
+               case ICLASS_CMD_READCHECK_KD:snprintf(exp,size,"READCHECK[Kd](%d)", cmd[1]); break;
+               case ICLASS_CMD_CHECK:       snprintf(exp,size,"CHECK"); break;
+               case ICLASS_CMD_DETECT:      snprintf(exp,size,"DETECT"); break;
+               case ICLASS_CMD_HALT:        snprintf(exp,size,"HALT"); break;
+               case ICLASS_CMD_UPDATE:      snprintf(exp,size,"UPDATE(%d)",cmd[1]); break;
+               case ICLASS_CMD_ACT:         snprintf(exp,size,"ACT"); break;
+               case ICLASS_CMD_READ4:       snprintf(exp,size,"READ4(%d)",cmd[1]); break;
+               default:                     snprintf(exp,size,"?"); break;

        }
        return;
 }
 
        }
        return;
 }
 

-void annotateIso15693(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
-
-       if(cmd[0] == 0x26)
-       {
+void annotateIso15693(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {
+       if(cmd[0] == 0x26) {

                switch(cmd[1]){
                switch(cmd[1]){

-               case ISO15693_INVENTORY           :snprintf(exp, size, "INVENTORY");break;
-               case ISO15693_STAYQUIET           :snprintf(exp, size, "STAY_QUIET");break;
-               default:                     snprintf(exp,size,"?"); break;
-
+                       case ISO15693_INVENTORY                         :snprintf(exp, size, "INVENTORY");break;
+                       case ISO15693_STAYQUIET                         :snprintf(exp, size, "STAY_QUIET");break;
+                       default                                                         :snprintf(exp,size,"?"); break;

                }
                }

-       }else if(cmd[0] == 0x02)
-       {
-               switch(cmd[1])
-               {
-               case ISO15693_READBLOCK            :snprintf(exp, size, "READBLOCK");break;
-               case ISO15693_WRITEBLOCK           :snprintf(exp, size, "WRITEBLOCK");break;
-               case ISO15693_LOCKBLOCK            :snprintf(exp, size, "LOCKBLOCK");break;
-               case ISO15693_READ_MULTI_BLOCK     :snprintf(exp, size, "READ_MULTI_BLOCK");break;
-               case ISO15693_SELECT               :snprintf(exp, size, "SELECT");break;
-               case ISO15693_RESET_TO_READY       :snprintf(exp, size, "RESET_TO_READY");break;
-               case ISO15693_WRITE_AFI            :snprintf(exp, size, "WRITE_AFI");break;
-               case ISO15693_LOCK_AFI             :snprintf(exp, size, "LOCK_AFI");break;
-               case ISO15693_WRITE_DSFID          :snprintf(exp, size, "WRITE_DSFID");break;
-               case ISO15693_LOCK_DSFID           :snprintf(exp, size, "LOCK_DSFID");break;
-               case ISO15693_GET_SYSTEM_INFO      :snprintf(exp, size, "GET_SYSTEM_INFO");break;
-               case ISO15693_READ_MULTI_SECSTATUS :snprintf(exp, size, "READ_MULTI_SECSTATUS");break;
-               default:                            snprintf(exp,size,"?"); break;
+       } else if(cmd[0] == 0x02) {
+               switch (cmd[1]) {
+                       case ISO15693_READBLOCK            :snprintf(exp, size, "READBLOCK");break;
+                       case ISO15693_WRITEBLOCK           :snprintf(exp, size, "WRITEBLOCK");break;
+                       case ISO15693_LOCKBLOCK            :snprintf(exp, size, "LOCKBLOCK");break;
+                       case ISO15693_READ_MULTI_BLOCK     :snprintf(exp, size, "READ_MULTI_BLOCK");break;
+                       case ISO15693_SELECT               :snprintf(exp, size, "SELECT");break;
+                       case ISO15693_RESET_TO_READY       :snprintf(exp, size, "RESET_TO_READY");break;
+                       case ISO15693_WRITE_AFI            :snprintf(exp, size, "WRITE_AFI");break;
+                       case ISO15693_LOCK_AFI             :snprintf(exp, size, "LOCK_AFI");break;
+                       case ISO15693_WRITE_DSFID          :snprintf(exp, size, "WRITE_DSFID");break;
+                       case ISO15693_LOCK_DSFID           :snprintf(exp, size, "LOCK_DSFID");break;
+                       case ISO15693_GET_SYSTEM_INFO      :snprintf(exp, size, "GET_SYSTEM_INFO");break;
+                       case ISO15693_READ_MULTI_SECSTATUS :snprintf(exp, size, "READ_MULTI_SECSTATUS");break;
+                       default:                            snprintf(exp,size,"?"); break;

                }
        }
 }
 
                }
        }
 }
 

-void annotateTopaz(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
+void annotateTopaz(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){

        switch(cmd[0]) {
                case TOPAZ_REQA                                         :snprintf(exp, size, "REQA");break;
                case TOPAZ_WUPA                                         :snprintf(exp, size, "WUPA");break;
        switch(cmd[0]) {
                case TOPAZ_REQA                                         :snprintf(exp, size, "REQA");break;
                case TOPAZ_WUPA                                         :snprintf(exp, size, "WUPA");break;


@@ -345,8 +333,7 @@ void annotateMfDesfire(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
 0A 11 22 33 44 55 66 = Authenticate (11 22 33 44 55 66 = data to authenticate)
 **/
 
 0A 11 22 33 44 55 66 = Authenticate (11 22 33 44 55 66 = data to authenticate)
 **/
 

-void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
-{
+void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize) {

        switch(cmd[0]){
                case ISO14443B_REQB             : {
                        
        switch(cmd[0]){
                case ISO14443B_REQB             : {
                        


@@ -379,6 +366,18 @@ void annotateIso14443b(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize)
        }
 }
 
        }
 }
 

+// LEGIC 
+// 1 = read
+// 0 = write
+// Quite simpel tag
+void annotateLegic(char *exp, size_t size, uint8_t* cmd, uint8_t cmdsize){
+       switch(cmd[0]) {
+               case LEGIC_HSK                                          :snprintf(exp, size, "HANDSHAKE");break;
+               case LEGIC_READ                                         :snprintf(exp, size, "READ");break;
+               case LEGIC_WRITE                                        :snprintf(exp, size, "WRITE");break;
+               default                                                         :snprintf(exp,size,"?"); break;
+       }               
+}

 /**
  * @brief iso14443A_CRC_check Checks CRC in command or response
  * @param isResponse
 /**
  * @brief iso14443A_CRC_check Checks CRC in command or response
  * @param isResponse


@@ -490,6 +489,16 @@ uint8_t iclass_CRC_check(bool isResponse, uint8_t* data, uint8_t len)
        }
 }
 
        }
 }
 

+uint8_t legic_CRC_check(bool isResponse, uint8_t* data, uint8_t len){
+       if (len > 2) return 2;
+       return 0;
+       // crc_init(&legic_crc, 4, 0x19 >> 1, 0x5, 0);
+       // crc_clear(&legic_crc);
+       // crc_update(&legic_crc, 1, 1); /* CMD_READ */
+       // crc_update(&legic_crc, byte_index, cmd_sz-1);
+       // crc_update(&legic_crc, value, 8);
+       // return crc_finish(&legic_crc);
+}

 
 bool is_last_record(uint16_t tracepos, uint8_t *trace, uint16_t traceLen)
 {
 
 bool is_last_record(uint16_t tracepos, uint8_t *trace, uint16_t traceLen)
 {


@@ -603,10 +612,12 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
                        case ISO_14443A:
                        case MFDES:
                                crcStatus = iso14443A_CRC_check(isResponse, frame, data_len);
                        case ISO_14443A:
                        case MFDES:
                                crcStatus = iso14443A_CRC_check(isResponse, frame, data_len);

-                               break;                          
+                               break;

                        default: 
                                break;
                }
                        default: 
                                break;
                }

+       } else if ( data_len == 2 && protocol == LEGIC ){
+               crcStatus = legic_CRC_check(isResponse, frame, data_len);               

        }
        //0 CRC-command, CRC not ok
        //1 CRC-command, CRC ok
        }
        //0 CRC-command, CRC not ok
        //1 CRC-command, CRC ok


@@ -661,6 +672,7 @@ uint16_t printTraceLine(uint16_t tracepos, uint16_t traceLen, uint8_t *trace, ui
                        case ISO_14443B:        annotateIso14443b(explanation,sizeof(explanation),frame,data_len); break;
                        case TOPAZ:                     annotateTopaz(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_7816_4:        annotateIso7816(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_14443B:        annotateIso14443b(explanation,sizeof(explanation),frame,data_len); break;
                        case TOPAZ:                     annotateTopaz(explanation,sizeof(explanation),frame,data_len); break;
                        case ISO_7816_4:        annotateIso7816(explanation,sizeof(explanation),frame,data_len); break;

+                       case LEGIC:                     annotateLegic(explanation,sizeof(explanation),frame,data_len); break;

                        default:                        break;
                }
        }
                        default:                        break;
                }
        }


@@ -706,10 +718,11 @@ int usage_hf_list(){
        PrintAndLog("    raw    - just show raw data without annotations");
        PrintAndLog("    14a    - interpret data as iso14443a communications");
        PrintAndLog("    14b    - interpret data as iso14443b communications");
        PrintAndLog("    raw    - just show raw data without annotations");
        PrintAndLog("    14a    - interpret data as iso14443a communications");
        PrintAndLog("    14b    - interpret data as iso14443b communications");

-               PrintAndLog("    des    - interpret data as DESFire communications");
+       PrintAndLog("    des    - interpret data as DESFire communications");

        PrintAndLog("    iclass - interpret data as iclass communications");
        PrintAndLog("    topaz  - interpret data as topaz communications");
        PrintAndLog("    7816   - interpret data as iso7816-4 communications");
        PrintAndLog("    iclass - interpret data as iclass communications");
        PrintAndLog("    topaz  - interpret data as topaz communications");
        PrintAndLog("    7816   - interpret data as iso7816-4 communications");

+       PrintAndLog("    legic  - interpret data as LEGIC communications");

        PrintAndLog("");
        PrintAndLog("example:   hf list 14a f");
        PrintAndLog("                   hf list iclass");
        PrintAndLog("");
        PrintAndLog("example:   hf list 14a f");
        PrintAndLog("                   hf list iclass");


@@ -738,8 +751,7 @@ int usage_hf_snoop(){
        return 0;
 }
 
        return 0;
 }
 

-int CmdHFList(const char *Cmd)
-{
+int CmdHFList(const char *Cmd) {

        clearCommandBuffer();
                
        bool showWaitCycles = false;
        clearCommandBuffer();
                
        bool showWaitCycles = false;


@@ -770,7 +782,8 @@ int CmdHFList(const char *Cmd)
        else if(strcmp(type, "14b") == 0)       protocol = ISO_14443B;
        else if(strcmp(type, "topaz")== 0)      protocol = TOPAZ;
        else if(strcmp(type, "7816")== 0)       protocol = ISO_7816_4;  
        else if(strcmp(type, "14b") == 0)       protocol = ISO_14443B;
        else if(strcmp(type, "topaz")== 0)      protocol = TOPAZ;
        else if(strcmp(type, "7816")== 0)       protocol = ISO_7816_4;  

-       else if(strcmp(type,"des")== 0)         protocol = MFDES;                       
+       else if(strcmp(type,"des")== 0)         protocol = MFDES;
+       else if(strcmp(type,"legic")==0)        protocol = LEGIC;

        else if(strcmp(type, "raw")== 0)        protocol = -1;//No crc, no annotations
        else errors = true;
 
        else if(strcmp(type, "raw")== 0)        protocol = -1;//No crc, no annotations
        else errors = true;
 


@@ -809,8 +822,7 @@ int CmdHFList(const char *Cmd)
     PrintAndLog("      Start |        End | Src | Data (! denotes parity error)                                   | CRC | Annotation         |");
        PrintAndLog("------------|------------|-----|-----------------------------------------------------------------|-----|--------------------|");
 
     PrintAndLog("      Start |        End | Src | Data (! denotes parity error)                                   | CRC | Annotation         |");
        PrintAndLog("------------|------------|-----|-----------------------------------------------------------------|-----|--------------------|");
 

-       while(tracepos < traceLen)
-       {
+       while(tracepos < traceLen) {

                tracepos = printTraceLine(tracepos, traceLen, trace, protocol, showWaitCycles, markCRCBytes);
        }
 
                tracepos = printTraceLine(tracepos, traceLen, trace, protocol, showWaitCycles, markCRCBytes);
        }
 


@@ -854,8 +866,7 @@ int CmdHFSearch(const char *Cmd){
        return 0;
 }
 
        return 0;
 }
 

-int CmdHFSnoop(const char *Cmd)
-{
+int CmdHFSnoop(const char *Cmd) {

        char cmdp = param_getchar(Cmd, 0);      
        if (cmdp == 'h' || cmdp == 'H') return usage_hf_snoop();
        
        char cmdp = param_getchar(Cmd, 0);      
        if (cmdp == 'h' || cmdp == 'H') return usage_hf_snoop();
        

diff --git a/client/cmdhflegic.c b/client/cmdhflegic.c
index be9018f6629be5f23f76e793e55d87913fb7b793..39c64921fe509f62bd6eb0427aaddf6d45e71cfe 100644 (file)
--- a/client/cmdhflegic.c
+++ b/client/cmdhflegic.c
@@ -107,7 +107,8 @@ int CmdLegicDecode(const char *Cmd) {
        int bIsSegmented = 0;
 
        // download EML memory, where the "legic read" command puts the data.
        int bIsSegmented = 0;
 
        // download EML memory, where the "legic read" command puts the data.

-       GetEMLFromBigBuf(data_buf, sizeof(data_buf), 0);
+       // copy data from proxmark into buffer
+       GetFromBigBuf(data_buf,sizeof(data_buf),0);

        if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
                PrintAndLog("Command execute timeout");
                return 1;
        if ( !WaitForResponseTimeout(CMD_ACK, NULL, 2000)){
                PrintAndLog("Command execute timeout");
                return 1;

diff --git a/common/legic_prng.c b/common/legic_prng.c
index 1f12873c2dd8e696e16adfd21139d6702cc932c6..93229251124563174032c946d693059b3a735ce9 100644 (file)
--- a/common/legic_prng.c
+++ b/common/legic_prng.c
@@ -9,35 +9,33 @@
 #include "legic_prng.h"
 
 struct lfsr {
 #include "legic_prng.h"
 
 struct lfsr {

-  uint8_t  a;
-  uint8_t  b;
-  uint32_t c;
+       uint8_t  a;
+       uint8_t  b;
+       uint32_t c;

 } lfsr;
 
 void legic_prng_init(uint8_t init) {
 } lfsr;
 
 void legic_prng_init(uint8_t init) {

-  lfsr.c = 0;
-  lfsr.a = init;
-  if(init == 0) /* hack to get a always 0 keystream */
-    lfsr.b = 0;
-  else
-    lfsr.b = (init << 1) | 1;
+       lfsr.a = init;
+       lfsr.b = 0;  // hack to get a always 0 keystream 
+       lfsr.c = 0;
+       if(init)
+               lfsr.b = (init << 1) | 1;

 }
 
 void legic_prng_forward(int count) {
 }
 
 void legic_prng_forward(int count) {

-  lfsr.c += count;
-  while(count--) {
-    //lfsr.a = lfsr.a >> 1 | (lfsr.a ^ lfsr.a >> 6) << 6;
-       // According: http://www.proxmark.org/forum/viewtopic.php?pid=5437#p5437
-       lfsr.a = (lfsr.a >> 1 | (lfsr.a ^ lfsr.a >> 6) << 6) & 0x7F;
-    lfsr.b = lfsr.b >> 1 | (lfsr.b ^ lfsr.b >> 2 ^ lfsr.b >> 3 ^ lfsr.b >> 7) << 7;
-  }
+       lfsr.c += count;
+       while(count--) {
+               // According: http://www.proxmark.org/forum/viewtopic.php?pid=5437#p5437
+               lfsr.a = (lfsr.a >> 1 | (lfsr.a ^ lfsr.a >> 6) << 6) & 0x7F;
+               lfsr.b = lfsr.b >> 1 | (lfsr.b ^ lfsr.b >> 2 ^ lfsr.b >> 3 ^ lfsr.b >> 7) << 7;
+       }

 }
 
 }
 

-int legic_prng_count() {
-  return lfsr.c;
+uint32_t legic_prng_count() {
+       return lfsr.c;

 }
 
 uint8_t legic_prng_get_bit() {
 }
 
 uint8_t legic_prng_get_bit() {

-  uint8_t idx = 7 - ( (lfsr.a & 4) | (lfsr.a >> 2 & 2) | (lfsr.a >> 4 & 1) );
-  return lfsr.b >> idx & 1;
-}
+       uint8_t idx = 7 - ( (lfsr.a & 4) | (lfsr.a >> 2 & 2) | (lfsr.a >> 4 & 1) );
+       return lfsr.b >> idx & 1;
+}
\ No newline at end of file

diff --git a/common/protocols.h b/common/protocols.h
index b47a2ae2b71e43e9586702d352b4f60349405ab6..0182ceb5d0b5b9849f38cbb12458495c4660c5e4 100644 (file)
--- a/common/protocols.h
+++ b/common/protocols.h
@@ -246,12 +246,14 @@ ISO 7816-4 Basic interindustry commands. For command APDU's.
 #define TOPAZ_WRITE_NE8                                        0x1B    // Write-no-erase (eight bytes)
 
 
 #define TOPAZ_WRITE_NE8                                        0x1B    // Write-no-erase (eight bytes)
 
 

+// Definetions of which protocol annotations there are available

 #define ISO_14443A     0
 #define ICLASS         1
 #define ISO_14443B     2
 #define TOPAZ          3
 #define ISO_7816_4  4
 #define MFDES          5
 #define ISO_14443A     0
 #define ICLASS         1
 #define ISO_14443B     2
 #define TOPAZ          3
 #define ISO_7816_4  4
 #define MFDES          5

+#define LEGIC          6

 
 //-- Picopass fuses
 #define FUSE_FPERS   0x80
 
 //-- Picopass fuses
 #define FUSE_FPERS   0x80


@@ -322,7 +324,12 @@ ISO 7816-4 Basic interindustry commands. For command APDU's.
 #define     MFDES_CHANGE_KEY                            0xc4
 #define     MFDES_GET_KEY_VERSION                       0x64
 #define     MFDES_AUTHENTICATION_FRAME                  0xAF
 #define     MFDES_CHANGE_KEY                            0xc4
 #define     MFDES_GET_KEY_VERSION                       0x64
 #define     MFDES_AUTHENTICATION_FRAME                  0xAF

-       
+
+// LEGIC Commands
+#define        LEGIC_HSK       0xFF
+#define                LEGIC_READ      0x01
+#define        LEGIC_WRITE     0x00
+

 void printIclassDumpInfo(uint8_t* iclass_dump);
 void getMemConfig(uint8_t mem_cfg, uint8_t chip_cfg, uint8_t *max_blk, uint8_t *app_areas, uint8_t *kb);
 
 void printIclassDumpInfo(uint8_t* iclass_dump);
 void getMemConfig(uint8_t mem_cfg, uint8_t chip_cfg, uint8_t *max_blk, uint8_t *app_areas, uint8_t *kb);
 

diff --git a/include/legic_prng.h b/include/legic_prng.h
index 36c6d550b1bfd91c628e9c3f2e40369323e26a6b..b9e778a61cf211ee163385485a48e4cb9f114e85 100644 (file)
--- a/include/legic_prng.h
+++ b/include/legic_prng.h
@@ -12,8 +12,7 @@
 #include <stdint.h>
 extern void legic_prng_init(uint8_t init);
 extern void legic_prng_forward(int count);
 #include <stdint.h>
 extern void legic_prng_init(uint8_t init);
 extern void legic_prng_forward(int count);

-extern int  legic_prng_count();
+extern uint32_t legic_prng_count();

 extern uint8_t legic_prng_get_bit();
 extern uint8_t legic_prng_get_bit();

-

 #endif
 
 #endif