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     list[len - 1] = 0;
 190   }
 191
 192   return list;
 193 }
 194
 195 /* Creates the hash value and returns it to the return_hash argument. */
 196
 197 void silc_hash_make(SilcHash hash, const unsigned char *data,
 198                     uint32 len, unsigned char *return_hash)
 199 {
 200   hash->hash->init(hash->context);
 201   hash->hash->update(hash->context, (unsigned char *)data, len);
 202   hash->hash->final(hash->context, return_hash);
 203 }
 204
 205 /* Creates fingerprint of the data. If `hash' is NULL SHA1 is used as
 206    default hash function. The returned fingerprint must be free's by the
 207    caller. */
 208
 209 char *silc_hash_fingerprint(SilcHash hash, const unsigned char *data,
 210                             uint32 data_len)
 211 {
 212   unsigned char h[32];
 213
 214   if (!hash)
 215     silc_hash_alloc("sha1", &hash);
 216
 217   silc_hash_make(hash, data, data_len, h);
 218   return silc_fingerprint(h, hash->hash->hash_len);
 219 }
 220
 221 static const char vo[]= "aeiouy";
 222 static const char co[]= "bcdfghklmnprstvzx";
 223
 224 /* Creates a babbleprint (Bubble Babble Encoding, developed by Antti
 225    Huima (draft-huima-babble-01.txt)), by first computing real fingerprint
 226    using `hash' or if NULL, then using SHA1, and then encoding the
 227    fingerprint to the babbleprint. */
 228
 229 char *silc_hash_babbleprint(SilcHash hash, const unsigned char *data,
 230                             uint32 data_len)
 231 {
 232   char *babbleprint;
 233   unsigned char hval[32];
 234   unsigned int a, b, c, d, e, check;
 235   int i, k, out_len;
 236
 237   if (!hash)
 238     silc_hash_alloc("sha1", &hash);
 239
 240   /* Take fingerprint */
 241   silc_hash_make(hash, data, data_len, hval);
 242
 243   /* Encode babbleprint */
 244   out_len = (((hash->hash->hash_len + 1) / 2) + 1) * 6;
 245   babbleprint = silc_calloc(out_len, sizeof(*babbleprint));
 246   babbleprint[0] = co[16];
 247
 248   check = 1;
 249   for (i = 0, k = 1; i < hash->hash->hash_len - 1; i += 2, k += 6) {
 250     a = (((hval[i] >> 6) & 3) + check) % 6;
 251     b = (hval[i] >> 2) & 15;
 252     c = ((hval[i] & 3) + (check / 6)) % 6;
 253     d = (hval[i + 1] >> 4) & 15;
 254     e = hval[i + 1] & 15;
 255
 256     check = ((check * 5) + (hval[i] * 7) + hval[i + 1]) % 36;
 257
 258     babbleprint[k + 0] = vo[a];
 259     babbleprint[k + 1] = co[b];
 260     babbleprint[k + 2] = vo[c];
 261     babbleprint[k + 3] = co[d];
 262     babbleprint[k + 4] = '-';
 263     babbleprint[k + 5] = co[e];
 264   }
 265
 266   if ((hash->hash->hash_len % 2) != 0) {
 267     a = (((hval[i] >> 6) & 3) + check) % 6;
 268     b = (hval[i] >> 2) & 15;
 269     c = ((hval[i] & 3) + (check / 6)) % 6;
 270     babbleprint[k + 0] = vo[a];
 271     babbleprint[k + 1] = co[b];
 272     babbleprint[k + 2] = vo[c];
 273   } else {
 274     a = check % 6;
 275     b = 16;
 276     c = check / 6;
 277     babbleprint[k + 0] = vo[a];
 278     babbleprint[k + 1] = co[b];
 279     babbleprint[k + 2] = vo[c];
 280   }
 281   babbleprint[k + 3] = co[16];
 282
 283   return babbleprint;
 284 }