8521e589f116464d1bbaf8ecbbd7208a75cdb2b2
[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       /* This command dumps information pertaining to the
544          configuration of libgcrypt to the given stream.  It may be
545          used before the initialization has been finished but not
546          before a gcry_version_check. */
547     case GCRYCTL_PRINT_CONFIG:
548       {
549         FILE *fp = va_arg (arg_ptr, FILE *);
550         _gcry_set_preferred_rng_type (0);
551         print_config (fp?fprintf:_gcry_log_info_with_dummy_fp, fp);
552       }
553       break;
554
555     case GCRYCTL_OPERATIONAL_P:
556       /* Returns true if the library is in an operational state.  This
557          is always true for non-fips mode.  */
558       _gcry_set_preferred_rng_type (0);
559       if (_gcry_fips_test_operational ())
560         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
561       break;
562
563     case GCRYCTL_FIPS_MODE_P:
564       if (fips_mode ()
565           && !_gcry_is_fips_mode_inactive ()
566           && !no_secure_memory)
567         rc = GPG_ERR_GENERAL; /* Used as TRUE value */
568       break;
569
570     case GCRYCTL_FORCE_FIPS_MODE:
571       /* Performing this command puts the library into fips mode.  If
572          the library has already been initialized into fips mode, a
573          selftest is triggered.  It is not possible to put the libraty
574          into fips mode after having passed the initialization. */
575       _gcry_set_preferred_rng_type (0);
576       if (!any_init_done)
577         {
578           /* Not yet intialized at all.  Set a flag so that we are put
579              into fips mode during initialization.  */
580           force_fips_mode = 1;
581         }
582       else
583         {
584           /* Already initialized.  If we are already operational we
585              run a selftest.  If not we use the is_operational call to
586              force us into operational state if possible.  */
587           if (_gcry_fips_test_error_or_operational ())
588             _gcry_fips_run_selftests (1);
589           if (_gcry_fips_is_operational ())
590             rc = GPG_ERR_GENERAL; /* Used as TRUE value */
591       }
592       break;
593
594     case GCRYCTL_SELFTEST:
595       /* Run a selftest.  This works in fips mode as well as in
596          standard mode.  In contrast to the power-up tests, we use an
597          extended version of the selftests. Returns 0 on success or an
598          error code. */
599       global_init ();
600       rc = _gcry_fips_run_selftests (1);
601       break;
602
603 #if _GCRY_GCC_VERSION >= 40600
604 # pragma GCC diagnostic push
605 # pragma GCC diagnostic ignored "-Wswitch"
606 #endif
607     case 58:  /* Init external random test.  */
608       {
609         void **rctx        = va_arg (arg_ptr, void **);
610         unsigned int flags = va_arg (arg_ptr, unsigned int);
611         const void *key    = va_arg (arg_ptr, const void *);
612         size_t keylen      = va_arg (arg_ptr, size_t);
613         const void *seed   = va_arg (arg_ptr, const void *);
614         size_t seedlen     = va_arg (arg_ptr, size_t);
615         const void *dt     = va_arg (arg_ptr, const void *);
616         size_t dtlen       = va_arg (arg_ptr, size_t);
617         if (!fips_is_operational ())
618           rc = fips_not_operational ();
619         else
620           rc = _gcry_random_init_external_test (rctx, flags, key, keylen,
621                                                 seed, seedlen, dt, dtlen);
622       }
623       break;
624     case 59:  /* Run external random test.  */
625       {
626         void *ctx     = va_arg (arg_ptr, void *);
627         void *buffer  = va_arg (arg_ptr, void *);
628         size_t buflen = va_arg (arg_ptr, size_t);
629         if (!fips_is_operational ())
630           rc = fips_not_operational ();
631         else
632           rc = _gcry_random_run_external_test (ctx, buffer, buflen);
633       }
634       break;
635     case 60:  /* Deinit external random test.  */
636       {
637         void *ctx = va_arg (arg_ptr, void *);
638         _gcry_random_deinit_external_test (ctx);
639       }
640       break;
641     case 61:  /* RFU */
642       break;
643     case 62:  /* RFU */
644       break;
645 #if _GCRY_GCC_VERSION >= 40600
646 # pragma GCC diagnostic pop
647 #endif
648
649     case GCRYCTL_DISABLE_HWF:
650       {
651         const char *name = va_arg (arg_ptr, const char *);
652         int i;
653
654         for (i=0; hwflist[i].desc; i++)
655           if (!strcmp (hwflist[i].desc, name))
656             {
657               disabled_hw_features |= hwflist[i].flag;
658               break;
659             }
660         if (!hwflist[i].desc)
661           rc = GPG_ERR_INV_NAME;
662       }
663       break;
664
665     case GCRYCTL_SET_ENFORCED_FIPS_FLAG:
666       if (!any_init_done)
667         {
668           /* Not yet initialized at all.  Set the enforced fips mode flag */
669           _gcry_set_preferred_rng_type (0);
670           _gcry_set_enforced_fips_mode ();
671         }
672       else
673         rc = GPG_ERR_GENERAL;
674       break;
675
676     case GCRYCTL_SET_PREFERRED_RNG_TYPE:
677       /* This may be called before gcry_check_version.  */
678       {
679         int i = va_arg (arg_ptr, int);
680         /* Note that we may not pass 0 to _gcry_set_preferred_rng_type.  */
681         if (i > 0)
682           _gcry_set_preferred_rng_type (i);
683       }
684       break;
685
686     case GCRYCTL_GET_CURRENT_RNG_TYPE:
687       {
688         int *ip = va_arg (arg_ptr, int*);
689         if (ip)
690           *ip = _gcry_get_rng_type (!any_init_done);
691       }
692       break;
693
694     case GCRYCTL_DISABLE_LOCKED_SECMEM:
695       _gcry_set_preferred_rng_type (0);
696       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
697                                | GCRY_SECMEM_FLAG_NO_MLOCK));
698       break;
699
700     case GCRYCTL_DISABLE_PRIV_DROP:
701       _gcry_set_preferred_rng_type (0);
702       _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
703                                | GCRY_SECMEM_FLAG_NO_PRIV_DROP));
704       break;
705
706     default:
707       _gcry_set_preferred_rng_type (0);
708       rc = GPG_ERR_INV_OP;
709     }
710
711   return rc;
712 }
713
714
715
716 /* Set custom allocation handlers.  This is in general not useful
717  * because the libgcrypt allocation functions are guaranteed to
718  * provide proper allocation handlers which zeroize memory if needed.
719  * NOTE: All 5 functions should be set.  */
720 void
721 _gcry_set_allocation_handler (gcry_handler_alloc_t new_alloc_func,
722                               gcry_handler_alloc_t new_alloc_secure_func,
723                               gcry_handler_secure_check_t new_is_secure_func,
724                               gcry_handler_realloc_t new_realloc_func,
725                               gcry_handler_free_t new_free_func)
726 {
727   global_init ();
728
729   if (fips_mode ())
730     {
731       /* We do not want to enforce the fips mode, but merely set a
732          flag so that the application may check whether it is still in
733          fips mode.  */
734       _gcry_inactivate_fips_mode ("custom allocation handler");
735     }
736
737   alloc_func = new_alloc_func;
738   alloc_secure_func = new_alloc_secure_func;
739   is_secure_func = new_is_secure_func;
740   realloc_func = new_realloc_func;
741   free_func = new_free_func;
742 }
743
744
745
746 /****************
747  * Set an optional handler which is called in case the xmalloc functions
748  * ran out of memory.  This handler may do one of these things:
749  *   o free some memory and return true, so that the xmalloc function
750  *     tries again.
751  *   o Do whatever it like and return false, so that the xmalloc functions
752  *     use the default fatal error handler.
753  *   o Terminate the program and don't return.
754  *
755  * The handler function is called with 3 arguments:  The opaque value set with
756  * this function, the requested memory size, and a flag with these bits
757  * currently defined:
758  *      bit 0 set = secure memory has been requested.
759  */
760 void
761 _gcry_set_outofcore_handler (int (*f)(void*, size_t, unsigned int), void *value)
762 {
763   global_init ();
764
765   if (fips_mode () )
766     {
767       log_info ("out of core handler ignored in FIPS mode\n");
768       return;
769     }
770
771   outofcore_handler = f;
772   outofcore_handler_value = value;
773 }
774
775 /* Return the no_secure_memory flag.  */
776 static int
777 get_no_secure_memory (void)
778 {
779   if (!no_secure_memory)
780     return 0;
781   if (_gcry_enforced_fips_mode ())
782     {
783       no_secure_memory = 0;
784       return 0;
785     }
786   return no_secure_memory;
787 }
788
789
790 static gcry_err_code_t
791 do_malloc (size_t n, unsigned int flags, void **mem)
792 {
793   gcry_err_code_t err = 0;
794   void *m;
795
796   if ((flags & GCRY_ALLOC_FLAG_SECURE) && !get_no_secure_memory ())
797     {
798       if (alloc_secure_func)
799         m = (*alloc_secure_func) (n);
800       else
801         m = _gcry_private_malloc_secure (n);
802     }
803   else
804     {
805       if (alloc_func)
806         m = (*alloc_func) (n);
807       else
808         m = _gcry_private_malloc (n);
809     }
810
811   if (!m)
812     {
813       /* Make sure that ERRNO has been set in case a user supplied
814          memory handler didn't it correctly. */
815       if (!errno)
816         gpg_err_set_errno (ENOMEM);
817       err = gpg_err_code_from_errno (errno);
818     }
819   else
820     *mem = m;
821
822   return err;
823 }
824
825 void *
826 gcry_malloc (size_t n)
827 {
828   void *mem = NULL;
829
830   do_malloc (n, 0, &mem);
831
832   return mem;
833 }
834
835 void *
836 gcry_malloc_secure (size_t n)
837 {
838   void *mem = NULL;
839
840   do_malloc (n, GCRY_ALLOC_FLAG_SECURE, &mem);
841
842   return mem;
843 }
844
845 int
846 gcry_is_secure (const void *a)
847 {
848   if (get_no_secure_memory ())
849     return 0;
850   if (is_secure_func)
851     return is_secure_func (a) ;
852   return _gcry_private_is_secure (a);
853 }
854
855 void
856 _gcry_check_heap( const void *a )
857 {
858   (void)a;
859
860     /* FIXME: implement this*/
861 #if 0
862     if( some_handler )
863         some_handler(a)
864     else
865         _gcry_private_check_heap(a)
866 #endif
867 }
868
869 void *
870 gcry_realloc (void *a, size_t n)
871 {
872   void *p;
873
874   /* To avoid problems with non-standard realloc implementations and
875      our own secmem_realloc, we divert to malloc and free here.  */
876   if (!a)
877     return gcry_malloc (n);
878   if (!n)
879     {
880       gcry_free (a);
881       return NULL;
882     }
883
884   if (realloc_func)
885     p = realloc_func (a, n);
886   else
887     p =  _gcry_private_realloc (a, n);
888   if (!p && !errno)
889     gpg_err_set_errno (ENOMEM);
890   return p;
891 }
892
893 void
894 gcry_free (void *p)
895 {
896   int save_errno;
897
898   if (!p)
899     return;
900
901   /* In case ERRNO is set we better save it so that the free machinery
902      may not accidently change ERRNO.  We restore it only if it was
903      already set to comply with the usual C semantic for ERRNO.  */
904   save_errno = errno;
905   if (free_func)
906     free_func (p);
907   else
908     _gcry_private_free (p);
909
910   if (save_errno)
911     gpg_err_set_errno (save_errno);
912 }
913
914 void *
915 gcry_calloc (size_t n, size_t m)
916 {
917   size_t bytes;
918   void *p;
919
920   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
921                     defined. */
922   if (m && bytes / m != n)
923     {
924       gpg_err_set_errno (ENOMEM);
925       return NULL;
926     }
927
928   p = gcry_malloc (bytes);
929   if (p)
930     memset (p, 0, bytes);
931   return p;
932 }
933
934 void *
935 gcry_calloc_secure (size_t n, size_t m)
936 {
937   size_t bytes;
938   void *p;
939
940   bytes = n * m; /* size_t is unsigned so the behavior on overflow is
941                     defined. */
942   if (m && bytes / m != n)
943     {
944       gpg_err_set_errno (ENOMEM);
945       return NULL;
946     }
947
948   p = gcry_malloc_secure (bytes);
949   if (p)
950     memset (p, 0, bytes);
951   return p;
952 }
953
954
955 /* Create and return a copy of the null-terminated string STRING.  If
956    it is contained in secure memory, the copy will be contained in
957    secure memory as well.  In an out-of-memory condition, NULL is
958    returned.  */
959 char *
960 gcry_strdup (const char *string)
961 {
962   char *string_cp = NULL;
963   size_t string_n = 0;
964
965   string_n = strlen (string);
966
967   if (gcry_is_secure (string))
968     string_cp = gcry_malloc_secure (string_n + 1);
969   else
970     string_cp = gcry_malloc (string_n + 1);
971
972   if (string_cp)
973     strcpy (string_cp, string);
974
975   return string_cp;
976 }
977
978
979 void *
980 gcry_xmalloc( size_t n )
981 {
982   void *p;
983
984   while ( !(p = gcry_malloc( n )) )
985     {
986       if ( fips_mode ()
987            || !outofcore_handler
988            || !outofcore_handler (outofcore_handler_value, n, 0) )
989         {
990           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL);
991         }
992     }
993     return p;
994 }
995
996 void *
997 gcry_xrealloc( void *a, size_t n )
998 {
999   void *p;
1000
1001   while ( !(p = gcry_realloc( a, n )) )
1002     {
1003       if ( fips_mode ()
1004            || !outofcore_handler
1005            || !outofcore_handler (outofcore_handler_value, n,
1006                                    gcry_is_secure(a)? 3:2 ) )
1007         {
1008           _gcry_fatal_error (gpg_err_code_from_errno (errno), NULL );
1009         }
1010     }
1011     return p;
1012 }
1013
1014 void *
1015 gcry_xmalloc_secure( size_t n )
1016 {
1017   void *p;
1018
1019   while ( !(p = gcry_malloc_secure( n )) )
1020     {
1021       if ( fips_mode ()
1022            || !outofcore_handler
1023            || !outofcore_handler (outofcore_handler_value, n, 1) )
1024         {
1025           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1026                              _("out of core in secure memory"));
1027         }
1028     }
1029   return p;
1030 }
1031
1032
1033 void *
1034 gcry_xcalloc( size_t n, size_t m )
1035 {
1036   size_t nbytes;
1037   void *p;
1038
1039   nbytes = n * m;
1040   if (m && nbytes / m != n)
1041     {
1042       gpg_err_set_errno (ENOMEM);
1043       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1044     }
1045
1046   p = gcry_xmalloc ( nbytes );
1047   memset ( p, 0, nbytes );
1048   return p;
1049 }
1050
1051 void *
1052 gcry_xcalloc_secure( size_t n, size_t m )
1053 {
1054   size_t nbytes;
1055   void *p;
1056
1057   nbytes = n * m;
1058   if (m && nbytes / m != n)
1059     {
1060       gpg_err_set_errno (ENOMEM);
1061       _gcry_fatal_error(gpg_err_code_from_errno (errno), NULL );
1062     }
1063
1064   p = gcry_xmalloc_secure ( nbytes );
1065   memset ( p, 0, nbytes );
1066   return p;
1067 }
1068
1069 char *
1070 gcry_xstrdup (const char *string)
1071 {
1072   char *p;
1073
1074   while ( !(p = gcry_strdup (string)) )
1075     {
1076       size_t n = strlen (string);
1077       int is_sec = !!gcry_is_secure (string);
1078
1079       if (fips_mode ()
1080           || !outofcore_handler
1081           || !outofcore_handler (outofcore_handler_value, n, is_sec) )
1082         {
1083           _gcry_fatal_error (gpg_err_code_from_errno (errno),
1084                              is_sec? _("out of core in secure memory"):NULL);
1085         }
1086     }
1087
1088   return p;
1089 }
1090
1091
1092 int
1093 _gcry_get_debug_flag (unsigned int mask)
1094 {
1095   if ( fips_mode () )
1096     return 0;
1097   return (debug_flags & mask);
1098 }
1099
1100
1101 \f
1102 /* It is often useful to get some feedback of long running operations.
1103    This function may be used to register a handler for this.
1104    The callback function CB is used as:
1105
1106    void cb (void *opaque, const char *what, int printchar,
1107            int current, int total);
1108
1109    Where WHAT is a string identifying the the type of the progress
1110    output, PRINTCHAR the character usually printed, CURRENT the amount
1111    of progress currently done and TOTAL the expected amount of
1112    progress.  A value of 0 for TOTAL indicates that there is no
1113    estimation available.
1114
1115    Defined values for WHAT:
1116
1117    "need_entropy"  X    0  number-of-bytes-required
1118             When running low on entropy
1119    "primegen"      '\n'  0 0
1120            Prime generated
1121                    '!'
1122            Need to refresh the prime pool
1123                    '<','>'
1124            Number of bits adjusted
1125                    '^'
1126            Looking for a generator
1127                    '.'
1128            Fermat tests on 10 candidates failed
1129                   ':'
1130            Restart with a new random value
1131                   '+'
1132            Rabin Miller test passed
1133    "pk_elg"        '+','-','.','\n'   0  0
1134             Only used in debugging mode.
1135    "pk_dsa"
1136             Only used in debugging mode.
1137 */
1138 void
1139 _gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
1140                             void *cb_data)
1141 {
1142 #if USE_DSA
1143   _gcry_register_pk_dsa_progress (cb, cb_data);
1144 #endif
1145 #if USE_ELGAMAL
1146   _gcry_register_pk_elg_progress (cb, cb_data);
1147 #endif
1148   _gcry_register_primegen_progress (cb, cb_data);
1149   _gcry_register_random_progress (cb, cb_data);
1150 }