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

migration to SCAL initiated

This commit is contained in:
bg 2011-01-21 23:29:18 +00:00
parent 3f759a542c
commit 66c915087d
16 changed files with 685 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
arcfour/arcfour-asm.S
View File

@ -40,8 +40,8 @@
* this function initialises the context
* param1: 16-bit pointer to the key
* given in r24:r25
* param2: 8-bit integer indicating keylength in byte
* given in r22
* param2: 8-bit integer indicating keylength in bits
* given in r22:r23
* param3: 16-bit pointer to a ctx struct
* given in r20:r21
*/
@ -52,7 +52,12 @@ arcfour_init:
st X+, r1
st X+, r1 /* X points to S */
movw r20, r26 /* store pointer to S in r21:r20 */
lsr r23
ror r22
lsr r23
ror r22
lsr r23
ror r22
1:
st X+, r1
inc r1

3
arcfour/arcfour.c
View File

@ -33,8 +33,9 @@
* length is length of key in bytes!
*/
void arcfour_init(const void *key, uint8_t length_B, arcfour_ctx_t *ctx){
void arcfour_init(const void *key, uint16_t length_b, arcfour_ctx_t *ctx){
uint8_t t;
uint8_t length_B = length_b/8;
uint16_t x,y=0;
for(x=0; x<= 255; ++x)
ctx->s[x]=x;

4
arcfour/arcfour.h
View File

@ -71,10 +71,10 @@ typedef struct arcfour_ctx_st {
* the supplied key of the given length.
* \param ctx pointer to the context
* \param key pointer to the key
* \param length_B length of the key in bytes (between 1 and 255)
* \param length_b length of the key in bits (between 8 and 2048)
*/
void arcfour_init(const void *key, uint8_t length_B, arcfour_ctx_t *ctx);
void arcfour_init(const void *key, uint16_t length_b, arcfour_ctx_t *ctx);
/** \fn uint8_t arcfour_gen(arcfour_ctx_t *ctx)
* \brief generates a byte of keystream

79
keysize_descriptor.c
View File

@ -25,6 +25,7 @@
*/
#include <stdint.h>
#include <stdlib.h>
#include <avr/pgmspace.h>
#include "keysize_descriptor.h"
@ -76,11 +77,85 @@ uint16_t get_keysize(PGM_VOID_P ks_desc){
uint8_t type;
uint16_t keysize;
type = pgm_read_byte(ks_desc);
if(type==KS_TYPE_LIST)
if(type==KS_TYPE_LIST){
ks_desc = (uint8_t*)ks_desc + 1;
}
ks_desc = (uint8_t*)ks_desc + 1;
keysize = pgm_read_word(ks_desc);
return keysize;
}
uint16_t get_keysizes(PGM_VOID_P ks_desc, uint16_t** list){
uint8_t type;
uint16_t items;
uint8_t i;
type = pgm_read_byte(ks_desc);
ks_desc = (uint8_t*)ks_desc + 1;
if(type==KS_TYPE_LIST){
items = pgm_read_byte(ks_desc);
ks_desc = (uint8_t*)ks_desc + 1;
if(!*list){
*list = malloc(items*2);
if(!*list){
return 0;
}
}
for(i=0; i<items; ++i){
((uint16_t*)(*list))[i] = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
}
return items;
}
if(type==KS_TYPE_ARG_RANGE){
uint16_t min, max, distance, offset;
min = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
max = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
distance = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
offset = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
items = (max-min)/distance+1;
if(min%distance!=offset){
--items;
min += (distance-(min%distance-offset))%distance;
}
if(!*list){
*list = malloc(items*2);
if(!*list){
return 0;
}
}
i=0;
while(min<max){
((uint16_t*)*list)[i++] = min;
min += distance;
}
return i;
}
if(type==KS_TYPE_RANGE){
uint16_t min, max, distance=8, offset=0;
min = pgm_read_word(ks_desc);
ks_desc = (uint8_t*)ks_desc + 2;
max = pgm_read_word(ks_desc);
items = (max-min)/distance+1;
if(min%distance!=offset){
--items;
min += (distance-(min%distance-offset))%distance;
}
if(!*list){
*list = malloc(items*2);
if(!*list){
return 0;
}
}
i=0;
while(min<max){
((uint16_t*)*list)[i++] = min;
min += distance;
}
return i;
}
return 0;
}

3
keysize_descriptor.h
View File

@ -56,4 +56,7 @@ typedef struct{ /* keysize is valid if min<=keysize<=max and if keysize mod dist
uint8_t is_valid_keysize_P(PGM_VOID_P ks_desc, uint16_t keysize);
uint16_t get_keysize(PGM_VOID_P ks_desc);
uint16_t get_keysizes(PGM_VOID_P ks_desc, uint16_t** list);
#endif /* KEYSIZE_DESCRIPTOR_H_ */

4
mkfiles/arcfour.mk
View File

@ -6,8 +6,8 @@ STREAM_CIPHERS += $(ALGO_NAME)
$(ALGO_NAME)_DIR := arcfour/
$(ALGO_NAME)_OBJ := arcfour-asm.o
$(ALGO_NAME)_TEST_BIN := main-arcfour-test.o $(CLI_STD) \
nessie_stream_test.o nessie_common.o performance_test.o
$(ALGO_NAME)_INCDIR := memxor/ scal/
$(ALGO_NAME)_TEST_BIN := main-arcfour-test.o $(CLI_STD) $(SCAL_STD) scal_arcfour.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PERFORMANCE_TEST := "performance"

3
mkfiles/arcfour_c.mk
View File

@ -5,8 +5,9 @@ ALGO_NAME := ARCFOUR_C
STREAM_CIPHERS += $(ALGO_NAME)
$(ALGO_NAME)_DIR := arcfour/
$(ALGO_NAME)_INCDIR := memxor/ scal/
$(ALGO_NAME)_OBJ := arcfour.o
$(ALGO_NAME)_TEST_BIN := main-arcfour-test.o $(CLI_STD) nessie_stream_test.o nessie_common.o performance_test.o
$(ALGO_NAME)_TEST_BIN := main-arcfour-test.o $(CLI_STD) $(SCAL_STD) scal_arcfour.o
$(ALGO_NAME)_NESSIE_TEST := "nessie"
$(ALGO_NAME)_PERFORMANCE_TEST := "performance"

164
scal/scal-basic.c Normal file
View File

@ -0,0 +1,164 @@
/* scal-basic.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 <string.h>
#include <avr/pgmspace.h>
#include "streamcipher_descriptor.h"
#include "keysize_descriptor.h"
uint8_t scal_cipher_init(const scdesc_t* cipher_descriptor,
const void* key, uint16_t keysize_b,
const void* iv, uint16_t ivsize_b, scgen_ctx_t* ctx){
ctx->buffer = NULL;
ctx->ctx = NULL;
if(!is_valid_keysize_P((PGM_VOID_P)pgm_read_word(&(cipher_descriptor->valid_keysize_desc)), keysize_b)){
return 1;
}
if(!is_valid_keysize_P((PGM_VOID_P)pgm_read_word(&(cipher_descriptor->valid_ivsize_desc)), ivsize_b)){
return 2;
}
uint8_t flags;
void_fpt init_fpt;
flags = pgm_read_byte(&(cipher_descriptor->flags));
ctx->desc_ptr = cipher_descriptor;
ctx->keysize = keysize_b;
ctx->ivsize = ivsize_b;
ctx->ctx = malloc(pgm_read_word(&(cipher_descriptor->ctxsize_B)));
if(ctx->ctx==NULL){
return 3;
}
init_fpt = (void_fpt)pgm_read_word(&(cipher_descriptor->init));
switch(flags&SC_INIT_TYPE){
case SC_INIT_TYPE_1:
((sc_init1_fpt)init_fpt)(key, ctx->ctx);
break;
case SC_INIT_TYPE_2:
((sc_init2_fpt)init_fpt)(key, iv, ctx->ctx);
break;
case SC_INIT_TYPE_3:
((sc_init3_fpt)init_fpt)(key, keysize_b, ctx->ctx);
break;
case SC_INIT_TYPE_4:
((sc_init4_fpt)init_fpt)(key, keysize_b, iv, ctx->ctx);
break;
case SC_INIT_TYPE_5:
((sc_init5_fpt)init_fpt)(key, keysize_b, iv, ivsize_b, ctx->ctx);
break;
default:
return 4;
}
uint16_t blocksize_b;
blocksize_b = pgm_read_word(&(cipher_descriptor->gensize_b));
if(blocksize_b>8){
ctx->buffer=malloc((blocksize_b+7)/8);
if(ctx->buffer==NULL){
return 5;
}
ctx->index=0;
}
return 0;
}
void scal_cipher_free(scgen_ctx_t* ctx){
if(ctx->buffer){
free(ctx->buffer);
}
if(ctx->ctx){
free(ctx->ctx);
}
}
uint8_t scal_cipher_gen_byte(scgen_ctx_t* ctx){
uint8_t flags;
uint16_t blocksize_b;
void_fpt gen_fpt;
flags = pgm_read_byte(&(ctx->desc_ptr->flags));
blocksize_b = pgm_read_word(&(ctx->desc_ptr->gensize_b));
gen_fpt = (void_fpt)(pgm_read_word(&(ctx->desc_ptr->gen.genvoid)));
if(blocksize_b==8){
if((flags&SC_GEN_TYPE)==SC_GEN_TYPE_1){
return ((sc_gen1_fpt)gen_fpt)(ctx->ctx);
}else{
uint8_t r;
((sc_gen2_fpt)gen_fpt)(&r, ctx->ctx);
return r;
}
}
if(blocksize_b<8){
uint8_t r=0;
uint8_t fill=0;
do{
r |= ((((sc_gen1_fpt)gen_fpt)(ctx->ctx))&(0xff<<(8-blocksize_b)))>>fill;
fill += blocksize_b;
}while(fill<8);
return r;
}else{
uint8_t r;
if(ctx->index==0){
((sc_gen2_fpt)gen_fpt)(ctx->buffer, ctx->ctx);
ctx->index = blocksize_b;
}
r=ctx->buffer[(blocksize_b-ctx->index)/8];
ctx->index -= 8;
return r;
}
}
void scal_cipher_gen_block(void* block, scgen_ctx_t* ctx){
uint8_t flags;
uint16_t blocksize_b;
void_fpt gen_fpt;
flags = pgm_read_byte(&(ctx->desc_ptr->flags));
blocksize_b = pgm_read_word(&(ctx->desc_ptr->gensize_b));
gen_fpt = (void_fpt)pgm_read_word(&(ctx->desc_ptr->gen));
if((flags&SC_GEN_TYPE)==SC_GEN_TYPE_1){
*((uint8_t*)block) = ((sc_gen1_fpt)gen_fpt)(ctx->ctx);
}else{
((sc_gen2_fpt)gen_fpt)(block, ctx->ctx);
}
}
void scal_cipher_gen_fillblock(void* block, uint16_t blocksize_B, scgen_ctx_t* ctx){
while(blocksize_B){
*((uint8_t*)block) = scal_cipher_gen_byte(ctx);
block = (uint8_t*)block + 1;
blocksize_B -= 1;
}
}
uint16_t scal_cipher_getBlocksize_b(const scdesc_t* desc){
uint16_t blocksize_b;
blocksize_b = pgm_read_word(&(desc->gensize_b));
return blocksize_b;
}
PGM_VOID_P scal_cipher_getKeysizeDesc(const scdesc_t* desc){
return (PGM_VOID_P)pgm_read_word(&(desc->valid_keysize_desc));
}
PGM_VOID_P scal_cipher_getIVsizeDesc(const scdesc_t* desc){
return (PGM_VOID_P)pgm_read_word(&(desc->valid_ivsize_desc));
}

41
scal/scal-basic.h Normal file
View File

@ -0,0 +1,41 @@
/* scal-basic.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_BASIC_H_
#define SCAL_BASIC_H_
#include <stdlib.h>
#include <stdint.h>
#include "streamcipher_descriptor.h"
#include "keysize_descriptor.h"
#include <avr/pgmspace.h>
uint8_t scal_cipher_init(const scdesc_t* cipher_descriptor,
const void* key, uint16_t keysize_b,
const void* iv, uint16_t ivsize_b, scgen_ctx_t* ctx);
void scal_cipher_free(scgen_ctx_t* ctx);
uint8_t scal_cipher_gen_byte(scgen_ctx_t* ctx);
void scal_cipher_gen_block(void* block, scgen_ctx_t* ctx);
void scal_cipher_gen_fillblock(void* block, uint16_t blocksize_B, scgen_ctx_t* ctx);
uint16_t scal_cipher_getBlocksize_b(const scdesc_t* desc);
PGM_VOID_P scal_cipher_getKeysizeDesc(const scdesc_t* desc);
PGM_VOID_P scal_cipher_getIVsizeDesc(const scdesc_t* desc);
#endif /* SCAL_BASIC_H_ */

265
scal/scal-nessie.c Normal file
View File

@ -0,0 +1,265 @@
/* scal-nessie.c */
/*
This file is part of the AVR-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 <stdint.h>
#include <string.h>
#include "streamcipher_descriptor.h"
#include "scal-basic.h"
#include "nessie_common.h"
#include "memxor.h"
#include <avr/pgmspace.h>
static const uint8_t normal_hooks[] PROGMEM = {
0, 192/64, 256/64, 448/64
};
static const uint16_t long_hooks[] PROGMEM = {
0, 65472/64, 65536/64, 131008/64
};
static const char stream0_n[] PROGMEM = "stream[0..63]";
static const char stream1_n[] PROGMEM = "stream[192..255]";
static const char stream2_n[] PROGMEM = "stream[256..319]";
static const char stream3_n[] PROGMEM = "stream[448..511]";
static const char streamX_n[] PROGMEM = "stream[0..511]xored";
static const char* stream_n_str[] PROGMEM = {
stream0_n,
stream1_n,
stream2_n,
stream3_n,
streamX_n
};
static const char stream1_l[] PROGMEM = "stream[65472..65535]";
static const char stream2_l[] PROGMEM = "stream[65536..65599]";
static const char stream3_l[] PROGMEM = "stream[131008..131071]";
static const char streamX_l[] PROGMEM = "stream[0..131071]xored";
static const char* stream_l_str[] PROGMEM = {
stream0_n,
stream1_l,
stream2_l,
stream3_l,
streamX_l
};
static const uint8_t list_of_keys[][20] PROGMEM = {
{ 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, 0xfe, 0xdc,
0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 0x00, 0x00, 0x00, 0x00 },
{ 0x67, 0x45, 0x23, 0x01, 0xef, 0xcd, 0xab, 0x89, 0x98, 0xba,
0xdc, 0xfe, 0x10, 0x32, 0x54, 0x76, 0xc3, 0xd2, 0xe1, 0xf0 }
};
static const uint8_t list_of_ivs[][4] PROGMEM = {
{ 0x00, 0x00, 0x00, 0x00 },
{ 0x01, 0x01, 0x01, 0x01 },
{ 0x01, 0x35, 0x77, 0xaf }
};
static
void normal_block(scgen_ctx_t *ctx){
uint8_t xor_block[64];
uint8_t block[64];
PGM_VOID_P hook_ptr = normal_hooks;
PGM_VOID_P hook_str_ptr = stream_n_str;
char str[21];
uint8_t i;
memset(xor_block, 0, 64);
for(i=0; i<=448/64; ++i){
scal_cipher_gen_fillblock(block, 64, ctx);
memxor(xor_block, block, 64);
if(i==pgm_read_byte(hook_ptr)){
hook_ptr = (uint8_t*)hook_ptr + 1;
strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
hook_str_ptr = (uint8_t*)hook_str_ptr + 2;
nessie_print_item(str, block, 64);
}
}
strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
nessie_print_item(str, xor_block, 64);
}
static
void long_block(scgen_ctx_t *ctx){
uint8_t xor_block[64];
uint8_t block[64];
PGM_VOID_P hook_ptr = long_hooks;
PGM_VOID_P hook_str_ptr = stream_l_str;
char str[24];
uint16_t i;
memset(xor_block, 0, 64);
for(i=0; i<=131008/64; ++i){
scal_cipher_gen_fillblock(block, 64, ctx);
memxor(xor_block, block, 64);
if(i==pgm_read_word(hook_ptr)){
hook_ptr = (uint8_t*)hook_ptr + 2;
strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
hook_str_ptr = (uint8_t*)hook_str_ptr + 2;
nessie_print_item(str, block, 64);
}
}
strcpy_P(str, (PGM_VOID_P)pgm_read_word(hook_str_ptr));
nessie_print_item(str, xor_block, 64);
}
void scal_nessie_stream_run(const scdesc_t *desc, uint16_t keysize_b, uint16_t ivsize_b){
uint8_t name_length = strlen_P((PGM_VOID_P)pgm_read_word(&(desc->name)));
char name[name_length+1];
memcpy_P(name, (PGM_VOID_P)pgm_read_word(&(desc->name)), name_length+1);
uint8_t key[(keysize_b+7)/8];
uint8_t iv[(ivsize_b+7)/8];
uint16_t v;
scgen_ctx_t ctx;
nessie_print_header(name, keysize_b, 0, 0, 0, ivsize_b?ivsize_b:((uint16_t)-1));
memset(iv, 0, (ivsize_b+7)/8);
memset(key, 0, (keysize_b+7)/8);
/*** Test SET 1 ***/
nessie_print_setheader(1);
for(v=0;v<keysize_b; ++v){
nessie_print_set_vector(1,v);
key[v/8] |= 0x80>>(v&7);
nessie_print_item("key", key, (keysize_b+7)/8);
if(ivsize_b){
nessie_print_item("IV", iv, (ivsize_b+7)/8);
}
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
normal_block(&ctx);
key[v/8] = 0;
scal_cipher_free(&ctx);
}
/*** Test SET 2 ***/
nessie_print_setheader(2);
for(v=0;v<256; ++v){
nessie_print_set_vector(2,v);
memset(key, v&0xff, (keysize_b+7)/8);
nessie_print_item("key", key, (keysize_b+7)/8);
if(ivsize_b){
nessie_print_item("IV", iv, (ivsize_b+7)/8);
}
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
normal_block(&ctx);
scal_cipher_free(&ctx);
}
/*** Test SET 3 ***/
nessie_print_setheader(3);
for(v=0;v<256; ++v){
uint8_t i;
nessie_print_set_vector(3,v);
for(i=0; i<((keysize_b+7)/8); ++i){
key[i]=(i+v)&0xff;
}
nessie_print_item("key", key, (keysize_b+7)/8);
if(ivsize_b){
nessie_print_item("IV", iv, (ivsize_b+7)/8);
}
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
normal_block(&ctx);
scal_cipher_free(&ctx);
}
/*** Test SET 4 ***/
nessie_print_setheader(4);
for(v=0;v<4; ++v){
uint8_t i;
nessie_print_set_vector(4,v);
for(i=0; i<((keysize_b+7)/8); ++i){
key[i]=(i*0x53+v*5)&0xff;
}
nessie_print_item("key", key, (keysize_b+7)/8);
if(ivsize_b){
nessie_print_item("IV", iv, (ivsize_b+7)/8);
}
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
long_block(&ctx);
scal_cipher_free(&ctx);
}
if(ivsize_b==0){ /* exit if there is no IV */
nessie_print_footer();
return;
}
/*** Test SET 5 ***/
nessie_print_setheader(5);
memset(key, 0, (keysize_b+7)/8);
for(v=0;v<ivsize_b; ++v){
nessie_print_set_vector(5,v);
iv[v/8] |= 0x80>>(v&7);
nessie_print_item("key", key, (keysize_b+7)/8);
nessie_print_item("IV", iv, (ivsize_b+7)/8);
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
normal_block(&ctx);
scal_cipher_free(&ctx);
iv[v/8] = 0;
}
/*** Test SET 6 ***/
nessie_print_setheader(6);
for(v=0;v<4; ++v){
uint8_t i;
nessie_print_set_vector(6,v);
for(i=0; i<((keysize_b+7)/8); ++i){
key[i]=(i*0x53+v*5)&0xff;
}
for(i=0; i<((ivsize_b+7)/8); ++i){
iv[i]=(i*0x67+v*9+13)&0xff;
}
nessie_print_item("key", key, (keysize_b+7)/8);
nessie_print_item("IV", iv, (ivsize_b+7)/8);
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
long_block(&ctx);
scal_cipher_free(&ctx);
}
/*** Test SET 7 ***/
nessie_print_setheader(7);
uint8_t u;
for(v=0;v<3; ++v){
for(u=0; u<3; ++u){
uint8_t i;
nessie_print_set_vector(7,v*3+u);
for(i=0; i<((keysize_b+7)/8); ++i){
key[i]=pgm_read_byte(list_of_keys+20*v+(i%20));
}
for(i=0; i<((ivsize_b+7)/8); ++i){
key[i]=pgm_read_byte(list_of_keys+4*u+(i%4));
}
}
nessie_print_item("key", key, (keysize_b+7)/8);
nessie_print_item("IV", iv, (ivsize_b+7)/8);
scal_cipher_init(desc, key, keysize_b, iv, ivsize_b, &ctx);
long_block(&ctx);
scal_cipher_free(&ctx);
}
nessie_print_footer();
}
void scal_nessie_run(const scdesc_t* desc){
uint16_t keysizes_count, ivsizes_count,i,j;
uint16_t *keysizes=NULL, *ivsizes=NULL;
keysizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_keysize_desc)), &keysizes);
ivsizes_count = get_keysizes((PGM_VOID_P)pgm_read_word(&(desc->valid_ivsize_desc)), &ivsizes);
for(i=0; i<keysizes_count; ++i){
for(j=0; j<ivsizes_count; ++j){
scal_nessie_stream_run(desc, keysizes[i], ivsizes[j]);
}
}
}

