some cleanup

fixed compare time for keyslot compare


git-svn-id: https://svn.spreadspace.org/avr/trunk@93 aa12f405-d877-488e-9caf-2d797e2a1cc7

1 files changed, 52 insertions, 44 deletions

diff --git a/usb-i2c-sl018/tuer-rfid.c b/usb-i2c-sl018/tuer-rfid.c
index b1a4b66..e51e361 100644
--- a/usb-i2c-sl018/tuer-rfid.c
+++ b/usb-i2c-sl018/tuer-rfid.c
@@ -38,9 +38,10 @@
 

 typedef union

 {

-  uint64_t uint;

+  uint8_t byte[8];

+  uint16_t uint16[4];

   uint32_t uint32[2];

-  unsigned char byte[8];

+  uint64_t uint64;

 } keyslot_t;

 keyslot_t EEMEM keyslots[EEPROM_SIZE/sizeof(keyslot_t)];

 

@@ -51,14 +52,6 @@ keyslot_t EEMEM keyslots[EEPROM_SIZE/sizeof(keyslot_t)];
 const uint8_t SL018_ADDR = 0xa0;

 const uint8_t SL018_WRITE = 0;

 const uint8_t SL018_READ  = 1;

-//============================================

-//  Command List, preamble + length + command 

-//============================================

-const unsigned char SL018CMD_ComSelectCard[]          ={1,1};                                               

-const unsigned char SL018CMD_ComRedLedOn[]            ={2,0x40,1};

-const unsigned char SL018CMD_ComRedLedOff[]           ={2,0x40,0};

-const unsigned char SL018CMD_ComGetFirmwareVersion[]  ={1,0xF0};

-const unsigned char SL018CMD_ComReset[]               ={1,0xFF};

 

 const char* SL018_cmd_tostring(const uint8_t status) 

 {

@@ -100,24 +93,27 @@ const char* SL018_status_tostring(const uint8_t status)
   }

 }

 

+const uint8_t SL018CMD_ComSelectCard[]          ={1,0x01};

+const uint8_t SL018CMD_ComRedLedOn[]            ={2,0x40,1};

+const uint8_t SL018CMD_ComRedLedOff[]           ={2,0x40,0};

+const uint8_t SL018CMD_ComGetFirmwareVersion[]  ={1,0xF0};

+const uint8_t SL018CMD_ComReset[]               ={1,0xFF};

 

-unsigned char twi_rcv_buff[256];

-

+uint8_t recv_twi_buf[256];

 typedef struct __attribute__((__packed__))

 {

+  uint8_t len;

   uint8_t command;

   uint8_t status;

-  unsigned char data[sizeof(twi_rcv_buff)-3];

-  uint8_t len;

+  uint8_t data[sizeof(recv_twi_buf)-3];

 } sl018_message_t;

 

-sl018_message_t* twi_message = (sl018_message_t *) &twi_rcv_buff;

+sl018_message_t* recv_twi_msg = (sl018_message_t *)&recv_twi_buf;

 uint8_t card_status =0;

 

 FILE stdio_stream;

 FILE * stdio = &stdio_stream;

 

-

 /*

              LUFA Library

      Copyright (C) Dean Camera, 2012.

@@ -169,15 +165,13 @@ void EVENT_USB_Device_Disconnect(void)
 

 

 

-bool sl018_cmd_raw(const unsigned char * buffer)

+bool sl018_cmd_raw(const uint8_t * send_twi_buf)

 {

-  uint8_t len = 0;

   uint8_t pos = 0;

-      //unsigned char ret;

-  len = buffer[0];

+      //uint8_t ret;

   if (TWI_StartTransmission(SL018_ADDR | SL018_WRITE,10) == TWI_ERROR_NoError) {

-    for(pos=0; pos<=len; pos++)

-      if( ! TWI_SendByte(buffer[pos])) {

+    for(pos=0; pos<=send_twi_buf[0]; pos++)

+      if( ! TWI_SendByte(send_twi_buf[pos])) {

         TWI_StopTransmission();

         return 1;

       }

@@ -188,10 +182,9 @@ bool sl018_cmd_raw(const unsigned char * buffer)
 

   _delay_ms(50);

   if (TWI_StartTransmission(SL018_ADDR | SL018_READ,10) == TWI_ERROR_NoError) {

-    TWI_ReceiveByte(&len, 0);

-    twi_rcv_buff[255]=len;

-    for(pos=0; pos<len; pos++)

-      if (! TWI_ReceiveByte(&twi_rcv_buff[pos], (pos == len-1) ? 1:0 ) ) {

+    TWI_ReceiveByte(recv_twi_buf, 0);

+    for(pos=1; pos<=recv_twi_buf[0]; pos++)

+      if (! TWI_ReceiveByte(&recv_twi_buf[pos], (pos == recv_twi_buf[0]) ? 1:0 ) ) {

         TWI_StopTransmission();

         return 1;

       }

@@ -203,19 +196,23 @@ bool sl018_cmd_raw(const unsigned char * buffer)
   return 0;

 }

 

-bool sl018_cmd(const unsigned char * buffer)

+bool sl018_cmd(const uint8_t * send_twi_buf)

 {

-  sl018_message_t * send_twi_message = (sl018_message_t *) (buffer+1);

-  if(sl018_cmd_raw(buffer)) {

+  if(sl018_cmd_raw(send_twi_buf)) {

     fprintf(stdio, "I2C error\n\r");

     return 0;

   } else {

-    if(twi_message->status) {

-      fprintf(stdio,"SL018 Cmd,Error: '%s','%s'\n\r",SL018_cmd_tostring(twi_message->command),SL018_status_tostring(twi_message->status));

+    if(recv_twi_msg->len < 2) {

+      fprintf(stdio,"SL018 Cmd,Error: short Message received\n\r");

+      return 0;

+    }

+    if(recv_twi_msg->status) {

+      fprintf(stdio,"SL018 Cmd,Error: '%s','%s'\n\r",SL018_cmd_tostring(recv_twi_msg->command),SL018_status_tostring(recv_twi_msg->status));

       return 0;

     }

-    if(send_twi_message->command != twi_message->command) {

-      fprintf(stdio,"SL018 Cmd missmatch: send, rcv: %02X,%02X\n\r",send_twi_message->command,twi_message->command);

+    sl018_message_t * send_twi_msg = (sl018_message_t *)send_twi_buf;

+    if(send_twi_msg->command != recv_twi_msg->command) {

+      fprintf(stdio,"SL018 Cmd,Error: mismatch: send, rcv: %02X,%02X\n\r",send_twi_msg->command,recv_twi_msg->command);

     }

   }

   return 1;

@@ -274,7 +271,7 @@ void handle_cmd(uint8_t cmd)
     case 'f': //get cardreader firmware version

              if(sl018_cmd(SL018CMD_ComGetFirmwareVersion))

              {

-               fprintf(stdio, "%s\n\r",twi_message->data);

+               fprintf(stdio, "%s\n\r",recv_twi_msg->data);

              }  

              break;

     case '4': //turn cardreader led off

@@ -302,18 +299,28 @@ void handle_cmd(uint8_t cmd)
 

 /* this generates a Fletcher8 checksum  */

 /* code from: http://stackoverflow.com/questions/13491700/8-bit-fletcher-checksum-of-16-byte-data */

