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