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