29
scal/scal-nessie.h Normal file
View File

@ -0,0 +1,29 @@
/* scal-nessie.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 SCALNESSIE_H_
#define SCALNESSIE_H_
#include <stdint.h>
#include <streamcipher_descriptor.h>
void scal_nessie_stream_run(const scdesc_t *desc, uint16_t keysize_b, uint16_t ivsize_b);
void scal_nessie_run(const scdesc_t* desc);
#endif /* SCALNESSIE_H_ */

56
scal/scal_arcfour.c Normal file
View File

@ -0,0 +1,56 @@
/* scal_arcfour.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 <avr/pgmspace.h>
#include <stdint.h>
#include "streamcipher_descriptor.h"
#include "keysize_descriptor.h"
#include "arcfour.h"
const char arcfour_str[] PROGMEM = "ARCFOUR";
const uint8_t arcfour_keysize_desc[] PROGMEM = {
KS_TYPE_ARG_RANGE, KS_INT(8), KS_INT(2040), KS_INT(8), KS_INT(0),
KS_TYPE_TERMINATOR };
const uint8_t arcfour_ivsize_desc[] PROGMEM = {
KS_TYPE_LIST, 1, KS_INT(0),
KS_TYPE_TERMINATOR };
const scdesc_t arcfour_desc PROGMEM = {
SCDESC_TYPE_BLOCKCIPHER, /* abstraction layer type designator */
SC_INIT_TYPE_3|SC_GEN_TYPE_1, /* flags*/
arcfour_str, /* name string pointer */
sizeof(arcfour_ctx_t), /* size of context */
8, /* blocksize */
{(void_fpt)arcfour_init}, /* init function pointer */
{(void_fpt)arcfour_gen}, /* key stream generator function pointer */
{(void_fpt)NULL}, /* key stream generator for random access function pointer */
(sc_free_fpt)NULL, /* free function pointer */
arcfour_keysize_desc, /* key size descriptor pointer */
arcfour_ivsize_desc /* iv size descriptor pointer */
};

