lib/gc-libgcrypt.c

   1 /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
   2  * Copyright (C) 2002, 2003, 2004, 2005  Simon Josefsson
   3  *
   4  * This file is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published
   6  * by the Free Software Foundation; either version 2, or (at your
   7  * option) any later version.
   8  *
   9  * This file is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this file; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  17  * 02110-1301, USA.
  18  *
  19  */
  20
  21 /* Note: This file is only built if GC uses Libgcrypt. */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 /* Get prototype. */
  28 #include "gc.h"
  29
  30 /* Get libgcrypt API. */
  31 #include <gcrypt.h>
  32
  33 #include <assert.h>
  34
  35 /* Initialization. */
  36
  37 int
  38 gc_init (void)
  39 {
  40   gcry_error_t err;
  41
  42   err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
  43   if (err == GPG_ERR_NO_ERROR)
  44     {
  45       if (gcry_check_version (GCRYPT_VERSION) == NULL)
  46         return GC_INIT_ERROR;
  47
  48       err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
  49       if (err != GPG_ERR_NO_ERROR)
  50         return GC_INIT_ERROR;
  51     }
  52
  53   return GC_OK;
  54 }
  55
  56 void
  57 gc_done (void)
  58 {
  59   return;
  60 }
  61
  62 /* Randomness. */
  63
  64 int
  65 gc_nonce (char *data, size_t datalen)
  66 {
  67   gcry_create_nonce ((unsigned char *) data, datalen);
  68   return GC_OK;
  69 }
  70
  71 int
  72 gc_pseudo_random (char *data, size_t datalen)
  73 {
  74   gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
  75   return GC_OK;
  76 }
  77
  78 int
  79 gc_random (char *data, size_t datalen)
  80 {
  81   gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
  82   return GC_OK;
  83 }
  84
  85 /* Memory allocation. */
  86
  87 void
  88 gc_set_allocators (gc_malloc_t func_malloc,
  89                    gc_malloc_t secure_malloc,
  90                    gc_secure_check_t secure_check,
  91                    gc_realloc_t func_realloc, gc_free_t func_free)
  92 {
  93   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
  94                                func_realloc, func_free);
  95 }
  96
  97 /* One-call interface. */
  98
  99 int
 100 gc_md5 (const void *in, size_t inlen, void *resbuf)
 101 {
 102   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 103   gcry_md_hd_t hd;
 104   gpg_error_t err;
 105   unsigned char *p;
 106
 107   assert (outlen == 16);
 108
 109   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 110   if (err != GPG_ERR_NO_ERROR)
 111     return GC_INVALID_HASH;
 112
 113   gcry_md_write (hd, in, inlen);
 114
 115   p = gcry_md_read (hd, GCRY_MD_MD5);
 116   if (p == NULL)
 117     {
 118       gcry_md_close (mdh);
 119       return GC_INVALID_HASH;
 120     }
 121
 122   memcpy (resbuf, p, outlen);
 123
 124   gcry_md_close (hd);
 125
 126   return GC_OK;
 127 }
 128
 129 int
 130 gc_hmac_md5 (const void *key, size_t keylen,
 131              const void *in, size_t inlen, char *resbuf)
 132 {
 133   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 134   gcry_md_hd_t mdh;
 135   unsigned char *hash;
 136   gpg_error_t err;
 137
 138   assert (hlen == 16);
 139
 140   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 141   if (err != GPG_ERR_NO_ERROR)
 142     return GC_INVALID_HASH;
 143
 144   err = gcry_md_setkey (mdh, key, keylen);
 145   if (err != GPG_ERR_NO_ERROR)
 146     {
 147       gcry_md_close (mdh);
 148       return GC_INVALID_HASH;
 149     }
 150
 151   gcry_md_write (mdh, in, inlen);
 152
 153   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 154   if (hash == NULL)
 155     {
 156       gcry_md_close (mdh);
 157       return GC_INVALID_HASH;
 158     }
 159
 160   memcpy (resbuf, hash, hlen);
 161
 162   gcry_md_close (mdh);
 163
 164   return GC_OK;
 165 }