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