1 /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
2 * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free
3 * Software Foundation, Inc.
5 * This file is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published
7 * by the Free Software Foundation; either version 2, or (at your
8 * option) any later version.
10 * This file is distributed in the hope that it will be useful, but
11 * WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this file; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
22 /* Note: This file is only built if GC uses Libgcrypt. */
32 /* Get libgcrypt API. */
40 #ifndef MIN_GCRYPT_VERSION
41 # define MIN_GCRYPT_VERSION "1.4.4"
51 err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
52 if (err == GPG_ERR_NO_ERROR)
54 if (gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0))
57 if (gcry_check_version (MIN_GCRYPT_VERSION) == NULL)
60 err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
61 if (err != GPG_ERR_NO_ERROR)
74 #ifdef GNULIB_GC_RANDOM
79 gc_nonce (char *data, size_t datalen)
81 gcry_create_nonce ((unsigned char *) data, datalen);
86 gc_pseudo_random (char *data, size_t datalen)
88 gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
93 gc_random (char *data, size_t datalen)
95 gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
101 /* Memory allocation. */
104 gc_set_allocators (gc_malloc_t func_malloc,
105 gc_malloc_t secure_malloc,
106 gc_secure_check_t secure_check,
107 gc_realloc_t func_realloc, gc_free_t func_free)
109 gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
110 func_realloc, func_free);
116 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
117 gc_cipher_handle * outhandle)
119 int gcryalg, gcrymode;
125 gcryalg = GCRY_CIPHER_RIJNDAEL;
129 gcryalg = GCRY_CIPHER_RIJNDAEL;
133 gcryalg = GCRY_CIPHER_RIJNDAEL256;
137 gcryalg = GCRY_CIPHER_3DES;
141 gcryalg = GCRY_CIPHER_DES;
146 gcryalg = GCRY_CIPHER_ARCFOUR;
150 gcryalg = GCRY_CIPHER_RFC2268_40;
155 gcryalg = GCRY_CIPHER_CAMELLIA128;
159 gcryalg = GCRY_CIPHER_CAMELLIA256;
164 return GC_INVALID_CIPHER;
170 gcrymode = GCRY_CIPHER_MODE_ECB;
174 gcrymode = GCRY_CIPHER_MODE_CBC;
178 gcrymode = GCRY_CIPHER_MODE_STREAM;
182 return GC_INVALID_CIPHER;
185 err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
186 gcryalg, gcrymode, 0);
187 if (gcry_err_code (err))
188 return GC_INVALID_CIPHER;
194 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
198 err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
199 if (gcry_err_code (err))
200 return GC_INVALID_CIPHER;
206 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
210 err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
211 if (gcry_err_code (err))
212 return GC_INVALID_CIPHER;
218 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
220 if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
221 data, len, NULL, len) != 0)
222 return GC_INVALID_CIPHER;
228 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
230 if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
231 data, len, NULL, len) != 0)
232 return GC_INVALID_CIPHER;
238 gc_cipher_close (gc_cipher_handle handle)
240 gcry_cipher_close (handle);
247 typedef struct _gc_hash_ctx {
252 char hash[GC_MD2_DIGEST_SIZE];
253 struct md2_ctx md2Context;
258 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
261 int gcryalg = 0, gcrymode = 0;
265 ctx = calloc (sizeof (*ctx), 1);
267 return GC_MALLOC_ERROR;
275 gcryalg = GCRY_MD_NONE;
279 gcryalg = GCRY_MD_MD4;
283 gcryalg = GCRY_MD_MD5;
287 gcryalg = GCRY_MD_SHA1;
291 gcryalg = GCRY_MD_SHA256;
295 gcryalg = GCRY_MD_SHA384;
299 gcryalg = GCRY_MD_SHA512;
303 gcryalg = GCRY_MD_SHA224;
307 gcryalg = GCRY_MD_RMD160;
311 rc = GC_INVALID_HASH;
321 gcrymode = GCRY_MD_FLAG_HMAC;
325 rc = GC_INVALID_HASH;
328 if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
330 err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
331 if (gcry_err_code (err))
332 rc = GC_INVALID_HASH;
344 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
346 _gc_hash_ctx *in = handle;
350 *outhandle = out = calloc (sizeof (*out), 1);
352 return GC_MALLOC_ERROR;
354 memcpy (out, in, sizeof (*out));
356 err = gcry_md_copy (&out->gch, in->gch);
360 return GC_INVALID_HASH;
367 gc_hash_digest_length (Gc_hash hash)
374 len = GC_MD2_DIGEST_SIZE;
378 len = GC_MD4_DIGEST_SIZE;
382 len = GC_MD5_DIGEST_SIZE;
386 len = GC_RMD160_DIGEST_SIZE;
390 len = GC_SHA1_DIGEST_SIZE;
394 len = GC_SHA256_DIGEST_SIZE;
398 len = GC_SHA384_DIGEST_SIZE;
402 len = GC_SHA512_DIGEST_SIZE;
406 len = GC_SHA224_DIGEST_SIZE;
417 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
419 _gc_hash_ctx *ctx = handle;
421 if (ctx->alg != GC_MD2)
423 gcry_md_setkey (ctx->gch, key, len);
427 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
429 _gc_hash_ctx *ctx = handle;
432 if (ctx->alg == GC_MD2)
433 md2_process_bytes (data, len, &ctx->md2Context);
436 gcry_md_write (ctx->gch, data, len);
440 gc_hash_read (gc_hash_handle handle)
442 _gc_hash_ctx *ctx = handle;
446 if (ctx->alg == GC_MD2)
448 md2_finish_ctx (&ctx->md2Context, ctx->hash);
454 gcry_md_final (ctx->gch);
455 digest = gcry_md_read (ctx->gch, 0);
462 gc_hash_close (gc_hash_handle handle)
464 _gc_hash_ctx *ctx = handle;
467 if (ctx->alg != GC_MD2)
469 gcry_md_close (ctx->gch);
475 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
483 md2_buffer (in, inlen, resbuf);
490 gcryalg = GCRY_MD_MD4;
496 gcryalg = GCRY_MD_MD5;
500 #ifdef GNULIB_GC_SHA1
502 gcryalg = GCRY_MD_SHA1;
506 #ifdef GNULIB_GC_SHA256
508 gcryalg = GCRY_MD_SHA256;
512 #ifdef GNULIB_GC_SHA384
514 gcryalg = GCRY_MD_SHA384;
518 #ifdef GNULIB_GC_SHA512
520 gcryalg = GCRY_MD_SHA512;
524 #ifdef GNULIB_GC_SHA224
526 gcryalg = GCRY_MD_SHA224;
530 #ifdef GNULIB_GC_RMD160
532 gcryalg = GCRY_MD_RMD160;
537 return GC_INVALID_HASH;
540 gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
545 /* One-call interface. */
549 gc_md2 (const void *in, size_t inlen, void *resbuf)
551 md2_buffer (in, inlen, resbuf);
558 gc_md4 (const void *in, size_t inlen, void *resbuf)
560 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
565 assert (outlen == GC_MD4_DIGEST_SIZE);
567 err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
568 if (err != GPG_ERR_NO_ERROR)
569 return GC_INVALID_HASH;
571 gcry_md_write (hd, in, inlen);
573 p = gcry_md_read (hd, GCRY_MD_MD4);
577 return GC_INVALID_HASH;
580 memcpy (resbuf, p, outlen);
590 gc_md5 (const void *in, size_t inlen, void *resbuf)
592 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
597 assert (outlen == GC_MD5_DIGEST_SIZE);
599 err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
600 if (err != GPG_ERR_NO_ERROR)
601 return GC_INVALID_HASH;
603 gcry_md_write (hd, in, inlen);
605 p = gcry_md_read (hd, GCRY_MD_MD5);
609 return GC_INVALID_HASH;
612 memcpy (resbuf, p, outlen);
620 #ifdef GNULIB_GC_SHA1
622 gc_sha1 (const void *in, size_t inlen, void *resbuf)
624 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
629 assert (outlen == GC_SHA1_DIGEST_SIZE);
631 err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
632 if (err != GPG_ERR_NO_ERROR)
633 return GC_INVALID_HASH;
635 gcry_md_write (hd, in, inlen);
637 p = gcry_md_read (hd, GCRY_MD_SHA1);
641 return GC_INVALID_HASH;
644 memcpy (resbuf, p, outlen);
652 #ifdef GNULIB_GC_HMAC_MD5
654 gc_hmac_md5 (const void *key, size_t keylen,
655 const void *in, size_t inlen, char *resbuf)
657 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
664 err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
665 if (err != GPG_ERR_NO_ERROR)
666 return GC_INVALID_HASH;
668 err = gcry_md_setkey (mdh, key, keylen);
669 if (err != GPG_ERR_NO_ERROR)
672 return GC_INVALID_HASH;
675 gcry_md_write (mdh, in, inlen);
677 hash = gcry_md_read (mdh, GCRY_MD_MD5);
681 return GC_INVALID_HASH;
684 memcpy (resbuf, hash, hlen);
692 #ifdef GNULIB_GC_HMAC_SHA1
694 gc_hmac_sha1 (const void *key, size_t keylen,
695 const void *in, size_t inlen, char *resbuf)
697 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
702 assert (hlen == GC_SHA1_DIGEST_SIZE);
704 err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
705 if (err != GPG_ERR_NO_ERROR)
706 return GC_INVALID_HASH;
708 err = gcry_md_setkey (mdh, key, keylen);
709 if (err != GPG_ERR_NO_ERROR)
712 return GC_INVALID_HASH;
715 gcry_md_write (mdh, in, inlen);
717 hash = gcry_md_read (mdh, GCRY_MD_SHA1);
721 return GC_INVALID_HASH;
724 memcpy (resbuf, hash, hlen);