lib/gc-libgcrypt.c

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