lib/gc-libgcrypt.c

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