d1c55de535321ee9e66b852d018d4d8121742538
[libgcrypt.git] / src / visibility.c
1 /* visibility.c - Wrapper for all public functions.
2  * Copyright (C) 2007, 2008, 2011  Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser General Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdarg.h>
22
23 #define _GCRY_INCLUDED_BY_VISIBILITY_C
24 #include "g10lib.h"
25 #include "cipher-proto.h"
26
27
28
29 const char *
30 gcry_strerror (gcry_error_t err)
31 {
32   return _gcry_strerror (err);
33 }
34
35 const char *
36 gcry_strsource (gcry_error_t err)
37 {
38   return _gcry_strsource (err);
39 }
40
41 gcry_err_code_t
42 gcry_err_code_from_errno (int err)
43 {
44   return _gcry_err_code_from_errno (err);
45 }
46
47 int
48 gcry_err_code_to_errno (gcry_err_code_t code)
49 {
50   return _gcry_err_code_to_errno (code);
51 }
52
53 gcry_error_t
54 gcry_err_make_from_errno (gcry_err_source_t source, int err)
55 {
56   return _gcry_err_make_from_errno (source, err);
57 }
58
59 gcry_err_code_t
60 gcry_error_from_errno (int err)
61 {
62   return _gcry_error_from_errno (err);
63 }
64
65 const char *
66 gcry_check_version (const char *req_version)
67 {
68   return _gcry_check_version (req_version);
69 }
70
71 gcry_error_t
72 gcry_control (enum gcry_ctl_cmds cmd, ...)
73 {
74   gcry_error_t err;
75   va_list arg_ptr;
76
77   va_start (arg_ptr, cmd);
78   err = _gcry_vcontrol (cmd, arg_ptr);
79   va_end(arg_ptr);
80   return err;
81 }
82
83 gcry_error_t
84 gcry_sexp_new (gcry_sexp_t *retsexp,
85                const void *buffer, size_t length,
86                int autodetect)
87 {
88   return _gcry_sexp_new (retsexp, buffer, length, autodetect);
89 }
90
91 gcry_error_t
92 gcry_sexp_create (gcry_sexp_t *retsexp,
93                   void *buffer, size_t length,
94                   int autodetect, void (*freefnc) (void *))
95 {
96   return _gcry_sexp_create (retsexp, buffer, length,
97                             autodetect, freefnc);
98 }
99
100 gcry_error_t
101 gcry_sexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
102                  const char *buffer, size_t length)
103 {
104   return _gcry_sexp_sscan (retsexp, erroff, buffer, length);
105 }
106
107 gcry_error_t
108 gcry_sexp_build (gcry_sexp_t *retsexp, size_t *erroff,
109                  const char *format, ...)
110 {
111   gcry_error_t err;
112   va_list arg_ptr;
113
114   va_start (arg_ptr, format);
115   err = _gcry_sexp_vbuild (retsexp, erroff, format, arg_ptr);
116   va_end (arg_ptr);
117   return err;
118 }
119
120 gcry_error_t
121 gcry_sexp_build_array (gcry_sexp_t *retsexp, size_t *erroff,
122                        const char *format, void **arg_list)
123 {
124   return _gcry_sexp_build_array (retsexp, erroff, format, arg_list);
125 }
126
127 void
128 gcry_sexp_release (gcry_sexp_t sexp)
129 {
130   _gcry_sexp_release (sexp);
131 }
132
133 size_t
134 gcry_sexp_canon_len (const unsigned char *buffer, size_t length,
135                      size_t *erroff, gcry_error_t *errcode)
136 {
137   return _gcry_sexp_canon_len (buffer, length, erroff, errcode);
138 }
139
140 size_t
141 gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer, size_t maxlength)
142 {
143   return _gcry_sexp_sprint (sexp, mode, buffer, maxlength);
144 }
145
146 void
147 gcry_sexp_dump (const gcry_sexp_t a)
148 {
149   _gcry_sexp_dump (a);
150 }
151
152 gcry_sexp_t
153 gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b)
154 {
155   return _gcry_sexp_cons (a, b);
156 }
157
158 gcry_sexp_t
159 gcry_sexp_alist (const gcry_sexp_t *array)
160 {
161   return _gcry_sexp_alist (array);
162 }
163
164 gcry_sexp_t
165 gcry_sexp_vlist (const gcry_sexp_t a, ...)
166 {
167   /* This is not yet implemented in sexp.c.  */
168   (void)a;
169   BUG ();
170   return NULL;
171 }
172
173 gcry_sexp_t
174 gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n)
175 {
176   return _gcry_sexp_append (a, n);
177 }
178
179 gcry_sexp_t
180 gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n)
181 {
182   return _gcry_sexp_prepend (a, n);
183 }
184
185
186 gcry_sexp_t
187 gcry_sexp_find_token (gcry_sexp_t list, const char *tok, size_t toklen)
188 {
189   return _gcry_sexp_find_token (list, tok, toklen);
190 }
191
192 int
193 gcry_sexp_length (const gcry_sexp_t list)
194 {
195   return _gcry_sexp_length (list);
196 }
197
198 gcry_sexp_t
199 gcry_sexp_nth (const gcry_sexp_t list, int number)
200 {
201   return _gcry_sexp_nth (list, number);
202 }
203
204 gcry_sexp_t
205 gcry_sexp_car (const gcry_sexp_t list)
206 {
207   return _gcry_sexp_car (list);
208 }
209
210 gcry_sexp_t
211 gcry_sexp_cdr (const gcry_sexp_t list)
212 {
213   return _gcry_sexp_cdr (list);
214 }
215
216 gcry_sexp_t
217 gcry_sexp_cadr (const gcry_sexp_t list)
218 {
219   return _gcry_sexp_cadr (list);
220 }
221
222 const char *
223 gcry_sexp_nth_data (const gcry_sexp_t list, int number, size_t *datalen)
224 {
225   return _gcry_sexp_nth_data (list, number, datalen);
226 }
227
228 char *
229 gcry_sexp_nth_string (gcry_sexp_t list, int number)
230 {
231   return _gcry_sexp_nth_string (list, number);
232 }
233
234 gcry_mpi_t
235 gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt)
236 {
237   return _gcry_sexp_nth_mpi (list, number, mpifmt);
238 }
239
240 gcry_mpi_t
241 gcry_mpi_new (unsigned int nbits)
242 {
243   return _gcry_mpi_new (nbits);
244 }
245
246 gcry_mpi_t
247 gcry_mpi_snew (unsigned int nbits)
248 {
249   return _gcry_mpi_snew (nbits);
250 }
251
252 void
253 gcry_mpi_release (gcry_mpi_t a)
254 {
255   _gcry_mpi_release (a);
256 }
257
258 gcry_mpi_t
259 gcry_mpi_copy (const gcry_mpi_t a)
260 {
261   return _gcry_mpi_copy (a);
262 }
263
264 gcry_mpi_t
265 gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u)
266 {
267   return _gcry_mpi_set (w, u);
268 }
269
270 gcry_mpi_t
271 gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u)
272 {
273   return _gcry_mpi_set_ui (w, u);
274 }
275
276 void
277 gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b)
278 {
279   _gcry_mpi_swap (a, b);
280 }
281
282 int
283 gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v)
284 {
285   return _gcry_mpi_cmp (u, v);
286 }
287
288 int
289 gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v)
290 {
291   return _gcry_mpi_cmp_ui (u, v);
292 }
293
294 gcry_error_t
295 gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
296                const void *buffer, size_t buflen,
297                size_t *nscanned)
298 {
299   return _gcry_mpi_scan (ret_mpi, format, buffer, buflen, nscanned);
300 }
301
302 gcry_error_t
303 gcry_mpi_print (enum gcry_mpi_format format,
304                 unsigned char *buffer, size_t buflen,
305                 size_t *nwritten,
306                 const gcry_mpi_t a)
307 {
308   return _gcry_mpi_print (format, buffer, buflen, nwritten, a);
309 }
310
311 gcry_error_t
312 gcry_mpi_aprint (enum gcry_mpi_format format,
313                  unsigned char **buffer, size_t *nwritten,
314                  const gcry_mpi_t a)
315 {
316   return _gcry_mpi_aprint (format, buffer, nwritten, a);
317 }
318
319 void
320 gcry_mpi_dump (const gcry_mpi_t a)
321 {
322   _gcry_mpi_dump (a);
323 }
324
325 void
326 gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
327 {
328   _gcry_mpi_add (w, u, v);
329 }
330
331 void
332 gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v)
333 {
334   _gcry_mpi_add_ui (w, u, v);
335 }
336
337 void
338 gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
339 {
340   _gcry_mpi_addm (w, u, v, m);
341 }
342
343 void
344 gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
345 {
346   _gcry_mpi_sub (w, u, v);
347 }
348
349 void
350 gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
351 {
352   _gcry_mpi_sub_ui (w, u, v);
353 }
354
355 void
356 gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
357 {
358   _gcry_mpi_subm (w, u, v, m);
359 }
360
361 void
362 gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
363 {
364   _gcry_mpi_mul (w, u, v);
365 }
366
367 void
368 gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
369 {
370   _gcry_mpi_mul_ui (w, u, v);
371 }
372
373 void
374 gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
375 {
376   _gcry_mpi_mulm (w, u, v, m);
377 }
378
379 void
380 gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt)
381 {
382   _gcry_mpi_mul_2exp (w, u, cnt);
383 }
384
385 void
386 gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
387               gcry_mpi_t dividend, gcry_mpi_t divisor, int round)
388 {
389   _gcry_mpi_div (q, r, dividend, divisor, round);
390 }
391
392 void
393 gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor)
394 {
395   _gcry_mpi_mod (r, dividend, divisor);
396 }
397
398 void
399 gcry_mpi_powm (gcry_mpi_t w, const gcry_mpi_t b, const gcry_mpi_t e,
400                const gcry_mpi_t m)
401 {
402   _gcry_mpi_powm (w, b, e, m);
403 }
404
405 int
406 gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b)
407 {
408   return _gcry_mpi_gcd (g, a, b);
409 }
410
411 int
412 gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m)
413 {
414   return _gcry_mpi_invm (x, a, m);
415 }
416
417
418 unsigned int
419 gcry_mpi_get_nbits (gcry_mpi_t a)
420 {
421   return _gcry_mpi_get_nbits (a);
422 }
423
424 int
425 gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n)
426 {
427   return _gcry_mpi_test_bit (a, n);
428 }
429
430 void
431 gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n)
432 {
433   _gcry_mpi_set_bit (a, n);
434 }
435
436 void
437 gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n)
438 {
439   _gcry_mpi_clear_bit (a, n);
440 }
441
442 void
443 gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n)
444 {
445   _gcry_mpi_set_highbit (a, n);
446 }
447
448 void
449 gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n)
450 {
451   _gcry_mpi_clear_highbit (a, n);
452 }
453
454 void
455 gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
456 {
457   _gcry_mpi_rshift (x, a, n);
458 }
459
460 void
461 gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
462 {
463   _gcry_mpi_lshift (x, a, n);
464 }
465
466 gcry_mpi_t
467 gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
468 {
469   return _gcry_mpi_set_opaque (a, p, nbits);
470 }
471
472 void *
473 gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits)
474 {
475   return _gcry_mpi_get_opaque (a, nbits);
476 }
477
478 void
479 gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
480 {
481   _gcry_mpi_set_flag (a, flag);
482 }
483
484 void
485 gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
486 {
487   _gcry_mpi_clear_flag (a, flag);
488 }
489
490 int
491 gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
492 {
493   return _gcry_mpi_get_flag (a, flag);
494 }
495
496 gcry_error_t
497 gcry_cipher_open (gcry_cipher_hd_t *handle,
498                   int algo, int mode, unsigned int flags)
499 {
500   if (!fips_is_operational ())
501     {
502       *handle = NULL;
503       return gpg_error (fips_not_operational ());
504     }
505
506   return _gcry_cipher_open (handle, algo, mode, flags);
507 }
508
509 void
510 gcry_cipher_close (gcry_cipher_hd_t h)
511 {
512   _gcry_cipher_close (h);
513 }
514
515 gcry_error_t
516 gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
517 {
518   if (!fips_is_operational ())
519     return gpg_error (fips_not_operational ());
520
521   return _gcry_cipher_setkey (hd, key, keylen);
522 }
523
524 gcry_error_t
525 gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
526 {
527   if (!fips_is_operational ())
528     return gpg_error (fips_not_operational ());
529
530   return _gcry_cipher_setiv (hd, iv, ivlen);
531 }
532
533 gpg_error_t
534 gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
535 {
536   if (!fips_is_operational ())
537     return gpg_error (fips_not_operational ());
538
539   return _gcry_cipher_setctr (hd, ctr, ctrlen);
540 }
541
542
543 gcry_error_t
544 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
545 {
546   if (!fips_is_operational ())
547     return gpg_error (fips_not_operational ());
548
549   return _gcry_cipher_ctl (h, cmd, buffer, buflen);
550 }
551
552 gcry_error_t
553 gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
554 {
555   return _gcry_cipher_info (h, what, buffer, nbytes);
556 }
557
558 gcry_error_t
559 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
560 {
561   if (!fips_is_operational ())
562     return gpg_error (fips_not_operational ());
563
564   return _gcry_cipher_algo_info (algo, what, buffer, nbytes);
565 }
566
567 const char *
568 gcry_cipher_algo_name (int algorithm)
569 {
570   return _gcry_cipher_algo_name (algorithm);
571 }
572
573 int
574 gcry_cipher_map_name (const char *name)
575 {
576   return _gcry_cipher_map_name (name);
577 }
578
579 int
580 gcry_cipher_mode_from_oid (const char *string)
581 {
582   return _gcry_cipher_mode_from_oid (string);
583 }
584
585 gcry_error_t
586 gcry_cipher_encrypt (gcry_cipher_hd_t h,
587                      void *out, size_t outsize,
588                      const void *in, size_t inlen)
589 {
590   if (!fips_is_operational ())
591     {
592       /* Make sure that the plaintext will never make it to OUT. */
593       if (out)
594         memset (out, 0x42, outsize);
595       return gpg_error (fips_not_operational ());
596     }
597
598   return _gcry_cipher_encrypt (h, out, outsize, in, inlen);
599 }
600
601 gcry_error_t
602 gcry_cipher_decrypt (gcry_cipher_hd_t h,
603                      void *out, size_t outsize,
604                      const void *in, size_t inlen)
605 {
606   if (!fips_is_operational ())
607     return gpg_error (fips_not_operational ());
608
609   return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
610 }
611
612 size_t
613 gcry_cipher_get_algo_keylen (int algo)
614 {
615   return _gcry_cipher_get_algo_keylen (algo);
616 }
617
618 size_t
619 gcry_cipher_get_algo_blklen (int algo)
620 {
621   return _gcry_cipher_get_algo_blklen (algo);
622 }
623
624 gcry_error_t
625 gcry_cipher_list (int *list, int *list_length)
626 {
627   return _gcry_cipher_list (list, list_length);
628 }
629
630 gcry_error_t
631 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
632 {
633   if (!fips_is_operational ())
634     {
635       *result = NULL;
636       return gpg_error (fips_not_operational ());
637     }
638   return _gcry_pk_encrypt (result, data, pkey);
639 }
640
641 gcry_error_t
642 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
643 {
644   if (!fips_is_operational ())
645     {
646       *result = NULL;
647       return gpg_error (fips_not_operational ());
648     }
649   return _gcry_pk_decrypt (result, data, skey);
650 }
651
652 gcry_error_t
653 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
654 {
655   if (!fips_is_operational ())
656     {
657       *result = NULL;
658       return gpg_error (fips_not_operational ());
659     }
660   return _gcry_pk_sign (result, data, skey);
661 }
662
663 gcry_error_t
664 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
665 {
666   if (!fips_is_operational ())
667     return gpg_error (fips_not_operational ());
668   return _gcry_pk_verify (sigval, data, pkey);
669 }
670
671 gcry_error_t
672 gcry_pk_testkey (gcry_sexp_t key)
673 {
674   if (!fips_is_operational ())
675     return gpg_error (fips_not_operational ());
676   return _gcry_pk_testkey (key);
677 }
678
679 gcry_error_t
680 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
681 {
682   if (!fips_is_operational ())
683     {
684       *r_key = NULL;
685       return gpg_error (fips_not_operational ());
686     }
687   return _gcry_pk_genkey (r_key, s_parms);
688 }
689
690 gcry_error_t
691 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
692 {
693   return _gcry_pk_ctl (cmd, buffer, buflen);
694 }
695
696 gcry_error_t
697 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
698 {
699   if (!fips_is_operational ())
700     return gpg_error (fips_not_operational ());
701
702   return _gcry_pk_algo_info (algo, what, buffer, nbytes);
703 }
704
705 const char *
706 gcry_pk_algo_name (int algorithm)
707 {
708   return _gcry_pk_algo_name (algorithm);
709 }
710
711 int
712 gcry_pk_map_name (const char *name)
713 {
714   return _gcry_pk_map_name (name);
715 }
716
717 unsigned int
718 gcry_pk_get_nbits (gcry_sexp_t key)
719 {
720   if (!fips_is_operational ())
721     {
722       (void)fips_not_operational ();
723       return 0;
724     }
725
726   return _gcry_pk_get_nbits (key);
727 }
728
729 unsigned char *
730 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
731 {
732   if (!fips_is_operational ())
733     {
734       (void)fips_not_operational ();
735       return NULL;
736     }
737   return _gcry_pk_get_keygrip (key, array);
738 }
739
740 const char *
741 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
742 {
743   if (!fips_is_operational ())
744     {
745       (void)fips_not_operational ();
746       return NULL;
747     }
748   return _gcry_pk_get_curve (key, iterator, r_nbits);
749 }
750
751 gcry_sexp_t
752 gcry_pk_get_param (int algo, const char *name)
753 {
754   if (!fips_is_operational ())
755     {
756       (void)fips_not_operational ();
757       return NULL;
758     }
759   return _gcry_pk_get_param (algo, name);
760 }
761
762 gcry_error_t
763 gcry_pk_list (int *list, int *list_length)
764 {
765   return _gcry_pk_list (list, list_length);
766 }
767
768 gcry_error_t
769 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
770 {
771   if (!fips_is_operational ())
772     {
773       *h = NULL;
774       return gpg_error (fips_not_operational ());
775     }
776
777   return _gcry_md_open (h, algo, flags);
778 }
779
780 void
781 gcry_md_close (gcry_md_hd_t hd)
782 {
783   _gcry_md_close (hd);
784 }
785
786 gcry_error_t
787 gcry_md_enable (gcry_md_hd_t hd, int algo)
788 {
789   if (!fips_is_operational ())
790     return gpg_error (fips_not_operational ());
791   return _gcry_md_enable (hd, algo);
792 }
793
794 gcry_error_t
795 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
796 {
797   if (!fips_is_operational ())
798     {
799       *bhd = NULL;
800       return gpg_error (fips_not_operational ());
801     }
802   return _gcry_md_copy (bhd, ahd);
803 }
804
805 void
806 gcry_md_reset (gcry_md_hd_t hd)
807 {
808   _gcry_md_reset (hd);
809 }
810
811 gcry_error_t
812 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
813 {
814   if (!fips_is_operational ())
815     return gpg_error (fips_not_operational ());
816   return _gcry_md_ctl (hd, cmd, buffer, buflen);
817 }
818
819 void
820 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
821 {
822   if (!fips_is_operational ())
823     {
824       (void)fips_not_operational ();
825       return;
826     }
827   _gcry_md_write (hd, buffer, length);
828 }
829
830 unsigned char *
831 gcry_md_read (gcry_md_hd_t hd, int algo)
832 {
833   return _gcry_md_read (hd, algo);
834 }
835
836 void
837 gcry_md_hash_buffer (int algo, void *digest,
838                      const void *buffer, size_t length)
839 {
840   if (!fips_is_operational ())
841     {
842       (void)fips_not_operational ();
843       fips_signal_error ("called in non-operational state");
844     }
845   _gcry_md_hash_buffer (algo, digest, buffer, length);
846 }
847
848 int
849 gcry_md_get_algo (gcry_md_hd_t hd)
850 {
851   if (!fips_is_operational ())
852     {
853       (void)fips_not_operational ();
854       fips_signal_error ("used in non-operational state");
855       return 0;
856     }
857   return _gcry_md_get_algo (hd);
858 }
859
860 unsigned int
861 gcry_md_get_algo_dlen (int algo)
862 {
863   return _gcry_md_get_algo_dlen (algo);
864 }
865
866 int
867 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
868 {
869   if (!fips_is_operational ())
870     {
871       (void)fips_not_operational ();
872       return 0;
873     }
874
875   return _gcry_md_is_enabled (a, algo);
876 }
877
878 int
879 gcry_md_is_secure (gcry_md_hd_t a)
880 {
881   return _gcry_md_is_secure (a);
882 }
883
884 gcry_error_t
885 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
886 {
887   if (!fips_is_operational ())
888     return gpg_error (fips_not_operational ());
889
890   return _gcry_md_info (h, what, buffer, nbytes);
891 }
892
893 gcry_error_t
894 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
895 {
896   return _gcry_md_algo_info (algo, what, buffer, nbytes);
897 }
898
899 const char *
900 gcry_md_algo_name (int algo)
901 {
902   return _gcry_md_algo_name (algo);
903 }
904
905 int
906 gcry_md_map_name (const char* name)
907 {
908   return _gcry_md_map_name (name);
909 }
910
911 gcry_error_t
912 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
913 {
914   if (!fips_is_operational ())
915     return gpg_error (fips_not_operational ());
916   return _gcry_md_setkey (hd, key, keylen);
917 }
918
919 void
920 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
921 {
922   _gcry_md_debug (hd, suffix);
923 }
924
925 gcry_error_t
926 gcry_md_list (int *list, int *list_length)
927 {
928   return _gcry_md_list (list, list_length);
929 }
930
931
932 gpg_error_t
933 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
934                  int algo, int hashalgo,
935                  const void *salt, size_t saltlen,
936                  unsigned long iterations,
937                  size_t keysize, void *keybuffer)
938 {
939   return _gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
940                            salt, saltlen, iterations, keysize, keybuffer);
941 }
942
943 void
944 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
945 {
946   if (!fips_is_operational ())
947     {
948       (void)fips_not_operational ();
949       fips_signal_fatal_error ("called in non-operational state");
950       fips_noreturn ();
951     }
952   _gcry_randomize (buffer, length, level);
953 }
954
955 gcry_error_t
956 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
957 {
958   if (!fips_is_operational ())
959     return gpg_error (fips_not_operational ());
960   return _gcry_random_add_bytes (buffer, length, quality);
961 }
962
963 void *
964 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
965 {
966   if (!fips_is_operational ())
967     {
968       (void)fips_not_operational ();
969       fips_signal_fatal_error ("called in non-operational state");
970       fips_noreturn ();
971     }
972
973   return _gcry_random_bytes (nbytes,level);
974 }
975
976 void *
977 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
978 {
979   if (!fips_is_operational ())
980     {
981       (void)fips_not_operational ();
982       fips_signal_fatal_error ("called in non-operational state");
983       fips_noreturn ();
984     }
985
986   return _gcry_random_bytes_secure (nbytes, level);
987 }
988
989 void
990 gcry_mpi_randomize (gcry_mpi_t w,
991                     unsigned int nbits, enum gcry_random_level level)
992 {
993   _gcry_mpi_randomize (w, nbits, level);
994 }
995
996 void
997 gcry_create_nonce (void *buffer, size_t length)
998 {
999   if (!fips_is_operational ())
1000     {
1001       (void)fips_not_operational ();
1002       fips_signal_fatal_error ("called in non-operational state");
1003       fips_noreturn ();
1004     }
1005   _gcry_create_nonce (buffer, length);
1006 }
1007
1008 gcry_error_t
1009 gcry_prime_generate (gcry_mpi_t *prime,
1010                      unsigned int prime_bits,
1011                      unsigned int factor_bits,
1012                      gcry_mpi_t **factors,
1013                      gcry_prime_check_func_t cb_func,
1014                      void *cb_arg,
1015                      gcry_random_level_t random_level,
1016                      unsigned int flags)
1017 {
1018   return _gcry_prime_generate (prime, prime_bits, factor_bits, factors,
1019                                cb_func, cb_arg, random_level, flags);
1020 }
1021
1022 gcry_error_t
1023 gcry_prime_group_generator (gcry_mpi_t *r_g,
1024                             gcry_mpi_t prime, gcry_mpi_t *factors,
1025                             gcry_mpi_t start_g)
1026 {
1027   return _gcry_prime_group_generator (r_g, prime, factors, start_g);
1028 }
1029
1030 void
1031 gcry_prime_release_factors (gcry_mpi_t *factors)
1032 {
1033   _gcry_prime_release_factors (factors);
1034 }
1035
1036 gcry_error_t
1037 gcry_prime_check (gcry_mpi_t x, unsigned int flags)
1038 {
1039   return _gcry_prime_check (x, flags);
1040 }
1041
1042 void
1043 gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
1044 {
1045   _gcry_set_progress_handler (cb, cb_data);
1046 }
1047
1048 void
1049 gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
1050                              gcry_handler_alloc_t func_alloc_secure,
1051                              gcry_handler_secure_check_t func_secure_check,
1052                              gcry_handler_realloc_t func_realloc,
1053                              gcry_handler_free_t func_free)
1054 {
1055   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
1056                                 func_secure_check, func_realloc, func_free);
1057 }
1058
1059 void
1060 gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
1061 {
1062   _gcry_set_outofcore_handler (h, opaque);
1063 }
1064
1065 void
1066 gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
1067 {
1068   _gcry_set_fatalerror_handler (fnc, opaque);
1069 }
1070
1071 void
1072 gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
1073 {
1074   _gcry_set_log_handler (f, opaque);
1075 }
1076
1077 void
1078 gcry_set_gettext_handler (const char *(*f)(const char*))
1079 {
1080   _gcry_set_gettext_handler (f);
1081 }
1082
1083 void *
1084 gcry_malloc (size_t n)
1085 {
1086   return _gcry_malloc (n);
1087 }
1088
1089 void *
1090 gcry_calloc (size_t n, size_t m)
1091 {
1092   return _gcry_calloc (n, m);
1093 }
1094
1095 void *
1096 gcry_malloc_secure (size_t n)
1097 {
1098   return _gcry_malloc_secure (n);
1099 }
1100
1101 void *
1102 gcry_calloc_secure (size_t n, size_t m)
1103 {
1104   return _gcry_calloc_secure (n,m);
1105 }
1106
1107 void *
1108 gcry_realloc (void *a, size_t n)
1109 {
1110   return _gcry_realloc (a, n);
1111 }
1112
1113 char *
1114 gcry_strdup (const char *string)
1115 {
1116   return _gcry_strdup (string);
1117 }
1118
1119 void *
1120 gcry_xmalloc (size_t n)
1121 {
1122   return _gcry_xmalloc (n);
1123 }
1124
1125 void *
1126 gcry_xcalloc (size_t n, size_t m)
1127 {
1128   return _gcry_xcalloc (n, m);
1129 }
1130
1131 void *
1132 gcry_xmalloc_secure (size_t n)
1133 {
1134   return _gcry_xmalloc_secure (n);
1135 }
1136
1137 void *
1138 gcry_xcalloc_secure (size_t n, size_t m)
1139 {
1140   return _gcry_xcalloc_secure (n, m);
1141 }
1142
1143 void *
1144 gcry_xrealloc (void *a, size_t n)
1145 {
1146   return _gcry_xrealloc (a, n);
1147 }
1148
1149 char *
1150 gcry_xstrdup (const char *a)
1151 {
1152   return _gcry_xstrdup (a);
1153 }
1154
1155 void
1156 gcry_free (void *a)
1157 {
1158   _gcry_free (a);
1159 }
1160
1161 int
1162 gcry_is_secure (const void *a)
1163 {
1164   return _gcry_is_secure (a);
1165 }
1166
1167
1168 gcry_error_t
1169 gcry_cipher_register (gcry_cipher_spec_t *cipher, int *algorithm_id,
1170                       gcry_module_t *module)
1171 {
1172   return _gcry_cipher_register (cipher, NULL, algorithm_id, module);
1173 }
1174
1175 void
1176 gcry_cipher_unregister (gcry_module_t module)
1177 {
1178   _gcry_cipher_unregister (module);
1179 }
1180
1181 gcry_error_t
1182 gcry_pk_register (gcry_pk_spec_t *pubkey, unsigned int *algorithm_id,
1183                   gcry_module_t *module)
1184 {
1185   return _gcry_pk_register (pubkey, NULL, algorithm_id, module);
1186 }
1187
1188 void
1189 gcry_pk_unregister (gcry_module_t module)
1190 {
1191   _gcry_pk_unregister (module);
1192 }
1193
1194 gcry_error_t
1195 gcry_md_register (gcry_md_spec_t *digest, unsigned int *algorithm_id,
1196                   gcry_module_t *module)
1197 {
1198   return _gcry_md_register (digest, NULL, algorithm_id, module);
1199 }
1200
1201 void
1202 gcry_md_unregister (gcry_module_t module)
1203 {
1204   _gcry_md_unregister (module);
1205 }