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

adding rabbit

This commit is contained in:
bg 2011-07-19 22:09:37 +02:00
parent 498cf95d73
commit b11f6230a4
12 changed files with 2871 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mkfiles/001_cli_std.mk
View File

@ -1,2 +1,4 @@
CLI_STD = cli.o hexdigit_tab.o dbz_strings.o string-extras.o uart_i.o \
sysclock.o hw_gptm.o dump.o startup.o circularbytebuffer.o
sysclock.o hw_gptm.o dump.o startup.o circularbytebuffer.o \
main-test-common.o

13
mkfiles/rabbit_c.mk Normal file
View File

@ -0,0 +1,13 @@
# Makefile for Rabbit
ALGO_NAME := RABBIT_C
# comment out the following line for removement of Rabbit from the build process
STREAM_CIPHERS += $(ALGO_NAME)
$(ALGO_NAME)_DIR := rabbit/
$(ALGO_NAME)_OBJ := rabbit_c.o
$(ALGO_NAME)_INCDIR := memxor/ scal/
$(ALGO_NAME)_TEST_BIN := main-rabbit-test.o $(CLI_STD) $(SCAL_STD) scal_rabbit.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PERFORMANCE_TEST := "performance"
$(ALGO_NAME)_DEF := ESTREAM=0

14
mkfiles/rabbit_estream_c.mk Normal file
View File

@ -0,0 +1,14 @@
# Makefile for Rabbit
ALGO_NAME := RABBIT_ESTREAM_C
# comment out the following line for removement of Rabbit from the build process
STREAM_CIPHERS += $(ALGO_NAME)
$(ALGO_NAME)_DIR := rabbit/
$(ALGO_NAME)_OBJ := rabbit_c.o
$(ALGO_NAME)_INCDIR := memxor/ scal/
$(ALGO_NAME)_TEST_BIN := main-rabbit-test.o $(CLI_STD) $(SCAL_STD) scal_rabbit.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PERFORMANCE_TEST := "performance"
$(ALGO_NAME)_DEF := ESTREAM=1

41
rabbit/rabbit.h Normal file
View File

@ -0,0 +1,41 @@
/* rabbit.h */
/*
This file is part of the AVR-Crypto-Lib.
Copyright (C) 2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef RABBIT_H_
#define RABBIT_H_
#include <stdint.h>
typedef struct {
uint32_t x[8];
uint32_t c[8];
uint8_t buffer[16];
uint8_t carry;
uint8_t buffer_idx;
} rabbit_ctx_t;
void dump_ctx(rabbit_ctx_t* ctx);
uint8_t rabbit_gen(rabbit_ctx_t* ctx);
void rabbit_init(const void* key, uint16_t keysize_b,
const void* iv,
rabbit_ctx_t* ctx);
#endif /* RABBIT_H_ */

237
rabbit/rabbit_c.c Normal file
View File

