mpi: Add an API for EC point operations.
[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
28
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 unsigned int
465 gcry_mpi_get_nbits (gcry_mpi_t a)
466 {
467   return _gcry_mpi_get_nbits (a);
468 }
469
470 int
471 gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n)
472 {
473   return _gcry_mpi_test_bit (a, n);
474 }
475
476 void
477 gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n)
478 {
479   _gcry_mpi_set_bit (a, n);
480 }
481
482 void
483 gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n)
484 {
485   _gcry_mpi_clear_bit (a, n);
486 }
487
488 void
489 gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n)
490 {
491   _gcry_mpi_set_highbit (a, n);
492 }
493
494 void
495 gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n)
496 {
497   _gcry_mpi_clear_highbit (a, n);
498 }
499
500 void
501 gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
502 {
503   _gcry_mpi_rshift (x, a, n);
504 }
505
506 void
507 gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
508 {
509   _gcry_mpi_lshift (x, a, n);
510 }
511
512 gcry_mpi_t
513 gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
514 {
515   return _gcry_mpi_set_opaque (a, p, nbits);
516 }
517
518 void *
519 gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits)
520 {
521   return _gcry_mpi_get_opaque (a, nbits);
522 }
523
524 void
525 gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
526 {
527   _gcry_mpi_set_flag (a, flag);
528 }
529
530 void
531 gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
532 {
533   _gcry_mpi_clear_flag (a, flag);
534 }
535
536 int
537 gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
538 {
539   return _gcry_mpi_get_flag (a, flag);
540 }
541
542 gcry_error_t
543 gcry_cipher_open (gcry_cipher_hd_t *handle,
544                   int algo, int mode, unsigned int flags)
545 {
546   if (!fips_is_operational ())
547     {
548       *handle = NULL;
549       return gpg_error (fips_not_operational ());
550     }
551
552   return _gcry_cipher_open (handle, algo, mode, flags);
553 }
554
555 void
556 gcry_cipher_close (gcry_cipher_hd_t h)
557 {
558   _gcry_cipher_close (h);
559 }
560
561 gcry_error_t
562 gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
563 {
564   if (!fips_is_operational ())
565     return gpg_error (fips_not_operational ());
566
567   return _gcry_cipher_setkey (hd, key, keylen);
568 }
569
570 gcry_error_t
571 gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
572 {
573   if (!fips_is_operational ())
574     return gpg_error (fips_not_operational ());
575
576   return _gcry_cipher_setiv (hd, iv, ivlen);
577 }
578
579 gpg_error_t
580 gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
581 {
582   if (!fips_is_operational ())
583     return gpg_error (fips_not_operational ());
584
585   return _gcry_cipher_setctr (hd, ctr, ctrlen);
586 }
587
588
589 gcry_error_t
590 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
591 {
592   if (!fips_is_operational ())
593     return gpg_error (fips_not_operational ());
594
595   return _gcry_cipher_ctl (h, cmd, buffer, buflen);
596 }
597
598 gcry_error_t
599 gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
600 {
601   return _gcry_cipher_info (h, what, buffer, nbytes);
602 }
603
604 gcry_error_t
605 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
606 {
607   if (!fips_is_operational ())
608     return gpg_error (fips_not_operational ());
609
610   return _gcry_cipher_algo_info (algo, what, buffer, nbytes);
611 }
612
613 const char *
614 gcry_cipher_algo_name (int algorithm)
615 {
616   return _gcry_cipher_algo_name (algorithm);
617 }
618
619 int
620 gcry_cipher_map_name (const char *name)
621 {
622   return _gcry_cipher_map_name (name);
623 }
624
625 int
626 gcry_cipher_mode_from_oid (const char *string)
627 {
628   return _gcry_cipher_mode_from_oid (string);
629 }
630
631 gcry_error_t
632 gcry_cipher_encrypt (gcry_cipher_hd_t h,
633                      void *out, size_t outsize,
634                      const void *in, size_t inlen)
635 {
636   if (!fips_is_operational ())
637     {
638       /* Make sure that the plaintext will never make it to OUT. */
639       if (out)
640         memset (out, 0x42, outsize);
641       return gpg_error (fips_not_operational ());
642     }
643
644   return _gcry_cipher_encrypt (h, out, outsize, in, inlen);
645 }
646
647 gcry_error_t
648 gcry_cipher_decrypt (gcry_cipher_hd_t h,
649                      void *out, size_t outsize,
650                      const void *in, size_t inlen)
651 {
652   if (!fips_is_operational ())
653     return gpg_error (fips_not_operational ());
654
655   return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
656 }
657
658 size_t
659 gcry_cipher_get_algo_keylen (int algo)
660 {
661   return _gcry_cipher_get_algo_keylen (algo);
662 }
663
664 size_t
665 gcry_cipher_get_algo_blklen (int algo)
666 {
667   return _gcry_cipher_get_algo_blklen (algo);
668 }
669
670 gcry_error_t
671 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
672 {
673   if (!fips_is_operational ())
674     {
675       *result = NULL;
676       return gpg_error (fips_not_operational ());
677     }
678   return _gcry_pk_encrypt (result, data, pkey);
679 }
680
681 gcry_error_t
682 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
683 {
684   if (!fips_is_operational ())
685     {
686       *result = NULL;
687       return gpg_error (fips_not_operational ());
688     }
689   return _gcry_pk_decrypt (result, data, skey);
690 }
691
692 gcry_error_t
693 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
694 {
695   if (!fips_is_operational ())
696     {
697       *result = NULL;
698       return gpg_error (fips_not_operational ());
699     }
700   return _gcry_pk_sign (result, data, skey);
701 }
702
703 gcry_error_t
704 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
705 {
706   if (!fips_is_operational ())
707     return gpg_error (fips_not_operational ());
708   return _gcry_pk_verify (sigval, data, pkey);
709 }
710
711 gcry_error_t
712 gcry_pk_testkey (gcry_sexp_t key)
713 {
714   if (!fips_is_operational ())
715     return gpg_error (fips_not_operational ());
716   return _gcry_pk_testkey (key);
717 }
718
719 gcry_error_t
720 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
721 {
722   if (!fips_is_operational ())
723     {
724       *r_key = NULL;
725       return gpg_error (fips_not_operational ());
726     }
727   return _gcry_pk_genkey (r_key, s_parms);
728 }
729
730 gcry_error_t
731 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
732 {
733   return _gcry_pk_ctl (cmd, buffer, buflen);
734 }
735
736 gcry_error_t
737 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
738 {
739   if (!fips_is_operational ())
740     return gpg_error (fips_not_operational ());
741
742   return _gcry_pk_algo_info (algo, what, buffer, nbytes);
743 }
744
745 const char *
746 gcry_pk_algo_name (int algorithm)
747 {
748   return _gcry_pk_algo_name (algorithm);
749 }
750
751 int
752 gcry_pk_map_name (const char *name)
753 {
754   return _gcry_pk_map_name (name);
755 }
756
757 unsigned int
758 gcry_pk_get_nbits (gcry_sexp_t key)
759 {
760   if (!fips_is_operational ())
761     {
762       (void)fips_not_operational ();
763       return 0;
764     }
765
766   return _gcry_pk_get_nbits (key);
767 }
768
769 unsigned char *
770 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
771 {
772   if (!fips_is_operational ())
773     {
774       (void)fips_not_operational ();
775       return NULL;
776     }
777   return _gcry_pk_get_keygrip (key, array);
778 }
779
780 const char *
781 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
782 {
783   if (!fips_is_operational ())
784     {
785       (void)fips_not_operational ();
786       return NULL;
787     }
788   return _gcry_pk_get_curve (key, iterator, r_nbits);
789 }
790
791 gcry_sexp_t
792 gcry_pk_get_param (int algo, const char *name)
793 {
794   if (!fips_is_operational ())
795     {
796       (void)fips_not_operational ();
797       return NULL;
798     }
799   return _gcry_pk_get_param (algo, name);
800 }
801
802 gcry_error_t
803 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
804 {
805   if (!fips_is_operational ())
806     {
807       *h = NULL;
808       return gpg_error (fips_not_operational ());
809     }
810
811   return _gcry_md_open (h, algo, flags);
812 }
813
814 void
815 gcry_md_close (gcry_md_hd_t hd)
816 {
817   _gcry_md_close (hd);
818 }
819
820 gcry_error_t
821 gcry_md_enable (gcry_md_hd_t hd, int algo)
822 {
823   if (!fips_is_operational ())
824     return gpg_error (fips_not_operational ());
825   return _gcry_md_enable (hd, algo);
826 }
827
828 gcry_error_t
829 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
830 {
831   if (!fips_is_operational ())
832     {
833       *bhd = NULL;
834       return gpg_error (fips_not_operational ());
835     }
836   return _gcry_md_copy (bhd, ahd);
837 }
838
839 void
840 gcry_md_reset (gcry_md_hd_t hd)
841 {
842   _gcry_md_reset (hd);
843 }
844
845 gcry_error_t
846 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
847 {
848   if (!fips_is_operational ())
849     return gpg_error (fips_not_operational ());
850   return _gcry_md_ctl (hd, cmd, buffer, buflen);
851 }
852
853 void
854 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
855 {
856   if (!fips_is_operational ())
857     {
858       (void)fips_not_operational ();
859       return;
860     }
861   _gcry_md_write (hd, buffer, length);
862 }
863
864 unsigned char *
865 gcry_md_read (gcry_md_hd_t hd, int algo)
866 {
867   return _gcry_md_read (hd, algo);
868 }
869
870 void
871 gcry_md_hash_buffer (int algo, void *digest,
872                      const void *buffer, size_t length)
873 {
874   if (!fips_is_operational ())
875     {
876       (void)fips_not_operational ();
877       fips_signal_error ("called in non-operational state");
878     }
879   _gcry_md_hash_buffer (algo, digest, buffer, length);
880 }
881
882 int
883 gcry_md_get_algo (gcry_md_hd_t hd)
884 {
885   if (!fips_is_operational ())
886     {
887       (void)fips_not_operational ();
888       fips_signal_error ("used in non-operational state");
889       return 0;
890     }
891   return _gcry_md_get_algo (hd);
892 }
893
894 unsigned int
895 gcry_md_get_algo_dlen (int algo)
896 {
897   return _gcry_md_get_algo_dlen (algo);
898 }
899
900 int
901 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
902 {
903   if (!fips_is_operational ())
904     {
905       (void)fips_not_operational ();
906       return 0;
907     }
908
909   return _gcry_md_is_enabled (a, algo);
910 }
911
912 int
913 gcry_md_is_secure (gcry_md_hd_t a)
914 {
915   return _gcry_md_is_secure (a);
916 }
917
918 gcry_error_t
919 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
920 {
921   if (!fips_is_operational ())
922     return gpg_error (fips_not_operational ());
923
924   return _gcry_md_info (h, what, buffer, nbytes);
925 }
926
927 gcry_error_t
928 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
929 {
930   return _gcry_md_algo_info (algo, what, buffer, nbytes);
931 }
932
933 const char *
934 gcry_md_algo_name (int algo)
935 {
936   return _gcry_md_algo_name (algo);
937 }
938
939 int
940 gcry_md_map_name (const char* name)
941 {
942   return _gcry_md_map_name (name);
943 }
944
945 gcry_error_t
946 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
947 {
948   if (!fips_is_operational ())
949     return gpg_error (fips_not_operational ());
950   return _gcry_md_setkey (hd, key, keylen);
951 }
952
953 void
954 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
955 {
956   _gcry_md_debug (hd, suffix);
957 }
958
959 gpg_error_t
960 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
961                  int algo, int hashalgo,
962                  const void *salt, size_t saltlen,
963                  unsigned long iterations,
964                  size_t keysize, void *keybuffer)
965 {
966   return _gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
967                            salt, saltlen, iterations, keysize, keybuffer);
968 }
969
970 void
971 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
972 {
973   if (!fips_is_operational ())
974     {
975       (void)fips_not_operational ();
976       fips_signal_fatal_error ("called in non-operational state");
977       fips_noreturn ();
978     }
979   _gcry_randomize (buffer, length, level);
980 }
981
982 gcry_error_t
983 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
984 {
985   if (!fips_is_operational ())
986     return gpg_error (fips_not_operational ());
987   return _gcry_random_add_bytes (buffer, length, quality);
988 }
989
990 void *
991 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
992 {
993   if (!fips_is_operational ())
994     {
995       (void)fips_not_operational ();
996       fips_signal_fatal_error ("called in non-operational state");
997       fips_noreturn ();
998     }
999
1000   return _gcry_random_bytes (nbytes,level);
1001 }
1002
1003 void *
1004 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
1005 {
1006   if (!fips_is_operational ())
1007     {
1008       (void)fips_not_operational ();
1009       fips_signal_fatal_error ("called in non-operational state");
1010       fips_noreturn ();
1011     }
1012
1013   return _gcry_random_bytes_secure (nbytes, level);
1014 }
1015
1016 void
1017 gcry_mpi_randomize (gcry_mpi_t w,
1018                     unsigned int nbits, enum gcry_random_level level)
1019 {
1020   _gcry_mpi_randomize (w, nbits, level);
1021 }
1022
1023 void
1024 gcry_create_nonce (void *buffer, size_t length)
1025 {
1026   if (!fips_is_operational ())
1027     {
1028       (void)fips_not_operational ();
1029       fips_signal_fatal_error ("called in non-operational state");
1030       fips_noreturn ();
1031     }
1032   _gcry_create_nonce (buffer, length);
1033 }
1034
1035 gcry_error_t
1036 gcry_prime_generate (gcry_mpi_t *prime,
1037                      unsigned int prime_bits,
1038                      unsigned int factor_bits,
1039                      gcry_mpi_t **factors,
1040                      gcry_prime_check_func_t cb_func,
1041                      void *cb_arg,
1042                      gcry_random_level_t random_level,
1043                      unsigned int flags)
1044 {
1045   return _gcry_prime_generate (prime, prime_bits, factor_bits, factors,
1046                                cb_func, cb_arg, random_level, flags);
1047 }
1048
1049 gcry_error_t
1050 gcry_prime_group_generator (gcry_mpi_t *r_g,
1051                             gcry_mpi_t prime, gcry_mpi_t *factors,
1052                             gcry_mpi_t start_g)
1053 {
1054   return _gcry_prime_group_generator (r_g, prime, factors, start_g);
1055 }
1056
1057 void
1058 gcry_prime_release_factors (gcry_mpi_t *factors)
1059 {
1060   _gcry_prime_release_factors (factors);
1061 }
1062
1063 gcry_error_t
1064 gcry_prime_check (gcry_mpi_t x, unsigned int flags)
1065 {
1066   return _gcry_prime_check (x, flags);
1067 }
1068
1069 void
1070 gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
1071 {
1072   _gcry_set_progress_handler (cb, cb_data);
1073 }
1074
1075 void
1076 gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
1077                              gcry_handler_alloc_t func_alloc_secure,
1078                              gcry_handler_secure_check_t func_secure_check,
1079                              gcry_handler_realloc_t func_realloc,
1080                              gcry_handler_free_t func_free)
1081 {
1082   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
1083                                 func_secure_check, func_realloc, func_free);
1084 }
1085
1086 void
1087 gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
1088 {
1089   _gcry_set_outofcore_handler (h, opaque);
1090 }
1091
1092 void
1093 gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
1094 {
1095   _gcry_set_fatalerror_handler (fnc, opaque);
1096 }
1097
1098 void
1099 gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
1100 {
1101   _gcry_set_log_handler (f, opaque);
1102 }
1103
1104 void
1105 gcry_set_gettext_handler (const char *(*f)(const char*))
1106 {
1107   _gcry_set_gettext_handler (f);
1108 }
1109
1110 void *
1111 gcry_malloc (size_t n)
1112 {
1113   return _gcry_malloc (n);
1114 }
1115
1116 void *
1117 gcry_calloc (size_t n, size_t m)
1118 {
1119   return _gcry_calloc (n, m);
1120 }
1121
1122 void *
1123 gcry_malloc_secure (size_t n)
1124 {
1125   return _gcry_malloc_secure (n);
1126 }
1127
1128 void *
1129 gcry_calloc_secure (size_t n, size_t m)
1130 {
1131   return _gcry_calloc_secure (n,m);
1132 }
1133
1134 void *
1135 gcry_realloc (void *a, size_t n)
1136 {
1137   return _gcry_realloc (a, n);
1138 }
1139
1140 char *
1141 gcry_strdup (const char *string)
1142 {
1143   return _gcry_strdup (string);
1144 }
1145
1146 void *
1147 gcry_xmalloc (size_t n)
1148 {
1149   return _gcry_xmalloc (n);
1150 }
1151
1152 void *
1153 gcry_xcalloc (size_t n, size_t m)
1154 {
1155   return _gcry_xcalloc (n, m);
1156 }
1157
1158 void *
1159 gcry_xmalloc_secure (size_t n)
1160 {
1161   return _gcry_xmalloc_secure (n);
1162 }
1163
1164 void *
1165 gcry_xcalloc_secure (size_t n, size_t m)
1166 {
1167   return _gcry_xcalloc_secure (n, m);
1168 }
1169
1170 void *
1171 gcry_xrealloc (void *a, size_t n)
1172 {
1173   return _gcry_xrealloc (a, n);
1174 }
1175
1176 char *
1177 gcry_xstrdup (const char *a)
1178 {
1179   return _gcry_xstrdup (a);
1180 }
1181
1182 void
1183 gcry_free (void *a)
1184 {
1185   _gcry_free (a);
1186 }
1187
1188 int
1189 gcry_is_secure (const void *a)
1190 {
1191   return _gcry_is_secure (a);
1192 }