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