@ -0,0 +1,237 @@
/* rabbit_c.c */
/*
This file is part of the ARM-Crypto-Lib.
Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string.h>
#include <stdint.h>
#include "rabbit.h"
#ifndef ESTREAM
#define ESTREAM 0
#endif
/*
void dump_ctx(rabbit_ctx_t* ctx){
uint8_t i=0;
cli_putstr_P(PSTR("\r\n --- ctx dump ---\r\n b = "));
cli_hexdump_byte(ctx->carry);
do{
if((i&3)==0){
cli_putstr_P(PSTR("\r\n"));
}
cli_putstr_P(PSTR(" X"));
cli_hexdump_byte(i);
cli_putstr_P(PSTR(" = 0x"));
cli_hexdump_rev(&(ctx->x[i]), 4);
}while(++i<8);
i=0;
do{
if((i&3)==0){
cli_putstr_P(PSTR("\r\n"));
}
cli_putstr_P(PSTR(" C"));
cli_hexdump_byte(i);
cli_putstr_P(PSTR(" = 0x"));
cli_hexdump_rev(&(ctx->c[i]), 4);
}while(++i<8);
}
*/
static
const uint32_t c_const[8] = {
0x4D34D34D, 0xD34D34D3,
0x34D34D34, 0x4D34D34D,
0xD34D34D3, 0x34D34D34,
0x4D34D34D, 0xD34D34D3
};
static
void gen_g(uint32_t* dest, rabbit_ctx_t* ctx){
uint8_t i=0;
uint64_t a;
uint32_t t, *x, *c;
x = ctx->x;
c = ctx->c;
do{
t = *x++ + *c++;
a = ((uint64_t)t)*((uint64_t)t);
dest[i] = (uint32_t)(a^(a>>32));
}while(++i<8);
}
static
void update_c(rabbit_ctx_t* ctx){
uint8_t i=0;
uint64_t a;
uint32_t *c;
const uint32_t *con;
c = ctx->c;
con = c_const;
a = ctx->carry;
do{
a += *c;
a += *con++;
*c++ = (uint32_t)a;
a >>= 32;
}while(++i<8);
ctx->carry = a?1:0;
}
#define ROT16(a) (((a)<<16) | ((a)>>16))
#define ROT8(a) (((a)<< 8) | ((a)>>24))
static
void step(rabbit_ctx_t* ctx){
uint32_t g[8];
uint8_t i=0;
update_c(ctx);
gen_g(g, ctx);
memcpy(ctx->x, g, 8*4);
do{
ctx->x[i] += ROT16(g[(i+8-1)%8]) + ROT16(g[(i+8-2)%8]);
++i;
ctx->x[i] += ROT8(g[(i+8-1)%8]) + g[(i+8-2)%8];
}while(++i<8);
}
static
void keysetup(rabbit_ctx_t* ctx, const void* key){
uint16_t *x, *c;
uint8_t i=0;
x = (uint16_t*)(ctx->x);
c = (uint16_t*)(ctx->c);
ctx->carry = 0;
do{
*x++ = ((uint16_t*)key)[i];
*x++ = ((uint16_t*)key)[(i+1)%8];
*c++ = ((uint16_t*)key)[(i+5)%8];
*c++ = ((uint16_t*)key)[(i+4)%8];
++i;
*x++ = ((uint16_t*)key)[(i+4)%8];
*x++ = ((uint16_t*)key)[(i+5)%8];
*c++ = ((uint16_t*)key)[(i+1)%8];
*c++ = ((uint16_t*)key)[i];
}while(++i<8);
i=0;
do{
step(ctx);
}while(++i<4);
i=0;
do{
ctx->c[i] ^= ctx->x[(i+4)%8];
}while(++i<8);
}
static
void ivsetup(rabbit_ctx_t* ctx, const void* iv){
uint8_t i;
uint32_t t;
uint8_t t_iv[8];
i=0;
#if ESTREAM
memcpy(t_iv, iv, 8);
#else
do{
t_iv[i] = ((uint8_t*)iv)[7-i];
t_iv[7-i] = ((uint8_t*)iv)[i];
}while(++i<4);
#endif
ctx->c[0] ^= *((uint32_t*)t_iv);
ctx->c[4] ^= *((uint32_t*)t_iv);
ctx->c[2] ^= ((uint32_t*)t_iv)[1];
ctx->c[6] ^= ((uint32_t*)t_iv)[1];
t = (( (uint32_t)((uint16_t*)t_iv)[3])<<16) | (((uint16_t*)t_iv)[1]);
ctx->c[1] ^= t;
ctx->c[5] ^= t;
t = (( (uint32_t)((uint16_t*)t_iv)[2])<<16) | (((uint16_t*)t_iv)[0]);
ctx->c[3] ^= t;
ctx->c[7] ^= t;
i=4;
do{
step(ctx);
}while(--i);
}
static
void extract(rabbit_ctx_t* ctx){
int8_t i=0;
uint8_t *t;
uint16_t v;
t = ctx->buffer;
i=6;
do{
v = ((uint16_t*)(ctx->x))[(2*(i+ 8)+1)%16]
^ ((uint16_t*)(ctx->x))[(2*(i+11)+0)%16];
*t++ = v>>8;
*t++ = (uint8_t)v;
v = ((uint16_t*)(ctx->x))[(2*(i+ 8)+0)%16]
^ ((uint16_t*)(ctx->x))[(2*(i+13)+1)%16];
*t++ = v>>8;
*t++ = (uint8_t)v;
i-=2;
}while(i>=0);
#if ESTREAM
uint8_t x;
i=0;
do{
x = ctx->buffer[i];
ctx->buffer[i] = ctx->buffer[15-i];
ctx->buffer[15-i] = x;
}while(++i<8);
#endif
}
static const uint8_t key80_pad[] = { 0xDE, 0x05, 0x6E, 0xAC, 0x8A, 0x11 };
void rabbit_init(const void* key, uint16_t keysize_b,
const void* iv,
rabbit_ctx_t* ctx){
uint8_t t_key[16];
if(keysize_b==80){
memcpy(t_key, key, 10);
memcpy(t_key+10, key80_pad, 6);
}else{
memcpy(t_key, key, 16);
}
#if !ESTREAM
uint8_t i=0, t;
do{
t = t_key[i];
t_key[i] = t_key[15-i];
t_key[15-i] = t;
}while(++i<8);
#endif
keysetup(ctx, t_key);
if(iv){
ivsetup(ctx, iv);
}
extract(ctx);
ctx->buffer_idx = 16;
}
uint8_t rabbit_gen(rabbit_ctx_t* ctx){
if(ctx->buffer_idx==16){
step(ctx);
extract(ctx);
ctx->buffer_idx = 0;
}
return ctx->buffer[ctx->buffer_idx++];
}

