- Added AES algorithm support.
authordocelic <docelic@ubuntu2.neaspec.com>
Fri, 8 Aug 2008 21:26:34 +0000 (16:26 -0500)
committerdocelic <docelic@ubuntu2.neaspec.com>
Fri, 8 Aug 2008 21:26:34 +0000 (16:26 -0500)
As published in works:
http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/
http://www.iaik.tu-graz.ac.at/aboutus/people/oswald/Bachelor%27s%20SeminarProject/index.php
http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/EfficientAESImplemetation.pdf
http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/projectpaper_pletzer.pdf
http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/Seminararbeit_Pletzer.pdf

Currently it just compiles etc., but I didn't try working with it.

Also, processor type needs to be set accordingly, because if you build for say, 8515,
you may get errors in LD stage regarding resulting image size.

src/Makefile
src/Makefile.ctapi
src/Makefile.emu
src/aes.c [new file with mode: 0644]
src/aes.h [new file with mode: 0644]
src/config.h
src/crypt.h

index 5f9c8ea..73eb8b5 100644 (file)
@@ -4,19 +4,26 @@
 # C 2008 Davor Ocelic, docelic@spinlocksolutions.com
 #
 
-# Your programmer device (for uisp -dprog=)
-BOARD=stk500
+# Your programmer device (as required by programmer
+# software)
+PROG=stk500v1
 PORT=/dev/ttyS0
 
-# Your smartcard chip (both for chip-specific
-# compilation and for uisp -dpart=)
+# Smartcard chip name as recognized by avr libc
 #ARCH=at90s2323
-ARCH=at90s8515
+#ARCH=at90s8515
 #ARCH=at90s8535
 #ARCH=atmega161
+ARCH=atmega163
+
+# Size of the external EEPROM on the smartcard. Atmel's sizes are
+# usually in bits (i.e. AT90(256) and 24C256 are both 32 KByte).
+# 00: none, 01: 16KB, 02: 32KB, 03: 64KB,
+# 04: 128KB, 05: 256KB, FF: unspec.,
+EXT_EEPROM_SIZE=0x02
 
 # The usual compile options
-CC=avr-gcc -mmcu=$(ARCH)
+CC=avr-gcc -mmcu=$(ARCH) -DEXT_EEPROM_SIZE=$(EXT_EEPROM_SIZE)
 AS=avr-as
 OBJCOPY=avr-objcopy
 SIZE=avr-size
@@ -25,6 +32,7 @@ CFLAGS=-Wall -I. -Os -mcall-prologues
 ASFLAGS=-Wall -I.
 
 CSRC= \
+       aes.c \
        auth.c \
        commands.c \
        fs.c \
@@ -49,10 +57,10 @@ OBJ=$(CSRC:.c=.o) $(SSRC:.S=.o)
 SLOCFILES = auth.c auth.h commands.c commands.h config.h eepromi2c.S sw.c \
        sw.h fs.c fs.h fstream.c fstream.h hal.c hal.h io.S main.c main.h t0.c \
        t0.h tea-$(ARCH).S tea.h tools.c tools.h transaction.c transaction.h \
-       types.h newdes-sk.c newdes-sk.h skipjack.c skipjack.h
+       types.h newdes-sk.c newdes-sk.h skipjack.c skipjack.h aes.c aes.h
 
 CALLTREEFILES = auth.c commands.c sw.c fs.c fstream.c hal.c main.c t0.c \
-       tea.c tools.c transaction.c newdes-sk.c skipjack.c
+       tea.c tools.c transaction.c newdes-sk.c skipjack.c aes.c
 
 all: sosse eedata
 
