lib/silccrypt/silchash.c

   1 /*
   2
   3   silchash.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20 /* $Id$ */
  21
  22 #include "silcincludes.h"
  23
  24 #include "md5.h"
  25 #include "sha1.h"
  26
  27 /* List of dynamically registered hash functions. */
  28 SilcDList silc_hash_list = NULL;
  29
  30 /* Default hash functions for silc_hash_register_default(). */
  31 SilcHashObject silc_default_hash[] =
  32 {
  33   { "sha1", 20, 64, silc_sha1_init, silc_sha1_update, silc_sha1_final,
  34     silc_sha1_transform, silc_sha1_context_len },
  35   { "md5", 16, 64, silc_md5_init, silc_md5_update, silc_md5_final,
  36     silc_md5_transform, silc_md5_context_len },
  37
  38   { NULL, 0, 0, NULL, NULL, NULL, NULL, NULL }
  39 };
  40
  41 /* Registers a new hash function into the SILC. This function is used at
  42    the initialization of the SILC. */
  43
  44 bool silc_hash_register(SilcHashObject *hash)
  45 {
  46   SilcHashObject *new;
  47
  48   SILC_LOG_DEBUG(("Registering new hash function `%s'", hash->name));
  49
  50   new = silc_calloc(1, sizeof(*new));
  51   new->name = strdup(hash->name);
  52   new->hash_len = hash->hash_len;
  53   new->block_len = hash->block_len;
  54   new->init = hash->init;
  55   new->update = hash->update;
  56   new->final = hash->final;
  57   new->transform = hash->transform;
  58   new->context_len = hash->context_len;
  59
  60   /* Add to list */
  61   if (silc_hash_list == NULL)
  62     silc_hash_list = silc_dlist_init();
  63   silc_dlist_add(silc_hash_list, new);
  64
  65   return TRUE;
  66 }
  67
  68 /* Unregister a hash function from the SILC. */
  69
  70 bool silc_hash_unregister(SilcHashObject *hash)
  71 {
  72   SilcHashObject *entry;
  73
  74   SILC_LOG_DEBUG(("Unregistering hash function"));
  75
  76   if (!silc_hash_list)
  77     return FALSE;
  78
  79   silc_dlist_start(silc_hash_list);
  80   while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
  81     if (hash == SILC_ALL_HASH_FUNCTIONS || entry == hash) {
  82       silc_dlist_del(silc_hash_list, entry);
  83
  84       if (silc_dlist_count(silc_hash_list) == 0) {
  85         silc_dlist_uninit(silc_hash_list);
  86         silc_hash_list = NULL;
  87       }
  88
  89       return TRUE;
  90     }
  91   }
  92
  93   return FALSE;
  94 }
  95
  96 /* Function that registers all the default hash funcs (all builtin ones).
  97    The application may use this to register the default hash funcs if
  98    specific hash funcs in any specific order is not wanted. */
  99
 100 bool silc_hash_register_default(void)
 101 {
 102   int i;
 103
 104   for (i = 0; silc_default_hash[i].name; i++)
 105     silc_hash_register(&(silc_default_hash[i]));
 106
 107   return TRUE;
 108 }
 109
 110 /* Allocates a new SilcHash object. New object is returned into new_hash
 111    argument. */
 112
 113 bool silc_hash_alloc(const unsigned char *name, SilcHash *new_hash)
 114 {
 115   SilcHashObject *entry;
 116
 117   SILC_LOG_DEBUG(("Allocating new hash object"));
 118
 119   if (silc_hash_list) {
 120     silc_dlist_start(silc_hash_list);
 121     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
 122       if (!strcmp(entry->name, name)) {
 123         *new_hash = silc_calloc(1, sizeof(**new_hash));
 124         (*new_hash)->hash = entry;
 125         (*new_hash)->context = silc_calloc(1, entry->context_len());
 126         (*new_hash)->make_hash = silc_hash_make;
 127         return TRUE;
 128       }
 129     }
 130   }
 131
 132   return FALSE;
 133 }
 134
 135 /* Free's the SilcHash object */
 136
 137 void silc_hash_free(SilcHash hash)
 138 {
 139   if (hash) {
 140     silc_free(hash->context);
 141     silc_free(hash);
 142   }
 143 }
 144
 145 /* Returns the length of the hash digest. */
 146
 147 uint32 silc_hash_len(SilcHash hash)
 148 {
 149   return hash->hash->hash_len;
 150 }
 151
 152 /* Returns TRUE if hash algorithm `name' is supported. */
 153
 154 bool silc_hash_is_supported(const unsigned char *name)
 155 {
 156   SilcHashObject *entry;
 157
 158   if (silc_hash_list) {
 159     silc_dlist_start(silc_hash_list);
 160     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
 161       if (!strcmp(entry->name, name))
 162         return TRUE;
 163     }
 164   }
 165
 166   return FALSE;
 167 }
 168
 169 /* Returns comma separated list of supported hash functions. */
 170
 171 char *silc_hash_get_supported(void)
 172 {
 173   SilcHashObject *entry;
 174   char *list = NULL;
 175   int len;
 176
 177   len = 0;
 178   if (silc_hash_list) {
 179     silc_dlist_start(silc_hash_list);
 180     while ((entry = silc_dlist_get(silc_hash_list)) != SILC_LIST_END) {
 181       len += strlen(entry->name);
 182       list = silc_realloc(list, len + 1);
 183
 184       memcpy(list + (len - strlen(entry->name)),
 185              entry->name, strlen(entry->name));
 186       memcpy(list + len, ",", 1);
 187       len++;
 188     }
 189   }
 190
 191   list[len - 1] = 0;
 192
 193   return list;
 194 }
 195
 196 /* Creates the hash value and returns it to the return_hash argument. */
 197
 198 void silc_hash_make(SilcHash hash, const unsigned char *data,
 199                     uint32 len, unsigned char *return_hash)
 200 {
 201   hash->hash->init(hash->context);
 202   hash->hash->update(hash->context, (unsigned char *)data, len);
 203   hash->hash->final(hash->context, return_hash);
 204 }
 205
 206 /* Creates fingerprint of the data. If `hash' is NULL SHA1 is used as
 207    default hash function. The returned fingerprint must be free's by the
 208    caller. */
 209
 210 char *silc_hash_fingerprint(SilcHash hash, const unsigned char *data,
 211                             uint32 data_len)
 212 {
 213   char fingerprint[64], *cp;
 214   unsigned char h[32];
 215   int i;
 216
 217   if (!hash)
 218     silc_hash_alloc("sha1", &hash);
 219
 220   silc_hash_make(hash, data, data_len, h);
 221
 222   memset(fingerprint, 0, sizeof(fingerprint));
 223   cp = fingerprint;
 224   for (i = 0; i < hash->hash->hash_len; i++) {
 225     snprintf(cp, sizeof(fingerprint), "%02X", h[i]);
 226     cp += 2;
 227
 228     if ((i + 1) % 2 == 0)
 229       snprintf(cp++, sizeof(fingerprint), " ");
 230
 231     if ((i + 1) % 10 == 0)
 232       snprintf(cp++, sizeof(fingerprint), " ");
 233   }
 234   i--;
 235   if ((i + 1) % 2 == 0)
 236     cp[-2] = 0;
 237   if ((i + 1) % 10 == 0)
 238     cp[-1] = 0;
 239
 240   return strdup(fingerprint);
 241 }