Update gnulib files.
[gnutls:gnutls.git] / lgl / gc-gnulib.c
1 /* gc-gnulib.c --- Common gnulib internal crypto interface functions
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 Lesser General Public License as published
6  * by the Free Software Foundation; either version 2.1, 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 Lesser 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 internal functions. */
22
23 #include <config.h>
24
25 /* Get prototype. */
26 #include "gc.h"
27
28 #include <stdlib.h>
29 #include <string.h>
30
31 /* For randomize. */
32 #ifdef GNULIB_GC_RANDOM
33 # include <unistd.h>
34 # include <sys/types.h>
35 # include <sys/stat.h>
36 # include <fcntl.h>
37 # include <errno.h>
38 #endif
39
40 /* Hashes. */
41 #ifdef GNULIB_GC_MD2
42 # include "md2.h"
43 #endif
44 #ifdef GNULIB_GC_MD4
45 # include "md4.h"
46 #endif
47 #ifdef GNULIB_GC_MD5
48 # include "md5.h"
49 #endif
50 #ifdef GNULIB_GC_SHA1
51 # include "sha1.h"
52 #endif
53 #if defined(GNULIB_GC_HMAC_MD5) || defined(GNULIB_GC_HMAC_SHA1)
54 # include "hmac.h"
55 #endif
56
57 /* Ciphers. */
58 #ifdef GNULIB_GC_ARCFOUR
59 # include "arcfour.h"
60 #endif
61 #ifdef GNULIB_GC_ARCTWO
62 # include "arctwo.h"
63 #endif
64 #ifdef GNULIB_GC_DES
65 # include "des.h"
66 #endif
67 #ifdef GNULIB_GC_RIJNDAEL
68 # include "rijndael-api-fst.h"
69 #endif
70
71 /* The results of open() in this file are not used with fchdir,
72    therefore save some unnecessary work in fchdir.c.  */
73 #undef open
74 #undef close
75
76 #ifdef GNULIB_GC_RANDOM
77 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
78 #  include <wincrypt.h>
79 HCRYPTPROV g_hProv = 0;
80 # endif
81 #endif
82
83 Gc_rc
84 gc_init (void)
85 {
86 #ifdef GNULIB_GC_RANDOM
87 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
88   if(g_hProv)
89     CryptReleaseContext(g_hProv, 0);
90   CryptAcquireContext(&g_hProv, NULL, NULL, PROV_RSA_FULL, 0);
91 # endif
92 #endif
93
94   return GC_OK;
95 }
96
97 void
98 gc_done (void)
99 {
100 #ifdef GNULIB_GC_RANDOM
101 # if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
102   if(g_hProv)
103     {
104       CryptReleaseContext(g_hProv, 0);
105       g_hProv = 0;
106     }
107 # endif
108 #endif
109
110   return;
111 }
112
113 #ifdef GNULIB_GC_RANDOM
114
115 /* Randomness. */
116
117 static Gc_rc
118 randomize (int level, char *data, size_t datalen)
119 {
120 #if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
121   if(!g_hProv)
122     return GC_RANDOM_ERROR;
123   CryptGenRandom(g_hProv, (DWORD)datalen, data);
124 #else
125   int fd;
126   const char *device;
127   size_t len = 0;
128   int rc;
129
130   switch (level)
131     {
132     case 0:
133       device = NAME_OF_NONCE_DEVICE;
134       break;
135
136     case 1:
137       device = NAME_OF_PSEUDO_RANDOM_DEVICE;
138       break;
139
140     default:
141       device = NAME_OF_RANDOM_DEVICE;
142       break;
143     }
144
145   if (strcmp (device, "no") == 0)
146     return GC_RANDOM_ERROR;
147
148   fd = open (device, O_RDONLY);
149   if (fd < 0)
150     return GC_RANDOM_ERROR;
151
152   do
153     {
154       ssize_t tmp;
155
156       tmp = read (fd, data, datalen);
157
158       if (tmp < 0)
159         {
160           int save_errno = errno;
161           close (fd);
162           errno = save_errno;
163           return GC_RANDOM_ERROR;
164         }
165
166       len += tmp;
167     }
168   while (len < datalen);
169
170   rc = close (fd);
171   if (rc < 0)
172     return GC_RANDOM_ERROR;
173 #endif
174
175   return GC_OK;
176 }
177
178 Gc_rc
179 gc_nonce (char *data, size_t datalen)
180 {
181   return randomize (0, data, datalen);
182 }
183
184 Gc_rc
185 gc_pseudo_random (char *data, size_t datalen)
186 {
187   return randomize (1, data, datalen);
188 }
189
190 Gc_rc
191 gc_random (char *data, size_t datalen)
192 {
193   return randomize (2, data, datalen);
194 }
195
196 #endif
197
198 /* Memory allocation. */
199
200 void
201 gc_set_allocators (gc_malloc_t func_malloc,
202                    gc_malloc_t secure_malloc,
203                    gc_secure_check_t secure_check,
204                    gc_realloc_t func_realloc, gc_free_t func_free)
205 {
206   return;
207 }
208 /* Ciphers. */
209
210 typedef struct _gc_cipher_ctx {
211   Gc_cipher alg;
212   Gc_cipher_mode mode;
213 #ifdef GNULIB_GC_ARCTWO
214   arctwo_context arctwoContext;
215   char arctwoIV[ARCTWO_BLOCK_SIZE];
216 #endif
217 #ifdef GNULIB_GC_ARCFOUR
218   arcfour_context arcfourContext;
219 #endif
220 #ifdef GNULIB_GC_DES
221   gl_des_ctx desContext;
222 #endif
223 #ifdef GNULIB_GC_RIJNDAEL
224   rijndaelKeyInstance aesEncKey;
225   rijndaelKeyInstance aesDecKey;
226   rijndaelCipherInstance aesContext;
227 #endif
228 } _gc_cipher_ctx;
229
230 Gc_rc
231 gc_cipher_open (Gc_cipher alg, Gc_cipher_mode mode,
232                 gc_cipher_handle * outhandle)
233 {
234   _gc_cipher_ctx *ctx;
235   Gc_rc rc = GC_OK;
236
237   ctx = calloc (sizeof (*ctx), 1);
238   if (!ctx)
239     return GC_MALLOC_ERROR;
240
241   ctx->alg = alg;
242   ctx->mode = mode;
243
244   switch (alg)
245     {
246 #ifdef GNULIB_GC_ARCTWO
247     case GC_ARCTWO40:
248       switch (mode)
249         {
250         case GC_ECB:
251         case GC_CBC:
252           break;
253
254         default:
255           rc = GC_INVALID_CIPHER;
256         }
257       break;
258 #endif
259
260 #ifdef GNULIB_GC_ARCFOUR
261     case GC_ARCFOUR128:
262     case GC_ARCFOUR40:
263       switch (mode)
264         {
265         case GC_STREAM:
266           break;
267
268         default:
269           rc = GC_INVALID_CIPHER;
270         }
271       break;
272 #endif
273
274 #ifdef GNULIB_GC_DES
275     case GC_DES:
276       switch (mode)
277         {
278         case GC_ECB:
279           break;
280
281         default:
282           rc = GC_INVALID_CIPHER;
283         }
284       break;
285 #endif
286
287 #ifdef GNULIB_GC_RIJNDAEL
288     case GC_AES128:
289     case GC_AES192:
290     case GC_AES256:
291       switch (mode)
292         {
293         case GC_ECB:
294         case GC_CBC:
295           break;
296
297         default:
298           rc = GC_INVALID_CIPHER;
299         }
300       break;
301 #endif
302
303     default:
304       rc = GC_INVALID_CIPHER;
305     }
306
307   if (rc == GC_OK)
308     *outhandle = ctx;
309   else
310     free (ctx);
311
312   return rc;
313 }
314
315 Gc_rc
316 gc_cipher_setkey (gc_cipher_handle handle, size_t keylen, const char *key)
317 {
318   _gc_cipher_ctx *ctx = handle;
319
320   switch (ctx->alg)
321     {
322 #ifdef GNULIB_GC_ARCTWO
323     case GC_ARCTWO40:
324       arctwo_setkey (&ctx->arctwoContext, keylen, key);
325       break;
326 #endif
327
328 #ifdef GNULIB_GC_ARCFOUR
329     case GC_ARCFOUR128:
330     case GC_ARCFOUR40:
331       arcfour_setkey (&ctx->arcfourContext, key, keylen);
332       break;
333 #endif
334
335 #ifdef GNULIB_GC_DES
336     case GC_DES:
337       if (keylen != 8)
338         return GC_INVALID_CIPHER;
339       gl_des_setkey (&ctx->desContext, key);
340       break;
341 #endif
342
343 #ifdef GNULIB_GC_RIJNDAEL
344     case GC_AES128:
345     case GC_AES192:
346     case GC_AES256:
347       {
348         rijndael_rc rc;
349         size_t i;
350         char keyMaterial[RIJNDAEL_MAX_KEY_SIZE + 1];
351
352         for (i = 0; i < keylen; i++)
353           sprintf (&keyMaterial[2*i], "%02x", key[i] & 0xFF);
354
355         rc = rijndaelMakeKey (&ctx->aesEncKey, RIJNDAEL_DIR_ENCRYPT,
356                               keylen * 8, keyMaterial);
357         if (rc < 0)
358           return GC_INVALID_CIPHER;
359
360         rc = rijndaelMakeKey (&ctx->aesDecKey, RIJNDAEL_DIR_DECRYPT,
361                               keylen * 8, keyMaterial);
362         if (rc < 0)
363           return GC_INVALID_CIPHER;
364
365         rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_ECB, NULL);
366         if (rc < 0)
367           return GC_INVALID_CIPHER;
368       }
369       break;
370 #endif
371
372     default:
373       return GC_INVALID_CIPHER;
374     }
375
376   return GC_OK;
377 }
378
379 Gc_rc
380 gc_cipher_setiv (gc_cipher_handle handle, size_t ivlen, const char *iv)
381 {
382   _gc_cipher_ctx *ctx = handle;
383
384   switch (ctx->alg)
385     {
386 #ifdef GNULIB_GC_ARCTWO
387     case GC_ARCTWO40:
388       if (ivlen != ARCTWO_BLOCK_SIZE)
389         return GC_INVALID_CIPHER;
390       memcpy (ctx->arctwoIV, iv, ivlen);
391       break;
392 #endif
393
394 #ifdef GNULIB_GC_RIJNDAEL
395     case GC_AES128:
396     case GC_AES192:
397     case GC_AES256:
398       switch (ctx->mode)
399         {
400         case GC_ECB:
401           /* Doesn't use IV. */
402           break;
403
404         case GC_CBC:
405           {
406             rijndael_rc rc;
407             size_t i;
408             char ivMaterial[2 * RIJNDAEL_MAX_IV_SIZE + 1];
409
410             for (i = 0; i < ivlen; i++)
411               sprintf (&ivMaterial[2*i], "%02x", iv[i] & 0xFF);
412
413             rc = rijndaelCipherInit (&ctx->aesContext, RIJNDAEL_MODE_CBC,
414                                      ivMaterial);
415             if (rc < 0)
416               return GC_INVALID_CIPHER;
417           }
418           break;
419
420         default:
421           return GC_INVALID_CIPHER;
422         }
423       break;
424 #endif
425
426     default:
427       return GC_INVALID_CIPHER;
428     }
429
430   return GC_OK;
431 }
432
433 Gc_rc
434 gc_cipher_encrypt_inline (gc_cipher_handle handle, size_t len, char *data)
435 {
436   _gc_cipher_ctx *ctx = handle;
437
438   switch (ctx->alg)
439     {
440 #ifdef GNULIB_GC_ARCTWO
441     case GC_ARCTWO40:
442       switch (ctx->mode)
443         {
444         case GC_ECB:
445           arctwo_encrypt (&ctx->arctwoContext, data, data, len);
446           break;
447
448         case GC_CBC:
449           for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
450                  data += ARCTWO_BLOCK_SIZE)
451             {
452               size_t i;
453               for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
454                 data[i] ^= ctx->arctwoIV[i];
455               arctwo_encrypt (&ctx->arctwoContext, data, data,
456                               ARCTWO_BLOCK_SIZE);
457               memcpy (ctx->arctwoIV, data, ARCTWO_BLOCK_SIZE);
458             }
459             break;
460
461         default:
462           return GC_INVALID_CIPHER;
463         }
464       break;
465 #endif
466
467 #ifdef GNULIB_GC_ARCFOUR
468     case GC_ARCFOUR128:
469     case GC_ARCFOUR40:
470       arcfour_stream (&ctx->arcfourContext, data, data, len);
471       break;
472 #endif
473
474 #ifdef GNULIB_GC_DES
475     case GC_DES:
476       for (; len >= 8; len -= 8, data += 8)
477         gl_des_ecb_encrypt (&ctx->desContext, data, data);
478       break;
479 #endif
480
481 #ifdef GNULIB_GC_RIJNDAEL
482     case GC_AES128:
483     case GC_AES192:
484     case GC_AES256:
485       {
486         int nblocks;
487
488         nblocks = rijndaelBlockEncrypt (&ctx->aesContext, &ctx->aesEncKey,
489                                         data, 8 * len, data);
490         if (nblocks < 0)
491           return GC_INVALID_CIPHER;
492       }
493       break;
494 #endif
495
496     default:
497       return GC_INVALID_CIPHER;
498     }
499
500   return GC_OK;
501 }
502
503 Gc_rc
504 gc_cipher_decrypt_inline (gc_cipher_handle handle, size_t len, char *data)
505 {
506   _gc_cipher_ctx *ctx = handle;
507
508   switch (ctx->alg)
509     {
510 #ifdef GNULIB_GC_ARCTWO
511     case GC_ARCTWO40:
512       switch (ctx->mode)
513         {
514         case GC_ECB:
515           arctwo_decrypt (&ctx->arctwoContext, data, data, len);
516           break;
517
518         case GC_CBC:
519           for (; len >= ARCTWO_BLOCK_SIZE; len -= ARCTWO_BLOCK_SIZE,
520                  data += ARCTWO_BLOCK_SIZE)
521             {
522               char tmpIV[ARCTWO_BLOCK_SIZE];
523               size_t i;
524               memcpy (tmpIV, data, ARCTWO_BLOCK_SIZE);
525               arctwo_decrypt (&ctx->arctwoContext, data, data,
526                               ARCTWO_BLOCK_SIZE);
527               for (i = 0; i < ARCTWO_BLOCK_SIZE; i++)
528                 data[i] ^= ctx->arctwoIV[i];
529               memcpy (ctx->arctwoIV, tmpIV, ARCTWO_BLOCK_SIZE);
530             }
531           break;
532
533         default:
534           return GC_INVALID_CIPHER;
535         }
536       break;
537 #endif
538
539 #ifdef GNULIB_GC_ARCFOUR
540     case GC_ARCFOUR128:
541     case GC_ARCFOUR40:
542       arcfour_stream (&ctx->arcfourContext, data, data, len);
543       break;
544 #endif
545
546 #ifdef GNULIB_GC_DES
547     case GC_DES:
548       for (; len >= 8; len -= 8, data += 8)
549         gl_des_ecb_decrypt (&ctx->desContext, data, data);
550       break;
551 #endif
552
553 #ifdef GNULIB_GC_RIJNDAEL
554     case GC_AES128:
555     case GC_AES192:
556     case GC_AES256:
557       {
558         int nblocks;
559
560         nblocks = rijndaelBlockDecrypt (&ctx->aesContext, &ctx->aesDecKey,
561                                         data, 8 * len, data);
562         if (nblocks < 0)
563           return GC_INVALID_CIPHER;
564       }
565       break;
566 #endif
567
568     default:
569       return GC_INVALID_CIPHER;
570     }
571
572   return GC_OK;
573 }
574
575 Gc_rc
576 gc_cipher_close (gc_cipher_handle handle)
577 {
578   _gc_cipher_ctx *ctx = handle;
579
580   free (ctx);
581
582   return GC_OK;
583 }
584
585 /* Hashes. */
586
587 #define MAX_DIGEST_SIZE 20
588
589 typedef struct _gc_hash_ctx {
590   Gc_hash alg;
591   Gc_hash_mode mode;
592   char hash[MAX_DIGEST_SIZE];
593 #ifdef GNULIB_GC_MD2
594   struct md2_ctx md2Context;
595 #endif
596 #ifdef GNULIB_GC_MD4
597   struct md4_ctx md4Context;
598 #endif
599 #ifdef GNULIB_GC_MD5
600   struct md5_ctx md5Context;
601 #endif
602 #ifdef GNULIB_GC_SHA1
603   struct sha1_ctx sha1Context;
604 #endif
605 } _gc_hash_ctx;
606
607 Gc_rc
608 gc_hash_open (Gc_hash hash, Gc_hash_mode mode, gc_hash_handle * outhandle)
609 {
610   _gc_hash_ctx *ctx;
611   Gc_rc rc = GC_OK;
612
613   ctx = calloc (sizeof (*ctx), 1);
614   if (!ctx)
615     return GC_MALLOC_ERROR;
616
617   ctx->alg = hash;
618   ctx->mode = mode;
619
620   switch (hash)
621     {
622 #ifdef GNULIB_GC_MD2
623     case GC_MD2:
624       md2_init_ctx (&ctx->md2Context);
625       break;
626 #endif
627
628 #ifdef GNULIB_GC_MD4
629     case GC_MD4:
630       md4_init_ctx (&ctx->md4Context);
631       break;
632 #endif
633
634 #ifdef GNULIB_GC_MD5
635     case GC_MD5:
636       md5_init_ctx (&ctx->md5Context);
637       break;
638 #endif
639
640 #ifdef GNULIB_GC_SHA1
641     case GC_SHA1:
642       sha1_init_ctx (&ctx->sha1Context);
643       break;
644 #endif
645
646     default:
647       rc = GC_INVALID_HASH;
648       break;
649     }
650
651   switch (mode)
652     {
653     case 0:
654       break;
655
656     default:
657       rc = GC_INVALID_HASH;
658       break;
659     }
660
661   if (rc == GC_OK)
662     *outhandle = ctx;
663   else
664     free (ctx);
665
666   return rc;
667 }
668
669 Gc_rc
670 gc_hash_clone (gc_hash_handle handle, gc_hash_handle * outhandle)
671 {
672   _gc_hash_ctx *in = handle;
673   _gc_hash_ctx *out;
674
675   *outhandle = out = calloc (sizeof (*out), 1);
676   if (!out)
677     return GC_MALLOC_ERROR;
678
679   memcpy (out, in, sizeof (*out));
680
681   return GC_OK;
682 }
683
684 size_t
685 gc_hash_digest_length (Gc_hash hash)
686 {
687   size_t len;
688
689   switch (hash)
690     {
691     case GC_MD2:
692       len = GC_MD2_DIGEST_SIZE;
693       break;
694
695     case GC_MD4:
696       len = GC_MD4_DIGEST_SIZE;
697       break;
698
699     case GC_MD5:
700       len = GC_MD5_DIGEST_SIZE;
701       break;
702
703     case GC_RMD160:
704       len = GC_RMD160_DIGEST_SIZE;
705       break;
706
707     case GC_SHA1:
708       len = GC_SHA1_DIGEST_SIZE;
709       break;
710
711     default:
712       return 0;
713     }
714
715   return len;
716 }
717
718 void
719 gc_hash_write (gc_hash_handle handle, size_t len, const char *data)
720 {
721   _gc_hash_ctx *ctx = handle;
722
723   switch (ctx->alg)
724     {
725 #ifdef GNULIB_GC_MD2
726     case GC_MD2:
727       md2_process_bytes (data, len, &ctx->md2Context);
728       break;
729 #endif
730
731 #ifdef GNULIB_GC_MD4
732     case GC_MD4:
733       md4_process_bytes (data, len, &ctx->md4Context);
734       break;
735 #endif
736
737 #ifdef GNULIB_GC_MD5
738     case GC_MD5:
739       md5_process_bytes (data, len, &ctx->md5Context);
740       break;
741 #endif
742
743 #ifdef GNULIB_GC_SHA1
744     case GC_SHA1:
745       sha1_process_bytes (data, len, &ctx->sha1Context);
746       break;
747 #endif
748
749     default:
750       break;
751     }
752 }
753
754 const char *
755 gc_hash_read (gc_hash_handle handle)
756 {
757   _gc_hash_ctx *ctx = handle;
758   const char *ret = NULL;
759
760   switch (ctx->alg)
761     {
762 #ifdef GNULIB_GC_MD2
763     case GC_MD2:
764       md2_finish_ctx (&ctx->md2Context, ctx->hash);
765       ret = ctx->hash;
766       break;
767 #endif
768
769 #ifdef GNULIB_GC_MD4
770     case GC_MD4:
771       md4_finish_ctx (&ctx->md4Context, ctx->hash);
772       ret = ctx->hash;
773       break;
774 #endif
775
776 #ifdef GNULIB_GC_MD5
777     case GC_MD5:
778       md5_finish_ctx (&ctx->md5Context, ctx->hash);
779       ret = ctx->hash;
780       break;
781 #endif
782
783 #ifdef GNULIB_GC_SHA1
784     case GC_SHA1:
785       sha1_finish_ctx (&ctx->sha1Context, ctx->hash);
786       ret = ctx->hash;
787       break;
788 #endif
789
790     default:
791       return NULL;
792     }
793
794   return ret;
795 }
796
797 void
798 gc_hash_close (gc_hash_handle handle)
799 {
800   _gc_hash_ctx *ctx = handle;
801
802   free (ctx);
803 }
804
805 Gc_rc
806 gc_hash_buffer (Gc_hash hash, const void *in, size_t inlen, char *resbuf)
807 {
808   switch (hash)
809     {
810 #ifdef GNULIB_GC_MD2
811     case GC_MD2:
812       md2_buffer (in, inlen, resbuf);
813       break;
814 #endif
815
816 #ifdef GNULIB_GC_MD4
817     case GC_MD4:
818       md4_buffer (in, inlen, resbuf);
819       break;
820 #endif
821
822 #ifdef GNULIB_GC_MD5
823     case GC_MD5:
824       md5_buffer (in, inlen, resbuf);
825       break;
826 #endif
827
828 #ifdef GNULIB_GC_SHA1
829     case GC_SHA1:
830       sha1_buffer (in, inlen, resbuf);
831       break;
832 #endif
833
834     default:
835       return GC_INVALID_HASH;
836     }
837
838   return GC_OK;
839 }
840
841 #ifdef GNULIB_GC_MD2
842 Gc_rc
843 gc_md2 (const void *in, size_t inlen, void *resbuf)
844 {
845   md2_buffer (in, inlen, resbuf);
846   return GC_OK;
847 }
848 #endif
849
850 #ifdef GNULIB_GC_MD4
851 Gc_rc
852 gc_md4 (const void *in, size_t inlen, void *resbuf)
853 {
854   md4_buffer (in, inlen, resbuf);
855   return GC_OK;
856 }
857 #endif
858
859 #ifdef GNULIB_GC_MD5
860 Gc_rc
861 gc_md5 (const void *in, size_t inlen, void *resbuf)
862 {
863   md5_buffer (in, inlen, resbuf);
864   return GC_OK;
865 }
866 #endif
867
868 #ifdef GNULIB_GC_SHA1
869 Gc_rc
870 gc_sha1 (const void *in, size_t inlen, void *resbuf)
871 {
872   sha1_buffer (in, inlen, resbuf);
873   return GC_OK;
874 }
875 #endif
876
877 #ifdef GNULIB_GC_HMAC_MD5
878 Gc_rc
879 gc_hmac_md5 (const void *key, size_t keylen,
880              const void *in, size_t inlen, char *resbuf)
881 {
882   hmac_md5 (key, keylen, in, inlen, resbuf);
883   return GC_OK;
884 }
885 #endif
886
887 #ifdef GNULIB_GC_HMAC_SHA1
888 Gc_rc
889 gc_hmac_sha1 (const void *key, size_t keylen,
890               const void *in, size_t inlen, char *resbuf)
891 {
892   hmac_sha1 (key, keylen, in, inlen, resbuf);
893   return GC_OK;
894 }
895 #endif