4e2e274a37131abb4aa5d092a9b2a1ce486dd826
[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, 2017 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 (const char *what, gpgrt_stream_t fp)
277 {
278   int i;
279   const char *s;
280
281   if (!what || !strcmp (what, "version"))
282     {
283       gpgrt_fprintf (fp, "version:%s:%x:%s:%x:\n",
284                      VERSION, GCRYPT_VERSION_NUMBER,
285                      GPGRT_VERSION, GPGRT_VERSION_NUMBER);
286     }
287   if (!what || !strcmp (what, "cc"))
288     {
289       gpgrt_fprintf (fp, "cc:%d:%s:\n",
290 #if GPGRT_VERSION_NUMBER >= 0x011b00 /* 1.27 */
291                      GPGRT_GCC_VERSION
292 #else
293                      _GPG_ERR_GCC_VERSION /* Due to a bug in gpg-error.h.  */
294 #endif
295                      ,
296 #ifdef __clang__
297                      "clang:" __VERSION__
298 #elif __GNUC__
299                      "gcc:" __VERSION__
300 #else
301                      ":"
302 #endif
303                      );
304     }
305
306   if (!what || !strcmp (what, "ciphers"))
307     gpgrt_fprintf (fp, "ciphers:%s:\n", LIBGCRYPT_CIPHERS);
308   if (!what || !strcmp (what, "pubkeys"))
309     gpgrt_fprintf (fp, "pubkeys:%s:\n", LIBGCRYPT_PUBKEY_CIPHERS);
310   if (!what || !strcmp (what, "digests"))
311     gpgrt_fprintf (fp, "digests:%s:\n", LIBGCRYPT_DIGESTS);
312
313   if (!what || !strcmp (what, "rnd-mod"))
314     {
315       gpgrt_fprintf (fp, "rnd-mod:"
316 #if USE_RNDEGD
317                      "egd:"
318 #endif
319 #if USE_RNDLINUX
320                      "linux:"
321 #endif
322 #if USE_RNDUNIX
323                      "unix:"
324 #endif
325 #if USE_RNDW32
326                      "w32:"
327 #endif
328                      "\n");
329     }
330
331   if (!what || !strcmp (what, "cpu-arch"))
332     {
333       gpgrt_fprintf (fp, "cpu-arch:"
334 #if defined(HAVE_CPU_ARCH_X86)
335                      "x86"
336 #elif defined(HAVE_CPU_ARCH_ALPHA)
337                      "alpha"
338 #elif defined(HAVE_CPU_ARCH_SPARC)
339                      "sparc"
340 #elif defined(HAVE_CPU_ARCH_MIPS)
341                      "mips"
342 #elif defined(HAVE_CPU_ARCH_M68K)
343                      "m68k"
344 #elif defined(HAVE_CPU_ARCH_PPC)
345                      "ppc"
346 #elif defined(HAVE_CPU_ARCH_ARM)
347                      "arm"
348 #endif
349                      ":\n");
350     }
351
352   if (!what || !strcmp (what, "mpi-asm"))
353     gpgrt_fprintf (fp, "mpi-asm:%s:\n", _gcry_mpi_get_hw_config ());
354
355   if (!what || !strcmp (what, "hwflist"))
356     {
357       unsigned int hwfeatures, afeature;
358
359       hwfeatures = _gcry_get_hw_features ();
360       gpgrt_fprintf (fp, "hwflist:");
361       for (i=0; (s = _gcry_enum_hw_features (i, &afeature)); i++)
362         if ((hwfeatures & afeature))
363           gpgrt_fprintf (fp, "%s:", s);
364       gpgrt_fprintf (fp, "\n");
365     }
366
367   if (!what || !strcmp (what, "fips-mode"))
368     {
369       /* We use y/n instead of 1/0 for the stupid reason that
370        * Emacsen's compile error parser would accidentally flag that
371        * line when printed during "make check" as an error.  */
372       gpgrt_fprintf (fp, "fips-mode:%c:%c:\n",
373                      fips_mode ()? 'y':'n',
374                      _gcry_enforced_fips_mode ()? 'y':'n' );
375     }
376
377   if (!what || !strcmp (what, "rng-type"))
378     {
379       /* The currently used RNG type.  */
380       unsigned int jver;
381       int active;
382
383       i = _gcry_get_rng_type (0);
384       switch (i)
385         {
386         case GCRY_RNG_TYPE_STANDARD: s = "standard"; break;
387         case GCRY_RNG_TYPE_FIPS:     s = "fips"; break;
388         case GCRY_RNG_TYPE_SYSTEM:   s = "system"; break;
389         default: BUG ();
390         }
391       jver = _gcry_rndjent_get_version (&active);
392       gpgrt_fprintf (fp, "rng-type:%s:%d:%u:%d:\n", s, i, jver, active);
393     }
394 }
395
396
397 /* With a MODE of 0 return a malloced string with configured features.
398  * In that case a WHAT of NULL returns everything in the same way
399  * GCRYCTL_PRINT_CONFIG would do.  With a specific WHAT string only
400  * the requested feature is returned (w/o the trailing LF.  On error
401  * NULL is returned.  */
402 char *
403 _gcry_get_config (int mode, const char *what)
404 {
405   gpgrt_stream_t fp;
406   int save_errno;
407   void *data;
408   char *p;
409
410   if (mode)
411     {
412       gpg_err_set_errno (EINVAL);
413       return NULL;
414     }
415
416   fp = gpgrt_fopenmem (0, "w+b,samethread");
417   if (!fp)
418     return NULL;
419
420   print_config (what, fp);
421   if (gpgrt_ferror (fp))
422     {
423       save_errno = errno;
424       gpgrt_fclose (fp);
425       gpg_err_set_errno (save_errno);
426       return NULL;
427     }
428
429   gpgrt_rewind (fp);
430   if (gpgrt_fclose_snatch (fp, &data, NULL))
431     {
432       save_errno = errno;
433       gpgrt_fclose (fp);
434       gpg_err_set_errno (save_errno);
435       return NULL;
436     }
437
438   if (!data)
439     {
440       /* Nothing was printed (unknown value for WHAT).  This is okay,
441        * so clear ERRNO to indicate this. */
442       gpg_err_set_errno (0);
443       return NULL;
444     }
445
446   /* Strip trailing LF.  */
447   if (what && (p = strchr (data, '\n')))
448     *p = 0;
449
450   return data;
451 }
452
453
454 \f
455
456 /* Command dispatcher function, acting as general control
457    function.  */
458 gcry_err_code_t
459 _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr)
460 {
461   static int init_finished = 0;
462   gcry_err_code_t rc = 0;
463
464   switch (cmd)
465     {
466     case GCRYCTL_ENABLE_M_GUARD:
467       _gcry_private_enable_m_guard ();
468       break;
469
470     case GCRYCTL_ENABLE_QUICK_RANDOM:
471       _gcry_set_preferred_rng_type (0);
472       _gcry_enable_quick_random_gen ();
473       break;
474
475     case GCRYCTL_FAKED_RANDOM_P:
476       /* Return an error if the RNG is faked one (e.g. enabled by
477          ENABLE_QUICK_RANDOM. */
478       if (_gcry_random_is_faked ())
479         rc = GPG_ERR_GENERAL;  /* Use as TRUE value.  */
480       break;
481
482     case GCRYCTL_DUMP_RANDOM_STATS:
483       _gcry_random_dump_stats ();
484       break;
485
486     case GCRYCTL_DUMP_MEMORY_STATS:
487       /*m_print_stats("[fixme: prefix]");*/
488       break;
489
490     case GCRYCTL_DUMP_SECMEM_STATS:
491       _gcry_secmem_dump_stats (0);
492       break;
493
494     case GCRYCTL_DROP_PRIVS:
495       global_init ();
496       _gcry_secmem_init (0);
497       break;
498
499     case GCRYCTL_DISABLE_SECMEM:
500       global_init ();
501       no_secure_memory = 1;
502       break;
503
504     case GCRYCTL_INIT_SECMEM:
505       global_init ();
506       _gcry_secmem_init (va_arg (arg_ptr, unsigned int));
507       if ((_gcry_secmem_get_flags () & GCRY_SECMEM_FLAG_NOT_LOCKED))
508         rc = GPG_ERR_GENERAL;
509       break;
510
511     case GCRYCTL_TERM_SECMEM:
512       global_init ();
513       _gcry_secmem_term ();
514       break;
515
516     case GCRYCTL_DISABLE_SECMEM_WARN:
517       _gcry_set_preferred_rng_type (0);
518       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
519                                | GCRY_SECMEM_FLAG_NO_WARNING));
520       break;
521
522     case GCRYCTL_SUSPEND_SECMEM_WARN:
523       _gcry_set_preferred_rng_type (0);
524       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
525                                | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
526       break;
527
528     case GCRYCTL_RESUME_SECMEM_WARN:
529       _gcry_set_preferred_rng_type (0);
530       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
531                                & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
532       break;
533
534     case GCRYCTL_USE_SECURE_RNDPOOL:
535       global_init ();
536       _gcry_secure_random_alloc (); /* Put random number into secure memory. */
537       break;
538
539     case GCRYCTL_SET_RANDOM_SEED_FILE:
540       _gcry_set_preferred_rng_type (0);
541       _gcry_set_random_seed_file (va_arg (arg_ptr, const char *));
542       break;
543
544     case GCRYCTL_UPDATE_RANDOM_SEED_FILE:
545       _gcry_set_preferred_rng_type (0);
546       if ( fips_is_operational () )
547         _gcry_update_random_seed_file ();
548       break;
549
550     case GCRYCTL_SET_VERBOSITY:
551       _gcry_set_preferred_rng_type (0);
552       _gcry_set_log_verbosity (va_arg (arg_ptr, int));
553       break;
554
555     case GCRYCTL_SET_DEBUG_FLAGS:
556       debug_flags |= va_arg (arg_ptr, unsigned int);
557       break;
558
559     case GCRYCTL_CLEAR_DEBUG_FLAGS:
560       debug_flags &= ~va_arg (arg_ptr, unsigned int);
561       break;
562
563     case GCRYCTL_DISABLE_INTERNAL_LOCKING:
564       /* Not used anymore.  */
565       global_init ();
566       break;
567
568     case GCRYCTL_ANY_INITIALIZATION_P:
569       if (any_init_done)
570         rc = GPG_ERR_GENERAL;
571       break;
572
573     case GCRYCTL_INITIALIZATION_FINISHED_P:
574       if (init_finished)
575         rc = GPG_ERR_GENERAL; /* Yes.  */
576       break;
577
578     case GCRYCTL_INITIALIZATION_FINISHED:
579       /* This is a hook which should be used by an application after
580          all initialization has been done and right before any threads
581          are started.  It is not really needed but the only way to be
582          really sure that all initialization for thread-safety has
583          been done. */
584       if (! init_finished)
585         {
586           global_init ();
587           /* Do only a basic random initialization, i.e. init the
588              mutexes. */
589           _gcry_random_initialize (0);
590           init_finished = 1;
591           /* Force us into operational state if in FIPS mode.  */
592           (void)fips_is_operational ();
593         }
594       break;
595
596     case GCRYCTL_SET_THREAD_CBS:
597       /* This is now a dummy call.  We used to install our own thread
598          library here. */
599       _gcry_set_preferred_rng_type (0);
600       global_init ();
601       break;
602
603     case GCRYCTL_FAST_POLL:
604       _gcry_set_preferred_rng_type (0);
605       /* We need to do make sure that the random pool is really
606          initialized so that the poll function is not a NOP. */
607       _gcry_random_initialize (1);
608
609       if ( fips_is_operational () )
610         _gcry_fast_random_poll ();
611       break;
612
613     case GCRYCTL_SET_RNDEGD_SOCKET:
614 #if USE_RNDEGD
615       _gcry_set_preferred_rng_type (0);
616       rc = _gcry_rndegd_set_socket_name (va_arg (arg_ptr, const char *));
617 #else
618       rc = GPG_ERR_NOT_SUPPORTED;
619 #endif
620       break;
621
622     case GCRYCTL_SET_RANDOM_DAEMON_SOCKET:
623       _gcry_set_preferred_rng_type (0);
624       _gcry_set_random_daemon_socket (va_arg (arg_ptr, const char *));
625       break;
626
627     case GCRYCTL_USE_RANDOM_DAEMON:
628       /* We need to do make sure that the random pool is really
629          initialized so that the poll function is not a NOP. */
630       _gcry_set_preferred_rng_type (0);
631       _gcry_random_initialize (1);
632       _gcry_use_random_daemon (!! va_arg (arg_ptr, int));
633       break;
634
635     case GCRYCTL_CLOSE_RANDOM_DEVICE:
636       _gcry_random_close_fds ();
637       break;
638
639       /* This command dumps information pertaining to the
640          configuration of libgcrypt to the given stream.  It may be
641          used before the initialization has been finished but not
642          before a gcry_version_check.  See also gcry_get_config.  */
643     case GCRYCTL_PRINT_CONFIG:
644       {
645         FILE *fp = va_arg (arg_ptr, FILE *);
646         char *tmpstr;
647         _gcry_set_preferred_rng_type (0);
648         tmpstr = _gcry_get_config (0, NULL);
649         if (tmpstr)
650           {
651             if (fp)
652               fputs (tmpstr, fp);
653             else
654               log_info ("%s", tmpstr);
655             xfree (tmpstr);
656           }
657       }
658       break;
659
660     case GCRYCTL_OPERATIONAL_P:
661       /* Returns true if the library is in an operational state.  This
662          is always true for non-fips mode.  */
663       _gcry_set_preferred_rng_type (0);
664       if (_gcry_fips_test_operational ())
665         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
666       break;
667
668     case GCRYCTL_FIPS_MODE_P:
669       if (fips_mode ()
670           && !_gcry_is_fips_mode_inactive ()
671           && !no_secure_memory)
672         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
673       break;
674
675     case GCRYCTL_FORCE_FIPS_MODE:
676       /* Performing this command puts the library into fips mode.  If
677          the library has already been initialized into fips mode, a
678          selftest is triggered.  It is not possible to put the libraty
679          into fips mode after having passed the initialization. */
680       _gcry_set_preferred_rng_type (0);
681       if (!any_init_done)
682         {
683           /* Not yet initialized at all.  Set a flag so that we are put
684              into fips mode during initialization.  */
685           force_fips_mode = 1;
686         }
687       else
688         {
689           /* Already initialized.  If we are already operational we
690              run a selftest.  If not we use the is_operational call to
691              force us into operational state if possible.  */
692           if (_gcry_fips_test_error_or_operational ())
693             _gcry_fips_run_selftests (1);
694           if (_gcry_fips_is_operational ())
695             rc = GPG_ERR_GENERAL; /* Used as TRUE value */
696       }
697       break;
698
699     case GCRYCTL_SELFTEST:
700       /* Run a selftest.  This works in fips mode as well as in
701          standard mode.  In contrast to the power-up tests, we use an
702          extended version of the selftests. Returns 0 on success or an
703          error code. */
704       global_init ();
705       rc = _gcry_fips_run_selftests (1);
706       break;
707
708 #if _GCRY_GCC_VERSION >= 40600
709 # pragma GCC diagnostic push
710 # pragma GCC diagnostic ignored "-Wswitch"
711 #endif
712     case PRIV_CTL_INIT_EXTRNG_TEST:  /* Init external random test.  */
713       rc = GPG_ERR_NOT_SUPPORTED;
714       break;
715     case PRIV_CTL_RUN_EXTRNG_TEST:  /* Run external DRBG test.  */
716       {
717         struct gcry_drbg_test_vector *test =
718           va_arg (arg_ptr, struct gcry_drbg_test_vector *);
719         unsigned char *buf = va_arg (arg_ptr, unsigned char *);
720
721         if (buf)
722           rc = _gcry_rngdrbg_cavs_test (test, buf);
723         else
724           rc = _gcry_rngdrbg_healthcheck_one (test);
725       }
726       break;
727     case PRIV_CTL_DEINIT_EXTRNG_TEST:  /* Deinit external random test.  */
728       rc = GPG_ERR_NOT_SUPPORTED;
729       break;
730     case PRIV_CTL_EXTERNAL_LOCK_TEST:  /* Run external lock test */
731       rc = external_lock_test (va_arg (arg_ptr, int));
732       break;
733     case PRIV_CTL_DUMP_SECMEM_STATS:
734       _gcry_secmem_dump_stats (1);
735       break;
736 #if _GCRY_GCC_VERSION >= 40600
737 # pragma GCC diagnostic pop
738 #endif
739
740     case GCRYCTL_DISABLE_HWF:
741       {
742         const char *name = va_arg (arg_ptr, const char *);
743         rc = _gcry_disable_hw_feature (name);
744       }
745       break;
746
747     case GCRYCTL_SET_ENFORCED_FIPS_FLAG:
748       if (!any_init_done)
749         {
750           /* Not yet initialized at all.  Set the enforced fips mode flag */
751           _gcry_set_preferred_rng_type (0);
752           _gcry_set_enforced_fips_mode ();
753         }
754       else
755         rc = GPG_ERR_GENERAL;
756       break;
757
758     case GCRYCTL_SET_PREFERRED_RNG_TYPE:
759       /* This may be called before gcry_check_version.  */
760       {
761         int i = va_arg (arg_ptr, int);
762         /* Note that we may not pass 0 to _gcry_set_preferred_rng_type.  */
763         if (i > 0)
764           _gcry_set_preferred_rng_type (i);
765       }
766       break;
767
768     case GCRYCTL_GET_CURRENT_RNG_TYPE:
769       {
770         int *ip = va_arg (arg_ptr, int*);
771         if (ip)
772           *ip = _gcry_get_rng_type (!any_init_done);
773       }
774       break;
775
776     case GCRYCTL_DISABLE_LOCKED_SECMEM:
777       _gcry_set_preferred_rng_type (0);
778       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
779                                | GCRY_SECMEM_FLAG_NO_MLOCK));
780       break;
781
782     case GCRYCTL_DISABLE_PRIV_DROP:
783       _gcry_set_preferred_rng_type (0);
784       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
785                                | GCRY_SECMEM_FLAG_NO_PRIV_DROP));
786       break;
787
788     case GCRYCTL_INACTIVATE_FIPS_FLAG:
789     case GCRYCTL_REACTIVATE_FIPS_FLAG:
790       rc = GPG_ERR_NOT_IMPLEMENTED;
791       break;
792
793     case GCRYCTL_DRBG_REINIT:
794       {
795         const char *flagstr = va_arg (arg_ptr, const char *);
796         gcry_buffer_t *pers = va_arg (arg_ptr, gcry_buffer_t *);
797         int npers = va_arg (arg_ptr, int);
798         if (va_arg (arg_ptr, void *) || npers < 0)
799           rc = GPG_ERR_INV_ARG;
800         else if (_gcry_get_rng_type (!any_init_done) != GCRY_RNG_TYPE_FIPS)
801           rc = GPG_ERR_NOT_SUPPORTED;
802         else
803           rc = _gcry_rngdrbg_reinit (flagstr, pers, npers);
804       }
805       break;
806
807     case GCRYCTL_REINIT_SYSCALL_CLAMP:
808       if (!pre_syscall_func)
809         gpgrt_get_syscall_clamp (&pre_syscall_func, &post_syscall_func);
810       break;
811
812     default:
813       _gcry_set_preferred_rng_type (0);
814       rc = GPG_ERR_INV_OP;
815     }
816
817   return rc;
818 }
819
820
821
822 /* Set custom allocation handlers.  This is in general not useful
823  * because the libgcrypt allocation functions are guaranteed to
824  * provide proper allocation handlers which zeroize memory if needed.
825  * NOTE: All 5 functions should be set.  */
826 void
827 _gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
828                               gcry_handler_alloc_t new_alloc_secure_func,
829                               gcry_handler_secure_check_t new_is_secure_func,
830                               gcry_handler_realloc_t new_realloc_func,
831                               gcry_handler_free_t new_free_func)
832 {
833   global_init ();
834
835   if (fips_mode ())
836     {
837       /* We do not want to enforce the fips mode, but merely set a
838          flag so that the application may check whether it is still in
839          fips mode.  */
840       _gcry_inactivate_fips_mode ("custom allocation handler");
841     }
842
843   alloc_func = new_alloc_func;
844   alloc_secure_func = new_alloc_secure_func;
845   is_secure_func = new_is_secure_func;
846   realloc_func = new_realloc_func;
847   free_func = new_free_func;
848 }
849
850
851
852 /****************
853  * Set an optional handler which is called in case the xmalloc functions
854  * ran out of memory.  This handler may do one of these things:
855  *   o free some memory and return true, so that the xmalloc function
856  *     tries again.
857  *   o Do whatever it like and return false, so that the xmalloc functions
858  *     use the default fatal error handler.
859  *   o Terminate the program and don't return.
860  *
861  * The handler function is called with 3 arguments:  The opaque value set with
862  * this function, the requested memory size, and a flag with these bits
863  * currently defined:
864  *      bit 0 set = secure memory has been requested.
865  */
866 void
867 _gcry_set_outofcore_handler (int (*f)(void*, size_t, unsigned int), void *value)
868 {
869   global_init ();
870
871   if (fips_mode () )
872     {
873       log_info ("out of core handler ignored in FIPS mode\n");
874       return;
875     }
876
877   outofcore_handler = f;
878   outofcore_handler_value = value;
879 }
880
881 /* Return the no_secure_memory flag.  */
882 static int
883 get_no_secure_memory (void)
884 {
885   if (!no_secure_memory)
886     return 0;
887   if (_gcry_enforced_fips_mode ())
888     {
889       no_secure_memory = 0;
890       return 0;
891     }
892   return no_secure_memory;
893 }
894
895
896 static gcry_err_code_t
897 do_malloc (size_t n, unsigned int flags, void **mem)
898 {
899   gcry_err_code_t err = 0;
900   void *m;
901
902   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
903     {
904       if (alloc_secure_func)
905         m = (*alloc_secure_func) (n);
906       else
907         m = _gcry_private_malloc_secure (n, !!(flags & GCRY_ALLOC_FLAG_XHINT));
908     }
909   else
910     {
911       if (alloc_func)
912         m = (*alloc_func) (n);
913       else
914         m = _gcry_private_malloc (n);
915     }
916
917   if (!m)
918     {
919       /* Make sure that ERRNO has been set in case a user supplied
920          memory handler didn't it correctly. */
921       if (!errno)
922         gpg_err_set_errno (ENOMEM);
923       err = gpg_err_code_from_errno (errno);
924     }
925   else
926     *mem = m;
927
928   return err;
929 }
930
931 void *
932 _gcry_malloc (size_t n)
933 {
934   void *mem = NULL;
935
936   do_malloc (n, 0, &mem);
937
938   return mem;
939 }
940
941 static void *
942 _gcry_malloc_secure_core (size_t n, int xhint)
943 {
944   void *mem = NULL;
945
946   do_malloc (n, (GCRY_ALLOC_FLAG_SECURE | (xhint? GCRY_ALLOC_FLAG_XHINT:0)),
947              &mem);
948
949   return mem;
950 }
951
952 void *
953 _gcry_malloc_secure (size_t n)
954 {
955   return _gcry_malloc_secure_core (n, 0);
956 }
957
958 int
959 _gcry_is_secure (const void *a)
960 {
961   if (get_no_secure_memory ())
962     return 0;
963   if (is_secure_func)
964     return is_secure_func (a) ;
965   return _gcry_private_is_secure (a);
966 }
967
968 void
969 _gcry_check_heap( const void *a )
970 {
971   (void)a;
972
973     /* FIXME: implement this*/
974 #if 0
975     if( some_handler )
976         some_handler(a)
977     else
978         _gcry_private_check_heap(a)
979 #endif
980 }
981
982 static void *
983 _gcry_realloc_core (void *a, size_t n, int xhint)
984 {
985   void *p;
986
987   /* To avoid problems with non-standard realloc implementations and
988      our own secmem_realloc, we divert to malloc and free here.  */
989   if (!a)
990     return _gcry_malloc (n);
991   if (!n)
992     {
993       xfree (a);
994       return NULL;
995     }
996
997   if (realloc_func)
998     p = realloc_func (a, n);
999   else
1000     p =  _gcry_private_realloc (a, n, xhint);
1001   if (!p && !errno)
1002     gpg_err_set_errno (ENOMEM);
1003   return p;
1004 }
1005
1006
1007 void *
1008 _gcry_realloc (void *a, size_t n)
1009 {
1010   return _gcry_realloc_core (a, n, 0);
1011 }
1012
1013
1014 void
1015 _gcry_free (void *p)
1016 {
1017   int save_errno;
1018
1019   if (!p)
1020     return;
1021
1022   /* In case ERRNO is set we better save it so that the free machinery
1023      may not accidentally change ERRNO.  We restore it only if it was
1024      already set to comply with the usual C semantic for ERRNO.  */
1025   save_errno = errno;
1026   if (free_func)
1027     free_func (p);
1028   else
1029     _gcry_private_free (p);
1030
1031   if (save_errno)
1032     gpg_err_set_errno (save_errno);
1033 }
1034
1035 void *
1036 _gcry_calloc (size_t n, size_t m)
1037 {
1038   size_t bytes;
1039   void *p;
1040
1041   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
1042                     defined. */
1043   if (m && bytes / m != n)
1044     {
1045       gpg_err_set_errno (ENOMEM);
1046       return NULL;
1047     }
1048
1049   p = _gcry_malloc (bytes);
1050   if (p)
1051     memset (p, 0, bytes);
1052   return p;
1053 }
1054
1055 void *
1056 _gcry_calloc_secure (size_t n, size_t m)
1057 {
1058   size_t bytes;
1059   void *p;
1060
1061   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
1062                     defined. */
1063   if (m && bytes / m != n)
1064     {
1065       gpg_err_set_errno (ENOMEM);
1066       return NULL;
1067     }
1068
1069   p = _gcry_malloc_secure (bytes);
1070   if (p)
1071     memset (p, 0, bytes);
1072   return p;
1073 }
1074
1075
1076 static char *
1077 _gcry_strdup_core (const char *string, int xhint)
1078 {
1079   char *string_cp = NULL;
1080   size_t string_n = 0;
1081
1082   string_n = strlen (string);
1083
1084   if (_gcry_is_secure (string))
1085     string_cp = _gcry_malloc_secure_core (string_n + 1, xhint);
1086   else
1087     string_cp = _gcry_malloc (string_n + 1);
1088
1089   if (string_cp)
1090     strcpy (string_cp, string);
1091
1092   return string_cp;
1093 }
1094
1095 /* Create and return a copy of the null-terminated string STRING.  If
1096  * it is contained in secure memory, the copy will be contained in
1097  * secure memory as well.  In an out-of-memory condition, NULL is
1098  * returned.  */
1099 char *
1100 _gcry_strdup (const char *string)
1101 {
1102   return _gcry_strdup_core (string, 0);
1103 }
1104
1105 void *
1106 _gcry_xmalloc( size_t n )
1107 {
1108   void *p;
1109
1110   while ( !(p = _gcry_malloc( n )) )
1111     {
1112       if ( fips_mode ()
1113            || !outofcore_handler
1114            || !outofcore_handler (outofcore_handler_value, n, 0) )
1115         {
1116           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
1117         }
1118     }
1119     return p;
1120 }
1121
1122 void *
1123 _gcry_xrealloc( void *a, size_t n )
1124 {
1125   void *p;
1126
1127   while (!(p = _gcry_realloc_core (a, n, 1)))
1128     {
1129       if ( fips_mode ()
1130            || !outofcore_handler
1131            || !outofcore_handler (outofcore_handler_value, n,
1132                                   _gcry_is_secure(a)? 3:2))
1133         {
1134           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
1135         }
1136     }
1137     return p;
1138 }
1139
1140 void *
1141 _gcry_xmalloc_secure( size_t n )
1142 {
1143   void *p;
1144
1145   while (!(p = _gcry_malloc_secure_core (n, 1)))
1146     {
1147       if ( fips_mode ()
1148            || !outofcore_handler
1149            || !outofcore_handler (outofcore_handler_value, n, 1) )
1150         {
1151           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1152                              _("out of core in secure memory"));
1153         }
1154     }
1155   return p;
1156 }
1157
1158
1159 void *
1160 _gcry_xcalloc( size_t n, size_t m )
1161 {
1162   size_t nbytes;
1163   void *p;
1164
1165   nbytes = n * m;
1166   if (m && nbytes / m != n)
1167     {
1168       gpg_err_set_errno (ENOMEM);
1169       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1170     }
1171
1172   p = _gcry_xmalloc ( nbytes );
1173   memset ( p, 0, nbytes );
1174   return p;
1175 }
1176
1177 void *
1178 _gcry_xcalloc_secure( size_t n, size_t m )
1179 {
1180   size_t nbytes;
1181   void *p;
1182
1183   nbytes = n * m;
1184   if (m && nbytes / m != n)
1185     {
1186       gpg_err_set_errno (ENOMEM);
1187       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1188     }
1189
1190   p = _gcry_xmalloc_secure ( nbytes );
1191   memset ( p, 0, nbytes );
1192   return p;
1193 }
1194
1195 char *
1196 _gcry_xstrdup (const char *string)
1197 {
1198   char *p;
1199
1200   while ( !(p = _gcry_strdup_core (string, 1)) )
1201     {
1202       size_t n = strlen (string);
1203       int is_sec = !!_gcry_is_secure (string);
1204
1205       if (fips_mode ()
1206           || !outofcore_handler
1207           || !outofcore_handler (outofcore_handler_value, n, is_sec) )
1208         {
1209           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1210                              is_sec? _("out of core in secure memory"):NULL);
1211         }
1212     }
1213
1214   return p;
1215 }
1216
1217
1218 /* Used before blocking system calls.  */
1219 void
1220 _gcry_pre_syscall (void)
1221 {
1222   if (pre_syscall_func)
1223     pre_syscall_func ();
1224 }
1225
1226
1227 /* Used after blocking system calls.  */
1228 void
1229 _gcry_post_syscall (void)
1230 {
1231   if (post_syscall_func)
1232     post_syscall_func ();
1233 }
1234
1235
1236 int
1237 _gcry_get_debug_flag (unsigned int mask)
1238 {
1239   if ( fips_mode () )
1240     return 0;
1241   return (debug_flags & mask);
1242 }
1243
1244
1245 \f
1246 /* It is often useful to get some feedback of long running operations.
1247    This function may be used to register a handler for this.
1248    The callback function CB is used as:
1249
1250    void cb (void *opaque, const char *what, int printchar,
1251            int current, int total);
1252
1253    Where WHAT is a string identifying the the type of the progress
1254    output, PRINTCHAR the character usually printed, CURRENT the amount
1255    of progress currently done and TOTAL the expected amount of
1256    progress.  A value of 0 for TOTAL indicates that there is no
1257    estimation available.
1258
1259    Defined values for WHAT:
1260
1261    "need_entropy"  X    0  number-of-bytes-required
1262             When running low on entropy
1263    "primegen"      '\n'  0 0
1264            Prime generated
1265                    '!'
1266            Need to refresh the prime pool
1267                    '<','>'
1268            Number of bits adjusted
1269                    '^'
1270            Looking for a generator
1271                    '.'
1272            Fermat tests on 10 candidates failed
1273                   ':'
1274            Restart with a new random value
1275                   '+'
1276            Rabin Miller test passed
1277    "pk_elg"        '+','-','.','\n'   0  0
1278             Only used in debugging mode.
1279    "pk_dsa"
1280             Only used in debugging mode.
1281 */
1282 void
1283 _gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1284                             void *cb_data)
1285 {
1286 #if USE_DSA
1287   _gcry_register_pk_dsa_progress (cb, cb_data);
1288 #endif
1289 #if USE_ELGAMAL
1290   _gcry_register_pk_elg_progress (cb, cb_data);
1291 #endif
1292   _gcry_register_primegen_progress (cb, cb_data);
1293   _gcry_register_random_progress (cb, cb_data);
1294 }
1295
1296
1297 \f
1298 /* This is a helper for the regression test suite to test Libgcrypt's locks.
1299    It works using a one test lock with CMD controlling what to do:
1300
1301      30111 - Allocate and init lock
1302      30112 - Take lock
1303      30113 - Release lock
1304      30114 - Destroy lock.
1305
1306    This function is used by tests/t-lock.c - it is not part of the
1307    public API!
1308  */
1309 static gpg_err_code_t
1310 external_lock_test (int cmd)
1311 {
1312   GPGRT_LOCK_DEFINE (testlock);
1313   gpg_err_code_t rc = 0;
1314
1315   switch (cmd)
1316     {
1317     case 30111:  /* Init Lock.  */
1318       rc = gpgrt_lock_init (&testlock);
1319       break;
1320
1321     case 30112:  /* Take Lock.  */
1322       rc = gpgrt_lock_lock (&testlock);
1323       break;
1324
1325     case 30113:  /* Release Lock.  */
1326       rc = gpgrt_lock_unlock (&testlock);
1327       break;
1328
1329     case 30114:  /* Destroy Lock.  */
1330       rc = gpgrt_lock_destroy (&testlock);
1331       break;
1332
1333     default:
1334       rc = GPG_ERR_INV_OP;
1335       break;
1336     }
1337
1338   return rc;
1339 }