AES-NI/OCB: Perform checksumming inline with encryption
[libgcrypt.git] / src / misc.c
1 /* misc.c
2  * Copyright (C) 1999, 2001, 2002, 2003, 2007,
3  *               2008 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 #include <config.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <stdarg.h>
27 #include <unistd.h>
28
29 #include "g10lib.h"
30 #include "secmem.h"
31 #include "mpi.h"
32
33 static int verbosity_level = 0;
34
35 /* Prevent compiler from optimizing away the call to memset by accessing
36    memset through volatile pointer. */
37 static void *(*volatile memset_ptr)(void *, int, size_t) = (void *)memset;
38
39 static void (*fatal_error_handler)(void*,int, const char*) = NULL;
40 static void *fatal_error_handler_value = 0;
41 static void (*log_handler)(void*,int, const char*, va_list) = NULL;
42 static void *log_handler_value = 0;
43
44 static const char *(*user_gettext_handler)( const char * ) = NULL;
45
46 void
47 _gcry_set_gettext_handler (const char *(*f)(const char*))
48 {
49     user_gettext_handler = f;
50 }
51
52
53 const char *
54 _gcry_gettext( const char *key )
55 {
56     if( user_gettext_handler )
57         return user_gettext_handler( key );
58     /* FIXME: switch the domain to gnupg and restore later */
59     return key;
60 }
61
62 void
63 _gcry_set_fatalerror_handler( void (*fnc)(void*,int, const char*), void *value)
64 {
65     fatal_error_handler_value = value;
66     fatal_error_handler = fnc;
67 }
68
69 static void
70 write2stderr( const char *s )
71 {
72   /* Dummy variable to silence gcc warning.  */
73   int res = write( 2, s, strlen(s) );
74   (void) res;
75 }
76
77 /*
78  * This function is called for fatal errors.  A caller might want to
79  * set his own handler because this function simply calls abort().
80  */
81 void
82 _gcry_fatal_error (int rc, const char *text)
83 {
84   if ( !text ) /* get a default text */
85     text = gpg_strerror (rc);
86
87   if (fatal_error_handler && !fips_mode () )
88     fatal_error_handler (fatal_error_handler_value, rc, text);
89
90   fips_signal_fatal_error (text);
91   write2stderr("\nFatal error: ");
92   write2stderr(text);
93   write2stderr("\n");
94   _gcry_secmem_term ();
95   abort ();
96 }
97
98 void
99 _gcry_set_log_handler (void (*f)(void*,int, const char*, va_list), void *opaque)
100 {
101     log_handler = f;
102     log_handler_value = opaque;
103 }
104
105 void
106 _gcry_set_log_verbosity( int level )
107 {
108     verbosity_level = level;
109 }
110
111 int
112 _gcry_log_verbosity( int level )
113 {
114     return verbosity_level >= level;
115 }
116
117 /****************
118  * This is our log function which prints all log messages to stderr or
119  * using the function defined with gcry_set_log_handler().
120  */
121 void
122 _gcry_logv( int level, const char *fmt, va_list arg_ptr )
123 {
124   if (log_handler)
125     log_handler (log_handler_value, level, fmt, arg_ptr);
126   else
127     {
128       switch (level)
129         {
130         case GCRY_LOG_CONT:  break;
131         case GCRY_LOG_INFO:  break;
132         case GCRY_LOG_WARN:  break;
133         case GCRY_LOG_ERROR: break;
134         case GCRY_LOG_FATAL: fputs("Fatal: ",stderr ); break;
135         case GCRY_LOG_BUG:   fputs("Ohhhh jeeee: ", stderr); break;
136         case GCRY_LOG_DEBUG: fputs("DBG: ", stderr ); break;
137         default: fprintf(stderr,"[Unknown log level %d]: ", level ); break;
138         }
139       vfprintf(stderr,fmt,arg_ptr) ;
140     }
141
142   if ( level == GCRY_LOG_FATAL || level == GCRY_LOG_BUG )
143     {
144       fips_signal_fatal_error ("internal error (fatal or bug)");
145       _gcry_secmem_term ();
146       abort ();
147     }
148 }
149
150
151 void
152 _gcry_log( int level, const char *fmt, ... )
153 {
154     va_list arg_ptr ;
155
156     va_start( arg_ptr, fmt ) ;
157     _gcry_logv( level, fmt, arg_ptr );
158     va_end(arg_ptr);
159 }
160
161
162 #if defined(JNLIB_GCC_M_FUNCTION) || __STDC_VERSION__ >= 199901L
163 void
164 _gcry_bug( const char *file, int line, const char *func )
165 {
166     _gcry_log( GCRY_LOG_BUG,
167              ("... this is a bug (%s:%d:%s)\n"), file, line, func );
168     abort(); /* never called, but it makes the compiler happy */
169 }
170 void
171 _gcry_assert_failed (const char *expr, const char *file, int line,
172                      const char *func)
173 {
174   _gcry_log (GCRY_LOG_BUG,
175              ("Assertion `%s' failed (%s:%d:%s)\n"), expr, file, line, func );
176   abort(); /* Never called, but it makes the compiler happy. */
177 }
178 #else
179 void
180 _gcry_bug( const char *file, int line )
181 {
182     _gcry_log( GCRY_LOG_BUG,
183              _("you found a bug ... (%s:%d)\n"), file, line);
184     abort(); /* never called, but it makes the compiler happy */
185 }
186 void
187 _gcry_assert_failed (const char *expr, const char *file, int line)
188 {
189   _gcry_log (GCRY_LOG_BUG,
190              ("Assertion `%s' failed (%s:%d)\n"), expr, file, line);
191   abort(); /* Never called, but it makes the compiler happy. */
192 }
193 #endif
194
195 void
196 _gcry_log_info( const char *fmt, ... )
197 {
198     va_list arg_ptr ;
199
200     va_start( arg_ptr, fmt ) ;
201     _gcry_logv( GCRY_LOG_INFO, fmt, arg_ptr );
202     va_end(arg_ptr);
203 }
204
205 void
206 _gcry_log_error( const char *fmt, ... )
207 {
208     va_list arg_ptr ;
209
210     va_start( arg_ptr, fmt ) ;
211     _gcry_logv( GCRY_LOG_ERROR, fmt, arg_ptr );
212     va_end(arg_ptr);
213 }
214
215
216 void
217 _gcry_log_fatal( const char *fmt, ... )
218 {
219     va_list arg_ptr ;
220
221     va_start( arg_ptr, fmt ) ;
222     _gcry_logv( GCRY_LOG_FATAL, fmt, arg_ptr );
223     va_end(arg_ptr);
224     abort(); /* never called, but it makes the compiler happy */
225 }
226
227 void
228 _gcry_log_bug( const char *fmt, ... )
229 {
230     va_list arg_ptr ;
231
232     va_start( arg_ptr, fmt ) ;
233     _gcry_logv( GCRY_LOG_BUG, fmt, arg_ptr );
234     va_end(arg_ptr);
235     abort(); /* never called, but it makes the compiler happy */
236 }
237
238 void
239 _gcry_log_debug( const char *fmt, ... )
240 {
241     va_list arg_ptr ;
242
243     va_start( arg_ptr, fmt ) ;
244     _gcry_logv( GCRY_LOG_DEBUG, fmt, arg_ptr );
245     va_end(arg_ptr);
246 }
247
248
249 void
250 _gcry_log_printf (const char *fmt, ...)
251 {
252   va_list arg_ptr;
253
254   if (fmt)
255     {
256       va_start( arg_ptr, fmt ) ;
257       _gcry_logv (GCRY_LOG_CONT, fmt, arg_ptr);
258       va_end(arg_ptr);
259     }
260 }
261
262
263 /* Helper for _gcry_log_printhex and _gcry_log_printmpi.  */
264 static void
265 do_printhex (const char *text, const char *text2,
266              const void *buffer, size_t length)
267 {
268   int wrap = 0;
269   int cnt = 0;
270
271   if (text && *text)
272     {
273       wrap = 1;
274       log_debug ("%s:%s", text, text2);
275       if (text2[1] == '[' && length && buffer)
276         {
277           /* Start with a new line so that we get nice output for
278              opaque MPIS:
279                "value: [31 bit]"
280                "        01020300"  */
281           log_printf ("\n");
282           text2 = " ";
283           log_debug ("%*s  ", (int)strlen(text), "");
284         }
285     }
286   if (length && buffer)
287     {
288       const unsigned char *p = buffer;
289       for (; length--; p++)
290         {
291           log_printf ("%02x", *p);
292           if (wrap && ++cnt == 32 && length)
293             {
294               cnt = 0;
295               log_printf (" \\\n");
296               log_debug ("%*s %*s",
297                          (int)strlen(text), "", (int)strlen(text2), "");
298             }
299         }
300     }
301   if (text)
302     log_printf ("\n");
303 }
304
305
306 /* Print a hexdump of BUFFER.  With TEXT of NULL print just the raw
307    dump without any wrappping, with TEXT an empty string, print a
308    trailing linefeed, otherwise print an entire debug line. */
309 void
310 _gcry_log_printhex (const char *text, const void *buffer, size_t length)
311 {
312   do_printhex (text, " ", buffer, length);
313 }
314
315
316 /* Print MPI in hex notation.  To make clear that the output is an MPI
317    a sign is always printed. With TEXT of NULL print just the raw dump
318    without any wrapping, with TEXT an empty string, print a trailing
319    linefeed, otherwise print an entire debug line. */
320 void
321 _gcry_log_printmpi (const char *text, gcry_mpi_t mpi)
322 {
323   unsigned char *rawmpi;
324   unsigned int rawmpilen;
325   int sign;
326
327   if (!mpi)
328     do_printhex (text? text:" ", " (null)", NULL, 0);
329   else if (mpi_is_opaque (mpi))
330     {
331       unsigned int nbits;
332       const unsigned char *p;
333       char prefix[30];
334
335       p = mpi_get_opaque (mpi, &nbits);
336       snprintf (prefix, sizeof prefix, " [%u bit]", nbits);
337       do_printhex (text? text:" ", prefix, p, (nbits+7)/8);
338     }
339   else
340     {
341       rawmpi = _gcry_mpi_get_buffer (mpi, 0, &rawmpilen, &sign);
342       if (!rawmpi)
343         do_printhex (text? text:" ", " [out of core]", NULL, 0);
344       else
345         {
346           if (!rawmpilen)
347             do_printhex (text, sign? "-":"+", "", 1);
348           else
349             do_printhex (text, sign? "-":"+", rawmpi, rawmpilen);
350           xfree (rawmpi);
351         }
352     }
353 }
354
355
356 static int
357 count_closing_parens (const char *p)
358 {
359   int count = 0;
360
361   for (; *p; p++)
362     if (*p == ')')
363       count++;
364     else if (!strchr ("\n \t", *p))
365       return 0;
366
367   return count;
368 }
369
370
371 /* Print SEXP in human readabale format.  With TEXT of NULL print just the raw
372    dump without any wrappping, with TEXT an empty string, print a
373    trailing linefeed, otherwise print the full debug output. */
374 void
375 _gcry_log_printsxp (const char *text, gcry_sexp_t sexp)
376 {
377   int with_lf = 0;
378
379   if (text && *text)
380     {
381       if ((with_lf = !!strchr (text, '\n')))
382         log_debug ("%s", text);
383       else
384         log_debug ("%s: ", text);
385     }
386   if (sexp)
387     {
388       int any = 0;
389       int n_closing;
390       char *buf, *pend;
391       const char *p;
392       size_t size;
393
394       size = sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, NULL, 0);
395       p = buf = xmalloc (size);
396       sexp_sprint (sexp, GCRYSEXP_FMT_ADVANCED, buf, size);
397
398       do
399         {
400           if (any && !with_lf)
401             log_debug ("%*s  ", text?(int)strlen(text):0, "");
402           else
403             any = 1;
404           pend = strchr (p, '\n');
405           size = pend? (pend - p) : strlen (p);
406           if (with_lf)
407             log_debug ("%.*s", (int)size, p);
408           else
409             log_printf ("%.*s", (int)size, p);
410           if (pend)
411             p = pend + 1;
412           else
413             p += size;
414           n_closing = count_closing_parens (p);
415           if (n_closing)
416             {
417               while (n_closing--)
418                 log_printf (")");
419               p = "";
420             }
421           log_printf ("\n");
422         }
423       while (*p);
424       xfree (buf);
425     }
426   else if (text)
427     log_printf ("\n");
428 }
429
430
431 /*
432  * Tokenize STRING using the set of delimiters in DELIM.  Leading
433  * white spaces are removed from all tokens.  The caller must xfree
434  * the result.
435  *
436  * Returns: A malloced and NULL delimited array with the tokens.  On
437  *          memory error NULL is returned and ERRNO is set.
438  */
439 char **
440 _gcry_strtokenize (const char *string, const char *delim)
441 {
442   const char *s;
443   size_t fields;
444   size_t bytes, n;
445   char *buffer;
446   char *p, *px, *pend;
447   char **result;
448   char const ws[] = " \t\v\f\r\n";
449
450   if (!delim)
451     delim = ws;
452
453   /* Count the number of fields.  */
454   for (fields = 1, s = strpbrk (string, delim); s; s = strpbrk (s + 1, delim))
455     fields++;
456   fields++; /* Add one for the terminating NULL.  */
457
458   /* Allocate an array for all fields, a terminating NULL, and space
459      for a copy of the string.  */
460   bytes = fields * sizeof *result;
461   if (bytes / sizeof *result != fields)
462     {
463       gpg_err_set_errno (ENOMEM);
464       return NULL;
465     }
466   n = strlen (string) + 1;
467   bytes += n;
468   if (bytes < n)
469     {
470       gpg_err_set_errno (ENOMEM);
471       return NULL;
472     }
473   result = xtrymalloc (bytes);
474   if (!result)
475     return NULL;
476   buffer = (char*)(result + fields);
477
478   /* Copy and parse the string.  */
479   strcpy (buffer, string);
480   for (n = 0, p = buffer; (pend = strpbrk (p, delim)); p = pend + 1)
481     {
482       *pend = 0;
483       while (strchr (ws, *(byte*)p))
484         p++;
485       for (px = pend - 1; px >= p && strchr (ws, *(byte*)px); px--)
486         *px = 0;
487       result[n++] = p;
488     }
489   while (*p && strchr (ws, *(byte*)p))
490     p++;
491   for (px = p + strlen (p) - 1; px >= p && strchr (ws, *(byte*)px); px--)
492     *px = 0;
493   /* Traling spaces may result in an empty field.  We do not want to
494      store that.  */
495   result[n++] = *p? p : NULL;
496   result[n] = NULL;
497
498   gcry_assert ((char*)(result + n + 1) == buffer);
499
500   return result;
501 }
502
503
504 void
505 _gcry_fast_wipememory (void *ptr, size_t len)
506 {
507   /* Note: This function is called from wipememory/wipememory2 only if LEN
508      is large or unknown at compile time. New wipe function alternatives
509      need to be checked before adding to this function. New implementations
510      need to be faster than wipememory/wipememory2 macros in 'misc.h'.
511
512      Following implementations were found to have suboptimal performance:
513
514      - [_WIN32/mingw32] SecureZeroMemory; Inline function, equivalent to
515        volatile byte buffer set: while(buflen--) (volatile char *)(buf++)=set;
516    */
517 #ifdef HAVE_EXPLICIT_BZERO
518   explicit_bzero (ptr, len);
519 #else
520   memset_ptr (ptr, 0, len);
521 #endif
522 }
523
524
525 void
526 _gcry_fast_wipememory2 (void *ptr, int set, size_t len)
527 {
528 #ifdef HAVE_EXPLICIT_BZERO
529   if (set == 0)
530     {
531       explicit_bzero (ptr, len);
532       return;
533     }
534 #endif
535
536   memset_ptr (ptr, set, len);
537 }
538
539
540 void
541 __gcry_burn_stack (unsigned int bytes)
542 {
543 #ifdef HAVE_VLA
544   /* (bytes == 0 ? 1 : bytes) == (!bytes + bytes) */
545   unsigned int buflen = ((!bytes + bytes) + 63) & ~63;
546   char buf[buflen];
547
548   _gcry_fast_wipememory (buf, buflen);
549 #else
550   volatile char buf[64];
551
552   _gcry_fast_wipememory (buf, sizeof buf);
553
554   if (bytes > sizeof buf)
555       _gcry_burn_stack (bytes - sizeof buf);
556 #endif
557 }
558
559 #ifndef HAVE_GCC_ASM_VOLATILE_MEMORY
560 void
561 __gcry_burn_stack_dummy (void)
562 {
563 }
564 #endif
565
566 void
567 _gcry_divide_by_zero (void)
568 {
569     gpg_err_set_errno (EDOM);
570     _gcry_fatal_error (gpg_err_code_from_errno (errno), "divide by zero");
571 }