@@ -110,21 +118,17 @@ write: write-eeprom write-flash
 verify: verify-eeprom verify-flash
 
 write-eeprom:
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --erase --segment=eeprom
-       sleep 2
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --upload --segment=eeprom if=eedata.hex
+       avrdude -p $(ARCH) -c $(PROG) -P $(PORT) -U eeprom:w:eedata.hex:i
+
 verify-eeprom:
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --verify --segment=eeprom if=eedata.hex
+       avrdude -p $(ARCH) -c $(PROG) -P $(PORT) -U eeprom:v:eedata.hex:i
+
 write-flash:
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --erase --segment=flash
-       sleep 2
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --upload --segment=flash if=sosse.hex
+       avrdude -p $(ARCH) -c $(PROG) -D -P $(PORT) -U flash:w:sosse.hex:i
+
 verify-flash:
-       uisp -dprog=$(BOARD) -dpart=$(ARCH) -dserial=$(PORT) \
-               --verify --segment=flash if=sosse.hex
+       avrdude -p $(ARCH) -c $(PROG) -P $(PORT) -U flash:v:sosse.hex:i
+
+erase:
+       avrdude -p $(ARCH) -c $(PROG) -P $(PORT) -e
 
index e10b31a..249346b 100644 (file)
@@ -5,6 +5,7 @@ OBJCOPY=objcopy
 CFLAGS=-Wall -I. -O6 -g -fpic -DCTAPI -I../../scez-ng
 
 SRC=\
+       aes.c \
        auth.c \
        ctapi.c \
        hal-emu.c \
@@ -22,6 +23,7 @@ SRC=\
        transaction.c
 
 OBJ=\
+       aes.o \
        auth.o \
        ctapi.o \
        hal-emu.o \
index b6a1a2e..9eda34a 100644 (file)
@@ -5,6 +5,7 @@ OBJCOPY=objcopy
 CFLAGS=-Wall -I. -O6 -g -DDEBUG -I../../scez-ng
 
 SRC=\
+       aes.c \
        auth.c \
        hal-emu.c \
        commands.c \
@@ -20,6 +21,7 @@ SRC=\
        transaction.c
 
 OBJ=\
+       aes.o \
        auth.o \
        hal-emu.o \
        commands.o \