55
scal/scal_rabbit.c Normal file
View File

@ -0,0 +1,55 @@
/* scal_rabbit.c */
/*
This file is part of the AVR-Crypto-Lib.
Copyright (C) 2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <stdlib.h>
#include <stdint.h>
#include "streamcipher_descriptor.h"
#include "keysize_descriptor.h"
#include "rabbit.h"
const char rabbit_str[] = "Rabbit";
const uint8_t rabbit_keysize_desc[] = {
KS_TYPE_LIST, 2, KS_INT(128), KS_INT(80),
KS_TYPE_TERMINATOR };
const uint8_t rabbit_ivsize_desc[] = {
KS_TYPE_LIST, 1, KS_INT(64),
KS_TYPE_TERMINATOR };
const scdesc_t rabbit_desc = {
SCDESC_TYPE_STREAMCIPHER, /* abstraction layer type designator */
SC_INIT_TYPE_4|SC_GEN_TYPE_1, /* flags*/
rabbit_str, /* name string pointer */
sizeof(rabbit_ctx_t), /* size of context */
8, /* blocksize */
{(void_fpt)rabbit_init}, /* init function pointer */
{(void_fpt)rabbit_gen}, /* key stream generator function pointer */
{(void_fpt)NULL}, /* key stream generator for random access function pointer */
(sc_free_fpt)NULL, /* free function pointer */
rabbit_keysize_desc, /* key size descriptor pointer */
rabbit_ivsize_desc /* iv size descriptor pointer */
};

27
scal/scal_rabbit.h Normal file
View File

@ -0,0 +1,27 @@
/* scal_rabbit.h */
/*
This file is part of the AVR-Crypto-Lib.
Copyright (C) 2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef SCAL_RABBIT_H_
#define SCAL_RABBIT_H_
#include "streamcipher_descriptor.h"
extern const scdesc_t rabbit_desc;
#endif /* SCAL_RABBIT_H_ */

37
test_src/main-arcfour-test.c
View File

