pintos-os.org Git - pspp/blob - 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 Gc_rc
  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 Gc_rc
  65 gc_nonce (char *data, size_t datalen)
  66 {
  67   gcry_create_nonce ((unsigned char *) data, datalen);
  68   return GC_OK;
  69 }
  70
  71 Gc_rc
  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 Gc_rc
  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 /* Ciphers. */
  98
  99 Gc_rc
 100 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
 101                 gc_cipher_handle * outhandle)
 102 {
 103   int gcryalg, gcrymode;
 104   gcry_error_t err;
 105
 106   switch (alg)
 107     {
 108     case GC_AES128:
 109       gcryalg = GCRY_CIPHER_RIJNDAEL;
 110       break;
 111
 112     case GC_AES192:
 113       gcryalg = GCRY_CIPHER_RIJNDAEL;
 114       break;
 115
 116     case GC_AES256:
 117       gcryalg = GCRY_CIPHER_RIJNDAEL256;
 118       break;
 119
 120     case GC_3DES:
 121       gcryalg = GCRY_CIPHER_3DES;
 122       break;
 123
 124     case GC_DES:
 125       gcryalg = GCRY_CIPHER_DES;
 126       break;
 127
 128     case GC_ARCFOUR128:
 129     case GC_ARCFOUR40:
 130       gcryalg = GCRY_CIPHER_ARCFOUR;
 131       break;
 132
 133     case GC_ARCTWO40:
 134       gcryalg = GCRY_CIPHER_RFC2268_40;
 135       break;
 136
 137     default:
 138       return GC_INVALID_CIPHER;
 139     }
 140
 141   switch (mode)
 142     {
 143     case GC_CBC:
 144       gcrymode = GCRY_CIPHER_MODE_CBC;
 145       break;
 146
 147     case GC_STREAM:
 148       gcrymode = GCRY_CIPHER_MODE_STREAM;
 149       break;
 150
 151     default:
 152       return GC_INVALID_CIPHER;
 153     }
 154
 155   err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
 156                           gcryalg, gcrymode, 0);
 157   if (gcry_err_code (err))
 158     return GC_INVALID_CIPHER;
 159
 160   return GC_OK;
 161 }
 162
 163 Gc_rc
 164 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 165 {
 166   gcry_error_t err;
 167
 168   err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
 169   if (gcry_err_code (err))
 170     return GC_INVALID_CIPHER;
 171
 172   return GC_OK;
 173 }
 174
 175 Gc_rc
 176 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 177 {
 178   gcry_error_t err;
 179
 180   err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
 181   if (gcry_err_code (err))
 182     return GC_INVALID_CIPHER;
 183
 184   return GC_OK;
 185 }
 186
 187 Gc_rc
 188 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 189 {
 190   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
 191                            data, len, NULL, len) != 0)
 192     return GC_INVALID_CIPHER;
 193
 194   return GC_OK;
 195 }
 196
 197 Gc_rc
 198 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 199 {
 200   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
 201                            data, len, NULL, len) != 0)
 202     return GC_INVALID_CIPHER;
 203
 204   return GC_OK;
 205 }
 206
 207 Gc_rc
 208 gc_cipher_close (gc_cipher_handle handle)
 209 {
 210   gcry_cipher_close (handle);
 211
 212   return GC_OK;
 213 }
 214
 215 /* Hashes. */
 216
 217 Gc_rc
 218 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 219 {
 220   int gcryalg;
 221
 222   switch (hash)
 223     {
 224 #ifdef GC_USE_MD5
 225     case GC_MD5:
 226       gcryalg = GCRY_MD_MD5;
 227       break;
 228 #endif
 229
 230 #ifdef GC_USE_SHA1
 231     case GC_SHA1:
 232       gcryalg = GCRY_MD_SHA1;
 233       break;
 234 #endif
 235
 236     default:
 237       return GC_INVALID_HASH;
 238     }
 239
 240   gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
 241
 242   return GC_OK;
 243 }
 244
 245 /* One-call interface. */
 246
 247 #ifdef GC_USE_MD5
 248 Gc_rc
 249 gc_md5 (const void *in, size_t inlen, void *resbuf)
 250 {
 251   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 252   gcry_md_hd_t hd;
 253   gpg_error_t err;
 254   unsigned char *p;
 255
 256   assert (outlen == GC_MD5_DIGEST_SIZE);
 257
 258   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 259   if (err != GPG_ERR_NO_ERROR)
 260     return GC_INVALID_HASH;
 261
 262   gcry_md_write (hd, in, inlen);
 263
 264   p = gcry_md_read (hd, GCRY_MD_MD5);
 265   if (p == NULL)
 266     {
 267       gcry_md_close (hd);
 268       return GC_INVALID_HASH;
 269     }
 270
 271   memcpy (resbuf, p, outlen);
 272
 273   gcry_md_close (hd);
 274
 275   return GC_OK;
 276 }
 277 #endif
 278
 279 #ifdef GC_USE_SHA1
 280 Gc_rc
 281 gc_sha1 (const void *in, size_t inlen, void *resbuf)
 282 {
 283   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 284   gcry_md_hd_t hd;
 285   gpg_error_t err;
 286   unsigned char *p;
 287
 288   assert (outlen == GC_SHA1_DIGEST_SIZE);
 289
 290   err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
 291   if (err != GPG_ERR_NO_ERROR)
 292     return GC_INVALID_HASH;
 293
 294   gcry_md_write (hd, in, inlen);
 295
 296   p = gcry_md_read (hd, GCRY_MD_SHA1);
 297   if (p == NULL)
 298     {
 299       gcry_md_close (hd);
 300       return GC_INVALID_HASH;
 301     }
 302
 303   memcpy (resbuf, p, outlen);
 304
 305   gcry_md_close (hd);
 306
 307   return GC_OK;
 308 }
 309 #endif
 310
 311 #ifdef GC_USE_HMAC_MD5
 312 Gc_rc
 313 gc_hmac_md5 (const void *key, size_t keylen,
 314              const void *in, size_t inlen, char *resbuf)
 315 {
 316   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 317   gcry_md_hd_t mdh;
 318   unsigned char *hash;
 319   gpg_error_t err;
 320
 321   assert (hlen == 16);
 322
 323   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 324   if (err != GPG_ERR_NO_ERROR)
 325     return GC_INVALID_HASH;
 326
 327   err = gcry_md_setkey (mdh, key, keylen);
 328   if (err != GPG_ERR_NO_ERROR)
 329     {
 330       gcry_md_close (mdh);
 331       return GC_INVALID_HASH;
 332     }
 333
 334   gcry_md_write (mdh, in, inlen);
 335
 336   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 337   if (hash == NULL)
 338     {
 339       gcry_md_close (mdh);
 340       return GC_INVALID_HASH;
 341     }
 342
 343   memcpy (resbuf, hash, hlen);
 344
 345   gcry_md_close (mdh);
 346
 347   return GC_OK;
 348 }
 349 #endif
 350
 351 #ifdef GC_USE_HMAC_SHA1
 352 Gc_rc
 353 gc_hmac_sha1 (const void *key, size_t keylen,
 354               const void *in, size_t inlen, char *resbuf)
 355 {
 356   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 357   gcry_md_hd_t mdh;
 358   unsigned char *hash;
 359   gpg_error_t err;
 360
 361   assert (hlen == 16);
 362
 363   err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
 364   if (err != GPG_ERR_NO_ERROR)
 365     return GC_INVALID_HASH;
 366
 367   err = gcry_md_setkey (mdh, key, keylen);
 368   if (err != GPG_ERR_NO_ERROR)
 369     {
 370       gcry_md_close (mdh);
 371       return GC_INVALID_HASH;
 372     }
 373
 374   gcry_md_write (mdh, in, inlen);
 375
 376   hash = gcry_md_read (mdh, GCRY_MD_SHA1);
 377   if (hash == NULL)
 378     {
 379       gcry_md_close (mdh);
 380       return GC_INVALID_HASH;
 381     }
 382
 383   memcpy (resbuf, hash, hlen);
 384
 385   gcry_md_close (mdh);
 386
 387   return GC_OK;
 388 }
 389 #endif