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