bg
/
avr-crypto-lib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

+RC6 +some forgotten files

This commit is contained in:
bg 2008-04-13 03:30:14 +00:00
parent 2aee09dcaf
commit 06da54b476
5 changed files with 159 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
main-noekeon-test.c
View File

@ -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"));
}
/*****************************************************************************

225
main-rc6-test.c
View File

@ -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);
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);
}
}
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);
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) */
}
}

14
rc5.mk Normal file
View File

@ -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

57
rc6.c
View File

@ -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];
}
}

42
rc6.h
View File

@ -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
*/
#include <stdint.h>
typedef struct rc6_ctx_st{
uint8_t rounds; /* specifys the number of rounds; default: 20 */
uint32_t* S; /* the round-keys */
} 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);
void rc6_enc(rc6_ctx_t *s, void* block);
void rc6_dec(rc6_ctx_t *s, void* block);
void rc6_free(rc6_ctx_t *s);
#ifndef RC6_H_
#define RC6_H_
#include <stdint.h>
typedef struct rc6_ctx_st{
uint8_t rounds; /* specifys the number of rounds; default: 20 */
uint32_t* S; /* the round-keys */
} rc6_ctx_t;
uint8_t rc6_init(void* key, uint16_t keylength_b, rc6_ctx_t *s);
uint8_t rc6_initl(void* key, uint16_t keylength_b, uint8_t rounds, rc6_ctx_t *s);
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);
#endif /* RC6_H_ */