@ -20,16 +20,7 @@
* arcfour (RC4 compatible) test-suit
*
*/
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "cli.h"
#include "dump.h"
#include "uart_lowlevel.h"
#include "sysclock.h"
#include "hw_gptm.h"
#include "main-test-common.h"
#include "arcfour.h"
#include "scal_arcfour.h"
@ -38,19 +29,9 @@
#include "nessie_stream_test.h"
#include "performance_test.h"
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
const char* algo_name = "Arcfour";
void uart0_putc(char byte){
uart_putc(UART_0, byte);
}
char uart0_getc(void){
return uart_getc(UART_0);
}
/*****************************************************************************
* additional validation-functions *
@ -104,22 +85,10 @@ const cmdlist_entry_t cmdlist[] = {
};
int main (void){
sysclk_set_freq(SYS_FREQ);
sysclk_mosc_verify_enable();
uart_init(UART_0, 115200, 8, UART_PARATY_NONE, UART_STOPBITS_ONE);
gptm_set_timer_32periodic(TIMER0);
cli_rx = uart0_getc;
cli_tx = uart0_putc;
main_setup();
for(;;){
cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
cli_putstr(algo_name);
cli_putstr("; ");
cli_putstr(__DATE__);
cli_putc(' ');
cli_putstr(__TIME__);
cli_putstr(")\r\nloaded and running\r\n");
welcome_msg(algo_name);
cmd_interface(cmdlist);
}
}

222
test_src/main-rabbit-test.c Normal file
View File

@ -0,0 +1,222 @@
/* main-rabbit-test.c */
/*
This file is part of the ARM-Crypto-Lib.
Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "main-test-common.h"
#include "rabbit.h"
#include "performance_test.h"
#include "scal_rabbit.h"
#include "scal-basic.h"
#include "scal-nessie.h"
char* algo_name = "Rabbit";
/*****************************************************************************
* additional validation-functions *
*****************************************************************************/
void test_vector(void* key, void* iv, const void* ref){
rabbit_ctx_t ctx;
uint8_t fail=0;
cli_putstr("\r\n testing with\r\n key: ");
cli_hexdump(key, 16);
cli_putstr("\r\n iv: ");
if(iv){
cli_hexdump(iv, 8);
}else{
cli_putstr("[no iv]");
}
rabbit_init(key, 128, iv, &ctx);
rabbit_gen(&ctx);
if(!ref || (memcmp(ctx.buffer, ref, 16))!=0){
fail = 1;
cli_putstr("\r\n S[0]: ");
cli_hexdump(ctx.buffer, 16);
}
ctx.buffer_idx=16;
if(!ref || (memcmp(ctx.buffer, ref, 16))!=0){
fail = 1;
cli_putstr("\r\n S[0]: ");
cli_hexdump(ctx.buffer, 16);
}
ctx.buffer_idx=16;
if(!ref || (memcmp(ctx.buffer, ref, 16))!=0){
fail = 1;
cli_putstr("\r\n S[0]: ");
cli_hexdump(ctx.buffer, 16);
}
if(ref){
cli_putstr(fail?"\r\n [fail]":"\r\n [ok]");
}
cli_putstr("\r\n");
}
void nessie_first(void){
uint8_t key[16];
uint8_t iv[8];
memset(iv, 0, 8);
memset(key, 0, 16);
key[0] = 0x80;
test_vector(key, iv, NULL);
key[0] = 0x00;
key[15] = 0x80;
test_vector(key, iv, NULL);
}
const uint8_t spec_key1[] = {
0x91, 0x28, 0x13, 0x29, 0x2E, /* 0xED */ 0x3D, 0x36, 0xFE,
0x3B, 0xFC, 0x62, 0xF1, 0xDC, 0x51, 0xC3, 0xAC
};
const uint8_t spec_key2[] = {
0x83, 0x95, 0x74, 0x15, 0x87, 0xE0, 0xC7, 0x33,
0xE9, 0xE9, 0xAB, 0x01, 0xC0, 0x9B, 0x00, 0x43
};
const uint8_t spec_iv1[] = {
0xC3, 0x73, 0xF5, 0x75, 0xC1, 0x26, 0x7E, 0x59
};
const uint8_t spec_iv2[] = {
0xA6, 0xEB, 0x56, 0x1A, 0xD2, 0xF4, 0x17, 0x27
};
const uint8_t spec_ref[] = {
0xB1, 0x57, 0x54, 0xF0, 0x36, 0xA5, 0xD6, 0xEC, 0xF5, 0x6B, 0x45, 0x26, 0x1C, 0x4A, 0xF7, 0x02,
0x88, 0xE8, 0xD8, 0x15, 0xC5, 0x9C, 0x0C, 0x39, 0x7B, 0x69, 0x6C, 0x47, 0x89, 0xC6, 0x8A, 0xA7,
0xF4, 0x16, 0xA1, 0xC3, 0x70, 0x0C, 0xD4, 0x51, 0xDA, 0x68, 0xD1, 0x88, 0x16, 0x73, 0xD6, 0x96,
0x3D, 0x2D, 0xF3, 0xC8, 0x3E, 0xF6, 0x27, 0xA1, 0xE9, 0x7F, 0xC3, 0x84, 0x87, 0xE2, 0x51, 0x9C,
0xF5, 0x76, 0xCD, 0x61, 0xF4, 0x40, 0x5B, 0x88, 0x96, 0xBF, 0x53, 0xAA, 0x85, 0x54, 0xFC, 0x19,
0xE5, 0x54, 0x74, 0x73, 0xFB, 0xDB, 0x43, 0x50, 0x8A, 0xE5, 0x3B, 0x20, 0x20, 0x4D, 0x4C, 0x5E,
0x0C, 0xB1, 0x0D, 0xCD, 0xA0, 0x41, 0xCD, 0xAC, 0x32, 0xEB, 0x5C, 0xFD, 0x02, 0xD0, 0x60, 0x9B,
0x95, 0xFC, 0x9F, 0xCA, 0x0F, 0x17, 0x01, 0x5A, 0x7B, 0x70, 0x92, 0x11, 0x4C, 0xFF, 0x3E, 0xAD,
0x96, 0x49, 0xE5, 0xDE, 0x8B, 0xFC, 0x7F, 0x3F, 0x92, 0x41, 0x47, 0xAD, 0x3A, 0x94, 0x74, 0x28,
0xC6, 0xA7, 0x27, 0x5E, 0xF8, 0x54, 0x95, 0xD8, 0x7C, 0xCD, 0x5D, 0x37, 0x67, 0x05, 0xB7, 0xED,
0x5F, 0x29, 0xA6, 0xAC, 0x04, 0xF5, 0xEF, 0xD4, 0x7B, 0x8F, 0x29, 0x32, 0x70, 0xDC, 0x4A, 0x8D,
0x2A, 0xDE, 0x82, 0x2B, 0x29, 0xDE, 0x6C, 0x1E, 0xE5, 0x2B, 0xDB, 0x8A, 0x47, 0xBF, 0x8F, 0x66,
0x1F, 0xCD, 0x4E, 0xB9, 0x58, 0x00, 0x12, 0xE2, 0xE0, 0xDC, 0xCC, 0x92, 0x22, 0x01, 0x7D, 0x6D,
0xA7, 0x5F, 0x4E, 0x10, 0xD1, 0x21, 0x25, 0x01, 0x7B, 0x24, 0x99, 0xFF, 0xED, 0x93, 0x6F, 0x2E,
0xEB, 0xC1, 0x12, 0xC3, 0x93, 0xE7, 0x38, 0x39, 0x23, 0x56, 0xBD, 0xD0, 0x12, 0x02, 0x9B, 0xA7,
0x44, 0x5A, 0xD8, 0xC8, 0x05, 0x85, 0x8D, 0xBF, 0x70, 0xB6, 0xAF, 0x23, 0xA1, 0x51, 0x10, 0x4D,
0x96, 0xC8, 0xF2, 0x79, 0x47, 0xF4, 0x2C, 0x5B, 0xAE, 0xAE, 0x67, 0xC6, 0xAC, 0xC3, 0x5B, 0x03,
0x9F, 0xCB, 0xFC, 0x89, 0x5F, 0xA7, 0x1C, 0x17, 0x31, 0x3D, 0xF0, 0x34, 0xF0, 0x15, 0x51, 0xCB
};
void spec_test(void){
uint8_t key[16];
uint8_t iv[8];
const uint8_t *ref;
ref = spec_ref;
memset(key, 0, 16);
test_vector(key, NULL, ref);
memcpy(key, spec_key1, 16);
ref += 48;
test_vector(key, NULL, ref);
memcpy(key, spec_key2, 16);
ref += 48;
test_vector(key, NULL, ref);
memset(key, 0, 16);
memset(iv, 0, 8);
ref += 48;
test_vector(key, iv, ref);
memcpy(iv, spec_iv1, 8);
ref += 48;
test_vector(key, iv, ref);
memcpy(iv, spec_iv2, 8);
ref += 48;
test_vector(key, iv, ref);
}
void testrun_nessie_rabbit(void){
scal_nessie_set_estream(1);
scal_nessie_run(&rabbit_desc);
}
void testrun_performance_rabbit(void){
uint64_t t;
char str[16];
uint8_t key[16];
rabbit_ctx_t ctx;
calibrateTimer();
print_overhead();
memset(key, 0, 16);
startTimer(1);
rabbit_init(key, 128, NULL, &ctx);
t = stopTimer();
cli_putstr("\r\n\tctx-gen time: ");
ultoa((unsigned long)t, str, 10);
cli_putstr(str);
startTimer(1);
rabbit_gen(&ctx);
t = stopTimer();
cli_putstr("\r\n\tencrypt time: ");
ultoa((unsigned long)t, str, 10);
cli_putstr(str);
cli_putstr("\r\n");
}
/*****************************************************************************
* main *
*****************************************************************************/
const char nessie_str[] = "nessie";
const char first_str[] = "first";
const char test_str[] = "test";
const char performance_str[] = "performance";
const char echo_str[] = "echo";
cmdlist_entry_t cmdlist[] = {
{ nessie_str, NULL, testrun_nessie_rabbit},
{ performance_str, NULL, testrun_performance_rabbit},
{ first_str, NULL, nessie_first},
{ test_str, NULL, spec_test},
{ echo_str, (void*)1, (void_fpt)echo_ctrl},
{ NULL, NULL, NULL}
};
int main (void){
main_setup();
for(;;){
welcome_msg(algo_name);
cmd_interface(cmdlist);
}
}

