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