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