pintos-os.org Git - pspp/blob - 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_RMD160:
 298       gcryalg = GCRY_MD_RMD160;
 299       break;
 300
 301     default:
 302       rc = GC_INVALID_HASH;
 303     }
 304
 305   switch (mode)
 306     {
 307     case 0:
 308       gcrymode = 0;
 309       break;
 310
 311     case GC_HMAC:
 312       gcrymode = GCRY_MD_FLAG_HMAC;
 313       break;
 314
 315     default:
 316       rc = GC_INVALID_HASH;
 317     }
 318
 319   if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
 320     {
 321       err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
 322       if (gcry_err_code (err))
 323         rc = GC_INVALID_HASH;
 324     }
 325
 326   if (rc == GC_OK)
 327     *outhandle = ctx;
 328   else
 329     free (ctx);
 330
 331   return rc;
 332 }
 333
 334 Gc_rc
 335 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
 336 {
 337   _gc_hash_ctx *in = handle;
 338   _gc_hash_ctx *out;
 339   int err;
 340
 341   *outhandle = out = calloc (sizeof (*out), 1);
 342   if (!out)
 343     return GC_MALLOC_ERROR;
 344
 345   memcpy (out, in, sizeof (*out));
 346
 347   err = gcry_md_copy (&out->gch, in->gch);
 348   if (err)
 349     {
 350       free (out);
 351       return GC_INVALID_HASH;
 352     }
 353
 354   return GC_OK;
 355 }
 356
 357 size_t
 358 gc_hash_digest_length (Gc_hash hash)
 359 {
 360   size_t len;
 361
 362   switch (hash)
 363     {
 364     case GC_MD2:
 365       len = GC_MD2_DIGEST_SIZE;
 366       break;
 367
 368     case GC_MD4:
 369       len = GC_MD4_DIGEST_SIZE;
 370       break;
 371
 372     case GC_MD5:
 373       len = GC_MD5_DIGEST_SIZE;
 374       break;
 375
 376     case GC_RMD160:
 377       len = GC_RMD160_DIGEST_SIZE;
 378       break;
 379
 380     case GC_SHA1:
 381       len = GC_SHA1_DIGEST_SIZE;
 382       break;
 383
 384     case GC_SHA256:
 385       len = GC_SHA256_DIGEST_SIZE;
 386       break;
 387
 388     case GC_SHA384:
 389       len = GC_SHA384_DIGEST_SIZE;
 390       break;
 391
 392     case GC_SHA512:
 393       len = GC_SHA512_DIGEST_SIZE;
 394       break;
 395
 396     default:
 397       return 0;
 398     }
 399
 400   return len;
 401 }
 402
 403 void
 404 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
 405 {
 406   _gc_hash_ctx *ctx = handle;
 407 #ifdef GNULIB_GC_MD2
 408   if (ctx->alg != GC_MD2)
 409 #endif
 410     gcry_md_setkey (ctx->gch, key, len);
 411 }
 412
 413 void
 414 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
 415 {
 416   _gc_hash_ctx *ctx = handle;
 417
 418 #ifdef GNULIB_GC_MD2
 419   if (ctx->alg == GC_MD2)
 420     md2_process_bytes (data, len, &ctx->md2Context);
 421   else
 422 #endif
 423     gcry_md_write (ctx->gch, data, len);
 424 }
 425
 426 const char *
 427 gc_hash_read (gc_hash_handle handle)
 428 {
 429   _gc_hash_ctx *ctx = handle;
 430   const char *digest;
 431
 432 #ifdef GNULIB_GC_MD2
 433   if (ctx->alg == GC_MD2)
 434     {
 435       md2_finish_ctx (&ctx->md2Context, ctx->hash);
 436       digest = ctx->hash;
 437     }
 438   else
 439 #endif
 440     {
 441       gcry_md_final (ctx->gch);
 442       digest = gcry_md_read (ctx->gch, 0);
 443     }
 444
 445   return digest;
 446 }
 447
 448 void
 449 gc_hash_close (gc_hash_handle handle)
 450 {
 451   _gc_hash_ctx *ctx = handle;
 452
 453 #ifdef GNULIB_GC_MD2
 454   if (ctx->alg != GC_MD2)
 455 #endif
 456     gcry_md_close (ctx->gch);
 457
 458   free (ctx);
 459 }
 460
 461 Gc_rc
 462 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 463 {
 464   int gcryalg;
 465
 466   switch (hash)
 467     {
 468 #ifdef GNULIB_GC_MD2
 469     case GC_MD2:
 470       md2_buffer (in, inlen, resbuf);
 471       return GC_OK;
 472       break;
 473 #endif
 474
 475 #ifdef GNULIB_GC_MD4
 476     case GC_MD4:
 477       gcryalg = GCRY_MD_MD4;
 478       break;
 479 #endif
 480
 481 #ifdef GNULIB_GC_MD5
 482     case GC_MD5:
 483       gcryalg = GCRY_MD_MD5;
 484       break;
 485 #endif
 486
 487 #ifdef GNULIB_GC_SHA1
 488     case GC_SHA1:
 489       gcryalg = GCRY_MD_SHA1;
 490       break;
 491 #endif
 492
 493 #ifdef GNULIB_GC_SHA256
 494     case GC_SHA256:
 495       gcryalg = GCRY_MD_SHA256;
 496       break;
 497 #endif
 498
 499 #ifdef GNULIB_GC_SHA384
 500     case GC_SHA384:
 501       gcryalg = GCRY_MD_SHA384;
 502       break;
 503 #endif
 504
 505 #ifdef GNULIB_GC_SHA512
 506     case GC_SHA512:
 507       gcryalg = GCRY_MD_SHA512;
 508       break;
 509 #endif
 510
 511 #ifdef GNULIB_GC_RMD160
 512     case GC_RMD160:
 513       gcryalg = GCRY_MD_RMD160;
 514       break;
 515 #endif
 516
 517     default:
 518       return GC_INVALID_HASH;
 519     }
 520
 521   gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
 522
 523   return GC_OK;
 524 }
 525
 526 /* One-call interface. */
 527
 528 #ifdef GNULIB_GC_MD2
 529 Gc_rc
 530 gc_md2 (const void *in, size_t inlen, void *resbuf)
 531 {
 532   md2_buffer (in, inlen, resbuf);
 533   return GC_OK;
 534 }
 535 #endif
 536
 537 #ifdef GNULIB_GC_MD4
 538 Gc_rc
 539 gc_md4 (const void *in, size_t inlen, void *resbuf)
 540 {
 541   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
 542   gcry_md_hd_t hd;
 543   gpg_error_t err;
 544   unsigned char *p;
 545
 546   assert (outlen == GC_MD4_DIGEST_SIZE);
 547
 548   err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
 549   if (err != GPG_ERR_NO_ERROR)
 550     return GC_INVALID_HASH;
 551
 552   gcry_md_write (hd, in, inlen);
 553
 554   p = gcry_md_read (hd, GCRY_MD_MD4);
 555   if (p == NULL)
 556     {
 557       gcry_md_close (hd);
 558       return GC_INVALID_HASH;
 559     }
 560
 561   memcpy (resbuf, p, outlen);
 562
 563   gcry_md_close (hd);
 564
 565   return GC_OK;
 566 }
 567 #endif
 568
 569 #ifdef GNULIB_GC_MD5
 570 Gc_rc
 571 gc_md5 (const void *in, size_t inlen, void *resbuf)
 572 {
 573   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 574   gcry_md_hd_t hd;
 575   gpg_error_t err;
 576   unsigned char *p;
 577
 578   assert (outlen == GC_MD5_DIGEST_SIZE);
 579
 580   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 581   if (err != GPG_ERR_NO_ERROR)
 582     return GC_INVALID_HASH;
 583
 584   gcry_md_write (hd, in, inlen);
 585
 586   p = gcry_md_read (hd, GCRY_MD_MD5);
 587   if (p == NULL)
 588     {
 589       gcry_md_close (hd);
 590       return GC_INVALID_HASH;
 591     }
 592
 593   memcpy (resbuf, p, outlen);
 594
 595   gcry_md_close (hd);
 596
 597   return GC_OK;
 598 }
 599 #endif
 600
 601 #ifdef GNULIB_GC_SHA1
 602 Gc_rc
 603 gc_sha1 (const void *in, size_t inlen, void *resbuf)
 604 {
 605   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 606   gcry_md_hd_t hd;
 607   gpg_error_t err;
 608   unsigned char *p;
 609
 610   assert (outlen == GC_SHA1_DIGEST_SIZE);
 611
 612   err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
 613   if (err != GPG_ERR_NO_ERROR)
 614     return GC_INVALID_HASH;
 615
 616   gcry_md_write (hd, in, inlen);
 617
 618   p = gcry_md_read (hd, GCRY_MD_SHA1);
 619   if (p == NULL)
 620     {
 621       gcry_md_close (hd);
 622       return GC_INVALID_HASH;
 623     }
 624
 625   memcpy (resbuf, p, outlen);
 626
 627   gcry_md_close (hd);
 628
 629   return GC_OK;
 630 }
 631 #endif
 632
 633 #ifdef GNULIB_GC_HMAC_MD5
 634 Gc_rc
 635 gc_hmac_md5 (const void *key, size_t keylen,
 636              const void *in, size_t inlen, char *resbuf)
 637 {
 638   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 639   gcry_md_hd_t mdh;
 640   unsigned char *hash;
 641   gpg_error_t err;
 642
 643   assert (hlen == 16);
 644
 645   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 646   if (err != GPG_ERR_NO_ERROR)
 647     return GC_INVALID_HASH;
 648
 649   err = gcry_md_setkey (mdh, key, keylen);
 650   if (err != GPG_ERR_NO_ERROR)
 651     {
 652       gcry_md_close (mdh);
 653       return GC_INVALID_HASH;
 654     }
 655
 656   gcry_md_write (mdh, in, inlen);
 657
 658   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 659   if (hash == NULL)
 660     {
 661       gcry_md_close (mdh);
 662       return GC_INVALID_HASH;
 663     }
 664
 665   memcpy (resbuf, hash, hlen);
 666
 667   gcry_md_close (mdh);
 668
 669   return GC_OK;
 670 }
 671 #endif
 672
 673 #ifdef GNULIB_GC_HMAC_SHA1
 674 Gc_rc
 675 gc_hmac_sha1 (const void *key, size_t keylen,
 676               const void *in, size_t inlen, char *resbuf)
 677 {
 678   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 679   gcry_md_hd_t mdh;
 680   unsigned char *hash;
 681   gpg_error_t err;
 682
 683   assert (hlen == GC_SHA1_DIGEST_SIZE);
 684
 685   err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
 686   if (err != GPG_ERR_NO_ERROR)
 687     return GC_INVALID_HASH;
 688
 689   err = gcry_md_setkey (mdh, key, keylen);
 690   if (err != GPG_ERR_NO_ERROR)
 691     {
 692       gcry_md_close (mdh);
 693       return GC_INVALID_HASH;
 694     }
 695
 696   gcry_md_write (mdh, in, inlen);
 697
 698   hash = gcry_md_read (mdh, GCRY_MD_SHA1);
 699   if (hash == NULL)
 700     {
 701       gcry_md_close (mdh);
 702       return GC_INVALID_HASH;
 703     }
 704
 705   memcpy (resbuf, hash, hlen);
 706
 707   gcry_md_close (mdh);
 708
 709   return GC_OK;
 710 }
 711 #endif