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