Add API to support AEAD cipher modes
[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 gpg_error (_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 gpg_error (_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 gpg_error (_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_err_code_t rc;
113   va_list arg_ptr;
114
115   va_start (arg_ptr, format);
116   rc = _gcry_sexp_vbuild (retsexp, erroff, format, arg_ptr);
117   va_end (arg_ptr);
118   return gpg_error (rc);
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 gpg_error (_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   size_t n;
139   gpg_err_code_t rc;
140
141   n = _gcry_sexp_canon_len (buffer, length, erroff, &rc);
142   if (errcode)
143     *errcode = gpg_error (rc);
144   return n;
145 }
146
147 size_t
148 gcry_sexp_sprint (gcry_sexp_t sexp, int mode, void *buffer, size_t maxlength)
149 {
150   return _gcry_sexp_sprint (sexp, mode, buffer, maxlength);
151 }
152
153 void
154 gcry_sexp_dump (const gcry_sexp_t a)
155 {
156   _gcry_sexp_dump (a);
157 }
158
159 gcry_sexp_t
160 gcry_sexp_cons (const gcry_sexp_t a, const gcry_sexp_t b)
161 {
162   return _gcry_sexp_cons (a, b);
163 }
164
165 gcry_sexp_t
166 gcry_sexp_alist (const gcry_sexp_t *array)
167 {
168   return _gcry_sexp_alist (array);
169 }
170
171 gcry_sexp_t
172 gcry_sexp_vlist (const gcry_sexp_t a, ...)
173 {
174   /* This is not yet implemented in sexp.c.  */
175   (void)a;
176   BUG ();
177   return NULL;
178 }
179
180 gcry_sexp_t
181 gcry_sexp_append (const gcry_sexp_t a, const gcry_sexp_t n)
182 {
183   return _gcry_sexp_append (a, n);
184 }
185
186 gcry_sexp_t
187 gcry_sexp_prepend (const gcry_sexp_t a, const gcry_sexp_t n)
188 {
189   return _gcry_sexp_prepend (a, n);
190 }
191
192
193 gcry_sexp_t
194 gcry_sexp_find_token (gcry_sexp_t list, const char *tok, size_t toklen)
195 {
196   return _gcry_sexp_find_token (list, tok, toklen);
197 }
198
199 int
200 gcry_sexp_length (const gcry_sexp_t list)
201 {
202   return _gcry_sexp_length (list);
203 }
204
205 gcry_sexp_t
206 gcry_sexp_nth (const gcry_sexp_t list, int number)
207 {
208   return _gcry_sexp_nth (list, number);
209 }
210
211 gcry_sexp_t
212 gcry_sexp_car (const gcry_sexp_t list)
213 {
214   return _gcry_sexp_car (list);
215 }
216
217 gcry_sexp_t
218 gcry_sexp_cdr (const gcry_sexp_t list)
219 {
220   return _gcry_sexp_cdr (list);
221 }
222
223 gcry_sexp_t
224 gcry_sexp_cadr (const gcry_sexp_t list)
225 {
226   return _gcry_sexp_cadr (list);
227 }
228
229 const char *
230 gcry_sexp_nth_data (const gcry_sexp_t list, int number, size_t *datalen)
231 {
232   return _gcry_sexp_nth_data (list, number, datalen);
233 }
234
235 void *
236 gcry_sexp_nth_buffer (const gcry_sexp_t list, int number, size_t *rlength)
237 {
238   return _gcry_sexp_nth_buffer (list, number, rlength);
239 }
240
241 char *
242 gcry_sexp_nth_string (gcry_sexp_t list, int number)
243 {
244   return _gcry_sexp_nth_string (list, number);
245 }
246
247 gcry_mpi_t
248 gcry_sexp_nth_mpi (gcry_sexp_t list, int number, int mpifmt)
249 {
250   return _gcry_sexp_nth_mpi (list, number, mpifmt);
251 }
252
253 gpg_error_t
254 gcry_sexp_extract_param (gcry_sexp_t sexp, const char *path,
255                          const char *list, ...)
256 {
257   gcry_err_code_t rc;
258   va_list arg_ptr;
259
260   va_start (arg_ptr, list);
261   rc = _gcry_sexp_vextract_param (sexp, path, list, arg_ptr);
262   va_end (arg_ptr);
263   return gpg_error (rc);
264 }
265
266
267 \f
268 gcry_mpi_t
269 gcry_mpi_new (unsigned int nbits)
270 {
271   return _gcry_mpi_new (nbits);
272 }
273
274 gcry_mpi_t
275 gcry_mpi_snew (unsigned int nbits)
276 {
277   return _gcry_mpi_snew (nbits);
278 }
279
280 void
281 gcry_mpi_release (gcry_mpi_t a)
282 {
283   _gcry_mpi_release (a);
284 }
285
286 gcry_mpi_t
287 gcry_mpi_copy (const gcry_mpi_t a)
288 {
289   return _gcry_mpi_copy (a);
290 }
291
292 void
293 gcry_mpi_snatch (gcry_mpi_t w, const gcry_mpi_t u)
294 {
295   return _gcry_mpi_snatch (w, u);
296 }
297
298 gcry_mpi_t
299 gcry_mpi_set (gcry_mpi_t w, const gcry_mpi_t u)
300 {
301   return _gcry_mpi_set (w, u);
302 }
303
304 gcry_mpi_t
305 gcry_mpi_set_ui (gcry_mpi_t w, unsigned long u)
306 {
307   return _gcry_mpi_set_ui (w, u);
308 }
309
310 void
311 gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b)
312 {
313   _gcry_mpi_swap (a, b);
314 }
315
316 int
317 gcry_mpi_is_neg (gcry_mpi_t a)
318 {
319   return _gcry_mpi_is_neg (a);
320 }
321
322 void
323 gcry_mpi_neg (gcry_mpi_t w, gcry_mpi_t u)
324 {
325   _gcry_mpi_neg (w, u);
326 }
327
328 void
329 gcry_mpi_abs (gcry_mpi_t w)
330 {
331   _gcry_mpi_abs (w);
332 }
333
334 int
335 gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v)
336 {
337   return _gcry_mpi_cmp (u, v);
338 }
339
340 int
341 gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v)
342 {
343   return _gcry_mpi_cmp_ui (u, v);
344 }
345
346 gcry_error_t
347 gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
348                const void *buffer, size_t buflen,
349                size_t *nscanned)
350 {
351   return _gcry_mpi_scan (ret_mpi, format, buffer, buflen, nscanned);
352 }
353
354 gcry_error_t
355 gcry_mpi_print (enum gcry_mpi_format format,
356                 unsigned char *buffer, size_t buflen,
357                 size_t *nwritten,
358                 const gcry_mpi_t a)
359 {
360   return _gcry_mpi_print (format, buffer, buflen, nwritten, a);
361 }
362
363 gcry_error_t
364 gcry_mpi_aprint (enum gcry_mpi_format format,
365                  unsigned char **buffer, size_t *nwritten,
366                  const gcry_mpi_t a)
367 {
368   return _gcry_mpi_aprint (format, buffer, nwritten, a);
369 }
370
371 void
372 gcry_mpi_dump (const gcry_mpi_t a)
373 {
374   _gcry_log_printmpi (NULL, a);
375 }
376
377 void
378 gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
379 {
380   _gcry_mpi_add (w, u, v);
381 }
382
383 void
384 gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v)
385 {
386   _gcry_mpi_add_ui (w, u, v);
387 }
388
389 void
390 gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
391 {
392   _gcry_mpi_addm (w, u, v, m);
393 }
394
395 void
396 gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
397 {
398   _gcry_mpi_sub (w, u, v);
399 }
400
401 void
402 gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
403 {
404   _gcry_mpi_sub_ui (w, u, v);
405 }
406
407 void
408 gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
409 {
410   _gcry_mpi_subm (w, u, v, m);
411 }
412
413 void
414 gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
415 {
416   _gcry_mpi_mul (w, u, v);
417 }
418
419 void
420 gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
421 {
422   _gcry_mpi_mul_ui (w, u, v);
423 }
424
425 void
426 gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
427 {
428   _gcry_mpi_mulm (w, u, v, m);
429 }
430
431 void
432 gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt)
433 {
434   _gcry_mpi_mul_2exp (w, u, cnt);
435 }
436
437 void
438 gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
439               gcry_mpi_t dividend, gcry_mpi_t divisor, int round)
440 {
441   _gcry_mpi_div (q, r, dividend, divisor, round);
442 }
443
444 void
445 gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor)
446 {
447   _gcry_mpi_mod (r, dividend, divisor);
448 }
449
450 void
451 gcry_mpi_powm (gcry_mpi_t w, const gcry_mpi_t b, const gcry_mpi_t e,
452                const gcry_mpi_t m)
453 {
454   _gcry_mpi_powm (w, b, e, m);
455 }
456
457 int
458 gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b)
459 {
460   return _gcry_mpi_gcd (g, a, b);
461 }
462
463 int
464 gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m)
465 {
466   return _gcry_mpi_invm (x, a, m);
467 }
468
469 gcry_mpi_point_t
470 gcry_mpi_point_new (unsigned int nbits)
471 {
472   return _gcry_mpi_point_new (nbits);
473 }
474
475 void
476 gcry_mpi_point_release (gcry_mpi_point_t point)
477 {
478   _gcry_mpi_point_release (point);
479 }
480
481 void
482 gcry_mpi_point_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
483                     gcry_mpi_point_t point)
484 {
485   _gcry_mpi_point_get (x, y, z, point);
486 }
487
488 void
489 gcry_mpi_point_snatch_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
490                            gcry_mpi_point_t point)
491 {
492   _gcry_mpi_point_snatch_get (x, y, z, point);
493 }
494
495 gcry_mpi_point_t
496 gcry_mpi_point_set (gcry_mpi_point_t point,
497                     gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
498 {
499   return _gcry_mpi_point_set (point, x, y, z);
500 }
501
502 gcry_mpi_point_t
503 gcry_mpi_point_snatch_set (gcry_mpi_point_t point,
504                            gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
505 {
506   return _gcry_mpi_point_snatch_set (point, x, y, z);
507 }
508
509 gpg_error_t
510 gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
511                  gcry_sexp_t keyparam, const char *curvename)
512 {
513   return gpg_error (_gcry_mpi_ec_new (r_ctx, keyparam, curvename));
514 }
515
516 gcry_mpi_t
517 gcry_mpi_ec_get_mpi (const char *name, gcry_ctx_t ctx, int copy)
518 {
519   return _gcry_mpi_ec_get_mpi (name, ctx, copy);
520 }
521
522 gcry_mpi_point_t
523 gcry_mpi_ec_get_point (const char *name, gcry_ctx_t ctx, int copy)
524 {
525   return _gcry_mpi_ec_get_point (name, ctx, copy);
526 }
527
528 gpg_error_t
529 gcry_mpi_ec_set_mpi (const char *name, gcry_mpi_t newvalue, gcry_ctx_t ctx)
530 {
531   return gpg_error (_gcry_mpi_ec_set_mpi (name, newvalue, ctx));
532 }
533
534 gpg_error_t
535 gcry_mpi_ec_set_point (const char *name, gcry_mpi_point_t newvalue,
536                         gcry_ctx_t ctx)
537 {
538   return gpg_error (_gcry_mpi_ec_set_point (name, newvalue, ctx));
539 }
540
541 int
542 gcry_mpi_ec_get_affine (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_point_t point,
543                         gcry_ctx_t ctx)
544 {
545   return _gcry_mpi_ec_get_affine (x, y, point,
546                                   _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
547 }
548
549 void
550 gcry_mpi_ec_dup (gcry_mpi_point_t w, gcry_mpi_point_t u, gcry_ctx_t ctx)
551 {
552   _gcry_mpi_ec_dup_point (w, u, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
553 }
554
555 void
556 gcry_mpi_ec_add (gcry_mpi_point_t w,
557                  gcry_mpi_point_t u, gcry_mpi_point_t v, gcry_ctx_t ctx)
558 {
559   _gcry_mpi_ec_add_points (w, u, v,
560                            _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
561 }
562
563 void
564 gcry_mpi_ec_mul (gcry_mpi_point_t w, gcry_mpi_t n, gcry_mpi_point_t u,
565                  gcry_ctx_t ctx)
566 {
567   _gcry_mpi_ec_mul_point (w, n, u,
568                           _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
569 }
570
571 int
572 gcry_mpi_ec_curve_point (gcry_mpi_point_t point, gcry_ctx_t ctx)
573 {
574   return _gcry_mpi_ec_curve_point
575     (point, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
576 }
577
578 unsigned int
579 gcry_mpi_get_nbits (gcry_mpi_t a)
580 {
581   return _gcry_mpi_get_nbits (a);
582 }
583
584 int
585 gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n)
586 {
587   return _gcry_mpi_test_bit (a, n);
588 }
589
590 void
591 gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n)
592 {
593   _gcry_mpi_set_bit (a, n);
594 }
595
596 void
597 gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n)
598 {
599   _gcry_mpi_clear_bit (a, n);
600 }
601
602 void
603 gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n)
604 {
605   _gcry_mpi_set_highbit (a, n);
606 }
607
608 void
609 gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n)
610 {
611   _gcry_mpi_clear_highbit (a, n);
612 }
613
614 void
615 gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
616 {
617   _gcry_mpi_rshift (x, a, n);
618 }
619
620 void
621 gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
622 {
623   _gcry_mpi_lshift (x, a, n);
624 }
625
626 gcry_mpi_t
627 gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
628 {
629   return _gcry_mpi_set_opaque (a, p, nbits);
630 }
631
632 void *
633 gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits)
634 {
635   return _gcry_mpi_get_opaque (a, nbits);
636 }
637
638 void
639 gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
640 {
641   _gcry_mpi_set_flag (a, flag);
642 }
643
644 void
645 gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
646 {
647   _gcry_mpi_clear_flag (a, flag);
648 }
649
650 int
651 gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
652 {
653   return _gcry_mpi_get_flag (a, flag);
654 }
655
656 gcry_mpi_t
657 _gcry_mpi_get_const (int no)
658 {
659   switch (no)
660     {
661     case 1: return _gcry_mpi_const (MPI_C_ONE);
662     case 2: return _gcry_mpi_const (MPI_C_TWO);
663     case 3: return _gcry_mpi_const (MPI_C_THREE);
664     case 4: return _gcry_mpi_const (MPI_C_FOUR);
665     case 8: return _gcry_mpi_const (MPI_C_EIGHT);
666     default: log_bug("unsupported GCRYMPI_CONST_ macro used\n");
667     }
668 }
669
670 gcry_error_t
671 gcry_cipher_open (gcry_cipher_hd_t *handle,
672                   int algo, int mode, unsigned int flags)
673 {
674   if (!fips_is_operational ())
675     {
676       *handle = NULL;
677       return gpg_error (fips_not_operational ());
678     }
679
680   return _gcry_cipher_open (handle, algo, mode, flags);
681 }
682
683 void
684 gcry_cipher_close (gcry_cipher_hd_t h)
685 {
686   _gcry_cipher_close (h);
687 }
688
689 gcry_error_t
690 gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
691 {
692   if (!fips_is_operational ())
693     return gpg_error (fips_not_operational ());
694
695   return _gcry_cipher_setkey (hd, key, keylen);
696 }
697
698 gcry_error_t
699 gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
700 {
701   if (!fips_is_operational ())
702     return gpg_error (fips_not_operational ());
703
704   return _gcry_cipher_setiv (hd, iv, ivlen);
705 }
706
707 gpg_error_t
708 gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
709 {
710   if (!fips_is_operational ())
711     return gpg_error (fips_not_operational ());
712
713   return _gcry_cipher_setctr (hd, ctr, ctrlen);
714 }
715
716 gcry_error_t
717 gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf, size_t abuflen)
718 {
719   if (!fips_is_operational ())
720     return gpg_error (fips_not_operational ());
721
722   return _gcry_cipher_authenticate (hd, abuf, abuflen);
723 }
724
725 gcry_error_t
726 gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
727 {
728   if (!fips_is_operational ())
729     return gpg_error (fips_not_operational ());
730
731   return _gcry_cipher_gettag (hd, outtag, taglen);
732 }
733
734 gcry_error_t
735 gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
736 {
737   if (!fips_is_operational ())
738     return gpg_error (fips_not_operational ());
739
740   return _gcry_cipher_checktag (hd, intag, taglen);
741 }
742
743
744 gcry_error_t
745 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
746 {
747   if (!fips_is_operational ())
748     return gpg_error (fips_not_operational ());
749
750   return _gcry_cipher_ctl (h, cmd, buffer, buflen);
751 }
752
753 gcry_error_t
754 gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
755 {
756   return _gcry_cipher_info (h, what, buffer, nbytes);
757 }
758
759 gcry_error_t
760 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
761 {
762   if (!fips_is_operational ())
763     return gpg_error (fips_not_operational ());
764
765   return _gcry_cipher_algo_info (algo, what, buffer, nbytes);
766 }
767
768 const char *
769 gcry_cipher_algo_name (int algorithm)
770 {
771   return _gcry_cipher_algo_name (algorithm);
772 }
773
774 int
775 gcry_cipher_map_name (const char *name)
776 {
777   return _gcry_cipher_map_name (name);
778 }
779
780 int
781 gcry_cipher_mode_from_oid (const char *string)
782 {
783   return _gcry_cipher_mode_from_oid (string);
784 }
785
786 gcry_error_t
787 gcry_cipher_encrypt (gcry_cipher_hd_t h,
788                      void *out, size_t outsize,
789                      const void *in, size_t inlen)
790 {
791   if (!fips_is_operational ())
792     {
793       /* Make sure that the plaintext will never make it to OUT. */
794       if (out)
795         memset (out, 0x42, outsize);
796       return gpg_error (fips_not_operational ());
797     }
798
799   return _gcry_cipher_encrypt (h, out, outsize, in, inlen);
800 }
801
802 gcry_error_t
803 gcry_cipher_decrypt (gcry_cipher_hd_t h,
804                      void *out, size_t outsize,
805                      const void *in, size_t inlen)
806 {
807   if (!fips_is_operational ())
808     return gpg_error (fips_not_operational ());
809
810   return _gcry_cipher_decrypt (h, out, outsize, in, inlen);
811 }
812
813 size_t
814 gcry_cipher_get_algo_keylen (int algo)
815 {
816   return _gcry_cipher_get_algo_keylen (algo);
817 }
818
819 size_t
820 gcry_cipher_get_algo_blklen (int algo)
821 {
822   return _gcry_cipher_get_algo_blklen (algo);
823 }
824
825 gcry_error_t
826 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
827 {
828   if (!fips_is_operational ())
829     {
830       *result = NULL;
831       return gpg_error (fips_not_operational ());
832     }
833   return _gcry_pk_encrypt (result, data, pkey);
834 }
835
836 gcry_error_t
837 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
838 {
839   if (!fips_is_operational ())
840     {
841       *result = NULL;
842       return gpg_error (fips_not_operational ());
843     }
844   return _gcry_pk_decrypt (result, data, skey);
845 }
846
847 gcry_error_t
848 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
849 {
850   if (!fips_is_operational ())
851     {
852       *result = NULL;
853       return gpg_error (fips_not_operational ());
854     }
855   return _gcry_pk_sign (result, data, skey);
856 }
857
858 gcry_error_t
859 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
860 {
861   if (!fips_is_operational ())
862     return gpg_error (fips_not_operational ());
863   return _gcry_pk_verify (sigval, data, pkey);
864 }
865
866 gcry_error_t
867 gcry_pk_testkey (gcry_sexp_t key)
868 {
869   if (!fips_is_operational ())
870     return gpg_error (fips_not_operational ());
871   return _gcry_pk_testkey (key);
872 }
873
874 gcry_error_t
875 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
876 {
877   if (!fips_is_operational ())
878     {
879       *r_key = NULL;
880       return gpg_error (fips_not_operational ());
881     }
882   return _gcry_pk_genkey (r_key, s_parms);
883 }
884
885 gcry_error_t
886 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
887 {
888   return _gcry_pk_ctl (cmd, buffer, buflen);
889 }
890
891 gcry_error_t
892 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
893 {
894   if (!fips_is_operational ())
895     return gpg_error (fips_not_operational ());
896
897   return _gcry_pk_algo_info (algo, what, buffer, nbytes);
898 }
899
900 const char *
901 gcry_pk_algo_name (int algorithm)
902 {
903   return _gcry_pk_algo_name (algorithm);
904 }
905
906 int
907 gcry_pk_map_name (const char *name)
908 {
909   return _gcry_pk_map_name (name);
910 }
911
912 unsigned int
913 gcry_pk_get_nbits (gcry_sexp_t key)
914 {
915   if (!fips_is_operational ())
916     {
917       (void)fips_not_operational ();
918       return 0;
919     }
920
921   return _gcry_pk_get_nbits (key);
922 }
923
924 unsigned char *
925 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
926 {
927   if (!fips_is_operational ())
928     {
929       (void)fips_not_operational ();
930       return NULL;
931     }
932   return _gcry_pk_get_keygrip (key, array);
933 }
934
935 const char *
936 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
937 {
938   if (!fips_is_operational ())
939     {
940       (void)fips_not_operational ();
941       return NULL;
942     }
943   return _gcry_pk_get_curve (key, iterator, r_nbits);
944 }
945
946 gcry_sexp_t
947 gcry_pk_get_param (int algo, const char *name)
948 {
949   if (!fips_is_operational ())
950     {
951       (void)fips_not_operational ();
952       return NULL;
953     }
954   return _gcry_pk_get_param (algo, name);
955 }
956
957 gcry_error_t
958 gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
959 {
960   if (!fips_is_operational ())
961     {
962       *r_sexp = NULL;
963       return gpg_error (fips_not_operational ());
964     }
965   return gpg_error (_gcry_pubkey_get_sexp (r_sexp, mode, ctx));
966 }
967
968 gcry_error_t
969 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
970 {
971   if (!fips_is_operational ())
972     {
973       *h = NULL;
974       return gpg_error (fips_not_operational ());
975     }
976
977   return _gcry_md_open (h, algo, flags);
978 }
979
980 void
981 gcry_md_close (gcry_md_hd_t hd)
982 {
983   _gcry_md_close (hd);
984 }
985
986 gcry_error_t
987 gcry_md_enable (gcry_md_hd_t hd, int algo)
988 {
989   if (!fips_is_operational ())
990     return gpg_error (fips_not_operational ());
991   return _gcry_md_enable (hd, algo);
992 }
993
994 gcry_error_t
995 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
996 {
997   if (!fips_is_operational ())
998     {
999       *bhd = NULL;
1000       return gpg_error (fips_not_operational ());
1001     }
1002   return _gcry_md_copy (bhd, ahd);
1003 }
1004
1005 void
1006 gcry_md_reset (gcry_md_hd_t hd)
1007 {
1008   _gcry_md_reset (hd);
1009 }
1010
1011 gcry_error_t
1012 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
1013 {
1014   if (!fips_is_operational ())
1015     return gpg_error (fips_not_operational ());
1016   return _gcry_md_ctl (hd, cmd, buffer, buflen);
1017 }
1018
1019 void
1020 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
1021 {
1022   if (!fips_is_operational ())
1023     {
1024       (void)fips_not_operational ();
1025       return;
1026     }
1027   _gcry_md_write (hd, buffer, length);
1028 }
1029
1030 unsigned char *
1031 gcry_md_read (gcry_md_hd_t hd, int algo)
1032 {
1033   return _gcry_md_read (hd, algo);
1034 }
1035
1036 void
1037 gcry_md_hash_buffer (int algo, void *digest,
1038                      const void *buffer, size_t length)
1039 {
1040   if (!fips_is_operational ())
1041     {
1042       (void)fips_not_operational ();
1043       fips_signal_error ("called in non-operational state");
1044     }
1045   _gcry_md_hash_buffer (algo, digest, buffer, length);
1046 }
1047
1048 gpg_error_t
1049 gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
1050                       const gcry_buffer_t *iov, int iovcnt)
1051 {
1052   if (!fips_is_operational ())
1053     {
1054       (void)fips_not_operational ();
1055       fips_signal_error ("called in non-operational state");
1056     }
1057   return _gcry_md_hash_buffers (algo, flags, digest, iov, iovcnt);
1058 }
1059
1060 int
1061 gcry_md_get_algo (gcry_md_hd_t hd)
1062 {
1063   if (!fips_is_operational ())
1064     {
1065       (void)fips_not_operational ();
1066       fips_signal_error ("used in non-operational state");
1067       return 0;
1068     }
1069   return _gcry_md_get_algo (hd);
1070 }
1071
1072 unsigned int
1073 gcry_md_get_algo_dlen (int algo)
1074 {
1075   return _gcry_md_get_algo_dlen (algo);
1076 }
1077
1078 int
1079 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
1080 {
1081   if (!fips_is_operational ())
1082     {
1083       (void)fips_not_operational ();
1084       return 0;
1085     }
1086
1087   return _gcry_md_is_enabled (a, algo);
1088 }
1089
1090 int
1091 gcry_md_is_secure (gcry_md_hd_t a)
1092 {
1093   return _gcry_md_is_secure (a);
1094 }
1095
1096 gcry_error_t
1097 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
1098 {
1099   if (!fips_is_operational ())
1100     return gpg_error (fips_not_operational ());
1101
1102   return _gcry_md_info (h, what, buffer, nbytes);
1103 }
1104
1105 gcry_error_t
1106 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1107 {
1108   return _gcry_md_algo_info (algo, what, buffer, nbytes);
1109 }
1110
1111 const char *
1112 gcry_md_algo_name (int algo)
1113 {
1114   return _gcry_md_algo_name (algo);
1115 }
1116
1117 int
1118 gcry_md_map_name (const char* name)
1119 {
1120   return _gcry_md_map_name (name);
1121 }
1122
1123 gcry_error_t
1124 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
1125 {
1126   if (!fips_is_operational ())
1127     return gpg_error (fips_not_operational ());
1128   return _gcry_md_setkey (hd, key, keylen);
1129 }
1130
1131 void
1132 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
1133 {
1134   _gcry_md_debug (hd, suffix);
1135 }
1136
1137 gpg_error_t
1138 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
1139                  int algo, int hashalgo,
1140                  const void *salt, size_t saltlen,
1141                  unsigned long iterations,
1142                  size_t keysize, void *keybuffer)
1143 {
1144   return _gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
1145                            salt, saltlen, iterations, keysize, keybuffer);
1146 }
1147
1148 void
1149 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
1150 {
1151   if (!fips_is_operational ())
1152     {
1153       (void)fips_not_operational ();
1154       fips_signal_fatal_error ("called in non-operational state");
1155       fips_noreturn ();
1156     }
1157   _gcry_randomize (buffer, length, level);
1158 }
1159
1160 gcry_error_t
1161 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
1162 {
1163   if (!fips_is_operational ())
1164     return gpg_error (fips_not_operational ());
1165   return _gcry_random_add_bytes (buffer, length, quality);
1166 }
1167
1168 void *
1169 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
1170 {
1171   if (!fips_is_operational ())
1172     {
1173       (void)fips_not_operational ();
1174       fips_signal_fatal_error ("called in non-operational state");
1175       fips_noreturn ();
1176     }
1177
1178   return _gcry_random_bytes (nbytes,level);
1179 }
1180
1181 void *
1182 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
1183 {
1184   if (!fips_is_operational ())
1185     {
1186       (void)fips_not_operational ();
1187       fips_signal_fatal_error ("called in non-operational state");
1188       fips_noreturn ();
1189     }
1190
1191   return _gcry_random_bytes_secure (nbytes, level);
1192 }
1193
1194 void
1195 gcry_mpi_randomize (gcry_mpi_t w,
1196                     unsigned int nbits, enum gcry_random_level level)
1197 {
1198   _gcry_mpi_randomize (w, nbits, level);
1199 }
1200
1201 void
1202 gcry_create_nonce (void *buffer, size_t length)
1203 {
1204   if (!fips_is_operational ())
1205     {
1206       (void)fips_not_operational ();
1207       fips_signal_fatal_error ("called in non-operational state");
1208       fips_noreturn ();
1209     }
1210   _gcry_create_nonce (buffer, length);
1211 }
1212
1213 gcry_error_t
1214 gcry_prime_generate (gcry_mpi_t *prime,
1215                      unsigned int prime_bits,
1216                      unsigned int factor_bits,
1217                      gcry_mpi_t **factors,
1218                      gcry_prime_check_func_t cb_func,
1219                      void *cb_arg,
1220                      gcry_random_level_t random_level,
1221                      unsigned int flags)
1222 {
1223   return _gcry_prime_generate (prime, prime_bits, factor_bits, factors,
1224                                cb_func, cb_arg, random_level, flags);
1225 }
1226
1227 gcry_error_t
1228 gcry_prime_group_generator (gcry_mpi_t *r_g,
1229                             gcry_mpi_t prime, gcry_mpi_t *factors,
1230                             gcry_mpi_t start_g)
1231 {
1232   return _gcry_prime_group_generator (r_g, prime, factors, start_g);
1233 }
1234
1235 void
1236 gcry_prime_release_factors (gcry_mpi_t *factors)
1237 {
1238   _gcry_prime_release_factors (factors);
1239 }
1240
1241 gcry_error_t
1242 gcry_prime_check (gcry_mpi_t x, unsigned int flags)
1243 {
1244   return _gcry_prime_check (x, flags);
1245 }
1246
1247 void
1248 gcry_ctx_release (gcry_ctx_t ctx)
1249 {
1250   _gcry_ctx_release (ctx);
1251 }
1252
1253 void
1254 gcry_log_debug (const char *fmt, ...)
1255 {
1256   va_list arg_ptr ;
1257
1258   va_start( arg_ptr, fmt ) ;
1259   _gcry_logv (GCRY_LOG_DEBUG, fmt, arg_ptr);
1260   va_end (arg_ptr);
1261 }
1262
1263 void
1264 gcry_log_debughex (const char *text, const void *buffer, size_t length)
1265 {
1266   _gcry_log_printhex (text, buffer, length);
1267 }
1268
1269 void
1270 gcry_log_debugmpi (const char *text, gcry_mpi_t mpi)
1271 {
1272   _gcry_log_printmpi (text, mpi);
1273 }
1274
1275 void
1276 gcry_log_debugpnt (const char *text, mpi_point_t point, gcry_ctx_t ctx)
1277 {
1278   mpi_ec_t ec = ctx? _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC) : NULL;
1279
1280   _gcry_mpi_point_log (text, point, ec);
1281 }
1282
1283 void
1284 gcry_log_debugsxp (const char *text, gcry_sexp_t sexp)
1285 {
1286   _gcry_log_printsxp (text, sexp);
1287 }
1288
1289 void
1290 gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
1291 {
1292   _gcry_set_progress_handler (cb, cb_data);
1293 }
1294
1295 void
1296 gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
1297                              gcry_handler_alloc_t func_alloc_secure,
1298                              gcry_handler_secure_check_t func_secure_check,
1299                              gcry_handler_realloc_t func_realloc,
1300                              gcry_handler_free_t func_free)
1301 {
1302   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
1303                                 func_secure_check, func_realloc, func_free);
1304 }
1305
1306 void
1307 gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
1308 {
1309   _gcry_set_outofcore_handler (h, opaque);
1310 }
1311
1312 void
1313 gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
1314 {
1315   _gcry_set_fatalerror_handler (fnc, opaque);
1316 }
1317
1318 void
1319 gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
1320 {
1321   _gcry_set_log_handler (f, opaque);
1322 }
1323
1324 void
1325 gcry_set_gettext_handler (const char *(*f)(const char*))
1326 {
1327   _gcry_set_gettext_handler (f);
1328 }
1329
1330 void *
1331 gcry_malloc (size_t n)
1332 {
1333   return _gcry_malloc (n);
1334 }
1335
1336 void *
1337 gcry_calloc (size_t n, size_t m)
1338 {
1339   return _gcry_calloc (n, m);
1340 }
1341
1342 void *
1343 gcry_malloc_secure (size_t n)
1344 {
1345   return _gcry_malloc_secure (n);
1346 }
1347
1348 void *
1349 gcry_calloc_secure (size_t n, size_t m)
1350 {
1351   return _gcry_calloc_secure (n,m);
1352 }
1353
1354 void *
1355 gcry_realloc (void *a, size_t n)
1356 {
1357   return _gcry_realloc (a, n);
1358 }
1359
1360 char *
1361 gcry_strdup (const char *string)
1362 {
1363   return _gcry_strdup (string);
1364 }
1365
1366 void *
1367 gcry_xmalloc (size_t n)
1368 {
1369   return _gcry_xmalloc (n);
1370 }
1371
1372 void *
1373 gcry_xcalloc (size_t n, size_t m)
1374 {
1375   return _gcry_xcalloc (n, m);
1376 }
1377
1378 void *
1379 gcry_xmalloc_secure (size_t n)
1380 {
1381   return _gcry_xmalloc_secure (n);
1382 }
1383
1384 void *
1385 gcry_xcalloc_secure (size_t n, size_t m)
1386 {
1387   return _gcry_xcalloc_secure (n, m);
1388 }
1389
1390 void *
1391 gcry_xrealloc (void *a, size_t n)
1392 {
1393   return _gcry_xrealloc (a, n);
1394 }
1395
1396 char *
1397 gcry_xstrdup (const char *a)
1398 {
1399   return _gcry_xstrdup (a);
1400 }
1401
1402 void
1403 gcry_free (void *a)
1404 {
1405   _gcry_free (a);
1406 }
1407
1408 int
1409 gcry_is_secure (const void *a)
1410 {
1411   return _gcry_is_secure (a);
1412 }