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. */
47 err = gcry_control (GCRYCTL_ANY_INITIALIZATION_P);
48 if (err == GPG_ERR_NO_ERROR)
50 if (gcry_control (GCRYCTL_DISABLE_SECMEM, NULL, 0))
53 if (gcry_check_version (GCRYPT_VERSION) == NULL)
56 err = gcry_control (GCRYCTL_INITIALIZATION_FINISHED, NULL, 0);
57 if (err != GPG_ERR_NO_ERROR)
70 #ifdef GNULIB_GC_RANDOM
75 gc_nonce (char *data, size_t datalen)
77 gcry_create_nonce ((unsigned char *) data, datalen);
82 gc_pseudo_random (char *data, size_t datalen)
84 gcry_randomize ((unsigned char *) data, datalen, GCRY_STRONG_RANDOM);
89 gc_random (char *data, size_t datalen)
91 gcry_randomize ((unsigned char *) data, datalen, GCRY_VERY_STRONG_RANDOM);
97 /* Memory allocation. */
100 gc_set_allocators (gc_malloc_t func_malloc,
101 gc_malloc_t secure_malloc,
102 gc_secure_check_t secure_check,
103 gc_realloc_t func_realloc, gc_free_t func_free)
105 gcry_set_allocation_handler (func_malloc, secure_malloc, secure_check,
106 func_realloc, func_free);
112 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
113 gc_cipher_handle * outhandle)
115 int gcryalg, gcrymode;
121 gcryalg = GCRY_CIPHER_RIJNDAEL;
125 gcryalg = GCRY_CIPHER_RIJNDAEL;
129 gcryalg = GCRY_CIPHER_RIJNDAEL256;
133 gcryalg = GCRY_CIPHER_3DES;
137 gcryalg = GCRY_CIPHER_DES;
142 gcryalg = GCRY_CIPHER_ARCFOUR;
146 gcryalg = GCRY_CIPHER_RFC2268_40;
151 gcryalg = GCRY_CIPHER_CAMELLIA128;
155 gcryalg = GCRY_CIPHER_CAMELLIA256;
160 return GC_INVALID_CIPHER;
166 gcrymode = GCRY_CIPHER_MODE_ECB;
170 gcrymode = GCRY_CIPHER_MODE_CBC;
174 gcrymode = GCRY_CIPHER_MODE_STREAM;
178 return GC_INVALID_CIPHER;
181 err = gcry_cipher_open ((gcry_cipher_hd_t *) outhandle,
182 gcryalg, gcrymode, 0);
183 if (gcry_err_code (err))
184 return GC_INVALID_CIPHER;
190 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
194 err = gcry_cipher_setkey ((gcry_cipher_hd_t) handle, key, keylen);
195 if (gcry_err_code (err))
196 return GC_INVALID_CIPHER;
202 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
206 err = gcry_cipher_setiv ((gcry_cipher_hd_t) handle, iv, ivlen);
207 if (gcry_err_code (err))
208 return GC_INVALID_CIPHER;
214 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
216 if (gcry_cipher_encrypt ((gcry_cipher_hd_t) handle,
217 data, len, NULL, len) != 0)
218 return GC_INVALID_CIPHER;
224 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
226 if (gcry_cipher_decrypt ((gcry_cipher_hd_t) handle,
227 data, len, NULL, len) != 0)
228 return GC_INVALID_CIPHER;
234 gc_cipher_close (gc_cipher_handle handle)
236 gcry_cipher_close (handle);
243 typedef struct _gc_hash_ctx {
248 char hash[GC_MD2_DIGEST_SIZE];
249 struct md2_ctx md2Context;
254 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
257 int gcryalg = 0, gcrymode = 0;
261 ctx = calloc (sizeof (*ctx), 1);
263 return GC_MALLOC_ERROR;
271 gcryalg = GCRY_MD_NONE;
275 gcryalg = GCRY_MD_MD4;
279 gcryalg = GCRY_MD_MD5;
283 gcryalg = GCRY_MD_SHA1;
287 gcryalg = GCRY_MD_SHA256;
291 gcryalg = GCRY_MD_SHA384;
295 gcryalg = GCRY_MD_SHA512;
299 gcryalg = GCRY_MD_SHA224;
303 gcryalg = GCRY_MD_RMD160;
307 rc = GC_INVALID_HASH;
317 gcrymode = GCRY_MD_FLAG_HMAC;
321 rc = GC_INVALID_HASH;
324 if (rc == GC_OK && gcryalg != GCRY_MD_NONE)
326 err = gcry_md_open (&ctx->gch, gcryalg, gcrymode);
327 if (gcry_err_code (err))
328 rc = GC_INVALID_HASH;
340 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
342 _gc_hash_ctx *in = handle;
346 *outhandle = out = calloc (sizeof (*out), 1);
348 return GC_MALLOC_ERROR;
350 memcpy (out, in, sizeof (*out));
352 err = gcry_md_copy (&out->gch, in->gch);
356 return GC_INVALID_HASH;
363 gc_hash_digest_length (Gc_hash hash)
370 len = GC_MD2_DIGEST_SIZE;
374 len = GC_MD4_DIGEST_SIZE;
378 len = GC_MD5_DIGEST_SIZE;
382 len = GC_RMD160_DIGEST_SIZE;
386 len = GC_SHA1_DIGEST_SIZE;
390 len = GC_SHA256_DIGEST_SIZE;
394 len = GC_SHA384_DIGEST_SIZE;
398 len = GC_SHA512_DIGEST_SIZE;
402 len = GC_SHA224_DIGEST_SIZE;
413 gc_hash_hmac_setkey (gc_hash_handle handle, size_t len, const char *key)
415 _gc_hash_ctx *ctx = handle;
417 if (ctx->alg != GC_MD2)
419 gcry_md_setkey (ctx->gch, key, len);
423 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
425 _gc_hash_ctx *ctx = handle;
428 if (ctx->alg == GC_MD2)
429 md2_process_bytes (data, len, &ctx->md2Context);
432 gcry_md_write (ctx->gch, data, len);
436 gc_hash_read (gc_hash_handle handle)
438 _gc_hash_ctx *ctx = handle;
442 if (ctx->alg == GC_MD2)
444 md2_finish_ctx (&ctx->md2Context, ctx->hash);
450 gcry_md_final (ctx->gch);
451 digest = gcry_md_read (ctx->gch, 0);
458 gc_hash_close (gc_hash_handle handle)
460 _gc_hash_ctx *ctx = handle;
463 if (ctx->alg != GC_MD2)
465 gcry_md_close (ctx->gch);
471 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
479 md2_buffer (in, inlen, resbuf);
486 gcryalg = GCRY_MD_MD4;
492 gcryalg = GCRY_MD_MD5;
496 #ifdef GNULIB_GC_SHA1
498 gcryalg = GCRY_MD_SHA1;
502 #ifdef GNULIB_GC_SHA256
504 gcryalg = GCRY_MD_SHA256;
508 #ifdef GNULIB_GC_SHA384
510 gcryalg = GCRY_MD_SHA384;
514 #ifdef GNULIB_GC_SHA512
516 gcryalg = GCRY_MD_SHA512;
520 #ifdef GNULIB_GC_SHA224
522 gcryalg = GCRY_MD_SHA224;
526 #ifdef GNULIB_GC_RMD160
528 gcryalg = GCRY_MD_RMD160;
533 return GC_INVALID_HASH;
536 gcry_md_hash_buffer (gcryalg, resbuf, in, inlen);
541 /* One-call interface. */
545 gc_md2 (const void *in, size_t inlen, void *resbuf)
547 md2_buffer (in, inlen, resbuf);
554 gc_md4 (const void *in, size_t inlen, void *resbuf)
556 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD4);
561 assert (outlen == GC_MD4_DIGEST_SIZE);
563 err = gcry_md_open (&hd, GCRY_MD_MD4, 0);
564 if (err != GPG_ERR_NO_ERROR)
565 return GC_INVALID_HASH;
567 gcry_md_write (hd, in, inlen);
569 p = gcry_md_read (hd, GCRY_MD_MD4);
573 return GC_INVALID_HASH;
576 memcpy (resbuf, p, outlen);
586 gc_md5 (const void *in, size_t inlen, void *resbuf)
588 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
593 assert (outlen == GC_MD5_DIGEST_SIZE);
595 err = gcry_md_open (&hd, GCRY_MD_MD5, 0);
596 if (err != GPG_ERR_NO_ERROR)
597 return GC_INVALID_HASH;
599 gcry_md_write (hd, in, inlen);
601 p = gcry_md_read (hd, GCRY_MD_MD5);
605 return GC_INVALID_HASH;
608 memcpy (resbuf, p, outlen);
616 #ifdef GNULIB_GC_SHA1
618 gc_sha1 (const void *in, size_t inlen, void *resbuf)
620 size_t outlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
625 assert (outlen == GC_SHA1_DIGEST_SIZE);
627 err = gcry_md_open (&hd, GCRY_MD_SHA1, 0);
628 if (err != GPG_ERR_NO_ERROR)
629 return GC_INVALID_HASH;
631 gcry_md_write (hd, in, inlen);
633 p = gcry_md_read (hd, GCRY_MD_SHA1);
637 return GC_INVALID_HASH;
640 memcpy (resbuf, p, outlen);
648 #ifdef GNULIB_GC_HMAC_MD5
650 gc_hmac_md5 (const void *key, size_t keylen,
651 const void *in, size_t inlen, char *resbuf)
653 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_MD5);
660 err = gcry_md_open (&mdh, GCRY_MD_MD5, GCRY_MD_FLAG_HMAC);
661 if (err != GPG_ERR_NO_ERROR)
662 return GC_INVALID_HASH;
664 err = gcry_md_setkey (mdh, key, keylen);
665 if (err != GPG_ERR_NO_ERROR)
668 return GC_INVALID_HASH;
671 gcry_md_write (mdh, in, inlen);
673 hash = gcry_md_read (mdh, GCRY_MD_MD5);
677 return GC_INVALID_HASH;
680 memcpy (resbuf, hash, hlen);
688 #ifdef GNULIB_GC_HMAC_SHA1
690 gc_hmac_sha1 (const void *key, size_t keylen,
691 const void *in, size_t inlen, char *resbuf)
693 size_t hlen = gcry_md_get_algo_dlen (GCRY_MD_SHA1);
698 assert (hlen == GC_SHA1_DIGEST_SIZE);
700 err = gcry_md_open (&mdh, GCRY_MD_SHA1, GCRY_MD_FLAG_HMAC);
701 if (err != GPG_ERR_NO_ERROR)
702 return GC_INVALID_HASH;
704 err = gcry_md_setkey (mdh, key, keylen);
705 if (err != GPG_ERR_NO_ERROR)
708 return GC_INVALID_HASH;
711 gcry_md_write (mdh, in, inlen);
713 hash = gcry_md_read (mdh, GCRY_MD_SHA1);
717 return GC_INVALID_HASH;
720 memcpy (resbuf, hash, hlen);