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