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