Add a function to retrieve algorithm used by MAC handler
[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 = gpg_error (_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 gcry_error_t
311 gcry_mpi_get_ui (gcry_mpi_t w, unsigned long *u)
312 {
313   return gpg_error (_gcry_mpi_get_ui (w, u));
314 }
315
316 void
317 gcry_mpi_swap (gcry_mpi_t a, gcry_mpi_t b)
318 {
319   _gcry_mpi_swap (a, b);
320 }
321
322 int
323 gcry_mpi_is_neg (gcry_mpi_t a)
324 {
325   return _gcry_mpi_is_neg (a);
326 }
327
328 void
329 gcry_mpi_neg (gcry_mpi_t w, gcry_mpi_t u)
330 {
331   _gcry_mpi_neg (w, u);
332 }
333
334 void
335 gcry_mpi_abs (gcry_mpi_t w)
336 {
337   _gcry_mpi_abs (w);
338 }
339
340 int
341 gcry_mpi_cmp (const gcry_mpi_t u, const gcry_mpi_t v)
342 {
343   return _gcry_mpi_cmp (u, v);
344 }
345
346 int
347 gcry_mpi_cmp_ui (const gcry_mpi_t u, unsigned long v)
348 {
349   return _gcry_mpi_cmp_ui (u, v);
350 }
351
352 gcry_error_t
353 gcry_mpi_scan (gcry_mpi_t *ret_mpi, enum gcry_mpi_format format,
354                const void *buffer, size_t buflen,
355                size_t *nscanned)
356 {
357   return gpg_error (_gcry_mpi_scan (ret_mpi, format, buffer, buflen, nscanned));
358 }
359
360 gcry_error_t
361 gcry_mpi_print (enum gcry_mpi_format format,
362                 unsigned char *buffer, size_t buflen,
363                 size_t *nwritten,
364                 const gcry_mpi_t a)
365 {
366   return gpg_error (_gcry_mpi_print (format, buffer, buflen, nwritten, a));
367 }
368
369 gcry_error_t
370 gcry_mpi_aprint (enum gcry_mpi_format format,
371                  unsigned char **buffer, size_t *nwritten,
372                  const gcry_mpi_t a)
373 {
374   return gpg_error (_gcry_mpi_aprint (format, buffer, nwritten, a));
375 }
376
377 void
378 gcry_mpi_dump (const gcry_mpi_t a)
379 {
380   _gcry_log_printmpi (NULL, a);
381 }
382
383 void
384 gcry_mpi_add (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
385 {
386   _gcry_mpi_add (w, u, v);
387 }
388
389 void
390 gcry_mpi_add_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v)
391 {
392   _gcry_mpi_add_ui (w, u, v);
393 }
394
395 void
396 gcry_mpi_addm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
397 {
398   _gcry_mpi_addm (w, u, v, m);
399 }
400
401 void
402 gcry_mpi_sub (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
403 {
404   _gcry_mpi_sub (w, u, v);
405 }
406
407 void
408 gcry_mpi_sub_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
409 {
410   _gcry_mpi_sub_ui (w, u, v);
411 }
412
413 void
414 gcry_mpi_subm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
415 {
416   _gcry_mpi_subm (w, u, v, m);
417 }
418
419 void
420 gcry_mpi_mul (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v)
421 {
422   _gcry_mpi_mul (w, u, v);
423 }
424
425 void
426 gcry_mpi_mul_ui (gcry_mpi_t w, gcry_mpi_t u, unsigned long v )
427 {
428   _gcry_mpi_mul_ui (w, u, v);
429 }
430
431 void
432 gcry_mpi_mulm (gcry_mpi_t w, gcry_mpi_t u, gcry_mpi_t v, gcry_mpi_t m)
433 {
434   _gcry_mpi_mulm (w, u, v, m);
435 }
436
437 void
438 gcry_mpi_mul_2exp (gcry_mpi_t w, gcry_mpi_t u, unsigned long cnt)
439 {
440   _gcry_mpi_mul_2exp (w, u, cnt);
441 }
442
443 void
444 gcry_mpi_div (gcry_mpi_t q, gcry_mpi_t r,
445               gcry_mpi_t dividend, gcry_mpi_t divisor, int round)
446 {
447   _gcry_mpi_div (q, r, dividend, divisor, round);
448 }
449
450 void
451 gcry_mpi_mod (gcry_mpi_t r, gcry_mpi_t dividend, gcry_mpi_t divisor)
452 {
453   _gcry_mpi_mod (r, dividend, divisor);
454 }
455
456 void
457 gcry_mpi_powm (gcry_mpi_t w, const gcry_mpi_t b, const gcry_mpi_t e,
458                const gcry_mpi_t m)
459 {
460   _gcry_mpi_powm (w, b, e, m);
461 }
462
463 int
464 gcry_mpi_gcd (gcry_mpi_t g, gcry_mpi_t a, gcry_mpi_t b)
465 {
466   return _gcry_mpi_gcd (g, a, b);
467 }
468
469 int
470 gcry_mpi_invm (gcry_mpi_t x, gcry_mpi_t a, gcry_mpi_t m)
471 {
472   return _gcry_mpi_invm (x, a, m);
473 }
474
475 gcry_mpi_point_t
476 gcry_mpi_point_new (unsigned int nbits)
477 {
478   return _gcry_mpi_point_new (nbits);
479 }
480
481 void
482 gcry_mpi_point_release (gcry_mpi_point_t point)
483 {
484   _gcry_mpi_point_release (point);
485 }
486
487 void
488 gcry_mpi_point_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
489                     gcry_mpi_point_t point)
490 {
491   _gcry_mpi_point_get (x, y, z, point);
492 }
493
494 void
495 gcry_mpi_point_snatch_get (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z,
496                            gcry_mpi_point_t point)
497 {
498   _gcry_mpi_point_snatch_get (x, y, z, point);
499 }
500
501 gcry_mpi_point_t
502 gcry_mpi_point_set (gcry_mpi_point_t point,
503                     gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
504 {
505   return _gcry_mpi_point_set (point, x, y, z);
506 }
507
508 gcry_mpi_point_t
509 gcry_mpi_point_snatch_set (gcry_mpi_point_t point,
510                            gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_t z)
511 {
512   return _gcry_mpi_point_snatch_set (point, x, y, z);
513 }
514
515 gpg_error_t
516 gcry_mpi_ec_new (gcry_ctx_t *r_ctx,
517                  gcry_sexp_t keyparam, const char *curvename)
518 {
519   return gpg_error (_gcry_mpi_ec_new (r_ctx, keyparam, curvename));
520 }
521
522 gcry_mpi_t
523 gcry_mpi_ec_get_mpi (const char *name, gcry_ctx_t ctx, int copy)
524 {
525   return _gcry_mpi_ec_get_mpi (name, ctx, copy);
526 }
527
528 gcry_mpi_point_t
529 gcry_mpi_ec_get_point (const char *name, gcry_ctx_t ctx, int copy)
530 {
531   return _gcry_mpi_ec_get_point (name, ctx, copy);
532 }
533
534 gpg_error_t
535 gcry_mpi_ec_set_mpi (const char *name, gcry_mpi_t newvalue, gcry_ctx_t ctx)
536 {
537   return gpg_error (_gcry_mpi_ec_set_mpi (name, newvalue, ctx));
538 }
539
540 gpg_error_t
541 gcry_mpi_ec_set_point (const char *name, gcry_mpi_point_t newvalue,
542                         gcry_ctx_t ctx)
543 {
544   return gpg_error (_gcry_mpi_ec_set_point (name, newvalue, ctx));
545 }
546
547 int
548 gcry_mpi_ec_get_affine (gcry_mpi_t x, gcry_mpi_t y, gcry_mpi_point_t point,
549                         gcry_ctx_t ctx)
550 {
551   return _gcry_mpi_ec_get_affine (x, y, point,
552                                   _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
553 }
554
555 void
556 gcry_mpi_ec_dup (gcry_mpi_point_t w, gcry_mpi_point_t u, gcry_ctx_t ctx)
557 {
558   _gcry_mpi_ec_dup_point (w, u, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
559 }
560
561 void
562 gcry_mpi_ec_add (gcry_mpi_point_t w,
563                  gcry_mpi_point_t u, gcry_mpi_point_t v, gcry_ctx_t ctx)
564 {
565   _gcry_mpi_ec_add_points (w, u, v,
566                            _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
567 }
568
569 void
570 gcry_mpi_ec_mul (gcry_mpi_point_t w, gcry_mpi_t n, gcry_mpi_point_t u,
571                  gcry_ctx_t ctx)
572 {
573   _gcry_mpi_ec_mul_point (w, n, u,
574                           _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
575 }
576
577 int
578 gcry_mpi_ec_curve_point (gcry_mpi_point_t point, gcry_ctx_t ctx)
579 {
580   return _gcry_mpi_ec_curve_point
581     (point, _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC));
582 }
583
584 unsigned int
585 gcry_mpi_get_nbits (gcry_mpi_t a)
586 {
587   return _gcry_mpi_get_nbits (a);
588 }
589
590 int
591 gcry_mpi_test_bit (gcry_mpi_t a, unsigned int n)
592 {
593   return _gcry_mpi_test_bit (a, n);
594 }
595
596 void
597 gcry_mpi_set_bit (gcry_mpi_t a, unsigned int n)
598 {
599   _gcry_mpi_set_bit (a, n);
600 }
601
602 void
603 gcry_mpi_clear_bit (gcry_mpi_t a, unsigned int n)
604 {
605   _gcry_mpi_clear_bit (a, n);
606 }
607
608 void
609 gcry_mpi_set_highbit (gcry_mpi_t a, unsigned int n)
610 {
611   _gcry_mpi_set_highbit (a, n);
612 }
613
614 void
615 gcry_mpi_clear_highbit (gcry_mpi_t a, unsigned int n)
616 {
617   _gcry_mpi_clear_highbit (a, n);
618 }
619
620 void
621 gcry_mpi_rshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
622 {
623   _gcry_mpi_rshift (x, a, n);
624 }
625
626 void
627 gcry_mpi_lshift (gcry_mpi_t x, gcry_mpi_t a, unsigned int n)
628 {
629   _gcry_mpi_lshift (x, a, n);
630 }
631
632 gcry_mpi_t
633 gcry_mpi_set_opaque (gcry_mpi_t a, void *p, unsigned int nbits)
634 {
635   return _gcry_mpi_set_opaque (a, p, nbits);
636 }
637
638 gcry_mpi_t
639 gcry_mpi_set_opaque_copy (gcry_mpi_t a, const void *p, unsigned int nbits)
640 {
641   return _gcry_mpi_set_opaque_copy (a, p, nbits);
642 }
643
644 void *
645 gcry_mpi_get_opaque (gcry_mpi_t a, unsigned int *nbits)
646 {
647   return _gcry_mpi_get_opaque (a, nbits);
648 }
649
650 void
651 gcry_mpi_set_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
652 {
653   _gcry_mpi_set_flag (a, flag);
654 }
655
656 void
657 gcry_mpi_clear_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
658 {
659   _gcry_mpi_clear_flag (a, flag);
660 }
661
662 int
663 gcry_mpi_get_flag (gcry_mpi_t a, enum gcry_mpi_flag flag)
664 {
665   return _gcry_mpi_get_flag (a, flag);
666 }
667
668 gcry_mpi_t
669 _gcry_mpi_get_const (int no)
670 {
671   switch (no)
672     {
673     case 1: return _gcry_mpi_const (MPI_C_ONE);
674     case 2: return _gcry_mpi_const (MPI_C_TWO);
675     case 3: return _gcry_mpi_const (MPI_C_THREE);
676     case 4: return _gcry_mpi_const (MPI_C_FOUR);
677     case 8: return _gcry_mpi_const (MPI_C_EIGHT);
678     default: log_bug("unsupported GCRYMPI_CONST_ macro used\n");
679     }
680 }
681
682 gcry_error_t
683 gcry_cipher_open (gcry_cipher_hd_t *handle,
684                   int algo, int mode, unsigned int flags)
685 {
686   if (!fips_is_operational ())
687     {
688       *handle = NULL;
689       return gpg_error (fips_not_operational ());
690     }
691
692   return gpg_error (_gcry_cipher_open (handle, algo, mode, flags));
693 }
694
695 void
696 gcry_cipher_close (gcry_cipher_hd_t h)
697 {
698   _gcry_cipher_close (h);
699 }
700
701 gcry_error_t
702 gcry_cipher_setkey (gcry_cipher_hd_t hd, const void *key, size_t keylen)
703 {
704   if (!fips_is_operational ())
705     return gpg_error (fips_not_operational ());
706
707   return gcry_error (_gcry_cipher_setkey (hd, key, keylen));
708 }
709
710 gcry_error_t
711 gcry_cipher_setiv (gcry_cipher_hd_t hd, const void *iv, size_t ivlen)
712 {
713   if (!fips_is_operational ())
714     return gpg_error (fips_not_operational ());
715
716   return gcry_error (_gcry_cipher_setiv (hd, iv, ivlen));
717 }
718
719 gpg_error_t
720 gcry_cipher_setctr (gcry_cipher_hd_t hd, const void *ctr, size_t ctrlen)
721 {
722   if (!fips_is_operational ())
723     return gpg_error (fips_not_operational ());
724
725   return gcry_error (_gcry_cipher_setctr (hd, ctr, ctrlen));
726 }
727
728 gcry_error_t
729 gcry_cipher_authenticate (gcry_cipher_hd_t hd, const void *abuf, size_t abuflen)
730 {
731   if (!fips_is_operational ())
732     return gpg_error (fips_not_operational ());
733
734   return gpg_error (_gcry_cipher_authenticate (hd, abuf, abuflen));
735 }
736
737 gcry_error_t
738 gcry_cipher_gettag (gcry_cipher_hd_t hd, void *outtag, size_t taglen)
739 {
740   if (!fips_is_operational ())
741     return gpg_error (fips_not_operational ());
742
743   return gpg_error (_gcry_cipher_gettag (hd, outtag, taglen));
744 }
745
746 gcry_error_t
747 gcry_cipher_checktag (gcry_cipher_hd_t hd, const void *intag, size_t taglen)
748 {
749   if (!fips_is_operational ())
750     return gpg_error (fips_not_operational ());
751
752   return gpg_error (_gcry_cipher_checktag (hd, intag, taglen));
753 }
754
755
756 gcry_error_t
757 gcry_cipher_ctl (gcry_cipher_hd_t h, int cmd, void *buffer, size_t buflen)
758 {
759   if (!fips_is_operational ())
760     return gpg_error (fips_not_operational ());
761
762   return gpg_error (_gcry_cipher_ctl (h, cmd, buffer, buflen));
763 }
764
765 gcry_error_t
766 gcry_cipher_info (gcry_cipher_hd_t h, int what, void *buffer, size_t *nbytes)
767 {
768   return gpg_error (_gcry_cipher_info (h, what, buffer, nbytes));
769 }
770
771 gcry_error_t
772 gcry_cipher_algo_info (int algo, int what, void *buffer, size_t *nbytes)
773 {
774   if (!fips_is_operational ())
775     return gpg_error (fips_not_operational ());
776
777   return gpg_error (_gcry_cipher_algo_info (algo, what, buffer, nbytes));
778 }
779
780 const char *
781 gcry_cipher_algo_name (int algorithm)
782 {
783   return _gcry_cipher_algo_name (algorithm);
784 }
785
786 int
787 gcry_cipher_map_name (const char *name)
788 {
789   return _gcry_cipher_map_name (name);
790 }
791
792 int
793 gcry_cipher_mode_from_oid (const char *string)
794 {
795   return _gcry_cipher_mode_from_oid (string);
796 }
797
798 gcry_error_t
799 gcry_cipher_encrypt (gcry_cipher_hd_t h,
800                      void *out, size_t outsize,
801                      const void *in, size_t inlen)
802 {
803   if (!fips_is_operational ())
804     {
805       /* Make sure that the plaintext will never make it to OUT. */
806       if (out)
807         memset (out, 0x42, outsize);
808       return gpg_error (fips_not_operational ());
809     }
810
811   return gpg_error (_gcry_cipher_encrypt (h, out, outsize, in, inlen));
812 }
813
814 gcry_error_t
815 gcry_cipher_decrypt (gcry_cipher_hd_t h,
816                      void *out, size_t outsize,
817                      const void *in, size_t inlen)
818 {
819   if (!fips_is_operational ())
820     return gpg_error (fips_not_operational ());
821
822   return gpg_error (_gcry_cipher_decrypt (h, out, outsize, in, inlen));
823 }
824
825 size_t
826 gcry_cipher_get_algo_keylen (int algo)
827 {
828   return _gcry_cipher_get_algo_keylen (algo);
829 }
830
831 size_t
832 gcry_cipher_get_algo_blklen (int algo)
833 {
834   return _gcry_cipher_get_algo_blklen (algo);
835 }
836
837 gcry_error_t
838 gcry_mac_algo_info (int algo, int what, void *buffer, size_t *nbytes)
839 {
840   if (!fips_is_operational ())
841     return gpg_error (fips_not_operational ());
842
843   return gpg_error (_gcry_mac_algo_info (algo, what, buffer, nbytes));
844 }
845
846 const char *
847 gcry_mac_algo_name (int algorithm)
848 {
849   return _gcry_mac_algo_name (algorithm);
850 }
851
852 int
853 gcry_mac_map_name (const char *string)
854 {
855   return _gcry_mac_map_name (string);
856 }
857
858 int
859 gcry_mac_get_algo (gcry_mac_hd_t hd)
860 {
861   return _gcry_mac_get_algo (hd);
862 }
863
864 unsigned int
865 gcry_mac_get_algo_maclen (int algo)
866 {
867   return _gcry_mac_get_algo_maclen (algo);
868 }
869
870 unsigned int
871 gcry_mac_get_algo_keylen (int algo)
872 {
873   return _gcry_mac_get_algo_keylen (algo);
874 }
875
876 gcry_error_t
877 gcry_mac_open (gcry_mac_hd_t *handle, int algo, unsigned int flags,
878                gcry_ctx_t ctx)
879 {
880   if (!fips_is_operational ())
881     {
882       *handle = NULL;
883       return gpg_error (fips_not_operational ());
884     }
885
886   return gpg_error (_gcry_mac_open (handle, algo, flags, ctx));
887 }
888
889 void
890 gcry_mac_close (gcry_mac_hd_t hd)
891 {
892   _gcry_mac_close (hd);
893 }
894
895 gcry_error_t
896 gcry_mac_setkey (gcry_mac_hd_t hd, const void *key, size_t keylen)
897 {
898   if (!fips_is_operational ())
899     return gpg_error (fips_not_operational ());
900
901   return gpg_error (_gcry_mac_setkey (hd, key, keylen));
902 }
903
904 gcry_error_t
905 gcry_mac_setiv (gcry_mac_hd_t hd, const void *iv, size_t ivlen)
906 {
907   if (!fips_is_operational ())
908     return gpg_error (fips_not_operational ());
909
910   return gpg_error (_gcry_mac_setiv (hd, iv, ivlen));
911 }
912
913 gcry_error_t
914 gcry_mac_write (gcry_mac_hd_t hd, const void *buf, size_t buflen)
915 {
916   if (!fips_is_operational ())
917     return gpg_error (fips_not_operational ());
918
919   return gpg_error (_gcry_mac_write (hd, buf, buflen));
920 }
921
922 gcry_error_t
923 gcry_mac_read (gcry_mac_hd_t hd, void *outbuf, size_t *outlen)
924 {
925   if (!fips_is_operational ())
926     return gpg_error (fips_not_operational ());
927
928   return gpg_error (_gcry_mac_read (hd, outbuf, outlen));
929 }
930
931 gcry_error_t
932 gcry_mac_verify (gcry_mac_hd_t hd, const void *buf, size_t buflen)
933 {
934   if (!fips_is_operational ())
935     return gpg_error (fips_not_operational ());
936
937   return gpg_error (_gcry_mac_verify (hd, buf, buflen));
938 }
939
940 gcry_error_t
941 gcry_mac_ctl (gcry_mac_hd_t h, int cmd, void *buffer, size_t buflen)
942 {
943   if (!fips_is_operational ())
944     return gpg_error (fips_not_operational ());
945
946   return gpg_error (_gcry_mac_ctl (h, cmd, buffer, buflen));
947 }
948
949 gcry_error_t
950 gcry_pk_encrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t pkey)
951 {
952   if (!fips_is_operational ())
953     {
954       *result = NULL;
955       return gpg_error (fips_not_operational ());
956     }
957   return gpg_error (_gcry_pk_encrypt (result, data, pkey));
958 }
959
960 gcry_error_t
961 gcry_pk_decrypt (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
962 {
963   if (!fips_is_operational ())
964     {
965       *result = NULL;
966       return gpg_error (fips_not_operational ());
967     }
968   return gpg_error (_gcry_pk_decrypt (result, data, skey));
969 }
970
971 gcry_error_t
972 gcry_pk_sign (gcry_sexp_t *result, gcry_sexp_t data, gcry_sexp_t skey)
973 {
974   if (!fips_is_operational ())
975     {
976       *result = NULL;
977       return gpg_error (fips_not_operational ());
978     }
979   return gpg_error (_gcry_pk_sign (result, data, skey));
980 }
981
982 gcry_error_t
983 gcry_pk_verify (gcry_sexp_t sigval, gcry_sexp_t data, gcry_sexp_t pkey)
984 {
985   if (!fips_is_operational ())
986     return gpg_error (fips_not_operational ());
987   return gpg_error (_gcry_pk_verify (sigval, data, pkey));
988 }
989
990 gcry_error_t
991 gcry_pk_testkey (gcry_sexp_t key)
992 {
993   if (!fips_is_operational ())
994     return gpg_error (fips_not_operational ());
995   return gpg_error (_gcry_pk_testkey (key));
996 }
997
998 gcry_error_t
999 gcry_pk_genkey (gcry_sexp_t *r_key, gcry_sexp_t s_parms)
1000 {
1001   if (!fips_is_operational ())
1002     {
1003       *r_key = NULL;
1004       return gpg_error (fips_not_operational ());
1005     }
1006   return gpg_error (_gcry_pk_genkey (r_key, s_parms));
1007 }
1008
1009 gcry_error_t
1010 gcry_pk_ctl (int cmd, void *buffer, size_t buflen)
1011 {
1012   return gpg_error (_gcry_pk_ctl (cmd, buffer, buflen));
1013 }
1014
1015 gcry_error_t
1016 gcry_pk_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1017 {
1018   if (!fips_is_operational ())
1019     return gpg_error (fips_not_operational ());
1020
1021   return gpg_error (_gcry_pk_algo_info (algo, what, buffer, nbytes));
1022 }
1023
1024 const char *
1025 gcry_pk_algo_name (int algorithm)
1026 {
1027   return _gcry_pk_algo_name (algorithm);
1028 }
1029
1030 int
1031 gcry_pk_map_name (const char *name)
1032 {
1033   return _gcry_pk_map_name (name);
1034 }
1035
1036 unsigned int
1037 gcry_pk_get_nbits (gcry_sexp_t key)
1038 {
1039   if (!fips_is_operational ())
1040     {
1041       (void)fips_not_operational ();
1042       return 0;
1043     }
1044
1045   return _gcry_pk_get_nbits (key);
1046 }
1047
1048 unsigned char *
1049 gcry_pk_get_keygrip (gcry_sexp_t key, unsigned char *array)
1050 {
1051   if (!fips_is_operational ())
1052     {
1053       (void)fips_not_operational ();
1054       return NULL;
1055     }
1056   return _gcry_pk_get_keygrip (key, array);
1057 }
1058
1059 const char *
1060 gcry_pk_get_curve (gcry_sexp_t key, int iterator, unsigned int *r_nbits)
1061 {
1062   if (!fips_is_operational ())
1063     {
1064       (void)fips_not_operational ();
1065       return NULL;
1066     }
1067   return _gcry_pk_get_curve (key, iterator, r_nbits);
1068 }
1069
1070 gcry_sexp_t
1071 gcry_pk_get_param (int algo, const char *name)
1072 {
1073   if (!fips_is_operational ())
1074     {
1075       (void)fips_not_operational ();
1076       return NULL;
1077     }
1078   return _gcry_pk_get_param (algo, name);
1079 }
1080
1081 gcry_error_t
1082 gcry_pubkey_get_sexp (gcry_sexp_t *r_sexp, int mode, gcry_ctx_t ctx)
1083 {
1084   if (!fips_is_operational ())
1085     {
1086       *r_sexp = NULL;
1087       return gpg_error (fips_not_operational ());
1088     }
1089   return gpg_error (_gcry_pubkey_get_sexp (r_sexp, mode, ctx));
1090 }
1091
1092 gcry_error_t
1093 gcry_md_open (gcry_md_hd_t *h, int algo, unsigned int flags)
1094 {
1095   if (!fips_is_operational ())
1096     {
1097       *h = NULL;
1098       return gpg_error (fips_not_operational ());
1099     }
1100
1101   return gpg_error (_gcry_md_open (h, algo, flags));
1102 }
1103
1104 void
1105 gcry_md_close (gcry_md_hd_t hd)
1106 {
1107   _gcry_md_close (hd);
1108 }
1109
1110 gcry_error_t
1111 gcry_md_enable (gcry_md_hd_t hd, int algo)
1112 {
1113   if (!fips_is_operational ())
1114     return gpg_error (fips_not_operational ());
1115   return gpg_error (_gcry_md_enable (hd, algo));
1116 }
1117
1118 gcry_error_t
1119 gcry_md_copy (gcry_md_hd_t *bhd, gcry_md_hd_t ahd)
1120 {
1121   if (!fips_is_operational ())
1122     {
1123       *bhd = NULL;
1124       return gpg_error (fips_not_operational ());
1125     }
1126   return gpg_error (_gcry_md_copy (bhd, ahd));
1127 }
1128
1129 void
1130 gcry_md_reset (gcry_md_hd_t hd)
1131 {
1132   _gcry_md_reset (hd);
1133 }
1134
1135 gcry_error_t
1136 gcry_md_ctl (gcry_md_hd_t hd, int cmd, void *buffer, size_t buflen)
1137 {
1138   if (!fips_is_operational ())
1139     return gpg_error (fips_not_operational ());
1140   return gpg_error (_gcry_md_ctl (hd, cmd, buffer, buflen));
1141 }
1142
1143 void
1144 gcry_md_write (gcry_md_hd_t hd, const void *buffer, size_t length)
1145 {
1146   if (!fips_is_operational ())
1147     {
1148       (void)fips_not_operational ();
1149       return;
1150     }
1151   _gcry_md_write (hd, buffer, length);
1152 }
1153
1154 unsigned char *
1155 gcry_md_read (gcry_md_hd_t hd, int algo)
1156 {
1157   return _gcry_md_read (hd, algo);
1158 }
1159
1160 void
1161 gcry_md_hash_buffer (int algo, void *digest,
1162                      const void *buffer, size_t length)
1163 {
1164   if (!fips_is_operational ())
1165     {
1166       (void)fips_not_operational ();
1167       fips_signal_error ("called in non-operational state");
1168     }
1169   _gcry_md_hash_buffer (algo, digest, buffer, length);
1170 }
1171
1172 gpg_error_t
1173 gcry_md_hash_buffers (int algo, unsigned int flags, void *digest,
1174                       const gcry_buffer_t *iov, int iovcnt)
1175 {
1176   if (!fips_is_operational ())
1177     {
1178       (void)fips_not_operational ();
1179       fips_signal_error ("called in non-operational state");
1180     }
1181   return gpg_error (_gcry_md_hash_buffers (algo, flags, digest, iov, iovcnt));
1182 }
1183
1184 int
1185 gcry_md_get_algo (gcry_md_hd_t hd)
1186 {
1187   if (!fips_is_operational ())
1188     {
1189       (void)fips_not_operational ();
1190       fips_signal_error ("used in non-operational state");
1191       return 0;
1192     }
1193   return _gcry_md_get_algo (hd);
1194 }
1195
1196 unsigned int
1197 gcry_md_get_algo_dlen (int algo)
1198 {
1199   return _gcry_md_get_algo_dlen (algo);
1200 }
1201
1202 int
1203 gcry_md_is_enabled (gcry_md_hd_t a, int algo)
1204 {
1205   if (!fips_is_operational ())
1206     {
1207       (void)fips_not_operational ();
1208       return 0;
1209     }
1210
1211   return _gcry_md_is_enabled (a, algo);
1212 }
1213
1214 int
1215 gcry_md_is_secure (gcry_md_hd_t a)
1216 {
1217   return _gcry_md_is_secure (a);
1218 }
1219
1220 gcry_error_t
1221 gcry_md_info (gcry_md_hd_t h, int what, void *buffer, size_t *nbytes)
1222 {
1223   if (!fips_is_operational ())
1224     return gpg_error (fips_not_operational ());
1225
1226   return gpg_error (_gcry_md_info (h, what, buffer, nbytes));
1227 }
1228
1229 gcry_error_t
1230 gcry_md_algo_info (int algo, int what, void *buffer, size_t *nbytes)
1231 {
1232   return gpg_error (_gcry_md_algo_info (algo, what, buffer, nbytes));
1233 }
1234
1235 const char *
1236 gcry_md_algo_name (int algo)
1237 {
1238   return _gcry_md_algo_name (algo);
1239 }
1240
1241 int
1242 gcry_md_map_name (const char* name)
1243 {
1244   return _gcry_md_map_name (name);
1245 }
1246
1247 gcry_error_t
1248 gcry_md_setkey (gcry_md_hd_t hd, const void *key, size_t keylen)
1249 {
1250   if (!fips_is_operational ())
1251     return gpg_error (fips_not_operational ());
1252   return gpg_error (_gcry_md_setkey (hd, key, keylen));
1253 }
1254
1255 void
1256 gcry_md_debug (gcry_md_hd_t hd, const char *suffix)
1257 {
1258   _gcry_md_debug (hd, suffix);
1259 }
1260
1261 gpg_error_t
1262 gcry_kdf_derive (const void *passphrase, size_t passphraselen,
1263                  int algo, int hashalgo,
1264                  const void *salt, size_t saltlen,
1265                  unsigned long iterations,
1266                  size_t keysize, void *keybuffer)
1267 {
1268   return gpg_error (_gcry_kdf_derive (passphrase, passphraselen, algo, hashalgo,
1269                                       salt, saltlen, iterations,
1270                                       keysize, keybuffer));
1271 }
1272
1273 void
1274 gcry_randomize (void *buffer, size_t length, enum gcry_random_level level)
1275 {
1276   if (!fips_is_operational ())
1277     {
1278       (void)fips_not_operational ();
1279       fips_signal_fatal_error ("called in non-operational state");
1280       fips_noreturn ();
1281     }
1282   _gcry_randomize (buffer, length, level);
1283 }
1284
1285 gcry_error_t
1286 gcry_random_add_bytes (const void *buffer, size_t length, int quality)
1287 {
1288   if (!fips_is_operational ())
1289     return gpg_error (fips_not_operational ());
1290   return gpg_error (_gcry_random_add_bytes (buffer, length, quality));
1291 }
1292
1293 void *
1294 gcry_random_bytes (size_t nbytes, enum gcry_random_level level)
1295 {
1296   if (!fips_is_operational ())
1297     {
1298       (void)fips_not_operational ();
1299       fips_signal_fatal_error ("called in non-operational state");
1300       fips_noreturn ();
1301     }
1302
1303   return _gcry_random_bytes (nbytes,level);
1304 }
1305
1306 void *
1307 gcry_random_bytes_secure (size_t nbytes, enum gcry_random_level level)
1308 {
1309   if (!fips_is_operational ())
1310     {
1311       (void)fips_not_operational ();
1312       fips_signal_fatal_error ("called in non-operational state");
1313       fips_noreturn ();
1314     }
1315
1316   return _gcry_random_bytes_secure (nbytes, level);
1317 }
1318
1319 void
1320 gcry_mpi_randomize (gcry_mpi_t w,
1321                     unsigned int nbits, enum gcry_random_level level)
1322 {
1323   _gcry_mpi_randomize (w, nbits, level);
1324 }
1325
1326 void
1327 gcry_create_nonce (void *buffer, size_t length)
1328 {
1329   if (!fips_is_operational ())
1330     {
1331       (void)fips_not_operational ();
1332       fips_signal_fatal_error ("called in non-operational state");
1333       fips_noreturn ();
1334     }
1335   _gcry_create_nonce (buffer, length);
1336 }
1337
1338 gcry_error_t
1339 gcry_prime_generate (gcry_mpi_t *prime,
1340                      unsigned int prime_bits,
1341                      unsigned int factor_bits,
1342                      gcry_mpi_t **factors,
1343                      gcry_prime_check_func_t cb_func,
1344                      void *cb_arg,
1345                      gcry_random_level_t random_level,
1346                      unsigned int flags)
1347 {
1348   return gpg_error (_gcry_prime_generate (prime, prime_bits, factor_bits,
1349                                           factors, cb_func, cb_arg,
1350                                           random_level, flags));
1351 }
1352
1353 gcry_error_t
1354 gcry_prime_group_generator (gcry_mpi_t *r_g,
1355                             gcry_mpi_t prime, gcry_mpi_t *factors,
1356                             gcry_mpi_t start_g)
1357 {
1358   return gpg_error (_gcry_prime_group_generator (r_g, prime, factors, start_g));
1359 }
1360
1361 void
1362 gcry_prime_release_factors (gcry_mpi_t *factors)
1363 {
1364   _gcry_prime_release_factors (factors);
1365 }
1366
1367 gcry_error_t
1368 gcry_prime_check (gcry_mpi_t x, unsigned int flags)
1369 {
1370   return gpg_error (_gcry_prime_check (x, flags));
1371 }
1372
1373 void
1374 gcry_ctx_release (gcry_ctx_t ctx)
1375 {
1376   _gcry_ctx_release (ctx);
1377 }
1378
1379 void
1380 gcry_log_debug (const char *fmt, ...)
1381 {
1382   va_list arg_ptr ;
1383
1384   va_start( arg_ptr, fmt ) ;
1385   _gcry_logv (GCRY_LOG_DEBUG, fmt, arg_ptr);
1386   va_end (arg_ptr);
1387 }
1388
1389 void
1390 gcry_log_debughex (const char *text, const void *buffer, size_t length)
1391 {
1392   _gcry_log_printhex (text, buffer, length);
1393 }
1394
1395 void
1396 gcry_log_debugmpi (const char *text, gcry_mpi_t mpi)
1397 {
1398   _gcry_log_printmpi (text, mpi);
1399 }
1400
1401 void
1402 gcry_log_debugpnt (const char *text, mpi_point_t point, gcry_ctx_t ctx)
1403 {
1404   mpi_ec_t ec = ctx? _gcry_ctx_get_pointer (ctx, CONTEXT_TYPE_EC) : NULL;
1405
1406   _gcry_mpi_point_log (text, point, ec);
1407 }
1408
1409 void
1410 gcry_log_debugsxp (const char *text, gcry_sexp_t sexp)
1411 {
1412   _gcry_log_printsxp (text, sexp);
1413 }
1414
1415 void
1416 gcry_set_progress_handler (gcry_handler_progress_t cb, void *cb_data)
1417 {
1418   _gcry_set_progress_handler (cb, cb_data);
1419 }
1420
1421 void
1422 gcry_set_allocation_handler (gcry_handler_alloc_t func_alloc,
1423                              gcry_handler_alloc_t func_alloc_secure,
1424                              gcry_handler_secure_check_t func_secure_check,
1425                              gcry_handler_realloc_t func_realloc,
1426                              gcry_handler_free_t func_free)
1427 {
1428   _gcry_set_allocation_handler (func_alloc, func_alloc_secure,
1429                                 func_secure_check, func_realloc, func_free);
1430 }
1431
1432 void
1433 gcry_set_outofcore_handler (gcry_handler_no_mem_t h, void *opaque)
1434 {
1435   _gcry_set_outofcore_handler (h, opaque);
1436 }
1437
1438 void
1439 gcry_set_fatalerror_handler (gcry_handler_error_t fnc, void *opaque)
1440 {
1441   _gcry_set_fatalerror_handler (fnc, opaque);
1442 }
1443
1444 void
1445 gcry_set_log_handler (gcry_handler_log_t f, void *opaque)
1446 {
1447   _gcry_set_log_handler (f, opaque);
1448 }
1449
1450 void
1451 gcry_set_gettext_handler (const char *(*f)(const char*))
1452 {
1453   _gcry_set_gettext_handler (f);
1454 }
1455
1456 void *
1457 gcry_malloc (size_t n)
1458 {
1459   return _gcry_malloc (n);
1460 }
1461
1462 void *
1463 gcry_calloc (size_t n, size_t m)
1464 {
1465   return _gcry_calloc (n, m);
1466 }
1467
1468 void *
1469 gcry_malloc_secure (size_t n)
1470 {
1471   return _gcry_malloc_secure (n);
1472 }
1473
1474 void *
1475 gcry_calloc_secure (size_t n, size_t m)
1476 {
1477   return _gcry_calloc_secure (n,m);
1478 }
1479
1480 void *
1481 gcry_realloc (void *a, size_t n)
1482 {
1483   return _gcry_realloc (a, n);
1484 }
1485
1486 char *
1487 gcry_strdup (const char *string)
1488 {
1489   return _gcry_strdup (string);
1490 }
1491
1492 void *
1493 gcry_xmalloc (size_t n)
1494 {
1495   return _gcry_xmalloc (n);
1496 }
1497
1498 void *
1499 gcry_xcalloc (size_t n, size_t m)
1500 {
1501   return _gcry_xcalloc (n, m);
1502 }
1503
1504 void *
1505 gcry_xmalloc_secure (size_t n)
1506 {
1507   return _gcry_xmalloc_secure (n);
1508 }
1509
1510 void *
1511 gcry_xcalloc_secure (size_t n, size_t m)
1512 {
1513   return _gcry_xcalloc_secure (n, m);
1514 }
1515
1516 void *
1517 gcry_xrealloc (void *a, size_t n)
1518 {
1519   return _gcry_xrealloc (a, n);
1520 }
1521
1522 char *
1523 gcry_xstrdup (const char *a)
1524 {
1525   return _gcry_xstrdup (a);
1526 }
1527
1528 void
1529 gcry_free (void *a)
1530 {
1531   _gcry_free (a);
1532 }
1533
1534 int
1535 gcry_is_secure (const void *a)
1536 {
1537   return _gcry_is_secure (a);
1538 }