-unsigned char generate_csum(unsigned char* data)

+uint8_t generate_csum(uint8_t* data)

 {

   uint16_t sum1 = 0xf, sum2 = 0xf, len = sizeof(keyslot_t) - 1;

   do { sum2 += ( sum1 += *data++ ); } while (--len);

   return sum2<<4 | sum1;

 }

 

-bool check_card(const unsigned char * uid, uint8_t uid_len)

+bool compare_keyslots(const keyslot_t* a, const keyslot_t* b) // constant time compare

+{

+  uint8_t tmp=0, i;

+  for(i=0; i<sizeof(keyslot_t); ++i)

+    tmp |= (a->byte[i] ^ a->byte[i]);

+

+  return tmp;

+}

+

+bool check_card(const uint8_t * uid, uint8_t uid_len)

 {

   keyslot_t card;

   keyslot_t eeprom_ks;

-  card.uint=0;

+  card.uint64=0;

+  uid_len = uid_len > sizeof(keyslot_t) ? sizeof(keyslot_t) : uid_len;

   for (uint8_t pos=0; pos<uid_len; pos++)

     card.byte[pos]=uid[uid_len-pos-1];

   card.byte[sizeof(keyslot_t) - 1]=generate_csum(&card.byte[0]);

@@ -321,9 +328,9 @@ bool check_card(const unsigned char * uid, uint8_t uid_len)
   bool valid=0;

   for(uint8_t ks_num=0;ks_num<(EEPROM_SIZE/sizeof(card));ks_num++) {

     eeprom_read_block(&eeprom_ks,&ks[ks_num],sizeof(eeprom_ks));

-    if(card.uint==eeprom_ks.uint) { // this breaks security (not const time)

+    if(card.uint64==eeprom_ks.uint64) {

       valid=1;

-      break; //this breaks security (not const time)

+      // break;  // this would break security (not const time)

     }

   }

   if(valid)

@@ -337,15 +344,16 @@ void handle_card(void)
   fprintf(stdio, "CARD IN: ");

   if(sl018_cmd(SL018CMD_ComSelectCard))

   {

-    for (pos=twi_message->len - 4 ; pos< 255; pos--)

-      fprintf(stdio,"%02X",twi_message->data[pos]);

+    uint8_t uid_len = recv_twi_msg->len - sizeof(recv_twi_msg->command) - sizeof(recv_twi_msg->status) - 1;

+    for (pos=uid_len-1; pos< 255; pos--)

+      fprintf(stdio,"%02X",recv_twi_msg->data[pos]);

 

     fprintf(stdio, "\n\r");

-    uint8_t type = twi_message->data[twi_message->len-1-sizeof(twi_message->command)-sizeof(twi_message->status)];

+    uint8_t type = recv_twi_msg->data[uid_len];

     if (0<type && type < 7) {

-      if(check_card(&twi_message->data[0],twi_message->len-1-sizeof(twi_message->command)-sizeof(twi_message->status))) {

+      if(check_card(recv_twi_msg->data,uid_len)) {

         sl018_cmd(SL018CMD_ComRedLedOn);

-        fprintf(stdio,"open\n\r");

+        fprintf(stdio,"open/close\n\r"); // TODO: open/close door!

         _delay_ms(255);

         sl018_cmd(SL018CMD_ComRedLedOff);

       }