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