50
test_src/main-test-common.c Normal file
View File

@ -0,0 +1,50 @@
/* main-test-common.c */
/*
This file is part of the ARM-Crypto-Lib.
Copyright (C) 2006-2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "main-test-common.h"
static
void uart0_putc(char byte){
uart_putc(UART_0, byte);
}
static
char uart0_getc(void){
return uart_getc(UART_0);
}
void main_setup(void){
sysclk_set_freq(SYS_FREQ);
sysclk_mosc_verify_enable();
uart_init(UART_0, 115200, 8, UART_PARATY_NONE, UART_STOPBITS_ONE);
gptm_set_timer_32periodic(TIMER0);
cli_rx = uart0_getc;
cli_tx = uart0_putc;
}
void welcome_msg(const char* algoname){
cli_putstr("\r\n\r\nARM-Crypto-Lib VS (");
cli_putstr(algoname);
cli_putstr("; ");
cli_putstr(__DATE__);
cli_putc(' ');
cli_putstr(__TIME__);
cli_putstr(")\r\nloaded and running\r\n");
}

37
test_src/main-test-common.h Normal file
View File

@ -0,0 +1,37 @@
/* main-test-common.h */
/*
This file is part of the AVR-Crypto-Lib.
Copyright (C) 2011 Daniel Otte (daniel.otte@rub.de)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef MAINTESTCOMMON_H_
#define MAINTESTCOMMON_H_
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include "config.h"
#include "cli.h"
#include "dump.h"
#include "uart_lowlevel.h"
#include "sysclock.h"
#include "hw_gptm.h"
void main_setup(void);
void welcome_msg(const char* algoname);
#endif /* MAINTESTCOMMON_H_ */

2169
testvectors/rabbit-verified.test-vectors Normal file
View File

File diff suppressed because it is too large Load Diff