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