diff --git a/src/aes.c b/src/aes.c
new file mode 100644 (file)
index 0000000..2fad80a
--- /dev/null
+++ b/src/aes.c
@@ -0,0 +1,265 @@
+
+/*! @file
+  \brief AES functions.
+
+  AES as implemented in http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/ ,
+  files http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/EfficientAESImplemetation.pdf, 
+  http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/projectpaper_pletzer.pdf,
+  http://www.iaik.tu-graz.ac.at/teaching/10_seminare-projekte/01_Telematik%20Bakkalaureat/Seminararbeit_Pletzer.pdf
+
+  $Id: aes.c,v 1.6 2003/04/02 23:57:54 m Exp $
+*/
+
+#include <config.h>
+#include <aes.h>
+#include <tools.h>
+#ifdef DEBUG
+#include <stdio.h>
+#endif
+
+#define hton_ul(x,y)
+
+#if CONF_WITH_CRYPT_ALGO==3
+
+iu8 substitution_table_[256] = {
+0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5,  0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
+0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0,  0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
+0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC,  0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
+0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A,  0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
+0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0,  0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
+0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B,  0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
+0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85,  0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
+0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5,  0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
+0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17,  0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
+0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88,  0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
+0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C,  0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
+0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9,  0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
+0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6,  0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
+0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E,  0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
+0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94,  0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
+0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68,  0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16,
+};
+
+iu8 inverse_substitution_table_[256] = {
+0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38,  0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
+0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87,  0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
+0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D,  0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
+0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2,  0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
+0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16,  0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
+0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA,  0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
+0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A,  0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
+0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02,  0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
+0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA,  0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
+0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85,  0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
+0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89,  0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
+0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20,  0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
+0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31,  0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
+0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D,  0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
+0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0,  0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
+0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26,  0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D,
+};
+
+void aes_enc( iu8 *data, iu8 *key, iu32 data_length )
+{
+       iu32 block_counter;
+       iu8 *state;
+       iu8 round_key[16];
+       iu8 round_constant[4] = {0x01, 0x00, 0x00, 0x00};
+       iu8 counter;
+
+       for(block_counter=0 ; block_counter < data_length ; block_counter+=16)
+       {
+               state = data+block_counter;
+               round_constant[0] = 0x01;
+
+               for(counter=0 ; counter<16 ; counter++)
+                       round_key[counter]=key[counter];
+
+               for(counter = 0; counter < 9; counter++)
+               {
+                       addRoundKeyAndSubstituteBytes(state, round_key);
+                       shiftRows(state);
+                       mixColumns(state);
+                       keyExpansion(round_key, round_constant);
+               }
+
+               addRoundKeyAndSubstituteBytes(state, round_key);
+               shiftRows(state);
+               keyExpansion(round_key, round_constant);
+
+               for(counter=0 ; counter<16 ; counter++)
+                       state[counter] = state[counter]^round_key[counter];
+       }
+
+}
+
+void aes_dec( iu8 *data, iu8 *key, iu32 data_length )
+{
+       iu32 block_counter;
+       iu8 *state;
+       iu8 round_key[16];
+       iu8 round_constant[4] = {0x01, 0x00, 0x00, 0x00};
+       iu8 counter;
+
+       for(block_counter=0 ; block_counter < data_length ; block_counter+=16)
+       {
+               state = data+block_counter;
+               round_constant[0] = 0x01;
+               calculateLastRoundKey(round_key, key, round_constant);
+
+               for(counter=0 ; counter<16 ; counter++)
+                       state[counter] = state[counter]^round_key[counter];
+
+               for(counter = 9; counter > 0; counter--)
+               {
+                       inverseShiftRows(state);
+                       inverseKeyExpansion(round_key,round_constant);
+                       inverseSubstituteBytesAndAddRoundKey(state, round_key);
+                       inverseMixColumns(state);
+               }
+
+               inverseShiftRows(state);
+               inverseSubstituteBytesAndAddRoundKey(state, key);
+       }
+}
+
+void addRoundKeyAndSubstituteBytes(iu8 *state, iu8 *round_key)
+{
+  iu8 counter;
+  for(counter=0 ; counter<16 ; counter++)
+    state[counter] = substitution_table_[state[counter]^round_key[counter]];
+}
+
+void inverseSubstituteBytesAndAddRoundKey(iu8 *state, iu8 *round_key)
+{
+  iu8 counter;
+  for(counter=0 ; counter<16 ; counter++)
+    state[counter] =
+      (inverse_substitution_table_[state[counter]])^round_key[counter];
+}
+
+
+void shiftRows(iu8 *state)
+{
+  swap(state+1, state+13);
+  swap(state+2, state+10);
+  swap(state+3, state+7 );
+  swap(state+3, state+11);
+  swap(state+5, state+1 );
+  swap(state+6, state+14);
+  swap(state+3, state+15);
+  swap(state+9, state+5 );
+}
+void inverseShiftRows(iu8 *state)
+{
+  swap(state+1, state+13);
+  swap(state+2, state+10);
+  swap(state+3, state+7 );
+  swap(state+5, state+13);
+  swap(state+6, state+14);
+  swap(state+7, state+11);
+  swap(state+9, state+13);
+  swap(state+11, state+15);
+}
+void mixColumns(iu8 *state)
+{
+  iu8 word_counter;
+  iu8 t;
+  iu8 u;
+  iu8 v;
+  for(word_counter=0 ; word_counter<4 ; word_counter++)
+    {
+      t = state[word_counter*4]^
+          state[word_counter*4+1]^
+          state[word_counter*4+2]^
+          state[word_counter*4+3];
+      u = state[word_counter*4];
+      v = state[word_counter*4]^
+          state[word_counter*4+1];
+      v = xtime(v);
+      state[word_counter*4] ^= v^t;
+      v = state[word_counter*4+1]^
+          state[word_counter*4+2];
+      v = xtime(v);
+      state[word_counter*4+1] ^= v^t;
+      v = state[word_counter*4+2]^
+          state[word_counter*4+3];
+      v = xtime(v);
+      state[word_counter*4+2] ^= v^t;
+      v = state[word_counter*4+3]^u;
+      v = xtime(v);
+      state[word_counter*4+3] ^= v^t;
+    }
+}
+void inverseMixColumns(iu8 *state)
+{
+  iu8 word_counter;
+  iu8 u;
+  iu8 v;
+  for(word_counter=0 ; word_counter<4 ; word_counter++)
+    {
+      u = xtime(xtime(state[word_counter*4]^state[word_counter*4+2]));
+      v = xtime(xtime(state[word_counter*4+1]^state[word_counter*4+3]));
+      state[word_counter*4] ^= u;
+      state[word_counter*4+1] ^= v;
+      state[word_counter*4+2] ^= u;
+      state[word_counter*4+3] ^= v;
+    }
+  mixColumns(state);
+}
+void keyExpansion(iu8 *round_key, iu8 *round_constant)
+{
+  iu8 temp[4] = {round_key[13], round_key[14], round_key[15], round_key[12]};
+  iu8 byte_counter = 0;
+  iu8 word_counter = 0;
+  for(byte_counter=0 ; byte_counter<4 ; byte_counter++)
+    round_key[byte_counter] ^= (substitution_table_[temp[byte_counter]])^
+                               (round_constant[byte_counter]);
+  for(word_counter=1 ; word_counter<4 ; word_counter++)
+    for(byte_counter=0 ; byte_counter<4 ; byte_counter++)
+      round_key[4*word_counter + byte_counter] ^=
+                                round_key[4*(word_counter-1) + byte_counter];
+  round_constant[0] = xtime(round_constant[0]);
+}
+void inverseKeyExpansion(iu8 *round_key, iu8 *round_constant)
+{
+  iu8 temp[4];
+  iu8 byte_counter = 0;
+  iu8 word_counter = 0;
+  if(((round_constant[0])^0x1b) == 0)
+    round_constant[0] = 0x80;
+  else
+    round_constant[0] = round_constant[0] >> 1;
+  for(word_counter=3 ; word_counter>0 ; word_counter--)
+    for(byte_counter=0 ; byte_counter<4 ; byte_counter++)
+       round_key[4*word_counter + byte_counter] ^=
+                            round_key[4*(word_counter-1) + byte_counter];
+  temp[0]  = round_key[13];
+  temp[1]  = round_key[14];
+  temp[2]  = round_key[15];
+  temp[3]  = round_key[12];
+  for(byte_counter=0 ; byte_counter<4 ; byte_counter++)
+    round_key[byte_counter] ^= (substitution_table_[temp[byte_counter]])^
+                                (round_constant[byte_counter]);
+}
+void calculateLastRoundKey(iu8 *round_key, iu8 *key, iu8 *round_constant)
+{
+  iu8 counter;
+  for(counter=0 ; counter<16 ; counter++)
+    round_key[counter]=key[counter];
+  for(counter=0 ; counter<10 ; counter++)
+    keyExpansion(round_key, round_constant);
+}
+void swap(iu8 *x,iu8 *y)
+{
+  *x=*x^*y;
+  *y=*x^*y;
+  *x=*x^*y;
+}
+iu8 xtime(iu8 value)
+{
+  return ((value & 0x80) ? (value<<1)^0x1b : value<<1) ;
+}
+
+#endif /* CONF_WITH_CRYPT_ALGO==0 */
+
diff --git a/src/aes.h b/src/aes.h
new file mode 100644 (file)
index 0000000..fbbd58c
--- /dev/null
+++ b/src/aes.h
@@ -0,0 +1,54 @@
+/*! @file
+       \brief AES declarations.
+
+       Documentation for AES is available at
+       XXX-fill in.
+
+       $Id: aes.h,v 1.5 2002/12/22 15:42:55 m Exp $
+*/
+
+#ifndef SOSSE_AES_H
+#define SOSSE_AES_H
+
+#include <types.h>
+
+//#define AES_KEY_LEN          16      //!< AES key size.
+//#define AES_BLOCK_LEN        16      //!< AES block length.
+
+//#define DELTA        0x9E3779B9      //!< Magic value. (Golden number * 2^31)
+//#define ROUNDS       32                      //!< Number of rounds.
+
+/*! \brief AES encryption function.
+
+       This function encrypts <EM>v</EM> with <EM>k</EM> and returns the
+       encrypted data in <EM>v</EM>.
+
+       \param v Array of two long values containing the data block.
+       \param k Array of four long values containing the key.
+*/
+void aes_enc( iu8 *v, iu8 *k, iu32 v_len );
+
+/*! \brief AES decryption function.
+
+       This function decrypts <EM>v</EM> with <EM>k</EM> and returns the
+       decrypted data in <EM>v</EM>.
+
+       \param v Array of two long values containing the data block.
+       \param k Array of four long values containing the key.
+*/
+void aes_dec( iu8 *v, iu8 *k, iu32 v_len );
+
+void addRoundKeyAndSubstituteBytes(iu8 *, iu8 *);
+void shiftRows(iu8 *);
+void mixColumns(iu8 *);
+void keyExpansion(iu8 *, iu8 *);
+void inverseSubstituteBytesAndAddRoundKey(iu8 *, iu8 *);
+void inverseShiftRows(iu8 *);
+void inverseMixColumns(iu8 *);
+void inverseKeyExpansion(iu8 *, iu8 *);
+void calculateLastRoundKey(iu8 *, iu8 *, iu8 *);
+void swap(iu8 *, iu8 *);
+iu8 xtime(iu8);
+
+#endif /* SOSSE_AES_H */
+
index 9b164dd..fd7230c 100644 (file)
 */
 #define CONF_WITH_KEYCMDS       0
 
