lib/gc-libgcrypt.c

   1 /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
   2  * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
   3  * Software Foundation, Inc.
   4  *
   5  * This file is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published
   7  * by the Free Software Foundation; either version 2, or (at your
   8  * option) any later version.
   9  *
  10  * This file is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this file; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  18  * 02110-1301, USA.
  19  *
  20  */
  21
  22 /* Note: This file is only built if GC uses Libgcrypt. */
  23
  24 #include <config.h>
  25
  26 /* Get prototype. */
  27 #include "gc.h"
  28
  29 #include <stdlib.h>
  30 #include <string.h>
  31
  32 /* Get libgcrypt API. */
  33 #include <gcrypt.h>
  34 #ifdef GNULIB_GC_MD2
  35 # include "md2.h"
  36 #endif
  37
  38 #include <assert.h>
  39
  40 #ifndef MIN_GCRYPT_VERSION
  41 # define MIN_GCRYPT_VERSION "1.4.4"
  42 #endif
  43
  44 /* Initialization. */
  45
  46 Gc_rc
  47 gc_init (void)
  48 {
  49   gcry_error_t err;
  50
  51   err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
  52   if (err == GPG_ERR_NO_ERROR)
  53     {
  54       if (gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0))
  55         return GC_INIT_ERROR;
  56
  57       if (gcry_check_version (MIN_GCRYPT_VERSION) == NULL)
  58         return GC_INIT_ERROR;
  59
  60       err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
  61       if (err != GPG_ERR_NO_ERROR)
  62         return GC_INIT_ERROR;
  63     }
  64
  65   return GC_OK;
  66 }
  67
  68 void
  69 gc_done (void)
  70 {
  71   return;
  72 }
  73
  74 #ifdef GNULIB_GC_RANDOM
  75
  76 /* Randomness. */
  77
  78 Gc_rc
  79 gc_nonce (char *data, size_t datalen)
  80 {
  81   gcry_create_nonce ((unsigned char *) data, datalen);
  82   return GC_OK;
  83 }
  84
  85 Gc_rc
  86 gc_pseudo_random (char *data, size_t datalen)
  87 {
  88   gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
  89   return GC_OK;
  90 }
  91
  92 Gc_rc
  93 gc_random (char *data, size_t datalen)
  94 {
  95   gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
  96   return GC_OK;
  97 }
  98
  99 #endif
 100
 101 /* Memory allocation. */
 102
 103 void
 104 gc_set_allocators (gc_malloc_t func_malloc,
 105                    gc_malloc_t secure_malloc,
 106                    gc_secure_check_t secure_check,
 107                    gc_realloc_t func_realloc, gc_free_t func_free)
 108 {
 109   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
 110                                func_realloc, func_free);
 111 }
 112
 113 /* Ciphers. */
 114
 115 Gc_rc
 116 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
 117                 gc_cipher_handle * outhandle)
 118 {
 119   int gcryalg, gcrymode;
 120   gcry_error_t err;
 121
 122   switch (alg)
 123     {
 124     case GC_AES128:
 125       gcryalg = GCRY_CIPHER_RIJNDAEL;
 126       break;
 127
 128     case GC_AES192:
 129       gcryalg = GCRY_CIPHER_RIJNDAEL;
 130       break;
 131
 132     case GC_AES256:
 133       gcryalg = GCRY_CIPHER_RIJNDAEL256;
 134       break;
 135
 136     case GC_3DES:
 137       gcryalg = GCRY_CIPHER_3DES;
 138       break;
 139
 140     case GC_DES:
 141       gcryalg = GCRY_CIPHER_DES;
 142       break;
 143
 144     case GC_ARCFOUR128:
 145     case GC_ARCFOUR40:
 146       gcryalg = GCRY_CIPHER_ARCFOUR;
 147       break;
 148
 149     case GC_ARCTWO40:
 150       gcryalg = GCRY_CIPHER_RFC2268_40;
 151       break;
 152
 153 #ifdef HAVE_CAMELLIA
 154     case GC_CAMELLIA128:
 155       gcryalg = GCRY_CIPHER_CAMELLIA128;
 156       break;
 157
 158     case GC_CAMELLIA256:
 159       gcryalg = GCRY_CIPHER_CAMELLIA256;
 160       break;
 161 #endif
 162
 163     default:
 164       return GC_INVALID_CIPHER;
 165     }
 166
 167   switch (mode)
 168     {
 169     case GC_ECB:
 170       gcrymode = GCRY_CIPHER_MODE_ECB;
 171       break;
 172
 173     case GC_CBC:
 174       gcrymode = GCRY_CIPHER_MODE_CBC;
 175       break;
 176
 177     case GC_STREAM:
 178       gcrymode = GCRY_CIPHER_MODE_STREAM;
 179       break;
 180
 181     default:
 182       return GC_INVALID_CIPHER;
 183     }
 184
 185   err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
 186                           gcryalg, gcrymode, 0);
 187   if (gcry_err_code (err))
 188     return GC_INVALID_CIPHER;
 189
 190   return GC_OK;
 191 }
 192
 193 Gc_rc
 194 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 195 {
 196   gcry_error_t err;
 197
 198   err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
 199   if (gcry_err_code (err))
 200     return GC_INVALID_CIPHER;
 201
 202   return GC_OK;
 203 }
 204
 205 Gc_rc
 206 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 207 {
 208   gcry_error_t err;
 209
 210   err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
 211   if (gcry_err_code (err))
 212     return GC_INVALID_CIPHER;
 213
 214   return GC_OK;
 215 }
 216
 217 Gc_rc
 218 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 219 {
 220   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
 221                            data, len, NULL, len) != 0)
 222     return GC_INVALID_CIPHER;
 223
 224   return GC_OK;
 225 }
 226
 227 Gc_rc
 228 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 229 {
 230   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
 231                            data, len, NULL, len) != 0)
 232     return GC_INVALID_CIPHER;
 233
 234   return GC_OK;
 235 }
 236
 237 Gc_rc
 238 gc_cipher_close (gc_cipher_handle handle)
 239 {
 240   gcry_cipher_close (handle);
 241
 242   return GC_OK;
 243 }
 244
 245 /* Hashes. */
 246
 247 typedef struct _gc_hash_ctx {
 248   Gc_hash alg;
 249   Gc_hash_mode mode;
 250   gcry_md_hd_t gch;
 251 #ifdef GNULIB_GC_MD2
 252   char hash[GC_MD2_DIGEST_SIZE];
 253   struct md2_ctx md2Context;
 254 #endif
 255 } _gc_hash_ctx;
 256
 257 Gc_rc
 258 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
 259 {
 260   _gc_hash_ctx *ctx;
 261   int gcryalg = 0, gcrymode = 0;
 262   gcry_error_t err;
 263   Gc_rc rc = GC_OK;
 264
 265   ctx = calloc (sizeof (*ctx), 1);
 266   if (!ctx)
 267     return GC_MALLOC_ERROR;
 268
 269   ctx->alg = hash;
 270   ctx->mode = mode;
 271
 272   switch (hash)
 273     {
 274     case GC_MD2:
 275       gcryalg = GCRY_MD_NONE;
 276       break;
 277
 278     case GC_MD4:
 279       gcryalg = GCRY_MD_MD4;
 280       break;
 281
 282     case GC_MD5:
 283       gcryalg = GCRY_MD_MD5;
 284       break;
 285
 286     case GC_SHA1:
 287       gcryalg = GCRY_MD_SHA1;
 288       break;
 289
 290     case GC_SHA256:
 291       gcryalg = GCRY_MD_SHA256;
 292       break;
 293
 294     case GC_SHA384:
 295       gcryalg = GCRY_MD_SHA384;
 296       break;
 297
 298     case GC_SHA512:
 299       gcryalg = GCRY_MD_SHA512;
 300       break;
 301
 302     case GC_SHA224:
 303       gcryalg = GCRY_MD_SHA224;
 304       break;
 305
 306     case GC_RMD160:
 307       gcryalg = GCRY_MD_RMD160;
 308       break;
 309
 310     default:
 311       rc = GC_INVALID_HASH;
 312     }
 313
 314   switch (mode)
 315     {
 316     case 0:
 317       gcrymode = 0;
 318       break;
 319
 320     case GC_HMAC:
 321       gcrymode = GCRY_MD_FLAG_HMAC;
 322       break;
 323
 324     default:
 325       rc = GC_INVALID_HASH;
 326     }
 327
 328   if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
 329     {
 330       err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
 331       if (gcry_err_code (err))
 332         rc = GC_INVALID_HASH;
 333     }
 334
 335   if (rc == GC_OK)
 336     *outhandle = ctx;
 337   else
 338     free (ctx);
 339
 340   return rc;
 341 }
 342
 343 Gc_rc
 344 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
 345 {
 346   _gc_hash_ctx *in = handle;
 347   _gc_hash_ctx *out;
 348   int err;
 349
 350   *outhandle = out = calloc (sizeof (*out), 1);
 351   if (!out)
 352     return GC_MALLOC_ERROR;
 353
 354   memcpy (out, in, sizeof (*out));
 355
 356   err = gcry_md_copy (&out->gch, in->gch);
 357   if (err)
 358     {
 359       free (out);
 360       return GC_INVALID_HASH;
 361     }
 362
 363   return GC_OK;
 364 }
 365
 366 size_t
 367 gc_hash_digest_length (Gc_hash hash)
 368 {
 369   size_t len;
 370
 371   switch (hash)
 372     {
 373     case GC_MD2:
 374       len = GC_MD2_DIGEST_SIZE;
 375       break;
 376
 377     case GC_MD4:
 378       len = GC_MD4_DIGEST_SIZE;
 379       break;
 380
 381     case GC_MD5:
 382       len = GC_MD5_DIGEST_SIZE;
 383       break;
 384
 385     case GC_RMD160:
 386       len = GC_RMD160_DIGEST_SIZE;
 387       break;
 388
 389     case GC_SHA1:
 390       len = GC_SHA1_DIGEST_SIZE;
 391       break;
 392
 393     case GC_SHA256:
 394       len = GC_SHA256_DIGEST_SIZE;
 395       break;
 396
 397     case GC_SHA384:
 398       len = GC_SHA384_DIGEST_SIZE;
 399       break;
 400
 401     case GC_SHA512:
 402       len = GC_SHA512_DIGEST_SIZE;
 403       break;
 404
 405     case GC_SHA224:
 406       len = GC_SHA224_DIGEST_SIZE;
 407       break;
 408
 409     default:
 410       return 0;
 411     }
 412
 413   return len;
 414 }
 415
 416 void
 417 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
 418 {
 419   _gc_hash_ctx *ctx = handle;
 420 #ifdef GNULIB_GC_MD2
 421   if (ctx->alg != GC_MD2)
 422 #endif
 423     gcry_md_setkey (ctx->gch, key, len);
 424 }
 425
 426 void
 427 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
 428 {
 429   _gc_hash_ctx *ctx = handle;
 430
 431 #ifdef GNULIB_GC_MD2
 432   if (ctx->alg == GC_MD2)
 433     md2_process_bytes (data, len, &ctx->md2Context);
 434   else
 435 #endif
 436     gcry_md_write (ctx->gch, data, len);
 437 }
 438
 439 const char *
 440 gc_hash_read (gc_hash_handle handle)
 441 {
 442   _gc_hash_ctx *ctx = handle;
 443   const char *digest;
 444
 445 #ifdef GNULIB_GC_MD2
 446   if (ctx->alg == GC_MD2)
 447     {
 448       md2_finish_ctx (&ctx->md2Context, ctx->hash);
 449       digest = ctx->hash;
 450     }
 451   else
 452 #endif
 453     {
 454       gcry_md_final (ctx->gch);
 455       digest = gcry_md_read (ctx->gch, 0);
 456     }
 457
 458   return digest;
 459 }
 460
 461 void
 462 gc_hash_close (gc_hash_handle handle)
 463 {
 464   _gc_hash_ctx *ctx = handle;
 465
 466 #ifdef GNULIB_GC_MD2
 467   if (ctx->alg != GC_MD2)
 468 #endif
 469     gcry_md_close (ctx->gch);
 470
 471   free (ctx);
 472 }
 473
 474 Gc_rc
 475 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 476 {
 477   int gcryalg;
 478
 479   switch (hash)
 480     {
 481 #ifdef GNULIB_GC_MD2
 482     case GC_MD2:
 483       md2_buffer (in, inlen, resbuf);
 484       return GC_OK;
 485       break;
 486 #endif
 487
 488 #ifdef GNULIB_GC_MD4
 489     case GC_MD4:
 490       gcryalg = GCRY_MD_MD4;
 491       break;
 492 #endif
 493
 494 #ifdef GNULIB_GC_MD5
 495     case GC_MD5:
 496       gcryalg = GCRY_MD_MD5;
 497       break;
 498 #endif
 499
 500 #ifdef GNULIB_GC_SHA1
 501     case GC_SHA1:
 502       gcryalg = GCRY_MD_SHA1;
 503       break;
 504 #endif
 505
 506 #ifdef GNULIB_GC_SHA256
 507     case GC_SHA256:
 508       gcryalg = GCRY_MD_SHA256;
 509       break;
 510 #endif
 511
 512 #ifdef GNULIB_GC_SHA384
 513     case GC_SHA384:
 514       gcryalg = GCRY_MD_SHA384;
 515       break;
 516 #endif
 517
 518 #ifdef GNULIB_GC_SHA512
 519     case GC_SHA512:
 520       gcryalg = GCRY_MD_SHA512;
 521       break;
 522 #endif
 523
 524 #ifdef GNULIB_GC_SHA224
 525     case GC_SHA224:
 526       gcryalg = GCRY_MD_SHA224;
 527       break;
 528 #endif
 529
 530 #ifdef GNULIB_GC_RMD160
 531     case GC_RMD160:
 532       gcryalg = GCRY_MD_RMD160;
 533       break;
 534 #endif
 535
 536     default:
 537       return GC_INVALID_HASH;
 538     }
 539
 540   gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
 541
 542   return GC_OK;
 543 }
 544
 545 /* One-call interface. */
 546
 547 #ifdef GNULIB_GC_MD2
 548 Gc_rc
 549 gc_md2 (const void *in, size_t inlen, void *resbuf)
 550 {
 551   md2_buffer (in, inlen, resbuf);
 552   return GC_OK;
 553 }
 554 #endif
 555
 556 #ifdef GNULIB_GC_MD4
 557 Gc_rc
 558 gc_md4 (const void *in, size_t inlen, void *resbuf)
 559 {
 560   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
 561   gcry_md_hd_t hd;
 562   gpg_error_t err;
 563   unsigned char *p;
 564
 565   assert (outlen == GC_MD4_DIGEST_SIZE);
 566
 567   err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
 568   if (err != GPG_ERR_NO_ERROR)
 569     return GC_INVALID_HASH;
 570
 571   gcry_md_write (hd, in, inlen);
 572
 573   p = gcry_md_read (hd, GCRY_MD_MD4);
 574   if (p == NULL)
 575     {
 576       gcry_md_close (hd);
 577       return GC_INVALID_HASH;
 578     }
 579
 580   memcpy (resbuf, p, outlen);
 581
 582   gcry_md_close (hd);
 583
 584   return GC_OK;
 585 }
 586 #endif
 587
 588 #ifdef GNULIB_GC_MD5
 589 Gc_rc
 590 gc_md5 (const void *in, size_t inlen, void *resbuf)
 591 {
 592   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 593   gcry_md_hd_t hd;
 594   gpg_error_t err;
 595   unsigned char *p;
 596
 597   assert (outlen == GC_MD5_DIGEST_SIZE);
 598
 599   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 600   if (err != GPG_ERR_NO_ERROR)
 601     return GC_INVALID_HASH;
 602
 603   gcry_md_write (hd, in, inlen);
 604
 605   p = gcry_md_read (hd, GCRY_MD_MD5);
 606   if (p == NULL)
 607     {
 608       gcry_md_close (hd);
 609       return GC_INVALID_HASH;
 610     }
 611
 612   memcpy (resbuf, p, outlen);
 613
 614   gcry_md_close (hd);
 615
 616   return GC_OK;
 617 }
 618 #endif
 619
 620 #ifdef GNULIB_GC_SHA1
 621 Gc_rc
 622 gc_sha1 (const void *in, size_t inlen, void *resbuf)
 623 {
 624   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 625   gcry_md_hd_t hd;
 626   gpg_error_t err;
 627   unsigned char *p;
 628
 629   assert (outlen == GC_SHA1_DIGEST_SIZE);
 630
 631   err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
 632   if (err != GPG_ERR_NO_ERROR)
 633     return GC_INVALID_HASH;
 634
 635   gcry_md_write (hd, in, inlen);
 636
 637   p = gcry_md_read (hd, GCRY_MD_SHA1);
 638   if (p == NULL)
 639     {
 640       gcry_md_close (hd);
 641       return GC_INVALID_HASH;
 642     }
 643
 644   memcpy (resbuf, p, outlen);
 645
 646   gcry_md_close (hd);
 647
 648   return GC_OK;
 649 }
 650 #endif
 651
 652 #ifdef GNULIB_GC_HMAC_MD5
 653 Gc_rc
 654 gc_hmac_md5 (const void *key, size_t keylen,
 655              const void *in, size_t inlen, char *resbuf)
 656 {
 657   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 658   gcry_md_hd_t mdh;
 659   unsigned char *hash;
 660   gpg_error_t err;
 661
 662   assert (hlen == 16);
 663
 664   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 665   if (err != GPG_ERR_NO_ERROR)
 666     return GC_INVALID_HASH;
 667
 668   err = gcry_md_setkey (mdh, key, keylen);
 669   if (err != GPG_ERR_NO_ERROR)
 670     {
 671       gcry_md_close (mdh);
 672       return GC_INVALID_HASH;
 673     }
 674
 675   gcry_md_write (mdh, in, inlen);
 676
 677   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 678   if (hash == NULL)
 679     {
 680       gcry_md_close (mdh);
 681       return GC_INVALID_HASH;
 682     }
 683
 684   memcpy (resbuf, hash, hlen);
 685
 686   gcry_md_close (mdh);
 687
 688   return GC_OK;
 689 }
 690 #endif
 691
 692 #ifdef GNULIB_GC_HMAC_SHA1
 693 Gc_rc
 694 gc_hmac_sha1 (const void *key, size_t keylen,
 695               const void *in, size_t inlen, char *resbuf)
 696 {
 697   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 698   gcry_md_hd_t mdh;
 699   unsigned char *hash;
 700   gpg_error_t err;
 701
 702   assert (hlen == GC_SHA1_DIGEST_SIZE);
 703
 704   err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
 705   if (err != GPG_ERR_NO_ERROR)
 706     return GC_INVALID_HASH;
 707
 708   err = gcry_md_setkey (mdh, key, keylen);
 709   if (err != GPG_ERR_NO_ERROR)
 710     {
 711       gcry_md_close (mdh);
 712       return GC_INVALID_HASH;
 713     }
 714
 715   gcry_md_write (mdh, in, inlen);
 716
 717   hash = gcry_md_read (mdh, GCRY_MD_SHA1);
 718   if (hash == NULL)
 719     {
 720       gcry_md_close (mdh);
 721       return GC_INVALID_HASH;
 722     }
 723
 724   memcpy (resbuf, hash, hlen);
 725
 726   gcry_md_close (mdh);
 727
 728   return GC_OK;
 729 }
 730 #endif