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