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 /* Hashes. */
  98
  99 int
 100 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 101 {
 102   int gcryalg;
 103
 104   switch (hash)
 105     {
 106 #ifdef GC_USE_MD5
 107     case GC_MD5:
 108       gcryalg = GCRY_MD_MD5;
 109       break;
 110 #endif
 111
 112     default:
 113       return GC_INVALID_HASH;
 114     }
 115
 116   gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
 117
 118   return GC_OK;
 119 }
 120
 121 /* One-call interface. */
 122
 123 #ifdef GC_USE_MD5
 124 int
 125 gc_md5 (const void *in, size_t inlen, void *resbuf)
 126 {
 127   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 128   gcry_md_hd_t hd;
 129   gpg_error_t err;
 130   unsigned char *p;
 131
 132   assert (outlen == GC_MD5_DIGEST_SIZE);
 133
 134   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 135   if (err != GPG_ERR_NO_ERROR)
 136     return GC_INVALID_HASH;
 137
 138   gcry_md_write (hd, in, inlen);
 139
 140   p = gcry_md_read (hd, GCRY_MD_MD5);
 141   if (p == NULL)
 142     {
 143       gcry_md_close (hd);
 144       return GC_INVALID_HASH;
 145     }
 146
 147   memcpy (resbuf, p, outlen);
 148
 149   gcry_md_close (hd);
 150
 151   return GC_OK;
 152 }
 153 #endif
 154
 155 #ifdef GC_USE_HMAC_MD5
 156 int
 157 gc_hmac_md5 (const void *key, size_t keylen,
 158              const void *in, size_t inlen, char *resbuf)
 159 {
 160   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 161   gcry_md_hd_t mdh;
 162   unsigned char *hash;
 163   gpg_error_t err;
 164
 165   assert (hlen == 16);
 166
 167   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 168   if (err != GPG_ERR_NO_ERROR)
 169     return GC_INVALID_HASH;
 170
 171   err = gcry_md_setkey (mdh, key, keylen);
 172   if (err != GPG_ERR_NO_ERROR)
 173     {
 174       gcry_md_close (mdh);
 175       return GC_INVALID_HASH;
 176     }
 177
 178   gcry_md_write (mdh, in, inlen);
 179
 180   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 181   if (hash == NULL)
 182     {
 183       gcry_md_close (mdh);
 184       return GC_INVALID_HASH;
 185     }
 186
 187   memcpy (resbuf, hash, hlen);
 188
 189   gcry_md_close (mdh);
 190
 191   return GC_OK;
 192 }
 193 #endif