1 /* gc-libgcrypt.c --- Crypto wrappers around Libgcrypt for GC.
2 * Copyright (C) 2002-2013 Free Software Foundation, Inc.
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.
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.
14 * You should have received a copy of the GNU General Public License
15 * along with this file; if not, see <http://www.gnu.org/licenses/>.
19 /* Note: This file is only built if GC uses Libgcrypt. */
29 /* Get libgcrypt API. */
37 #ifndef MIN_GCRYPT_VERSION
38 # define MIN_GCRYPT_VERSION "1.4.4"
48 err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
49 if (err == GPG_ERR_NO_ERROR)
51 if (gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0))
54 if (gcry_check_version (MIN_GCRYPT_VERSION) == NULL)
57 err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
58 if (err != GPG_ERR_NO_ERROR)
71 #ifdef GNULIB_GC_RANDOM
76 gc_nonce (char *data, size_t datalen)
78 gcry_create_nonce ((unsigned char *) data, datalen);
83 gc_pseudo_random (char *data, size_t datalen)
85 gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
90 gc_random (char *data, size_t datalen)
92 gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
98 /* Memory allocation. */
101 gc_set_allocators (gc_malloc_t func_malloc,
102 gc_malloc_t secure_malloc,
103 gc_secure_check_t secure_check,
104 gc_realloc_t func_realloc, gc_free_t func_free)
106 gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
107 func_realloc, func_free);
113 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
114 gc_cipher_handle * outhandle)
116 int gcryalg, gcrymode;
122 gcryalg = GCRY_CIPHER_RIJNDAEL;
126 gcryalg = GCRY_CIPHER_RIJNDAEL;
130 gcryalg = GCRY_CIPHER_RIJNDAEL256;
134 gcryalg = GCRY_CIPHER_3DES;
138 gcryalg = GCRY_CIPHER_DES;
143 gcryalg = GCRY_CIPHER_ARCFOUR;
147 gcryalg = GCRY_CIPHER_RFC2268_40;
152 gcryalg = GCRY_CIPHER_CAMELLIA128;
156 gcryalg = GCRY_CIPHER_CAMELLIA256;
161 return GC_INVALID_CIPHER;
167 gcrymode = GCRY_CIPHER_MODE_ECB;
171 gcrymode = GCRY_CIPHER_MODE_CBC;
175 gcrymode = GCRY_CIPHER_MODE_STREAM;
179 return GC_INVALID_CIPHER;
182 err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
183 gcryalg, gcrymode, 0);
184 if (gcry_err_code (err))
185 return GC_INVALID_CIPHER;
191 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
195 err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
196 if (gcry_err_code (err))
197 return GC_INVALID_CIPHER;
203 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
207 err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
208 if (gcry_err_code (err))
209 return GC_INVALID_CIPHER;
215 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
217 if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
218 data, len, NULL, len) != 0)
219 return GC_INVALID_CIPHER;
225 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
227 if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
228 data, len, NULL, len) != 0)
229 return GC_INVALID_CIPHER;
235 gc_cipher_close (gc_cipher_handle handle)
237 gcry_cipher_close (handle);
244 typedef struct _gc_hash_ctx {
249 char hash[GC_MD2_DIGEST_SIZE];
250 struct md2_ctx md2Context;
255 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
258 int gcryalg = 0, gcrymode = 0;
262 ctx = calloc (sizeof (*ctx), 1);
264 return GC_MALLOC_ERROR;
272 gcryalg = GCRY_MD_NONE;
276 gcryalg = GCRY_MD_MD4;
280 gcryalg = GCRY_MD_MD5;
284 gcryalg = GCRY_MD_SHA1;
288 gcryalg = GCRY_MD_SHA256;
292 gcryalg = GCRY_MD_SHA384;
296 gcryalg = GCRY_MD_SHA512;
300 gcryalg = GCRY_MD_SHA224;
304 gcryalg = GCRY_MD_RMD160;
308 rc = GC_INVALID_HASH;
318 gcrymode = GCRY_MD_FLAG_HMAC;
322 rc = GC_INVALID_HASH;
325 if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
327 err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
328 if (gcry_err_code (err))
329 rc = GC_INVALID_HASH;
341 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
343 _gc_hash_ctx *in = handle;
347 *outhandle = out = calloc (sizeof (*out), 1);
349 return GC_MALLOC_ERROR;
351 memcpy (out, in, sizeof (*out));
353 err = gcry_md_copy (&out->gch, in->gch);
357 return GC_INVALID_HASH;
364 gc_hash_digest_length (Gc_hash hash)
371 len = GC_MD2_DIGEST_SIZE;
375 len = GC_MD4_DIGEST_SIZE;
379 len = GC_MD5_DIGEST_SIZE;
383 len = GC_RMD160_DIGEST_SIZE;
387 len = GC_SHA1_DIGEST_SIZE;
391 len = GC_SHA256_DIGEST_SIZE;
395 len = GC_SHA384_DIGEST_SIZE;
399 len = GC_SHA512_DIGEST_SIZE;
403 len = GC_SHA224_DIGEST_SIZE;
414 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
416 _gc_hash_ctx *ctx = handle;
418 if (ctx->alg != GC_MD2)
420 gcry_md_setkey (ctx->gch, key, len);
424 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
426 _gc_hash_ctx *ctx = handle;
429 if (ctx->alg == GC_MD2)
430 md2_process_bytes (data, len, &ctx->md2Context);
433 gcry_md_write (ctx->gch, data, len);
437 gc_hash_read (gc_hash_handle handle)
439 _gc_hash_ctx *ctx = handle;
443 if (ctx->alg == GC_MD2)
445 md2_finish_ctx (&ctx->md2Context, ctx->hash);
451 gcry_md_final (ctx->gch);
452 digest = gcry_md_read (ctx->gch, 0);
459 gc_hash_close (gc_hash_handle handle)
461 _gc_hash_ctx *ctx = handle;
464 if (ctx->alg != GC_MD2)
466 gcry_md_close (ctx->gch);
472 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
480 md2_buffer (in, inlen, resbuf);
487 gcryalg = GCRY_MD_MD4;
493 gcryalg = GCRY_MD_MD5;
497 #ifdef GNULIB_GC_SHA1
499 gcryalg = GCRY_MD_SHA1;
503 #ifdef GNULIB_GC_SHA256
505 gcryalg = GCRY_MD_SHA256;
509 #ifdef GNULIB_GC_SHA384
511 gcryalg = GCRY_MD_SHA384;
515 #ifdef GNULIB_GC_SHA512
517 gcryalg = GCRY_MD_SHA512;
521 #ifdef GNULIB_GC_SHA224
523 gcryalg = GCRY_MD_SHA224;
527 #ifdef GNULIB_GC_RMD160
529 gcryalg = GCRY_MD_RMD160;
534 return GC_INVALID_HASH;
537 gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
542 /* One-call interface. */
546 gc_md2 (const void *in, size_t inlen, void *resbuf)
548 md2_buffer (in, inlen, resbuf);
555 gc_md4 (const void *in, size_t inlen, void *resbuf)
557 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
562 assert (outlen == GC_MD4_DIGEST_SIZE);
564 err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
565 if (err != GPG_ERR_NO_ERROR)
566 return GC_INVALID_HASH;
568 gcry_md_write (hd, in, inlen);
570 p = gcry_md_read (hd, GCRY_MD_MD4);
574 return GC_INVALID_HASH;
577 memcpy (resbuf, p, outlen);
587 gc_md5 (const void *in, size_t inlen, void *resbuf)
589 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
594 assert (outlen == GC_MD5_DIGEST_SIZE);
596 err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
597 if (err != GPG_ERR_NO_ERROR)
598 return GC_INVALID_HASH;
600 gcry_md_write (hd, in, inlen);
602 p = gcry_md_read (hd, GCRY_MD_MD5);
606 return GC_INVALID_HASH;
609 memcpy (resbuf, p, outlen);
617 #ifdef GNULIB_GC_SHA1
619 gc_sha1 (const void *in, size_t inlen, void *resbuf)
621 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
626 assert (outlen == GC_SHA1_DIGEST_SIZE);
628 err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
629 if (err != GPG_ERR_NO_ERROR)
630 return GC_INVALID_HASH;
632 gcry_md_write (hd, in, inlen);
634 p = gcry_md_read (hd, GCRY_MD_SHA1);
638 return GC_INVALID_HASH;
641 memcpy (resbuf, p, outlen);
649 #ifdef GNULIB_GC_HMAC_MD5
651 gc_hmac_md5 (const void *key, size_t keylen,
652 const void *in, size_t inlen, char *resbuf)
654 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
659 assert (hlen == GC_MD5_DIGEST_SIZE);
661 err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
662 if (err != GPG_ERR_NO_ERROR)
663 return GC_INVALID_HASH;
665 err = gcry_md_setkey (mdh, key, keylen);
666 if (err != GPG_ERR_NO_ERROR)
669 return GC_INVALID_HASH;
672 gcry_md_write (mdh, in, inlen);
674 hash = gcry_md_read (mdh, GCRY_MD_MD5);
678 return GC_INVALID_HASH;
681 memcpy (resbuf, hash, hlen);
689 #ifdef GNULIB_GC_HMAC_SHA1
691 gc_hmac_sha1 (const void *key, size_t keylen,
692 const void *in, size_t inlen, char *resbuf)
694 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
699 assert (hlen == GC_SHA1_DIGEST_SIZE);
701 err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
702 if (err != GPG_ERR_NO_ERROR)
703 return GC_INVALID_HASH;
705 err = gcry_md_setkey (mdh, key, keylen);
706 if (err != GPG_ERR_NO_ERROR)
709 return GC_INVALID_HASH;
712 gcry_md_write (mdh, in, inlen);
714 hash = gcry_md_read (mdh, GCRY_MD_SHA1);
718 return GC_INVALID_HASH;
721 memcpy (resbuf, hash, hlen);
729 #ifdef GNULIB_GC_HMAC_SHA256
731 gc_hmac_sha256 (const void *key, size_t keylen,
732 const void *in, size_t inlen, char *resbuf)
734 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA256);
739 assert (hlen == GC_SHA256_DIGEST_SIZE);
741 err = gcry_md_open (&mdh, GCRY_MD_SHA256, GCRY_MD_FLAG_HMAC);
742 if (err != GPG_ERR_NO_ERROR)
743 return GC_INVALID_HASH;
745 err = gcry_md_setkey (mdh, key, keylen);
746 if (err != GPG_ERR_NO_ERROR)
749 return GC_INVALID_HASH;
752 gcry_md_write (mdh, in, inlen);
754 hash = gcry_md_read (mdh, GCRY_MD_SHA256);
758 return GC_INVALID_HASH;
761 memcpy (resbuf, hash, hlen);
769 #ifdef GNULIB_GC_HMAC_SHA512
771 gc_hmac_sha512 (const void *key, size_t keylen,
772 const void *in, size_t inlen, char *resbuf)
774 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA512);
779 assert (hlen == GC_SHA512_DIGEST_SIZE);
781 err = gcry_md_open (&mdh, GCRY_MD_SHA512, GCRY_MD_FLAG_HMAC);
782 if (err != GPG_ERR_NO_ERROR)
783 return GC_INVALID_HASH;
785 err = gcry_md_setkey (mdh, key, keylen);
786 if (err != GPG_ERR_NO_ERROR)
789 return GC_INVALID_HASH;
792 gcry_md_write (mdh, in, inlen);
794 hash = gcry_md_read (mdh, GCRY_MD_SHA512);
798 return GC_INVALID_HASH;
801 memcpy (resbuf, hash, hlen);