c1f84ee3b3fe06fdaedb96bc4c97bbdf0561c44f
[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 #else
82 #define LIKELY( expr )    (!!(expr))
83 #define UNLIKELY( expr )  (!!(expr))
84 #endif
85
86 /* Gettext macros.  */
87
88 #define _(a)  _gcry_gettext(a)
89 #define N_(a) (a)
90
91 /* Some handy macros */
92 #ifndef STR
93 #define STR(v) #v
94 #endif
95 #define STR2(v) STR(v)
96 #define DIM(v) (sizeof(v)/sizeof((v)[0]))
97 #define DIMof(type,member)   DIM(((type *)0)->member)
98
99 #define my_isascii(c) (!((c) & 0x80))
100
101
102 \f
103
104 /*-- src/global.c -*/
105 extern int _gcry_global_any_init_done;
106 int _gcry_global_is_operational (void);
107 gcry_err_code_t _gcry_vcontrol (enum gcry_ctl_cmds cmd, va_list arg_ptr);
108 void _gcry_check_heap (const void *a);
109 void _gcry_pre_syscall (void);
110 void _gcry_post_syscall (void);
111 int _gcry_get_debug_flag (unsigned int mask);
112
113 char *_gcry_get_config (int mode, const char *what);
114
115 /* Malloc functions and common wrapper macros.  */
116 void *_gcry_malloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
117 void *_gcry_calloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
118 void *_gcry_malloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
119 void *_gcry_calloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
120 void *_gcry_realloc (void *a, size_t n);
121 char *_gcry_strdup (const char *string) _GCRY_GCC_ATTR_MALLOC;
122 void *_gcry_xmalloc (size_t n) _GCRY_GCC_ATTR_MALLOC;
123 void *_gcry_xcalloc (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
124 void *_gcry_xmalloc_secure (size_t n) _GCRY_GCC_ATTR_MALLOC;
125 void *_gcry_xcalloc_secure (size_t n, size_t m) _GCRY_GCC_ATTR_MALLOC;
126 void *_gcry_xrealloc (void *a, size_t n);
127 char *_gcry_xstrdup (const char * a) _GCRY_GCC_ATTR_MALLOC;
128 void  _gcry_free (void *a);
129 int   _gcry_is_secure (const void *a) _GCRY_GCC_ATTR_PURE;
130
131 #define xtrymalloc(a)    _gcry_malloc ((a))
132 #define xtrycalloc(a,b)  _gcry_calloc ((a),(b))
133 #define xtrymalloc_secure(a)   _gcry_malloc_secure ((a))
134 #define xtrycalloc_secure(a,b) _gcry_calloc_secure ((a),(b))
135 #define xtryrealloc(a,b) _gcry_realloc ((a),(b))
136 #define xtrystrdup(a)    _gcry_strdup ((a))
137 #define xmalloc(a)       _gcry_xmalloc ((a))
138 #define xcalloc(a,b)     _gcry_xcalloc ((a),(b))
139 #define xmalloc_secure(a)   _gcry_xmalloc_secure ((a))
140 #define xcalloc_secure(a,b) _gcry_xcalloc_secure ((a),(b))
141 #define xrealloc(a,b)    _gcry_xrealloc ((a),(b))
142 #define xstrdup(a)       _gcry_xstrdup ((a))
143 #define xfree(a)         _gcry_free ((a))
144
145
146 /*-- src/misc.c --*/
147
148 #if defined(JNLIB_GCC_M_FUNCTION) || __STDC_VERSION__ >= 199901L
149 void _gcry_bug (const char *file, int line,
150                 const char *func) GCC_ATTR_NORETURN;
151 void _gcry_assert_failed (const char *expr, const char *file, int line,
152                           const char *func) GCC_ATTR_NORETURN;
153 #else
154 void _gcry_bug (const char *file, int line);
155 void _gcry_assert_failed (const char *expr, const char *file, int line);
156 #endif
157
158 void _gcry_divide_by_zero (void) JNLIB_GCC_A_NR;
159
160 const char *_gcry_gettext (const char *key) GCC_ATTR_FORMAT_ARG(1);
161 void _gcry_fatal_error(int rc, const char *text ) JNLIB_GCC_A_NR;
162 void _gcry_logv (int level,
163                  const char *fmt, va_list arg_ptr) JNLIB_GCC_A_PRINTF(2,0);
164 void _gcry_log( int level, const char *fmt, ... ) JNLIB_GCC_A_PRINTF(2,3);
165 void _gcry_log_bug( const char *fmt, ... )   JNLIB_GCC_A_NR_PRINTF(1,2);
166 void _gcry_log_fatal( const char *fmt, ... ) JNLIB_GCC_A_NR_PRINTF(1,2);
167 void _gcry_log_error( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
168 void _gcry_log_info( const char *fmt, ... )  JNLIB_GCC_A_PRINTF(1,2);
169 void _gcry_log_debug( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
170 void _gcry_log_printf ( const char *fmt, ... ) JNLIB_GCC_A_PRINTF(1,2);
171 void _gcry_log_printhex (const char *text, const void *buffer, size_t length);
172 void _gcry_log_printmpi (const char *text, gcry_mpi_t mpi);
173 void _gcry_log_printsxp (const char *text, gcry_sexp_t sexp);
174
175 void _gcry_set_log_verbosity( int level );
176 int _gcry_log_verbosity( int level );
177
178
179 #ifdef JNLIB_GCC_M_FUNCTION
180 #define BUG() _gcry_bug( __FILE__ , __LINE__, __FUNCTION__ )
181 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
182          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__, __FUNCTION__))
183 #elif __STDC_VERSION__ >= 199901L
184 #define BUG() _gcry_bug( __FILE__ , __LINE__, __func__ )
185 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
186          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__, __func__))
187 #else
188 #define BUG() _gcry_bug( __FILE__ , __LINE__ )
189 #define gcry_assert(expr) (LIKELY(expr)? (void)0 \
190          : _gcry_assert_failed (STR(expr), __FILE__, __LINE__))
191 #endif
192
193
194 #define log_bug     _gcry_log_bug
195 #define log_fatal   _gcry_log_fatal
196 #define log_error   _gcry_log_error
197 #define log_info    _gcry_log_info
198 #define log_debug   _gcry_log_debug
199 #define log_printf  _gcry_log_printf
200 #define log_printhex _gcry_log_printhex
201 #define log_printmpi _gcry_log_printmpi
202 #define log_printsxp _gcry_log_printsxp
203
204 /* Compatibility macro.  */
205 #define log_mpidump _gcry_log_printmpi
206
207 /* Tokeninze STRING and return a malloced array.  */
208 char **_gcry_strtokenize (const char *string, const char *delim);
209
210
211 /*-- src/hwfeatures.c --*/
212 #define HWF_PADLOCK_RNG         (1 << 0)
213 #define HWF_PADLOCK_AES         (1 << 1)
214 #define HWF_PADLOCK_SHA         (1 << 2)
215 #define HWF_PADLOCK_MMUL        (1 << 3)
216
217 #define HWF_INTEL_CPU           (1 << 4)
218 #define HWF_INTEL_FAST_SHLD     (1 << 5)
219 #define HWF_INTEL_BMI2          (1 << 6)
220 #define HWF_INTEL_SSSE3         (1 << 7)
221 #define HWF_INTEL_SSE4_1        (1 << 8)
222 #define HWF_INTEL_PCLMUL        (1 << 9)
223 #define HWF_INTEL_AESNI         (1 << 10)
224 #define HWF_INTEL_RDRAND        (1 << 11)
225 #define HWF_INTEL_AVX           (1 << 12)
226 #define HWF_INTEL_AVX2          (1 << 13)
227 #define HWF_INTEL_FAST_VPGATHER (1 << 14)
228 #define HWF_INTEL_RDTSC         (1 << 15)
229 #define HWF_INTEL_SHAEXT        (1 << 16)
230
231 #define HWF_ARM_NEON            (1 << 17)
232 #define HWF_ARM_AES             (1 << 18)
233 #define HWF_ARM_SHA1            (1 << 19)
234 #define HWF_ARM_SHA2            (1 << 20)
235 #define HWF_ARM_PMULL           (1 << 21)
236
237
238
239 gpg_err_code_t _gcry_disable_hw_feature (const char *name);
240 void _gcry_detect_hw_features (void);
241 unsigned int _gcry_get_hw_features (void);
242 const char *_gcry_enum_hw_features (int idx, unsigned int *r_feature);
243
244
245 /*-- mpi/mpiutil.c --*/
246 const char *_gcry_mpi_get_hw_config (void);
247
248
249 /*-- cipher/pubkey.c --*/
250
251 /* FIXME: shouldn't this go into mpi.h?  */
252 #ifndef mpi_powm
253 #define mpi_powm(w,b,e,m)   gcry_mpi_powm( (w), (b), (e), (m) )
254 #endif
255
256 /*-- primegen.c --*/
257 gcry_err_code_t _gcry_primegen_init (void);
258 gcry_mpi_t _gcry_generate_secret_prime (unsigned int nbits,
259                                  gcry_random_level_t random_level,
260                                  int (*extra_check)(void*, gcry_mpi_t),
261                                  void *extra_check_arg);
262 gcry_mpi_t _gcry_generate_public_prime (unsigned int nbits,
263                                  gcry_random_level_t random_level,
264                                  int (*extra_check)(void*, gcry_mpi_t),
265                                  void *extra_check_arg);
266 gcry_err_code_t _gcry_generate_elg_prime (int mode,
267                                           unsigned int pbits,
268                                           unsigned int qbits,
269                                           gcry_mpi_t g,
270                                           gcry_mpi_t *r_prime,
271                                           gcry_mpi_t **factors);
272 gcry_mpi_t _gcry_derive_x931_prime (const gcry_mpi_t xp,
273                                     const gcry_mpi_t xp1, const gcry_mpi_t xp2,
274                                     const gcry_mpi_t e,
275                                     gcry_mpi_t *r_p1, gcry_mpi_t *r_p2);
276 gpg_err_code_t _gcry_generate_fips186_2_prime
277                  (unsigned int pbits, unsigned int qbits,
278                   const void *seed, size_t seedlen,
279                   gcry_mpi_t *r_q, gcry_mpi_t *r_p,
280                   int *r_counter,
281                   void **r_seed, size_t *r_seedlen);
282 gpg_err_code_t _gcry_generate_fips186_3_prime
283                  (unsigned int pbits, unsigned int qbits,
284                   const void *seed, size_t seedlen,
285                   gcry_mpi_t *r_q, gcry_mpi_t *r_p,
286                   int *r_counter,
287                   void **r_seed, size_t *r_seedlen, int *r_hashalgo);
288
289 gpg_err_code_t _gcry_fips186_4_prime_check (const gcry_mpi_t x,
290                                             unsigned int bits);
291
292
293 /* Replacements of missing functions (missing-string.c).  */
294 #ifndef HAVE_STPCPY
295 char *stpcpy (char *a, const char *b);
296 #endif
297 #ifndef HAVE_STRCASECMP
298 int strcasecmp (const char *a, const char *b) _GCRY_GCC_ATTR_PURE;
299 #endif
300
301 #include "../compat/libcompat.h"
302
303
304 /* Macros used to rename missing functions.  */
305 #ifndef HAVE_STRTOUL
306 #define strtoul(a,b,c)  ((unsigned long)strtol((a),(b),(c)))
307 #endif
308 #ifndef HAVE_MEMMOVE
309 #define memmove(d, s, n) bcopy((s), (d), (n))
310 #endif
311 #ifndef HAVE_STRICMP
312 #define stricmp(a,b)     strcasecmp( (a), (b) )
313 #endif
314 #ifndef HAVE_ATEXIT
315 #define atexit(a)    (on_exit((a),0))
316 #endif
317 #ifndef HAVE_RAISE
318 #define raise(a) kill(getpid(), (a))
319 #endif
320
321
322 /* Stack burning.  */
323
324 #ifdef HAVE_GCC_ASM_VOLATILE_MEMORY
325 #define  __gcry_burn_stack_dummy() asm volatile ("":::"memory")
326 #else
327 void __gcry_burn_stack_dummy (void);
328 #endif
329
330 void __gcry_burn_stack (unsigned int bytes);
331 #define _gcry_burn_stack(bytes) \
332         do { __gcry_burn_stack (bytes); \
333              __gcry_burn_stack_dummy (); } while(0)
334
335
336 /* To avoid that a compiler optimizes certain memset calls away, these
337    macros may be used instead. */
338 #define wipememory2(_ptr,_set,_len) do { \
339               volatile char *_vptr=(volatile char *)(_ptr); \
340               size_t _vlen=(_len); \
341               unsigned char _vset=(_set); \
342               fast_wipememory2(_vptr,_vset,_vlen); \
343               while(_vlen) { *_vptr=(_vset); _vptr++; _vlen--; } \
344                   } while(0)
345 #define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
346
347 #define FASTWIPE_T u64
348 #define FASTWIPE_MULT (U64_C(0x0101010101010101))
349
350 /* Following architectures can handle unaligned accesses fast.  */
351 #if defined(HAVE_GCC_ATTRIBUTE_PACKED) && \
352     defined(HAVE_GCC_ATTRIBUTE_ALIGNED) && \
353     defined(HAVE_GCC_ATTRIBUTE_MAY_ALIAS) && \
354     (defined(__i386__) || defined(__x86_64__) || \
355      defined(__powerpc__) || defined(__powerpc64__) || \
356      (defined(__arm__) && defined(__ARM_FEATURE_UNALIGNED)) || \
357      defined(__aarch64__))
358 #define fast_wipememory2_unaligned_head(_ptr,_set,_len) /*do nothing*/
359 typedef struct fast_wipememory_s
360 {
361   FASTWIPE_T a;
362 } __attribute__((packed, aligned(1), may_alias)) fast_wipememory_t;
363 #else
364 #define fast_wipememory2_unaligned_head(_vptr,_vset,_vlen) do { \
365               while(UNLIKELY((size_t)(_vptr)&(sizeof(FASTWIPE_T)-1)) && _vlen) \
366                 { *_vptr=(_vset); _vptr++; _vlen--; } \
367                   } while(0)
368 typedef struct fast_wipememory_s
369 {
370   FASTWIPE_T a;
371 } fast_wipememory_t;
372 #endif
373
374 /* fast_wipememory2 may leave tail bytes unhandled, in which case tail bytes
375    are handled by wipememory2. */
376 #define fast_wipememory2(_vptr,_vset,_vlen) do { \
377               FASTWIPE_T _vset_long = _vset; \
378               fast_wipememory2_unaligned_head(_vptr,_vset,_vlen); \
379               if (_vlen < sizeof(FASTWIPE_T)) \
380                 break; \
381               _vset_long *= FASTWIPE_MULT; \
382               do { \
383                 volatile fast_wipememory_t *_vptr_long = \
384                   (volatile void *)_vptr; \
385                 _vptr_long->a = _vset_long; \
386                 _vlen -= sizeof(FASTWIPE_T); \
387                 _vptr += sizeof(FASTWIPE_T); \
388               } while (_vlen >= sizeof(FASTWIPE_T)); \
389                   } while (0)
390
391
392 /* Digit predicates.  */
393
394 #define digitp(p)   (*(p) >= '0' && *(p) <= '9')
395 #define octdigitp(p) (*(p) >= '0' && *(p) <= '7')
396 #define alphap(a)    (   (*(a) >= 'A' && *(a) <= 'Z')  \
397                       || (*(a) >= 'a' && *(a) <= 'z'))
398 #define hexdigitp(a) (digitp (a)                     \
399                       || (*(a) >= 'A' && *(a) <= 'F')  \
400                       || (*(a) >= 'a' && *(a) <= 'f'))
401
402 /* Init functions.  */
403
404 gcry_err_code_t _gcry_cipher_init (void);
405 gcry_err_code_t _gcry_md_init (void);
406 gcry_err_code_t _gcry_mac_init (void);
407 gcry_err_code_t _gcry_pk_init (void);
408 gcry_err_code_t _gcry_secmem_module_init (void);
409 gcry_err_code_t _gcry_mpi_init (void);
410
411 /* Memory management.  */
412 #define GCRY_ALLOC_FLAG_SECURE (1 << 0)
413 #define GCRY_ALLOC_FLAG_XHINT  (1 << 1)  /* Called from xmalloc.  */
414
415
416 /*-- sexp.c --*/
417 gcry_err_code_t _gcry_sexp_vbuild (gcry_sexp_t *retsexp, size_t *erroff,
418                                    const char *format, va_list arg_ptr);
419 char *_gcry_sexp_nth_string (const gcry_sexp_t list, int number);
420 gpg_err_code_t _gcry_sexp_vextract_param (gcry_sexp_t sexp, const char *path,
421                                           const char *list, va_list arg_ptr);
422
423
424 /*-- fips.c --*/
425
426 extern int _gcry_no_fips_mode_required;
427
428 void _gcry_initialize_fips_mode (int force);
429
430 int _gcry_fips_mode (void);
431
432 /* This macro returns true if fips mode is enabled.  This is
433    independent of the fips required finite state machine and only used
434    to enable fips specific code.
435
436    No locking is required because we have the requirement that this
437    variable is only initialized once with no other threads
438    existing.  */
439 #define fips_mode() (!_gcry_no_fips_mode_required)
440
441 int _gcry_enforced_fips_mode (void);
442
443 void _gcry_set_enforced_fips_mode (void);
444
445 void _gcry_inactivate_fips_mode (const char *text);
446 int _gcry_is_fips_mode_inactive (void);
447
448
449 void _gcry_fips_signal_error (const char *srcfile,
450                               int srcline,
451                               const char *srcfunc,
452                               int is_fatal,
453                               const char *description);
454 #ifdef JNLIB_GCC_M_FUNCTION
455 # define fips_signal_error(a) \
456            _gcry_fips_signal_error (__FILE__, __LINE__, __FUNCTION__, 0, (a))
457 # define fips_signal_fatal_error(a) \
458            _gcry_fips_signal_error (__FILE__, __LINE__, __FUNCTION__, 1, (a))
459 #else
460 # define fips_signal_error(a) \
461            _gcry_fips_signal_error (__FILE__, __LINE__, NULL, 0, (a))
462 # define fips_signal_fatal_error(a) \
463            _gcry_fips_signal_error (__FILE__, __LINE__, NULL, 1, (a))
464 #endif
465
466 int _gcry_fips_is_operational (void);
467
468 /* Return true if the library is in the operational state.  */
469 #define fips_is_operational()   \
470         (!_gcry_global_any_init_done ? \
471                 _gcry_global_is_operational() : \
472                 (!fips_mode () || _gcry_global_is_operational ()))
473
474 #define fips_not_operational()  (GPG_ERR_NOT_OPERATIONAL)
475
476 int _gcry_fips_test_operational (void);
477 int _gcry_fips_test_error_or_operational (void);
478
479 gpg_err_code_t _gcry_fips_run_selftests (int extended);
480
481 void _gcry_fips_noreturn (void);
482 #define fips_noreturn()  (_gcry_fips_noreturn ())
483
484
485
486 #endif /* G10LIB_H */