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