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