lib/gnutls_hash_int.c

   1 /*
   2  * Copyright (C) 2000, 2001, 2004, 2005, 2007 Free Software Foundation
   3  *
   4  * Author: Nikos Mavroyanopoulos
   5  *
   6  * This file is part of GNUTLS.
   7  *
   8  * The GNUTLS library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  21  * USA
  22  *
  23  */
  24
  25 /* This file handles all the internal functions that cope with hashes
  26  * and HMACs.
  27  */
  28
  29 #include <gnutls_int.h>
  30 #include <gnutls_hash_int.h>
  31 #include <gnutls_errors.h>
  32
  33 static inline Gc_hash _gnutls_mac2gc (gnutls_mac_algorithm_t mac)
  34 {
  35   switch (mac)
  36     {
  37     case GNUTLS_MAC_NULL:
  38       return -1;
  39       break;
  40     case GNUTLS_MAC_SHA1:
  41       return GC_SHA1;
  42       break;
  43     case GNUTLS_MAC_SHA256:
  44       return GC_SHA256;
  45       break;
  46     case GNUTLS_MAC_SHA384:
  47       return GC_SHA384;
  48       break;
  49     case GNUTLS_MAC_SHA512:
  50       return GC_SHA512;
  51       break;
  52     case GNUTLS_MAC_MD5:
  53       return GC_MD5;
  54       break;
  55     case GNUTLS_MAC_RMD160:
  56       return GC_RMD160;
  57       break;
  58     case GNUTLS_MAC_MD2:
  59       return GC_MD2;
  60       break;
  61     default:
  62       gnutls_assert ();
  63       return -1;
  64     }
  65   return -1;
  66 }
  67
  68 GNUTLS_HASH_HANDLE
  69 _gnutls_hash_init (gnutls_mac_algorithm_t algorithm)
  70 {
  71   mac_hd_t ret;
  72   int result;
  73
  74   ret = gnutls_malloc (sizeof (mac_hd_st));
  75   if (ret == NULL)
  76     {
  77       gnutls_assert ();
  78       return GNUTLS_HASH_FAILED;
  79     }
  80
  81   ret->algorithm = algorithm;
  82
  83   result = gc_hash_open (_gnutls_mac2gc (algorithm), 0, &ret->handle);
  84   if (result)
  85     {
  86       gnutls_assert ();
  87       gnutls_free (ret);
  88       ret = GNUTLS_HASH_FAILED;
  89     }
  90
  91   return ret;
  92 }
  93
  94 int
  95 _gnutls_hash_get_algo_len (gnutls_mac_algorithm_t algorithm)
  96 {
  97   int ret;
  98
  99   ret = gc_hash_digest_length (_gnutls_mac2gc (algorithm));
 100
 101   return ret;
 102
 103 }
 104
 105 int
 106 _gnutls_hash (GNUTLS_HASH_HANDLE handle, const void *text, size_t textlen)
 107 {
 108   if (textlen > 0)
 109     gc_hash_write (handle->handle, textlen, text);
 110   return 0;
 111 }
 112
 113 GNUTLS_HASH_HANDLE
 114 _gnutls_hash_copy (GNUTLS_HASH_HANDLE handle)
 115 {
 116   GNUTLS_HASH_HANDLE ret;
 117   int result;
 118
 119   ret = gnutls_malloc (sizeof (mac_hd_st));
 120
 121   if (ret == NULL)
 122     return GNUTLS_HASH_FAILED;
 123
 124   ret->algorithm = handle->algorithm;
 125   ret->key = NULL;              /* it's a hash anyway */
 126   ret->keysize = 0;
 127
 128   result = gc_hash_clone (handle->handle, &ret->handle);
 129
 130   if (result)
 131     {
 132       gnutls_free (ret);
 133       return GNUTLS_HASH_FAILED;
 134     }
 135
 136   return ret;
 137 }
 138
 139 void
 140 _gnutls_hash_deinit (GNUTLS_HASH_HANDLE handle, void *digest)
 141 {
 142   const opaque *mac;
 143   int maclen;
 144
 145   maclen = _gnutls_hash_get_algo_len (handle->algorithm);
 146
 147   mac = gc_hash_read (handle->handle);
 148   if (digest != NULL)
 149     memcpy (digest, mac, maclen);
 150
 151   gc_hash_close (handle->handle);
 152
 153   gnutls_free (handle);
 154 }
 155
 156
 157 mac_hd_t
 158 _gnutls_hmac_init (gnutls_mac_algorithm_t algorithm,
 159                    const void *key, int keylen)
 160 {
 161   mac_hd_t ret;
 162   int result;
 163
 164   ret = gnutls_malloc (sizeof (mac_hd_st));
 165   if (ret == NULL)
 166     return GNUTLS_MAC_FAILED;
 167
 168   result = gc_hash_open (_gnutls_mac2gc (algorithm), GC_HMAC, &ret->handle);
 169   if (result)
 170     {
 171       gnutls_free (ret);
 172       return GNUTLS_MAC_FAILED;
 173     }
 174
 175   gc_hash_hmac_setkey (ret->handle, keylen, key);
 176
 177   ret->algorithm = algorithm;
 178   ret->key = key;
 179   ret->keysize = keylen;
 180
 181   return ret;
 182 }
 183
 184 void
 185 _gnutls_hmac_deinit (mac_hd_t handle, void *digest)
 186 {
 187   const opaque *mac;
 188   int maclen;
 189
 190   maclen = _gnutls_hash_get_algo_len (handle->algorithm);
 191
 192   mac = gc_hash_read (handle->handle);
 193
 194   if (digest != NULL)
 195     memcpy (digest, mac, maclen);
 196
 197   gc_hash_close (handle->handle);
 198
 199   gnutls_free (handle);
 200 }
 201
 202 inline static int
 203 get_padsize (gnutls_mac_algorithm_t algorithm)
 204 {
 205   switch (algorithm)
 206     {
 207     case GNUTLS_MAC_MD5:
 208       return 48;
 209     case GNUTLS_MAC_SHA1:
 210       return 40;
 211     default:
 212       return 0;
 213     }
 214 }
 215
 216 mac_hd_t
 217 _gnutls_mac_init_ssl3 (gnutls_mac_algorithm_t algorithm, void *key,
 218                        int keylen)
 219 {
 220   mac_hd_t ret;
 221   opaque ipad[48];
 222   int padsize;
 223
 224   padsize = get_padsize (algorithm);
 225   if (padsize == 0)
 226     {
 227       gnutls_assert ();
 228       return GNUTLS_MAC_FAILED;
 229     }
 230
 231   memset (ipad, 0x36, padsize);
 232
 233   ret = _gnutls_hash_init (algorithm);
 234   if (ret != GNUTLS_HASH_FAILED)
 235     {
 236       ret->key = key;
 237       ret->keysize = keylen;
 238
 239       if (keylen > 0)
 240         _gnutls_hash (ret, key, keylen);
 241       _gnutls_hash (ret, ipad, padsize);
 242     }
 243
 244   return ret;
 245 }
 246
 247 void
 248 _gnutls_mac_deinit_ssl3 (mac_hd_t handle, void *digest)
 249 {
 250   opaque ret[MAX_HASH_SIZE];
 251   mac_hd_t td;
 252   opaque opad[48];
 253   int padsize;
 254   int block;
 255
 256   padsize = get_padsize (handle->algorithm);
 257   if (padsize == 0)
 258     {
 259       gnutls_assert ();
 260       return;
 261     }
 262
 263   memset (opad, 0x5C, padsize);
 264
 265   td = _gnutls_hash_init (handle->algorithm);
 266   if (td != GNUTLS_MAC_FAILED)
 267     {
 268       if (handle->keysize > 0)
 269         _gnutls_hash (td, handle->key, handle->keysize);
 270
 271       _gnutls_hash (td, opad, padsize);
 272       block = _gnutls_hmac_get_algo_len (handle->algorithm);
 273       _gnutls_hash_deinit (handle, ret);        /* get the previous hash */
 274       _gnutls_hash (td, ret, block);
 275
 276       _gnutls_hash_deinit (td, digest);
 277     }
 278 }
 279
 280 void
 281 _gnutls_mac_deinit_ssl3_handshake (mac_hd_t handle,
 282                                    void *digest, opaque * key,
 283                                    uint32_t key_size)
 284 {
 285   opaque ret[MAX_HASH_SIZE];
 286   mac_hd_t td;
 287   opaque opad[48];
 288   opaque ipad[48];
 289   int padsize;
 290   int block;
 291
 292   padsize = get_padsize (handle->algorithm);
 293   if (padsize == 0)
 294     {
 295       gnutls_assert ();
 296       return;
 297     }
 298
 299   memset (opad, 0x5C, padsize);
 300   memset (ipad, 0x36, padsize);
 301
 302   td = _gnutls_hash_init (handle->algorithm);
 303   if (td != GNUTLS_HASH_FAILED)
 304     {
 305       if (key_size > 0)
 306         _gnutls_hash (td, key, key_size);
 307
 308       _gnutls_hash (td, opad, padsize);
 309       block = _gnutls_hmac_get_algo_len (handle->algorithm);
 310
 311       if (key_size > 0)
 312         _gnutls_hash (handle, key, key_size);
 313       _gnutls_hash (handle, ipad, padsize);
 314       _gnutls_hash_deinit (handle, ret);        /* get the previous hash */
 315
 316       _gnutls_hash (td, ret, block);
 317
 318       _gnutls_hash_deinit (td, digest);
 319     }
 320 }
 321
 322 static int
 323 ssl3_sha (int i, opaque * secret, int secret_len,
 324           opaque * rnd, int rnd_len, void *digest)
 325 {
 326   int j;
 327   opaque text1[26];
 328
 329   GNUTLS_HASH_HANDLE td;
 330
 331   for (j = 0; j < i + 1; j++)
 332     {
 333       text1[j] = 65 + i;        /* A==65 */
 334     }
 335
 336   td = _gnutls_hash_init (GNUTLS_MAC_SHA1);
 337   if (td == NULL)
 338     {
 339       gnutls_assert ();
 340       return GNUTLS_E_HASH_FAILED;
 341     }
 342
 343   _gnutls_hash (td, text1, i + 1);
 344   _gnutls_hash (td, secret, secret_len);
 345   _gnutls_hash (td, rnd, rnd_len);
 346
 347   _gnutls_hash_deinit (td, digest);
 348   return 0;
 349 }
 350
 351 static int
 352 ssl3_md5 (int i, opaque * secret, int secret_len,
 353           opaque * rnd, int rnd_len, void *digest)
 354 {
 355   opaque tmp[MAX_HASH_SIZE];
 356   mac_hd_t td;
 357   int ret;
 358
 359   td = _gnutls_hash_init (GNUTLS_MAC_MD5);
 360   if (td == NULL)
 361     {
 362       gnutls_assert ();
 363       return GNUTLS_E_HASH_FAILED;
 364     }
 365
 366   _gnutls_hash (td, secret, secret_len);
 367
 368   ret = ssl3_sha (i, secret, secret_len, rnd, rnd_len, tmp);
 369   if (ret < 0)
 370     {
 371       gnutls_assert ();
 372       _gnutls_hash_deinit (td, digest);
 373       return ret;
 374     }
 375
 376   _gnutls_hash (td, tmp, _gnutls_hash_get_algo_len (GNUTLS_MAC_SHA1));
 377
 378   _gnutls_hash_deinit (td, digest);
 379   return 0;
 380 }
 381
 382 int
 383 _gnutls_ssl3_hash_md5 (void *first, int first_len,
 384                        void *second, int second_len, int ret_len,
 385                        opaque * ret)
 386 {
 387   opaque digest[MAX_HASH_SIZE];
 388   mac_hd_t td;
 389   int block = _gnutls_hash_get_algo_len (GNUTLS_MAC_MD5);
 390
 391   td = _gnutls_hash_init (GNUTLS_MAC_MD5);
 392   if (td == NULL)
 393     {
 394       gnutls_assert ();
 395       return GNUTLS_E_HASH_FAILED;
 396     }
 397
 398   _gnutls_hash (td, first, first_len);
 399   _gnutls_hash (td, second, second_len);
 400
 401   _gnutls_hash_deinit (td, digest);
 402
 403   if (ret_len > block)
 404     {
 405       gnutls_assert ();
 406       return GNUTLS_E_INTERNAL_ERROR;
 407     }
 408
 409   memcpy (ret, digest, ret_len);
 410
 411   return 0;
 412
 413 }
 414
 415 int
 416 _gnutls_ssl3_generate_random (void *secret, int secret_len,
 417                               void *rnd, int rnd_len,
 418                               int ret_bytes, opaque * ret)
 419 {
 420   int i = 0, copy, output_bytes;
 421   opaque digest[MAX_HASH_SIZE];
 422   int block = _gnutls_hash_get_algo_len (GNUTLS_MAC_MD5);
 423   int result, times;
 424
 425   output_bytes = 0;
 426   do
 427     {
 428       output_bytes += block;
 429     }
 430   while (output_bytes < ret_bytes);
 431
 432   times = output_bytes / block;
 433
 434   for (i = 0; i < times; i++)
 435     {
 436
 437       result = ssl3_md5 (i, secret, secret_len, rnd, rnd_len, digest);
 438       if (result < 0)
 439         {
 440           gnutls_assert ();
 441           return result;
 442         }
 443
 444       if ((1 + i) * block < ret_bytes)
 445         {
 446           copy = block;
 447         }
 448       else
 449         {
 450           copy = ret_bytes - (i) * block;
 451         }
 452
 453       memcpy (&ret[i * block], digest, copy);
 454     }
 455
 456   return 0;
 457 }