Add support for Salsa20.
[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_mpi_t
605 _gcry_mpi_get_const (int no)
606 {
607   switch (no)
608     {
609     case 1: return _gcry_mpi_const (MPI_C_ONE);
610     case 2: return _gcry_mpi_const (MPI_C_TWO);
611     case 3: return _gcry_mpi_const (MPI_C_THREE);
612     case 4: return _gcry_mpi_const (MPI_C_FOUR);
613     case 8: return _gcry_mpi_const (MPI_C_EIGHT);
614     default: log_bug("unsupported GCRYMPI_CONST_ macro used\n");
615     }
616 }
617
618 gcry_error_t
619 gcry_cipher_open (gcry_cipher_hd_t *handle,
620                   int algo, int mode, unsigned int flags)
621 {
622   if (!fips_is_operational ())
623     {
624       *handle = NULL;
625       return gpg_error (fips_not_operational ());
626     }
627
628   return _gcry_cipher_open (handle, algo, mode, flags);
629 }
630
631 void
632 gcry_cipher_close (gcry_cipher_hd_t h)
633 {
634   _gcry_cipher_close (h);
635 }
636
637 gcry_error_t
638 gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
639 {
640   if (!fips_is_operational ())
641     return gpg_error (fips_not_operational ());
642
643   return _gcry_cipher_setkey (hd, key, keylen);
644 }
645
646 gcry_error_t
647 gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
648 {
649   if (!fips_is_operational ())
650     return gpg_error (fips_not_operational ());
651
652   return _gcry_cipher_setiv (hd, iv, ivlen);
653 }
654
655 gpg_error_t
656 gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
657 {
658   if (!fips_is_operational ())
659     return gpg_error (fips_not_operational ());
660
661   return _gcry_cipher_setctr (hd, ctr, ctrlen);
662 }
663
664
665 gcry_error_t
666 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
667 {
668   if (!fips_is_operational ())
669     return gpg_error (fips_not_operational ());
670
671   return _gcry_cipher_ctl (h, cmd, buffer, buflen);
672 }
673
674 gcry_error_t
675 gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
676 {
677   return _gcry_cipher_info (h, what, buffer, nbytes);
678 }
679
680 gcry_error_t
681 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
682 {
683   if (!fips_is_operational ())
684     return gpg_error (fips_not_operational ());
685
686   return _gcry_cipher_algo_info (algo, what, buffer, nbytes);
687 }
688
689 const char *
690 gcry_cipher_algo_name (int algorithm)
691 {
692   return _gcry_cipher_algo_name (algorithm);
693 }
694
695 int
696 gcry_cipher_map_name (const char *name)
697 {
698   return _gcry_cipher_map_name (name);
699 }
700
701 int
702 gcry_cipher_mode_from_oid (const char *string)
703 {
704   return _gcry_cipher_mode_from_oid (string);
705 }
706
707 gcry_error_t
708 gcry_cipher_encrypt (gcry_cipher_hd_t h,
709                      void *out, size_t outsize,
710                      const void *in, size_t inlen)
711 {
712   if (!fips_is_operational ())
713     {
714       /* Make sure that the plaintext will never make it to OUT. */
715       if (out)
716         memset (out, 0x42, outsize);
717       return gpg_error (fips_not_operational ());
718     }
719
720   return _gcry_cipher_encrypt (h, out, outsize, in, inlen);
721 }
722
723 gcry_error_t
724 gcry_cipher_decrypt (gcry_cipher_hd_t h,
725                      void *out, size_t outsize,
726                      const void *in, size_t inlen)
727 {
728   if (!fips_is_operational ())
729     return gpg_error (fips_not_operational ());
730
731   return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
732 }
733
734 size_t
735 gcry_cipher_get_algo_keylen (int algo)
736 {
737   return _gcry_cipher_get_algo_keylen (algo);
738 }
739
740 size_t
741 gcry_cipher_get_algo_blklen (int algo)
742 {
743   return _gcry_cipher_get_algo_blklen (algo);
744 }
745
746 gcry_error_t
747 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
748 {
749   if (!fips_is_operational ())
750     {
751       *result = NULL;
752       return gpg_error (fips_not_operational ());
753     }
754   return _gcry_pk_encrypt (result, data, pkey);
755 }
756
757 gcry_error_t
758 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
759 {
760   if (!fips_is_operational ())
761     {
762       *result = NULL;
763       return gpg_error (fips_not_operational ());
764     }
765   return _gcry_pk_decrypt (result, data, skey);
766 }
767
768 gcry_error_t
769 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
770 {
771   if (!fips_is_operational ())
772     {
773       *result = NULL;
774       return gpg_error (fips_not_operational ());
775     }
776   return _gcry_pk_sign (result, data, skey);
777 }
778
779 gcry_error_t
780 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
781 {
782   if (!fips_is_operational ())
783     return gpg_error (fips_not_operational ());
784   return _gcry_pk_verify (sigval, data, pkey);
785 }
786
787 gcry_error_t
788 gcry_pk_testkey (gcry_sexp_t key)
789 {
790   if (!fips_is_operational ())
791     return gpg_error (fips_not_operational ());
792   return _gcry_pk_testkey (key);
793 }
794
795 gcry_error_t
796 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
797 {
798   if (!fips_is_operational ())
799     {
800       *r_key = NULL;
801       return gpg_error (fips_not_operational ());
802     }
803   return _gcry_pk_genkey (r_key, s_parms);
804 }
805
806 gcry_error_t
807 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
808 {
809   return _gcry_pk_ctl (cmd, buffer, buflen);
810 }
811
812 gcry_error_t
813 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
814 {
815   if (!fips_is_operational ())
816     return gpg_error (fips_not_operational ());
817
818   return _gcry_pk_algo_info (algo, what, buffer, nbytes);
819 }
820
821 const char *
822 gcry_pk_algo_name (int algorithm)
823 {
824   return _gcry_pk_algo_name (algorithm);
825 }
826
827 int
828 gcry_pk_map_name (const char *name)
829 {
830   return _gcry_pk_map_name (name);
831 }
832
833 unsigned int
834 gcry_pk_get_nbits (gcry_sexp_t key)
835 {
836   if (!fips_is_operational ())
837     {
838       (void)fips_not_operational ();
839       return 0;
840     }
841
842   return _gcry_pk_get_nbits (key);
843 }
844
845 unsigned char *
846 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
847 {
848   if (!fips_is_operational ())
849     {
850       (void)fips_not_operational ();
851       return NULL;
852     }
853   return _gcry_pk_get_keygrip (key, array);
854 }
855
856 const char *
857 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
858 {
859   if (!fips_is_operational ())
860     {
861       (void)fips_not_operational ();
862       return NULL;
863     }
864   return _gcry_pk_get_curve (key, iterator, r_nbits);
865 }
866
867 gcry_sexp_t
868 gcry_pk_get_param (int algo, const char *name)
869 {
870   if (!fips_is_operational ())
871     {
872       (void)fips_not_operational ();
873       return NULL;
874     }
875   return _gcry_pk_get_param (algo, name);
876 }
877
878 gcry_error_t
879 gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
880 {
881   if (!fips_is_operational ())
882     {
883       *r_sexp = NULL;
884       return gpg_error (fips_not_operational ());
885     }
886   return gpg_error (_gcry_pubkey_get_sexp (r_sexp, mode, ctx));
887 }
888
889 gcry_error_t
890 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
891 {
892   if (!fips_is_operational ())
893     {
894       *h = NULL;
895       return gpg_error (fips_not_operational ());
896     }
897
898   return _gcry_md_open (h, algo, flags);
899 }
900
901 void
902 gcry_md_close (gcry_md_hd_t hd)
903 {
904   _gcry_md_close (hd);
905 }
906
907 gcry_error_t
908 gcry_md_enable (gcry_md_hd_t hd, int algo)
909 {
910   if (!fips_is_operational ())
911     return gpg_error (fips_not_operational ());
912   return _gcry_md_enable (hd, algo);
913 }
914
915 gcry_error_t
916 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
917 {
918   if (!fips_is_operational ())
919     {
920       *bhd = NULL;
921       return gpg_error (fips_not_operational ());
922     }
923   return _gcry_md_copy (bhd, ahd);
924 }
925
926 void
927 gcry_md_reset (gcry_md_hd_t hd)
928 {
929   _gcry_md_reset (hd);
930 }
931
932 gcry_error_t
933 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
934 {
935   if (!fips_is_operational ())
936     return gpg_error (fips_not_operational ());
937   return _gcry_md_ctl (hd, cmd, buffer, buflen);
938 }
939
940 void
941 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
942 {
943   if (!fips_is_operational ())
944     {
945       (void)fips_not_operational ();
946       return;
947     }
948   _gcry_md_write (hd, buffer, length);
949 }
950
951 unsigned char *
952 gcry_md_read (gcry_md_hd_t hd, int algo)
953 {
954   return _gcry_md_read (hd, algo);
955 }
956
957 void
958 gcry_md_hash_buffer (int algo, void *digest,
959                      const void *buffer, size_t length)
960 {
961   if (!fips_is_operational ())
962     {
963       (void)fips_not_operational ();
964       fips_signal_error ("called in non-operational state");
965     }
966   _gcry_md_hash_buffer (algo, digest, buffer, length);
967 }
968
969 int
970 gcry_md_get_algo (gcry_md_hd_t hd)
971 {
972   if (!fips_is_operational ())
973     {
974       (void)fips_not_operational ();
975       fips_signal_error ("used in non-operational state");
976       return 0;
977     }
978   return _gcry_md_get_algo (hd);
979 }
980
981 unsigned int
982 gcry_md_get_algo_dlen (int algo)
983 {
984   return _gcry_md_get_algo_dlen (algo);
985 }
986
987 int
988 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
989 {
990   if (!fips_is_operational ())
991     {
992       (void)fips_not_operational ();
993       return 0;
994     }
995
996   return _gcry_md_is_enabled (a, algo);
997 }
998
999 int
1000 gcry_md_is_secure (gcry_md_hd_t a)
1001 {
1002   return _gcry_md_is_secure (a);
1003 }
1004
1005 gcry_error_t
1006 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
1007 {
1008   if (!fips_is_operational ())
1009     return gpg_error (fips_not_operational ());
1010
1011   return _gcry_md_info (h, what, buffer, nbytes);
1012 }
1013
1014 gcry_error_t
1015 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1016 {
1017   return _gcry_md_algo_info (algo, what, buffer, nbytes);
1018 }
1019
1020 const char *
1021 gcry_md_algo_name (int algo)
1022 {
1023   return _gcry_md_algo_name (algo);
1024 }
1025
1026 int
1027 gcry_md_map_name (const char* name)
1028 {
1029   return _gcry_md_map_name (name);
1030 }
1031
1032 gcry_error_t
1033 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
1034 {
1035   if (!fips_is_operational ())
1036     return gpg_error (fips_not_operational ());
1037   return _gcry_md_setkey (hd, key, keylen);
1038 }
1039
1040 void
1041 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
1042 {
1043   _gcry_md_debug (hd, suffix);
1044 }
1045
1046 gpg_error_t
1047 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
1048                  int algo, int hashalgo,
1049                  const void *salt, size_t saltlen,
1050                  unsigned long iterations,
1051                  size_t keysize, void *keybuffer)
1052 {
1053   return _gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
1054                            salt, saltlen, iterations, keysize, keybuffer);
1055 }
1056
1057 void
1058 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
1059 {
1060   if (!fips_is_operational ())
1061     {
1062       (void)fips_not_operational ();
1063       fips_signal_fatal_error ("called in non-operational state");
1064       fips_noreturn ();
1065     }
1066   _gcry_randomize (buffer, length, level);
1067 }
1068
1069 gcry_error_t
1070 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
1071 {
1072   if (!fips_is_operational ())
1073     return gpg_error (fips_not_operational ());
1074   return _gcry_random_add_bytes (buffer, length, quality);
1075 }
1076
1077 void *
1078 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
1079 {
1080   if (!fips_is_operational ())
1081     {
1082       (void)fips_not_operational ();
1083       fips_signal_fatal_error ("called in non-operational state");
1084       fips_noreturn ();
1085     }
1086
1087   return _gcry_random_bytes (nbytes,level);
1088 }
1089
1090 void *
1091 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
1092 {
1093   if (!fips_is_operational ())
1094     {
1095       (void)fips_not_operational ();
1096       fips_signal_fatal_error ("called in non-operational state");
1097       fips_noreturn ();
1098     }
1099
1100   return _gcry_random_bytes_secure (nbytes, level);
1101 }
1102
1103 void
1104 gcry_mpi_randomize (gcry_mpi_t w,
1105                     unsigned int nbits, enum gcry_random_level level)
1106 {
1107   _gcry_mpi_randomize (w, nbits, level);
1108 }
1109
1110 void
1111 gcry_create_nonce (void *buffer, size_t length)
1112 {
1113   if (!fips_is_operational ())
1114     {
1115       (void)fips_not_operational ();
1116       fips_signal_fatal_error ("called in non-operational state");
1117       fips_noreturn ();
1118     }
1119   _gcry_create_nonce (buffer, length);
1120 }
1121
1122 gcry_error_t
1123 gcry_prime_generate (gcry_mpi_t *prime,
1124                      unsigned int prime_bits,
1125                      unsigned int factor_bits,
1126                      gcry_mpi_t **factors,
1127                      gcry_prime_check_func_t cb_func,
1128                      void *cb_arg,
1129                      gcry_random_level_t random_level,
1130                      unsigned int flags)
1131 {
1132   return _gcry_prime_generate (prime, prime_bits, factor_bits, factors,
1133                                cb_func, cb_arg, random_level, flags);
1134 }
1135
1136 gcry_error_t
1137 gcry_prime_group_generator (gcry_mpi_t *r_g,
1138                             gcry_mpi_t prime, gcry_mpi_t *factors,
1139                             gcry_mpi_t start_g)
1140 {
1141   return _gcry_prime_group_generator (r_g, prime, factors, start_g);
1142 }
1143
1144 void
1145 gcry_prime_release_factors (gcry_mpi_t *factors)
1146 {
1147   _gcry_prime_release_factors (factors);
1148 }
1149
1150 gcry_error_t
1151 gcry_prime_check (gcry_mpi_t x, unsigned int flags)
1152 {
1153   return _gcry_prime_check (x, flags);
1154 }
1155
1156 void
1157 gcry_ctx_release (gcry_ctx_t ctx)
1158 {
1159   _gcry_ctx_release (ctx);
1160 }
1161
1162 void
1163 gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
1164 {
1165   _gcry_set_progress_handler (cb, cb_data);
1166 }
1167
1168 void
1169 gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
1170                              gcry_handler_alloc_t func_alloc_secure,
1171                              gcry_handler_secure_check_t func_secure_check,
1172                              gcry_handler_realloc_t func_realloc,
1173                              gcry_handler_free_t func_free)
1174 {
1175   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
1176                                 func_secure_check, func_realloc, func_free);
1177 }
1178
1179 void
1180 gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
1181 {
1182   _gcry_set_outofcore_handler (h, opaque);
1183 }
1184
1185 void
1186 gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
1187 {
1188   _gcry_set_fatalerror_handler (fnc, opaque);
1189 }
1190
1191 void
1192 gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
1193 {
1194   _gcry_set_log_handler (f, opaque);
1195 }
1196
1197 void
1198 gcry_set_gettext_handler (const char *(*f)(const char*))
1199 {
1200   _gcry_set_gettext_handler (f);
1201 }
1202
1203 void *
1204 gcry_malloc (size_t n)
1205 {
1206   return _gcry_malloc (n);
1207 }
1208
1209 void *
1210 gcry_calloc (size_t n, size_t m)
1211 {
1212   return _gcry_calloc (n, m);
1213 }
1214
1215 void *
1216 gcry_malloc_secure (size_t n)
1217 {
1218   return _gcry_malloc_secure (n);
1219 }
1220
1221 void *
1222 gcry_calloc_secure (size_t n, size_t m)
1223 {
1224   return _gcry_calloc_secure (n,m);
1225 }
1226
1227 void *
1228 gcry_realloc (void *a, size_t n)
1229 {
1230   return _gcry_realloc (a, n);
1231 }
1232
1233 char *
1234 gcry_strdup (const char *string)
1235 {
1236   return _gcry_strdup (string);
1237 }
1238
1239 void *
1240 gcry_xmalloc (size_t n)
1241 {
1242   return _gcry_xmalloc (n);
1243 }
1244
1245 void *
1246 gcry_xcalloc (size_t n, size_t m)
1247 {
1248   return _gcry_xcalloc (n, m);
1249 }
1250
1251 void *
1252 gcry_xmalloc_secure (size_t n)
1253 {
1254   return _gcry_xmalloc_secure (n);
1255 }
1256
1257 void *
1258 gcry_xcalloc_secure (size_t n, size_t m)
1259 {
1260   return _gcry_xcalloc_secure (n, m);
1261 }
1262
1263 void *
1264 gcry_xrealloc (void *a, size_t n)
1265 {
1266   return _gcry_xrealloc (a, n);
1267 }
1268
1269 char *
1270 gcry_xstrdup (const char *a)
1271 {
1272   return _gcry_xstrdup (a);
1273 }
1274
1275 void
1276 gcry_free (void *a)
1277 {
1278   _gcry_free (a);
1279 }
1280
1281 int
1282 gcry_is_secure (const void *a)
1283 {
1284   return _gcry_is_secure (a);
1285 }