0c6fbbdd7b52e7c06576ac3ee74c204291f6265f
[libgcrypt.git] / src / global.c
1 /* global.c  -  global control functions
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003
3  *               2004, 2005, 2006, 2008, 2011,
4  *               2012  Free Software Foundation, Inc.
5  *
6  * This file is part of Libgcrypt.
7  *
8  * Libgcrypt is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU Lesser general Public License as
10  * published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * Libgcrypt is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
20  */
21
22 #include <config.h>
23
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <stdarg.h>
28 #include <ctype.h>
29 #include <limits.h>
30 #include <errno.h>
31 #include <unistd.h>
32 #ifdef HAVE_SYSLOG
33 # include <syslog.h>
34 #endif /*HAVE_SYSLOG*/
35
36 #include "g10lib.h"
37 #include "cipher.h"
38 #include "stdmem.h" /* our own memory allocator */
39 #include "secmem.h" /* our own secmem allocator */
40 #include "ath.h"
41
42 \f
43
44 /****************
45  * flag bits: 0 : general cipher debug
46  *            1 : general MPI debug
47  */
48 static unsigned int debug_flags;
49
50 /* gcry_control (GCRYCTL_SET_FIPS_MODE), sets this flag so that the
51    initialization code switched fips mode on.  */
52 static int force_fips_mode;
53
54 /* Controlled by global_init().  */
55 static int any_init_done;
56
57 /* A table to map hardware features to a string.  */
58 static struct
59 {
60   unsigned int flag;
61   const char *desc;
62 } hwflist[] =
63   {
64     { HWF_PADLOCK_RNG, "padlock-rng" },
65     { HWF_PADLOCK_AES, "padlock-aes" },
66     { HWF_PADLOCK_SHA, "padlock-sha" },
67     { HWF_PADLOCK_MMUL,"padlock-mmul"},
68     { HWF_INTEL_AESNI, "intel-aesni" },
69     { HWF_INTEL_RDRAND,"intel-rdrand" },
70     { HWF_INTEL_AVX,   "intel-avx" },
71     { 0, NULL}
72   };
73
74 /* A bit vector with the hardware features which shall not be used.
75    This variable must be set prior to any initialization.  */
76 static unsigned int disabled_hw_features;
77
78
79 /* Memory management. */
80
81 static gcry_handler_alloc_t alloc_func;
82 static gcry_handler_alloc_t alloc_secure_func;
83 static gcry_handler_secure_check_t is_secure_func;
84 static gcry_handler_realloc_t realloc_func;
85 static gcry_handler_free_t free_func;
86 static gcry_handler_no_mem_t outofcore_handler;
87 static void *outofcore_handler_value;
88 static int no_secure_memory;
89
90
91 \f
92
93
94 /* This is our handmade constructor.  It gets called by any function
95    likely to be called at startup.  The suggested way for an
96    application to make sure that this has been called is by using
97    gcry_check_version. */
98 static void
99 global_init (void)
100 {
101   gcry_error_t err = 0;
102
103   if (any_init_done)
104     return;
105   any_init_done = 1;
106
107   /* Tell the random module that we have seen an init call.  */
108   _gcry_set_preferred_rng_type (0);
109
110   /* Initialize our portable thread/mutex wrapper.  */
111   err = ath_init ();
112   if (err)
113     {
114       err = gpg_error_from_errno (err);
115       goto fail;
116     }
117
118   /* See whether the system is in FIPS mode.  This needs to come as
119      early as possible but after ATH has been initialized.  */
120   _gcry_initialize_fips_mode (force_fips_mode);
121
122   /* Before we do any other initialization we need to test available
123      hardware features.  */
124   _gcry_detect_hw_features (disabled_hw_features);
125
126   /* Initialize the modules - this is mainly allocating some memory and
127      creating mutexes.  */
128   err = _gcry_cipher_init ();
129   if (err)
130     goto fail;
131   err = _gcry_md_init ();
132   if (err)
133     goto fail;
134   err = _gcry_pk_init ();
135   if (err)
136     goto fail;
137   err = _gcry_primegen_init ();
138   if (err)
139     goto fail;
140   err = _gcry_secmem_module_init ();
141   if (err)
142     goto fail;
143   err = _gcry_mpi_init ();
144   if (err)
145     goto fail;
146
147   return;
148
149  fail:
150   BUG ();
151 }
152
153
154 /* This function is called by the macro fips_is_operational and makes
155    sure that the minimal initialization has been done.  This is far
156    from a perfect solution and hides problems with an improper
157    initialization but at least in single-threaded mode it should work
158    reliable.
159
160    The reason we need this is that a lot of applications don't use
161    Libgcrypt properly by not running any initialization code at all.
162    They just call a Libgcrypt function and that is all what they want.
163    Now with the FIPS mode, that has the side effect of entering FIPS
164    mode (for security reasons, FIPS mode is the default if no
165    initialization has been done) and bailing out immediately because
166    the FSM is in the wrong state.  If we always run the init code,
167    Libgcrypt can test for FIPS mode and at least if not in FIPS mode,
168    it will behave as before.  Note that this on-the-fly initialization
169    is only done for the cryptographic functions subject to FIPS mode
170    and thus not all API calls will do such an initialization.  */
171 int
172 _gcry_global_is_operational (void)
173 {
174   if (!any_init_done)
175     {
176 #ifdef HAVE_SYSLOG
177       syslog (LOG_USER|LOG_WARNING, "Libgcrypt warning: "
178               "missing initialization - please fix the application");
179 #endif /*HAVE_SYSLOG*/
180       global_init ();
181     }
182   return _gcry_fips_is_operational ();
183 }
184
185
186
187 \f
188 /* Version number parsing.  */
189
190 /* This function parses the first portion of the version number S and
191    stores it in *NUMBER.  On success, this function returns a pointer
192    into S starting with the first character, which is not part of the
193    initial number portion; on failure, NULL is returned.  */
194 static const char*
195 parse_version_number( const char *s, int *number )
196 {
197     int val = 0;
198
199     if( *s == '0' && isdigit(s[1]) )
200         return NULL; /* leading zeros are not allowed */
201     for ( ; isdigit(*s); s++ ) {
202         val *= 10;
203         val += *s - '0';
204     }
205     *number = val;
206     return val < 0? NULL : s;
207 }
208
209 /* This function breaks up the complete string-representation of the
210    version number S, which is of the following struture: <major
211    number>.<minor number>.<micro number><patch level>.  The major,
212    minor and micro number components will be stored in *MAJOR, *MINOR
213    and *MICRO.
214
215    On success, the last component, the patch level, will be returned;
216    in failure, NULL will be returned.  */
217
218 static const char *
219 parse_version_string( const char *s, int *major, int *minor, int *micro )
220 {
221     s = parse_version_number( s, major );
222     if( !s || *s != '.' )
223         return NULL;
224     s++;
225     s = parse_version_number( s, minor );
226     if( !s || *s != '.' )
227         return NULL;
228     s++;
229     s = parse_version_number( s, micro );
230     if( !s )
231         return NULL;
232     return s; /* patchlevel */
233 }
234
235 /* If REQ_VERSION is non-NULL, check that the version of the library
236    is at minimum the requested one.  Returns the string representation
237    of the library version if the condition is satisfied; return NULL
238    if the requested version is newer than that of the library.
239
240    If a NULL is passed to this function, no check is done, but the
241    string representation of the library is simply returned.  */
242 const char *
243 gcry_check_version( const char *req_version )
244 {
245     const char *ver = VERSION;
246     int my_major, my_minor, my_micro;
247     int rq_major, rq_minor, rq_micro;
248     const char *my_plvl;
249
250     /* Initialize library.  */
251     global_init ();
252
253     if ( !req_version )
254         /* Caller wants our version number.  */
255         return ver;
256
257     /* Parse own version number.  */
258     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
259     if ( !my_plvl )
260         /* very strange our own version is bogus.  Shouldn't we use
261            assert() here and bail out in case this happens?  -mo.  */
262         return NULL;
263
264     /* Parse requested version number.  */
265     if (!parse_version_string (req_version, &rq_major, &rq_minor, &rq_micro))
266       return NULL;  /* req version string is invalid, this can happen.  */
267
268     /* Compare version numbers.  */
269     if ( my_major > rq_major
270         || (my_major == rq_major && my_minor > rq_minor)
271         || (my_major == rq_major && my_minor == rq_minor                                                         && my_micro > rq_micro)
272         || (my_major == rq_major && my_minor == rq_minor
273                                  && my_micro == rq_micro))
274       {
275         return ver;
276       }
277
278     return NULL;
279 }
280
281
282 static void
283 print_config ( int (*fnc)(FILE *fp, const char *format, ...), FILE *fp)
284 {
285   unsigned int hwf;
286   int i;
287
288   fnc (fp, "version:%s:\n", VERSION);
289   fnc (fp, "ciphers:%s:\n", LIBGCRYPT_CIPHERS);
290   fnc (fp, "pubkeys:%s:\n", LIBGCRYPT_PUBKEY_CIPHERS);
291   fnc (fp, "digests:%s:\n", LIBGCRYPT_DIGESTS);
292   fnc (fp, "rnd-mod:"
293 #if USE_RNDEGD
294                 "egd:"
295 #endif
296 #if USE_RNDLINUX
297                 "linux:"
298 #endif
299 #if USE_RNDUNIX
300                 "unix:"
301 #endif
302 #if USE_RNDW32
303                 "w32:"
304 #endif
305        "\n");
306   fnc (fp, "cpu-arch:"
307 #if defined(HAVE_CPU_ARCH_X86)
308        "x86"
309 #elif defined(HAVE_CPU_ARCH_ALPHA)
310        "alpha"
311 #elif defined(HAVE_CPU_ARCH_SPARC)
312        "sparc"
313 #elif defined(HAVE_CPU_ARCH_MIPS)
314        "mips"
315 #elif defined(HAVE_CPU_ARCH_M68K)
316        "m68k"
317 #elif defined(HAVE_CPU_ARCH_PPC)
318        "ppc"
319 #elif defined(HAVE_CPU_ARCH_ARM)
320        "arm"
321 #endif
322        ":\n");
323   fnc (fp, "mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
324   fnc (fp, "threads:%s:\n", ath_get_model (NULL));
325   hwf = _gcry_get_hw_features ();
326   fnc (fp, "hwflist:");
327   for (i=0; hwflist[i].desc; i++)
328     if ( (hwf & hwflist[i].flag) )
329       fnc (fp, "%s:", hwflist[i].desc);
330   fnc (fp, "\n");
331   /* We use y/n instead of 1/0 for the simple reason that Emacsen's
332      compile error parser would accidently flag that line when printed
333      during "make check" as an error.  */
334   fnc (fp, "fips-mode:%c:%c:\n",
335        fips_mode ()? 'y':'n',
336        _gcry_enforced_fips_mode ()? 'y':'n' );
337   /* The currently used RNG type.  */
338   {
339     const char *s;
340
341     i = _gcry_get_rng_type (0);
342     switch (i)
343       {
344       case GCRY_RNG_TYPE_STANDARD: s = "standard"; break;
345       case GCRY_RNG_TYPE_FIPS:     s = "fips"; break;
346       case GCRY_RNG_TYPE_SYSTEM:   s = "system"; break;
347       default: BUG ();
348       }
349     fnc (fp, "rng-type:%s:%d:\n", s, i);
350   }
351
352 }
353
354
355 \f
356
357 /* Command dispatcher function, acting as general control
358    function.  */
359 gcry_error_t
360 _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr)
361 {
362   static int init_finished = 0;
363   gcry_err_code_t err = 0;
364
365   switch (cmd)
366     {
367     case GCRYCTL_ENABLE_M_GUARD:
368       _gcry_private_enable_m_guard ();
369       break;
370
371     case GCRYCTL_ENABLE_QUICK_RANDOM:
372       _gcry_set_preferred_rng_type (0);
373       _gcry_enable_quick_random_gen ();
374       break;
375
376     case GCRYCTL_FAKED_RANDOM_P:
377       /* Return an error if the RNG is faked one (e.g. enabled by
378          ENABLE_QUICK_RANDOM. */
379       if (_gcry_random_is_faked ())
380         err = GPG_ERR_GENERAL;  /* Use as TRUE value.  */
381       break;
382
383     case GCRYCTL_DUMP_RANDOM_STATS:
384       _gcry_random_dump_stats ();
385       break;
386
387     case GCRYCTL_DUMP_MEMORY_STATS:
388       /*m_print_stats("[fixme: prefix]");*/
389       break;
390
391     case GCRYCTL_DUMP_SECMEM_STATS:
392       _gcry_secmem_dump_stats ();
393       break;
394
395     case GCRYCTL_DROP_PRIVS:
396       global_init ();
397       _gcry_secmem_init (0);
398       break;
399
400     case GCRYCTL_DISABLE_SECMEM:
401       global_init ();
402       no_secure_memory = 1;
403       break;
404
405     case GCRYCTL_INIT_SECMEM:
406       global_init ();
407       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
408       if ((_gcry_secmem_get_flags () & GCRY_SECMEM_FLAG_NOT_LOCKED))
409         err = GPG_ERR_GENERAL;
410       break;
411
412     case GCRYCTL_TERM_SECMEM:
413       global_init ();
414       _gcry_secmem_term ();
415       break;
416
417     case GCRYCTL_DISABLE_SECMEM_WARN:
418       _gcry_set_preferred_rng_type (0);
419       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
420                                | GCRY_SECMEM_FLAG_NO_WARNING));
421       break;
422
423     case GCRYCTL_SUSPEND_SECMEM_WARN:
424       _gcry_set_preferred_rng_type (0);
425       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
426                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
427       break;
428
429     case GCRYCTL_RESUME_SECMEM_WARN:
430       _gcry_set_preferred_rng_type (0);
431       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
432                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
433       break;
434
435     case GCRYCTL_USE_SECURE_RNDPOOL:
436       global_init ();
437       _gcry_secure_random_alloc (); /* Put random number into secure memory. */
438       break;
439
440     case GCRYCTL_SET_RANDOM_SEED_FILE:
441       _gcry_set_preferred_rng_type (0);
442       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
443       break;
444
445     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
446       _gcry_set_preferred_rng_type (0);
447       if ( fips_is_operational () )
448         _gcry_update_random_seed_file ();
449       break;
450
451     case GCRYCTL_SET_VERBOSITY:
452       _gcry_set_preferred_rng_type (0);
453       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
454       break;
455
456     case GCRYCTL_SET_DEBUG_FLAGS:
457       debug_flags |= va_arg (arg_ptr, unsigned int);
458       break;
459
460     case GCRYCTL_CLEAR_DEBUG_FLAGS:
461       debug_flags &= ~va_arg (arg_ptr, unsigned int);
462       break;
463
464     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
465       /* Not used anymore.  */
466       global_init ();
467       break;
468
469     case GCRYCTL_ANY_INITIALIZATION_P:
470       if (any_init_done)
471         err = GPG_ERR_GENERAL;
472       break;
473
474     case GCRYCTL_INITIALIZATION_FINISHED_P:
475       if (init_finished)
476         err = GPG_ERR_GENERAL; /* Yes.  */
477       break;
478
479     case GCRYCTL_INITIALIZATION_FINISHED:
480       /* This is a hook which should be used by an application after
481          all initialization has been done and right before any threads
482          are started.  It is not really needed but the only way to be
483          really sure that all initialization for thread-safety has
484          been done. */
485       if (! init_finished)
486         {
487           global_init ();
488           /* Do only a basic random initialization, i.e. init the
489              mutexes. */
490           _gcry_random_initialize (0);
491           init_finished = 1;
492           /* Force us into operational state if in FIPS mode.  */
493           (void)fips_is_operational ();
494         }
495       break;
496
497     case GCRYCTL_SET_THREAD_CBS:
498       _gcry_set_preferred_rng_type (0);
499       err = ath_install (va_arg (arg_ptr, void *));
500       if (!err)
501         global_init ();
502       break;
503
504     case GCRYCTL_FAST_POLL:
505       _gcry_set_preferred_rng_type (0);
506       /* We need to do make sure that the random pool is really
507          initialized so that the poll function is not a NOP. */
508       _gcry_random_initialize (1);
509
510       if ( fips_is_operational () )
511         _gcry_fast_random_poll ();
512       break;
513
514     case GCRYCTL_SET_RNDEGD_SOCKET:
515 #if USE_RNDEGD
516       _gcry_set_preferred_rng_type (0);
517       err = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
518 #else
519       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
520 #endif
521       break;
522
523     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
524       _gcry_set_preferred_rng_type (0);
525       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
526       break;
527
528     case GCRYCTL_USE_RANDOM_DAEMON:
529       /* We need to do make sure that the random pool is really
530          initialized so that the poll function is not a NOP. */
531       _gcry_set_preferred_rng_type (0);
532       _gcry_random_initialize (1);
533       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
534       break;
535
536       /* This command dumps information pertaining to the
537          configuration of libgcrypt to the given stream.  It may be
538          used before the initialization has been finished but not
539          before a gcry_version_check. */
540     case GCRYCTL_PRINT_CONFIG:
541       {
542         FILE *fp = va_arg (arg_ptr, FILE *);
543         _gcry_set_preferred_rng_type (0);
544         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
545       }
546       break;
547
548     case GCRYCTL_OPERATIONAL_P:
549       /* Returns true if the library is in an operational state.  This
550          is always true for non-fips mode.  */
551       _gcry_set_preferred_rng_type (0);
552       if (_gcry_fips_test_operational ())
553         err = GPG_ERR_GENERAL; /* Used as TRUE value */
554       break;
555
556     case GCRYCTL_FIPS_MODE_P:
557       if (fips_mode ()
558           && !_gcry_is_fips_mode_inactive ()
559           && !no_secure_memory)
560         err = GPG_ERR_GENERAL; /* Used as TRUE value */
561       break;
562
563     case GCRYCTL_FORCE_FIPS_MODE:
564       /* Performing this command puts the library into fips mode.  If
565          the library has already been initialized into fips mode, a
566          selftest is triggered.  It is not possible to put the libraty
567          into fips mode after having passed the initialization. */
568       _gcry_set_preferred_rng_type (0);
569       if (!any_init_done)
570         {
571           /* Not yet intialized at all.  Set a flag so that we are put
572              into fips mode during initialization.  */
573           force_fips_mode = 1;
574         }
575       else
576         {
577           /* Already initialized.  If we are already operational we
578              run a selftest.  If not we use the is_operational call to
579              force us into operational state if possible.  */
580           if (_gcry_fips_test_error_or_operational ())
581             _gcry_fips_run_selftests (1);
582           if (_gcry_fips_is_operational ())
583             err = GPG_ERR_GENERAL; /* Used as TRUE value */
584       }
585       break;
586
587     case GCRYCTL_SELFTEST:
588       /* Run a selftest.  This works in fips mode as well as in
589          standard mode.  In contrast to the power-up tests, we use an
590          extended version of the selftests. Returns 0 on success or an
591          error code. */
592       global_init ();
593       err = _gcry_fips_run_selftests (1);
594       break;
595
596 #if _GCRY_GCC_VERSION >= 40600
597 # pragma GCC diagnostic push
598 # pragma GCC diagnostic ignored "-Wswitch"
599 #endif
600     case 58:  /* Init external random test.  */
601       {
602         void **rctx        = va_arg (arg_ptr, void **);
603         unsigned int flags = va_arg (arg_ptr, unsigned int);
604         const void *key    = va_arg (arg_ptr, const void *);
605         size_t keylen      = va_arg (arg_ptr, size_t);
606         const void *seed   = va_arg (arg_ptr, const void *);
607         size_t seedlen     = va_arg (arg_ptr, size_t);
608         const void *dt     = va_arg (arg_ptr, const void *);
609         size_t dtlen       = va_arg (arg_ptr, size_t);
610         if (!fips_is_operational ())
611           err = fips_not_operational ();
612         else
613           err = _gcry_random_init_external_test (rctx, flags, key, keylen,
614                                                  seed, seedlen, dt, dtlen);
615       }
616       break;
617     case 59:  /* Run external random test.  */
618       {
619         void *ctx     = va_arg (arg_ptr, void *);
620         void *buffer  = va_arg (arg_ptr, void *);
621         size_t buflen = va_arg (arg_ptr, size_t);
622         if (!fips_is_operational ())
623           err = fips_not_operational ();
624         else
625           err = _gcry_random_run_external_test (ctx, buffer, buflen);
626       }
627       break;
628     case 60:  /* Deinit external random test.  */
629       {
630         void *ctx = va_arg (arg_ptr, void *);
631         _gcry_random_deinit_external_test (ctx);
632       }
633       break;
634     case 61:  /* RFU */
635       break;
636     case 62:  /* RFU */
637       break;
638 #if _GCRY_GCC_VERSION >= 40600
639 # pragma GCC diagnostic pop
640 #endif
641
642     case GCRYCTL_DISABLE_HWF:
643       {
644         const char *name = va_arg (arg_ptr, const char *);
645         int i;
646
647         for (i=0; hwflist[i].desc; i++)
648           if (!strcmp (hwflist[i].desc, name))
649             {
650               disabled_hw_features |= hwflist[i].flag;
651               break;
652             }
653         if (!hwflist[i].desc)
654           err = GPG_ERR_INV_NAME;
655       }
656       break;
657
658     case GCRYCTL_SET_ENFORCED_FIPS_FLAG:
659       if (!any_init_done)
660         {
661           /* Not yet initialized at all.  Set the enforced fips mode flag */
662           _gcry_set_preferred_rng_type (0);
663           _gcry_set_enforced_fips_mode ();
664         }
665       else
666         err = GPG_ERR_GENERAL;
667       break;
668
669     case GCRYCTL_SET_PREFERRED_RNG_TYPE:
670       /* This may be called before gcry_check_version.  */
671       {
672         int i = va_arg (arg_ptr, int);
673         /* Note that we may not pass 0 to _gcry_set_preferred_rng_type.  */
674         if (i > 0)
675           _gcry_set_preferred_rng_type (i);
676       }
677       break;
678
679     case GCRYCTL_GET_CURRENT_RNG_TYPE:
680       {
681         int *ip = va_arg (arg_ptr, int*);
682         if (ip)
683           *ip = _gcry_get_rng_type (!any_init_done);
684       }
685       break;
686
687     default:
688       _gcry_set_preferred_rng_type (0);
689       /* A call to make sure that the dummy code is linked in.  */
690       _gcry_compat_identification ();
691       err = GPG_ERR_INV_OP;
692     }
693
694   return gcry_error (err);
695 }
696
697
698 /* Command dispatcher function, acting as general control
699    function.  */
700 gcry_error_t
701 gcry_control (enum gcry_ctl_cmds cmd, ...)
702 {
703   gcry_error_t err;
704   va_list arg_ptr;
705
706   va_start (arg_ptr, cmd);
707   err = _gcry_vcontrol (cmd, arg_ptr);
708   va_end(arg_ptr);
709   return err;
710 }
711
712
713
714 /* Return a pointer to a string containing a description of the error
715    code in the error value ERR.  */
716 const char *
717 gcry_strerror (gcry_error_t err)
718 {
719   return gpg_strerror (err);
720 }
721
722 /* Return a pointer to a string containing a description of the error
723    source in the error value ERR.  */
724 const char *
725 gcry_strsource (gcry_error_t err)
726 {
727   return gpg_strsource (err);
728 }
729
730 /* Retrieve the error code for the system error ERR.  This returns
731    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
732    this).  */
733 gcry_err_code_t
734 gcry_err_code_from_errno (int err)
735 {
736   return gpg_err_code_from_errno (err);
737 }
738
739
740 /* Retrieve the system error for the error code CODE.  This returns 0
741    if CODE is not a system error code.  */
742 int
743 gcry_err_code_to_errno (gcry_err_code_t code)
744 {
745   return gpg_err_code_from_errno (code);
746 }
747
748
749 /* Return an error value with the error source SOURCE and the system
750    error ERR.  */
751 gcry_error_t
752 gcry_err_make_from_errno (gpg_err_source_t source, int err)
753 {
754   return gpg_err_make_from_errno (source, err);
755 }
756
757
758 /* Return an error value with the system error ERR.  */
759 gcry_err_code_t
760 gcry_error_from_errno (int err)
761 {
762   return gcry_error (gpg_err_code_from_errno (err));
763 }
764
765
766 /* Set custom allocation handlers.  This is in general not useful
767  * because the libgcrypt allocation functions are guaranteed to
768  * provide proper allocation handlers which zeroize memory if needed.
769  * NOTE: All 5 functions should be set.  */
770 void
771 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
772                              gcry_handler_alloc_t new_alloc_secure_func,
773                              gcry_handler_secure_check_t new_is_secure_func,
774                              gcry_handler_realloc_t new_realloc_func,
775                              gcry_handler_free_t new_free_func)
776 {
777   global_init ();
778
779   if (fips_mode ())
780     {
781       /* We do not want to enforce the fips mode, but merely set a
782          flag so that the application may check whether it is still in
783          fips mode.  */
784       _gcry_inactivate_fips_mode ("custom allocation handler");
785     }
786
787   alloc_func = new_alloc_func;
788   alloc_secure_func = new_alloc_secure_func;
789   is_secure_func = new_is_secure_func;
790   realloc_func = new_realloc_func;
791   free_func = new_free_func;
792 }
793
794
795
796 /****************
797  * Set an optional handler which is called in case the xmalloc functions
798  * ran out of memory.  This handler may do one of these things:
799  *   o free some memory and return true, so that the xmalloc function
800  *     tries again.
801  *   o Do whatever it like and return false, so that the xmalloc functions
802  *     use the default fatal error handler.
803  *   o Terminate the program and don't return.
804  *
805  * The handler function is called with 3 arguments:  The opaque value set with
806  * this function, the requested memory size, and a flag with these bits
807  * currently defined:
808  *      bit 0 set = secure memory has been requested.
809  */
810 void
811 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
812                                                         void *value )
813 {
814   global_init ();
815
816   if (fips_mode () )
817     {
818       log_info ("out of core handler ignored in FIPS mode\n");
819       return;
820     }
821
822   outofcore_handler = f;
823   outofcore_handler_value = value;
824 }
825
826 /* Return the no_secure_memory flag.  */
827 static int
828 get_no_secure_memory (void)
829 {
830   if (!no_secure_memory)
831     return 0;
832   if (_gcry_enforced_fips_mode ())
833     {
834       no_secure_memory = 0;
835       return 0;
836     }
837   return no_secure_memory;
838 }
839
840
841 static gcry_err_code_t
842 do_malloc (size_t n, unsigned int flags, void **mem)
843 {
844   gcry_err_code_t err = 0;
845   void *m;
846
847   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
848     {
849       if (alloc_secure_func)
850         m = (*alloc_secure_func) (n);
851       else
852         m = _gcry_private_malloc_secure (n);
853     }
854   else
855     {
856       if (alloc_func)
857         m = (*alloc_func) (n);
858       else
859         m = _gcry_private_malloc (n);
860     }
861
862   if (!m)
863     {
864       /* Make sure that ERRNO has been set in case a user supplied
865          memory handler didn't it correctly. */
866       if (!errno)
867         gpg_err_set_errno (ENOMEM);
868       err = gpg_err_code_from_errno (errno);
869     }
870   else
871     *mem = m;
872
873   return err;
874 }
875
876 void *
877 gcry_malloc (size_t n)
878 {
879   void *mem = NULL;
880
881   do_malloc (n, 0, &mem);
882
883   return mem;
884 }
885
886 void *
887 gcry_malloc_secure (size_t n)
888 {
889   void *mem = NULL;
890
891   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
892
893   return mem;
894 }
895
896 int
897 gcry_is_secure (const void *a)
898 {
899   if (get_no_secure_memory ())
900     return 0;
901   if (is_secure_func)
902     return is_secure_func (a) ;
903   return _gcry_private_is_secure (a);
904 }
905
906 void
907 _gcry_check_heap( const void *a )
908 {
909   (void)a;
910
911     /* FIXME: implement this*/
912 #if 0
913     if( some_handler )
914         some_handler(a)
915     else
916         _gcry_private_check_heap(a)
917 #endif
918 }
919
920 void *
921 gcry_realloc (void *a, size_t n)
922 {
923   void *p;
924
925   /* To avoid problems with non-standard realloc implementations and
926      our own secmem_realloc, we divert to malloc and free here.  */
927   if (!a)
928     return gcry_malloc (n);
929   if (!n)
930     {
931       gcry_free (a);
932       return NULL;
933     }
934
935   if (realloc_func)
936     p = realloc_func (a, n);
937   else
938     p =  _gcry_private_realloc (a, n);
939   if (!p && !errno)
940     gpg_err_set_errno (ENOMEM);
941   return p;
942 }
943
944 void
945 gcry_free (void *p)
946 {
947   int save_errno;
948
949   if (!p)
950     return;
951
952   /* In case ERRNO is set we better save it so that the free machinery
953      may not accidently change ERRNO.  We restore it only if it was
954      already set to comply with the usual C semantic for ERRNO.  */
955   save_errno = errno;
956   if (free_func)
957     free_func (p);
958   else
959     _gcry_private_free (p);
960
961   if (save_errno)
962     gpg_err_set_errno (save_errno);
963 }
964
965 void *
966 gcry_calloc (size_t n, size_t m)
967 {
968   size_t bytes;
969   void *p;
970
971   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
972                     defined. */
973   if (m && bytes / m != n)
974     {
975       gpg_err_set_errno (ENOMEM);
976       return NULL;
977     }
978
979   p = gcry_malloc (bytes);
980   if (p)
981     memset (p, 0, bytes);
982   return p;
983 }
984
985 void *
986 gcry_calloc_secure (size_t n, size_t m)
987 {
988   size_t bytes;
989   void *p;
990
991   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
992                     defined. */
993   if (m && bytes / m != n)
994     {
995       gpg_err_set_errno (ENOMEM);
996       return NULL;
997     }
998
999   p = gcry_malloc_secure (bytes);
1000   if (p)
1001     memset (p, 0, bytes);
1002   return p;
1003 }
1004
1005
1006 /* Create and return a copy of the null-terminated string STRING.  If
1007    it is contained in secure memory, the copy will be contained in
1008    secure memory as well.  In an out-of-memory condition, NULL is
1009    returned.  */
1010 char *
1011 gcry_strdup (const char *string)
1012 {
1013   char *string_cp = NULL;
1014   size_t string_n = 0;
1015
1016   string_n = strlen (string);
1017
1018   if (gcry_is_secure (string))
1019     string_cp = gcry_malloc_secure (string_n + 1);
1020   else
1021     string_cp = gcry_malloc (string_n + 1);
1022
1023   if (string_cp)
1024     strcpy (string_cp, string);
1025
1026   return string_cp;
1027 }
1028
1029
1030 void *
1031 gcry_xmalloc( size_t n )
1032 {
1033   void *p;
1034
1035   while ( !(p = gcry_malloc( n )) )
1036     {
1037       if ( fips_mode ()
1038            || !outofcore_handler
1039            || !outofcore_handler (outofcore_handler_value, n, 0) )
1040         {
1041           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
1042         }
1043     }
1044     return p;
1045 }
1046
1047 void *
1048 gcry_xrealloc( void *a, size_t n )
1049 {
1050   void *p;
1051
1052   while ( !(p = gcry_realloc( a, n )) )
1053     {
1054       if ( fips_mode ()
1055            || !outofcore_handler
1056            || !outofcore_handler (outofcore_handler_value, n,
1057                                    gcry_is_secure(a)? 3:2 ) )
1058         {
1059           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
1060         }
1061     }
1062     return p;
1063 }
1064
1065 void *
1066 gcry_xmalloc_secure( size_t n )
1067 {
1068   void *p;
1069
1070   while ( !(p = gcry_malloc_secure( n )) )
1071     {
1072       if ( fips_mode ()
1073            || !outofcore_handler
1074            || !outofcore_handler (outofcore_handler_value, n, 1) )
1075         {
1076           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1077                              _("out of core in secure memory"));
1078         }
1079     }
1080   return p;
1081 }
1082
1083
1084 void *
1085 gcry_xcalloc( size_t n, size_t m )
1086 {
1087   size_t nbytes;
1088   void *p;
1089
1090   nbytes = n * m;
1091   if (m && nbytes / m != n)
1092     {
1093       gpg_err_set_errno (ENOMEM);
1094       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1095     }
1096
1097   p = gcry_xmalloc ( nbytes );
1098   memset ( p, 0, nbytes );
1099   return p;
1100 }
1101
1102 void *
1103 gcry_xcalloc_secure( size_t n, size_t m )
1104 {
1105   size_t nbytes;
1106   void *p;
1107
1108   nbytes = n * m;
1109   if (m && nbytes / m != n)
1110     {
1111       gpg_err_set_errno (ENOMEM);
1112       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1113     }
1114
1115   p = gcry_xmalloc_secure ( nbytes );
1116   memset ( p, 0, nbytes );
1117   return p;
1118 }
1119
1120 char *
1121 gcry_xstrdup (const char *string)
1122 {
1123   char *p;
1124
1125   while ( !(p = gcry_strdup (string)) )
1126     {
1127       size_t n = strlen (string);
1128       int is_sec = !!gcry_is_secure (string);
1129
1130       if (fips_mode ()
1131           || !outofcore_handler
1132           || !outofcore_handler (outofcore_handler_value, n, is_sec) )
1133         {
1134           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1135                              is_sec? _("out of core in secure memory"):NULL);
1136         }
1137     }
1138
1139   return p;
1140 }
1141
1142
1143 int
1144 _gcry_get_debug_flag (unsigned int mask)
1145 {
1146   if ( fips_mode () )
1147     return 0;
1148   return (debug_flags & mask);
1149 }
1150
1151
1152 \f
1153 /* It is often useful to get some feedback of long running operations.
1154    This function may be used to register a handler for this.
1155    The callback function CB is used as:
1156
1157    void cb (void *opaque, const char *what, int printchar,
1158            int current, int total);
1159
1160    Where WHAT is a string identifying the the type of the progress
1161    output, PRINTCHAR the character usually printed, CURRENT the amount
1162    of progress currently done and TOTAL the expected amount of
1163    progress.  A value of 0 for TOTAL indicates that there is no
1164    estimation available.
1165
1166    Defined values for WHAT:
1167
1168    "need_entropy"  X    0  number-of-bytes-required
1169             When running low on entropy
1170    "primegen"      '\n'  0 0
1171            Prime generated
1172                    '!'
1173            Need to refresh the prime pool
1174                    '<','>'
1175            Number of bits adjusted
1176                    '^'
1177            Looking for a generator
1178                    '.'
1179            Fermat tests on 10 candidates failed
1180                   ':'
1181            Restart with a new random value
1182                   '+'
1183            Rabin Miller test passed
1184    "pk_elg"        '+','-','.','\n'   0  0
1185             Only used in debugging mode.
1186    "pk_dsa"
1187             Only used in debugging mode.
1188 */
1189 void
1190 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1191                            void *cb_data)
1192 {
1193 #if USE_DSA
1194   _gcry_register_pk_dsa_progress (cb, cb_data);
1195 #endif
1196 #if USE_ELGAMAL
1197   _gcry_register_pk_elg_progress (cb, cb_data);
1198 #endif
1199   _gcry_register_primegen_progress (cb, cb_data);
1200   _gcry_register_random_progress (cb, cb_data);
1201 }