+some changes in make architecture +hmac-sha1

diff --git a/Makefile b/Makefile
index e72513346c294da2825890ffc8091b7f55badf1c..ec201f44fa4baaa99cc16f1386d3409d34577f16 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -150,7 +150,7 @@ $(1)_FLASH: $(2)
 endef
 
 $(foreach algo, $(ALGORITHMS),$(eval $(call FLASH_TEMPLATE, $(algo), \
-                $(patsubst %.o,%.hex,$(firstword $($(algo)_TEST_BIN)))) ))  
+                $(patsubst $(BIN_DIR)%.o,$(TESTBIN_DIR)%.hex,$(firstword $($(algo)_TEST_BIN)))) ))  
 
 #-------------------------------------------------------------------------------
 

diff --git a/hmac-sha256.c b/hmac-sha256.c
index a0ad1dcdcb20cb9fa8e3481c1f078d43c0dd4169..274c9c470e5f0acf441653d1a99de000f6224d8b 100644 (file)
--- a/hmac-sha256.c
+++ b/hmac-sha256.c
@@ -40,41 +40,41 @@ typedef sha256_ctx_t hmac_sha256_ctx_t;
 
 #ifndef HMAC_SHORTONLY
 
-void hmac_sha256_init(hmac_sha256_ctx_t *s, void* key, uint16_t kl){
-       uint8_t buffer[SHA256_BLOCK_BITS/8];
+void hmac_sha256_init(hmac_sha256_ctx_t *s, void* key, uint16_t keylength_b){
+       uint8_t buffer[SHA256_HASH_BYTES];
        uint8_t i;
        
-       memset(buffer, 0, SHA256_BLOCK_BITS/8);
-       if (kl > SHA256_BLOCK_BITS){
-               sha256((void*)buffer, key, kl);
+       memset(buffer, 0, SHA256_HASH_BYTES);
+       if (keylength_b > SHA256_BLOCK_BITS){
+               sha256((void*)buffer, key, keylength_b);
        } else {
-               memcpy(buffer, key, (kl+7)/8);
+               memcpy(buffer, key, (keylength_b+7)/8);
        }
        
-       for (i=0; i<SHA256_BLOCK_BITS/8; ++i){
+       for (i=0; i<SHA256_HASH_BYTES; ++i){
                buffer[i] ^= IPAD;
        }
        
        sha256_init(s);
        sha256_nextBlock(s, buffer);
 #if defined SECURE_WIPE_BUFFER
-       memset(buffer, 0, SHA256_BLOCK_BITS/8);
+       memset(buffer, 0, SHA256_HASH_BYTES);
 #endif
 }
 
-void hmac_sha256_final(hmac_sha256_ctx_t *s, void* key, uint16_t kl){
-       uint8_t buffer[SHA256_BLOCK_BITS/8];
+void hmac_sha256_final(hmac_sha256_ctx_t *s, void* key, uint16_t keylength_b){
+       uint8_t buffer[SHA256_HASH_BYTES];
        uint8_t i;
        sha256_ctx_t a;
        
-       memset(buffer, 0, SHA256_BLOCK_BITS/8);
-       if (kl > SHA256_BLOCK_BITS){
-               sha256((void*)buffer, key, kl);
+       memset(buffer, 0, SHA256_HASH_BYTES);
+       if (keylength_b > SHA256_BLOCK_BITS){
+               sha256((void*)buffer, key, keylength_b);
        } else {
-               memcpy(buffer, key, (kl+7)/8);
+               memcpy(buffer, key, (keylength_b+7)/8);
        }
        
-       for (i=0; i<SHA256_BLOCK_BITS/8; ++i){
+       for (i=0; i<SHA256_HASH_BYTES; ++i){
                buffer[i] ^= OPAD;
        }
        
@@ -84,7 +84,7 @@ void hmac_sha256_final(hmac_sha256_ctx_t *s, void* key, uint16_t kl){
        sha256_lastBlock(&a, buffer, SHA256_HASH_BITS);
        memcpy(s, &a, sizeof(sha256_ctx_t));
 #if defined SECURE_WIPE_BUFFER
-       memset(buffer, 0, SHA256_BLOCK_BITS/8);
+       memset(buffer, 0, SHA256_HASH_BYTES);
        memset(a.h, 0, 8*4);
 #endif 
 }
@@ -100,33 +100,33 @@ void hmac_sha256_lastBlock()
  * keylength in bits!
  * message length in bits!
  */
-void hmac_sha256(void* dest, void* key, uint16_t kl, void* msg, uint64_t ml){ /* a one-shot*/
+void hmac_sha256(void* dest, void* key, uint16_t keylength_b, void* msg, uint64_t msglength_b){ /* a one-shot*/
        sha256_ctx_t s;
        uint8_t i;
-       uint8_t buffer[SHA256_BLOCK_BITS/8];
+       uint8_t buffer[SHA256_HASH_BYTES];
        
-       memset(buffer, 0, SHA256_BLOCK_BITS/8);
+       memset(buffer, 0, SHA256_HASH_BYTES);
        
        /* if key is larger than a block we have to hash it*/
-       if (kl > SHA256_BLOCK_BITS){
-               sha256((void*)buffer, key, kl);
+       if (keylength_b > SHA256_BLOCK_BITS){
+               sha256((void*)buffer, key, keylength_b);
        } else {
-               memcpy(buffer, key, (kl+7)/8);
+               memcpy(buffer, key, (keylength_b+7)/8);
        }
        
-       for (i=0; i<SHA256_BLOCK_BITS/8; ++i){
+       for (i=0; i<SHA256_HASH_BYTES; ++i){
                buffer[i] ^= IPAD;
        }
        sha256_init(&s);
        sha256_nextBlock(&s, buffer);
-       while (ml >= SHA256_BLOCK_BITS){
+       while (msglength_b >= SHA256_BLOCK_BITS){
                sha256_nextBlock(&s, msg);
-               msg = (uint8_t*)msg + SHA256_BLOCK_BITS/8;
-               ml -=  SHA256_BLOCK_BITS;
+               msg = (uint8_t*)msg + SHA256_HASH_BYTES;
+               msglength_b -=  SHA256_BLOCK_BITS;
        }
-       sha256_lastBlock(&s, msg, ml);
+       sha256_lastBlock(&s, msg, msglength_b);
        /* since buffer still contains key xor ipad we can do ... */
-       for (i=0; i<SHA256_BLOCK_BITS/8; ++i){
+       for (i=0; i<SHA256_HASH_BYTES; ++i){
                buffer[i] ^= IPAD ^ OPAD;
        }
        sha256_ctx2hash(dest, &s); /* save inner hash temporary to dest */

diff --git a/hmac-sha256.h b/hmac-sha256.h
index 00e00c2d383aca8991c1cc1d52d1d73b626e88a0..ad43f60c534d87d874b32a408d4bb9fdc43892d3 100644 (file)
--- a/hmac-sha256.h
+++ b/hmac-sha256.h
@@ -27,9 +27,9 @@
 typedef sha256_ctx_t hmac_sha256_ctx_t;
 
 
-void hmac_sha256_init(hmac_sha256_ctx_t *s, void* key, uint16_t kl);
-void hmac_sha256_final(hmac_sha256_ctx_t *s, void* key, uint16_t kl);
-void hmac_sha256(void* dest, void* key, uint16_t kl, void* msg, uint64_t ml);
+void hmac_sha256_init(hmac_sha256_ctx_t *s, void* key, uint16_t keylength_b);
+void hmac_sha256_final(hmac_sha256_ctx_t *s, void* key, uint16_t keylength_b);
+void hmac_sha256(void* dest, void* key, uint16_t keylength_b, void* msg, uint64_t msglength_b);
 
 
 #endif /*HMACSHA256_H_*/

diff --git a/sha1.h b/sha1.h
index 675369e9a25b2f117d1415339a2a8786d760b173..cd4805da8e5a33c16b54ade337e58e68ce437687 100644 (file)
--- a/sha1.h
+++ b/sha1.h
@@ -19,7 +19,7 @@
 /**
  * \file       sha1.c
  * \author     Daniel Otte
- * \date       08.10.2006
+ * \date       2006-10-08
  * \par License:
  * GPL
  * \brief SHA-1 declaration.
@@ -33,7 +33,9 @@
 
 
 #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)
 
 /**
  * \brief SHA-1 context type
@@ -49,12 +51,10 @@ typedef uint8_t sha1_hash_t[SHA1_HASH_BITS/8];
 void sha1_init(sha1_ctx_t *state);
 
 void sha1_nextBlock (sha1_ctx_t *state, void* block);
-void sha1_lastBlock (sha1_ctx_t *state, void* block, uint16_t length);
+void sha1_lastBlock (sha1_ctx_t *state, void* block, uint16_t length_b);
 
 void sha1_ctx2hash (sha1_hash_t *dest, sha1_ctx_t *state);
-void sha1 (sha1_hash_t *dest, void* msg, uint32_t length);
-//uint32_t change_endian32(uint32_t x);
-
+void sha1 (sha1_hash_t *dest, void* msg, uint32_t length_b);
 
 
 

diff --git a/sha256-asm.h b/sha256-asm.h
deleted file mode 100644 (file)
index a033b00..0000000
--- a/sha256-asm.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/* sha256-asm.h */
-/*
-    This file is part of the Crypto-avr-lib/microcrypt-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               sha256-asm.h
- * \author     Daniel Otte 
- * \date               16.05.2006
- * \par License        
- * GPL
- * 
- */
-
-#ifndef SHA256ASM_H_
-#define SHA256ASM_H_
-
-
-#define SHA256_HASH_BITS  256
-#define SHA256_BLOCK_BITS 512
-
-typedef struct {
-       uint32_t h[8];
-       uint64_t length;
-} sha256_ctx_t;
-
-typedef uint8_t sha256_hash_t[SHA256_HASH_BITS/8];
-
-void sha256_ctx2hash(sha256_hash_t *dest, sha256_ctx_t *state);
-void sha256(sha256_hash_t *dest, void* msg, uint32_t length);
-void sha256_init(sha256_ctx_t *state);
-void sha256_nextBlock(sha256_ctx_t *state, void* block);
-void sha256_lastBlock(sha256_ctx_t *state, void* block, uint16_t length);
-uint32_t rotr32(uint32_t, uint8_t);
-uint32_t change_endian32(uint32_t x);
-
-#endif /*SHA256ASM_H_*/

diff --git a/sha256.h b/sha256.h
index b76aa5f40c46acb7d90bb6aec3b862e1fef8ef96..ec1dac0045d73b61b37c486912d6010b94677cfe 100644 (file)
--- a/sha256.h
+++ b/sha256.h
@@ -35,7 +35,9 @@
 
 
 #define SHA256_HASH_BITS  256
+#define SHA256_HASH_BYTES (SHA256_HASH_BITS/8)
 #define SHA256_BLOCK_BITS 512
+#define SHA256_BLOCK_BYTES (SHA256_BLOCK_BITS/8)
 
 /**
  * \brief sha256 context type
@@ -46,19 +48,19 @@ typedef struct {
        uint64_t length;
 } sha256_ctx_t;
 
-typedef uint8_t sha256_hash_t[SHA256_HASH_BITS/8];
+typedef uint8_t sha256_hash_t[SHA256_HASH_BYTES];
 
 void sha256_init(sha256_ctx_t *state);
 
 void sha256_nextBlock (sha256_ctx_t *state, const void* block);
-void sha256_lastBlock(sha256_ctx_t *state, const void* block, uint16_t length);
+void sha256_lastBlock(sha256_ctx_t *state, const void* block, uint16_t length_b);
 
 void sha256_ctx2hash(sha256_hash_t *dest, const sha256_ctx_t *state);
 
 /*
  * length in bits!
  */
-void sha256(sha256_hash_t *dest, const void* msg, uint32_t length);
+void sha256(sha256_hash_t *dest, const void* msg, uint32_t length_b);
 uint32_t change_endian32(uint32_t x);