lib/gc-libgcrypt.c

   1 /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
   2  * Copyright (C) 2002, 2003, 2004, 2005  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 #ifdef HAVE_CONFIG_H
  24 # include <config.h>
  25 #endif
  26
  27 /* Get prototype. */
  28 #include "gc.h"
  29
  30 /* Get libgcrypt API. */
  31 #include <gcrypt.h>
  32
  33 #include <assert.h>
  34
  35 /* Initialization. */
  36
  37 Gc_rc
  38 gc_init (void)
  39 {
  40   gcry_error_t err;
  41
  42   err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
  43   if (err == GPG_ERR_NO_ERROR)
  44     {
  45       if (gcry_check_version (GCRYPT_VERSION) == NULL)
  46         return GC_INIT_ERROR;
  47
  48       err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
  49       if (err != GPG_ERR_NO_ERROR)
  50         return GC_INIT_ERROR;
  51     }
  52
  53   return GC_OK;
  54 }
  55
  56 void
  57 gc_done (void)
  58 {
  59   return;
  60 }
  61
  62 /* Randomness. */
  63
  64 Gc_rc
  65 gc_nonce (char *data, size_t datalen)
  66 {
  67   gcry_create_nonce ((unsigned char *) data, datalen);
  68   return GC_OK;
  69 }
  70
  71 Gc_rc
  72 gc_pseudo_random (char *data, size_t datalen)
  73 {
  74   gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
  75   return GC_OK;
  76 }
  77
  78 Gc_rc
  79 gc_random (char *data, size_t datalen)
  80 {
  81   gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
  82   return GC_OK;
  83 }
  84
  85 /* Memory allocation. */
  86
  87 void
  88 gc_set_allocators (gc_malloc_t func_malloc,
  89                    gc_malloc_t secure_malloc,
  90                    gc_secure_check_t secure_check,
  91                    gc_realloc_t func_realloc, gc_free_t func_free)
  92 {
  93   gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
  94                                func_realloc, func_free);
  95 }
  96
  97 /* Ciphers. */
  98
  99 Gc_rc
 100 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
 101                 gc_cipher_handle * outhandle)
 102 {
 103   int gcryalg, gcrymode;
 104   gcry_error_t err;
 105
 106   switch (alg)
 107     {
 108     case GC_AES128:
 109       gcryalg = GCRY_CIPHER_RIJNDAEL;
 110       break;
 111
 112     case GC_AES192:
 113       gcryalg = GCRY_CIPHER_RIJNDAEL;
 114       break;
 115
 116     case GC_AES256:
 117       gcryalg = GCRY_CIPHER_RIJNDAEL256;
 118       break;
 119
 120     case GC_3DES:
 121       gcryalg = GCRY_CIPHER_3DES;
 122       break;
 123
 124     case GC_DES:
 125       gcryalg = GCRY_CIPHER_DES;
 126       break;
 127
 128     case GC_ARCFOUR128:
 129     case GC_ARCFOUR40:
 130       gcryalg = GCRY_CIPHER_ARCFOUR;
 131       break;
 132
 133     case GC_ARCTWO40:
 134       gcryalg = GCRY_CIPHER_RFC2268_40;
 135       break;
 136
 137     default:
 138       return GC_INVALID_CIPHER;
 139     }
 140
 141   switch (mode)
 142     {
 143     case GC_CBC:
 144       gcrymode = GCRY_CIPHER_MODE_CBC;
 145       break;
 146
 147     case GC_STREAM:
 148       gcrymode = GCRY_CIPHER_MODE_STREAM;
 149       break;
 150
 151     default:
 152       return GC_INVALID_CIPHER;
 153     }
 154
 155   err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
 156                           gcryalg, gcrymode, 0);
 157   if (gcry_err_code (err))
 158     return GC_INVALID_CIPHER;
 159
 160   return GC_OK;
 161 }
 162
 163 Gc_rc
 164 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
 165 {
 166   gcry_error_t err;
 167
 168   err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
 169   if (gcry_err_code (err))
 170     return GC_INVALID_CIPHER;
 171
 172   return GC_OK;
 173 }
 174
 175 Gc_rc
 176 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
 177 {
 178   gcry_error_t err;
 179
 180   err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
 181   if (gcry_err_code (err))
 182     return GC_INVALID_CIPHER;
 183
 184   return GC_OK;
 185 }
 186
 187 Gc_rc
 188 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 189 {
 190   if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
 191                            data, len, NULL, len) != 0)
 192     return GC_INVALID_CIPHER;
 193
 194   return GC_OK;
 195 }
 196
 197 Gc_rc
 198 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
 199 {
 200   if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
 201                            data, len, NULL, len) != 0)
 202     return GC_INVALID_CIPHER;
 203
 204   return GC_OK;
 205 }
 206
 207 Gc_rc
 208 gc_cipher_close (gc_cipher_handle handle)
 209 {
 210   gcry_cipher_close (handle);
 211
 212   return GC_OK;
 213 }
 214
 215 /* Hashes. */
 216
 217 Gc_rc
 218 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
 219 {
 220   int gcryalg, gcrymode;
 221   gcry_error_t err;
 222
 223   switch (hash)
 224     {
 225     case GC_MD5:
 226       gcryalg = GCRY_MD_MD5;
 227       break;
 228
 229     case GC_SHA1:
 230       gcryalg = GCRY_MD_SHA1;
 231       break;
 232
 233     case GC_RMD160:
 234       gcryalg = GCRY_MD_RMD160;
 235       break;
 236
 237     default:
 238       return GC_INVALID_HASH;
 239     }
 240
 241   switch (mode)
 242     {
 243     case 0:
 244       gcrymode = 0;
 245       break;
 246
 247     case GC_HMAC:
 248       gcrymode = GCRY_MD_FLAG_HMAC;
 249       break;
 250
 251     default:
 252       return GC_INVALID_HASH;
 253     }
 254
 255   err = gcry_md_open ((gcry_md_hd_t *) outhandle, gcryalg, gcrymode);
 256   if (gcry_err_code (err))
 257     return GC_INVALID_HASH;
 258
 259   return GC_OK;
 260 }
 261
 262 Gc_rc
 263 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
 264 {
 265   int err;
 266
 267   err = gcry_md_copy ((gcry_md_hd_t *) outhandle, (gcry_md_hd_t) handle);
 268   if (err)
 269     return GC_INVALID_HASH;
 270
 271   return GC_OK;
 272 }
 273
 274 size_t
 275 gc_hash_digest_length (Gc_hash hash)
 276 {
 277   int gcryalg;
 278
 279   switch (hash)
 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_RMD160:
 290       gcryalg = GCRY_MD_RMD160;
 291       break;
 292
 293     default:
 294       return 0;
 295     }
 296
 297   return gcry_md_get_algo_dlen (gcryalg);
 298 }
 299
 300 void
 301 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
 302 {
 303   gcry_md_setkey ((gcry_md_hd_t) handle, key, len);
 304 }
 305
 306 void
 307 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
 308 {
 309   gcry_md_write ((gcry_md_hd_t) handle, data, len);
 310 }
 311
 312 const char *
 313 gc_hash_read (gc_hash_handle handle)
 314 {
 315   const char *digest;
 316
 317   gcry_md_final ((gcry_md_hd_t) handle);
 318   digest = gcry_md_read ((gcry_md_hd_t) handle, 0);
 319
 320   return digest;
 321 }
 322
 323 void
 324 gc_hash_close (gc_hash_handle handle)
 325 {
 326   gcry_md_close ((gcry_md_hd_t) handle);
 327 }
 328
 329 Gc_rc
 330 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
 331 {
 332   int gcryalg;
 333
 334   switch (hash)
 335     {
 336 #ifdef GC_USE_MD5
 337     case GC_MD5:
 338       gcryalg = GCRY_MD_MD5;
 339       break;
 340 #endif
 341
 342 #ifdef GC_USE_SHA1
 343     case GC_SHA1:
 344       gcryalg = GCRY_MD_SHA1;
 345       break;
 346 #endif
 347
 348 #ifdef GC_USE_RMD160
 349     case GC_RMD160:
 350       gcryalg = GCRY_MD_RMD160;
 351       break;
 352 #endif
 353
 354     default:
 355       return GC_INVALID_HASH;
 356     }
 357
 358   gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
 359
 360   return GC_OK;
 361 }
 362
 363 /* One-call interface. */
 364
 365 #ifdef GC_USE_MD5
 366 Gc_rc
 367 gc_md5 (const void *in, size_t inlen, void *resbuf)
 368 {
 369   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 370   gcry_md_hd_t hd;
 371   gpg_error_t err;
 372   unsigned char *p;
 373
 374   assert (outlen == GC_MD5_DIGEST_SIZE);
 375
 376   err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
 377   if (err != GPG_ERR_NO_ERROR)
 378     return GC_INVALID_HASH;
 379
 380   gcry_md_write (hd, in, inlen);
 381
 382   p = gcry_md_read (hd, GCRY_MD_MD5);
 383   if (p == NULL)
 384     {
 385       gcry_md_close (hd);
 386       return GC_INVALID_HASH;
 387     }
 388
 389   memcpy (resbuf, p, outlen);
 390
 391   gcry_md_close (hd);
 392
 393   return GC_OK;
 394 }
 395 #endif
 396
 397 #ifdef GC_USE_SHA1
 398 Gc_rc
 399 gc_sha1 (const void *in, size_t inlen, void *resbuf)
 400 {
 401   size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 402   gcry_md_hd_t hd;
 403   gpg_error_t err;
 404   unsigned char *p;
 405
 406   assert (outlen == GC_SHA1_DIGEST_SIZE);
 407
 408   err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
 409   if (err != GPG_ERR_NO_ERROR)
 410     return GC_INVALID_HASH;
 411
 412   gcry_md_write (hd, in, inlen);
 413
 414   p = gcry_md_read (hd, GCRY_MD_SHA1);
 415   if (p == NULL)
 416     {
 417       gcry_md_close (hd);
 418       return GC_INVALID_HASH;
 419     }
 420
 421   memcpy (resbuf, p, outlen);
 422
 423   gcry_md_close (hd);
 424
 425   return GC_OK;
 426 }
 427 #endif
 428
 429 #ifdef GC_USE_HMAC_MD5
 430 Gc_rc
 431 gc_hmac_md5 (const void *key, size_t keylen,
 432              const void *in, size_t inlen, char *resbuf)
 433 {
 434   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
 435   gcry_md_hd_t mdh;
 436   unsigned char *hash;
 437   gpg_error_t err;
 438
 439   assert (hlen == 16);
 440
 441   err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
 442   if (err != GPG_ERR_NO_ERROR)
 443     return GC_INVALID_HASH;
 444
 445   err = gcry_md_setkey (mdh, key, keylen);
 446   if (err != GPG_ERR_NO_ERROR)
 447     {
 448       gcry_md_close (mdh);
 449       return GC_INVALID_HASH;
 450     }
 451
 452   gcry_md_write (mdh, in, inlen);
 453
 454   hash = gcry_md_read (mdh, GCRY_MD_MD5);
 455   if (hash == NULL)
 456     {
 457       gcry_md_close (mdh);
 458       return GC_INVALID_HASH;
 459     }
 460
 461   memcpy (resbuf, hash, hlen);
 462
 463   gcry_md_close (mdh);
 464
 465   return GC_OK;
 466 }
 467 #endif
 468
 469 #ifdef GC_USE_HMAC_SHA1
 470 Gc_rc
 471 gc_hmac_sha1 (const void *key, size_t keylen,
 472               const void *in, size_t inlen, char *resbuf)
 473 {
 474   size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
 475   gcry_md_hd_t mdh;
 476   unsigned char *hash;
 477   gpg_error_t err;
 478
 479   assert (hlen == 16);
 480
 481   err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
 482   if (err != GPG_ERR_NO_ERROR)
 483     return GC_INVALID_HASH;
 484
 485   err = gcry_md_setkey (mdh, key, keylen);
 486   if (err != GPG_ERR_NO_ERROR)
 487     {
 488       gcry_md_close (mdh);
 489       return GC_INVALID_HASH;
 490     }
 491
 492   gcry_md_write (mdh, in, inlen);
 493
 494   hash = gcry_md_read (mdh, GCRY_MD_SHA1);
 495   if (hash == NULL)
 496     {
 497       gcry_md_close (mdh);
 498       return GC_INVALID_HASH;
 499     }
 500
 501   memcpy (resbuf, hash, hlen);
 502
 503   gcry_md_close (mdh);
 504
 505   return GC_OK;
 506 }
 507 #endif