-/*! \brief En-/disables support for the external I2C EEPROM.
+/*! \brief En-/disables support for the external (I2C) EEPROM.
+ *  Atmel chips have internal EEPROM integrated onto the card, usually
+ *  512 Bytes. This option enables use of the external EEPROM chip, the
+ *  one specified as 24C64 (8 KB), 24C128, 256, 512, 1024 (128 KB)...
 */
 #define CONF_WITH_I2CEEPROM     1
 
   - 1: Skipjack
   - 2: NEWDES-SK
 */
-#define CONF_WITH_CRYPT_ALGO    0 /* TEA */
+//#define CONF_WITH_CRYPT_ALGO    0 /* TEA */
 //#define CONF_WITH_CRYPT_ALGO    1 /* Skipjack */
 //#define CONF_WITH_CRYPT_ALGO    2 /* NEWDES-SK */
+#define CONF_WITH_CRYPT_ALGO    3 /* AES */
 
 
 /* Verify dependencies */
  *
  *  ENDIAN_LITTLE    If architecture is little endian
  *  INT_EEPROM_SIZE  Internal EEPROM size in bytes (0x200=512B, 0x80=128B...)
- *  RAM_SIZE         RAM size in bytes (0x200 = 512 B...)
+ *  RAM_SIZE         RAM size in bytes (0x200 = 512 B, 0x400 = 1 KB...)
  *  CHIP             Chip ID, voluntarily assigned by us and returned as
  *                     part of card's ATR signature. Scheme is as follows:
  *                       00: AT90S2323, AT90S2343 (2343 not supported)
  *                       01: AT90S8515, AT90S8535
  *                       02: ATmega161
