lib/gc-libgcrypt.c

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