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 }