- *                       03: ATmega163 (not supported)
+ *                       03: ATmega163
  *                       10: 16F84 (not supported)
  *                       11: 16F876 (not supported)
  *                       FF: unspec. (running on 386 emulator)
  *  EXT_EEPROM_SIZE  External EEPROM size in Kbytes. Unused, but returned as
- *                     part of card's ATR signature. Scheme is as follows:
+ *                     part of card's ATR signature. The defines here are 
+ *                     commented because this information is not part of
+ *                     the chip (can vary between smartcards even though
+ *                     the processor chip may be the same), so it is set as 
+ *                     its own option in the Makefile. Scheme is as follows:
  *                       00: none
  *                       01: 16 KB
  *                       02: 32 KB
 #define INT_EEPROM_SIZE    0x200
 #define RAM_SIZE           0x200
 #define CHIP               0x01
-#define EXT_EEPROM_SIZE    0x02
+//#define EXT_EEPROM_SIZE    0x02
 #define ARCH               avr2
 
 #elif defined(__AVR_AT90S8535__)
 #define INT_EEPROM_SIZE    0x200
 #define RAM_SIZE           0x200
 #define CHIP               0x01
-#define EXT_EEPROM_SIZE    0x03
+//#define EXT_EEPROM_SIZE    0x03
 #define ARCH               avr2
 
 #elif defined(__AVR_AT90S2323__)
 #define INT_EEPROM_SIZE    0x80
 #define RAM_SIZE           0x80
 #define CHIP               0x00
