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