X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilccrypt%2Fsilchmac.c;h=86754f230c977682c5ce2547ec94c94f25586d39;hb=e7b6c157b80152bf9fb9266e6bdd93f9fb0db776;hp=1cce72cd2d4d3e175ba69c308abc4db812f4bac9;hpb=e2c551b9693b6d42e5997b9df416a17fb94c1ccb;p=silc.git diff --git a/lib/silccrypt/silchmac.c b/lib/silccrypt/silchmac.c index 1cce72cd..86754f23 100644 --- a/lib/silccrypt/silchmac.c +++ b/lib/silccrypt/silchmac.c @@ -1,10 +1,10 @@ /* - silchmac.c + silchmac.c Author: Pekka Riikonen - Copyright (C) 1999 - 2001 Pekka Riikonen + Copyright (C) 1999 - 2007 Pekka Riikonen 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 @@ -18,31 +18,33 @@ */ /* $Id$ */ -#include "silcincludes.h" +#include "silc.h" /* HMAC context */ struct SilcHmacStruct { SilcHmacObject *hmac; SilcHash hash; - - unsigned char *key; - SilcUInt32 key_len; - unsigned char inner_pad[64]; unsigned char outer_pad[64]; - bool allocated_hash; /* TRUE if the hash was allocated */ + unsigned char *key; + unsigned int key_len : 31; + unsigned int allocated_hash : 1; /* TRUE if the hash was allocated */ }; -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN /* List of dynamically registered HMACs. */ SilcDList silc_hmac_list = NULL; -#endif /* SILC_EPOC */ +#endif /* SILC_SYMBIAN */ /* Default hmacs for silc_hmac_register_default(). */ const SilcHmacObject silc_default_hmacs[] = { + { "hmac-sha256-96", 12 }, + { "hmac-sha512-96", 12 }, { "hmac-sha1-96", 12 }, { "hmac-md5-96", 12 }, + { "hmac-sha256", 32 }, + { "hmac-sha512", 64 }, { "hmac-sha1", 20 }, { "hmac-md5", 16 }, @@ -54,7 +56,7 @@ static void silc_hmac_init_internal(SilcHmac hmac, unsigned char *key, { SilcHash hash = hmac->hash; SilcUInt32 block_len; - unsigned char hvalue[20]; + unsigned char hvalue[SILC_HASH_MAXLEN]; int i; memset(hmac->inner_pad, 0, sizeof(hmac->inner_pad)); @@ -81,12 +83,11 @@ static void silc_hmac_init_internal(SilcHmac hmac, unsigned char *key, } } -/* Registers a new HMAC into the SILC. This function is used at the - initialization of the SILC. */ +/* Registers a new HMAC */ -bool silc_hmac_register(const SilcHmacObject *hmac) +SilcBool silc_hmac_register(const SilcHmacObject *hmac) { -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN SilcHmacObject *new; SILC_LOG_DEBUG(("Registering new HMAC `%s'", hmac->name)); @@ -102,6 +103,8 @@ bool silc_hmac_register(const SilcHmacObject *hmac) } new = silc_calloc(1, sizeof(*new)); + if (!new) + return FALSE; new->name = strdup(hmac->name); new->len = hmac->len; @@ -110,15 +113,15 @@ bool silc_hmac_register(const SilcHmacObject *hmac) silc_hmac_list = silc_dlist_init(); silc_dlist_add(silc_hmac_list, new); -#endif /* SILC_EPOC */ +#endif /* SILC_SYMBIAN */ return TRUE; } -/* Unregister a HMAC from the SILC. */ +/* Unregister a HMAC */ -bool silc_hmac_unregister(SilcHmacObject *hmac) +SilcBool silc_hmac_unregister(SilcHmacObject *hmac) { -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN SilcHmacObject *entry; SILC_LOG_DEBUG(("Unregistering HMAC")); @@ -142,29 +145,23 @@ bool silc_hmac_unregister(SilcHmacObject *hmac) } } -#endif /* SILC_EPOC */ +#endif /* SILC_SYMBIAN */ return FALSE; } -/* Function that registers all the default hmacs (all builtin ones). - The application may use this to register the default hmacs if - specific hmacs in any specific order is not wanted. */ +/* Register default HMACs */ -bool silc_hmac_register_default(void) +SilcBool silc_hmac_register_default(void) { -#ifndef SILC_EPOC - int i; - - for (i = 0; silc_default_hmacs[i].name; i++) - silc_hmac_register(&(silc_default_hmacs[i])); - -#endif /* SILC_EPOC */ + /* We use builtin HMACs */ return TRUE; } -bool silc_hmac_unregister_all(void) +/* Unregister all HMACs */ + +SilcBool silc_hmac_unregister_all(void) { -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN SilcHmacObject *entry; if (!silc_hmac_list) @@ -176,7 +173,7 @@ bool silc_hmac_unregister_all(void) if (!silc_hmac_list) break; } -#endif /* SILC_EPOC */ +#endif /* SILC_SYMBIAN */ return TRUE; } @@ -185,12 +182,17 @@ bool silc_hmac_unregister_all(void) of the HMAC. If it is NULL then the hash function is allocated and the name of the hash algorithm is derived from the `name'. */ -bool silc_hmac_alloc(char *name, SilcHash hash, SilcHmac *new_hmac) +SilcBool silc_hmac_alloc(const char *name, SilcHash hash, SilcHmac *new_hmac) { + SilcHmacObject *entry = NULL; + int i; + SILC_LOG_DEBUG(("Allocating new HMAC")); /* Allocate the new object */ *new_hmac = silc_calloc(1, sizeof(**new_hmac)); + if (!(*new_hmac)) + return FALSE; if (!hash) { char *tmp = strdup(name), *hname; @@ -214,21 +216,21 @@ bool silc_hmac_alloc(char *name, SilcHash hash, SilcHmac *new_hmac) (*new_hmac)->hash = hash; -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN + /* Check registered list of HMACs */ if (silc_hmac_list) { - SilcHmacObject *entry; silc_dlist_start(silc_hmac_list); while ((entry = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) { if (!strcmp(entry->name, name)) { - (*new_hmac)->hmac = entry; + (*new_hmac)->hmac = entry; return TRUE; } } } -#else - { - /* On EPOC which don't have globals we check our constant hash list. */ - int i; +#endif /* SILC_SYMBIAN */ + + if (!entry) { + /* Check builtin list of HMACs */ for (i = 0; silc_default_hmacs[i].name; i++) { if (!strcmp(silc_default_hmacs[i].name, name)) { (*new_hmac)->hmac = (SilcHmacObject *)&(silc_default_hmacs[i]); @@ -236,7 +238,6 @@ bool silc_hmac_alloc(char *name, SilcHash hash, SilcHmac *new_hmac) } } } -#endif /* SILC_EPOC */ silc_free(*new_hmac); *new_hmac = NULL; @@ -283,14 +284,15 @@ const char *silc_hmac_get_name(SilcHmac hmac) /* Returns TRUE if HMAC `name' is supported. */ -bool silc_hmac_is_supported(const char *name) +SilcBool silc_hmac_is_supported(const char *name) { -#ifndef SILC_EPOC SilcHmacObject *entry; + int i; if (!name) return FALSE; - + +#ifndef SILC_SYMBIAN if (silc_hmac_list) { silc_dlist_start(silc_hmac_list); while ((entry = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) { @@ -298,14 +300,12 @@ bool silc_hmac_is_supported(const char *name) return TRUE; } } -#else - { - int i; - for (i = 0; silc_default_hmacs[i].name; i++) - if (!strcmp(silc_default_hmacs[i].name, name)) - return TRUE; - } -#endif /* SILC_EPOC */ +#endif /* SILC_SYMBIAN */ + + for (i = 0; silc_default_hmacs[i].name; i++) + if (!strcmp(silc_default_hmacs[i].name, name)) + return TRUE; + return FALSE; } @@ -313,38 +313,47 @@ bool silc_hmac_is_supported(const char *name) char *silc_hmac_get_supported() { - SilcHmacObject *entry; + SilcHmacObject *entry, *entry2; char *list = NULL; - int len = 0; + int len = 0, i; -#ifndef SILC_EPOC +#ifndef SILC_SYMBIAN if (silc_hmac_list) { silc_dlist_start(silc_hmac_list); while ((entry = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) { len += strlen(entry->name); list = silc_realloc(list, len + 1); - - memcpy(list + (len - strlen(entry->name)), + + memcpy(list + (len - strlen(entry->name)), entry->name, strlen(entry->name)); memcpy(list + len, ",", 1); len++; } } -#else - { - int i; - for (i = 0; silc_default_hmacs[i].name; i++) { - entry = (SilcHmacObject *)&(silc_default_hmacs[i]); - len += strlen(entry->name); - list = silc_realloc(list, len + 1); - - memcpy(list + (len - strlen(entry->name)), - entry->name, strlen(entry->name)); - memcpy(list + len, ",", 1); - len++; +#endif /* SILC_SYMBIAN */ + + + for (i = 0; silc_default_hmacs[i].name; i++) { + entry = (SilcHmacObject *)&(silc_default_hmacs[i]); + + if (silc_hmac_list) { + silc_dlist_start(silc_hmac_list); + while ((entry2 = silc_dlist_get(silc_hmac_list)) != SILC_LIST_END) { + if (!strcmp(entry2->name, entry->name)) + break; + } + if (entry2) + continue; } + + len += strlen(entry->name); + list = silc_realloc(list, len + 1); + + memcpy(list + (len - strlen(entry->name)), + entry->name, strlen(entry->name)); + memcpy(list + len, ",", 1); + len++; } -#endif /* SILC_EPOC */ list[len - 1] = 0; @@ -360,11 +369,22 @@ void silc_hmac_set_key(SilcHmac hmac, const unsigned char *key, memset(hmac->key, 0, hmac->key_len); silc_free(hmac->key); } - hmac->key = silc_calloc(key_len, sizeof(unsigned char)); + hmac->key = silc_malloc(key_len); + if (!hmac->key) + return; hmac->key_len = key_len; memcpy(hmac->key, key, key_len); } +/* Return HMAC key */ + +const unsigned char *silc_hmac_get_key(SilcHmac hmac, SilcUInt32 *key_len) +{ + if (key_len) + *key_len = hmac->key_len; + return (const unsigned char *)hmac->key; +} + /* Create the HMAC. This is thee make_hmac function pointer. This uses the internal key set with silc_hmac_set_key. */ @@ -383,7 +403,7 @@ void silc_hmac_make(SilcHmac hmac, unsigned char *data, key. The key is sent as argument to the function. */ void silc_hmac_make_with_key(SilcHmac hmac, unsigned char *data, - SilcUInt32 data_len, + SilcUInt32 data_len, unsigned char *key, SilcUInt32 key_len, unsigned char *return_hash, SilcUInt32 *return_len) @@ -397,7 +417,7 @@ void silc_hmac_make_with_key(SilcHmac hmac, unsigned char *data, /* Creates the HMAC just as above except that the hash value is truncated to the truncated_len sent as argument. NOTE: One should not truncate to - less than half of the length of original hash value. However, this + less than half of the length of original hash value. However, this routine allows these dangerous truncations. */ void silc_hmac_make_truncated(SilcHmac hmac, unsigned char *data, @@ -405,7 +425,7 @@ void silc_hmac_make_truncated(SilcHmac hmac, unsigned char *data, SilcUInt32 truncated_len, unsigned char *return_hash) { - unsigned char hvalue[20]; + unsigned char hvalue[SILC_HASH_MAXLEN]; SILC_LOG_DEBUG(("Making HMAC for message")); @@ -429,7 +449,7 @@ void silc_hmac_init_with_key(SilcHmac hmac, const unsigned char *key, SilcUInt32 key_len) { SilcHash hash = hmac->hash; - silc_hmac_init_internal(hmac, hmac->key, hmac->key_len); + silc_hmac_init_internal(hmac, (unsigned char *)key, key_len); silc_hash_init(hash); silc_hash_update(hash, hmac->inner_pad, silc_hash_block_len(hash)); } @@ -449,7 +469,7 @@ void silc_hmac_final(SilcHmac hmac, unsigned char *return_hash, SilcUInt32 *return_len) { SilcHash hash = hmac->hash; - unsigned char mac[20]; + unsigned char mac[SILC_HASH_MAXLEN]; silc_hash_final(hash, mac); silc_hash_init(hash);