wipememory: use memset for non-constant length or large buffer wipes
[libgcrypt.git] / src / g10lib.h
1 /* g10lib.h - Internal definitions for libgcrypt
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2005
3  *               2007, 2011 Free Software Foundation, Inc.
4  *
5  * This file is part of Libgcrypt.
6  *
7  * Libgcrypt is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU Lesser general Public License as
9  * published by the Free Software Foundation; either version 2.1 of
10  * the License, or (at your option) any later version.
11  *
12  * Libgcrypt is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this program; if not, see <http://www.gnu.org/licenses/>.
19  */
20
21 /* This header is to be used inside of libgcrypt in place of gcrypt.h.
22    This way we can better distinguish between internal and external
23    usage of gcrypt.h. */
24
25 #ifndef G10LIB_H
26 #define G10LIB_H 1
27
28 #ifdef _GCRYPT_H
29 #error  gcrypt.h already included
30 #endif
31
32 #ifndef _GCRYPT_IN_LIBGCRYPT
33 #error something is wrong with config.h
34 #endif
35
36 #include <stdio.h>
37 #include <stdarg.h>
38
39 #include "visibility.h"
40 #include "types.h"
41
42
43 \f
44
45 /* Attribute handling macros.  */
46
47 #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 5 )
48 #define JNLIB_GCC_M_FUNCTION 1
49 #define JNLIB_GCC_A_NR       __attribute__ ((noreturn))
50 #define JNLIB_GCC_A_PRINTF( f, a )  __attribute__ ((format (printf,f,a)))
51 #define JNLIB_GCC_A_NR_PRINTF( f, a ) \
52                             __attribute__ ((noreturn, format (printf,f,a)))
53 #define GCC_ATTR_NORETURN  __attribute__ ((__noreturn__))
54 #else
55 #define JNLIB_GCC_A_NR
56 #define JNLIB_GCC_A_PRINTF( f, a )
57 #define JNLIB_GCC_A_NR_PRINTF( f, a )
58 #define GCC_ATTR_NORETURN
59 #endif
60
61 #if __GNUC__ >= 3
62 /* According to glibc this attribute is available since 2.8 however we
63    better play safe and use it only with gcc 3 or newer. */
64 #define GCC_ATTR_FORMAT_ARG(a)  __attribute__ ((format_arg (a)))
65 #else
66 #define GCC_ATTR_FORMAT_ARG(a)
67 #endif
68
69 /* I am not sure since when the unused attribute is really supported.
70    In any case it it only needed for gcc versions which print a
71    warning.  Thus let us require gcc >= 3.5.  */
72 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 5 )
73 #define GCC_ATTR_UNUSED  __attribute__ ((unused))
74 #else
75 #define GCC_ATTR_UNUSED
76 #endif
77
78 #if __GNUC__ >= 3
79 #define LIKELY(expr)      __builtin_expect( !!(expr), 1 )
80 #define UNLIKELY(expr)    __builtin_expect( !!(expr), 0 )
81 #define CONSTANT_P(expr)  __builtin_constant_p( expr )
82 #else
83 #define LIKELY(expr)      (!!(expr))
84 #define UNLIKELY(expr)    (!!(expr))
85 #define CONSTANT_P(expr)  (0)
86 #endif
87
88 /* Gettext macros.  */
89
90 #define _(a)  _gcry_gettext(a)
91 #define N_(a) (a)
92
93 /* Some handy macros */
94 #ifndef STR
95 #define STR(v) #v
96 #endif
97 #define STR2(v) STR(v)
98 #define DIM(v) (sizeof(v)/sizeof((v)[0]))
99 #define DIMof(type,member)   DIM(((type *)0)->member)
100
101 #define my_isascii(c) (!((c) & 0x80))
102
103
104 \f
105
106 /*-- src/global.c -*/
107 extern int _gcry_global_any_init_done;
108 int _gcry_global_is_operational (void);
109 gcry_err_code_t _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr);
110 void _gcry_check_heap (const void *a);
111 void _gcry_pre_syscall (void);
112 void _gcry_post_syscall (void);
113 int _gcry_get_debug_flag (unsigned int mask);
114
115 char *_gcry_get_config (int mode, const char *what);
116
117 /* Malloc functions and common wrapper macros.  */
118 void *_gcry_malloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
119 void *_gcry_calloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
120 void *_gcry_malloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
121 void *_gcry_calloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
122 void *_gcry_realloc (void *a, size_t n);
123 char *_gcry_strdup (const char *string) _GCRY_GCC_ATTR_MALLOC;
124 void *_gcry_xmalloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
125 void *_gcry_xcalloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
126 void *_gcry_xmalloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
127 void *_gcry_xcalloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
128 void *_gcry_xrealloc (void *a, size_t n);
129 char *_gcry_xstrdup (const char * a) _GCRY_GCC_ATTR_MALLOC;
130 void  _gcry_free (void *a);
131 int   _gcry_is_secure (const void *a) _GCRY_GCC_ATTR_PURE;
132
133 #define xtrymalloc(a)    _gcry_malloc ((a))
134 #define xtrycalloc(a,b)  _gcry_calloc ((a),(b))
135 #define xtrymalloc_secure(a)   _gcry_malloc_secure ((a))
136 #define xtrycalloc_secure(a,b) _gcry_calloc_secure ((a),(b))
137 #define xtryrealloc(a,b) _gcry_realloc ((a),(b))
138 #define xtrystrdup(a)    _gcry_strdup ((a))
139 #define xmalloc(a)       _gcry_xmalloc ((a))
140 #define xcalloc(a,b)     _gcry_xcalloc ((a),(b))
141 #define xmalloc_secure(a)   _gcry_xmalloc_secure ((a))
142 #define xcalloc_secure(a,b) _gcry_xcalloc_secure ((a),(b))
143 #define xrealloc(a,b)    _gcry_xrealloc ((a),(b))
144 #define xstrdup(a)       _gcry_xstrdup ((a))
145 #define xfree(a)         _gcry_free ((a))
146
147
148 /*-- src/misc.c --*/
149
150 #if defined(JNLIB_GCC_M_FUNCTION) || __STDC_VERSION__ >= 199901L
151 void _gcry_bug (const char *file, int line,
152                 const char *func) GCC_ATTR_NORETURN;
153 void _gcry_assert_failed (const char *expr, const char *file, int line,
154                           const char *func) GCC_ATTR_NORETURN;
155 #else
156 void _gcry_bug (const char *file, int line);
157 void _gcry_assert_failed (const char *expr, const char *file, int line);
158 #endif
159
160 void _gcry_divide_by_zero (void) JNLIB_GCC_A_NR;
161
162 const char *_gcry_gettext (const char *key) GCC_ATTR_FORMAT_ARG(1);
163 void _gcry_fatal_error(int rc, const char *text ) JNLIB_GCC_A_NR;
164 void _gcry_logv (int level,
165                  const char *fmt, va_list arg_ptr) JNLIB_GCC_A_PRINTF(2,0);
166 void _gcry_log( int level, const char *fmt, ... ) JNLIB_GCC_A_PRINTF(2,3);
167 void _gcry_log_bug( const char *fmt, ... )   JNLIB_GCC_A_NR_PRINTF(1,2);
168 void _gcry_log_fatal( const char *fmt, ... ) JNLIB_GCC_A_NR_PRINTF(1,2);
169 void _gcry_log_error( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
170 void _gcry_log_info( const char *fmt, ... )  JNLIB_GCC_A_PRINTF(1,2);
171 void _gcry_log_debug( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
172 void _gcry_log_printf ( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
173 void _gcry_log_printhex (const char *text, const void *buffer, size_t length);
174 void _gcry_log_printmpi (const char *text, gcry_mpi_t mpi);
175 void _gcry_log_printsxp (const char *text, gcry_sexp_t sexp);
176
177 void _gcry_set_log_verbosity( int level );
178 int _gcry_log_verbosity( int level );
179
180
181 #ifdef JNLIB_GCC_M_FUNCTION
182 #define BUG() _gcry_bug( __FILE__ , __LINE__, __FUNCTION__ )
183 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
184          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__, __FUNCTION__))
185 #elif __STDC_VERSION__ >= 199901L
186 #define BUG() _gcry_bug( __FILE__ , __LINE__, __func__ )
187 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
188          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__, __func__))
189 #else
190 #define BUG() _gcry_bug( __FILE__ , __LINE__ )
191 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
192          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__))
193 #endif
194
195
196 #define log_bug     _gcry_log_bug
197 #define log_fatal   _gcry_log_fatal
198 #define log_error   _gcry_log_error
199 #define log_info    _gcry_log_info
200 #define log_debug   _gcry_log_debug
201 #define log_printf  _gcry_log_printf
202 #define log_printhex _gcry_log_printhex
203 #define log_printmpi _gcry_log_printmpi
204 #define log_printsxp _gcry_log_printsxp
205
206 /* Compatibility macro.  */
207 #define log_mpidump _gcry_log_printmpi
208
209 /* Tokeninze STRING and return a malloced array.  */
210 char **_gcry_strtokenize (const char *string, const char *delim);
211
212
213 /*-- src/hwfeatures.c --*/
214 #define HWF_PADLOCK_RNG         (1 << 0)
215 #define HWF_PADLOCK_AES         (1 << 1)
216 #define HWF_PADLOCK_SHA         (1 << 2)
217 #define HWF_PADLOCK_MMUL        (1 << 3)
218
219 #define HWF_INTEL_CPU           (1 << 4)
220 #define HWF_INTEL_FAST_SHLD     (1 << 5)
221 #define HWF_INTEL_BMI2          (1 << 6)
222 #define HWF_INTEL_SSSE3         (1 << 7)
223 #define HWF_INTEL_SSE4_1        (1 << 8)
224 #define HWF_INTEL_PCLMUL        (1 << 9)
225 #define HWF_INTEL_AESNI         (1 << 10)
226 #define HWF_INTEL_RDRAND        (1 << 11)
227 #define HWF_INTEL_AVX           (1 << 12)
228 #define HWF_INTEL_AVX2          (1 << 13)
229 #define HWF_INTEL_FAST_VPGATHER (1 << 14)
230 #define HWF_INTEL_RDTSC         (1 << 15)
231 #define HWF_INTEL_SHAEXT        (1 << 16)
232
233 #define HWF_ARM_NEON            (1 << 17)
234 #define HWF_ARM_AES             (1 << 18)
235 #define HWF_ARM_SHA1            (1 << 19)
236 #define HWF_ARM_SHA2            (1 << 20)
237 #define HWF_ARM_PMULL           (1 << 21)
238
239
240
241 gpg_err_code_t _gcry_disable_hw_feature (const char *name);
242 void _gcry_detect_hw_features (void);
243 unsigned int _gcry_get_hw_features (void);
244 const char *_gcry_enum_hw_features (int idx, unsigned int *r_feature);
245
246
247 /*-- mpi/mpiutil.c --*/
248 const char *_gcry_mpi_get_hw_config (void);
249
250
251 /*-- cipher/pubkey.c --*/
252
253 /* FIXME: shouldn't this go into mpi.h?  */
254 #ifndef mpi_powm
255 #define mpi_powm(w,b,e,m)   gcry_mpi_powm( (w), (b), (e), (m) )
256 #endif
257
258 /*-- primegen.c --*/
259 gcry_err_code_t _gcry_primegen_init (void);
260 gcry_mpi_t _gcry_generate_secret_prime (unsigned int nbits,
261                                  gcry_random_level_t random_level,
262                                  int (*extra_check)(void*, gcry_mpi_t),
263                                  void *extra_check_arg);
264 gcry_mpi_t _gcry_generate_public_prime (unsigned int nbits,
265                                  gcry_random_level_t random_level,
266                                  int (*extra_check)(void*, gcry_mpi_t),
267                                  void *extra_check_arg);
268 gcry_err_code_t _gcry_generate_elg_prime (int mode,
269                                           unsigned int pbits,
270                                           unsigned int qbits,
271                                           gcry_mpi_t g,
272                                           gcry_mpi_t *r_prime,
273                                           gcry_mpi_t **factors);
274 gcry_mpi_t _gcry_derive_x931_prime (const gcry_mpi_t xp,
275                                     const gcry_mpi_t xp1, const gcry_mpi_t xp2,
276                                     const gcry_mpi_t e,
277                                     gcry_mpi_t *r_p1, gcry_mpi_t *r_p2);
278 gpg_err_code_t _gcry_generate_fips186_2_prime
279                  (unsigned int pbits, unsigned int qbits,
280                   const void *seed, size_t seedlen,
281                   gcry_mpi_t *r_q, gcry_mpi_t *r_p,
282                   int *r_counter,
283                   void **r_seed, size_t *r_seedlen);
284 gpg_err_code_t _gcry_generate_fips186_3_prime
285                  (unsigned int pbits, unsigned int qbits,
286                   const void *seed, size_t seedlen,
287                   gcry_mpi_t *r_q, gcry_mpi_t *r_p,
288                   int *r_counter,
289                   void **r_seed, size_t *r_seedlen, int *r_hashalgo);
290
291 gpg_err_code_t _gcry_fips186_4_prime_check (const gcry_mpi_t x,
292                                             unsigned int bits);
293
294
295 /* Replacements of missing functions (missing-string.c).  */
296 #ifndef HAVE_STPCPY
297 char *stpcpy (char *a, const char *b);
298 #endif
299 #ifndef HAVE_STRCASECMP
300 int strcasecmp (const char *a, const char *b) _GCRY_GCC_ATTR_PURE;
301 #endif
302
303 #include "../compat/libcompat.h"
304
305
306 /* Macros used to rename missing functions.  */
307 #ifndef HAVE_STRTOUL
308 #define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
309 #endif
310 #ifndef HAVE_MEMMOVE
311 #define memmove(d, s, n) bcopy((s), (d), (n))
312 #endif
313 #ifndef HAVE_STRICMP
314 #define stricmp(a,b)     strcasecmp( (a), (b) )
315 #endif
316 #ifndef HAVE_ATEXIT
317 #define atexit(a)    (on_exit((a),0))
318 #endif
319 #ifndef HAVE_RAISE
320 #define raise(a) kill(getpid(), (a))
321 #endif
322
323
324 /* Stack burning.  */
325
326 #ifdef HAVE_GCC_ASM_VOLATILE_MEMORY
327 #define  __gcry_burn_stack_dummy() asm volatile ("":::"memory")
328 #else
329 void __gcry_burn_stack_dummy (void);
330 #endif
331
332 void __gcry_burn_stack (unsigned int bytes);
333 #define _gcry_burn_stack(bytes) \
334         do { __gcry_burn_stack (bytes); \
335              __gcry_burn_stack_dummy (); } while(0)
336
337
338 /* To avoid that a compiler optimizes certain memset calls away, these
339    macros may be used instead.  For small constant length buffers,
340    memory wiping is inlined.  For non-constant or large length buffers,
341    memory is wiped with memset through _gcry_wipememory. */
342 void _gcry_wipememory2(void *ptr, int set, size_t len);
343 #define wipememory2(_ptr,_set,_len) do { \
344               if (!CONSTANT_P(_len) || _len > 64) { \
345                 _gcry_wipememory2((void *)_ptr, _set, _len); \
346               } else {\
347                 volatile char *_vptr = (volatile char *)(_ptr); \
348                 size_t _vlen = (_len); \
349                 const unsigned char _vset = (_set); \
350                 fast_wipememory2(_vptr, _vset, _vlen); \
351                 while(_vlen) { *_vptr = (_vset); _vptr++; _vlen--; } \
352               } \
353             } while(0)
354 #define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
355
356 #if defined(HAVE_GCC_ATTRIBUTE_PACKED) && \
357     defined(HAVE_GCC_ATTRIBUTE_ALIGNED) && \
358     defined(HAVE_GCC_ATTRIBUTE_MAY_ALIAS)
359 typedef struct fast_wipememory_s
360 {
361   u64 a;
362 } __attribute__((packed, aligned(1), may_alias)) fast_wipememory_t;
363 /* fast_wipememory may leave tail bytes unhandled, in which case tail bytes
364    are handled by wipememory. */
365 # define fast_wipememory2(_vptr,_vset,_vlen) do { \
366               fast_wipememory_t _vset_long; \
367               if (_vlen < sizeof(fast_wipememory_t)) \
368                 break; \
369               _vset_long.a = (_vset); \
370               _vset_long.a *= U64_C(0x0101010101010101); \
371               do { \
372                 volatile fast_wipememory_t *_vptr_long = \
373                   (volatile void *)_vptr; \
374                 _vptr_long->a = _vset_long.a; \
375                 _vlen -= sizeof(fast_wipememory_t); \
376                 _vptr += sizeof(fast_wipememory_t); \
377               } while (_vlen >= sizeof(fast_wipememory_t)); \
378             } while (0)
379 #else
380 # define fast_wipememory2(_vptr,_vset,_vlen)
381 #endif
382
383
384 /* Digit predicates.  */
385
386 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
387 #define octdigitp(p) (*(p) >= '0' && *(p) <= '7')
388 #define alphap(a)    (   (*(a) >= 'A' && *(a) <= 'Z')  \
389                       || (*(a) >= 'a' && *(a) <= 'z'))
390 #define hexdigitp(a) (digitp (a)                     \
391                       || (*(a) >= 'A' && *(a) <= 'F')  \
392                       || (*(a) >= 'a' && *(a) <= 'f'))
393
394 /* Init functions.  */
395
396 gcry_err_code_t _gcry_cipher_init (void);
397 gcry_err_code_t _gcry_md_init (void);
398 gcry_err_code_t _gcry_mac_init (void);
399 gcry_err_code_t _gcry_pk_init (void);
400 gcry_err_code_t _gcry_secmem_module_init (void);
401 gcry_err_code_t _gcry_mpi_init (void);
402
403 /* Memory management.  */
404 #define GCRY_ALLOC_FLAG_SECURE (1 << 0)
405 #define GCRY_ALLOC_FLAG_XHINT  (1 << 1)  /* Called from xmalloc.  */
406
407
408 /*-- sexp.c --*/
409 gcry_err_code_t _gcry_sexp_vbuild (gcry_sexp_t *retsexp, size_t *erroff,
410                                    const char *format, va_list arg_ptr);
411 char *_gcry_sexp_nth_string (const gcry_sexp_t list, int number);
412 gpg_err_code_t _gcry_sexp_vextract_param (gcry_sexp_t sexp, const char *path,
413                                           const char *list, va_list arg_ptr);
414
415
416 /*-- fips.c --*/
417
418 extern int _gcry_no_fips_mode_required;
419
420 void _gcry_initialize_fips_mode (int force);
421
422 /* This macro returns true if fips mode is enabled.  This is
423    independent of the fips required finite state machine and only used
424    to enable fips specific code.
425
426    No locking is required because we have the requirement that this
427    variable is only initialized once with no other threads
428    existing.  */
429 #define fips_mode() (!_gcry_no_fips_mode_required)
430
431 int _gcry_enforced_fips_mode (void);
432
433 void _gcry_set_enforced_fips_mode (void);
434
435 void _gcry_inactivate_fips_mode (const char *text);
436 int _gcry_is_fips_mode_inactive (void);
437
438
439 void _gcry_fips_signal_error (const char *srcfile,
440                               int srcline,
441                               const char *srcfunc,
442                               int is_fatal,
443                               const char *description);
444 #ifdef JNLIB_GCC_M_FUNCTION
445 # define fips_signal_error(a) \
446            _gcry_fips_signal_error (__FILE__, __LINE__, __FUNCTION__, 0, (a))
447 # define fips_signal_fatal_error(a) \
448            _gcry_fips_signal_error (__FILE__, __LINE__, __FUNCTION__, 1, (a))
449 #else
450 # define fips_signal_error(a) \
451            _gcry_fips_signal_error (__FILE__, __LINE__, NULL, 0, (a))
452 # define fips_signal_fatal_error(a) \
453            _gcry_fips_signal_error (__FILE__, __LINE__, NULL, 1, (a))
454 #endif
455
456 int _gcry_fips_is_operational (void);
457
458 /* Return true if the library is in the operational state.  */
459 #define fips_is_operational()   \
460         (!_gcry_global_any_init_done ? \
461                 _gcry_global_is_operational() : \
462                 (!fips_mode () || _gcry_global_is_operational ()))
463
464 #define fips_not_operational()  (GPG_ERR_NOT_OPERATIONAL)
465
466 int _gcry_fips_test_operational (void);
467 int _gcry_fips_test_error_or_operational (void);
468
469 gpg_err_code_t _gcry_fips_run_selftests (int extended);
470
471 void _gcry_fips_noreturn (void);
472 #define fips_noreturn()  (_gcry_fips_noreturn ())
473
474
475
476 #endif /* G10LIB_H */