From: bg Date: Mon, 16 Feb 2009 14:18:19 +0000 (+0000) Subject: +MUGI X-Git-Url: https://git.cryptolib.org/?a=commitdiff_plain;h=2dc047a070be7f0d64f4d4e7f4296a9650af07dc;p=avr-crypto-lib.git +MUGI --- diff --git a/aes128_dec.h b/aes128_dec.h index 97e04d1..f6015d8 100644 --- a/aes128_dec.h +++ b/aes128_dec.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-30 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES128_DEC_H_ @@ -31,6 +31,14 @@ #include "aes.h" #include "aes_dec.h" +/** \fn void aes128_dec(void* buffer, aes128_ctx_t* ctx) + * \brief decrypt with 128 bit key. + * + * This function decrypts one block with the AES algorithm under control of + * a keyschedule produced from a 128 bit key. + * \param buffer pointer to the block to decrypt + * \param ctx pointer to the key schedule + */ void aes128_dec(void* buffer, aes128_ctx_t* ctx); diff --git a/aes128_enc.h b/aes128_enc.h index 169e5c9..5cb4953 100644 --- a/aes128_enc.h +++ b/aes128_enc.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-30 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES128_ENC_H_ @@ -31,6 +31,15 @@ #include "aes.h" #include "aes_enc.h" + +/** \fn void aes128_enc(void* buffer, aes128_ctx_t* ctx) + * \brief encrypt with 128 bit key. + * + * This function encrypts one block with the AES algorithm under control of + * a keyschedule produced from a 128 bit key. + * \param buffer pointer to the block to encrypt + * \param ctx pointer to the key schedule + */ void aes128_enc(void* buffer, aes128_ctx_t* ctx); diff --git a/aes192_dec.h b/aes192_dec.h index 44d237a..299edf9 100644 --- a/aes192_dec.h +++ b/aes192_dec.h @@ -17,12 +17,12 @@ along with this program. If not, see . */ /** - * \file aes128_dec.h + * \file aes192_dec.h * \email daniel.otte@rub.de * \author Daniel Otte * \date 2008-12-31 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES192_DEC_H_ @@ -31,6 +31,14 @@ #include "aes.h" #include "aes_dec.h" +/** \fn void aes192_dec(void* buffer, aes192_ctx_t* ctx) + * \brief decrypt with 192 bit key. + * + * This function decrypts one block with the AES algorithm under control of + * a keyschedule produced from a 192 bit key. + * \param buffer pointer to the block to decrypt + * \param ctx pointer to the key schedule + */ void aes192_dec(void* buffer, aes192_ctx_t* ctx); diff --git a/aes192_enc.h b/aes192_enc.h index b82504b..30b79ec 100644 --- a/aes192_enc.h +++ b/aes192_enc.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-31 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES192_ENC_H_ @@ -31,6 +31,15 @@ #include "aes.h" #include "aes_enc.h" + +/** \fn void aes192_enc(void* buffer, aes192_ctx_t* ctx) + * \brief encrypt with 192 bit key. + * + * This function encrypts one block with the AES algorithm under control of + * a keyschedule produced from a 192 bit key. + * \param buffer pointer to the block to encrypt + * \param ctx pointer to the key schedule + */ void aes192_enc(void* buffer, aes192_ctx_t* ctx); diff --git a/aes256_dec.h b/aes256_dec.h index b8abfe8..3c77c7b 100644 --- a/aes256_dec.h +++ b/aes256_dec.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-31 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES256_DEC_H_ @@ -31,6 +31,14 @@ #include "aes.h" #include "aes_dec.h" +/** \fn void aes256_dec(void* buffer, aes256_ctx_t* ctx) + * \brief decrypt with 256 bit key. + * + * This function decrypts one block with the AES algorithm under control of + * a keyschedule produced from a 256 bit key. + * \param buffer pointer to the block to decrypt + * \param ctx pointer to the key schedule + */ void aes256_dec(void* buffer, aes256_ctx_t* ctx); diff --git a/aes256_enc.h b/aes256_enc.h index f5ba0fa..b42b0f3 100644 --- a/aes256_enc.h +++ b/aes256_enc.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-31 * \license GPLv3 or later - * + * \ingroup AES */ #ifndef AES256_ENC_H_ @@ -31,6 +31,15 @@ #include "aes.h" #include "aes_enc.h" + +/** \fn void aes256_enc(void* buffer, aes256_ctx_t* ctx) + * \brief encrypt with 256 bit key. + * + * This function encrypts one block with the AES algorithm under control of + * a keyschedule produced from a 256 bit key. + * \param buffer pointer to the block to encrypt + * \param ctx pointer to the key schedule + */ void aes256_enc(void* buffer, aes256_ctx_t* ctx); diff --git a/aes_keyschedule.h b/aes_keyschedule.h index 7d6d840..b013971 100644 --- a/aes_keyschedule.h +++ b/aes_keyschedule.h @@ -22,7 +22,7 @@ * \author Daniel Otte * \date 2008-12-30 * \license GPLv3 or later - * + * \ingroup AES */ @@ -30,11 +30,46 @@ #define AES_KEYSCHEDULE_H_ #include "aes.h" - +/** \fn void aes_init(const void* key, uint16_t keysize_b, aes_genctx_t* ctx) + * \brief initialize the keyschedule + * + * This function computes the keyschedule from a given key with a given length + * and stores it in the context variable + * \param key pointer to the key material + * \param keysize_b length of the key in bits (valid are 128, 192 and 256) + * \param ctx pointer to the context where the keyschedule should be stored + */ void aes_init(const void* key, uint16_t keysize_b, aes_genctx_t* ctx); +/** \fn void aes128_init(const void* key, aes128_ctx_t* ctx) + * \brief initialize the keyschedule for 128 bit key + * + * This function computes the keyschedule from a given 128 bit key + * and stores it in the context variable + * \param key pointer to the key material + * \param ctx pointer to the context where the keyschedule should be stored + */ void aes128_init(const void* key, aes128_ctx_t* ctx); + +/** \fn void aes192_init(const void* key, aes192_ctx_t* ctx) + * \brief initialize the keyschedule for 192 bit key + * + * This function computes the keyschedule from a given 192 bit key + * and stores it in the context variable + * \param key pointer to the key material + * \param ctx pointer to the context where the keyschedule should be stored + */ void aes192_init(const void* key, aes192_ctx_t* ctx); + +/** \fn void aes256_init(const void* key, aes256_ctx_t* ctx) + * \brief initialize the keyschedule for 256 bit key + * + * This function computes the keyschedule from a given 256 bit key + * and stores it in the context variable + * \param key pointer to the key material + * \param ctx pointer to the context where the keyschedule should be stored + */ void aes256_init(const void* key, aes256_ctx_t* ctx); #endif /* AES_KEYSCHEDULE_H_ */ + diff --git a/arcfour.h b/arcfour.h index 3daaf81..d332d7f 100644 --- a/arcfour.h +++ b/arcfour.h @@ -64,7 +64,7 @@ typedef struct arcfour_ctx_st { } arcfour_ctx_t; -/** \fn void arcfour_init(arcfour_ctx_t *ctx, void *key, uint8_t length_B) +/** \fn void arcfour_init(const void *key, uint8_t length_B, arcfour_ctx_t *ctx) * \brief setup a context with a key * * This function sets up a ::arcfour_ctx_t context using diff --git a/cast5.h b/cast5.h index f7d4cb9..b014f7c 100644 --- a/cast5.h +++ b/cast5.h @@ -56,7 +56,7 @@ typedef struct cast5_ctx_st{ } cast5_ctx_t; -/** \fn void cast5_init(void* key, uint8_t keylength_b, cast5_ctx_t* s); +/** \fn void cast5_init(const void* key, uint16_t keylength_b, cast5_ctx_t* s); * \brief generate keyschedule/contex for CAST-5 * * This function generates the keyschedule from the supplied key for the @@ -67,7 +67,7 @@ typedef struct cast5_ctx_st{ */ void cast5_init(const void* key, uint16_t keylength_b, cast5_ctx_t* s); -/** \fn void cast5_enc(void* block, const cast5_ctx_t *s); +/** \fn void cast5_enc(void* block, const cast5_ctx_t* s); * \brief encrypt a block with the CAST-5 algorithm * * This function encrypts a block of 64 bits (8 bytes) with the CAST-5 algorithm. @@ -76,9 +76,9 @@ void cast5_init(const void* key, uint16_t keylength_b, cast5_ctx_t* s); * \param block pointer to the block which gets encrypted * \param s pointer to the keyschedule/context */ -void cast5_enc(void* block, const cast5_ctx_t *s); +void cast5_enc(void* block, const cast5_ctx_t* s); -/** \fn void cast5_dec(void* block, const cast5_ctx_t *s); +/** \fn void cast5_dec(void* block, const cast5_ctx_t* s); * \brief decrypt a block with the CAST-5 algorithm * * This function decrypts a block of 64 bits (8 bytes) with the CAST-5 algorithm. @@ -87,7 +87,7 @@ void cast5_enc(void* block, const cast5_ctx_t *s); * \param block pointer to the block which gets decrypted * \param s pointer to the keyschedule/context */ -void cast5_dec(void* block, const cast5_ctx_t *s); +void cast5_dec(void* block, const cast5_ctx_t* s); diff --git a/hashfunction_descriptor.h b/hashfunction_descriptor.h index e1347dc..8b5faed 100644 --- a/hashfunction_descriptor.h +++ b/hashfunction_descriptor.h @@ -21,18 +21,31 @@ typedef void(*hf_mem_fpt)(void*, const void*, uint32_t); #define HFDESC_TYPE_HASHFUNCTION 0x02 typedef struct { + /** typefield, always 2 for hash functions */ uint8_t type; /* 2 == hashfunction */ + /** flags, currently unused should be set to zero */ uint8_t flags; + /** name, flash pointer to the name string */ PGM_P name; + /** ctxsize_B, size of the hash context in bytes */ uint16_t ctxsize_B; + /** blocksize_b, size of an input block in bits */ uint16_t blocksize_b; + /** hashsize_b, size of the output hash value in bits */ uint16_t hashsize_b; - + /** init, function pointer to the algorithms init function */ hf_init_fpt init; + /** nextBlock, function pointer to the algorithms nextBlock function */ hf_nextBlock_fpt nextBlock; + /** lastBlock, function pointer to the algorithms lastBlock function */ hf_lastBlock_fpt lastBlock; + /** ctx2hash, function pointer to the algorithms ctx2hash function */ hf_ctx2hash_fpt ctx2hash; + /** free, function pointer to the algorithms free function or NULL if + * there is no such function */ hf_free_fpt free; + /** mem, function pointer to a function which hashes a message in RAM + * completely or NULL if there is no such function */ hf_mem_fpt mem; } hfdesc_t; /* blockcipher descriptor type */ diff --git a/host/get_test.rb b/host/get_test.rb index 2a12de1..cc8b48a 100644 --- a/host/get_test.rb +++ b/host/get_test.rb @@ -111,7 +111,7 @@ param=(ARGV.size>=7)?ARGV[6]:""; puts("\nPort: "+ARGV[0]+ "@"+ARGV[1]+" "+ARGV[2]+"N"+ARGV[3]+"\n"); $linewidth = 16 $sp = SerialPort.new(ARGV[0], ARGV[1].to_i, ARGV[2].to_i, ARGV[3].to_i, SerialPort::NONE); -$sp.read_timeout=1*60*1000; # 5 minutes +$sp.read_timeout=1000; # 1 secound $extended_wait=100; $sp.write(command); diff --git a/host/nessie_check.rb b/host/nessie_check.rb index 9ec83b2..56bd17b 100644 --- a/host/nessie_check.rb +++ b/host/nessie_check.rb @@ -22,19 +22,15 @@ def skip_header(file) begin l = file.gets().strip end until /[*]{10,}.*/.match(l) - puts("DBG 0.0: "+l) begin l = file.gets().strip end until /[*]{10,}.*/.match(l) - puts("DBG 0.1: "+l) begin l = file.gets().strip end until /[=]{5,}.*/.match(l) - puts("DBG 0.2: "+l) begin l = file.gets().strip end until /[=]{5,}.*/.match(l) - puts("DBG 0.3: "+l) end def get_next_assign(file, i) @@ -82,17 +78,16 @@ def compare(fname1, fname2) a = get_next_assign(file1, 0) b = get_next_assign(file2, 1) return if(a==nil or b==nil) - puts("") if pos%$linewidth==0 and pos!=0 - putc((a==b)?'*':'!') -# puts("a == nil") if a==nil -# puts("b == nil") if b==nil - + if not $quiet + puts("") if pos%$linewidth==0 and pos!=0 + putc((a==b)?'*':'!') + pos +=1 + end if(a!=b and a!=nil and b!=nil) $error = 1 puts("a key: "+a[0]+" value: "+a[1]) puts("b key: "+b[0]+" value: "+b[1]) end - pos +=1 end until a==nil or b==nil end @@ -100,14 +95,26 @@ $error = 0 $linewidth=64 $last_assign=[nil, nil] -if ARGV.size!=2 +if ARGV.size<2 or ARGV.size>3 STDERR.print <. +*/ +/** + * \file mugi.c + * \author Daniel Otte + * \email daniel.otte@rub.de + * \date 2009-02-15 + * \brief implementation of the MUGI key stream generator + * \license GPLv3 or later + */ + +#include +#include +#include +#include +#include "aes_sbox.h" +#include "mugi.h" +#include "gf256mul.h" + +/* +#include "test_src/cli.h" / * only for debugging * / + +void dump_mugi_ctx(mugi_ctx_t* ctx){ + uint8_t i; + cli_putstr_P(PSTR("\r\n== MUGI CTX DUMP==\r\n a:")); + cli_hexdump(&(ctx->a[0]), 8); + cli_putc(' '); + cli_hexdump(&(ctx->a[1]), 8); + cli_putc(' '); + cli_hexdump(&(ctx->a[2]), 8); + cli_putstr_P(PSTR("\r\n b: ")); + for(i=0; i<4; ++i){ + cli_putstr_P(PSTR("\r\n ")); + cli_hexdump(&(ctx->b[i*4+0]), 8); + cli_putc(' '); + cli_hexdump(&(ctx->b[i*4+1]), 8); + cli_putc(' '); + cli_hexdump(&(ctx->b[i*4+2]), 8); + cli_putc(' '); + cli_hexdump(&(ctx->b[i*4+3]), 8); + } +} +*/ + +#define C0 0x08c9bcf367e6096all +#define C1 0x3ba7ca8485ae67bbll +#define C2 0x2bf894fe72f36e3cll + +#define GF256MUL_2(a) (gf256mul(2, (a), 0x1b)) + +uint64_t changeendian64(uint64_t a){ + uint8_t r[8]; + r[0] = ((uint8_t*)&a)[7]; + r[1] = ((uint8_t*)&a)[6]; + r[2] = ((uint8_t*)&a)[5]; + r[3] = ((uint8_t*)&a)[4]; + r[4] = ((uint8_t*)&a)[3]; + r[5] = ((uint8_t*)&a)[2]; + r[6] = ((uint8_t*)&a)[1]; + r[7] = ((uint8_t*)&a)[0]; + return *((uint64_t*)r); +} + +static +uint64_t rotl64(uint64_t a, uint8_t i){ + uint64_t r; + r=changeendian64(a); + r=(r<>(64-i)); + r=changeendian64(r); + return r; +} + +static +uint64_t rotr64(uint64_t a, uint8_t i){ + uint64_t r; + r=changeendian64(a); + r=(r>>i | r<<(64-i)); + r=changeendian64(r); + return r; +} + + +#define T(x) (((uint8_t*)&t)[(x)]) +#define D(y) (((uint8_t*)dest)[(y)]) +static void mugi_f(uint64_t* dest, uint64_t* a, uint64_t* b){ + uint64_t t; + uint8_t i,x; + t = (*a); + if(b) + t ^= (*b); + for(i=0; i<8; ++i) + T(i) = pgm_read_byte(aes_sbox+T(i)); + + x = T(0) ^ T(1) ^ T(2) ^ T(3); + D(4) = + GF256MUL_2(T(0)^T(1)) + ^ T(0) + ^ x; + D(5) = + GF256MUL_2(T(1)^T(2)) + ^ T(1) + ^ x; + D(2) = + GF256MUL_2(T(2)^T(3)) + ^ T(2) + ^ x; + D(3) = + GF256MUL_2(T(3)^T(0)) + ^ T(3) + ^ x; + x = T(4) ^ T(5) ^ T(6) ^ T(7); + D(0) = + GF256MUL_2(T(4)^T(5)) + ^ T(4) + ^ x; + D(1) = + GF256MUL_2(T(5)^T(6)) + ^ T(5) + ^ x; + D(6) = + GF256MUL_2(T(6)^T(7)) + ^ T(6) + ^ x; + D(7) = + GF256MUL_2(T(7)^T(4)) + ^ T(7) + ^ x; +} + +static +void mugi_rho(mugi_ctx_t* ctx){ + uint64_t t,bx; + t = ctx->a[1]; + ctx->a[1] = ctx->a[2]; + ctx->a[2] = ctx->a[0]; + ctx->a[0] = t; + mugi_f(&t, &(ctx->a[0]), &(ctx->b[4])); + ctx->a[1] ^= t ^ C1; + bx = rotl64(ctx->b[10], 17); + mugi_f(&t, &(ctx->a[0]), &bx); + ctx->a[2] ^= t ^ C2; +} + +static +void mugi_rho_init(uint64_t* a){ + uint64_t t; + t = a[1]; + a[1] = a[2]; + a[2] = a[0]; + a[0] = t; + mugi_f(&t, &(a[0]), NULL); + a[1] ^= t ^ C1; + mugi_f(&t, &(a[0]), NULL); + a[2] ^= t ^ C2; +} + +static +void mugi_lambda(uint64_t* b, uint64_t *a){ + uint8_t i; + uint64_t t; + t=b[15]; + for(i=15; i!=0; --i){ + b[i]=b[i-1]; + } + b[0] = t ^ *a; + b[4] ^= b[8]; + b[10] ^= rotl64(b[14], 32); +} + +void mugi_init(const void* key, const void* iv, mugi_ctx_t* ctx){ + uint8_t i; + uint64_t a0; + memcpy(ctx->a, key, 128/8); + ctx->a[2] = rotl64(ctx->a[0], 7) ^ rotr64(ctx->a[1], 7) ^ C0; + for(i=0; i<16;i++){ + mugi_rho_init(ctx->a); + ctx->b[15-i] = ctx->a[0]; + } + ctx->a[0] ^= ((uint64_t*)iv)[0]; + ctx->a[1] ^= ((uint64_t*)iv)[1]; + ctx->a[2] ^= rotl64(((uint64_t*)iv)[0], 7) ^ rotr64(((uint64_t*)iv)[1], 7) ^ C0; + for(i=0; i<16;i++){ + mugi_rho_init(ctx->a); + } + for(i=0; i<15;i++){ + a0 = ctx->a[0]; + mugi_rho(ctx); + mugi_lambda(ctx->b, &a0); + } + a0=0x00; +} + +uint64_t mugi_gen(mugi_ctx_t* ctx){ + uint64_t r; + r=ctx->a[0]; + mugi_rho(ctx); + mugi_lambda(ctx->b, &r); + r=ctx->a[2]; + return r; +} diff --git a/mugi.h b/mugi.h new file mode 100644 index 0000000..809b9fd --- /dev/null +++ b/mugi.h @@ -0,0 +1,41 @@ +/* mugi.h */ +/* + This file is part of the AVR-Crypto-Lib. + Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +/** + * \file mugi.h + * \author Daniel Otte + * \date 2009-02-15 + * \brief implementation of the MUGI key stream generator + * \license GPLv3 or later + */ + +#ifndef MUGI_H_ +#define MUGI_H_ + +#include + +typedef struct{ + uint64_t a[3]; + uint64_t b[16]; +}mugi_ctx_t; /* 152 bytes in total */ + +void mugi_init(const void* key, const void* iv, mugi_ctx_t* ctx); +uint64_t mugi_gen(mugi_ctx_t* ctx); + + +#endif /* MUGI_H_ */ diff --git a/noekeon.h b/noekeon.h index c637ce2..9c046f3 100644 --- a/noekeon.h +++ b/noekeon.h @@ -20,40 +20,49 @@ #define NOEKEON_H_ /** + * \file noekeon.h * \author Daniel Otte * \email daniel.otte@rub.de * \date 2008-04-11 - * \license GPLv3 - * \brief - * - * + * \license GPLv3 or later + * \brief Implementation of the Noekeon block cipher + * \ingroup Noekeon + * This is an implementation of the Noekeon block cipher. + * For more details on Noekeon see http://gro.noekeon.org/ */ #include +/** \typedef noekeon_ctx_t + * \brief holds key data for indirect mode + * + * A variable of this type may hold the key data for the indirect mode. + * For direct mode simply pass the key directly to the encryption or + * decryption function. + */ typedef uint8_t noekeon_ctx_t[16]; -/** \fn void noekeon_enc(void* buffer, void* key) +/** \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) + * 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_enc(void* buffer, 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) + * (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) @@ -61,12 +70,12 @@ void noekeon_enc(void* buffer, const void* key); void noekeon_dec(void* buffer, const void* key); -/** \fn void noekeon_init(void* key, noekeon_ctx_t* ctx) +/** \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 + * 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) diff --git a/seed.h b/seed.h index fed393f..78d7d59 100644 --- a/seed.h +++ b/seed.h @@ -42,7 +42,7 @@ typedef struct{ /******************************************************************************/ -/** \fn void seed_init(void * key, seed_ctx_t * ctx) +/** \fn void seed_init(const void * key, seed_ctx_t * ctx) * \brief initializes context for SEED operation * * This function copys the key material into a context variable. @@ -52,7 +52,7 @@ typedef struct{ */ void seed_init(const void * key, seed_ctx_t * ctx); -/** \fn void seed_enc(void * buffer, seed_ctx_t * ctx) +/** \fn void seed_enc(void * buffer,const seed_ctx_t * ctx) * \brief encrypt a block with SEED * * This function encrypts a block of 64 bits (8 bytes) with the SEED algorithm. @@ -65,7 +65,7 @@ void seed_init(const void * key, seed_ctx_t * ctx); void seed_enc(void * buffer, const seed_ctx_t * ctx); -/** \fn void seed_dec(void * buffer, seed_ctx_t * ctx) +/** \fn void seed_dec(void * buffer, const seed_ctx_t * ctx) * \brief decrypt a block with SEED * * This function decrypts a block of 64 bits (8 bytes) with the SEED algorithm. diff --git a/sha1.h b/sha1.h index c993741..17cda9b 100644 --- a/sha1.h +++ b/sha1.h @@ -17,12 +17,13 @@ along with this program. If not, see . */ /** - * \file sha1.c + * \file sha1.h * \author Daniel Otte + * \email daniel.otte@rub.de * \date 2006-10-08 - * \par License: - * GPL - * \brief SHA-1 declaration. + * \license GPLv3 or later + * \brief SHA-1 declaration. + * \ingroup SHA-1 * */ @@ -30,31 +31,86 @@ #define SHA1_H_ #include +/** \def SHA1_HASH_BITS + * definees the size of a SHA-1 hash in bits + */ + +/** \def SHA1_HASH_BYTES + * definees the size of a SHA-1 hash in bytes + */ +/** \def SHA1_BLOCK_BITS + * definees the size of a SHA-1 input block in bits + */ +/** \def SHA1_BLOCK_BYTES + * definees the size of a SHA-1 input block in bytes + */ #define SHA1_HASH_BITS 160 #define SHA1_HASH_BYTES (SHA1_HASH_BITS/8) #define SHA1_BLOCK_BITS 512 #define SHA1_BLOCK_BYTES (SHA1_BLOCK_BITS/8) -/** +/** \typedef sha1_ctx_t * \brief SHA-1 context type * + * A vatiable of this type may hold the state of a SHA-1 hashing process */ typedef struct { uint32_t h[5]; uint64_t length; } sha1_ctx_t; +/** \typedef sha1_hash_t + * \brief hash value type + * A variable of this type may hold a SHA-1 hash value + */ typedef uint8_t sha1_hash_t[SHA1_HASH_BITS/8]; +/** \fn sha1_init(sha1_ctx_t *state) + * \brief initializes a SHA-1 context + * This function sets a ::sha1_ctx_t variable to the initialization vector + * for SHA-1 hashing. + * \param state pointer to the SHA-1 context variable + */ void sha1_init(sha1_ctx_t *state); +/** \fn sha1_nextBlock(sha1_ctx_t *state, void* block) + * \brief process one input block + * This function processes one input block and updates the hash context + * accordingly + * \param state pointer to the state variable to update + * \param block pointer to the message block to process + */ void sha1_nextBlock (sha1_ctx_t *state, void* block); + +/** \fn sha1_lastBlock(sha1_ctx_t *state, void* block, uint16_t length_b) + * \brief processes the given block and finalizes the context + * This function processes the last block in a SHA-1 hashing process. + * The block should have a maximum length of a single input block. + * \param state pointer to the state variable to update and finalize + * \param block pointer to themessage block to process + * \param length_b length of the message block in bits + */ void sha1_lastBlock (sha1_ctx_t *state, void* block, uint16_t length_b); +/** \fn sha1_ctx2hash(sha1_hash_t *dest, sha1_ctx_t *state) + * \brief convert a state variable into an actual hash value + * Writes the hash value corresponding to the state to the memory pointed by dest. + * \param dest pointer to the hash value destination + * \param state pointer to the hash context + */ void sha1_ctx2hash (sha1_hash_t *dest, sha1_ctx_t *state); -void sha1 (sha1_hash_t *dest, void* msg, uint32_t length_b); + +/** \fn sha1(sha1_hash_t *dest, void* msg, uint32_t length_b) + * \brief hashing a message which in located entirely in RAM + * This function automatically hashes a message which is entirely in RAM with + * the SHA-1 hashing algorithm. + * \param dest pointer to the hash value destination + * \param msg pointer to the message which should be hashed + * \param length_b length of the message in bits + */ +void sha1(sha1_hash_t *dest, void* msg, uint32_t length_b); diff --git a/string-extras.h b/string-extras.h index 457f9a7..bf2cbf7 100644 --- a/string-extras.h +++ b/string-extras.h @@ -1,4 +1,4 @@ -/* string_extras.h */ +/* string-extras.h */ /* This file is part of the AVR-Crypto-Lib. Copyright (C) 2008 Daniel Otte (daniel.otte@rub.de) @@ -17,13 +17,39 @@ along with this program. If not, see . */ /** - * \file string_extras.h + * \file string-extras.h * \author Daniel Otte * \date 2006-05-16 * \license GPLv3 or later * */ +/** \fn stridentcnt_P(char* a, PGM_P b) + * \brief counts the number of identic chars + * + * This function compares the supplyed strings and returns the index of the + * first char where the strings differ. + * \param a pointer to string in RAM + * \param b pointer to string in Flash + * \return index of the first char where \c a and \c b differ + */ uint16_t stridentcnt_P(char* a, PGM_P b); + +/** \fn firstword_length(char* s) + * \brief compute the length of the first word in supllyed string + * + * This function searches for the first whitespace in the string and returns the + * number of chars before the first whitespace. + * \param s string + * \return number of chars in first word + */ uint16_t firstword_length(char* s); -char* strstrip(char*); + +/** \fn strstrip(char* str) + * \brief removes whitespace at the beginning and the end of a string + * + * This function removes whitespaces at the end of a string. + * \param str sting + * \return pointer to the first non-whitespace char in string + */ +char* strstrip(char* str); diff --git a/test_src/main-mugi-test.c b/test_src/main-mugi-test.c new file mode 100644 index 0000000..2255d1a --- /dev/null +++ b/test_src/main-mugi-test.c @@ -0,0 +1,141 @@ +/* main-mugi-test.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 . +*/ +/* + * MUGI test-suit + * +*/ + +#include "config.h" +#include "serial-tools.h" +#include "uart.h" +#include "debug.h" + +#include "mugi.h" +#include "nessie_stream_test.h" +#include "cli.h" +#include "performance_test.h" + +#include +#include +#include + +char* algo_name = "MUGI"; + +/***************************************************************************** + * additional validation-functions * + *****************************************************************************/ + +void testrun_performance_mugi(void){ + uint64_t t; + char str[16]; + uint8_t key[16]; + uint8_t iv[16]; + mugi_ctx_t ctx; + + calibrateTimer(); + print_overhead(); + + memset(key, 0, 16); + memset(iv, 0, 16); + + startTimer(1); + mugi_init(key, iv, &ctx); + t = stopTimer(); + cli_putstr_P(PSTR("\r\n\tctx-gen time: ")); + ultoa((unsigned long)t, str, 10); + cli_putstr(str); + + startTimer(1); + mugi_gen(&ctx); + t = stopTimer(); + cli_putstr_P(PSTR("\r\n\tencrypt time: ")); + ultoa((unsigned long)t, str, 10); + cli_putstr(str); + + cli_putstr_P(PSTR("\r\n")); +} + + +void testrun_mugi(void){ + uint8_t key[]={ 0x00, 0x01, 0x02, 0x03, + 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x0b, + 0x0c, 0x0d, 0x0e, 0x0f }; + uint8_t iv[]= { 0xf0, 0xe0, 0xd0, 0xc0, + 0xb0, 0xa0, 0x90, 0x80, + 0x70, 0x60, 0x50, 0x40, + 0x30, 0x20, 0x10, 0x00 }; + mugi_ctx_t ctx; + uint64_t output; + uint8_t i; + mugi_init(key, iv, &ctx); + cli_putstr_P(PSTR("\r\nkey = ")); + cli_hexdump2(key, 16); + cli_putstr_P(PSTR("\r\niv = ")); + cli_hexdump2(iv, 16); + for(i=0; i<8; ++i){ + output = mugi_gen(&ctx); + cli_putstr_P(PSTR("\r\nMUGI output: ")); + cli_hexdump(&output, 8); + } + + memset(key, 0, 16); + memset(iv, 0, 16); + mugi_init(key, iv, &ctx); + cli_putstr_P(PSTR("\r\nkey = ")); + cli_hexdump2(key, 16); + cli_putstr_P(PSTR("\r\niv = ")); + cli_hexdump2(iv, 16); + for(i=0; i<8; ++i){ + output = mugi_gen(&ctx); + cli_putstr_P(PSTR("\r\nMUGI output: ")); + cli_hexdump(&output, 8); + } +} + +/***************************************************************************** + * main * + *****************************************************************************/ + +const char nessie_str[] PROGMEM = "nessie"; +const char test_str[] PROGMEM = "test"; +const char performance_str[] PROGMEM = "performance"; +const char echo_str[] PROGMEM = "echo"; + +cmdlist_entry_t cmdlist[] PROGMEM = { +// { nessie_str, NULL, testrun_nessie_arcfour }, + { test_str, NULL, testrun_mugi}, + { performance_str, NULL, testrun_performance_mugi}, + { echo_str, (void*)1, (void_fpt)echo_ctrl}, + { NULL, NULL, NULL} +}; + +int main (void){ + DEBUG_INIT(); + uart_putstr("\r\n"); + cli_rx = uart_getc; + cli_tx = uart_putc; + for(;;){ + uart_putstr_P(PSTR("\r\n\r\nCrypto-VS (")); + uart_putstr(algo_name); + uart_putstr_P(PSTR(")\r\nloaded and running\r\n")); + cmd_interface(cmdlist); + } +} +