Provide GCRYPT_VERSION_NUMBER macro, add build info to the binary.
[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     if (req_version && req_version[0] == 1 && req_version[1] == 1)
251         return _gcry_compat_identification ();
252
253     /* Initialize library.  */
254     global_init ();
255
256     if ( !req_version )
257         /* Caller wants our version number.  */
258         return ver;
259
260     /* Parse own version number.  */
261     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
262     if ( !my_plvl )
263         /* very strange our own version is bogus.  Shouldn't we use
264            assert() here and bail out in case this happens?  -mo.  */
265         return NULL;
266
267     /* Parse requested version number.  */
268     if (!parse_version_string (req_version, &rq_major, &rq_minor, &rq_micro))
269       return NULL;  /* req version string is invalid, this can happen.  */
270
271     /* Compare version numbers.  */
272     if ( my_major > rq_major
273         || (my_major == rq_major && my_minor > rq_minor)
274         || (my_major == rq_major && my_minor == rq_minor                                                         && my_micro > rq_micro)
275         || (my_major == rq_major && my_minor == rq_minor
276                                  && my_micro == rq_micro))
277       {
278         return ver;
279       }
280
281     return NULL;
282 }
283
284
285 static void
286 print_config ( int (*fnc)(FILE *fp, const char *format, ...), FILE *fp)
287 {
288   unsigned int hwf;
289   int i;
290
291   fnc (fp, "version:%s:\n", VERSION);
292   fnc (fp, "ciphers:%s:\n", LIBGCRYPT_CIPHERS);
293   fnc (fp, "pubkeys:%s:\n", LIBGCRYPT_PUBKEY_CIPHERS);
294   fnc (fp, "digests:%s:\n", LIBGCRYPT_DIGESTS);
295   fnc (fp, "rnd-mod:"
296 #if USE_RNDEGD
297                 "egd:"
298 #endif
299 #if USE_RNDLINUX
300                 "linux:"
301 #endif
302 #if USE_RNDUNIX
303                 "unix:"
304 #endif
305 #if USE_RNDW32
306                 "w32:"
307 #endif
308        "\n");
309   fnc (fp, "cpu-arch:"
310 #if defined(HAVE_CPU_ARCH_X86)
311        "x86"
312 #elif defined(HAVE_CPU_ARCH_ALPHA)
313        "alpha"
314 #elif defined(HAVE_CPU_ARCH_SPARC)
315        "sparc"
316 #elif defined(HAVE_CPU_ARCH_MIPS)
317        "mips"
318 #elif defined(HAVE_CPU_ARCH_M68K)
319        "m68k"
320 #elif defined(HAVE_CPU_ARCH_PPC)
321        "ppc"
322 #elif defined(HAVE_CPU_ARCH_ARM)
323        "arm"
324 #endif
325        ":\n");
326   fnc (fp, "mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
327   fnc (fp, "threads:%s:\n", ath_get_model (NULL));
328   hwf = _gcry_get_hw_features ();
329   fnc (fp, "hwflist:");
330   for (i=0; hwflist[i].desc; i++)
331     if ( (hwf & hwflist[i].flag) )
332       fnc (fp, "%s:", hwflist[i].desc);
333   fnc (fp, "\n");
334   /* We use y/n instead of 1/0 for the simple reason that Emacsen's
335      compile error parser would accidently flag that line when printed
336      during "make check" as an error.  */
337   fnc (fp, "fips-mode:%c:%c:\n",
338        fips_mode ()? 'y':'n',
339        _gcry_enforced_fips_mode ()? 'y':'n' );
340   /* The currently used RNG type.  */
341   {
342     const char *s;
343
344     i = _gcry_get_rng_type (0);
345     switch (i)
346       {
347       case GCRY_RNG_TYPE_STANDARD: s = "standard"; break;
348       case GCRY_RNG_TYPE_FIPS:     s = "fips"; break;
349       case GCRY_RNG_TYPE_SYSTEM:   s = "system"; break;
350       default: BUG ();
351       }
352     fnc (fp, "rng-type:%s:%d:\n", s, i);
353   }
354
355 }
356
357
358 \f
359
360 /* Command dispatcher function, acting as general control
361    function.  */
362 gcry_error_t
363 _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr)
364 {
365   static int init_finished = 0;
366   gcry_err_code_t err = 0;
367
368   switch (cmd)
369     {
370     case GCRYCTL_ENABLE_M_GUARD:
371       _gcry_private_enable_m_guard ();
372       break;
373
374     case GCRYCTL_ENABLE_QUICK_RANDOM:
375       _gcry_set_preferred_rng_type (0);
376       _gcry_enable_quick_random_gen ();
377       break;
378
379     case GCRYCTL_FAKED_RANDOM_P:
380       /* Return an error if the RNG is faked one (e.g. enabled by
381          ENABLE_QUICK_RANDOM. */
382       if (_gcry_random_is_faked ())
383         err = GPG_ERR_GENERAL;  /* Use as TRUE value.  */
384       break;
385
386     case GCRYCTL_DUMP_RANDOM_STATS:
387       _gcry_random_dump_stats ();
388       break;
389
390     case GCRYCTL_DUMP_MEMORY_STATS:
391       /*m_print_stats("[fixme: prefix]");*/
392       break;
393
394     case GCRYCTL_DUMP_SECMEM_STATS:
395       _gcry_secmem_dump_stats ();
396       break;
397
398     case GCRYCTL_DROP_PRIVS:
399       global_init ();
400       _gcry_secmem_init (0);
401       break;
402
403     case GCRYCTL_DISABLE_SECMEM:
404       global_init ();
405       no_secure_memory = 1;
406       break;
407
408     case GCRYCTL_INIT_SECMEM:
409       global_init ();
410       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
411       if ((_gcry_secmem_get_flags () & GCRY_SECMEM_FLAG_NOT_LOCKED))
412         err = GPG_ERR_GENERAL;
413       break;
414
415     case GCRYCTL_TERM_SECMEM:
416       global_init ();
417       _gcry_secmem_term ();
418       break;
419
420     case GCRYCTL_DISABLE_SECMEM_WARN:
421       _gcry_set_preferred_rng_type (0);
422       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
423                                | GCRY_SECMEM_FLAG_NO_WARNING));
424       break;
425
426     case GCRYCTL_SUSPEND_SECMEM_WARN:
427       _gcry_set_preferred_rng_type (0);
428       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
429                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
430       break;
431
432     case GCRYCTL_RESUME_SECMEM_WARN:
433       _gcry_set_preferred_rng_type (0);
434       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
435                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
436       break;
437
438     case GCRYCTL_USE_SECURE_RNDPOOL:
439       global_init ();
440       _gcry_secure_random_alloc (); /* Put random number into secure memory. */
441       break;
442
443     case GCRYCTL_SET_RANDOM_SEED_FILE:
444       _gcry_set_preferred_rng_type (0);
445       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
446       break;
447
448     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
449       _gcry_set_preferred_rng_type (0);
450       if ( fips_is_operational () )
451         _gcry_update_random_seed_file ();
452       break;
453
454     case GCRYCTL_SET_VERBOSITY:
455       _gcry_set_preferred_rng_type (0);
456       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
457       break;
458
459     case GCRYCTL_SET_DEBUG_FLAGS:
460       debug_flags |= va_arg (arg_ptr, unsigned int);
461       break;
462
463     case GCRYCTL_CLEAR_DEBUG_FLAGS:
464       debug_flags &= ~va_arg (arg_ptr, unsigned int);
465       break;
466
467     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
468       /* Not used anymore.  */
469       global_init ();
470       break;
471
472     case GCRYCTL_ANY_INITIALIZATION_P:
473       if (any_init_done)
474         err = GPG_ERR_GENERAL;
475       break;
476
477     case GCRYCTL_INITIALIZATION_FINISHED_P:
478       if (init_finished)
479         err = GPG_ERR_GENERAL; /* Yes.  */
480       break;
481
482     case GCRYCTL_INITIALIZATION_FINISHED:
483       /* This is a hook which should be used by an application after
484          all initialization has been done and right before any threads
485          are started.  It is not really needed but the only way to be
486          really sure that all initialization for thread-safety has
487          been done. */
488       if (! init_finished)
489         {
490           global_init ();
491           /* Do only a basic random initialization, i.e. init the
492              mutexes. */
493           _gcry_random_initialize (0);
494           init_finished = 1;
495           /* Force us into operational state if in FIPS mode.  */
496           (void)fips_is_operational ();
497         }
498       break;
499
500     case GCRYCTL_SET_THREAD_CBS:
501       _gcry_set_preferred_rng_type (0);
502       err = ath_install (va_arg (arg_ptr, void *));
503       if (!err)
504         global_init ();
505       break;
506
507     case GCRYCTL_FAST_POLL:
508       _gcry_set_preferred_rng_type (0);
509       /* We need to do make sure that the random pool is really
510          initialized so that the poll function is not a NOP. */
511       _gcry_random_initialize (1);
512
513       if ( fips_is_operational () )
514         _gcry_fast_random_poll ();
515       break;
516
517     case GCRYCTL_SET_RNDEGD_SOCKET:
518 #if USE_RNDEGD
519       _gcry_set_preferred_rng_type (0);
520       err = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
521 #else
522       err = gpg_error (GPG_ERR_NOT_SUPPORTED);
523 #endif
524       break;
525
526     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
527       _gcry_set_preferred_rng_type (0);
528       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
529       break;
530
531     case GCRYCTL_USE_RANDOM_DAEMON:
532       /* We need to do make sure that the random pool is really
533          initialized so that the poll function is not a NOP. */
534       _gcry_set_preferred_rng_type (0);
535       _gcry_random_initialize (1);
536       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
537       break;
538
539       /* This command dumps information pertaining to the
540          configuration of libgcrypt to the given stream.  It may be
541          used before the initialization has been finished but not
542          before a gcry_version_check. */
543     case GCRYCTL_PRINT_CONFIG:
544       {
545         FILE *fp = va_arg (arg_ptr, FILE *);
546         _gcry_set_preferred_rng_type (0);
547         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
548       }
549       break;
550
551     case GCRYCTL_OPERATIONAL_P:
552       /* Returns true if the library is in an operational state.  This
553          is always true for non-fips mode.  */
554       _gcry_set_preferred_rng_type (0);
555       if (_gcry_fips_test_operational ())
556         err = GPG_ERR_GENERAL; /* Used as TRUE value */
557       break;
558
559     case GCRYCTL_FIPS_MODE_P:
560       if (fips_mode ()
561           && !_gcry_is_fips_mode_inactive ()
562           && !no_secure_memory)
563         err = GPG_ERR_GENERAL; /* Used as TRUE value */
564       break;
565
566     case GCRYCTL_FORCE_FIPS_MODE:
567       /* Performing this command puts the library into fips mode.  If
568          the library has already been initialized into fips mode, a
569          selftest is triggered.  It is not possible to put the libraty
570          into fips mode after having passed the initialization. */
571       _gcry_set_preferred_rng_type (0);
572       if (!any_init_done)
573         {
574           /* Not yet intialized at all.  Set a flag so that we are put
575              into fips mode during initialization.  */
576           force_fips_mode = 1;
577         }
578       else
579         {
580           /* Already initialized.  If we are already operational we
581              run a selftest.  If not we use the is_operational call to
582              force us into operational state if possible.  */
583           if (_gcry_fips_test_error_or_operational ())
584             _gcry_fips_run_selftests (1);
585           if (_gcry_fips_is_operational ())
586             err = GPG_ERR_GENERAL; /* Used as TRUE value */
587       }
588       break;
589
590     case GCRYCTL_SELFTEST:
591       /* Run a selftest.  This works in fips mode as well as in
592          standard mode.  In contrast to the power-up tests, we use an
593          extended version of the selftests. Returns 0 on success or an
594          error code. */
595       global_init ();
596       err = _gcry_fips_run_selftests (1);
597       break;
598
599 #if _GCRY_GCC_VERSION >= 40600
600 # pragma GCC diagnostic push
601 # pragma GCC diagnostic ignored "-Wswitch"
602 #endif
603     case 58:  /* Init external random test.  */
604       {
605         void **rctx        = va_arg (arg_ptr, void **);
606         unsigned int flags = va_arg (arg_ptr, unsigned int);
607         const void *key    = va_arg (arg_ptr, const void *);
608         size_t keylen      = va_arg (arg_ptr, size_t);
609         const void *seed   = va_arg (arg_ptr, const void *);
610         size_t seedlen     = va_arg (arg_ptr, size_t);
611         const void *dt     = va_arg (arg_ptr, const void *);
612         size_t dtlen       = va_arg (arg_ptr, size_t);
613         if (!fips_is_operational ())
614           err = fips_not_operational ();
615         else
616           err = _gcry_random_init_external_test (rctx, flags, key, keylen,
617                                                  seed, seedlen, dt, dtlen);
618       }
619       break;
620     case 59:  /* Run external random test.  */
621       {
622         void *ctx     = va_arg (arg_ptr, void *);
623         void *buffer  = va_arg (arg_ptr, void *);
624         size_t buflen = va_arg (arg_ptr, size_t);
625         if (!fips_is_operational ())
626           err = fips_not_operational ();
627         else
628           err = _gcry_random_run_external_test (ctx, buffer, buflen);
629       }
630       break;
631     case 60:  /* Deinit external random test.  */
632       {
633         void *ctx = va_arg (arg_ptr, void *);
634         _gcry_random_deinit_external_test (ctx);
635       }
636       break;
637     case 61:  /* RFU */
638       break;
639     case 62:  /* RFU */
640       break;
641 #if _GCRY_GCC_VERSION >= 40600
642 # pragma GCC diagnostic pop
643 #endif
644
645     case GCRYCTL_DISABLE_HWF:
646       {
647         const char *name = va_arg (arg_ptr, const char *);
648         int i;
649
650         for (i=0; hwflist[i].desc; i++)
651           if (!strcmp (hwflist[i].desc, name))
652             {
653               disabled_hw_features |= hwflist[i].flag;
654               break;
655             }
656         if (!hwflist[i].desc)
657           err = GPG_ERR_INV_NAME;
658       }
659       break;
660
661     case GCRYCTL_SET_ENFORCED_FIPS_FLAG:
662       if (!any_init_done)
663         {
664           /* Not yet initialized at all.  Set the enforced fips mode flag */
665           _gcry_set_preferred_rng_type (0);
666           _gcry_set_enforced_fips_mode ();
667         }
668       else
669         err = GPG_ERR_GENERAL;
670       break;
671
672     case GCRYCTL_SET_PREFERRED_RNG_TYPE:
673       /* This may be called before gcry_check_version.  */
674       {
675         int i = va_arg (arg_ptr, int);
676         /* Note that we may not pass 0 to _gcry_set_preferred_rng_type.  */
677         if (i > 0)
678           _gcry_set_preferred_rng_type (i);
679       }
680       break;
681
682     case GCRYCTL_GET_CURRENT_RNG_TYPE:
683       {
684         int *ip = va_arg (arg_ptr, int*);
685         if (ip)
686           *ip = _gcry_get_rng_type (!any_init_done);
687       }
688       break;
689
690     default:
691       _gcry_set_preferred_rng_type (0);
692       err = GPG_ERR_INV_OP;
693     }
694
695   return gcry_error (err);
696 }
697
698
699 /* Command dispatcher function, acting as general control
700    function.  */
701 gcry_error_t
702 gcry_control (enum gcry_ctl_cmds cmd, ...)
703 {
704   gcry_error_t err;
705   va_list arg_ptr;
706
707   va_start (arg_ptr, cmd);
708   err = _gcry_vcontrol (cmd, arg_ptr);
709   va_end(arg_ptr);
710   return err;
711 }
712
713
714
715 /* Return a pointer to a string containing a description of the error
716    code in the error value ERR.  */
717 const char *
718 gcry_strerror (gcry_error_t err)
719 {
720   return gpg_strerror (err);
721 }
722
723 /* Return a pointer to a string containing a description of the error
724    source in the error value ERR.  */
725 const char *
726 gcry_strsource (gcry_error_t err)
727 {
728   return gpg_strsource (err);
729 }
730
731 /* Retrieve the error code for the system error ERR.  This returns
732    GPG_ERR_UNKNOWN_ERRNO if the system error is not mapped (report
733    this).  */
734 gcry_err_code_t
735 gcry_err_code_from_errno (int err)
736 {
737   return gpg_err_code_from_errno (err);
738 }
739
740
741 /* Retrieve the system error for the error code CODE.  This returns 0
742    if CODE is not a system error code.  */
743 int
744 gcry_err_code_to_errno (gcry_err_code_t code)
745 {
746   return gpg_err_code_from_errno (code);
747 }
748
749
750 /* Return an error value with the error source SOURCE and the system
751    error ERR.  */
752 gcry_error_t
753 gcry_err_make_from_errno (gpg_err_source_t source, int err)
754 {
755   return gpg_err_make_from_errno (source, err);
756 }
757
758
759 /* Return an error value with the system error ERR.  */
760 gcry_err_code_t
761 gcry_error_from_errno (int err)
762 {
763   return gcry_error (gpg_err_code_from_errno (err));
764 }
765
766
767 /* Set custom allocation handlers.  This is in general not useful
768  * because the libgcrypt allocation functions are guaranteed to
769  * provide proper allocation handlers which zeroize memory if needed.
770  * NOTE: All 5 functions should be set.  */
771 void
772 gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
773                              gcry_handler_alloc_t new_alloc_secure_func,
774                              gcry_handler_secure_check_t new_is_secure_func,
775                              gcry_handler_realloc_t new_realloc_func,
776                              gcry_handler_free_t new_free_func)
777 {
778   global_init ();
779
780   if (fips_mode ())
781     {
782       /* We do not want to enforce the fips mode, but merely set a
783          flag so that the application may check whether it is still in
784          fips mode.  */
785       _gcry_inactivate_fips_mode ("custom allocation handler");
786     }
787
788   alloc_func = new_alloc_func;
789   alloc_secure_func = new_alloc_secure_func;
790   is_secure_func = new_is_secure_func;
791   realloc_func = new_realloc_func;
792   free_func = new_free_func;
793 }
794
795
796
797 /****************
798  * Set an optional handler which is called in case the xmalloc functions
799  * ran out of memory.  This handler may do one of these things:
800  *   o free some memory and return true, so that the xmalloc function
801  *     tries again.
802  *   o Do whatever it like and return false, so that the xmalloc functions
803  *     use the default fatal error handler.
804  *   o Terminate the program and don't return.
805  *
806  * The handler function is called with 3 arguments:  The opaque value set with
807  * this function, the requested memory size, and a flag with these bits
808  * currently defined:
809  *      bit 0 set = secure memory has been requested.
810  */
811 void
812 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
813                                                         void *value )
814 {
815   global_init ();
816
817   if (fips_mode () )
818     {
819       log_info ("out of core handler ignored in FIPS mode\n");
820       return;
821     }
822
823   outofcore_handler = f;
824   outofcore_handler_value = value;
825 }
826
827 /* Return the no_secure_memory flag.  */
828 static int
829 get_no_secure_memory (void)
830 {
831   if (!no_secure_memory)
832     return 0;
833   if (_gcry_enforced_fips_mode ())
834     {
835       no_secure_memory = 0;
836       return 0;
837     }
838   return no_secure_memory;
839 }
840
841
842 static gcry_err_code_t
843 do_malloc (size_t n, unsigned int flags, void **mem)
844 {
845   gcry_err_code_t err = 0;
846   void *m;
847
848   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
849     {
850       if (alloc_secure_func)
851         m = (*alloc_secure_func) (n);
852       else
853         m = _gcry_private_malloc_secure (n);
854     }
855   else
856     {
857       if (alloc_func)
858         m = (*alloc_func) (n);
859       else
860         m = _gcry_private_malloc (n);
861     }
862
863   if (!m)
864     {
865       /* Make sure that ERRNO has been set in case a user supplied
866          memory handler didn't it correctly. */
867       if (!errno)
868         gpg_err_set_errno (ENOMEM);
869       err = gpg_err_code_from_errno (errno);
870     }
871   else
872     *mem = m;
873
874   return err;
875 }
876
877 void *
878 gcry_malloc (size_t n)
879 {
880   void *mem = NULL;
881
882   do_malloc (n, 0, &mem);
883
884   return mem;
885 }
886
887 void *
888 gcry_malloc_secure (size_t n)
889 {
890   void *mem = NULL;
891
892   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
893
894   return mem;
895 }
896
897 int
898 gcry_is_secure (const void *a)
899 {
900   if (get_no_secure_memory ())
901     return 0;
902   if (is_secure_func)
903     return is_secure_func (a) ;
904   return _gcry_private_is_secure (a);
905 }
906
907 void
908 _gcry_check_heap( const void *a )
909 {
910   (void)a;
911
912     /* FIXME: implement this*/
913 #if 0
914     if( some_handler )
915         some_handler(a)
916     else
917         _gcry_private_check_heap(a)
918 #endif
919 }
920
921 void *
922 gcry_realloc (void *a, size_t n)
923 {
924   void *p;
925
926   /* To avoid problems with non-standard realloc implementations and
927      our own secmem_realloc, we divert to malloc and free here.  */
928   if (!a)
929     return gcry_malloc (n);
930   if (!n)
931     {
932       gcry_free (a);
933       return NULL;
934     }
935
936   if (realloc_func)
937     p = realloc_func (a, n);
938   else
939     p =  _gcry_private_realloc (a, n);
940   if (!p && !errno)
941     gpg_err_set_errno (ENOMEM);
942   return p;
943 }
944
945 void
946 gcry_free (void *p)
947 {
948   int save_errno;
949
950   if (!p)
951     return;
952
953   /* In case ERRNO is set we better save it so that the free machinery
954      may not accidently change ERRNO.  We restore it only if it was
955      already set to comply with the usual C semantic for ERRNO.  */
956   save_errno = errno;
957   if (free_func)
958     free_func (p);
959   else
960     _gcry_private_free (p);
961
962   if (save_errno)
963     gpg_err_set_errno (save_errno);
964 }
965
966 void *
967 gcry_calloc (size_t n, size_t m)
968 {
969   size_t bytes;
970   void *p;
971
972   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
973                     defined. */
974   if (m && bytes / m != n)
975     {
976       gpg_err_set_errno (ENOMEM);
977       return NULL;
978     }
979
980   p = gcry_malloc (bytes);
981   if (p)
982     memset (p, 0, bytes);
983   return p;
984 }
985
986 void *
987 gcry_calloc_secure (size_t n, size_t m)
988 {
989   size_t bytes;
990   void *p;
991
992   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
993                     defined. */
994   if (m && bytes / m != n)
995     {
996       gpg_err_set_errno (ENOMEM);
997       return NULL;
998     }
999
1000   p = gcry_malloc_secure (bytes);
1001   if (p)
1002     memset (p, 0, bytes);
1003   return p;
1004 }
1005
1006
1007 /* Create and return a copy of the null-terminated string STRING.  If
1008    it is contained in secure memory, the copy will be contained in
1009    secure memory as well.  In an out-of-memory condition, NULL is
1010    returned.  */
1011 char *
1012 gcry_strdup (const char *string)
1013 {
1014   char *string_cp = NULL;
1015   size_t string_n = 0;
1016
1017   string_n = strlen (string);
1018
1019   if (gcry_is_secure (string))
1020     string_cp = gcry_malloc_secure (string_n + 1);
1021   else
1022     string_cp = gcry_malloc (string_n + 1);
1023
1024   if (string_cp)
1025     strcpy (string_cp, string);
1026
1027   return string_cp;
1028 }
1029
1030
1031 void *
1032 gcry_xmalloc( size_t n )
1033 {
1034   void *p;
1035
1036   while ( !(p = gcry_malloc( n )) )
1037     {
1038       if ( fips_mode ()
1039            || !outofcore_handler
1040            || !outofcore_handler (outofcore_handler_value, n, 0) )
1041         {
1042           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
1043         }
1044     }
1045     return p;
1046 }
1047
1048 void *
1049 gcry_xrealloc( void *a, size_t n )
1050 {
1051   void *p;
1052
1053   while ( !(p = gcry_realloc( a, n )) )
1054     {
1055       if ( fips_mode ()
1056            || !outofcore_handler
1057            || !outofcore_handler (outofcore_handler_value, n,
1058                                    gcry_is_secure(a)? 3:2 ) )
1059         {
1060           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
1061         }
1062     }
1063     return p;
1064 }
1065
1066 void *
1067 gcry_xmalloc_secure( size_t n )
1068 {
1069   void *p;
1070
1071   while ( !(p = gcry_malloc_secure( n )) )
1072     {
1073       if ( fips_mode ()
1074            || !outofcore_handler
1075            || !outofcore_handler (outofcore_handler_value, n, 1) )
1076         {
1077           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1078                              _("out of core in secure memory"));
1079         }
1080     }
1081   return p;
1082 }
1083
1084
1085 void *
1086 gcry_xcalloc( size_t n, size_t m )
1087 {
1088   size_t nbytes;
1089   void *p;
1090
1091   nbytes = n * m;
1092   if (m && nbytes / m != n)
1093     {
1094       gpg_err_set_errno (ENOMEM);
1095       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1096     }
1097
1098   p = gcry_xmalloc ( nbytes );
1099   memset ( p, 0, nbytes );
1100   return p;
1101 }
1102
1103 void *
1104 gcry_xcalloc_secure( size_t n, size_t m )
1105 {
1106   size_t nbytes;
1107   void *p;
1108
1109   nbytes = n * m;
1110   if (m && nbytes / m != n)
1111     {
1112       gpg_err_set_errno (ENOMEM);
1113       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1114     }
1115
1116   p = gcry_xmalloc_secure ( nbytes );
1117   memset ( p, 0, nbytes );
1118   return p;
1119 }
1120
1121 char *
1122 gcry_xstrdup (const char *string)
1123 {
1124   char *p;
1125
1126   while ( !(p = gcry_strdup (string)) )
1127     {
1128       size_t n = strlen (string);
1129       int is_sec = !!gcry_is_secure (string);
1130
1131       if (fips_mode ()
1132           || !outofcore_handler
1133           || !outofcore_handler (outofcore_handler_value, n, is_sec) )
1134         {
1135           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1136                              is_sec? _("out of core in secure memory"):NULL);
1137         }
1138     }
1139
1140   return p;
1141 }
1142
1143
1144 int
1145 _gcry_get_debug_flag (unsigned int mask)
1146 {
1147   if ( fips_mode () )
1148     return 0;
1149   return (debug_flags & mask);
1150 }
1151
1152
1153 \f
1154 /* It is often useful to get some feedback of long running operations.
1155    This function may be used to register a handler for this.
1156    The callback function CB is used as:
1157
1158    void cb (void *opaque, const char *what, int printchar,
1159            int current, int total);
1160
1161    Where WHAT is a string identifying the the type of the progress
1162    output, PRINTCHAR the character usually printed, CURRENT the amount
1163    of progress currently done and TOTAL the expected amount of
1164    progress.  A value of 0 for TOTAL indicates that there is no
1165    estimation available.
1166
1167    Defined values for WHAT:
1168
1169    "need_entropy"  X    0  number-of-bytes-required
1170             When running low on entropy
1171    "primegen"      '\n'  0 0
1172            Prime generated
1173                    '!'
1174            Need to refresh the prime pool
1175                    '<','>'
1176            Number of bits adjusted
1177                    '^'
1178            Looking for a generator
1179                    '.'
1180            Fermat tests on 10 candidates failed
1181                   ':'
1182            Restart with a new random value
1183                   '+'
1184            Rabin Miller test passed
1185    "pk_elg"        '+','-','.','\n'   0  0
1186             Only used in debugging mode.
1187    "pk_dsa"
1188             Only used in debugging mode.
1189 */
1190 void
1191 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1192                            void *cb_data)
1193 {
1194 #if USE_DSA
1195   _gcry_register_pk_dsa_progress (cb, cb_data);
1196 #endif
1197 #if USE_ELGAMAL
1198   _gcry_register_pk_elg_progress (cb, cb_data);
1199 #endif
1200   _gcry_register_primegen_progress (cb, cb_data);
1201   _gcry_register_random_progress (cb, cb_data);
1202 }