-#define EXT_EEPROM_SIZE    0x03
+//#define EXT_EEPROM_SIZE    0x03
 #define ARCH               avr2
 
 #elif defined(__AVR_ATmega161__)
 #define INT_EEPROM_SIZE    0x200
 #define RAM_SIZE           0x400
 #define CHIP               0x02
-#define EXT_EEPROM_SIZE    0x03
+//#define EXT_EEPROM_SIZE    0x03
+#define ARCH               avr5
+
+#elif defined(__AVR_ATmega163__)
+#define ENDIAN_LITTLE
+#define INT_EEPROM_SIZE    0x200
+#define RAM_SIZE           0x400
+#define CHIP               0x03
+//#define EXT_EEPROM_SIZE    0x03
 #define ARCH               avr5
 
 #elif defined(__i386__)
 #define INT_EEPROM_SIZE    0x200
 #define RAM_SIZE           0x200
 #define CHIP               0xFF
-#define EXT_EEPROM_SIZE    0xFF
+//#define EXT_EEPROM_SIZE    0xFF
 
 #else
 #error Unknown destination platform. Use proper ARCH type in Makefile.
index 22eaabc..700ca50 100644 (file)
@@ -35,6 +35,7 @@
 #define CRYPT_ALGO_TEA                 0       //!< Algorithm ID: TEA
 #define CRYPT_ALGO_SKIPJACK            1       //!< Algorithm ID: Skipjack
 #define CRYPT_ALGO_NEWDESSK            2       //!< Algorithm ID: NEWDES-SK
+#define CRYPT_ALGO_AES         3       //!< Algorithm ID: AES
 
 #if CONF_CRYPT_ALGO==0
 /* TEA */
 //! Single block decryption function.
 #define crypt_dec(v,k) newdessk_dec((iu8*)(v),(iu8*)(k))
 
+#elif CONF_CRYPT_ALGO==3
+/* NEWDES-SK */
+#include <aes.h>
+//! Length of key in octets.
+#define CRYPT_KEY_LEN  AES_KEY_LEN
+//! Length of cipher block in octets.
+#define CRYPT_BLOCK_LEN        AES_BLOCK_LEN
+//! Single block encryption function.
+#define crypt_enc(v,k) aes_enc((iu32*)(v),(iu16*)(k))
+//! Single block decryption function.
+#define crypt_dec(v,k) aes_dec((iu32*)(v),(iu16*)(k))
+
 #else
 #error No valid crypto algorithm selected.
 #endif