lib/gc-libgcrypt.c

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