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