/*****************************************************************************/
/* extern prog_uint64_t camellia_sigma[6]; */
-void camellia128_init(camellia128_ctx_t* s, uint8_t* key){
+void camellia128_init(uint8_t* key, camellia128_ctx_t* s){
uint8_t i;
s->kll = 0; /* ((uint64_t*)key)[0]; */
/*****************************************************************************/
-void camellia128_enc(camellia128_ctx_t* s, void* block){
+void camellia128_enc(void* block, camellia128_ctx_t* s){
#define BL (((uint64_t*)block)[0])
#define BR (((uint64_t*)block)[1])
/*****************************************************************************/
-void camellia128_dec(camellia128_ctx_t* s, void* block){
+void camellia128_dec(void* block, camellia128_ctx_t* s){
#define BL (((uint64_t*)block)[1])
#define BR (((uint64_t*)block)[0])
}camellia128_ctx_t;
-void camellia128_init(camellia128_ctx_t* s, uint8_t* key);
-void camellia128_enc(camellia128_ctx_t* s, void* block);
-void camellia128_dec(camellia128_ctx_t* s, void* block);
+void camellia128_init(uint8_t* key, camellia128_ctx_t* s);
+void camellia128_enc(void* block, camellia128_ctx_t* s);
+void camellia128_dec(void* block, camellia128_ctx_t* s);
#endif /*CAMELLIA_H_*/
* @param key Pointer to binary key.
* @param keylength length of keydata in bits.
*/
-void cast5_init(cast5_ctx_t* s, uint8_t* key, uint8_t keylength){
+void cast5_init(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* s){
/* we migth return if the key is valid and if setup was sucessfull */
uint32_t x[4], z[4];
#define BPX ((uint8_t*)&(x[0]))
#define BPZ ((uint8_t*)&(z[0]))
- s->shortkey = (keylength<=80);
+ s->shortkey = (keylength_b<=80);
/* littel endian only! */
memset(&(x[0]), 0 ,16); /* set x to zero */
- if(keylength > 128)
- keylength=128;
- memcpy(&(x[0]), key, (keylength+7)/8);
+ if(keylength_b > 128)
+ keylength_b=128;
+ memcpy(&(x[0]), key, (keylength_b+7)/8);
/* todo: merge a and b and compress the whole stuff */
* @param s Pointer to cast5 roundkeys (context)
* @param block Pointer to datablock
*/
-void cast5_enc(cast5_ctx_t *s, void* block){
+void cast5_enc(void* block, cast5_ctx_t *s){
uint32_t l,r, x, y;
uint8_t i;
cast5_f_t* f[]={cast5_f1,cast5_f2,cast5_f3};
* @param s Pointer to cast5 roundkeys (context)
* @param block Pointer to datablock
*/
-void cast5_dec(cast5_ctx_t *s, void* block){
+void cast5_dec(void* block, cast5_ctx_t *s){
uint32_t l,r, x, y;
int8_t i, rounds;
cast5_f_t* f[]={cast5_f1,cast5_f2,cast5_f3};
/*
* File: cast5.h
* Author: Daniel Otte
- * Date: 26.07.2006
+ * Date: 2006-07-26
* License: GPL
* Description: Implementation of the CAST5 (aka CAST-128) cipher algorithm as described in RFC 2144
*
bool shortkey;
} cast5_ctx_t;
-void cast5_init(cast5_ctx_t* s, uint8_t* key, uint8_t keylength);
-void cast5_enc(cast5_ctx_t *s, void* block);
-void cast5_dec(cast5_ctx_t *s, void* block);
+void cast5_init(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* s);
+void cast5_enc(void* block, cast5_ctx_t *s);
+void cast5_dec(void* block, cast5_ctx_t *s);
#include "debug.h"
#include "camellia.h"
+#include "nessie_bc_test.h"
+#include "performance_test.h"
+#include "cli.h"
+
+char* cipher_name = "Camellia";
+
#include <stdint.h>
#include <string.h>
+#include <stdlib.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
-
-
-
/*****************************************************************************
* additional validation-functions *
*****************************************************************************/
+void camellia128_init_dummy(void* key, uint16_t keysize_b, void* ctx){
+ camellia128_init(key, ctx);
+}
-/*****************************************************************************
- * self tests *
- *****************************************************************************/
-void camellia128_ctx_dump(camellia128_ctx_t *s);
-
-void test_encrypt(uint8_t *block, uint8_t *key, uint16_t keylength, bool print){
- camellia128_ctx_t s;
- if (print){
- uart_putstr("\r\nCamellia (enc):\r\n key:\t\t");
- uart_hexdump(key, keylength/8);
- uart_putstr("\r\n plaintext:\t");
- uart_hexdump(block, 16);
- }
+void testrun_nessie_camellia(void){
+ 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(camellia128_ctx_t);
+ nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)camellia128_enc;
+ nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)camellia128_dec;
+ nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)camellia128_init_dummy;
- camellia128_init(&s, key);;
- camellia128_enc(&s, block);
- if (print){
- uart_putstr("\r\n ciphertext:\t");
- uart_hexdump(block, 16);
- }
-}
-
-void test_decrypt(uint8_t *block, uint8_t *key, uint16_t keylength, bool print){
- camellia128_ctx_t s;
- if (print){
- uart_putstr("\r\nCamellia (dec):\r\n key:\t\t");
- uart_hexdump(key, keylength/8);
- uart_putstr("\r\n ciphertext:\t");
- uart_hexdump(block, 16);
- }
- camellia128_init(&s, key);
- camellia128_dec(&s, block);
- if (print){
- uart_putstr("\r\n plaintext:\t");
- uart_hexdump(block, 16);
- }
-}
-
-void nessie_test_iterate(uint8_t *block, uint8_t *key){
- uint16_t i;
- test_encrypt(block, key, 128, true);
- test_decrypt(block, key, 128, true);
- uart_putstr("\r\n100 times:");
- for(i=0; i<99; ++i){
- test_encrypt(block, key, 128, false);
- }
- test_encrypt(block, key, 128, true);
- uart_putstr("\r\n1000 times:");
- for(i=0; i<(999-100); ++i){
- test_encrypt(block, key, 128, false);
- }
- test_encrypt(block, key, 128, true);
+ nessie_bc_run();
}
-void nessie_test_iterate_inv(uint8_t *block, uint8_t *key){
- uint16_t i;
- test_decrypt(block, key, 128, true);
- test_encrypt(block, key, 128, true);
- uart_putstr("\r\n100 times:");
- for(i=0; i<99; ++i){
- test_decrypt(block, key, 128, false);
- }
- test_encrypt(block, key, 128, true);
- uart_putstr("\r\n1000 times:");
- for(i=0; i<(999-100); ++i){
- test_decrypt(block, key, 128, false);
- }
- test_decrypt(block, key, 128, true);
-}
-prog_uint8_t ntt_test_values_in[16] = {
- 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
- 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
-};
-
-prog_uint8_t ntt_test_values_out[16] = {
- 0x67, 0x67, 0x31, 0x38, 0x54, 0x96, 0x69, 0x73,
- 0x08, 0x57, 0x06, 0x56, 0x48, 0xea, 0xbe, 0x43
-};
-/* memcmp_P() is now implemented in avr-libc
-int memcmp_P(const void *s1, PGM_P s2, size_t n){
- uint8_t b;
- while(n--){
- b = pgm_read_byte_near(s2);
- if( *((uint8_t*)s1) != b)
- return(*((uint8_t*)s1)-b);
- ++s1; ++s2;
- }
- return 0;
-}
-*/
-void testrun_camellia(void){
- /* we run the NESSIE test for Camellia here see
- * https://www.cosic.esat.kuleuven.be/nessie/testvectors/bc/camellia/Camellia-128-128.verified.test-vectors
- * for the vectors
- */
- unsigned j, setn;
- uint8_t block[16];
- uint8_t key[16];
- memcpy_P(block, ntt_test_values_in, 16);
- memcpy_P(key, ntt_test_values_in, 16);
- test_encrypt(block, key, 128, true);
- if(memcmp_P(block, ntt_test_values_out, 16)){
- uart_putstr("\t[FAILED]\r\n");
- return;
- }
- uart_putstr("\t[OK]");
- test_decrypt(block, key, 128, true);
- if(memcmp_P(block, ntt_test_values_in, 16)){
- uart_putstr("\t[FAILED]\r\n");
- return;
- }
- uart_putstr("\t[OK]");
+void test_performance_cast5(void){
+ uint64_t t;
+ char str[6];
+ uint8_t key[16], data[16];
+ camellia128_ctx_t ctx;
-/* test set #1 & #2 */
- setn=1;
- for(setn=1; setn<=2; ++setn){
- for(j=0; j<128; ++j){
- uart_putstr("\r\n\r\n### SET: ");
- uart_hexdump(&setn,1);
- uart_putstr(" Vector: ");
- uart_hexdump(&j,1);
-
- memset(block, 0, 16);
- memset(key, 0, 16);
- ((setn&0x1)?key:block)[j>>3] = 1<<(((~j)&0x7));
- nessie_test_iterate(block, key);
- }
- }
-/* test set #3 */
- for(j=0; j<256; ++j){
- uart_putstr("\r\n### SET: ");
- uart_hexdump(&setn,1);
- uart_putstr(" Vector: ");
- uart_hexdump(&j,1);
-
- memset(block, j, 16);
- memset(key, 0, 16);
- nessie_test_iterate(block, key);
- }
- setn++;
-/* test set #4 (some strange values*/
- setn++;
-/* test ser #5 & #6 (same as 1&2 but enc and dec exchanged)*/
- for(setn=5; setn<=6; ++setn){
- for(j=0; j<128; ++j){
- uart_putstr("\r\n\r\n### SET: ");
- uart_hexdump(&setn,1);
- uart_putstr(" Vector: ");
- uart_hexdump(&j,1);
-
- memset(block, 0, 16);
- memset(key, 0, 16);
- ((setn&0x1)?key:block)[j>>3] = 1<<(((~j)&0x7));
- nessie_test_iterate_inv(block, key);
- }
- }
-/* test set #7 */
- for(j=0; j<256; ++j){
- uart_putstr("\r\n### SET: ");
- uart_hexdump(&setn,1);
- uart_putstr(" Vector: ");
- uart_hexdump(&j,1);
-
- memset(block, j, 16);
- memset(key, 0, 16);
- nessie_test_iterate_inv(block, key);
- }
- setn++;
-/* test set #4 (some strange values*/
- setn++;
+ calibrateTimer();
+ print_overhead();
+
+ memset(key, 0, 16);
+ memset(data, 0, 16);
+
+ startTimer(1);
+ camellia128_init(key, &ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ camellia128_enc(data, &ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tencrypt time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ camellia128_dec(data, &ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+ uart_putstr_P(PSTR("\r\n"));
}
+/*****************************************************************************
+ * self tests *
+ *****************************************************************************/
+
/*****************************************************************************
* main *
*****************************************************************************/
DEBUG_INIT();
uart_putstr("\r\n");
- uart_putstr("\r\n\r\nCrypto-VS (Camellia)\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_camellia, testrun_nessie_camellia, test_performance_cast5};
+
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_camellia();
- 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) */
+ }
}
/*****************************************************************************
* additional validation-functions *
*****************************************************************************/
-/*
- void cast5_init(cast5_ctx_t* s, uint8_t* key, uint8_t keylength);
- void cast5_enc(cast5_ctx_t *s, void* block);
- void cast5_dec(cast5_ctx_t *s, void* block);
-*/
-
-void cast5_init_dummy(uint8_t* key, uint8_t keylength_b, cast5_ctx_t* ctx){
- cast5_init(ctx, key, keylength_b);
-}
-
-void cast5_enc_dummy(void* buffer, cast5_ctx_t* ctx){
- cast5_enc(ctx, buffer);
-}
-void cast5_dec_dummy(void* buffer, cast5_ctx_t* ctx){
- cast5_dec(ctx, buffer);
-}
-
-void test_nessie_cast5(void){
+void testrun_nessie_cast5(void){
nessie_bc_ctx.blocksize_B = 8;
nessie_bc_ctx.keysize_b = 128;
nessie_bc_ctx.name = cipher_name;
nessie_bc_ctx.ctx_size_B = sizeof(cast5_ctx_t);
- nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)cast5_enc_dummy;
- nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)cast5_dec_dummy;
- nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)cast5_init_dummy;
+ nessie_bc_ctx.cipher_enc = (nessie_bc_enc_fpt)cast5_enc;
+ nessie_bc_ctx.cipher_dec = (nessie_bc_dec_fpt)cast5_dec;
+ nessie_bc_ctx.cipher_genctx = (nessie_bc_gen_fpt)cast5_init;
nessie_bc_run();
}
uart_putstr("\r\n plaintext:\t");
uart_hexdump(block, 8);
}
- cast5_init(&s, key, keylength);
-// cast5_ctx_dump(&s);
- cast5_enc(&s, block);
+ cast5_init(key, keylength, &s);
+ cast5_enc(block, &s);
if (print){
uart_putstr("\r\n ciphertext:\t");
uart_hexdump(block, 8);
uart_putstr("\r\n ciphertext:\t");
uart_hexdump(block, 8);
}
- cast5_init(&s, key, keylength);
-// cast5_ctx_dump(&s);
- cast5_dec(&s, block);
+ cast5_init(key, keylength, &s);
+ cast5_dec(block, &s);
if (print){
uart_putstr("\r\n plaintext:\t");
uart_hexdump(block, 8);
}
-void test_performance_cast5(void){
- uint16_t i,c;
+void testrun_performance_cast5(void){
uint64_t t;
char str[6];
uint8_t key[16], data[16];
cast5_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 16);
memset(data, 0, 16);
startTimer(1);
- cast5_init(&ctx, key, 128);
+ cast5_init(key, 128, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
ultoa((unsigned long)t, str, 10);
startTimer(1);
- cast5_enc(&ctx, data);
+ cast5_enc(data, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tencrypt time: "));
ultoa((unsigned long)t, str, 10);
startTimer(1);
- cast5_dec(&ctx, data);
+ cast5_dec(data, &ctx);
t = stopTimer();
uart_putstr_P(PSTR("\r\n\tdecrypt time: "));
ultoa((unsigned long)t, str, 10);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
PGM_P u = PSTR("nessie\0test\0performance\0");
- void_fpt v[] = {test_nessie_cast5, test_nessie_cast5, test_performance_cast5};
+ void_fpt v[] = {testrun_nessie_cast5, testrun_cast5, testrun_performance_cast5};
while(1){
if (!getnextwordn(str,20)){DEBUG_S("DBG: W1\r\n"); goto error;}
void testrun_performance_des(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[8], data[8];
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);
+ print_overhead();
memset(key, 0, 8);
memset(data, 0, 8);
void testrun_performance_entropium(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t data[32];
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);
+ print_overhead();
startTimer(1);
entropium_addEntropy(128, data);
}
void testrun_performance_grain(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[10], iv[8];
grain_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 10);
memset(iv, 0, 8);
#include "md5.h"
#include "nessie_hash_test.h"
+#include "performance_test.h"
#include <stdint.h>
#include <string.h>
+#include <stdlib.h>
#include "cli.h"
char* algo_name = "MD5";
}
+void testrun_performance_md5(void){
+ uint64_t t;
+ char str[16];
+ uint8_t data[32];
+ md5_ctx_t ctx;
+
+ calibrateTimer();
+ print_overhead();
+
+ memset(data, 0, 32);
+
+ startTimer(1);
+ md5_init(&ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ md5_nextBlock(&ctx, data);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tone-block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ md5_lastBlock(&ctx, data, 0);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tlast block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+ uart_putstr_P(PSTR("\r\n"));
+}
+
/*****************************************************************************
* main *
uart_putstr("\r\n");
uart_putstr("\r\n\r\nCrypto-VS (MD5)\r\nloaded and running\r\n");
- PGM_P u = PSTR("nessie\0test\0");
- void_fpt v[] = {testrun_nessie_md5, testrun_md5};
+ PGM_P u = PSTR("nessie\0test\0performance\0");
+ void_fpt v[] = {testrun_nessie_md5, testrun_md5, testrun_performance_md5};
while(1){
if (!getnextwordn(str,20)){DEBUG_S("DBG: W1\r\n"); goto error;}
}
void testrun_performance_noekeon(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[16], data[16];
noekeon_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 16);
memset(data, 0, 16);
void testrun_performance_rc5(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[16], data[16];
rc5_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 16);
memset(data, 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;
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);
+ print_overhead();
memset(key, 0, 16);
memset(data, 0, 16);
void testrun_performance_seed(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[16], data[16];
seed_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 16);
memset(data, 0, 16);
void testrun_performance_serpent(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[32], data[16];
serpent_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 32);
memset(data, 0, 16);
#include "sha1.h"
#include "nessie_hash_test.h"
+#include "performance_test.h"
#include <stdint.h>
#include <string.h>
+#include <stdlib.h>
#include "cli.h"
char* algo_name = "SHA-1";
uart_putstr("\r\nx");
}
+void testrun_performance_sha1(void){
+ uint64_t t;
+ char str[16];
+ uint8_t data[32];
+ sha1_ctx_t ctx;
+
+ calibrateTimer();
+ print_overhead();
+
+ memset(data, 0, 32);
+
+ startTimer(1);
+ sha1_init(&ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ sha1_nextBlock(&ctx, data);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tone-block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ sha1_lastBlock(&ctx, data, 0);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tlast block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+ uart_putstr_P(PSTR("\r\n"));
+}
/*****************************************************************************
uart_putstr("\r\n\r\nCrypto-VS (SHA-1)\r\nloaded and running\r\n");
- PGM_P u = PSTR("nessie\0test\0");
- void_fpt v[] = {testrun_nessie_sha1, testrun_sha1};
+ PGM_P u = PSTR("nessie\0test\0performance\0");
+ void_fpt v[] = {testrun_nessie_sha1, testrun_sha1, testrun_performance_sha1};
while(1){
if (!getnextwordn(str,20)){DEBUG_S("DBG: W1\r\n"); goto error;}
#include "sha256.h"
#include "nessie_hash_test.h"
+#include "performance_test.h"
#include <stdint.h>
#include <string.h>
+#include <stdlib.h>
#include "cli.h"
char* algo_name = "SHA-256";
nessie_hash_run();
}
-
+void testrun_performance_sha256(void){
+ uint64_t t;
+ char str[16];
+ uint8_t data[32];
+ sha256_ctx_t ctx;
+
+ calibrateTimer();
+ print_overhead();
+
+ memset(data, 0, 32);
+
+ startTimer(1);
+ sha256_init(&ctx);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tctx-gen time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ sha256_nextBlock(&ctx, data);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tone-block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+
+ startTimer(1);
+ sha256_lastBlock(&ctx, data, 0);
+ t = stopTimer();
+ uart_putstr_P(PSTR("\r\n\tlast block time: "));
+ ultoa((unsigned long)t, str, 10);
+ uart_putstr(str);
+
+ uart_putstr_P(PSTR("\r\n"));
+}
/*****************************************************************************
* main *
uart_putstr(algo_name);
uart_putstr_P(PSTR(")\r\nloaded and running\r\n"));
- PGM_P u = PSTR("nessie\0test\0");
- void_fpt v[] = {testrun_nessie_sha256, testrun_nessie_sha256};
+ PGM_P u = PSTR("nessie\0test\0performance\0");
+ void_fpt v[] = {testrun_nessie_sha256, testrun_nessie_sha256, testrun_performance_sha256};
while(1){
if (!getnextwordn(str,20)){DEBUG_S("DBG: W1\r\n"); goto error;}
void testrun_performance_shabea(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[32], data[32];
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);
+ print_overhead();
memset(key, 0, 32);
memset(data, 0, 32);
void testrun_performance_skipjack(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[10], data[8];
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);
+ print_overhead();
memset(key, 0, 10);
memset(data, 0, 8);
void testrun_performance_tdes(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[8*3], data[8];
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);
+ print_overhead();
memset(key, 0, 8*3);
memset(data, 0, 8);
}
void testrun_performance_trivium(void){
- uint16_t i,c;
uint64_t t;
char str[16];
uint8_t key[10], iv[10];
trivium_ctx_t ctx;
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);
+ print_overhead();
memset(key, 0, 10);
memset(iv, 0, 10);
# main-camellia-test.o debug.o uart.o serial-tools.o camellia.o camellia-asm.o
$(ALGO_NAME)_OBJ := camellia.o camellia-asm.o
$(ALGO_NAME)_TEST_BIN := main-camellia-test.o debug.o uart.o serial-tools.o \
- camellia.o camellia-asm.o
+ camellia.o camellia-asm.o nessie_bc_test.o \
+ nessie_common.o cli.o performance_test.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PEROFRMANCE_TEST := "performance"
$(ALGO_NAME)_OBJ := md5.o
$(ALGO_NAME)_TEST_BIN := main-md5-test.o debug.o uart.o serial-tools.o md5.o \
- nessie_hash_test.o nessie_common.o cli.o
+ nessie_hash_test.o nessie_common.o cli.o performance_test.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PEROFRMANCE_TEST := "performance"
$(ALGO_NAME)_OBJ := sha1-asm.o
$(ALGO_NAME)_TEST_BIN := main-sha1-test.o debug.o uart.o serial-tools.o \
- sha1-asm.o nessie_hash_test.o nessie_common.o cli.o
+ sha1-asm.o nessie_hash_test.o nessie_common.o cli.o \
+ performance_test.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PEROFRMANCE_TEST := "performance"
$(ALGO_NAME)_OBJ := sha256-asm.o
$(ALGO_NAME)_TEST_BIN := main-sha256-test.o debug.o uart.o serial-tools.o \
- sha256-asm.o nessie_hash_test.o nessie_common.o cli.o
+ sha256-asm.o nessie_hash_test.o nessie_common.o cli.o \
+ performance_test.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PEROFRMANCE_TEST := "performance"
projects / avr-crypto-lib.git / commitdiff