+RC6 +some forgotten files

diff --git a/main-noekeon-test.c b/main-noekeon-test.c
index 2c19de49fb4b896bf378b4a8cc34330ccafaaa36..c7b21e722872b023048adcaf855ef67f060fb6aa 100644 (file)
--- a/main-noekeon-test.c
+++ b/main-noekeon-test.c
@@ -127,7 +127,6 @@ void testrun_stdtest_noekeon(void){
        noekeon_enc(data, &ctx);
        testrun_stdtest_runindirect(data, key3);
        
-       
        uart_putstr_P(PSTR("\r\nTest vectors for block cipher Noekeon in Direct-Key Mode:\r\n"));
        
        memset(key,  0, 16);
@@ -174,26 +173,21 @@ void testrun_performance_noekeon(void){
        t = stopTimer();
        uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
        ultoa((unsigned long)t, str, 10);
-       uart_putstr(str);
-//     uart_hexdump(&t, 8);
-       
+       uart_putstr(str);       
        
        startTimer(1);
-       noekeon_enc(data, ctx);
+       noekeon_enc(data, &ctx);
        t = stopTimer();
        uart_putstr_P(PSTR("\r\n\tencrypt time: "));
        ultoa((unsigned long)t, str, 10);
-       uart_putstr(str);
-//     uart_hexdump(&t, 8);
-       
+       uart_putstr(str);       
        
        startTimer(1);
-       noekeon_dec(data, ctx);
+       noekeon_dec(data, &ctx);
        t = stopTimer();
        uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
        ultoa((unsigned long)t, str, 10);
        uart_putstr(str);
-//     uart_hexdump(&t, 8);
        uart_putstr_P(PSTR("\r\n"));
 }
 /*****************************************************************************

diff --git a/main-rc6-test.c b/main-rc6-test.c
index 0c886d1646656a84d5649ff10c355a0fad2426c0..cf00207233e30774849236c9def227a2928bc401 100644 (file)
--- a/main-rc6-test.c
+++ b/main-rc6-test.c
@@ -1,5 +1,5 @@
 /*
- * rc6 test-suit
+ * rc5 test-suit
  * 
 */
 
@@ -9,169 +9,122 @@
 #include "debug.h"
 
 #include "rc6.h"
+#include "nessie_bc_test.h"
+#include "cli.h"
+#include "performance_test.h"
 
 #include <stdint.h>
 #include <string.h>
-#include <avr/pgmspace.h>
-
-
-#ifndef BOOL
-#define BOOL
- #ifndef __BOOL
- #define __BOOL
-  #ifndef __BOOL__
-  #define __BOOL__
-       typedef enum{false=0,true=1} bool;
-  #endif
- #endif
-#endif
-
+#include <stdlib.h>
 
+#define RC6_ROUNDS 20
+char* cipher_name = "RC6-32/20/16";
 
 /*****************************************************************************
  *  additional validation-functions                                                                                     *
  *****************************************************************************/
+void rc6_genctx_dummy(uint8_t* key, uint16_t keysize_b, void* ctx){
+       rc6_initl(key, keysize_b, RC6_ROUNDS, ctx);
+}
 
-/*****************************************************************************
- *  self tests                                                                                                                          *
- *****************************************************************************/
-
-void test_encrypt(uint8_t *block, uint8_t *key, uint16_t keylength, bool print){
-       rc6_ctx_t s;
-       if (print){
-               uart_putstr("\r\nRC6 (enc):\r\n key:\t");
-               uart_hexdump(key, keylength/8);
-               uart_putstr("\r\n plaintext:\t");
-               uart_hexdump(block, 16);
-       }
-       if (rc6_init(&s, key, keylength)){
-               uart_putstr("RC6 init failed!");
-               return;
-       }       
-       rc6_enc(&s, block);
-       if (print){
-               uart_putstr("\r\n ciphertext:\t");
-               uart_hexdump(block, 16);
-       }
-       rc6_free(&s);
-} 
-
-void test_decrypt(uint8_t *block, uint8_t *key, uint16_t keylength, bool print){
-       rc6_ctx_t s;
-       if (print){
-               uart_putstr("\r\nRC6 (dec):\r\n key:\t");
-               uart_hexdump(key, keylength/8);
-               uart_putstr("\r\n ciphertext:\t");
-               uart_hexdump(block, 16);
-       }
-       if (rc6_init(&s, key, keylength)){
-               uart_putstr("RC6 init failed!");
-               return;
-       }
-       rc6_dec(&s, block);
-       if (print){
-               uart_putstr("\r\n plaintext:\t");
-               uart_hexdump(block, 16);
-       }
-       rc6_free(&s);
-} 
-
-/*
- *               Test vectors for encryption with RC6
-       plaintext  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-       user key   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-       ciphertext 8f c3 a5 36 56 b1 f7 78 c1 29 df 4e 98 48 a4 1e
+void testrun_nessie_rc6(void){
+       nessie_bc_init();
+       nessie_bc_ctx.blocksize_B =  16;
+       nessie_bc_ctx.keysize_b   = 128;
+       nessie_bc_ctx.name        = cipher_name;
+       nessie_bc_ctx.ctx_size_B  = sizeof(rc6_ctx_t);
+       nessie_bc_ctx.cipher_enc  = (nessie_bc_enc_fpt)rc6_enc;
+       nessie_bc_ctx.cipher_dec  = (nessie_bc_dec_fpt)rc6_dec;
+       nessie_bc_ctx.cipher_free = (nessie_bc_free_fpt)rc6_free;
+       nessie_bc_ctx.cipher_genctx  = (nessie_bc_gen_fpt)rc6_init;
        
-       plaintext  02 13 24 35 46 57 68 79 8a 9b ac bd ce df e0 f1
-       user key   01 23 45 67 89 ab cd ef 01 12 23 34 45 56 67 78
-       ciphertext 52 4e 19 2f 47 15 c6 23 1f 51 f6 36 7e a4 3f 18
+       nessie_bc_run();
        
-       plaintext  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-       user key   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-                  00 00 00 00 00 00 00 00
-       ciphertext 6c d6 1b cb 19 0b 30 38 4e 8a 3f 16 86 90 ae 82
+       nessie_bc_ctx.keysize_b   = 192;
+       nessie_bc_run();
        
-       plaintext  02 13 24 35 46 57 68 79 8a 9b ac bd ce df e0 f1
-       user key   01 23 45 67 89 ab cd ef 01 12 23 34 45 56 67 78
-                  89 9a ab bc cd de ef f0
-       ciphertext 68 83 29 d0 19 e5 05 04 1e 52 e9 2a f9 52 91 d4
+       nessie_bc_ctx.keysize_b   = 256;
+       nessie_bc_run();
        
-       plaintext  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-       user key   00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-                  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
-       ciphertext 8f 5f bd 05 10 d1 5f a8 93 fa 3f da 6e 85 7e c2
-       
-       plaintext  02 13 24 35 46 57 68 79 8a 9b ac bd ce df e0 f1
-       user key   01 23 45 67 89 ab cd ef 01 12 23 34 45 56 67 78
-                  89 9a ab bc cd de ef f0 10 32 54 76 98 ba dc fe
-       ciphertext c8 24 18 16 f0 d7 e4 89 20 ad 16 a1 67 4e 5d 48
- * 
- */
-
-       uint8_t PROGMEM testkey[6][256/8]={
-               {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-               {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78},
-               {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-               {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
-                       0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0},
-               {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-               {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0x01, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x78,
-                       0x89, 0x9a, 0xab, 0xbc, 0xcd, 0xde, 0xef, 0xf0, 0x10, 0x32, 0x54, 0x76, 0x98, 0xba, 0xdc, 0xfe}};
-       uint8_t PROGMEM testplain[2][128/8]={
-               {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-               {0x02, 0x13, 0x24, 0x35, 0x46, 0x57, 0x68, 0x79, 0x8a, 0x9b, 0xac, 0xbd, 0xce, 0xdf, 0xe0, 0xf1}};
-       uint8_t PROGMEM testcipher[6][128/8]={
-               {0x8f, 0xc3, 0xa5, 0x36, 0x56, 0xb1, 0xf7, 0x78, 0xc1, 0x29, 0xdf, 0x4e, 0x98, 0x48, 0xa4, 0x1e},
-               {0x52, 0x4e, 0x19, 0x2f, 0x47, 0x15, 0xc6, 0x23, 0x1f, 0x51, 0xf6, 0x36, 0x7e, 0xa4, 0x3f, 0x18},
-               {0x6c, 0xd6, 0x1b, 0xcb, 0x19, 0x0b, 0x30, 0x38, 0x4e, 0x8a, 0x3f, 0x16, 0x86, 0x90, 0xae, 0x82},
-               {0x68, 0x83, 0x29, 0xd0, 0x19, 0xe5, 0x05, 0x04, 0x1e, 0x52, 0xe9, 0x2a, 0xf9, 0x52, 0x91, 0xd4},
-               {0x8f, 0x5f, 0xbd, 0x05, 0x10, 0xd1, 0x5f, 0xa8, 0x93, 0xfa, 0x3f, 0xda, 0x6e, 0x85, 0x7e, 0xc2},
-               {0xc8, 0x24, 0x18, 0x16, 0xf0, 0xd7, 0xe4, 0x89, 0x20, 0xad, 0x16, 0xa1, 0x67, 0x4e, 0x5d, 0x48}};
+}
 
 
-void testrun_rc6(void){
-       uint16_t keysize[]={128, 128, 192, 192, 256, 256};
-       uint8_t i;
-       uint8_t block[16];
-       uint8_t key[32];
-       memset(block, 0, 16);
-       memset(key, 0, 16);
+void testrun_performance_rc6(void){
+       uint16_t i,c;
+       uint64_t t;
+       char str[16];
+       uint8_t key[16], data[16];
+       rc6_ctx_t ctx;
        
-       test_encrypt(block, key, 128, true);
-       for(i=0; i<6; ++i){
-               memcpy_P(block, testplain[i&1], 128/8);
-               memcpy_P(key, testkey[i], keysize[i]/8);
-               test_encrypt(block, key, keysize[i], true);
-               memcpy_P(key, testkey[i], keysize[i]/8);
-               test_decrypt(block, key, keysize[i], true);
-       }
+       calibrateTimer();
+       getOverhead(&c, &i);
+       uart_putstr_P(PSTR("\r\n\r\n=== benchmark ==="));
+       utoa(c, str, 10);
+       uart_putstr_P(PSTR("\r\n\tconst overhead:     "));
+       uart_putstr(str);
+       utoa(i, str, 10);
+       uart_putstr_P(PSTR("\r\n\tinterrupt overhead: "));
+       uart_putstr(str);
+       
+       memset(key,  0, 16);
+       memset(data, 0, 16);
+       
+       startTimer(1);
+       rc6_init(key, 128, &ctx);
+       t = stopTimer();
+       uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
+       ultoa((unsigned long)t, str, 10);
+       uart_putstr(str);       
+       
+       startTimer(1);
+       rc6_enc(data, &ctx);
+       t = stopTimer();
+       uart_putstr_P(PSTR("\r\n\tencrypt time: "));
+       ultoa((unsigned long)t, str, 10);
+       uart_putstr(str);
+       
+       startTimer(1);
+       rc6_dec(data, &ctx);
+       t = stopTimer();
+       uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
+       ultoa((unsigned long)t, str, 10);
+       uart_putstr(str);
+
+       startTimer(1);
+       rc6_free(&ctx);
+       t = stopTimer();
+       uart_putstr_P(PSTR("\r\n\tfree time: "));
+       ultoa((unsigned long)t, str, 10);
+       uart_putstr(str);
+       uart_putstr_P(PSTR("\r\n"));
 }
-
-
-
 /*****************************************************************************
  *  main                                                                                                                                        *
  *****************************************************************************/
 
-int main (void){
-       char str[20];
+typedef void(*void_fpt)(void);
 
-       
+int main (void){
+       char  str[20];
        DEBUG_INIT();
        uart_putstr("\r\n");
 
-       uart_putstr("\r\n\r\nCrypto-VS (RC6)\r\nloaded and running\r\n");
-restart:
+       uart_putstr_P(PSTR("\r\n\r\nCrypto-VS ("));
+       uart_putstr(cipher_name);
+       uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
+
+       PGM_P    u   = PSTR("nessie\0test\0performance\0");
+       void_fpt v[] = {testrun_nessie_rc6, testrun_nessie_rc6, testrun_performance_rc6};
+
        while(1){ 
-               if (!getnextwordn(str,20))  {DEBUG_S("DBG: W1\r\n"); goto error;}
-               if (strcmp(str, "test")) {DEBUG_S("DBG: 1b\r\n"); goto error;}
-                       testrun_rc6();
-               goto restart;           
+               if (!getnextwordn(str,20)){DEBUG_S("DBG: W1\r\n"); goto error;}
+               if(execcommand_d0_P(str, u, v)<0){
+                       uart_putstr_P(PSTR("\r\nunknown command\r\n"));
+               }
                continue;
        error:
                uart_putstr("ERROR\r\n");
-       } /* while (1) */
+       }
+       
 }
 

diff --git a/rc5.mk b/rc5.mk
new file mode 100644 (file)
index 0000000..b45a610
--- /dev/null
+++ b/rc5.mk
@@ -0,0 +1,14 @@
+# Makefile for RC5
+ALGO_NAME := RC5
+
+# comment out the following line for removement of RC5 from the build process
+BLOCK_CIPHERS += $(ALGO_NAME)
+
+
+$(ALGO_NAME)_OBJ      := rc5.o
+$(ALGO_NAME)_TEST_BIN := main-rc5-test.o debug.o uart.o serial-tools.o \
+                         rc5.o nessie_bc_test.o \
+                         nessie_common.o cli.o performance_test.o
+$(ALGO_NAME)_NESSIE_TEST      := test nessie
+$(ALGO_NAME)_PEROFRMANCE_TEST := performance
+

diff --git a/rc6.c b/rc6.c
index 29889a20235573a20861cf100f2e177aa634638a..d35791b7b80a0be68feabae1eb088171da265ea1 100644 (file)
--- a/rc6.c
+++ b/rc6.c
@@ -10,30 +10,30 @@
  * THIS ONLY WORKS FOR LITTEL ENDIAN!!!
  */
  
- #include <stdint.h>
- #include <stdlib.h>
- #include "rc6.h"
- #include "config.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include "rc6.h"
+#include "config.h"
  
- #define P32 0xB7E15163                /* e -2 */
- #define Q32 0x9E3779B9                /* Golden Ratio -1 */
+#define P32 0xB7E15163         /* e -2 */
+#define Q32 0x9E3779B9         /* Golden Ratio -1 */
  
 uint32_t rotl32(uint32_t a, uint8_t n){
        n &= 0x1f; /* higher rotates would not bring anything */
        return ( (a<<n)| (a>>(32-n)) );
- }
+}
 
 uint32_t rotr32(uint32_t a, uint8_t n){
        n &= 0x1f; /* higher rotates would not bring anything */
        return ( (a>>n)| (a<<(32-n)) );
- }
+}
  
- uint8_t rc6_init(rc6_ctx_t *s,void* key, uint16_t keylength){
-       return rc6_initl(s, key, keylength, 20);
- }
+uint8_t rc6_init(void* key, uint16_t keylength_b, rc6_ctx_t *s){
+       return rc6_initl(key, keylength_b, 20, s);
+}
  
  
- uint8_t rc6_initl(rc6_ctx_t *s,void* key, uint16_t keylength, uint8_t rounds){
+uint8_t rc6_initl(void* key, uint16_t keylength_b, uint8_t rounds, rc6_ctx_t *s){
        uint8_t i,j;
        uint16_t v,p,c;
        uint32_t a,b, l=0;
@@ -44,11 +44,11 @@ uint32_t rotr32(uint32_t a, uint8_t n){
        
        s->rounds=rounds;
        
-       c = keylength/32;
-       if (keylength%32){ 
+       c = keylength_b/32;
+       if (keylength_b%32){ 
                ++c;
-               j=(keylength%32)/8;
-               if(keylength%8)
+               j=(keylength_b%32)/8;
+               if(keylength_b%8)
                        ++j;
                for (i=0; i<j; ++i) 
                        ((uint8_t*)&l)[i] = ((uint8_t*)key)[(c-1)*4 + i];
@@ -74,19 +74,19 @@ uint32_t rotr32(uint32_t a, uint8_t n){
                j = (j+1) % c;
        }
        return 0;
- }
+}
  
- void rc6_free(rc6_ctx_t *s){
+void rc6_free(rc6_ctx_t *s){
        free(s->S);
- } 
+} 
  
- #define LG_W 5
- #define A (((uint32_t*)block)[0])
- #define B (((uint32_t*)block)[1])
- #define C (((uint32_t*)block)[2])
- #define D (((uint32_t*)block)[3])
+#define LG_W 5
+#define A (((uint32_t*)block)[0])
+#define B (((uint32_t*)block)[1])
+#define C (((uint32_t*)block)[2])
+#define D (((uint32_t*)block)[3])
  
- void rc6_enc(rc6_ctx_t *s, void* block){
+void rc6_enc(void* block, rc6_ctx_t *s){
        uint8_t i;
        uint32_t t,u,x; /* greetings to Linux? */
        B += s->S[0];
@@ -104,10 +104,9 @@ uint32_t rotr32(uint32_t a, uint8_t n){
        }
        A += s->S[2*s->rounds+2];
        C += s->S[2*s->rounds+3];
- }
+}
  
- void rc6_dec(rc6_ctx_t *s, void* block)
- {
+void rc6_dec(void* block, rc6_ctx_t *s){
        uint8_t i;
        uint32_t t,u,x; /* greetings to Linux? */
  
@@ -127,5 +126,5 @@ uint32_t rotr32(uint32_t a, uint8_t n){
        }
        D -= s->S[1];
        B -= s->S[0];
- }
+}
  

diff --git a/rc6.h b/rc6.h
index 35887bc44be8ae900fbc5ed07e2c653274b82a18..f1f78e953c37f19bbc9c25836c606232ece39c07 100644 (file)
--- a/rc6.h
+++ b/rc6.h
@@ -7,22 +7,28 @@
  *     This implementation is restricted to 32-bit words, but free in the choice of number of rounds (0 to 255).
  *     so it is RC6-32/r/b
  */
+
+#ifndef RC6_H_
+#define RC6_H_
+
  
- #include <stdint.h>
+#include <stdint.h>
  
- typedef struct rc6_ctx_st{
-       uint8_t         rounds;         /* specifys the number of rounds; default: 20 */
+typedef struct rc6_ctx_st{
+       uint8_t         rounds;         /* specifys the number of rounds; default: 20 */
        uint32_t*       S;                      /* the round-keys */
- } rc6_ctx_t;
- 
+} rc6_ctx_t;
  
- uint8_t rc6_init(rc6_ctx_t *s,void* key, uint16_t keylength);
  
- uint8_t rc6_initl(rc6_ctx_t *s,void* key, uint16_t keylength, uint8_t rounds);
+uint8_t rc6_init(void* key, uint16_t keylength_b, rc6_ctx_t *s);
  
- void rc6_enc(rc6_ctx_t *s, void* block);
+uint8_t rc6_initl(void* key, uint16_t keylength_b, uint8_t rounds, rc6_ctx_t *s);
  
- void rc6_dec(rc6_ctx_t *s, void* block);
+void rc6_enc(void* block, rc6_ctx_t *s);
+
+void rc6_dec(void* block, rc6_ctx_t *s);
  
- void rc6_free(rc6_ctx_t *s); 
+void rc6_free(rc6_ctx_t *s); 
+
+#endif /* RC6_H_ */