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