27
scal/scal_arcfour.h Normal file
View File

@ -0,0 +1,27 @@
/* scal_arcfour.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_ARCFOUR_H_
#define SCAL_ARCFOUR_H_
#include "streamcipher_descriptor.h"
extern const scdesc_t arcfour_desc;
#endif /* SCAL_ARCFOUR_H_ */

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

@ -27,10 +27,13 @@
#include "debug.h"
#include <arcfour.h>
#include "nessie_stream_test.h"
#include "cli.h"
#include "performance_test.h"
#include "scal_arcfour.h"
#include "scal-basic.h"
#include "scal-nessie.h"
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
@ -44,18 +47,8 @@ void arcfour_genctx_dummy(uint8_t* key, uint16_t keysize, void* ctx){
arcfour_init(key, (uint8_t)((keysize+7)/8), ctx);
}
void testrun_nessie_arcfour(void){
nessie_stream_ctx.outsize_b = 8; /* actually unused */
nessie_stream_ctx.keysize_b = 128; /* this is theone we have refrence vectors for */
nessie_stream_ctx.ivsize_b = (uint16_t)-1;
nessie_stream_ctx.name = algo_name;
nessie_stream_ctx.ctx_size_B = sizeof(arcfour_ctx_t);
nessie_stream_ctx.cipher_genctx = (nessie_stream_genctx_fpt)arcfour_genctx_dummy;
nessie_stream_ctx.cipher_enc = (nessie_stream_genenc_fpt)arcfour_gen;
nessie_stream_run();
scal_nessie_run(&arcfour_desc);
}
void testrun_performance_arcfour(void){

3
test_src/nessie_common.c
View File

@ -170,8 +170,7 @@ void nessie_print_header(char* name,
if(ivsize_b){
if(ivsize_b==(uint16_t)-1){
NESSIE_PUTSTR_P(PSTR("\r\nNo initial value (IV) mode"));
}
{
}else{
NESSIE_PUTSTR_P(PSTR("\r\nIV size: "));
utoa(ivsize_b, str, 10);
NESSIE_PUTSTR(str);

10
test_src/nessie_stream_test.c
View File

@ -29,21 +29,13 @@
#include <string.h>
#include "nessie_stream_test.h"
#include "nessie_common.h"
#include "memxor.h"
nessie_stream_ctx_t nessie_stream_ctx;
#define BLOCKSIZE_B 64
static
void memxor(void* dest, void* src, uint8_t length){
while(length--){
*((uint8_t*)dest) ^= *((uint8_t*)src);
dest = (uint8_t*)dest +1;
src = (uint8_t*)src +1;
}
}
static
void nessie_gen_block(void* ctx, uint8_t* block){