--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <avr/pgmspace.h>
+#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));
+}
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCAL_BASIC_H_
+#define BCAL_BASIC_H_
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "blockcipher_descriptor.h"
+#include "keysize_descriptor.h"
+#include <avr/pgmspace.h>
+
+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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <string.h>
+#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);
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCALCBC_H_
+#define BCALCBC_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdint.h>
+#include <string.h>
+#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; i<ctx->blocksize_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; i<ctx->size_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; i<ctx->blocksize_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; i<ctx->size_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;
+ }
+}
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef BCALCFB_BIT_H_
+#define BCALCFB_BIT_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdint.h>
+#include <string.h>
+#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;
+ }
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCALCFB_BYTE_H_
+#define BCALCFB_BYTE_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdint.h>
+#include <string.h>
+#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);
+}
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCALCMAC_H_
+#define BCALCMAC_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdint.h>
+#include <string.h>
+#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);
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCALCTR_H_
+#define BCALCTR_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#include <stdint.h>
+#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);
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BCALEAX_H_
+#define BCALEAX_H_
+
+#include <stdint.h>
+#include <string.h>
+#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_ */
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdint.h>
+#include <string.h>
+#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);
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef BCALOFB_H_
+#define BCALOFB_H_
+
+#include <stdint.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * \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 <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <avr/pgmspace.h>
+
+#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);
+ }
+}
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * \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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes128.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes128.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#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;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes192.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes192.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#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;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes256.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_aes256.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#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;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_camellia128.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_camellia128.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "camellia.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t camellia128_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_cast5.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_cast5.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "cast5.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t cast5_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_cast6.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-04-03
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_cast6.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-04-03
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "cast6.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t cast6_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_des.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_des.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "des.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t des_desc;
--- /dev/null
+/* bcal_noekeon.c */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* bcal_noekeon.h */
+
+#include <avr/pgmspace.h>
+#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;
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_present.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_present.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "present.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t present_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_rc5.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_rc5.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "rc5.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t rc5_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_rc6.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_rc6.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "rc6.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t rc6_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_seed.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_seed.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "seed.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t seed_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_serpent.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_serpent.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "serpent.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t serpent_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_skipjack.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_skipjack.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "skipjack.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t skipjack_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_tdes.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_tdes.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "des.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t tdes_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_tdes.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-02
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "des.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t tdes2_desc;
+
+#endif /* BCAL_TDES2_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish1024.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish1024.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "threefish.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t threefish1024_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish256.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish256.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "threefish.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t threefish256_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish512.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_threefish512.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "threefish.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t threefish512_desc;
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_xtea.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file bcal_xtea.h
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-01-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include "blockcipher_descriptor.h"
+#include "xtea.h"
+#include "keysize_descriptor.h"
+
+extern const bcdesc_t xtea_desc;
--- /dev/null
+sx#include\([^"<]*["<]\)noekeonx#include\1noekeon/noekeonx
+sq#include\([^"<]*["<]\)memxorq#include\1memxor/memxorq
+sq#include\([^"<]*["<]\)gf256mulq#include\1gf256mul/gf256mulq
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * 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 <avr/io.h>
+#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
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+#ifndef GF256MUL_H_
+#define GF256MUL_H_
+
+/**
+ * \author Daniel Otte
+ * \email daniel.otte@rub.de
+ * \date 2008-12-19
+ * \license GPLv3
+ * \brief
+ *
+ *
+ */
+
+#include <stdint.h>
+
+uint8_t gf256mul(uint8_t a, uint8_t b, uint8_t reducer);
+
+#endif /* GF256MUL_H_ */
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+#include "hfal-basic.h"
+#include <stdlib.h>
+
+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;
+}
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef HFAL_BASIC_H_
+#define HFAL_BASIC_H_
+
+#include <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#include <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+#include "hfal-basic.h"
+#include <stdlib.h>
+
+#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; i<bs/8; ++i){
+ buffer[i] ^= IPAD;
+ }
+ init = pgm_read_word(&(hash_descriptor->init));
+ nextBlock = pgm_read_word(&(hash_descriptor->nextBlock));
+ init(ctx->ctx);
+ init(ctx->finctx);
+ nextBlock(ctx->ctx, buffer);
+ for(i=0; i<bs/8; ++i){
+ buffer[i] ^= IPAD^OPAD;
+ }
+ nextBlock(ctx->finctx, 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);
+}
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef HFAL_HMAC_H_
+#define HFAL_HMAC_H_
+
+#include <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+#include <avr/pgmspace.h>
+
+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);
+ }
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <avr/pgmspace.h>
+
+#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);
+ }
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+#include <avr/pgmspace.h>
+
+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"));
+}
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+
+void hfal_test(const hfdesc_t* hd, void* msg, uint32_t length_b);
+
+#endif /* HFAL_TEST_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_blake_large.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-05-08
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t blake48_desc;
+extern const hfdesc_t blake64_desc;
+
+#endif /* HFAL_BLAKE_LARGE_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_blake_small.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-05-05
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t blake28_desc;
+extern const hfdesc_t blake32_desc;
+
+#endif /* HFAL_BLAKE_SMALL_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_bmw_large.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-04-28
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t bmw384_desc;
+extern const hfdesc_t bmw512_desc;
+
+#endif /* HFAL_BMW_LARGE_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_bmw_small.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-04-28
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t bmw224_desc;
+extern const hfdesc_t bmw256_desc;
+
+#endif /* HFAL_BMW_SMALL_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_cubehash.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef HFAL_CUBEHASH_H_
+#define HFAL_CUBEHASH_H_
+
+#include <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_echo.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-21
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef HFAL_ECHO_H_
+#define HFAL_ECHO_H_
+
+#include <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_groestl_large.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-05-05
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t groestl384_desc;
+extern const hfdesc_t groestl512_desc;
+
+#endif /* HFAL_GROESTL_LARGE_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_groestl_small.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-05-05
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t groestl224_desc;
+extern const hfdesc_t groestl256_desc;
+
+#endif /* HFAL_GROESTL_SMALL_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_keccak.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2010-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_md5.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t md5_desc;
+
+#endif /* HFAL_MD5_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_sha1.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-04
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t sha1_desc;
+
+#endif /* HFAL_SHA1_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_sha256.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-04
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t sha256_desc;
+
+#endif /* HFAL_SHA256_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_shabal.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-04-20
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_skein1024.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-03-13
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_skein256.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-03-13
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_skein512.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-03-13
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#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_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_twister224.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-04
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t twister224_desc;
+
+#endif /* HFAL_TWISTER224_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_twister256.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t twister256_desc;
+
+#endif /* HFAL_TWISTER256_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_twister384.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t twister384_desc;
+
+#endif /* HFAL_TWISTER384_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \file hfal_twister512.c
+ * \email daniel.otte@rub.de
+ * \author Daniel Otte
+ * \date 2009-02-09
+ * \license GPLv3 or later
+ *
+ */
+
+#include <avr/pgmspace.h>
+#include <stdlib.h>
+#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
+};
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/**
+ * \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 <avr/pgmspace.h>
+#include "hashfunction_descriptor.h"
+
+extern const hfdesc_t twister512_desc;
+
+#endif /* HFAL_TWISTER512_H_ */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+
+/*
+ * 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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+#ifndef MEMXOR_H_
+#define MEMXOR_H_
+#include <stdint.h>
+
+void memxor(void* dest, const void* src, uint16_t n);
+
+#endif
--- /dev/null
+#include <stdint.h>
+
+#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;
+ }
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3 or later
+ *
+ *
+ *
+ */
+
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __AVR__
+ #include <avr/pgmspace.h>
+#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)<<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<ROUND_NR; ++i){
+ noekeon_round((uint32_t*)keyb, (uint32_t*)buffer, rc, 0);
+#ifdef __AVR__
+ rc = pgm_read_byte(rc_tab+i);
+#else
+ rc = rc_tab[i];
+#endif
+ }
+ ((uint8_t*)buffer)[RC_POS] ^= rc;
+ theta((uint32_t*)keyb, (uint32_t*)buffer);
+
+ changendian(buffer);
+}
+
+
+void noekeon_dec(void* buffer, const void* key){
+ uint8_t rc;
+ int8_t i;
+ uint8_t nullv[16];
+ uint8_t dkey[16];
+
+
+ changendian(buffer);
+
+ memset(nullv, 0, 16);
+ memcpy(dkey, key, 16);
+ changendian(dkey);
+
+ theta((uint32_t*)nullv, (uint32_t*)dkey);
+// cli_putstr_P(PSTR("\r\nTheta: "));
+// cli_hexdump(dkey, 16);
+
+ for(i=ROUND_NR-1; 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);
+}
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+#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 <stdint.h>
+
+/** \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_*/
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * noekeon assembler implementation for avr
+ * author: Daniel Otte
+ * email: daniel.otte@rub.de
+ * license: GPLv3
+ */
+
+#include <avr/io.h>
+
+.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
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+#ifndef NOEKEON_CBC_ENC_H_
+#define NOEKEON_CBC_ENC_H_
+
+#include <stdint.h>
+#include "noekeon/noekeon.h"
+
+void noekeon_cbc_enc(void* buffer, uint8_t block_cnt, const void* key);
+
+#endif /*NOEKEON_CBC_ENC_H_*/
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 */
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+#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_*/
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+ */
+/**
+ * \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 <stdint.h>
+#include <string.h>
+
+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);
+}
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+ */
+/**
+ * \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 <stdint.h>
+
+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_*/
+
+
--- /dev/null
+/* 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \author Daniel Otte
+ * \email daniel.otte@rub.de
+ * \date 2008-08-24
+ * \license GPLv3 or later
+ *
+ *
+ *
+ */
+
+#include <avr/io.h>
+#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
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
--- /dev/null
+/*
+ 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 <http://www.gnu.org/licenses/>.
+*/
+/*
+ * \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 <stdint.h>
+
+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_*/
--- /dev/null
+#include "noekeon/noekeon.h"
+#include "omac_noekeon.h"
+#include "memxor/memxor.h"
+#include <string.h>
+#include <stdint.h>
+
+
+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);
+}
+
+
+
+
+
projects / avr-crypto-lib.git / commitdiff