From: bg Date: Sat, 25 Sep 2010 12:11:44 +0000 (+0000) Subject: forgotten directories X-Git-Url: https://git.cryptolib.org/?a=commitdiff_plain;h=924aa320bef6f192feecdb67d209c790bd49ea49;p=avr-crypto-lib.git forgotten directories --- diff --git a/bcal/bcal-basic.c b/bcal/bcal-basic.c new file mode 100644 index 0000000..3d7a65c --- /dev/null +++ b/bcal/bcal-basic.c @@ -0,0 +1,94 @@ +/* bcal-basic.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#include +#include +#include +#include +#include "blockcipher_descriptor.h" +#include "keysize_descriptor.h" + +uint8_t bcal_cipher_init(const bcdesc_t* cipher_descriptor, + const void* key, uint16_t keysize_b, bcgen_ctx_t* ctx){ + if(!is_valid_keysize_P((PGM_VOID_P)pgm_read_word(&(cipher_descriptor->valid_keysize_desc)), + keysize_b)){ + return 1; + } + uint8_t flags; + bc_init_fpt init_fpt; + ctx->desc_ptr = (bcdesc_t*)cipher_descriptor; + ctx->keysize = keysize_b; + flags = pgm_read_byte(cipher_descriptor->flags); + init_fpt.initvoid = (void_fpt)(pgm_read_word(&(cipher_descriptor->init.initvoid))); + if(init_fpt.initvoid == NULL){ + if(!(ctx->ctx = malloc((keysize_b+7)/8))) + return 2; + memcpy(ctx->ctx, key, (keysize_b+7)/8); + return 0; + } + if(!(ctx->ctx = malloc(pgm_read_word(&(cipher_descriptor->ctxsize_B))))) + return 3; + if((flags&BC_INIT_TYPE)==BC_INIT_TYPE_1){ + init_fpt.init1((void*)key, (ctx->ctx)); + }else{ + init_fpt.init2((void*)key, keysize_b, (ctx->ctx)); + } + return 0; +} + +void bcal_cipher_free(bcgen_ctx_t* ctx){ + if(!ctx) + return; + bc_free_fpt free_fpt; + free_fpt = (bc_free_fpt)(pgm_read_word(&(ctx->desc_ptr->free))); + if(free_fpt) + free_fpt((ctx->ctx)); + free(ctx->ctx); +} + +void bcal_cipher_enc(void* block, const bcgen_ctx_t* ctx){ + bc_enc_fpt enc_fpt; + enc_fpt.encvoid = (void_fpt)pgm_read_word(&(ctx->desc_ptr->enc.encvoid)); + if(!enc_fpt.encvoid){ + /* very bad error, no enciphering function specified */ + return; + } + enc_fpt.enc1(block, (ctx->ctx)); + +} + +void bcal_cipher_dec(void* block, const bcgen_ctx_t* ctx){ + bc_dec_fpt dec_fpt; + dec_fpt.decvoid = (void_fpt)pgm_read_word(&(ctx->desc_ptr->dec.decvoid)); + if(!dec_fpt.decvoid){ + /* very bad error, no deciphering function specified */ + return; + } + dec_fpt.dec1(block, (ctx->ctx)); +} + +uint16_t bcal_cipher_getBlocksize_b(const bcdesc_t* desc){ + return pgm_read_word(&(desc->blocksize_b)); +} + +PGM_VOID_P bcal_cipher_getKeysizeDesc(const bcdesc_t* desc){ + return (PGM_VOID_P)pgm_read_word(&(desc->valid_keysize_desc)); +} + + diff --git a/bcal/bcal-basic.h b/bcal/bcal-basic.h new file mode 100644 index 0000000..e45b9b8 --- /dev/null +++ b/bcal/bcal-basic.h @@ -0,0 +1,36 @@ +/* bcal-basic.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#ifndef BCAL_BASIC_H_ +#define BCAL_BASIC_H_ + +#include +#include +#include "blockcipher_descriptor.h" +#include "keysize_descriptor.h" +#include + +uint8_t bcal_cipher_init(const bcdesc_t* cipher_descriptor, + const void* key, uint16_t keysize_b, bcgen_ctx_t* ctx); +void bcal_cipher_free(bcgen_ctx_t* ctx); +void bcal_cipher_enc(void* block, const bcgen_ctx_t* ctx); +void bcal_cipher_dec(void* block, const bcgen_ctx_t* ctx); +uint16_t bcal_cipher_getBlocksize_b(const bcdesc_t* desc); +PGM_VOID_P bcal_cipher_getKeysizeDesc(const bcdesc_t* desc); +#endif /* BCAL_BASIC_H_ */ diff --git a/bcal/bcal-cbc.c b/bcal/bcal-cbc.c new file mode 100644 index 0000000..99e91ae --- /dev/null +++ b/bcal/bcal-cbc.c @@ -0,0 +1,84 @@ +/* bcal-cbc.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#include +#include +#include "bcal-cbc.h" +#include "bcal-basic.h" +#include "memxor/memxor.h" + +uint8_t bcal_cbc_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_cbc_ctx_t* ctx){ + ctx->desc = (bcdesc_t*)desc; + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->prev_block = malloc(ctx->blocksize_B); + + if(ctx->prev_block==NULL){ + return 0x11; + } + return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); +} + +void bcal_cbc_free(bcal_cbc_ctx_t* ctx){ + bcal_cipher_free(&(ctx->cctx)); + free(ctx->prev_block); +} + + +void bcal_cbc_loadIV(const void* iv, bcal_cbc_ctx_t* ctx){ + if(iv){ + memcpy(ctx->prev_block, iv, ctx->blocksize_B); + } +} + +void bcal_cbc_encNext(void* block, bcal_cbc_ctx_t* ctx){ + memxor(block, ctx->prev_block, ctx->blocksize_B); + bcal_cipher_enc(block, &(ctx->cctx)); + memcpy(ctx->prev_block, block, ctx->blocksize_B); +} + +void bcal_cbc_decNext(void* block, bcal_cbc_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + memcpy(tmp, block, ctx->blocksize_B); + bcal_cipher_dec(block, &(ctx->cctx)); + memxor(block, ctx->prev_block, ctx->blocksize_B); + memcpy(ctx->prev_block, tmp, ctx->blocksize_B); +} +void bcal_cbc_decRand(void* block, const void* prev_block, bcal_cbc_ctx_t* ctx){ + bcal_cipher_dec(block, &(ctx->cctx)); + memxor(block, prev_block, ctx->blocksize_B); +} + +void bcal_cbc_encMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cbc_ctx_t* ctx){ + bcal_cbc_loadIV(iv, ctx); + while(msg_blocks--){ + bcal_cbc_encNext(msg, ctx); + msg = (uint8_t*)msg + ctx->blocksize_B; + } +} + +void bcal_cbc_decMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cbc_ctx_t* ctx){ + msg=(uint8_t*)msg + (msg_blocks-1)*ctx->blocksize_B; + while(msg_blocks > 1){ + bcal_cbc_decRand(msg, (uint8_t*)msg-ctx->blocksize_B, ctx); + msg_blocks -= 1; + msg=(uint8_t*)msg-ctx->blocksize_B; + } + bcal_cbc_decRand(msg, iv, ctx); +} + diff --git a/bcal/bcal-cbc.h b/bcal/bcal-cbc.h new file mode 100644 index 0000000..ba20186 --- /dev/null +++ b/bcal/bcal-cbc.h @@ -0,0 +1,44 @@ +/* bcal-cbc.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef BCALCBC_H_ +#define BCALCBC_H_ + +#include +#include "blockcipher_descriptor.h" +#include "bcal-basic.h" + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* prev_block; + uint8_t blocksize_B; +} bcal_cbc_ctx_t; + +uint8_t bcal_cbc_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_cbc_ctx_t* ctx); +void bcal_cbc_free(bcal_cbc_ctx_t* ctx); +void bcal_cbc_loadIV(const void* iv, bcal_cbc_ctx_t* ctx); +void bcal_cbc_encNext(void* block, bcal_cbc_ctx_t* ctx); +void bcal_cbc_decNext(void* block, bcal_cbc_ctx_t* ctx); +void bcal_cbc_decRand(void* block, const void* prev_block, bcal_cbc_ctx_t* ctx); +void bcal_cbc_encMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cbc_ctx_t* ctx); +void bcal_cbc_decMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cbc_ctx_t* ctx); + + +#endif /* BCALCBC_H_ */ diff --git a/bcal/bcal-cfb_bit.c b/bcal/bcal-cfb_bit.c new file mode 100644 index 0000000..2611b65 --- /dev/null +++ b/bcal/bcal-cfb_bit.c @@ -0,0 +1,128 @@ +/* bcal-cfb_bit.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#include +#include +#include "bcal-cfb_bit.h" +#include "bcal-basic.h" + +static uint8_t read_bit(void* block, uint32_t index){ + uint8_t r; + r=((uint8_t*)block)[index/8]; + r=(r&(0x80>>(index&7)))?0xff:0x00; + return r; +} + +static void write_bit(void* block, uint32_t index, uint8_t value){ + if(value){ + /* set bit */ + ((uint8_t*)block)[index/8] |= 0x80>>(index&7); + }else{ + /* clear bit */ + ((uint8_t*)block)[index/8] &= ~(0x80>>(index&7)); + } +} + +uint8_t bcal_cfb_b_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, uint16_t size_b, bcal_cfb_b_ctx_t* ctx){ + ctx->desc = (bcdesc_t*)desc; + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->in_block=malloc(ctx->blocksize_B); + if(ctx->in_block==NULL){ + return 0x11; + } + if(size_b>bcal_cipher_getBlocksize_b(desc)){ + return 0x12; + } + ctx->size_b = size_b; + return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); +} + +void bcal_cfb_b_free(bcal_cfb_b_ctx_t* ctx){ + free(ctx->in_block); + bcal_cipher_free(&(ctx->cctx)); +} + +void bcal_cfb_b_loadIV(const void* iv, bcal_cfb_b_ctx_t* ctx){ + if(iv){ + memcpy(ctx->in_block, iv, ctx->blocksize_B); + } +} + +void bcal_cfb_b_encNext(void* block, uint8_t offset, bcal_cfb_b_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + offset &= 7; + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + uint16_t i,j; + uint8_t a; + for(i=0; iblocksize_B*8-ctx->size_b; ++i){ + a = read_bit(ctx->in_block, i+ctx->size_b); + write_bit(ctx->in_block, i, a); + } + for(j=offset,i=0; isize_b; ++i, ++j){ + a = read_bit(tmp, i) ^ read_bit(block, j); + write_bit(ctx->in_block, ctx->blocksize_B*8-ctx->size_b+i, a); + write_bit(block, j, a); + } +} + +void bcal_cfb_b_decNext(void* block, uint8_t offset, bcal_cfb_b_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + offset &= 7; + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + uint16_t i,j; + uint8_t a,b; + for(i=0; iblocksize_B*8-ctx->size_b; ++i){ + a = read_bit(ctx->in_block, i+ctx->size_b); + write_bit(ctx->in_block, i, a); + } + for(j=offset,i=0; isize_b; ++i, ++j){ + a = read_bit(tmp, i); + b = read_bit(block, j); + a ^= b; + write_bit(ctx->in_block, ctx->blocksize_B*8-ctx->size_b+i, b); + write_bit(block, j, a); + } +} + +void bcal_cfb_b_encMsg(const void* iv, void* msg, uint8_t offset, uint32_t msg_blocks, bcal_cfb_b_ctx_t* ctx){ + bcal_cfb_b_loadIV(iv, ctx); + uint32_t addr; + addr = ((uint16_t)msg)*8+offset; + while(msg_blocks--){ + msg = (void*)((uint16_t)(addr/8)); + offset = addr&7; + bcal_cfb_b_encNext(msg, offset, ctx); + addr += ctx->size_b; + } +} + +void bcal_cfb_b_decMsg(const void* iv, void* msg, uint8_t offset, uint32_t msg_blocks, bcal_cfb_b_ctx_t* ctx){ + bcal_cfb_b_loadIV(iv, ctx); + uint32_t addr; + addr = ((uint16_t)msg)*8+offset; + while(msg_blocks--){ + msg = (void*)((uint16_t)(addr/8)); + offset = addr&7; + bcal_cfb_b_decNext(msg, offset, ctx); + addr += ctx->size_b; + } +} diff --git a/bcal/bcal-cfb_bit.h b/bcal/bcal-cfb_bit.h new file mode 100644 index 0000000..df62e17 --- /dev/null +++ b/bcal/bcal-cfb_bit.h @@ -0,0 +1,47 @@ +/* bcal-cfb_bit.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#ifndef BCALCFB_BIT_H_ +#define BCALCFB_BIT_H_ + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" + + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* in_block; + uint8_t blocksize_B; + uint16_t size_b; +} bcal_cfb_b_ctx_t; + + +uint8_t bcal_cfb_b_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, uint16_t size_b, bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_free(bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_loadIV(const void* iv, bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_encNext(void* block, uint8_t offset, bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_decNext(void* block, uint8_t offset, bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_encMsg(const void* iv, void* msg, uint8_t offset, uint32_t msg_blocks, bcal_cfb_b_ctx_t* ctx); +void bcal_cfb_b_decMsg(const void* iv, void* msg, uint8_t offset, uint32_t msg_blocks, bcal_cfb_b_ctx_t* ctx); + + +#endif /* BCALCFB_BIT_H_ */ diff --git a/bcal/bcal-cfb_byte.c b/bcal/bcal-cfb_byte.c new file mode 100644 index 0000000..f91f400 --- /dev/null +++ b/bcal/bcal-cfb_byte.c @@ -0,0 +1,88 @@ +/* bcal-cfb_byte.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#include +#include +#include "bcal-cfb_byte.h" +#include "bcal-basic.h" +#include "memxor/memxor.h" + + +uint8_t bcal_cfb_B_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, uint16_t size_b, bcal_cfb_B_ctx_t* ctx){ + ctx->desc = (bcdesc_t*)desc; + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->in_block=malloc(ctx->blocksize_B); + if(ctx->in_block==NULL){ + return 0x11; + } + if(size_b&7){ + return 0x12; + } + ctx->size_B = size_b/8; + return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); +} + +void bcal_cfb_B_free(bcal_cfb_B_ctx_t* ctx){ + free(ctx->in_block); + bcal_cipher_free(&(ctx->cctx)); +} + +void bcal_cfb_B_loadIV(const void* iv, bcal_cfb_B_ctx_t* ctx){ + if(iv){ + memcpy(ctx->in_block, iv, ctx->blocksize_B); + } +} + +void bcal_cfb_B_encNext(void* block, bcal_cfb_B_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + memxor(block, tmp, ctx->size_B); + memmove(ctx->in_block, ctx->in_block+ctx->size_B, ctx->blocksize_B - ctx->size_B); + memcpy(ctx->in_block+ctx->blocksize_B-ctx->size_B, block, ctx->size_B); +} + +void bcal_cfb_B_decNext(void* block, bcal_cfb_B_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + uint8_t xblock[ctx->size_B]; + memcpy(xblock, block, ctx->size_B); + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + memxor(block, tmp, ctx->size_B); + memmove(ctx->in_block, ctx->in_block+ctx->size_B, ctx->blocksize_B - ctx->size_B); + memcpy(ctx->in_block+ctx->blocksize_B-ctx->size_B, xblock, ctx->size_B); +} + +void bcal_cfb_B_encMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cfb_B_ctx_t* ctx){ + bcal_cfb_B_loadIV(iv, ctx); + while(msg_blocks--){ + bcal_cfb_B_encNext(msg, ctx); + msg = (uint8_t*)msg+ctx->size_B; + } +} + +void bcal_cfb_B_decMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cfb_B_ctx_t* ctx){ + bcal_cfb_B_loadIV(iv, ctx); + while(msg_blocks--){ + bcal_cfb_B_decNext(msg, ctx); + msg = (uint8_t*)msg+ctx->size_B; + } +} + diff --git a/bcal/bcal-cfb_byte.h b/bcal/bcal-cfb_byte.h new file mode 100644 index 0000000..276a904 --- /dev/null +++ b/bcal/bcal-cfb_byte.h @@ -0,0 +1,46 @@ +/* bcal-cbc.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef BCALCFB_BYTE_H_ +#define BCALCFB_BYTE_H_ + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" + + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* in_block; + uint8_t blocksize_B; + uint8_t size_B; +} bcal_cfb_B_ctx_t; + + +uint8_t bcal_cfb_B_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, uint16_t size_b, bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_free(bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_loadIV(const void* iv, bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_encNext(void* block, bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_decNext(void* block, bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_encMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cfb_B_ctx_t* ctx); +void bcal_cfb_B_decMsg(const void* iv, void* msg, uint16_t msg_blocks, bcal_cfb_B_ctx_t* ctx); + + +#endif /* BCALCFB_BYTE_H_ */ diff --git a/bcal/bcal-cmac.c b/bcal/bcal-cmac.c new file mode 100644 index 0000000..5821e26 --- /dev/null +++ b/bcal/bcal-cmac.c @@ -0,0 +1,152 @@ +/* bcal-omac.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#include +#include +#include "bcal-basic.h" +#include "bcal-cmac.h" +#include "memxor/memxor.h" + + +static uint8_t left_shift_be_block(void* block, uint8_t blocksize_B){ + uint8_t c1=0, c2; + do{ + --blocksize_B; + c2 = (((uint8_t*)block)[blocksize_B])>>7; + (((uint8_t*)block)[blocksize_B]) <<= 1; + (((uint8_t*)block)[blocksize_B]) |= c1; + c1 = c2; + }while(blocksize_B); + return c1; +} + +static const uint8_t const_128 = 0x87; +static const uint8_t const_64 = 0x1b; + +uint8_t bcal_cmac_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_cmac_ctx_t* ctx){ + uint8_t r; + ctx->desc = (bcdesc_t*)desc; + ctx->blocksize_B = bcal_cipher_getBlocksize_b(desc)/8; + if (ctx->blocksize_B!=128/8 && ctx->blocksize_B!=64/8){ + return 0x13; + } + ctx->accu = malloc(ctx->blocksize_B); + if(ctx->accu==NULL){ + return 0x14; + } + ctx->k1 = malloc(ctx->blocksize_B); + if(ctx->k1==NULL){ + return 0x15; + } + ctx->k2 = malloc(ctx->blocksize_B); + if(ctx->k2==NULL){ + return 0x16; + } + ctx->lastblock = malloc(ctx->blocksize_B); + if(ctx->lastblock==NULL){ + return 0x17; + } + r = bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); + if(r){ + return r; + } + if(ctx->blocksize_B==128/8){ + r = const_128; + }else{ + r = const_64; + } + /* subkey computation */ + memset(ctx->accu, 0x00, ctx->blocksize_B); + memset(ctx->k1, 0x00, ctx->blocksize_B); + bcal_cipher_enc(ctx->k1, &(ctx->cctx)); + if(left_shift_be_block(ctx->k1, ctx->blocksize_B)){ + ctx->k1[ctx->blocksize_B-1] ^= r; + } + memcpy(ctx->k2, ctx->k1, ctx->blocksize_B); + if(left_shift_be_block(ctx->k2, ctx->blocksize_B)){ + ctx->k2[ctx->blocksize_B-1] ^= r; + } + ctx->last_set=0; + return 0; +} + +void bcal_cmac_free(bcal_cmac_ctx_t* ctx){ + free(ctx->accu); + free(ctx->k1); + free(ctx->k2); + bcal_cipher_free(&(ctx->cctx)); +} + +void bcal_cmac_nextBlock (bcal_cmac_ctx_t* ctx, const void* block){ + if(ctx->last_set){ + memxor(ctx->accu, ctx->lastblock, ctx->blocksize_B); + bcal_cipher_enc(ctx->accu, &(ctx->cctx)); + } + memcpy(ctx->lastblock, block, ctx->blocksize_B); + ctx->last_set=1; +} + + +void bcal_cmac_lastBlock(bcal_cmac_ctx_t* ctx, const void* block, uint16_t length_b){ + uint16_t blocksize_b; + blocksize_b = ctx->blocksize_B*8; + while(length_b>=blocksize_b){ + bcal_cmac_nextBlock(ctx, block); + block = (uint8_t*)block + ctx->blocksize_B; + length_b -= blocksize_b; + } + if(ctx->last_set==0){ + memxor(ctx->accu, block, (length_b+7)/8); + memxor(ctx->accu, ctx->k2, ctx->blocksize_B); + ctx->accu[length_b/8] ^= 0x80>>(length_b&7); + }else{ + if(length_b==0){ + memxor(ctx->accu, ctx->lastblock, ctx->blocksize_B); + memxor(ctx->accu, ctx->k1, ctx->blocksize_B); + }else{ + memxor(ctx->accu, ctx->lastblock, ctx->blocksize_B); + bcal_cipher_enc(ctx->accu, &(ctx->cctx)); + memxor(ctx->accu, block, (length_b+7)/8); + memxor(ctx->accu, ctx->k2, ctx->blocksize_B); + ctx->accu[length_b/8] ^= 0x80>>(length_b&7); + } + } + bcal_cipher_enc(ctx->accu, &(ctx->cctx)); +} + +void bcal_cmac_ctx2mac(void* dest, uint16_t length_b, const bcal_cmac_ctx_t* ctx){ + memcpy(dest, ctx->accu, length_b/8); + if(length_b&7){ + ((uint8_t*)dest)[length_b/8] &= 0xff>>(length_b&7); + ((uint8_t*)dest)[length_b/8] |= (0xff00>>(length_b&7))&(ctx->accu[length_b/8]); + } +} + +void bcal_cmac(void* dest, uint16_t out_length_b, const void* block, uint32_t length_b, bcal_cmac_ctx_t* ctx){ + uint16_t blocksize_b; + blocksize_b = ctx->blocksize_B*8; + while(length_b>blocksize_b){ + bcal_cmac_nextBlock(ctx, block); + block = (uint8_t*)block + ctx->blocksize_B; + length_b -= blocksize_b; + } + bcal_cmac_lastBlock(ctx, block, length_b); + bcal_cmac_ctx2mac(dest, out_length_b, ctx); +} diff --git a/bcal/bcal-cmac.h b/bcal/bcal-cmac.h new file mode 100644 index 0000000..be699b6 --- /dev/null +++ b/bcal/bcal-cmac.h @@ -0,0 +1,45 @@ +/* bcal-cmac.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef BCALCMAC_H_ +#define BCALCMAC_H_ + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* accu; + uint8_t* k1; + uint8_t* k2; + uint8_t* lastblock; + uint8_t last_set; + uint8_t blocksize_B; +} bcal_cmac_ctx_t; + +uint8_t bcal_cmac_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_cmac_ctx_t* ctx); +void bcal_cmac_free(bcal_cmac_ctx_t* ctx); +void bcal_cmac_nextBlock(bcal_cmac_ctx_t* ctx, const void* block); +void bcal_cmac_lastBlock(bcal_cmac_ctx_t* ctx, const void* block, uint16_t length_b); +void bcal_cmac_ctx2mac(void* dest, uint16_t length_b, const bcal_cmac_ctx_t* ctx); +void bcal_cmac(void* dest, uint16_t out_length_b, const void* block, uint32_t length_b, bcal_cmac_ctx_t* ctx); + +#endif /* BCALCMAC_H_ */ diff --git a/bcal/bcal-ctr.c b/bcal/bcal-ctr.c new file mode 100644 index 0000000..60df831 --- /dev/null +++ b/bcal/bcal-ctr.c @@ -0,0 +1,95 @@ +/* bcal-ctr.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#include +#include +#include "bcal-basic.h" +#include "bcal-ctr.h" +#include "memxor/memxor.h" + +static void increment_be(void* block, uint8_t size_B){ + uint16_t c=1; + do{ + --size_B; + c += ((uint8_t*)block)[size_B]; + ((uint8_t*)block)[size_B] = (uint8_t)c; + c>>=8; + }while(size_B); +} + +uint8_t bcal_ctr_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, inc_fp_t inc_func, bcal_ctr_ctx_t* ctx){ + ctx->desc = (bcdesc_t*)desc; + if(inc_func){ + ctx->inc_func = inc_func; + }else{ + ctx->inc_func = increment_be; + } + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->in_block=malloc(ctx->blocksize_B); + if(ctx->in_block==NULL){ + return 0x11; + } + return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); +} + +void bcal_ctr_free(bcal_ctr_ctx_t* ctx){ + free(ctx->in_block); + bcal_cipher_free(&(ctx->cctx)); +} + +void bcal_ctr_loadIV(const void* iv, bcal_ctr_ctx_t* ctx){ + if(iv){ + memcpy(ctx->in_block, iv, ctx->blocksize_B); + } +} + +void bcal_ctr_encNext(void* block, bcal_ctr_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + memxor(block, tmp, ctx->blocksize_B); + ctx->inc_func(ctx->in_block, ctx->blocksize_B); +} + +void bcal_ctr_decNext(void* block, bcal_ctr_ctx_t* ctx){ + bcal_ctr_encNext(block, ctx); +} + +void bcal_ctr_encMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ctr_ctx_t* ctx){ + bcal_ctr_loadIV(iv, ctx); + uint16_t blocksize_b; + blocksize_b = ctx->blocksize_B*8; + while(msg_len_b>blocksize_b){ + bcal_ctr_encNext(msg, ctx); + msg_len_b -= blocksize_b; + msg = (uint8_t*)msg + ctx->blocksize_B; + } + uint8_t tmp[ctx->blocksize_B]; + memcpy(tmp, ctx->in_block, ctx->blocksize_B); + bcal_cipher_enc(tmp, &(ctx->cctx)); + ctx->inc_func(ctx->in_block, ctx->blocksize_B); + tmp[msg_len_b/8] = 0xff00>>(msg_len_b&7); + memxor(msg, tmp, (msg_len_b+7)/8); +} + +void bcal_ctr_decMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ctr_ctx_t* ctx){ + bcal_ctr_encMsg(iv, msg, msg_len_b, ctx); +} + diff --git a/bcal/bcal-ctr.h b/bcal/bcal-ctr.h new file mode 100644 index 0000000..55de485 --- /dev/null +++ b/bcal/bcal-ctr.h @@ -0,0 +1,45 @@ +/* bcal-ctr.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef BCALCTR_H_ +#define BCALCTR_H_ + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" + +typedef void(*inc_fp_t)(void* block, uint8_t size_B); + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* in_block; + inc_fp_t inc_func; + uint8_t blocksize_B; +} bcal_ctr_ctx_t; + +uint8_t bcal_ctr_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, inc_fp_t inc_func, bcal_ctr_ctx_t* ctx); +void bcal_ctr_free(bcal_ctr_ctx_t* ctx); +void bcal_ctr_loadIV(const void* iv, bcal_ctr_ctx_t* ctx); +void bcal_ctr_encNext(void* block, bcal_ctr_ctx_t* ctx); +void bcal_ctr_decNext(void* block, bcal_ctr_ctx_t* ctx); +void bcal_ctr_encMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ctr_ctx_t* ctx); +void bcal_ctr_decMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ctr_ctx_t* ctx); + +#endif /* BCALCTR_H_ */ diff --git a/bcal/bcal-eax.c b/bcal/bcal-eax.c new file mode 100644 index 0000000..ca23e5c --- /dev/null +++ b/bcal/bcal-eax.c @@ -0,0 +1,119 @@ +/* bca-eax.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" +#include "bcal-cmac.h" +#include "bcal-ctr.h" +#include "bcal-eax.h" +#include "memxor/memxor.h" + +uint8_t bcal_eax_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_eax_ctx_t* ctx){ + uint8_t r; + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->nonce = malloc(ctx->blocksize_B); + if(ctx->nonce==NULL){ + return 0x81; + } + r = bcal_cmac_init(desc, key, keysize_b, &(ctx->ctag)); + if(r){ + return r; + } + r = bcal_cmac_init(desc, key, keysize_b, &(ctx->htag)); + if(r){ + return (r|0x10); + } + r = bcal_cmac_init(desc, key, keysize_b, &(ctx->ntag)); + if(r){ + return (r|0x20); + } + r = bcal_ctr_init(desc, key, keysize_b, NULL, &(ctx->cipher)); + if(r){ + return (r|0x30); + } + ctx->header_set=0; + uint8_t tmp[ctx->blocksize_B]; + memset(tmp, 0, ctx->blocksize_B); + bcal_cmac_nextBlock(&(ctx->ntag), tmp); + tmp[ctx->blocksize_B-1]=1; + bcal_cmac_nextBlock(&(ctx->htag), tmp); + tmp[ctx->blocksize_B-1]=2; + bcal_cmac_nextBlock(&(ctx->ctag), tmp); + return 0; +} + +void bcal_eax_free(bcal_eax_ctx_t* ctx){ + bcal_ctr_free(&(ctx->cipher)); + bcal_cmac_free(&(ctx->ctag)); + bcal_cmac_free(&(ctx->htag)); + bcal_cmac_free(&(ctx->ntag)); + free(ctx->nonce); +} + +void bcal_eax_loadNonce(const void* nonce, uint16_t length_b, bcal_eax_ctx_t* ctx){ + bcal_cmac_lastBlock(&(ctx->ntag), nonce, length_b); + bcal_cmac_ctx2mac(ctx->nonce, ctx->blocksize_B*8, &(ctx->ntag)); + bcal_ctr_loadIV(ctx->nonce, &(ctx->cipher)); +} + +void bcal_eax_addNextHeader(const void* header, bcal_eax_ctx_t* ctx){ + bcal_cmac_nextBlock(&(ctx->htag), header); +} + +void bcal_eax_addLastHeader(const void* header, uint16_t length_b, bcal_eax_ctx_t* ctx){ + bcal_cmac_lastBlock(&(ctx->htag), header, length_b); + ctx->header_set = 1; +} + +void bcal_eax_encNextBlock(void* block, bcal_eax_ctx_t* ctx){ + bcal_ctr_encNext(block, &(ctx->cipher)); + bcal_cmac_nextBlock(&(ctx->ctag), block); +} + +void bcal_eax_encLastBlock(void* block, uint16_t length_b, bcal_eax_ctx_t* ctx){ + bcal_ctr_encMsg(NULL, block, length_b, &(ctx->cipher)); + bcal_cmac_lastBlock(&(ctx->ctag), block, length_b); +} + +void bcal_eax_decNextBlock(void* block, bcal_eax_ctx_t* ctx){ + bcal_cmac_nextBlock(&(ctx->ctag), block); + bcal_ctr_decNext(block, &(ctx->cipher)); +} + +void bcal_eax_decLastBlock(void* block, uint16_t length_b, bcal_eax_ctx_t* ctx){ + bcal_cmac_lastBlock(&(ctx->ctag), block, length_b); + bcal_ctr_decMsg(NULL, block, length_b, &(ctx->cipher)); +} + +void bcal_eax_ctx2tag(void* dest, uint16_t length_b, bcal_eax_ctx_t* ctx){ + uint8_t tmp[ctx->blocksize_B]; + if(ctx->header_set==0){ + bcal_cmac_lastBlock(&(ctx->htag), NULL, 0); + } + + bcal_cmac_ctx2mac(tmp, ctx->blocksize_B*8, &(ctx->htag)); + memxor(ctx->nonce, tmp, ctx->blocksize_B); + + bcal_cmac_ctx2mac(tmp, ctx->blocksize_B*8, &(ctx->ctag)); + memxor(ctx->nonce, tmp, ctx->blocksize_B); + memcpy(dest, ctx->nonce, (length_b+7)/8); +} + diff --git a/bcal/bcal-eax.h b/bcal/bcal-eax.h new file mode 100644 index 0000000..190eee9 --- /dev/null +++ b/bcal/bcal-eax.h @@ -0,0 +1,53 @@ +/* bcal-eax.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef BCALEAX_H_ +#define BCALEAX_H_ + +#include +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" +#include "bcal-cmac.h" +#include "bcal-ctr.h" + +typedef struct{ + uint8_t* nonce; + bcal_cmac_ctx_t ntag; + bcal_cmac_ctx_t ctag; + bcal_cmac_ctx_t htag; + bcal_ctr_ctx_t cipher; + uint8_t blocksize_B; + uint8_t header_set; +} bcal_eax_ctx_t; + +uint8_t bcal_eax_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_eax_ctx_t* ctx); +void bcal_eax_free(bcal_eax_ctx_t* ctx); +void bcal_eax_loadNonce(const void* nonce, uint16_t length_b, bcal_eax_ctx_t* ctx); +void bcal_eax_addNextHeader(const void* header, bcal_eax_ctx_t* ctx); +void bcal_eax_addLastHeader(const void* header, uint16_t length_b, bcal_eax_ctx_t* ctx); +void bcal_eax_encNextBlock(void* block, bcal_eax_ctx_t* ctx); +void bcal_eax_encLastBlock(void* block, uint16_t length_b, bcal_eax_ctx_t* ctx); +void bcal_eax_decNextBlock(void* block, bcal_eax_ctx_t* ctx); +void bcal_eax_decLastBlock(void* block, uint16_t length_b, bcal_eax_ctx_t* ctx); +void bcal_eax_ctx2tag(void* dest, uint16_t length_b, bcal_eax_ctx_t* ctx); +//void bcal_eax(void* dest, uint16_t out_length_b, const void* block, uint32_t length_b, bcal_eax_ctx_t* ctx); + +#endif /* BCALEAX_H_ */ + diff --git a/bcal/bcal-ofb.c b/bcal/bcal-ofb.c new file mode 100644 index 0000000..eb1fd4d --- /dev/null +++ b/bcal/bcal-ofb.c @@ -0,0 +1,76 @@ +/* bcal-ofb.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#include +#include +#include "bcal-ofb.h" +#include "bcal-basic.h" +#include "memxor/memxor.h" + + +uint8_t bcal_ofb_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_ofb_ctx_t* ctx){ + ctx->desc = (bcdesc_t*)desc; + ctx->blocksize_B = (bcal_cipher_getBlocksize_b(desc)+7)/8; + ctx->in_block=malloc(ctx->blocksize_B); + if(ctx->in_block==NULL){ + return 0x11; + } + return bcal_cipher_init(desc, key, keysize_b, &(ctx->cctx)); +} + +void bcal_ofb_free(bcal_ofb_ctx_t* ctx){ + free(ctx->in_block); + bcal_cipher_free(&(ctx->cctx)); +} + +void bcal_ofb_loadIV(const void* iv, bcal_ofb_ctx_t* ctx){ + if(iv){ + memcpy(ctx->in_block, iv, ctx->blocksize_B); + } +} + +void bcal_ofb_encNext(void* block, bcal_ofb_ctx_t* ctx){ + bcal_cipher_enc(ctx->in_block , &(ctx->cctx)); + memxor(block, ctx->in_block, ctx->blocksize_B); +} + +void bcal_ofb_decNext(void* block, bcal_ofb_ctx_t* ctx){ + bcal_cipher_enc(ctx->in_block , &(ctx->cctx)); + memxor(block, ctx->in_block, ctx->blocksize_B); +} + + +void bcal_ofb_encMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ofb_ctx_t* ctx){ + uint16_t block_len_b; + block_len_b = ctx->blocksize_B*8; + bcal_ofb_loadIV(iv, ctx); + while(msg_len_b>block_len_b){ + bcal_ofb_encNext(msg, ctx); + msg_len_b -= block_len_b; + msg = (uint8_t*)msg + ctx->blocksize_B; + } + bcal_cipher_enc(ctx->in_block, &(ctx->cctx)); + ctx->in_block[msg_len_b/8] = 0xff00>>(msg_len_b&7); + memxor(msg, ctx->in_block, (msg_len_b+7)/8); +} + +void bcal_ofb_decMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ofb_ctx_t* ctx){ + bcal_ofb_encMsg(iv, msg, msg_len_b, ctx); +} + diff --git a/bcal/bcal-ofb.h b/bcal/bcal-ofb.h new file mode 100644 index 0000000..aa69c05 --- /dev/null +++ b/bcal/bcal-ofb.h @@ -0,0 +1,46 @@ +/* bcal-ofb.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + + +#ifndef BCALOFB_H_ +#define BCALOFB_H_ + +#include +#include "bcal-basic.h" +#include "blockcipher_descriptor.h" + + +typedef struct{ + bcdesc_t* desc; + bcgen_ctx_t cctx; + uint8_t* in_block; + uint8_t blocksize_B; +} bcal_ofb_ctx_t; + + +uint8_t bcal_ofb_init(const bcdesc_t* desc, const void* key, uint16_t keysize_b, bcal_ofb_ctx_t* ctx); +void bcal_ofb_free(bcal_ofb_ctx_t* ctx); +void bcal_ofb_loadIV(const void* iv, bcal_ofb_ctx_t* ctx); +void bcal_ofb_encNext(void* block, bcal_ofb_ctx_t* ctx); +void bcal_ofb_decNext(void* block, bcal_ofb_ctx_t* ctx); +void bcal_ofb_encMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ofb_ctx_t* ctx); +void bcal_ofb_decMsg(const void* iv, void* msg, uint32_t msg_len_b, bcal_ofb_ctx_t* ctx); + + +#endif /* BCALOFB_H_ */ diff --git a/bcal/bcal-performance.c b/bcal/bcal-performance.c new file mode 100644 index 0000000..36cc823 --- /dev/null +++ b/bcal/bcal-performance.c @@ -0,0 +1,225 @@ +/* bcal-performance.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +/* + * \file bcal-performance.c + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2010-02-16 + * \license GPLv3 or later + * + */ + +#include "bcal-performance.h" +#include "keysize_descriptor.h" +#include "blockcipher_descriptor.h" +#include "performance_test.h" +#include "stack_measuring.h" +#include "cli.h" +#include +#include +#include +#include + +#define PATTERN_A 0xAA +#define PATTERN_B 0x55 + + +static +void printvalue(unsigned long v){ + char str[20]; + int i; + ultoa(v, str, 10); + for(i=0; i<10-strlen(str); ++i){ + cli_putc(' '); + } + cli_putstr(str); +} + +void bcal_performance(const bcdesc_t* bcd){ + bcdesc_t bc; + memcpy_P(&bc, bcd, sizeof(bcdesc_t)); + uint8_t ctx[bc.ctxsize_B]; + uint8_t data[(bc.blocksize_b+7)/8]; + uint16_t keysize = get_keysize(bc.valid_keysize_desc); + uint8_t key[(keysize+7)/8]; + uint64_t t; + uint8_t i; + + if(bc.type!=BCDESC_TYPE_BLOCKCIPHER) + return; + calibrateTimer(); + print_overhead(); + cli_putstr_P(PSTR("\r\n\r\n === ")); + cli_putstr_P(bc.name); + cli_putstr_P(PSTR(" performance === " + "\r\n type: blockcipher" + "\r\n keysize (bits): ")); + printvalue(keysize); + + cli_putstr_P(PSTR("\r\n ctxsize (bytes): ")); + printvalue(bc.ctxsize_B); + + cli_putstr_P(PSTR("\r\n blocksize (bits): ")); + printvalue(bc.blocksize_b); + + + + t=0; + if(bc.init.init1){ + if((bc.flags&BC_INIT_TYPE)==BC_INIT_TYPE_1){ + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + (bc.init.init1)(key, &ctx); + STOP_TIMER; + t += stopTimer(); + if(i!=31 && bc.free){ + bc.free(&ctx); + } + } + } else { + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + (bc.init.init2)(key, keysize, &ctx); + STOP_TIMER; + t += stopTimer(); + if(i!=31 && bc.free){ + bc.free(&ctx); + } + } + } + t>>=5; + cli_putstr_P(PSTR("\r\n init (cycles): ")); + printvalue(t); + } + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + bc.enc.enc1(data, &ctx); + STOP_TIMER; + t += stopTimer(); + } + t>>=5; + cli_putstr_P(PSTR("\r\n encrypt (cycles): ")); + printvalue(t); + + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + bc.dec.dec1(data, &ctx); + STOP_TIMER; + t += stopTimer(); + } + t>>=5; + cli_putstr_P(PSTR("\r\n decrypt (cycles): ")); + printvalue(t); + + if(bc.free){ + bc.free(&ctx); + } +} + +void bcal_stacksize(const bcdesc_t* bcd){ + bcdesc_t bc; + stack_measuring_ctx_t smctx; + memcpy_P(&bc, bcd, sizeof(bcdesc_t)); + uint8_t ctx[bc.ctxsize_B]; + uint8_t data[(bc.blocksize_b+7)/8]; + uint16_t keysize = get_keysize(bc.valid_keysize_desc); + uint8_t key[(keysize+7)/8]; + uint16_t t1, t2; + + if(bc.type!=BCDESC_TYPE_BLOCKCIPHER) + return; + cli_putstr_P(PSTR("\r\n\r\n === ")); + cli_putstr_P(bc.name); + cli_putstr_P(PSTR(" stack-usage === ")); + + if(bc.init.init1){ + if((bc.flags&BC_INIT_TYPE)==BC_INIT_TYPE_1){ + cli(); + stack_measure_init(&smctx, PATTERN_A); + bc.init.init1(&ctx, key); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + bc.init.init1(&ctx, key); + t2 = stack_measure_final(&smctx); + sei(); + } else { + cli(); + stack_measure_init(&smctx, PATTERN_A); + bc.init.init2(&ctx, keysize, key); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + bc.init.init2(&ctx, keysize, key); + t2 = stack_measure_final(&smctx); + sei(); + } + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n init (bytes): ")); + printvalue((unsigned long)t1); + } + cli(); + stack_measure_init(&smctx, PATTERN_A); + bc.enc.enc1(data, &ctx); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + bc.enc.enc1(data, &ctx); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n encBlock (bytes): ")); + printvalue((unsigned long)t1); + + cli(); + stack_measure_init(&smctx, PATTERN_A); + bc.dec.dec1(data, &ctx); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + bc.dec.dec1(data, &ctx); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n decBlock (bytes): ")); + printvalue((unsigned long)t1); + + if(bc.free){ + bc.free(&ctx); + } +} + +void bcal_performance_multiple(const bcdesc_t** bcd_list){ + const bcdesc_t* bcd; + for(;;){ + bcd = (void*)pgm_read_word(bcd_list); + if(!bcd){ + cli_putstr_P(PSTR("\r\n\r\n End of performance figures\r\n")); + return; + } + bcal_performance(bcd); + bcal_stacksize(bcd); + bcd_list = (void*)((uint8_t*)bcd_list + 2); + } +} diff --git a/bcal/bcal-performance.h b/bcal/bcal-performance.h new file mode 100644 index 0000000..b8c5666 --- /dev/null +++ b/bcal/bcal-performance.h @@ -0,0 +1,38 @@ +/* bcal-performance.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +/* + * \file bcal-performance.h + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2010-02-16 + * \license GPLv3 or later + * + */ + +#ifndef BCAL_PERFORMANCE_H_ +#define BCAL_PERFORMANCE_H_ + +#include "blockcipher_descriptor.h" + +void bcal_performance(const bcdesc_t* hd); +void bcal_performance_multiple(const bcdesc_t** hd_list); + + +#endif /* BCAL_PERFORMANCE_H_ */ diff --git a/bcal/bcal_aes128.c b/bcal/bcal_aes128.c new file mode 100644 index 0000000..946d7a9 --- /dev/null +++ b/bcal/bcal_aes128.c @@ -0,0 +1,55 @@ +/* bcal_aes128.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes128.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes128_enc.h" +#include "aes128_dec.h" +#include "aes_keyschedule.h" +#include "keysize_descriptor.h" + +const char aes128_str[] PROGMEM = "AES-128"; + +const uint8_t aes128_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +const bcdesc_t aes128_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + aes128_str, + sizeof(aes128_ctx_t), + 128, + {(void_fpt)aes128_init}, + {(void_fpt)aes128_enc}, + {(void_fpt)aes128_dec}, + (bc_free_fpt)NULL, + aes128_keysize_desc +}; + + diff --git a/bcal/bcal_aes128.h b/bcal/bcal_aes128.h new file mode 100644 index 0000000..7257425 --- /dev/null +++ b/bcal/bcal_aes128.h @@ -0,0 +1,35 @@ +/* bcal_aes128.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes128.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes128_enc.h" +#include "aes128_dec.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t aes128_desc; diff --git a/bcal/bcal_aes192.c b/bcal/bcal_aes192.c new file mode 100644 index 0000000..48f9954 --- /dev/null +++ b/bcal/bcal_aes192.c @@ -0,0 +1,55 @@ +/* bcal_aes192.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes192.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes192_enc.h" +#include "aes192_dec.h" +#include "aes_keyschedule.h" +#include "keysize_descriptor.h" + +const char aes192_str[] PROGMEM = "AES-192"; + +const uint8_t aes192_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(192), + KS_TYPE_TERMINATOR }; + +const bcdesc_t aes192_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + aes192_str, + sizeof(aes192_ctx_t), + 128, + {(void_fpt)aes192_init}, + {(void_fpt)aes192_enc}, + {(void_fpt)aes192_dec}, + (bc_free_fpt)NULL, + aes192_keysize_desc +}; + + diff --git a/bcal/bcal_aes192.h b/bcal/bcal_aes192.h new file mode 100644 index 0000000..cff8371 --- /dev/null +++ b/bcal/bcal_aes192.h @@ -0,0 +1,35 @@ +/* bcal_aes192.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes192.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes192_enc.h" +#include "aes192_dec.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t aes192_desc; diff --git a/bcal/bcal_aes256.c b/bcal/bcal_aes256.c new file mode 100644 index 0000000..12f5665 --- /dev/null +++ b/bcal/bcal_aes256.c @@ -0,0 +1,55 @@ +/* bcal_aes256.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes256.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes256_enc.h" +#include "aes256_dec.h" +#include "aes_keyschedule.h" +#include "keysize_descriptor.h" + +const char aes256_str[] PROGMEM = "AES-256"; + +const uint8_t aes256_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(256), + KS_TYPE_TERMINATOR }; + +const bcdesc_t aes256_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + aes256_str, + sizeof(aes256_ctx_t), + 128, + {(void_fpt)aes256_init}, + {(void_fpt)aes256_enc}, + {(void_fpt)aes256_dec}, + (bc_free_fpt)NULL, + aes256_keysize_desc +}; + + diff --git a/bcal/bcal_aes256.h b/bcal/bcal_aes256.h new file mode 100644 index 0000000..19dbb50 --- /dev/null +++ b/bcal/bcal_aes256.h @@ -0,0 +1,35 @@ +/* bcal_aes256.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_aes256.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-08 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "aes.h" +#include "aes256_enc.h" +#include "aes256_dec.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t aes256_desc; diff --git a/bcal/bcal_camellia128.c b/bcal/bcal_camellia128.c new file mode 100644 index 0000000..a891b9d --- /dev/null +++ b/bcal/bcal_camellia128.c @@ -0,0 +1,52 @@ +/* bcal_camellia128.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_camellia128.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "camellia.h" +#include "keysize_descriptor.h" + +const char camellia128_str[] PROGMEM = "Camellia-128"; + +const uint8_t camellia128_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +const bcdesc_t camellia128_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + camellia128_str, + sizeof(camellia128_ctx_t), + 128, + {(void_fpt)camellia128_init}, + {(void_fpt)camellia128_enc}, + {(void_fpt)camellia128_dec}, + (bc_free_fpt)NULL, + camellia128_keysize_desc +}; + + diff --git a/bcal/bcal_camellia128.h b/bcal/bcal_camellia128.h new file mode 100644 index 0000000..bbe0199 --- /dev/null +++ b/bcal/bcal_camellia128.h @@ -0,0 +1,33 @@ +/* bcal_camellia128.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_camellia128.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "camellia.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t camellia128_desc; diff --git a/bcal/bcal_cast5.c b/bcal/bcal_cast5.c new file mode 100644 index 0000000..bc91297 --- /dev/null +++ b/bcal/bcal_cast5.c @@ -0,0 +1,52 @@ +/* bcal_cast5.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_cast5.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "cast5.h" +#include "keysize_descriptor.h" + +const char cast5_str[] PROGMEM = "CAST5"; + +const uint8_t cast5_keysize_desc[] PROGMEM = { KS_TYPE_RANGE, KS_INT(0), KS_INT(128), + KS_TYPE_TERMINATOR }; + +const bcdesc_t cast5_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + cast5_str, + sizeof(cast5_ctx_t), + 128, + {(void_fpt)cast5_init}, + {(void_fpt)cast5_enc}, + {(void_fpt)cast5_dec}, + (bc_free_fpt)NULL, + cast5_keysize_desc +}; + + diff --git a/bcal/bcal_cast5.h b/bcal/bcal_cast5.h new file mode 100644 index 0000000..2b620ea --- /dev/null +++ b/bcal/bcal_cast5.h @@ -0,0 +1,33 @@ +/* bcal_cast5.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_cast5.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "cast5.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t cast5_desc; diff --git a/bcal/bcal_cast6.c b/bcal/bcal_cast6.c new file mode 100644 index 0000000..7df7825 --- /dev/null +++ b/bcal/bcal_cast6.c @@ -0,0 +1,52 @@ +/* bcal_cast6.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_cast6.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-03 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "cast6.h" +#include "keysize_descriptor.h" + +const char cast6_str[] PROGMEM = "CAST-256"; + +const uint8_t cast6_keysize_desc[] PROGMEM = { KS_TYPE_RANGE, KS_INT(0), KS_INT(256), + KS_TYPE_TERMINATOR }; + +const bcdesc_t cast6_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + cast6_str, + sizeof(cast6_ctx_t), + 128, + {(void_fpt)cast6_init}, + {(void_fpt)cast6_enc}, + {(void_fpt)cast6_dec}, + (bc_free_fpt)NULL, + cast6_keysize_desc +}; + + diff --git a/bcal/bcal_cast6.h b/bcal/bcal_cast6.h new file mode 100644 index 0000000..c327cf6 --- /dev/null +++ b/bcal/bcal_cast6.h @@ -0,0 +1,33 @@ +/* bcal_cast6.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_cast6.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-03 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "cast6.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t cast6_desc; diff --git a/bcal/bcal_des.c b/bcal/bcal_des.c new file mode 100644 index 0000000..04ed5e5 --- /dev/null +++ b/bcal/bcal_des.c @@ -0,0 +1,61 @@ +/* bcal_des.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_des.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +const char des_str[] PROGMEM = "DES"; + +const uint8_t des_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(64), + KS_TYPE_TERMINATOR }; +static +void des_dummy_enc(void* block, void* key){ + des_enc(block, block, key); +} + +static +void des_dummy_dec(void* block, void* key){ + des_dec(block, block, key); +} + +const bcdesc_t des_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + des_str, + 8, + 128, + {(void_fpt)NULL}, + {(void_fpt)des_dummy_enc}, + {(void_fpt)des_dummy_dec}, + (bc_free_fpt)NULL, + des_keysize_desc +}; + + diff --git a/bcal/bcal_des.h b/bcal/bcal_des.h new file mode 100644 index 0000000..84f76d2 --- /dev/null +++ b/bcal/bcal_des.h @@ -0,0 +1,33 @@ +/* bcal_des.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_des.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t des_desc; diff --git a/bcal/bcal_noekeon.c b/bcal/bcal_noekeon.c new file mode 100644 index 0000000..47e1c59 --- /dev/null +++ b/bcal/bcal_noekeon.c @@ -0,0 +1,41 @@ +/* bcal_noekeon.c */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "noekeon/noekeon.h" +#include "keysize_descriptor.h" + +const char noekeon_direct_str[] PROGMEM = "Noekeon-Direct"; +const char noekeon_indirect_str[] PROGMEM = "Noekeon-Indirect"; + +const uint8_t noekeon_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +const bcdesc_t noekeon_direct_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_ENC_TYPE_1, + noekeon_direct_str, + 16, + 128, + {(void_fpt)NULL}, + {(void_fpt)noekeon_enc}, + {(void_fpt)noekeon_dec}, + (bc_free_fpt)NULL, + noekeon_keysize_desc +}; + +const bcdesc_t noekeon_indirect_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1 | BC_ENC_TYPE_1, + noekeon_indirect_str, + 16, + 128, + {(void_fpt)noekeon_init}, + {(void_fpt)noekeon_enc}, + {(void_fpt)noekeon_dec}, + (bc_free_fpt)NULL, + noekeon_keysize_desc +}; + + diff --git a/bcal/bcal_noekeon.h b/bcal/bcal_noekeon.h new file mode 100644 index 0000000..16a8179 --- /dev/null +++ b/bcal/bcal_noekeon.h @@ -0,0 +1,10 @@ +/* bcal_noekeon.h */ + +#include +#include "blockcipher_descriptor.h" +#include "noekeon/noekeon.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t noekeon_direct_desc; +extern const bcdesc_t noekeon_indirect_desc; + diff --git a/bcal/bcal_present.c b/bcal/bcal_present.c new file mode 100644 index 0000000..96842b1 --- /dev/null +++ b/bcal/bcal_present.c @@ -0,0 +1,52 @@ +/* bcal_present.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_present.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "present.h" +#include "keysize_descriptor.h" + +const char present_str[] PROGMEM = "Present"; + +const uint8_t present_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(80), + KS_TYPE_TERMINATOR }; + +const bcdesc_t present_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + present_str, + sizeof(present_ctx_t), + 64, + {(void_fpt)present_init}, + {(void_fpt)present_enc}, + {(void_fpt)present_dec}, + (bc_free_fpt)NULL, + present_keysize_desc +}; + + diff --git a/bcal/bcal_present.h b/bcal/bcal_present.h new file mode 100644 index 0000000..1de8365 --- /dev/null +++ b/bcal/bcal_present.h @@ -0,0 +1,33 @@ +/* bcal_present.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_present.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "present.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t present_desc; diff --git a/bcal/bcal_rc5.c b/bcal/bcal_rc5.c new file mode 100644 index 0000000..9702168 --- /dev/null +++ b/bcal/bcal_rc5.c @@ -0,0 +1,59 @@ +/* bcal_rc5.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_rc5.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "rc5.h" +#include "keysize_descriptor.h" + +#define RC5_ROUNDS 12 + +const char rc5_str[] PROGMEM = "RC5"; + +const uint8_t rc5_keysize_desc[] PROGMEM = { KS_TYPE_RANGE, KS_INT(1), KS_INT(2040), + KS_TYPE_TERMINATOR }; + +static +void rc5_dummy_init(void* key, uint16_t keysize_b, void* ctx){ + rc5_init(key, keysize_b, RC5_ROUNDS, ctx); +} + +const bcdesc_t rc5_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + rc5_str, + sizeof(rc5_ctx_t), + 128, + {(void_fpt)rc5_dummy_init}, + {(void_fpt)rc5_enc}, + {(void_fpt)rc5_dec}, + (bc_free_fpt)rc5_free, + rc5_keysize_desc +}; + + diff --git a/bcal/bcal_rc5.h b/bcal/bcal_rc5.h new file mode 100644 index 0000000..30d2100 --- /dev/null +++ b/bcal/bcal_rc5.h @@ -0,0 +1,33 @@ +/* bcal_rc5.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_rc5.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "rc5.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t rc5_desc; diff --git a/bcal/bcal_rc6.c b/bcal/bcal_rc6.c new file mode 100644 index 0000000..e1b98e1 --- /dev/null +++ b/bcal/bcal_rc6.c @@ -0,0 +1,52 @@ +/* bcal_rc6.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_rc6.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "rc6.h" +#include "keysize_descriptor.h" + +const char rc6_str[] PROGMEM = "RC6"; + +const uint8_t rc6_keysize_desc[] PROGMEM = { KS_TYPE_RANGE, KS_INT(1), KS_INT(2040), + KS_TYPE_TERMINATOR }; + +const bcdesc_t rc6_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + rc6_str, + sizeof(rc6_ctx_t), + 128, + {(void_fpt)rc6_init}, + {(void_fpt)rc6_enc}, + {(void_fpt)rc6_dec}, + (bc_free_fpt)rc6_free, + rc6_keysize_desc +}; + + diff --git a/bcal/bcal_rc6.h b/bcal/bcal_rc6.h new file mode 100644 index 0000000..f6d0d1b --- /dev/null +++ b/bcal/bcal_rc6.h @@ -0,0 +1,33 @@ +/* bcal_rc6.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_rc6.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "rc6.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t rc6_desc; diff --git a/bcal/bcal_seed.c b/bcal/bcal_seed.c new file mode 100644 index 0000000..590f027 --- /dev/null +++ b/bcal/bcal_seed.c @@ -0,0 +1,52 @@ +/* bcal_seed.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_seed.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "seed.h" +#include "keysize_descriptor.h" + +const char seed_str[] PROGMEM = "SEED"; + +const uint8_t seed_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +const bcdesc_t seed_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + seed_str, + sizeof(seed_ctx_t), + 128, + {(void_fpt)seed_init}, + {(void_fpt)seed_enc}, + {(void_fpt)seed_dec}, + (bc_free_fpt)NULL, + seed_keysize_desc +}; + + diff --git a/bcal/bcal_seed.h b/bcal/bcal_seed.h new file mode 100644 index 0000000..a8bdf2c --- /dev/null +++ b/bcal/bcal_seed.h @@ -0,0 +1,33 @@ +/* bcal_seed.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_seed.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "seed.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t seed_desc; diff --git a/bcal/bcal_serpent.c b/bcal/bcal_serpent.c new file mode 100644 index 0000000..df1b578 --- /dev/null +++ b/bcal/bcal_serpent.c @@ -0,0 +1,52 @@ +/* bcal_serpent.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_serpent.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "serpent.h" +#include "keysize_descriptor.h" + +const char serpent_str[] PROGMEM = "serpent"; + +const uint8_t serpent_keysize_desc[] PROGMEM = { KS_TYPE_RANGE, KS_INT(1), KS_INT(256), + KS_TYPE_TERMINATOR }; + +const bcdesc_t serpent_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + serpent_str, + sizeof(serpent_ctx_t), + 128, + {(void_fpt)serpent_init}, + {(void_fpt)serpent_enc}, + {(void_fpt)serpent_dec}, + (bc_free_fpt)NULL, + serpent_keysize_desc +}; + + diff --git a/bcal/bcal_serpent.h b/bcal/bcal_serpent.h new file mode 100644 index 0000000..60fc8cc --- /dev/null +++ b/bcal/bcal_serpent.h @@ -0,0 +1,33 @@ +/* bcal_serpent.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_serpent.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "serpent.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t serpent_desc; diff --git a/bcal/bcal_skipjack.c b/bcal/bcal_skipjack.c new file mode 100644 index 0000000..09caead --- /dev/null +++ b/bcal/bcal_skipjack.c @@ -0,0 +1,52 @@ +/* bcal_skipjack.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_skipjack.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "skipjack.h" +#include "keysize_descriptor.h" + +const char skipjack_str[] PROGMEM = "Skipjack"; + +const uint8_t skipjack_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(80), + KS_TYPE_TERMINATOR }; + +const bcdesc_t skipjack_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + skipjack_str, + 10, + 64, + {(void_fpt)NULL}, + {(void_fpt)skipjack_enc}, + {(void_fpt)skipjack_dec}, + (bc_free_fpt)NULL, + skipjack_keysize_desc +}; + + diff --git a/bcal/bcal_skipjack.h b/bcal/bcal_skipjack.h new file mode 100644 index 0000000..e238141 --- /dev/null +++ b/bcal/bcal_skipjack.h @@ -0,0 +1,33 @@ +/* bcal_skipjack.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_skipjack.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "skipjack.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t skipjack_desc; diff --git a/bcal/bcal_tdes.c b/bcal/bcal_tdes.c new file mode 100644 index 0000000..6a6f49d --- /dev/null +++ b/bcal/bcal_tdes.c @@ -0,0 +1,62 @@ +/* bcal_tdes.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_tdes.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +const char tdes_str[] PROGMEM = "TDES"; + +const uint8_t tdes_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(192), + KS_TYPE_TERMINATOR }; + +static +void tdes_dummy_enc(void* block, void* key){ + tdes_enc(block, block, key); +} + +static +void tdes_dummy_dec(void* block, void* key){ + tdes_dec(block, block, key); +} + +const bcdesc_t tdes_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + tdes_str, + 24, + 64, + {(void_fpt)NULL}, + {(void_fpt)tdes_dummy_enc}, + {(void_fpt)tdes_dummy_dec}, + (bc_free_fpt)NULL, + tdes_keysize_desc +}; + + diff --git a/bcal/bcal_tdes.h b/bcal/bcal_tdes.h new file mode 100644 index 0000000..e2f2b31 --- /dev/null +++ b/bcal/bcal_tdes.h @@ -0,0 +1,33 @@ +/* bcal_tdes.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_tdes.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t tdes_desc; diff --git a/bcal/bcal_tdes2.c b/bcal/bcal_tdes2.c new file mode 100644 index 0000000..d763366 --- /dev/null +++ b/bcal/bcal_tdes2.c @@ -0,0 +1,70 @@ +/* bcal_tdes2.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_tdes.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-02 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +const char tdes2_str[] PROGMEM = "TDES-2"; + +const uint8_t tdes2_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +static +void tdes_dummy_enc(void* block, void* key){ + tdes_enc(block, block, key); +} + +static +void tdes_dummy_dec(void* block, void* key){ + tdes_dec(block, block, key); +} + +static +void tdes2_init(void* key, void* ctx){ + memcpy(ctx, key, 16); + memcpy((uint8_t*)ctx+16, key, 8); +} + + + +const bcdesc_t tdes2_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + tdes2_str, + 24, + 64, + {(void_fpt)tdes2_init}, + {(void_fpt)tdes_dummy_enc}, + {(void_fpt)tdes_dummy_dec}, + (bc_free_fpt)NULL, + tdes2_keysize_desc +}; + + diff --git a/bcal/bcal_tdes2.h b/bcal/bcal_tdes2.h new file mode 100644 index 0000000..4dac992 --- /dev/null +++ b/bcal/bcal_tdes2.h @@ -0,0 +1,38 @@ +/* bcal_tdes2.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_tdes.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#ifndef BCAL_TDES2_H_ +#define BCAL_TDES2_H_ + +#include +#include "blockcipher_descriptor.h" +#include "des.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t tdes2_desc; + +#endif /* BCAL_TDES2_H_ */ diff --git a/bcal/bcal_threefish1024.c b/bcal/bcal_threefish1024.c new file mode 100644 index 0000000..8f1a108 --- /dev/null +++ b/bcal/bcal_threefish1024.c @@ -0,0 +1,56 @@ +/* bcal_threefish1024.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish1024.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +const char threefish1024_str[] PROGMEM = "Threefish-1024"; + +const uint8_t threefish1024_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(1024), + KS_TYPE_TERMINATOR }; + +static void threefish1024_dummy_init(void* key, void* ctx){ + threefish1024_init(key, NULL, ctx); +} + +const bcdesc_t threefish1024_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + threefish1024_str, + sizeof(threefish1024_ctx_t), + 1024, + {(void_fpt)threefish1024_dummy_init}, + {(void_fpt)threefish1024_enc}, + {(void_fpt)threefish1024_dec}, + (bc_free_fpt)NULL, + threefish1024_keysize_desc +}; + + diff --git a/bcal/bcal_threefish1024.h b/bcal/bcal_threefish1024.h new file mode 100644 index 0000000..67c9b3c --- /dev/null +++ b/bcal/bcal_threefish1024.h @@ -0,0 +1,33 @@ +/* bcal_threefis1024.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish1024.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t threefish1024_desc; diff --git a/bcal/bcal_threefish256.c b/bcal/bcal_threefish256.c new file mode 100644 index 0000000..f95f1a2 --- /dev/null +++ b/bcal/bcal_threefish256.c @@ -0,0 +1,56 @@ +/* bcal_threefish256.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish256.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +const char threefish256_str[] PROGMEM = "Threefish-256"; + +const uint8_t threefish256_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(256), + KS_TYPE_TERMINATOR }; + +static void threefish256_dummy_init(void* key, void* ctx){ + threefish256_init(key, NULL, ctx); +} + +const bcdesc_t threefish256_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + threefish256_str, + sizeof(threefish256_ctx_t), + 256, + {(void_fpt)threefish256_dummy_init}, + {(void_fpt)threefish256_enc}, + {(void_fpt)threefish256_dec}, + (bc_free_fpt)NULL, + threefish256_keysize_desc +}; + + diff --git a/bcal/bcal_threefish256.h b/bcal/bcal_threefish256.h new file mode 100644 index 0000000..d2819bf --- /dev/null +++ b/bcal/bcal_threefish256.h @@ -0,0 +1,33 @@ +/* bcal_threefis256.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish256.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t threefish256_desc; diff --git a/bcal/bcal_threefish512.c b/bcal/bcal_threefish512.c new file mode 100644 index 0000000..ff61a74 --- /dev/null +++ b/bcal/bcal_threefish512.c @@ -0,0 +1,56 @@ +/* bcal_threefish512.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish512.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +const char threefish512_str[] PROGMEM = "Threefish-512"; + +const uint8_t threefish512_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(512), + KS_TYPE_TERMINATOR }; + +static void threefish512_dummy_init(void* key, void* ctx){ + threefish512_init(key, NULL, ctx); +} + +const bcdesc_t threefish512_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_1, + threefish512_str, + sizeof(threefish512_ctx_t), + 512, + {(void_fpt)threefish512_dummy_init}, + {(void_fpt)threefish512_enc}, + {(void_fpt)threefish512_dec}, + (bc_free_fpt)NULL, + threefish512_keysize_desc +}; + + diff --git a/bcal/bcal_threefish512.h b/bcal/bcal_threefish512.h new file mode 100644 index 0000000..8f87d65 --- /dev/null +++ b/bcal/bcal_threefish512.h @@ -0,0 +1,33 @@ +/* bcal_threefis512.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_threefish512.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-20 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "threefish.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t threefish512_desc; diff --git a/bcal/bcal_xtea.c b/bcal/bcal_xtea.c new file mode 100644 index 0000000..5902c10 --- /dev/null +++ b/bcal/bcal_xtea.c @@ -0,0 +1,62 @@ +/* bcal_xtea.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_xtea.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "blockcipher_descriptor.h" +#include "xtea.h" +#include "keysize_descriptor.h" + +const char xtea_str[] PROGMEM = "XTEA"; + +const uint8_t xtea_keysize_desc[] PROGMEM = { KS_TYPE_LIST, 1, KS_INT(128), + KS_TYPE_TERMINATOR }; + +static +void xtea_dummy_enc(void* block, void* key){ + xtea_enc(block, block, key); +} + +static +void xtea_dummy_dec(void* block, void* key){ + xtea_dec(block, block, key); +} + +const bcdesc_t xtea_desc PROGMEM = { + BCDESC_TYPE_BLOCKCIPHER, + BC_INIT_TYPE_2, + xtea_str, + 16, + 64, + {(void_fpt)NULL}, + {(void_fpt)xtea_dummy_enc}, + {(void_fpt)xtea_dummy_dec}, + (bc_free_fpt)NULL, + xtea_keysize_desc +}; + + diff --git a/bcal/bcal_xtea.h b/bcal/bcal_xtea.h new file mode 100644 index 0000000..66e6d26 --- /dev/null +++ b/bcal/bcal_xtea.h @@ -0,0 +1,33 @@ +/* bcal_xtea.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file bcal_xtea.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-01-09 + * \license GPLv3 or later + * + */ + +#include +#include "blockcipher_descriptor.h" +#include "xtea.h" +#include "keysize_descriptor.h" + +extern const bcdesc_t xtea_desc; diff --git a/bcal/mov1.sed b/bcal/mov1.sed new file mode 100644 index 0000000..04ce46b --- /dev/null +++ b/bcal/mov1.sed @@ -0,0 +1,3 @@ +sx#include\([^"<]*["<]\)noekeonx#include\1noekeon/noekeonx +sq#include\([^"<]*["<]\)memxorq#include\1memxor/memxorq +sq#include\([^"<]*["<]\)gf256mulq#include\1gf256mul/gf256mulq diff --git a/gf256mul/gf256mul.S b/gf256mul/gf256mul.S new file mode 100644 index 0000000..b269d3a --- /dev/null +++ b/gf256mul/gf256mul.S @@ -0,0 +1,82 @@ +/* gf256mul.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ + +/* + * File: gf256mul.S + * Author: Daniel Otte + * Date: 2008-12-19 + * License: GPLv3 or later + * Description: peasant's algorithm for multiplication in GF(2^8) + * + */ + +#include +#define OPTIMIZE_SMALL_A + +/* + * param a: r24 + * param b: r22 + * param reducer: r20 + */ +A = 23 +B = 22 +P = 24 +.global gf256mul + +#ifdef OPTIMIZE_SMALL_A +gf256mul: + mov A, r24 + clr r24 +1: + lsr A + breq 4f + brcc 2f + eor P, B +2: + lsl B + brcc 3f + eor B, r20 +3: + rjmp 1b +4: + brcc 2f + eor P, B +2: + ret + +#else + +gf256mul: + mov r21, r24 + clr r24 + ldi r25, 8 +1: + lsr A + brcc 2f + eor P, B +2: + lsl B + brcc 3f + eor B, r20 +3: + dec r25 + brne 1b + ret + +#endif diff --git a/gf256mul/gf256mul.h b/gf256mul/gf256mul.h new file mode 100644 index 0000000..87f1cb3 --- /dev/null +++ b/gf256mul/gf256mul.h @@ -0,0 +1,37 @@ +/* gf256mul.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +#ifndef GF256MUL_H_ +#define GF256MUL_H_ + +/** + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-12-19 + * \license GPLv3 + * \brief + * + * + */ + +#include + +uint8_t gf256mul(uint8_t a, uint8_t b, uint8_t reducer); + +#endif /* GF256MUL_H_ */ + diff --git a/hfal/hfal-basic.c b/hfal/hfal-basic.c new file mode 100644 index 0000000..551a8bc --- /dev/null +++ b/hfal/hfal-basic.c @@ -0,0 +1,102 @@ +/* hfal-basic.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#include +#include "hashfunction_descriptor.h" +#include "hfal-basic.h" +#include + +uint8_t hfal_hash_init(const hfdesc_t* hash_descriptor, hfgen_ctx_t* ctx){ + hf_init_fpt f; + uint16_t tmp; + ctx->desc_ptr = (hfdesc_t*)hash_descriptor; + tmp = pgm_read_word(&(hash_descriptor->ctxsize_B)); + if(!(ctx->ctx=malloc(tmp))) + return 3; + f= (hf_init_fpt)pgm_read_word(&(hash_descriptor->init)); + f(ctx->ctx); + return 0; +} + +void hfal_hash_nextBlock(hfgen_ctx_t* ctx, const void* block){ + hf_nextBlock_fpt f; + hfdesc_t* x=(ctx->desc_ptr); + f =(hf_nextBlock_fpt)pgm_read_word(&(x->nextBlock)); + f(ctx->ctx, block); +} + +void hfal_hash_lastBlock(hfgen_ctx_t* ctx, const void* block, uint16_t length_b){ + hf_lastBlock_fpt f; + hfdesc_t* x=ctx->desc_ptr; + f =(hf_lastBlock_fpt)pgm_read_word(&(x->lastBlock)); + f(ctx->ctx, block, length_b); +} + +void hfal_hash_ctx2hash(void* dest, hfgen_ctx_t* ctx){ + hf_ctx2hash_fpt f; + hfdesc_t* x=ctx->desc_ptr; + f =(hf_ctx2hash_fpt)pgm_read_word(&(x->ctx2hash)); + f(dest, ctx->ctx); +} + +void hfal_hash_free(hfgen_ctx_t* ctx){ + hf_free_fpt f; + hfdesc_t* x=ctx->desc_ptr; + f =(hf_free_fpt)pgm_read_word(&(x->free)); + if(f) + f(ctx->ctx); + free(ctx->ctx); +} + +void hfal_hash_mem(const hfdesc_t* hash_descriptor, void* dest, const void* msg, uint32_t length_b){ + void_fpt f; + f = (void_fpt)pgm_read_word(&(hash_descriptor->mem)); + if(f){ + ((hf_mem_fpt)f)(dest, msg, length_b); + }else{ + uint16_t bs,bsb; + uint8_t ctx[pgm_read_word(&(hash_descriptor->ctxsize_B))]; + f=(void_fpt)(pgm_read_word(&(hash_descriptor->init))); + ((hf_init_fpt)f)(ctx); + bs=pgm_read_word(&(hash_descriptor->blocksize_b)); + bsb=bs/8; + f=(void_fpt)(pgm_read_word(&(hash_descriptor->nextBlock))); + while(length_b>bs){ + ((hf_nextBlock_fpt)f)(ctx, msg); + length_b -= bs; + msg = (uint8_t*)msg + bsb; + } + f=(void_fpt)(pgm_read_word(&(hash_descriptor->lastBlock))); + ((hf_lastBlock_fpt)f)(ctx, msg, length_b); + f=(void_fpt)(pgm_read_word(&(hash_descriptor->ctx2hash))); + ((hf_ctx2hash_fpt)f)(dest, ctx); + } +} + +uint16_t hfal_hash_getBlocksize(const hfdesc_t* hash_descriptor){ + uint16_t ret; + ret = pgm_read_word(&(hash_descriptor->blocksize_b)); + return ret; +} + +uint16_t hfal_hash_getHashsize(const hfdesc_t* hash_descriptor){ + uint16_t ret; + ret = pgm_read_word(&(hash_descriptor->hashsize_b)); + return ret; +} diff --git a/hfal/hfal-basic.h b/hfal/hfal-basic.h new file mode 100644 index 0000000..7737e05 --- /dev/null +++ b/hfal/hfal-basic.h @@ -0,0 +1,35 @@ +/* hfal-basic.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#ifndef HFAL_BASIC_H_ +#define HFAL_BASIC_H_ + +#include +#include "hashfunction_descriptor.h" + +uint8_t hfal_hash_init(const hfdesc_t* hash_descriptor, hfgen_ctx_t* ctx); +void hfal_hash_nextBlock(hfgen_ctx_t* ctx, const void* block); +void hfal_hash_lastBlock(hfgen_ctx_t* ctx, const void* block, uint16_t length_b); +void hfal_hash_ctx2hash(void* dest, hfgen_ctx_t* ctx); +void hfal_hash_free(hfgen_ctx_t* ctx); +void hfal_hash_mem(const hfdesc_t* hash_descriptor, void* dest, const void* msg, uint32_t length_b); +uint16_t hfal_hash_getBlocksize(const hfdesc_t* hash_descriptor); +uint16_t hfal_hash_getHashsize(const hfdesc_t* hash_descriptor); + +#endif /* HFAL_BASIC_H_ */ diff --git a/hfal/hfal-hmac.c b/hfal/hfal-hmac.c new file mode 100644 index 0000000..dbc5608 --- /dev/null +++ b/hfal/hfal-hmac.c @@ -0,0 +1,127 @@ +/* hfal-hmac.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#include +#include "hashfunction_descriptor.h" +#include "hfal-basic.h" +#include + +#define IPAD 0x36 +#define OPAD 0x5C + +uint8_t hfal_hmac_init(const hfdesc_t* hash_descriptor, + hfhmacgen_ctx_t* ctx, + const void* key, uint16_t keylength_b){ + uint16_t bs = hfal_hash_getBlocksize(); + uint8_t buffer[bs/8]; + uint8_t i; + hf_init_fpt init; + hf_nextBlock_fpt nextBlock; + memset(buffer, 0, bs/8); + ctx->desc = hash_descriptor; + ctx->ctx = malloc(pgm_read_word(&(hash_descriptor->ctxsize_B))); + ctx->finctx = malloc(pgm_read_word(&(hash_descriptor->ctxsize_B))); + if(ctx->ctx==NULL && ctx->finctx==NULL) + return 3; + if(ctx->finctx==NULL){ + free(ctx->ctx) + return 2; + } + if(ctx->ctx==NULL){ + free(ctx->finctx) + return 1; + } + if(keylength_b>bs){ + hfal_hash_mem(hash_descriptor, buffer, key, keylength_b); + } else { + memcpy(buffer, key, (keylength_b+7)/8); + } + for(i=0; iinit)); + nextBlock = pgm_read_word(&(hash_descriptor->nextBlock)); + init(ctx->ctx); + init(ctx->finctx); + nextBlock(ctx->ctx, buffer); + for(i=0; ifinctx, buffer); + memset(buffer, 0, bs/8); +} + +void hfal_hmac_nextBlock(hfhmacgen_ctx_t* ctx, const void* block){ + hf_nextBlock_fpt nextBlock; + nextBlock = pgm_read_word(&(hash_descriptor->nextBlock)); + nextBlock(ctx->ctx, block); +} + +void hfal_hmac_lastBlock(hfhmacgen_ctx_t* ctx, const void* block, uint16_t length_b){ + hf_lastBlock_fpt lastBlock; + hf_ctx2hash_fpt ctx2hash; + uint16_t hs = pgm_read_word(&(hash_descriptor->hashsize_b)); + uint8_t buffer[(hs+7)/8]; + lastBlock = pgm_read_word(&(hash_descriptor->lastBlock)); + ctx2hash = pgm_read_word(&(hash_descriptor->ctx2hash)); + lastBlock(ctx->ctx, block, length_b); + ctx2hash(buffer, ctx->ctx); + lastBlock(ctx->finctx, buffer, hs); +} + +void hfal_hmac_ctx2mac(void* dest, hfhmacgen_ctx_t* ctx){ + hf_ctx2hash_fpt ctx2hash; + ctx2hash = pgm_read_word(&(hash_descriptor->ctx2hash)); + ctx2hash(dest, ctx->finctx); +} + +void hfal_hmac_free(hfhmacgen_ctx_t* ctx){ + hf_free_fpt free_fpt; + free_fpt = pgm_read_word(&(hash_descriptor->free)); + if(free_fpt){ + free_fpt(ctx->ctx); + free_fpt(ctx->finctx); + } + free(ctx->ctx) + free(ctx->finctx) +} + +void hfal_hmac_mem(const hfdesc_t* hash_descriptor, const void* key, uint16_t keylength_b, void* dest, const void* msg, uint32_t length_b){ + hfhmacgen_ctx_t ctx; + uint16_t bs = hfal_hash_getBlocksize(); + hfal_hmac_init(hash_descriptor, &ctx, key, keylength_b); + while(length_b>bs){ + hfal_hmac_nextBlock(&ctx, msg); + msg = msg + bs/8; + length_b-=bs; + } + hfal_hmac_lastBlock(&ctx, msg, length_b); + hfal_hmac_ctx2mac(dest, &ctx); + hfal_free(&ctx); +} + +uint16_t hfal_hmac_getBlocksize(const hfdesc_t* hash_descriptor){ + return hfal_hash_getBlocksize(hash_descriptor); +} + +uint16_t hfal_hmac_getMACsize(const hfdesc_t* hash_descriptor){ + return hfal_hash_getHashsize(hash_descriptor); +} + + diff --git a/hfal/hfal-hmac.h b/hfal/hfal-hmac.h new file mode 100644 index 0000000..8c9b899 --- /dev/null +++ b/hfal/hfal-hmac.h @@ -0,0 +1,41 @@ +/* hfal-hmac.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ + +#ifndef HFAL_HMAC_H_ +#define HFAL_HMAC_H_ + +#include +#include "hashfunction_descriptor.h" + +typedef struct { + hfdesc_t* desc; + void* ctx; + void* finctx; +} hfhmacgen_ctx_t; + +uint8_t hfal_hmac_init(const hfdesc_t* hash_descriptor, hfhmacgen_ctx_t* ctx, const void* key, uint16_t keylength_b); +void hfal_hmac_nextBlock(hfhmacgen_ctx_t* ctx, const void* block); +void hfal_hmac_lastBlock(hfhmacgen_ctx_t* ctx, const void* block, uint16_t length_b); +void hfal_hmac_ctx2mac(void* dest, hfhmacgen_ctx_t* ctx); +void hfal_hmac_free(hfhmacgen_ctx_t* ctx); +void hfal_hmac_mem(const hfdesc_t* hash_descriptor, const void* key, uint16_t keylength_b, void* dest, const void* msg, uint32_t length_b); +uint16_t hfal_hmac_getBlocksize(const hfdesc_t* hash_descriptor); +uint16_t hfal_hmac_getMACsize(const hfdesc_t* hash_descriptor); + +#endif /* HFAL_HMAC_H_ */ diff --git a/hfal/hfal-nessie.c b/hfal/hfal-nessie.c new file mode 100644 index 0000000..7188d0e --- /dev/null +++ b/hfal/hfal-nessie.c @@ -0,0 +1,61 @@ +/* hfal-nessie.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-nessie.c + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#include "nessie_hash_test.h" +#include "hashfunction_descriptor.h" +#include +#include + +void hfal_nessie(const hfdesc_t* hd){ + if(pgm_read_byte(&(hd->type))!=HFDESC_TYPE_HASHFUNCTION) + return; + char name[1+strlen_P((void*)pgm_read_word(&(hd->name)))]; + strcpy_P(name, (void*)pgm_read_word(&(hd->name))); + + nessie_hash_ctx.hashsize_b = pgm_read_word(&(hd->hashsize_b)); + nessie_hash_ctx.name = name; + nessie_hash_ctx.blocksize_B = pgm_read_word(&(hd->blocksize_b))/8; + nessie_hash_ctx.ctx_size_B = pgm_read_word(&(hd->ctxsize_B)); + nessie_hash_ctx.hash_init = (nessie_hash_init_fpt)pgm_read_word(&(hd->init)); + nessie_hash_ctx.hash_next = (nessie_hash_next_fpt)pgm_read_word(&(hd->nextBlock)); + nessie_hash_ctx.hash_last = (nessie_hash_last_fpt)pgm_read_word(&(hd->lastBlock)); + nessie_hash_ctx.hash_conv = (nessie_hash_conv_fpt)pgm_read_word(&(hd->ctx2hash)); + + nessie_hash_run(); +} + +void hfal_nessie_multiple(const hfdesc_t** hd_list){ + const hfdesc_t* hd; + for(;;){ + hd = (void*)pgm_read_word(hd_list); + if(!hd) + return; + hfal_nessie(hd); + hd_list = (void*)((uint8_t*)hd_list + 2); + } +} + diff --git a/hfal/hfal-nessie.h b/hfal/hfal-nessie.h new file mode 100644 index 0000000..e9be131 --- /dev/null +++ b/hfal/hfal-nessie.h @@ -0,0 +1,36 @@ +/* hfal-nessie.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-nessie.h + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_NESSIE_H_ +#define HFAL_NESSIE_H_ + +#include "hashfunction_descriptor.h" + +void hfal_nessie(const hfdesc_t* hd); +void hfal_nessie_multiple(const hfdesc_t** hd_list); + +#endif /* HFAL_NESSIE_H_ */ diff --git a/hfal/hfal-performance.c b/hfal/hfal-performance.c new file mode 100644 index 0000000..5371f80 --- /dev/null +++ b/hfal/hfal-performance.c @@ -0,0 +1,219 @@ +/* hfal-performance.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-performance.c + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#include "hfal-performance.h" +#include "hashfunction_descriptor.h" +#include "stack_measuring.h" +#include "cli.h" +#include "performance_test.h" +#include +#include +#include +#include + +#define PATTERN_A 0xAA +#define PATTERN_B 0x55 + +static +void printvalue(unsigned long v){ + char str[20]; + int i; + ultoa(v, str, 10); + for(i=0; i<10-strlen(str); ++i){ + cli_putc(' '); + } + cli_putstr(str); +} + +void hfal_performance(const hfdesc_t* hd){ + hfdesc_t hf; + memcpy_P(&hf, hd, sizeof(hfdesc_t)); + uint8_t ctx[hf.ctxsize_B]; + uint8_t data[(hf.blocksize_b+7)/8]; + uint8_t digest[(hf.hashsize_b+7)/8]; + uint64_t t; + uint8_t i; + + if(hf.type!=HFDESC_TYPE_HASHFUNCTION) + return; + calibrateTimer(); + print_overhead(); + cli_putstr_P(PSTR("\r\n\r\n === ")); + cli_putstr_P(hf.name); + cli_putstr_P(PSTR(" performance === " + "\r\n type: hashfunction" + "\r\n hashsize (bits): ")); + printvalue(hf.hashsize_b); + + cli_putstr_P(PSTR("\r\n ctxsize (bytes): ")); + printvalue(hf.ctxsize_B); + + cli_putstr_P(PSTR("\r\n blocksize (bits): ")); + printvalue(hf.blocksize_b); + + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + hf.init(&ctx); + STOP_TIMER; + t += stopTimer(); + if(i!=31 && hf.free){ + hf.free(&ctx); + } + } + t>>=5; + cli_putstr_P(PSTR("\r\n init (cycles): ")); + printvalue(t); + + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + hf.nextBlock(&ctx, data); + STOP_TIMER; + t += stopTimer(); + } + t>>=5; + cli_putstr_P(PSTR("\r\n nextBlock (cycles): ")); + printvalue(t); + + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + hf.lastBlock(&ctx, data, 0); + STOP_TIMER; + t += stopTimer(); + } + t>>=5; + cli_putstr_P(PSTR("\r\n lastBlock (cycles): ")); + printvalue(t); + + t=0; + for(i=0; i<32; ++i){ + startTimer(0); + START_TIMER; + hf.ctx2hash(digest, &ctx); + STOP_TIMER; + t += stopTimer(); + } + t>>=5; + cli_putstr_P(PSTR("\r\n ctx2hash (cycles): ")); + printvalue(t); + + if(hf.free){ + hf.free(&ctx); + } +} + +void hfal_stacksize(const hfdesc_t* hd){ + hfdesc_t hf; + stack_measuring_ctx_t smctx; + memcpy_P(&hf, hd, sizeof(hfdesc_t)); + uint8_t ctx[hf.ctxsize_B]; + uint8_t data[(hf.blocksize_b+7)/8]; + uint8_t digest[(hf.hashsize_b+7)/8]; + uint16_t t1, t2; + + if(hf.type!=HFDESC_TYPE_HASHFUNCTION) + return; + cli_putstr_P(PSTR("\r\n\r\n === ")); + cli_putstr_P(hf.name); + cli_putstr_P(PSTR(" stack-usage === ")); + + cli(); + stack_measure_init(&smctx, PATTERN_A); + hf.init(&ctx); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + hf.init(&ctx); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n init (bytes): ")); + printvalue((unsigned long)t1); + + cli(); + stack_measure_init(&smctx, PATTERN_A); + hf.nextBlock(&ctx, data); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + hf.nextBlock(&ctx, data); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n nextBlock (bytes): ")); + printvalue((unsigned long)t1); + + cli(); + stack_measure_init(&smctx, PATTERN_A); + hf.lastBlock(&ctx, data, 0); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + hf.lastBlock(&ctx, data, 0); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n lastBlock (bytes): ")); + printvalue((unsigned long)t1); + + cli(); + stack_measure_init(&smctx, PATTERN_A); + hf.ctx2hash(digest, &ctx); + t1 = stack_measure_final(&smctx); + stack_measure_init(&smctx, PATTERN_B); + hf.ctx2hash(digest, &ctx); + t2 = stack_measure_final(&smctx); + sei(); + + t1 = (t1>t2)?t1:t2; + cli_putstr_P(PSTR("\r\n ctx2hash (bytes): ")); + printvalue((unsigned long)t1); + + if(hf.free){ + hf.free(&ctx); + } +} + +void hfal_performance_multiple(const hfdesc_t** hd_list){ + const hfdesc_t* hd; + for(;;){ + hd = (void*)pgm_read_word(hd_list); + if(!hd){ + cli_putstr_P(PSTR("\r\n\r\n End of performance figures\r\n")); + return; + } + hfal_performance(hd); + hfal_stacksize(hd); + hd_list = (void*)((uint8_t*)hd_list + 2); + } +} + diff --git a/hfal/hfal-performance.h b/hfal/hfal-performance.h new file mode 100644 index 0000000..65b0473 --- /dev/null +++ b/hfal/hfal-performance.h @@ -0,0 +1,35 @@ +/* hfal-performance.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-performance.h + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_PERFORMANCE_H_ +#define HFAL_PERFORMANCE_H_ + +#include "hashfunction_descriptor.h" + +void hfal_performance(const hfdesc_t* hd); +void hfal_performance_multiple(const hfdesc_t** hd_list); +#endif /* HFAL_PERFORMANCE_H_ */ diff --git a/hfal/hfal-test.c b/hfal/hfal-test.c new file mode 100644 index 0000000..9efce38 --- /dev/null +++ b/hfal/hfal-test.c @@ -0,0 +1,49 @@ +/* hfal-test.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-test.c + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#include "hfal-basic.h" +#include "hashfunction_descriptor.h" +#include "cli.h" +#include +#include + +void hfal_test(const hfdesc_t* hd, void* msg, uint32_t length_b){ + if(pgm_read_byte(&(hd->type))!=HFDESC_TYPE_HASHFUNCTION) + return; + uint16_t dlen = (pgm_read_word(&(hd->hashsize_b))+7)/8; + uint8_t digest[dlen]; + cli_putstr_P(PSTR("\r\n=== ")); + cli_putstr_P((void*)pgm_read_word(&(hd->name))); + cli_putstr_P(PSTR(" ===\r\n message:")); + cli_hexdump_block(msg, (length_b+7)/8, 4, 16); + hfal_hash_mem(hd, digest, msg, length_b); + cli_putstr_P(PSTR(" \r\n digest:")); + cli_hexdump_block(digest, dlen, 4, 16); + cli_putstr_P(PSTR("\r\n")); +} + + diff --git a/hfal/hfal-test.h b/hfal/hfal-test.h new file mode 100644 index 0000000..ac43338 --- /dev/null +++ b/hfal/hfal-test.h @@ -0,0 +1,36 @@ +/* hfal-test.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/* + * \file hfal-test.h + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-05-10 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_TEST_H_ +#define HFAL_TEST_H_ + +#include "hashfunction_descriptor.h" +#include + +void hfal_test(const hfdesc_t* hd, void* msg, uint32_t length_b); + +#endif /* HFAL_TEST_H_ */ diff --git a/hfal/hfal_blake_large.c b/hfal/hfal_blake_large.c new file mode 100644 index 0000000..f9f8180 --- /dev/null +++ b/hfal/hfal_blake_large.c @@ -0,0 +1,67 @@ +/* hfal_blake_large.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_blake_large.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-08 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "blake_large.h" + + +static const char blake48_str[] PROGMEM = "Blake-48"; +static const char blake64_str[] PROGMEM = "Blake-64"; + +const hfdesc_t blake48_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + blake48_str, + sizeof(blake48_ctx_t), + BLAKE48_BLOCKSIZE, + 384, + (hf_init_fpt)blake48_init, + (hf_nextBlock_fpt)blake_large_nextBlock, + (hf_lastBlock_fpt)blake_large_lastBlock, + (hf_ctx2hash_fpt)blake48_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)blake48 +}; + +const hfdesc_t blake64_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + blake64_str, + sizeof(blake64_ctx_t), + BLAKE64_BLOCKSIZE, + 512, + (hf_init_fpt)blake64_init, + (hf_nextBlock_fpt)blake_large_nextBlock, + (hf_lastBlock_fpt)blake_large_lastBlock, + (hf_ctx2hash_fpt)blake64_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)blake64 +}; + + diff --git a/hfal/hfal_blake_large.h b/hfal/hfal_blake_large.h new file mode 100644 index 0000000..e894689 --- /dev/null +++ b/hfal/hfal_blake_large.h @@ -0,0 +1,37 @@ +/* hfal_blake_large.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_blake_large.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-08 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_BLAKE_LARGE_H_ +#define HFAL_BLAKE_LARGE_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t blake48_desc; +extern const hfdesc_t blake64_desc; + +#endif /* HFAL_BLAKE_LARGE_H_ */ diff --git a/hfal/hfal_blake_small.c b/hfal/hfal_blake_small.c new file mode 100644 index 0000000..1d890f6 --- /dev/null +++ b/hfal/hfal_blake_small.c @@ -0,0 +1,67 @@ +/* hfal_blake_small.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/** + * \file hfal_blake_small.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-05 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "blake_small.h" + + +static const char blake28_str[] PROGMEM = "Blake-28"; +static const char blake32_str[] PROGMEM = "Blake-32"; + +const hfdesc_t blake28_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + blake28_str, + sizeof(blake28_ctx_t), + BLAKE28_BLOCKSIZE, + 224, + (hf_init_fpt)blake28_init, + (hf_nextBlock_fpt)blake_small_nextBlock, + (hf_lastBlock_fpt)blake_small_lastBlock, + (hf_ctx2hash_fpt)blake28_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)blake28 +}; + +const hfdesc_t blake32_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + blake32_str, + sizeof(blake32_ctx_t), + BLAKE32_BLOCKSIZE, + 256, + (hf_init_fpt)blake32_init, + (hf_nextBlock_fpt)blake_small_nextBlock, + (hf_lastBlock_fpt)blake_small_lastBlock, + (hf_ctx2hash_fpt)blake32_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)blake32 +}; + + diff --git a/hfal/hfal_blake_small.h b/hfal/hfal_blake_small.h new file mode 100644 index 0000000..70c8b83 --- /dev/null +++ b/hfal/hfal_blake_small.h @@ -0,0 +1,37 @@ +/* hfal_blake_small.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_blake_small.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-05 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_BLAKE_SMALL_H_ +#define HFAL_BLAKE_SMALL_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t blake28_desc; +extern const hfdesc_t blake32_desc; + +#endif /* HFAL_BLAKE_SMALL_H_ */ diff --git a/hfal/hfal_bmw_large.c b/hfal/hfal_bmw_large.c new file mode 100644 index 0000000..7497362 --- /dev/null +++ b/hfal/hfal_bmw_large.c @@ -0,0 +1,67 @@ +/* hfal_bmw_large.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_bmw_large.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-28 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "bmw_large.h" + + +static const char bmw384_str[] PROGMEM = "BlueMidnightWish-384"; +static const char bmw512_str[] PROGMEM = "BlueMidnightWish-512"; + +const hfdesc_t bmw384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + bmw384_str, + sizeof(bmw384_ctx_t), + BMW384_BLOCKSIZE, + 384, + (hf_init_fpt)bmw384_init, + (hf_nextBlock_fpt)bmw384_nextBlock, + (hf_lastBlock_fpt)bmw384_lastBlock, + (hf_ctx2hash_fpt)bmw384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)bmw384 +}; + +const hfdesc_t bmw512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + bmw512_str, + sizeof(bmw512_ctx_t), + BMW512_BLOCKSIZE, + 512, + (hf_init_fpt)bmw512_init, + (hf_nextBlock_fpt)bmw512_nextBlock, + (hf_lastBlock_fpt)bmw512_lastBlock, + (hf_ctx2hash_fpt)bmw512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)bmw512 +}; + + diff --git a/hfal/hfal_bmw_large.h b/hfal/hfal_bmw_large.h new file mode 100644 index 0000000..667087e --- /dev/null +++ b/hfal/hfal_bmw_large.h @@ -0,0 +1,37 @@ +/* hfal_bmw_large.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_bmw_large.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-28 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_BMW_LARGE_H_ +#define HFAL_BMW_LARGE_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t bmw384_desc; +extern const hfdesc_t bmw512_desc; + +#endif /* HFAL_BMW_LARGE_H_ */ diff --git a/hfal/hfal_bmw_small.c b/hfal/hfal_bmw_small.c new file mode 100644 index 0000000..e87b239 --- /dev/null +++ b/hfal/hfal_bmw_small.c @@ -0,0 +1,67 @@ +/* hfal_bmw_small.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_bmw_small.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-28 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "bmw_small.h" + + +static const char bmw224_str[] PROGMEM = "BlueMidnightWish-224"; +static const char bmw256_str[] PROGMEM = "BlueMidnightWish-256"; + +const hfdesc_t bmw224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + bmw224_str, + sizeof(bmw224_ctx_t), + BMW224_BLOCKSIZE, + 224, + (hf_init_fpt)bmw224_init, + (hf_nextBlock_fpt)bmw224_nextBlock, + (hf_lastBlock_fpt)bmw224_lastBlock, + (hf_ctx2hash_fpt)bmw224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)bmw224 +}; + +const hfdesc_t bmw256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + bmw256_str, + sizeof(bmw256_ctx_t), + BMW256_BLOCKSIZE, + 256, + (hf_init_fpt)bmw256_init, + (hf_nextBlock_fpt)bmw256_nextBlock, + (hf_lastBlock_fpt)bmw256_lastBlock, + (hf_ctx2hash_fpt)bmw256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)bmw256 +}; + + diff --git a/hfal/hfal_bmw_small.h b/hfal/hfal_bmw_small.h new file mode 100644 index 0000000..1ca350e --- /dev/null +++ b/hfal/hfal_bmw_small.h @@ -0,0 +1,37 @@ +/* hfal_bmw_small.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_bmw_small.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-28 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_BMW_SMALL_H_ +#define HFAL_BMW_SMALL_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t bmw224_desc; +extern const hfdesc_t bmw256_desc; + +#endif /* HFAL_BMW_SMALL_H_ */ diff --git a/hfal/hfal_cubehash.c b/hfal/hfal_cubehash.c new file mode 100644 index 0000000..f393cec --- /dev/null +++ b/hfal/hfal_cubehash.c @@ -0,0 +1,99 @@ +/* hfal_cubehash.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ +/** + * \file hfal_cubehash.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "cubehash.h" + + +static const char cubehash224_str[] PROGMEM = "CubeHash-224"; +static const char cubehash256_str[] PROGMEM = "CubeHash-256"; +static const char cubehash384_str[] PROGMEM = "CubeHash-384"; +static const char cubehash512_str[] PROGMEM = "CubeHash-512"; + +const hfdesc_t cubehash224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + cubehash224_str, + sizeof(cubehash_ctx_t), + CUBEHASH224_BLOCKSIZE, + 224, + (hf_init_fpt)cubehash224_init, + (hf_nextBlock_fpt)cubehash_nextBlock, + (hf_lastBlock_fpt)cubehash_lastBlock, + (hf_ctx2hash_fpt)cubehash224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t cubehash256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + cubehash256_str, + sizeof(cubehash_ctx_t), + CUBEHASH256_BLOCKSIZE, + 256, + (hf_init_fpt)cubehash256_init, + (hf_nextBlock_fpt)cubehash_nextBlock, + (hf_lastBlock_fpt)cubehash_lastBlock, + (hf_ctx2hash_fpt)cubehash256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t cubehash384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + cubehash384_str, + sizeof(cubehash_ctx_t), + CUBEHASH384_BLOCKSIZE, + 384, + (hf_init_fpt)cubehash384_init, + (hf_nextBlock_fpt)cubehash_nextBlock, + (hf_lastBlock_fpt)cubehash_lastBlock, + (hf_ctx2hash_fpt)cubehash384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t cubehash512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + cubehash512_str, + sizeof(cubehash_ctx_t), + CUBEHASH512_BLOCKSIZE, + 512, + (hf_init_fpt)cubehash512_init, + (hf_nextBlock_fpt)cubehash_nextBlock, + (hf_lastBlock_fpt)cubehash_lastBlock, + (hf_ctx2hash_fpt)cubehash512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + + diff --git a/hfal/hfal_cubehash.h b/hfal/hfal_cubehash.h new file mode 100644 index 0000000..cd46625 --- /dev/null +++ b/hfal/hfal_cubehash.h @@ -0,0 +1,32 @@ +/* hfal_cubehash.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef HFAL_CUBEHASH_H_ +#define HFAL_CUBEHASH_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t cubehash224_desc; +extern const hfdesc_t cubehash256_desc; +extern const hfdesc_t cubehash384_desc; +extern const hfdesc_t cubehash512_desc; + + +#endif /* HFAL_CUBEHASH_H_ */ diff --git a/hfal/hfal_echo.c b/hfal/hfal_echo.c new file mode 100644 index 0000000..008b688 --- /dev/null +++ b/hfal/hfal_echo.c @@ -0,0 +1,99 @@ +/* hfal_echo.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ +/** + * \file hfal_echo.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-21 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "echo.h" + + +static const char echo224_str[] PROGMEM = "ECHO-224"; +static const char echo256_str[] PROGMEM = "ECHO-256"; +static const char echo384_str[] PROGMEM = "ECHO-384"; +static const char echo512_str[] PROGMEM = "ECHO-512"; + +const hfdesc_t echo224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + echo224_str, + sizeof(echo_small_ctx_t), + ECHO224_BLOCKSIZE, + 224, + (hf_init_fpt)echo224_init, + (hf_nextBlock_fpt)echo_small_nextBlock, + (hf_lastBlock_fpt)echo_small_lastBlock, + (hf_ctx2hash_fpt)echo224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t echo256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + echo256_str, + sizeof(echo_small_ctx_t), + ECHO256_BLOCKSIZE, + 256, + (hf_init_fpt)echo256_init, + (hf_nextBlock_fpt)echo_small_nextBlock, + (hf_lastBlock_fpt)echo_small_lastBlock, + (hf_ctx2hash_fpt)echo256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t echo384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + echo384_str, + sizeof(echo_large_ctx_t), + ECHO384_BLOCKSIZE, + 384, + (hf_init_fpt)echo384_init, + (hf_nextBlock_fpt)echo_large_nextBlock, + (hf_lastBlock_fpt)echo_large_lastBlock, + (hf_ctx2hash_fpt)echo384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t echo512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + echo512_str, + sizeof(echo_large_ctx_t), + ECHO512_BLOCKSIZE, + 512, + (hf_init_fpt)echo512_init, + (hf_nextBlock_fpt)echo_large_nextBlock, + (hf_lastBlock_fpt)echo_large_lastBlock, + (hf_ctx2hash_fpt)echo512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + + diff --git a/hfal/hfal_echo.h b/hfal/hfal_echo.h new file mode 100644 index 0000000..1e5fa31 --- /dev/null +++ b/hfal/hfal_echo.h @@ -0,0 +1,31 @@ +/* hfal_echo.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2010 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 . +*/ + +#ifndef HFAL_ECHO_H_ +#define HFAL_ECHO_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t echo224_desc; +extern const hfdesc_t echo256_desc; +extern const hfdesc_t echo384_desc; +extern const hfdesc_t echo512_desc; + +#endif /* HFAL_ECHO_H_ */ diff --git a/hfal/hfal_groestl_large.c b/hfal/hfal_groestl_large.c new file mode 100644 index 0000000..c8d9acb --- /dev/null +++ b/hfal/hfal_groestl_large.c @@ -0,0 +1,67 @@ +/* hfal_groestl_large.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/** + * \file hfal_groestl_large.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-05 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "groestl_large.h" +#include "groestl_small.h" + + +static const char groestl384_str[] PROGMEM = "Groestl-384"; +static const char groestl512_str[] PROGMEM = "Groestl-512"; + +const hfdesc_t groestl384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + groestl384_str, + sizeof(groestl384_ctx_t), + GROESTL384_BLOCKSIZE, + 384, + (hf_init_fpt)groestl384_init, + (hf_nextBlock_fpt)groestl_large_nextBlock, + (hf_lastBlock_fpt)groestl_large_lastBlock, + (hf_ctx2hash_fpt)groestl384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)groestl384 +}; + +const hfdesc_t groestl512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + groestl512_str, + sizeof(groestl512_ctx_t), + GROESTL512_BLOCKSIZE, + 512, + (hf_init_fpt)groestl512_init, + (hf_nextBlock_fpt)groestl_large_nextBlock, + (hf_lastBlock_fpt)groestl_large_lastBlock, + (hf_ctx2hash_fpt)groestl512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)groestl512 +}; + diff --git a/hfal/hfal_groestl_large.h b/hfal/hfal_groestl_large.h new file mode 100644 index 0000000..6b50db1 --- /dev/null +++ b/hfal/hfal_groestl_large.h @@ -0,0 +1,37 @@ +/* hfal_groestl_large.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_groestl_large.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-06-11 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_GROESTL_LARGE_H_ +#define HFAL_GROESTL_LARGE_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t groestl384_desc; +extern const hfdesc_t groestl512_desc; + +#endif /* HFAL_GROESTL_LARGE_H_ */ diff --git a/hfal/hfal_groestl_small.c b/hfal/hfal_groestl_small.c new file mode 100644 index 0000000..27dbf57 --- /dev/null +++ b/hfal/hfal_groestl_small.c @@ -0,0 +1,67 @@ +/* hfal_groestl_small.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2009 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 . +*/ +/** + * \file hfal_groestl_small.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-05 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "groestl_small.h" + + +static const char groestl224_str[] PROGMEM = "Groestl-224"; +static const char groestl256_str[] PROGMEM = "Groestl-256"; + +const hfdesc_t groestl224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + groestl224_str, + sizeof(groestl224_ctx_t), + GROESTL224_BLOCKSIZE, + 224, + (hf_init_fpt)groestl224_init, + (hf_nextBlock_fpt)groestl_small_nextBlock, + (hf_lastBlock_fpt)groestl_small_lastBlock, + (hf_ctx2hash_fpt)groestl224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)groestl224 +}; + +const hfdesc_t groestl256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + groestl256_str, + sizeof(groestl256_ctx_t), + GROESTL256_BLOCKSIZE, + 256, + (hf_init_fpt)groestl256_init, + (hf_nextBlock_fpt)groestl_small_nextBlock, + (hf_lastBlock_fpt)groestl_small_lastBlock, + (hf_ctx2hash_fpt)groestl256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)groestl256 +}; + + diff --git a/hfal/hfal_groestl_small.h b/hfal/hfal_groestl_small.h new file mode 100644 index 0000000..deb7796 --- /dev/null +++ b/hfal/hfal_groestl_small.h @@ -0,0 +1,37 @@ +/* hfal_groestl_small.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_groestl_small.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-05-05 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_GROESTL_SMALL_H_ +#define HFAL_GROESTL_SMALL_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t groestl224_desc; +extern const hfdesc_t groestl256_desc; + +#endif /* HFAL_GROESTL_SMALL_H_ */ diff --git a/hfal/hfal_keccak.c b/hfal/hfal_keccak.c new file mode 100644 index 0000000..2f50bbb --- /dev/null +++ b/hfal/hfal_keccak.c @@ -0,0 +1,99 @@ +/* hfal_keccak.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_keccak.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "keccak.h" + + +static const char keccak224_str[] PROGMEM = "Keccak-224"; +static const char keccak256_str[] PROGMEM = "Keccak-256"; +static const char keccak384_str[] PROGMEM = "Keccak-384"; +static const char keccak512_str[] PROGMEM = "Keccak-512"; + +const hfdesc_t keccak224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + keccak224_str, + sizeof(keccak_ctx_t), + KECCAK224_BLOCKSIZE, + 224, + (hf_init_fpt)keccak224_init, + (hf_nextBlock_fpt)keccak_nextBlock, + (hf_lastBlock_fpt)keccak_lastBlock, + (hf_ctx2hash_fpt)keccak224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t keccak256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + keccak256_str, + sizeof(keccak_ctx_t), + KECCAK256_BLOCKSIZE, + 256, + (hf_init_fpt)keccak256_init, + (hf_nextBlock_fpt)keccak_nextBlock, + (hf_lastBlock_fpt)keccak_lastBlock, + (hf_ctx2hash_fpt)keccak256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t keccak384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + keccak384_str, + sizeof(keccak_ctx_t), + KECCAK384_BLOCKSIZE, + 384, + (hf_init_fpt)keccak384_init, + (hf_nextBlock_fpt)keccak_nextBlock, + (hf_lastBlock_fpt)keccak_lastBlock, + (hf_ctx2hash_fpt)keccak384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + +const hfdesc_t keccak512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + keccak512_str, + sizeof(keccak_ctx_t), + KECCAK512_BLOCKSIZE, + 512, + (hf_init_fpt)keccak512_init, + (hf_nextBlock_fpt)keccak_nextBlock, + (hf_lastBlock_fpt)keccak_lastBlock, + (hf_ctx2hash_fpt)keccak512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + + diff --git a/hfal/hfal_keccak.h b/hfal/hfal_keccak.h new file mode 100644 index 0000000..662c6e3 --- /dev/null +++ b/hfal/hfal_keccak.h @@ -0,0 +1,39 @@ +/* hfal_keccak.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_keccak.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2010-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_KECCAK_H_ +#define HFAL_KECCAK_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t keccak224_desc; +extern const hfdesc_t keccak256_desc; +extern const hfdesc_t keccak384_desc; +extern const hfdesc_t keccak512_desc; + +#endif /* HFAL_KECCAK_H_ */ diff --git a/hfal/hfal_md5.c b/hfal/hfal_md5.c new file mode 100644 index 0000000..0ccee60 --- /dev/null +++ b/hfal/hfal_md5.c @@ -0,0 +1,49 @@ +/* hfal_md5.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_md5.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "md5.h" + +static const char md5_str[] PROGMEM = "MD5"; + +const hfdesc_t md5_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + md5_str, + sizeof(md5_ctx_t), + 512, + 128, + (hf_init_fpt)md5_init, + (hf_nextBlock_fpt)md5_nextBlock, + (hf_lastBlock_fpt)md5_lastBlock, + (hf_ctx2hash_fpt)md5_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)md5 +}; + diff --git a/hfal/hfal_md5.h b/hfal/hfal_md5.h new file mode 100644 index 0000000..1c4d529 --- /dev/null +++ b/hfal/hfal_md5.h @@ -0,0 +1,36 @@ +/* hfal_md5.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_md5.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_MD5_H_ +#define HFAL_MD5_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t md5_desc; + +#endif /* HFAL_MD5_H_ */ diff --git a/hfal/hfal_sha1.c b/hfal/hfal_sha1.c new file mode 100644 index 0000000..26128ee --- /dev/null +++ b/hfal/hfal_sha1.c @@ -0,0 +1,49 @@ +/* hfal_sha1.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_sha1.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-04 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "sha1/sha1.h" + +static const char sha1_str[] PROGMEM = "SHA-1"; + +const hfdesc_t sha1_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + sha1_str, + sizeof(sha1_ctx_t), + 512, + 160, + (hf_init_fpt)sha1_init, + (hf_nextBlock_fpt)sha1_nextBlock, + (hf_lastBlock_fpt)sha1_lastBlock, + (hf_ctx2hash_fpt)sha1_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)sha1 +}; + diff --git a/hfal/hfal_sha1.h b/hfal/hfal_sha1.h new file mode 100644 index 0000000..d39e460 --- /dev/null +++ b/hfal/hfal_sha1.h @@ -0,0 +1,36 @@ +/* hfal_sha1.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_sha1.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-04 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SHA1_H_ +#define HFAL_SHA1_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t sha1_desc; + +#endif /* HFAL_SHA1_H_ */ diff --git a/hfal/hfal_sha256.c b/hfal/hfal_sha256.c new file mode 100644 index 0000000..0ae65c4 --- /dev/null +++ b/hfal/hfal_sha256.c @@ -0,0 +1,49 @@ +/* hfal_sha256.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_sha256.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-04 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "sha256.h" + +static const char sha256_str[] PROGMEM = "SHA-256"; + +const hfdesc_t sha256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + sha256_str, + sizeof(sha256_ctx_t), + 512, + 256, + (hf_init_fpt)sha256_init, + (hf_nextBlock_fpt)sha256_nextBlock, + (hf_lastBlock_fpt)sha256_lastBlock, + (hf_ctx2hash_fpt)sha256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)sha256 +}; + diff --git a/hfal/hfal_sha256.h b/hfal/hfal_sha256.h new file mode 100644 index 0000000..bf308a5 --- /dev/null +++ b/hfal/hfal_sha256.h @@ -0,0 +1,36 @@ +/* hfal_sha256.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_sha256.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-04 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SHA256_H_ +#define HFAL_SHA256_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t sha256_desc; + +#endif /* HFAL_SHA256_H_ */ diff --git a/hfal/hfal_shabal.c b/hfal/hfal_shabal.c new file mode 100644 index 0000000..bacce62 --- /dev/null +++ b/hfal/hfal_shabal.c @@ -0,0 +1,113 @@ +/* hfal_shabal.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_shabal.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-20 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "shabal.h" + + +static const char shabal192_str[] PROGMEM = "Shabal-192"; +static const char shabal224_str[] PROGMEM = "Shabal-224"; +static const char shabal256_str[] PROGMEM = "Shabal-256"; +static const char shabal384_str[] PROGMEM = "Shabal-384"; +static const char shabal512_str[] PROGMEM = "Shabal-512"; + +const hfdesc_t shabal192_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + shabal192_str, + sizeof(shabal_ctx_t), + SHABAL_BLOCKSIZE, + 192, + (hf_init_fpt)shabal192_init, + (hf_nextBlock_fpt)shabal_nextBlock, + (hf_lastBlock_fpt)shabal_lastBlock, + (hf_ctx2hash_fpt)shabal192_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)shabal192 +}; + +const hfdesc_t shabal224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + shabal224_str, + sizeof(shabal_ctx_t), + SHABAL_BLOCKSIZE, + 224, + (hf_init_fpt)shabal224_init, + (hf_nextBlock_fpt)shabal_nextBlock, + (hf_lastBlock_fpt)shabal_lastBlock, + (hf_ctx2hash_fpt)shabal224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)shabal224 +}; + +const hfdesc_t shabal256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + shabal256_str, + sizeof(shabal_ctx_t), + SHABAL_BLOCKSIZE, + 256, + (hf_init_fpt)shabal256_init, + (hf_nextBlock_fpt)shabal_nextBlock, + (hf_lastBlock_fpt)shabal_lastBlock, + (hf_ctx2hash_fpt)shabal256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)shabal256 +}; + +const hfdesc_t shabal384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + shabal384_str, + sizeof(shabal_ctx_t), + SHABAL_BLOCKSIZE, + 384, + (hf_init_fpt)shabal384_init, + (hf_nextBlock_fpt)shabal_nextBlock, + (hf_lastBlock_fpt)shabal_lastBlock, + (hf_ctx2hash_fpt)shabal384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)shabal384 +}; + +const hfdesc_t shabal512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + shabal512_str, + sizeof(shabal_ctx_t), + SHABAL_BLOCKSIZE, + 512, + (hf_init_fpt)shabal512_init, + (hf_nextBlock_fpt)shabal_nextBlock, + (hf_lastBlock_fpt)shabal_lastBlock, + (hf_ctx2hash_fpt)shabal512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)shabal512 +}; diff --git a/hfal/hfal_shabal.h b/hfal/hfal_shabal.h new file mode 100644 index 0000000..6299519 --- /dev/null +++ b/hfal/hfal_shabal.h @@ -0,0 +1,40 @@ +/* hfal_shabal.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_shabal.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-04-20 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SHABAL_H_ +#define HFAL_SHABAL_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t shabal192_desc; +extern const hfdesc_t shabal224_desc; +extern const hfdesc_t shabal256_desc; +extern const hfdesc_t shabal384_desc; +extern const hfdesc_t shabal512_desc; + +#endif /* HFAL_SHABAL_H_ */ diff --git a/hfal/hfal_skein1024.c b/hfal/hfal_skein1024.c new file mode 100644 index 0000000..485bed5 --- /dev/null +++ b/hfal/hfal_skein1024.c @@ -0,0 +1,162 @@ +/* hfal_skein1024.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein1024.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "skein.h" + + +static const char skein1024_128_str[] PROGMEM = "Skein-1024-128"; +static const char skein1024_160_str[] PROGMEM = "Skein-1024-160"; +static const char skein1024_224_str[] PROGMEM = "Skein-1024-224"; +static const char skein1024_256_str[] PROGMEM = "Skein-1024-256"; +static const char skein1024_384_str[] PROGMEM = "Skein-1024-384"; +static const char skein1024_512_str[] PROGMEM = "Skein-1024-512"; +static const char skein1024_1024_str[] PROGMEM = "Skein-1024-1024"; + +void skein1024_128_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 128); +} +void skein1024_160_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 160); +} +void skein1024_224_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 224); +} +void skein1024_256_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 256); +} +void skein1024_384_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 384); +} +void skein1024_512_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 512); +} +void skein1024_1024_init(skein1024_ctx_t* ctx){ + skein1024_init(ctx, 1024); +} + +const hfdesc_t skein1024_128_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_128_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 128, + (hf_init_fpt)skein1024_128_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_160_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_160_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 160, + (hf_init_fpt)skein1024_160_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_224_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 224, + (hf_init_fpt)skein1024_224_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_256_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 256, + (hf_init_fpt)skein1024_256_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_384_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 384, + (hf_init_fpt)skein1024_384_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_512_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 512, + (hf_init_fpt)skein1024_512_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein1024_1024_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein1024_1024_str, + sizeof(skein1024_ctx_t), + SKEIN1024_BLOCKSIZE, + 1024, + (hf_init_fpt)skein1024_1024_init, + (hf_nextBlock_fpt)skein1024_nextBlock, + (hf_lastBlock_fpt)skein1024_lastBlock, + (hf_ctx2hash_fpt)skein1024_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + diff --git a/hfal/hfal_skein1024.h b/hfal/hfal_skein1024.h new file mode 100644 index 0000000..e2ce083 --- /dev/null +++ b/hfal/hfal_skein1024.h @@ -0,0 +1,42 @@ +/* hfal_skein1024.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein1024.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SKEIN1024_H_ +#define HFAL_SKEIN1024_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t skein1024_128_desc; +extern const hfdesc_t skein1024_160_desc; +extern const hfdesc_t skein1024_224_desc; +extern const hfdesc_t skein1024_256_desc; +extern const hfdesc_t skein1024_384_desc; +extern const hfdesc_t skein1024_512_desc; +extern const hfdesc_t skein1024_1024_desc; + +#endif /* HFAL_SHA1024_H_ */ diff --git a/hfal/hfal_skein256.c b/hfal/hfal_skein256.c new file mode 100644 index 0000000..c647e1e --- /dev/null +++ b/hfal/hfal_skein256.c @@ -0,0 +1,143 @@ +/* hfal_skein256.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein256.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "skein.h" + + +static const char skein256_128_str[] PROGMEM = "Skein-256-128"; +static const char skein256_160_str[] PROGMEM = "Skein-256-160"; +static const char skein256_224_str[] PROGMEM = "Skein-256-224"; +static const char skein256_256_str[] PROGMEM = "Skein-256-256"; +static const char skein256_384_str[] PROGMEM = "Skein-256-384"; +static const char skein256_512_str[] PROGMEM = "Skein-256-512"; + +void skein256_128_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 128); +} +void skein256_160_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 160); +} +void skein256_224_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 224); +} +void skein256_256_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 256); +} +void skein256_384_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 384); +} +void skein256_512_init(skein256_ctx_t* ctx){ + skein256_init(ctx, 512); +} + +const hfdesc_t skein256_128_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_128_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 128, + (hf_init_fpt)skein256_128_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein256_160_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_160_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 160, + (hf_init_fpt)skein256_160_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein256_224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_224_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 224, + (hf_init_fpt)skein256_224_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein256_256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_256_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 256, + (hf_init_fpt)skein256_256_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein256_384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_384_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 384, + (hf_init_fpt)skein256_384_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein256_512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein256_512_str, + sizeof(skein256_ctx_t), + SKEIN256_BLOCKSIZE, + 512, + (hf_init_fpt)skein256_512_init, + (hf_nextBlock_fpt)skein256_nextBlock, + (hf_lastBlock_fpt)skein256_lastBlock, + (hf_ctx2hash_fpt)skein256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; diff --git a/hfal/hfal_skein256.h b/hfal/hfal_skein256.h new file mode 100644 index 0000000..ae6cf3e --- /dev/null +++ b/hfal/hfal_skein256.h @@ -0,0 +1,41 @@ +/* hfal_skein256.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein256.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SKEIN256_H_ +#define HFAL_SKEIN256_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t skein256_128_desc; +extern const hfdesc_t skein256_160_desc; +extern const hfdesc_t skein256_224_desc; +extern const hfdesc_t skein256_256_desc; +extern const hfdesc_t skein256_384_desc; +extern const hfdesc_t skein256_512_desc; + +#endif /* HFAL_SKEIN256_H_ */ diff --git a/hfal/hfal_skein512.c b/hfal/hfal_skein512.c new file mode 100644 index 0000000..f78bc6f --- /dev/null +++ b/hfal/hfal_skein512.c @@ -0,0 +1,162 @@ +/* hfal_skein512.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein512.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "skein.h" + + +static const char skein512_128_str[] PROGMEM = "Skein-512-128"; +static const char skein512_160_str[] PROGMEM = "Skein-512-160"; +static const char skein512_224_str[] PROGMEM = "Skein-512-224"; +static const char skein512_256_str[] PROGMEM = "Skein-512-256"; +static const char skein512_384_str[] PROGMEM = "Skein-512-384"; +static const char skein512_512_str[] PROGMEM = "Skein-512-512"; +static const char skein512_1024_str[] PROGMEM = "Skein-512-1024"; + +void skein512_128_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 128); +} +void skein512_160_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 160); +} +void skein512_224_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 224); +} +void skein512_256_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 256); +} +void skein512_384_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 384); +} +void skein512_512_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 512); +} +void skein512_1024_init(skein512_ctx_t* ctx){ + skein512_init(ctx, 1024); +} + +const hfdesc_t skein512_128_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_128_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 128, + (hf_init_fpt)skein512_128_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_160_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_160_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 160, + (hf_init_fpt)skein512_160_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_224_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 224, + (hf_init_fpt)skein512_224_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_256_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 256, + (hf_init_fpt)skein512_256_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_384_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 384, + (hf_init_fpt)skein512_384_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_512_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 512, + (hf_init_fpt)skein512_512_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; +const hfdesc_t skein512_1024_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + skein512_1024_str, + sizeof(skein512_ctx_t), + SKEIN512_BLOCKSIZE, + 1024, + (hf_init_fpt)skein512_1024_init, + (hf_nextBlock_fpt)skein512_nextBlock, + (hf_lastBlock_fpt)skein512_lastBlock, + (hf_ctx2hash_fpt)skein512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)NULL +}; + diff --git a/hfal/hfal_skein512.h b/hfal/hfal_skein512.h new file mode 100644 index 0000000..52fe48f --- /dev/null +++ b/hfal/hfal_skein512.h @@ -0,0 +1,42 @@ +/* hfal_skein512.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_skein512.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-03-13 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_SKEIN512_H_ +#define HFAL_SKEIN512_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t skein512_128_desc; +extern const hfdesc_t skein512_160_desc; +extern const hfdesc_t skein512_224_desc; +extern const hfdesc_t skein512_256_desc; +extern const hfdesc_t skein512_384_desc; +extern const hfdesc_t skein512_512_desc; +extern const hfdesc_t skein512_1024_desc; + +#endif /* HFAL_SHA512_H_ */ diff --git a/hfal/hfal_twister224.c b/hfal/hfal_twister224.c new file mode 100644 index 0000000..e533c40 --- /dev/null +++ b/hfal/hfal_twister224.c @@ -0,0 +1,49 @@ +/* hfal_twister224.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister224.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-04 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "twister-small.h" + +static const char twister224_str[] PROGMEM = "Twister-224"; + +const hfdesc_t twister224_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + twister224_str, + sizeof(twister224_ctx_t), + 512, + 224, + (hf_init_fpt)twister224_init, + (hf_nextBlock_fpt)twister224_nextBlock, + (hf_lastBlock_fpt)twister224_lastBlock, + (hf_ctx2hash_fpt)twister224_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)twister224 +}; + diff --git a/hfal/hfal_twister224.h b/hfal/hfal_twister224.h new file mode 100644 index 0000000..87926e2 --- /dev/null +++ b/hfal/hfal_twister224.h @@ -0,0 +1,36 @@ +/* hfal_twister224.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister224.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_TWISTER224_H_ +#define HFAL_TWISTER224_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t twister224_desc; + +#endif /* HFAL_TWISTER224_H_ */ diff --git a/hfal/hfal_twister256.c b/hfal/hfal_twister256.c new file mode 100644 index 0000000..0507be3 --- /dev/null +++ b/hfal/hfal_twister256.c @@ -0,0 +1,49 @@ +/* hfal_twister256.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister256.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "twister-small.h" + +static const char twister256_str[] PROGMEM = "Twister-256"; + +const hfdesc_t twister256_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + twister256_str, + sizeof(twister256_ctx_t), + 512, + 256, + (hf_init_fpt)twister256_init, + (hf_nextBlock_fpt)twister256_nextBlock, + (hf_lastBlock_fpt)twister256_lastBlock, + (hf_ctx2hash_fpt)twister256_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)twister256 +}; + diff --git a/hfal/hfal_twister256.h b/hfal/hfal_twister256.h new file mode 100644 index 0000000..3c01faa --- /dev/null +++ b/hfal/hfal_twister256.h @@ -0,0 +1,36 @@ +/* hfal_twister256.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister256.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_TWISTER256_H_ +#define HFAL_TWISTER256_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t twister256_desc; + +#endif /* HFAL_TWISTER256_H_ */ diff --git a/hfal/hfal_twister384.c b/hfal/hfal_twister384.c new file mode 100644 index 0000000..888078e --- /dev/null +++ b/hfal/hfal_twister384.c @@ -0,0 +1,49 @@ +/* hfal_twister384.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister384.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "twister-large.h" + +static const char twister384_str[] PROGMEM = "Twister-384"; + +const hfdesc_t twister384_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + twister384_str, + sizeof(twister384_ctx_t), + 512, + 384, + (hf_init_fpt)twister384_init, + (hf_nextBlock_fpt)twister384_nextBlock, + (hf_lastBlock_fpt)twister384_lastBlock, + (hf_ctx2hash_fpt)twister384_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)twister384 +}; + diff --git a/hfal/hfal_twister384.h b/hfal/hfal_twister384.h new file mode 100644 index 0000000..93c42cf --- /dev/null +++ b/hfal/hfal_twister384.h @@ -0,0 +1,36 @@ +/* hfal_twister384.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister384.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_TWISTER384_H_ +#define HFAL_TWISTER384_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t twister384_desc; + +#endif /* HFAL_TWISTER384_H_ */ diff --git a/hfal/hfal_twister512.c b/hfal/hfal_twister512.c new file mode 100644 index 0000000..4f6e7b0 --- /dev/null +++ b/hfal/hfal_twister512.c @@ -0,0 +1,49 @@ +/* hfal_twister512.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister512.c + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#include +#include +#include "hashfunction_descriptor.h" +#include "twister-large.h" + +static const char twister512_str[] PROGMEM = "Twister-512"; + +const hfdesc_t twister512_desc PROGMEM = { + HFDESC_TYPE_HASHFUNCTION, + 0, + twister512_str, + sizeof(twister512_ctx_t), + 512, + 512, + (hf_init_fpt)twister512_init, + (hf_nextBlock_fpt)twister512_nextBlock, + (hf_lastBlock_fpt)twister512_lastBlock, + (hf_ctx2hash_fpt)twister512_ctx2hash, + (hf_free_fpt)NULL, + (hf_mem_fpt)twister512 +}; + diff --git a/hfal/hfal_twister512.h b/hfal/hfal_twister512.h new file mode 100644 index 0000000..937c3d8 --- /dev/null +++ b/hfal/hfal_twister512.h @@ -0,0 +1,36 @@ +/* hfal_twister512.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/** + * \file hfal_twister512.h + * \email daniel.otte@rub.de + * \author Daniel Otte + * \date 2009-02-09 + * \license GPLv3 or later + * + */ + +#ifndef HFAL_TWISTER512_H_ +#define HFAL_TWISTER512_H_ + +#include +#include "hashfunction_descriptor.h" + +extern const hfdesc_t twister512_desc; + +#endif /* HFAL_TWISTER512_H_ */ diff --git a/memxor/memxor.S b/memxor/memxor.S new file mode 100644 index 0000000..a32058b --- /dev/null +++ b/memxor/memxor.S @@ -0,0 +1,66 @@ +/* memxor.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ + +/* + * File: memxor.S + * Author: Daniel Otte + * Date: 2008-08-07 + * License: GPLv3 or later + * Description: memxor, XORing one block into another + * + */ + +/* + * void memxor(void* dest, const void* src, uint16_t n); + */ + /* + * param dest is passed in r24:r25 + * param src is passed in r22:r23 + * param n is passed in r20:r21 + */ +.global memxor +memxor: + movw r30, r24 + movw r26, r22 + movw r24, r20 + adiw r24, 0 + breq 2f +1: + ld r20, X+ + ld r21, Z + eor r20, r21 + st Z+, r20 + sbiw r24, 1 + brne 1b +2: + ret + + + + + + + + + + + + + + diff --git a/memxor/memxor.h b/memxor/memxor.h new file mode 100644 index 0000000..a62a616 --- /dev/null +++ b/memxor/memxor.h @@ -0,0 +1,7 @@ +#ifndef MEMXOR_H_ +#define MEMXOR_H_ +#include + +void memxor(void* dest, const void* src, uint16_t n); + +#endif diff --git a/memxor/memxor_c.c b/memxor/memxor_c.c new file mode 100644 index 0000000..e438d5d --- /dev/null +++ b/memxor/memxor_c.c @@ -0,0 +1,12 @@ +#include + +#include "memxor/memxor.h" + +void memxor(void* dest, const void* src, uint16_t n){ + while(n--){ + *((uint8_t*)dest) ^= *((uint8_t*)src); + dest = (uint8_t*)dest +1; + src = (uint8_t*)src +1; + } +} + diff --git a/noekeon/noekeon.c b/noekeon/noekeon.c new file mode 100644 index 0000000..a800d4d --- /dev/null +++ b/noekeon/noekeon.c @@ -0,0 +1,199 @@ +/* noekeon.c */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * author: Daniel Otte + * email: daniel.otte@rub.de + * license: GPLv3 or later + * + * + * + */ + +#include +#include + +#ifdef __AVR__ + #include +#endif +#include "noekeon/noekeon.h" +// #include "cli.h" + +#define ROUND_NR 16 + +#define RC_POS 0 + +static +void gamma(uint32_t* a){ + uint32_t tmp; + + a[1] ^= ~((a[3]) | (a[2])); + a[0] ^= a[2] & a[1]; + + tmp=a[3]; a[3]=a[0]; a[0]=tmp; + a[2] ^= a[0] ^ a[1] ^ a[3]; + + a[1] ^= ~((a[3]) | (a[2])); + a[0] ^= a[2] & a[1]; +} + +#define ROTL32(a,n) (((a)<>(32-n))) +#define ROTR32(a,n) (((a)>>n)|((a)<<(32-n))) + +static +void pi1(uint32_t* a){ + a[1] = ROTL32(a[1], 1); + a[2] = ROTL32(a[2], 5); + a[3] = ROTL32(a[3], 2); +} + +static +void pi2(uint32_t* a){ + a[1] = ROTR32(a[1], 1); + a[2] = ROTR32(a[2], 5); + a[3] = ROTR32(a[3], 2); +} + +static +void theta(const uint32_t* k, uint32_t* a){ + uint32_t temp; + + temp = a[0] ^ a[2]; temp ^= ROTR32(temp, 8) ^ ROTL32(temp, 8); + a[1] ^= temp; + a[3] ^= temp; + + a[0] ^= k[0]; + a[1] ^= k[1]; + a[2] ^= k[2]; + a[3] ^= k[3]; + + temp = a[1] ^ a[3]; temp ^= ROTR32(temp, 8) ^ ROTL32(temp, 8); + a[0] ^= temp; + a[2] ^= temp; + +} + +static +void noekeon_round(uint32_t* key, uint32_t* state, uint8_t const1, uint8_t const2){ + ((uint8_t*)state)[RC_POS] ^= const1; + theta(key, state); + ((uint8_t*)state)[RC_POS] ^= const2; + pi1(state); + gamma(state); + pi2(state); +} + +uint8_t rc_tab[] +#ifdef __AVR__ + PROGMEM +#endif + = { +/* 0x80, */ + 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A, + 0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A, + 0xD4 +}; +/* for more rounds + 0xD4, 0xB3, 0x7D, 0xFA, 0xEF, 0xC5, 0x91, 0x39, + 0x72, 0xE4, 0xD3, 0xBD, 0x61, 0xC2, 0x9F, 0x25, +*/ + +static +void changendian32(void* a){ + ((uint8_t*)a)[0] ^= ((uint8_t*)a)[3]; + ((uint8_t*)a)[3] ^= ((uint8_t*)a)[0]; + ((uint8_t*)a)[0] ^= ((uint8_t*)a)[3]; + + ((uint8_t*)a)[1] ^= ((uint8_t*)a)[2]; + ((uint8_t*)a)[2] ^= ((uint8_t*)a)[1]; + ((uint8_t*)a)[1] ^= ((uint8_t*)a)[2]; +} + +static +void changendian(void* a){ + changendian32((uint32_t*)(&(((uint32_t*)a)[0]))); + changendian32((uint32_t*)(&(((uint32_t*)a)[1]))); + changendian32((uint32_t*)(&(((uint32_t*)a)[2]))); + changendian32((uint32_t*)(&(((uint32_t*)a)[3]))); +} + +/******************************************************************************/ + +void noekeon_enc(void* buffer, const void* key){ + uint8_t rc=0x80; + uint8_t keyb[16]; + int8_t i; + + memcpy(keyb, key, 16); + changendian(buffer); + changendian(keyb); + + for(i=0; i=0; --i){ +#ifdef __AVR__ + rc = pgm_read_byte(rc_tab+i); +#else + rc = rc_tab[i]; +#endif + noekeon_round((uint32_t*)dkey, (uint32_t*)buffer, 0, rc); + } + theta((uint32_t*)dkey, (uint32_t*)buffer); + ((uint8_t*)buffer)[RC_POS] ^= 0x80; + + changendian(buffer); +} + +void noekeon_init(const void* key, noekeon_ctx_t* ctx){ + uint8_t nullv[16]; + + memset(nullv, 0, 16); + memcpy(ctx, key, 16); + noekeon_enc(ctx, nullv); +} + diff --git a/noekeon/noekeon.h b/noekeon/noekeon.h new file mode 100644 index 0000000..9c046f3 --- /dev/null +++ b/noekeon/noekeon.h @@ -0,0 +1,85 @@ +/* noekeon.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +#ifndef NOEKEON_H_ +#define NOEKEON_H_ + +/** + * \file noekeon.h + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-04-11 + * \license GPLv3 or later + * \brief Implementation of the Noekeon block cipher + * \ingroup Noekeon + * This is an implementation of the Noekeon block cipher. + * For more details on Noekeon see http://gro.noekeon.org/ + */ + +#include + +/** \typedef noekeon_ctx_t + * \brief holds key data for indirect mode + * + * A variable of this type may hold the key data for the indirect mode. + * For direct mode simply pass the key directly to the encryption or + * decryption function. + */ +typedef uint8_t noekeon_ctx_t[16]; + +/** \fn void noekeon_enc(void* buffer, const void* key) + * \brief noekeon encrytion funtion + * + * This function encrypts a block (64 bit = 8 byte) with the noekeon encrytion + * algorithm. Due to the two modes of noekeon (direct mode and indirect mode) + * the second parameter either points directly to the key (direct mode) or to a + * context generated by the noekeon_init() function (indirect mode). + * \param buffer pointer to the 64 bit (8 byte) block to encrypt + * \param key pointer to either the key (128 bit = 16 byte; direct mode) or + * to the context (indirect mode) + */ +void noekeon_enc(void* buffer, const void* key); + +/** \fn void noekeon_dec(void* buffer, const void* key) + * \brief noekeon encrytion funtion + * + * This function decrypts a block (64 bit = 8 byte) encrypted with the noekeon + * encrytion algorithm. Due to the two modes of noekeon (direct mode and + * indirect mode) the second parameter either points directly to the key + * (direct mode) or to a context generated by the noekeon_init() function + * (indirect mode). + * \param buffer pointer to the 64 bit (8 byte) block to decrypt + * \param key pointer to either the key (128 bit = 16 byte; direct mode) or + * to the context (indirect mode) + */ +void noekeon_dec(void* buffer, const void* key); + + +/** \fn void noekeon_init(const void* key, noekeon_ctx_t* ctx) + * \brief noekeon context generation function for indirect mode + * + * This function generates a context from the supplied key for using + * noekeon in indirect mode. For using noekeon in direct mode supply the key + * direct to the noekeon_enc() and noekeon_dec() functions. + * \param key pointer to the key (128 bit = 16 byte) + * \param ctx pointer to the context to fill with key material + * to the context (indirect mode) + */ +void noekeon_init(const void* key, noekeon_ctx_t* ctx); + +#endif /*NOEKEON_H_*/ diff --git a/noekeon/noekeon_asm.S b/noekeon/noekeon_asm.S new file mode 100644 index 0000000..b0a2a16 --- /dev/null +++ b/noekeon/noekeon_asm.S @@ -0,0 +1,641 @@ +/* noekeon_asm.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * noekeon assembler implementation for avr + * author: Daniel Otte + * email: daniel.otte@rub.de + * license: GPLv3 + */ + +#include + +.macro push_all + push r2 + push r3 + push r4 + push r5 + push r6 + push r7 + push r8 + push r9 + push r10 + push r11 + push r12 + push r13 + push r14 + push r15 + push r16 + push r17 + push r28 + push r29 +.endm + +.macro pop_all + pop r29 + pop r28 + pop r17 + pop r16 + pop r15 + pop r14 + pop r13 + pop r12 + pop r11 + pop r10 + pop r9 + pop r8 + pop r7 + pop r6 + pop r5 + pop r4 + pop r3 + pop r2 + clr r1 +.endm + +push_all_func: + pop r31 + pop r30 + push_all + ijmp + +pop_all_func: + pop r31 + pop r30 + pop_all + ijmp + +.macro xchg a b + eor \a, \b + eor \b, \a + eor \a, \b +.endm + +.macro op32 op a b + \op \a\()_0, \b\()_0 + \op \a\()_1, \b\()_1 + \op \a\()_2, \b\()_2 + \op \a\()_3, \b\()_3 +.endm + + +.macro op32_4t op a b c d w x y z + \op \a, \w + \op \b, \x + \op \c, \y + \op \d, \z +.endm + + +.macro op32_prefix op p q a b c d w x y z + \op \p\()\a, \q\()\w + \op \p\()\b, \q\()\x + \op \p\()\c, \q\()\y + \op \p\()\d, \q\()\z +.endm + +; === bigendian_rotl32 === +; this function rotates a 32bit bigendian word n bits to the left +; param1: the 32-bit value +; given in r25,r24,r23,r22 (r22 is most significant) +; param2: the 8-bit parameter giving the number of bits to rotate +; given in r20 +; return: the rotatet 32-bit word +; given in r25,r24,r23,r22 + +bigendian_rotl32: + /* copy high bit of r22 to carry */ + mov r1, r22 +2: + rol r1 + + rol r25 + rol r24 + rol r23 + rol r22 + + dec r20 + brne 2b +bigendian_rotl32_exit: + clr r1 + ret + + +/******************************************************************************/ + +; === bigendian_rotl32 === +; this function rotates a 32bit bigendian word n bits to the right +; param1: the 32-bit value +; given in r25,r24,r23,r22 (r22 is most significant) +; param2: the 8-bit parameter giving the number of bits to rotate +; given in r20 +; return: the rotatet 32-bit word +; given in r25,r24,r23,r22 + +bigendian_rotr32: + /* copy high bit of r25 to carry */ + + mov r1, r25 +2: + ror r1 + + ror r22 + ror r23 + ror r24 + ror r25 + dec r20 + brne 2b +bigendian_rotr32_exit: + clr r1 + ret + +/******************************************************************************/ +/* +void theta(uint32_t* k, uint32_t* a){ + uint32_t temp; + temp = a[0] ^ a[2]; temp ^= ROTR32(temp, 8) ^ ROTL32(temp, 8); + a[1] ^= temp; + a[3] ^= temp; + + a[0] ^= k[0]; + a[1] ^= k[1]; + a[2] ^= k[2]; + a[3] ^= k[3]; + + temp = a[1] ^ a[3]; temp ^= ROTR32(temp, 8) ^ ROTL32(temp, 8); + a[0] ^= temp; + a[2] ^= temp; +} +*/ + +round_const: .byte 0x1B, 0x36, 0x6C, 0xD8, 0xAB, 0x4D, 0x9A, \ + 0x2F, 0x5E, 0xBC, 0x63, 0xC6, 0x97, 0x35, 0x6A, \ + 0xD4 + +;-- a[0] +state0_0 = 2 +state0_1 = 3 +state0_2 = 4 +state0_3 = 5 +;-- a[1] +state1_0 = 6 +state1_1 = 7 +state1_2 = 8 +state1_3 = 9 +;-- a[2] +state2_0 = 10 +state2_1 = 11 +state2_2 = 12 +state2_3 = 13 +;-- a[3] +state3_0 = 14 +state3_1 = 15 +state3_2 = 16 +state3_3 = 17 + +; === theta === +; +; param1: the state in r2-r17 +; param2: pointer to k in X (r26,r27) +; +temp_a = 18 +temp_b = 19 +temp_c = 20 +temp_d = 21 + +theta: + /* temp = a[0] ^ a[2]; temp ^= temp>>>8 ^ temp<<<8 */ + op32_prefix mov, temp_, state0_, a,b,c,d, 0,1,2,3 + op32_prefix eor, temp_, state2_, a,b,c,d, 0,1,2,3 + + mov r1, temp_a + eor r1, temp_b + eor r1, temp_c + eor r1, temp_d + + op32_prefix eor, temp_, r, a,b,c,d, 1,1,1,1 + + /* temp is know a little bit mixed c,d,a,b (if abcd is normal order) */ + /* a[1] ^= temp */ + eor state1_0, temp_c + eor state1_1, temp_d + eor state1_2, temp_a + eor state1_3, temp_b + /* a[3] ^= temp */ + eor state3_0, temp_c + eor state3_1, temp_d + eor state3_2, temp_a + eor state3_3, temp_b + + /* state ^ k (X points to K) */ + ldi r28, 2 + clr r29 /* Y points to r2 aka state0_0 */ + ldi temp_a, 16 +1: + ld r1, X+ + ld r0, Y + eor r1, r0 + st Y+, r1 + dec temp_a + brne 1b + sbiw r26, 16 /* set X back to key */ + + mov temp_a, state1_0 + mov temp_b, state1_1 + mov temp_c, state1_2 + mov temp_d, state1_3 + eor temp_a, state3_0 + eor temp_b, state3_1 + eor temp_c, state3_2 + eor temp_d, state3_3 + mov r1, temp_a + eor r1, temp_b + eor r1, temp_c + eor r1, temp_d + eor temp_a, r1 + eor temp_b, r1 + eor temp_c, r1 + eor temp_d, r1 + /* temp is know a little bit mixed c,d,a,b (if abcd is normal order) */ + /* a[0] ^= temp */ + eor state0_0, temp_c + eor state0_1, temp_d + eor state0_2, temp_a + eor state0_3, temp_b + /* a[2] ^= temp */ + eor state2_0, temp_c + eor state2_1, temp_d + eor state2_2, temp_a + eor state2_3, temp_b + + clr r1 + ret + +/******************************************************************************/ +#ifndef NOEKEON_NO_ENC +; === noekeon_enc === +; +; param1: pointer to buffer (r24,r25) +; param2: pointer to k (r22,r23) +; +.global noekeon_enc +noekeon_enc: + rcall push_all_func + /* load state */ + movw r26, r22 + ldi r28, 2 + clr r29 /* Y points at r2 aka state0_0 */ + movw r30, r24 /* Z points at state */ + push r30 + push r31 + ldi r22, 16 + push r22 /* 16 is also the number of rounds and gets pushed here */ +1: + ld r0, Z+ + st Y+, r0 + dec r22 + brne 1b + /* state loaded */ + push r1 /* push round constan2 (0x00) */ + ldi r20, 0x80 + push r20 /* push round constan2 (0x00) */ + rjmp 3f +2: + ldi r30, lo8(round_const+15) + ldi r31, hi8(round_const+15) + sub r30, r22 + sbci r31, 0 + clr r1 + push r1 + lpm r0, Z + push r0 +3: + rcall round /* pops rc2 & rc1 */ + pop r22 + dec r22 + push r22 + brne 2b + + pop r22 + + ldi r22, 0xD4 + eor state0_3, r22 + rcall theta + + pop r31 + pop r30 + clr r29 + ldi r28, 2 + ldi r22, 16 +1: + ld r0, Y+ + st Z+, r0 + dec r22 + brne 1b + + rcall pop_all_func + ret +#endif +/******************************************************************************/ +/******************************************************************************/ +#ifndef NOEKEON_NO_DEC + +; === noekeon_dec === +; +; param1: pointer to buffer/state (r24,r25) +; param2: pointer to k (r22,r23) +; +.global noekeon_dec +noekeon_dec: + rcall push_all_func + /* allocate 16 bytes on the stack */ + in r30, _SFR_IO_ADDR(SPL) + in r31, _SFR_IO_ADDR(SPH) + sbiw r30, 16 + out _SFR_IO_ADDR(SPH), r31 + out _SFR_IO_ADDR(SPL), r30 + + adiw r30, 1 + /* push state pointer */ + push r24 + push r25 + movw r26, r22 /* move key ptr to X */ + + /* set stackkey to zero */ + ldi r22, 16 +1: st Z+, r1 + dec r22 + brne 1b + + /* copy key to state */ + clr r29 + ldi r28, 2 + ldi r22, 16 +1: ld r0, X+ + st Y+, r0 + dec r22 + brne 1b + + movw r26, r30 + sbiw r26, 16 /* set X back to begining of stack key */ + rcall theta + + /* mov state to stackkey */ + clr r29 + ldi r28, 2 + ldi r22, 16 +1: ld r0, Y+ + st X+, r0 + dec r22 + brne 1b + sbiw r26, 16 /* set X back to begining of stack key */ + + /* move data from stateptr to state */ + pop r31 + pop r30 + push r30 + push r31 + clr r29 + ldi r28, 2 + ldi r22, 16 + push r22 +1: ld r0, Z+ + st Y+, r0 + dec r22 + brne 1b + +;--- snip 8< ---- + + ldi r20, 0xD4 + push r20 /* push round constant2 (0xD4) */ + push r22 /* push round constan1 (0x00) */ + rjmp 3f +2: + ldi r30, lo8(round_const-1) + ldi r31, hi8(round_const-1) + clr r1 + add r30, r22 + adc r31, r1 + lpm r0, Z + push r0 + push r1 +3: + rcall round /* pops rc2 & rc1 */ + pop r22 + dec r22 + push r22 + brne 2b +;---- + pop r22 + + rcall theta + ldi r22, 0x80 + eor state0_3, r22 + +write_state_back: + /* write state back */ + pop r31 /* pop state pointer */ + pop r30 + clr r29 + ldi r28, 2 + ldi r22, 16 +1: + ld r0, Y+ + st Z+, r0 + dec r22 + brne 1b + + /* remove key from stack */ + in r30, _SFR_IO_ADDR(SPL) + in r31, _SFR_IO_ADDR(SPH) + adiw r30, 16 + out _SFR_IO_ADDR(SPH), r31 + out _SFR_IO_ADDR(SPL), r30 + rcall pop_all_func + ret +#endif +/******************************************************************************/ + + +round: + pop r24 + pop r25 + pop r1 + eor state0_3, r1 + rcall theta + pop r1 + eor state0_3, r1 + push r25 + push r24 +pi_gamma_pi: + ldi r30, pm_lo8(bigendian_rotl32) + ldi r31, pm_hi8(bigendian_rotl32) + rcall pi + /* pi1 done; now gamma */ + rcall gamma_1 + /* a[0] <-> a[3] */ + xchg state0_0, state3_0 + xchg state0_1, state3_1 + xchg state0_2, state3_2 + xchg state0_3, state3_3 + /* a[2] ^= a[0] ^ a[1] ^ a[3] */ + op32 eor, state2, state0 + op32 eor, state2, state1 + op32 eor, state2, state3 + + rcall gamma_1 + ldi r30, pm_lo8(bigendian_rotr32) + ldi r31, pm_hi8(bigendian_rotr32) + rcall pi + ret + +gamma_1: + /* a[1] ^= ~(a[3]|a[2])*/ + mov r1, state3_0 + or r1, state2_0 + com r1 + eor state1_0, r1 + + mov r1, state3_1 + or r1, state2_1 + com r1 + eor state1_1, r1 + + mov r1, state3_2 + or r1, state2_2 + com r1 + eor state1_2, r1 + + mov r1, state3_3 + or r1, state2_3 + com r1 + eor state1_3, r1 + + /* a[0] ^= a[2]&a[1] */ + mov r1, state2_0 + and r1, state1_0 + eor state0_0, r1 + + mov r1, state2_1 + and r1, state1_1 + eor state0_1, r1 + + mov r1, state2_2 + and r1, state1_2 + eor state0_2, r1 + + mov r1, state2_3 + and r1, state1_3 + eor state0_3, r1 + ret + +pi: + /* a[1] <<<= 1*/ + mov r22, state1_0 + mov r23, state1_1 + mov r24, state1_2 + mov r25, state1_3 + ldi r20, 1 + icall + mov state1_0, r22 + mov state1_1, r23 + mov state1_2, r24 + mov state1_3, r25 + /* a[2] <<<= 5*/ + mov r22, state2_0 + mov r23, state2_1 + mov r24, state2_2 + mov r25, state2_3 + ldi r20, 5 + icall + mov state2_0, r22 + mov state2_1, r23 + mov state2_2, r24 + mov state2_3, r25 + /* a[3] <<<= 2*/ + mov r22, state3_0 + mov r23, state3_1 + mov r24, state3_2 + mov r25, state3_3 + ldi r20, 2 + icall + mov state3_0, r22 + mov state3_1, r23 + mov state3_2, r24 + mov state3_3, r25 + ret + +/******************************************************************************/ + +/* +void noekeon_init(void* key, noekeon_ctx_t* ctx){ + uint8_t nullv[16]; + + memset(nullv, 0, 16); + memcpy(ctx, key, 16); + noekeon_enc(ctx, nullv); +} +*/ + +#ifndef NOEKEON_NO_INIT + +.global noekeon_init +noekeon_init: +; === noekeon_init === +; +; param1: pointer to key (r24,r25) +; param2: pointer to context (r22,r23) +; + in r30, _SFR_IO_ADDR(SPL) + in r31, _SFR_IO_ADDR(SPH) + sbiw r30, 16 + out _SFR_IO_ADDR(SPH), r31 + out _SFR_IO_ADDR(SPL), r30 + + movw r26, r22 + adiw r30, 1 + movw r22, r30 + /* set nullv(stack) to zero */ + ldi r20, 16 +1: st Z+, r1 + dec r20 + brne 1b + + /* copy key data to ctx */ + movw r30, r24 + ldi r20, 16 +1: ld r1, Z+ + st X+, r1 + dec r20 + brne 1b + clr r1 + + sbiw r26, 16 + movw r24, r26 + rcall noekeon_enc + + in r30, _SFR_IO_ADDR(SPL) + in r31, _SFR_IO_ADDR(SPH) + adiw r30, 16 + out _SFR_IO_ADDR(SPH), r31 + out _SFR_IO_ADDR(SPL), r30 + ret + +#endif + + diff --git a/noekeon/noekeon_cbc_enc.S b/noekeon/noekeon_cbc_enc.S new file mode 100644 index 0000000..0c0b89a --- /dev/null +++ b/noekeon/noekeon_cbc_enc.S @@ -0,0 +1,99 @@ +/* noekeon_cbc_enc.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-08-06 + * \license GPLv3 or later + * + * + * + */ + +.macro push_ p1:req p2:vararg + push \p1 +.ifnb \p2 + push_ \p2 +.endif +.endm + +.macro pop_ p1:req p2:vararg + pop \p1 +.ifnb \p2 + pop_ \p2 +.endif +.endm + +.extern noekeon_enc + +/* + * void noekeon_cbc_enc(void* buffer, uint8_t block_cnt, const void* key) + */ + +/* param buffer is passed in r24:r25 + * param block_cnt is passed in r22 (r23 is 0) + * param key is passed in r20:r21 + */ +.global noekeon_cbc_enc + noekeon_cbc_enc: + push r22 + movw r22, r20 + push_ r22, r23, r24, r25 + rcall noekeon_enc +1: + pop_ r27, r26, r23, r22 + pop r16 /* block counter */ + dec r16 + breq 9f + push r16 + /* xor blocks */ + movw r30, r26 + adiw r30, 16 + ldi r16, 16 +2: + ld r17, X+ + ld r18, Z + eor r18, r17 + st Z+, r18 + dec r16 + brne 2b + + /* call encryption function; X points to our new block */ + push_ r22, r23, r26, r27 + movw r24, r26 + rcall noekeon_enc + rjmp 1b +9: + ret + + + + + + + + + + + + + + + + diff --git a/noekeon/noekeon_cbc_enc.h b/noekeon/noekeon_cbc_enc.h new file mode 100644 index 0000000..b47048f --- /dev/null +++ b/noekeon/noekeon_cbc_enc.h @@ -0,0 +1,9 @@ +#ifndef NOEKEON_CBC_ENC_H_ +#define NOEKEON_CBC_ENC_H_ + +#include +#include "noekeon/noekeon.h" + +void noekeon_cbc_enc(void* buffer, uint8_t block_cnt, const void* key); + +#endif /*NOEKEON_CBC_ENC_H_*/ diff --git a/noekeon/noekeon_ctr.S b/noekeon/noekeon_ctr.S new file mode 100644 index 0000000..bf366ba --- /dev/null +++ b/noekeon/noekeon_ctr.S @@ -0,0 +1,70 @@ +/* noekeon_ctr.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-08-06 + * \license GPLv3 or later + * + * + * + */ + +.extern noekeon_enc + +/* + * void noekeon_ctr_next(void* buffer, const noekeon_ctr_ctx_t* ctx); + */ +.global noekeon_ctr_next +/* + * param buffer passed in r24:r25 + * param ctx passed in r22:r23 + */ +noekeon_ctr_next: + /* copy counter to buffer */ + movw r26, r24 /* copy buffer pointer to X */ + movw r30, r22 /* copy counter pointer to Z */ + ldi r16, 16 +1: + ld r0, Z+ + st X+, r0 + dec r16 + brne 1b + /* increment counter */ + movw r30, r22 /* copy counter pointer to Z */ + ldi r17, 1 + ldi r16, 15 + ld r0, Z + add r0, r17 + st Z+, r0 +1: + ld r0, Z + adc r0, r1 + st Z+, r0 + dec r16 + brne 1b + /* call encryption routine */ + /* we can leave the first param as is, but have to adjust the second to point to the key */ + //adiw r22, 16 + ldi r16, 16 + add r22, r16 + adc r23, r0 +// rcall noekeon_enc +// ret + rjmp noekeon_enc /* noekeon_enc will return for us */ diff --git a/noekeon/noekeon_ctr.h b/noekeon/noekeon_ctr.h new file mode 100644 index 0000000..19cbe36 --- /dev/null +++ b/noekeon/noekeon_ctr.h @@ -0,0 +1,42 @@ +/* noekeon_ctr.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-08-06 + * \license GPLv3 or later + * + * + * + */ + +#ifndef NOEKEON_CTR_H_ +#define NOEKEON_CTR_H_ + +#include +#include "noekeon/noekeon.h" + +typedef struct{ + uint8_t counter[16]; + uint8_t key[16]; +}noekeon_ctr_ctx_t; + +void noekeon_ctr_next(void* buffer, const noekeon_ctr_ctx_t* ctx); + +#endif /*NOEKEON_CTR_H_*/ diff --git a/noekeon/noekeon_prng.c b/noekeon/noekeon_prng.c new file mode 100644 index 0000000..5e984d2 --- /dev/null +++ b/noekeon/noekeon_prng.c @@ -0,0 +1,67 @@ +/* noekeon_prng.c */ +/* + * This file is part of the AVR-Crypto-Lib. + * Copyright (C) 2006, 2007, 2008 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 . + */ +/** + * \author Daniel Otte + * \date 2008-08-24 + * \license GPLv3 or later + * \brief random number generator based on noekeon running in CFB-mode + * + */ + +#include "noekeon/noekeon.h" +#include "memxor/memxor.h" +#include +#include + +static uint8_t random_state[16]; +static uint8_t random_key[16]; +static uint8_t i=0; + +uint8_t random8(void){ + static uint8_t sr[16]; + + if(i==0){ + noekeon_enc(random_state, random_key); + memcpy(sr, random_state, 16); + i=15; + return sr[15]; + } + --i; + return sr[i]; +} + +void random_block(void* dest){ + i=0; + noekeon_enc(random_state, random_key); + memcpy(dest, random_state, 16); +} + +void srandom32(uint32_t seed){ + memcpy(random_key, &seed, 4); +} + +void random_seed(const void* buffer){ + memcpy(random_key, buffer, 16); +} + +void random_add(const void* buffer){ + memxor(random_key, buffer, 16); +} + + diff --git a/noekeon/noekeon_prng.h b/noekeon/noekeon_prng.h new file mode 100644 index 0000000..ff9ca03 --- /dev/null +++ b/noekeon/noekeon_prng.h @@ -0,0 +1,40 @@ +/* noekeon_prng.h */ +/* + * This file is part of the AVR-Crypto-Lib. + * Copyright (C) 2006, 2007, 2008 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 . + */ +/** + * \author Daniel Otte + * \date 2008-08-24 + * \license GPLv3 or later + * \brief random number generator based on noekeon running in CFB-mode + * + */ + +#ifndef PRNG_H_ +#define PRNG_H_ + +#include + +uint8_t random8(void); +void random_block(void* dest); +void srandom32(uint32_t seed); +void random_seed(const void* buffer); +void random_add(const void* buffer); + +#endif /* PRNG_H_*/ + + diff --git a/noekeon/omac_noekeon.S b/noekeon/omac_noekeon.S new file mode 100644 index 0000000..598280b --- /dev/null +++ b/noekeon/omac_noekeon.S @@ -0,0 +1,353 @@ +/* noekeon_omac.S */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 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 . +*/ +/* + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2008-08-24 + * \license GPLv3 or later + * + * + * + */ + +#include +#include "avr-asm-macros.S" + +.extern noekeon_enc + + +/******************************************************************************/ + +/* + * void noekeon_omac_init(noekeon_omac_ctx_t* ctx){ + * memset(ctx, 0, 16); + * } + */ +/* + * param ctx in r24:r25 + */ + +.global omac_noekeon_init +omac_noekeon_init: + movw r30, r24 + ldi r24, 16 +1: + st Z+, r1 + dec r24 + brne 1b + ret + +/******************************************************************************/ + +/* + * void omac_noekeon_tweak(uint8_t t, const void* key, noekeon_omac_ctx_t* ctx){ + * *ctx[15] = t; + * noekeon_enc(ctx, key); + * } + */ +/* + * param t in r24 + * param key in r22:r23 + * param ctx in r20:r21 + */ +.global omac_noekeon_tweak +omac_noekeon_tweak: + movw r30, r20 + std Z+15, r24 + movw r24, r20 + rjmp noekeon_enc + +/******************************************************************************/ + +/* + * void noekeon_omac_next(const void* buffer, const void* key, noekeon_omac_ctx_t* ctx){ + * memxor(ctx, buffer, 16); + * noekeon_enc(ctx, key); + * } + */ +/* + * param buffer in r24:r25 + * param key in r22:r23 + * param ctx in r20:r21 + */ +.global omac_noekeon_next +omac_noekeon_next: + movw r26, r20 + movw r30, r24 + ldi r24, 16 +1: + ld r0, X + ld r25, Z+ + eor r0, r25 + st X+, r0 + dec r24 + brne 1b + movw r24, r20 + rjmp noekeon_enc + +/******************************************************************************/ + +/* + * void omac_noekeon_comppad(uint8_t* pad, const void* key, uint8_t length_b){ + * uint8_t c1,c2,r,j; + * memset(pad, 0, 16); + * noekeon_enc(pad, key); + * r=(length_b==128)?1:2; + * for(;r!=0;--r){ + * c1=0; + * for(j=0;j<16;++j){ + * c2 = c1; + * c1 = (pad[15-j])>>7; + * pad[15-j] = ((pad[15-j])<<1) | c2; + * } + * if(c1){ + * pad[15] ^= 0x87; + * } + * } + * if(length_b<128){ + * pad[(length_b)/8] ^= 0x80 >> (length_b%8); + * } + *} + */ +/* + * param pad in r24:r25 + * param key in r22:r23 + * param length_b in r20 + */ +.global omac_noekeon_comppad +omac_noekeon_comppad: + push_ r20, r24, r25 + ldi r20, 16 + movw r30, r24 +1: + st Z+, r1 + dec r20 + brne 1b + rcall noekeon_enc + pop_ r31, r30, r20 /* now Z points at pad, and r20 contains length_b */ + ldi r21, 1 + clt + cpi r20, 128 + breq 2f + set + inc r21 +2: + adiw r30, 16 + ldi r24, 16 + clc +3: + ld r0, -Z + rol r0 + st Z, r0 + dec r24 + brne 3b + + brcc 4f + ldi r24, 0x87 + ldd r0, Z+15 + eor r0, r24 + std Z+15, r0 +4: + dec r21 + brne 2b + /* the B/P calculation is done, now we have only to insert the one for + messages of a length != n*128 */ + brts 5f + ret +5: + /* r20 contains the length in bits where a one must be appended via xor */ + mov r21, r20 + lsr r21 + lsr r21 + lsr r21 + add r30, r21 + adc r31, r1 + andi r20, 0x07 + ldi r21, 0x80 +6: tst r20 + breq 8f +7: lsr r21 + dec r20 + brne 7b +8: + ld r24, Z + eor r24, r21 + st Z, r24 + ret + +/******************************************************************************/ + +/* + * void omac_noekeon_last(const void* buffer, uint8_t length_b, const void* key, noekeon_omac_ctx_t* ctx){ + * while(length_b>128){ + * omac_noekeon_next(buffer, key, ctx); + * buffer = (uint8_t*)buffer +16; + * length_b -= 128; + * } + * uint8_t pad[16]; + * omac_noekeon_comppad(pad, key, length_b); + * memxor(pad, buffer, (length_b+7)/8); + * omac_noekeon_next(pad, key, ctx); + *} + */ +/* + * param buffer in r24:r25 + * param length_b in r22 + * param key in r20:r21 + * param ctx in r18:r19 + */ +.global omac_noekeon_last +omac_noekeon_last: + push_range 10, 16 + push_ r28, r29 + movw r28, r24 /* buffer */ + movw r12, r20 /* key */ + movw r14, r18 /* ctx */ + mov r16, r22 /* length_b */ +1: + cpi r16, 129 + brlo 2f + movw r22, r20 + movw r20, r18 + rcall omac_noekeon_next + adiw r28, 16 + subi r16, 128 +2: + stack_alloc 16 + adiw r30, 1 + movw r10, r30 + movw r24, r30 + movw r22, r12 + mov r20, r16 + rcall omac_noekeon_comppad + movw r30, r10 + subi r16, -7 + lsr r16 + lsr r16 + lsr r16 + breq 4f +3: + ld r0, Z + ld r24, Y+ + eor r0, r24 + st Z+, r0 + dec r16 + brne 3b +4: + movw r24, r10 + movw r22, r12 + movw r20, r14 + rcall omac_noekeon_next + stack_free 16 + + pop_ r29, r28 + pop_range 10, 16 + ret + +/******************************************************************************/ + +/* + *void omac_noekeon(void* dest, const void* msg, uint16_t msglength_b, + * const void* key, uint8_t t){ + * omac_noekeon_init(dest); + * if(t!=0xff) + * omac_noekeon_tweak(t,key,dest); + * while(msglength_b>128){ + * omac_noekeon_next(msg, key, dest); + * msg = (uint8_t*)msg +16; + * msglength_b -= 128; + * } + * omac_noekeon_last(msg, msglength_b, key, dest); + *} + */ +/* + * param dest in r24:r25 + * param msg in r22:r23 + * param msglength_b in r20:r21 + * param key in r18:r19 + * param t in r16 + */ +MSG0 = 28 +MSG1 = 29 +KEY0 = 10 +KEY1 = 11 +LEN0 = 12 +LEN1 = 13 +DST0 = 14 +DST1 = 15 + +.global omac_noekeon +omac_noekeon: + push_ r28, r29 + push_range 10, 17 + movw MSG0, r22 /* msg */ + movw KEY0, r18 /* key */ + movw LEN0, r20 /* msglength_b */ + movw DST0, r24 /* dest */ + /* omac_noekeon_init(dest); */ + rcall omac_noekeon_init + cpi r16, 0xff + breq 1f + mov r24, r16 + movw r22, KEY0 + movw r20, DST0 + /* omac_noekeon_tweak(t,key,dest); */ + rcall omac_noekeon_tweak +1: + movw r16, LEN0 + tst r17 + breq 4f +3: + movw r24, MSG0 + movw r22, KEY0 + movw r20, DST0 + /* omac_noekeon_next(msg, key, dest); */ + rcall omac_noekeon_next + adiw MSG0, 16 + subi r16, 128 + sez + sbci r17, 0 /* wont change Z if result is zero */ + brne 3b +4: + movw r24, MSG0 + mov r22, r16 + movw r20, KEY0 + movw r18, DST0 + /* omac_noekeon_last(msg, msglength_b, key, dest); */ + call omac_noekeon_last + + pop_range 10, 17 + pop_ r29, r28 + ret + + + + + + + + + + + + + + + + diff --git a/noekeon/omac_noekeon.h b/noekeon/omac_noekeon.h new file mode 100644 index 0000000..c9f1067 --- /dev/null +++ b/noekeon/omac_noekeon.h @@ -0,0 +1,44 @@ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008, 2009 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 . +*/ +/* + * \author Daniel Otte + * \email daniel.otte@rub.de + * \license GPLv3 or later + * + * + * + */ + +#ifndef NOEKEON_OMAC_H_ +#define NOEKEON_OMAC_H_ + +#include "noekeon/noekeon.h" +#include + +typedef uint8_t omac_noekeon_ctx_t[16]; + +void omac_noekeon_init(omac_noekeon_ctx_t* ctx); +void omac_noekeon_tweak(uint8_t t, const void* key, omac_noekeon_ctx_t* ctx); +void omac_noekeon_next(const void* buffer, const void* key, + omac_noekeon_ctx_t* ctx); +void omac_noekeon_last(const void* buffer, uint8_t length_b, const void* key, + omac_noekeon_ctx_t* ctx); +void omac_noekeon(void* dest, const void* msg, uint16_t msglength_b, + const void* key, uint8_t t); + +#endif /*NOEKEON_OMAC_H_*/ diff --git a/noekeon/omac_noekeon_C.c b/noekeon/omac_noekeon_C.c new file mode 100644 index 0000000..923fc48 --- /dev/null +++ b/noekeon/omac_noekeon_C.c @@ -0,0 +1,74 @@ +#include "noekeon/noekeon.h" +#include "omac_noekeon.h" +#include "memxor/memxor.h" +#include +#include + + +void omac_noekeon_init(omac_noekeon_ctx_t* ctx){ + memset(ctx, 0, 16); +} + + +void omac_noekeon_tweak(uint8_t t, const void* key, omac_noekeon_ctx_t* ctx){ + *ctx[15] = t; + noekeon_enc(ctx, key); +} + +void omac_noekeon_next(const void* buffer, const void* key, omac_noekeon_ctx_t* ctx){ + memxor(ctx, buffer, 16); + noekeon_enc(ctx, key); +} + +static +void omac_noekeon_comppad(uint8_t* pad, const void* key, uint8_t length_b){ + uint8_t c1,c2,r,j; + memset(pad, 0, 16); + noekeon_enc(pad, key); + r=(length_b==128)?1:2; + for(;r!=0;--r){ + c1=0; + for(j=0;j<16;++j){ + c2 = c1; + c1 = (pad[15-j])>>7; + pad[15-j] = ((pad[15-j])<<1) | c2; + } + if(c1){ + pad[15] ^= 0x87; + } + } + if(length_b<128){ + pad[(length_b)/8] ^= 0x80 >> (length_b%8); + } +} + +void omac_noekeon_last(const void* buffer, uint8_t length_b, const void* key, omac_noekeon_ctx_t* ctx){ + while(length_b>128){ + omac_noekeon_next(buffer, key, ctx); + buffer = (uint8_t*)buffer +16; + length_b -= 128; + } + uint8_t pad[16]; + omac_noekeon_comppad(pad, key, length_b); + memxor(pad, buffer, (length_b+7)/8); + omac_noekeon_next(pad, key, ctx); +} + + +void omac_noekeon(void* dest, const void* msg, uint16_t msglength_b, + const void* key, uint8_t t){ + omac_noekeon_init(dest); + if(t!=0xff) + omac_noekeon_tweak(t,key,dest); + while(msglength_b>128){ + omac_noekeon_next(msg, key, dest); + msg = (uint8_t*)msg +16; + msglength_b -= 128; + } + omac_noekeon_last(msg, msglength_b, key, dest); +} + + + + +