2003-05-27 Moritz Schulte <moritz@g10code.com>
[libgcrypt.git] / src / global.c
1 /* global.c  -  global control functions
2  * Copyright (C) 1998,1999,2000,2001,2002,2003 Free Software Foundation, Inc.
3  *
4  * This file is part of Libgcrypt.
5  *
6  * Libgcrypt is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU Lesser general Public License as
8  * published by the Free Software Foundation; either version 2.1 of
9  * the License, or (at your option) any later version.
10  *
11  * Libgcrypt is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <stdarg.h>
26 #include <ctype.h>
27 #include <assert.h>
28 #include <limits.h>
29 #include <errno.h>
30
31 #include "g10lib.h"
32 #include "cipher.h"
33 #include "stdmem.h" /* our own memory allocator */
34 #include "secmem.h" /* our own secmem allocator */
35 #include "ath.h"
36
37 /****************
38  * flag bits: 0 : general cipher debug
39  *            1 : general MPI debug
40  */
41 static unsigned int debug_flags;
42 static int last_ec; /* fixme: make thread safe */
43
44 static void *(*alloc_func)(size_t n) = NULL;
45 static void *(*alloc_secure_func)(size_t n) = NULL;
46 static int   (*is_secure_func)(const void*) = NULL;
47 static void *(*realloc_func)(void *p, size_t n) = NULL;
48 static void (*free_func)(void*) = NULL;
49 static int (*outofcore_handler)( void*, size_t, unsigned int ) = NULL;
50 static void *outofcore_handler_value = NULL;
51 static int no_secure_memory = 0;
52 static int any_init_done;
53
54 /* This is our handmade constructor.  It gets called by any function
55    likely to be called at startup.  The suggested way for an
56    application to make sure that this has been called is by using
57    gcry_check_version. */
58 static void
59 global_init (void)
60 {
61   if (any_init_done)
62     return;
63   any_init_done = 1;
64   ath_init ();
65 }
66
67
68 static const char*
69 parse_version_number( const char *s, int *number )
70 {
71     int val = 0;
72
73     if( *s == '0' && isdigit(s[1]) )
74         return NULL; /* leading zeros are not allowed */
75     for ( ; isdigit(*s); s++ ) {
76         val *= 10;
77         val += *s - '0';
78     }
79     *number = val;
80     return val < 0? NULL : s;
81 }
82
83
84 static const char *
85 parse_version_string( const char *s, int *major, int *minor, int *micro )
86 {
87     s = parse_version_number( s, major );
88     if( !s || *s != '.' )
89         return NULL;
90     s++;
91     s = parse_version_number( s, minor );
92     if( !s || *s != '.' )
93         return NULL;
94     s++;
95     s = parse_version_number( s, micro );
96     if( !s )
97         return NULL;
98     return s; /* patchlevel */
99 }
100
101 /****************
102  * Check that the the version of the library is at minimum the requested one
103  * and return the version string; return NULL if the condition is not
104  * satisfied.  If a NULL is passed to this function, no check is done,
105  * but the version string is simply returned.
106  */
107 const char *
108 gcry_check_version( const char *req_version )
109 {
110     const char *ver = VERSION;
111     int my_major, my_minor, my_micro;
112     int rq_major, rq_minor, rq_micro;
113     const char *my_plvl, *rq_plvl;
114
115     global_init ();
116     if ( !req_version )
117         return ver;
118
119     my_plvl = parse_version_string( ver, &my_major, &my_minor, &my_micro );
120     if ( !my_plvl )
121         return NULL;  /* very strange our own version is bogus */
122     rq_plvl = parse_version_string( req_version, &rq_major, &rq_minor,
123                                                                 &rq_micro );
124     if ( !rq_plvl )
125         return NULL;  /* req version string is invalid */
126
127     if ( my_major > rq_major
128         || (my_major == rq_major && my_minor > rq_minor)
129         || (my_major == rq_major && my_minor == rq_minor
130                                  && my_micro > rq_micro)
131         || (my_major == rq_major && my_minor == rq_minor
132                                  && my_micro == rq_micro
133                                  && strcmp( my_plvl, rq_plvl ) >= 0) ) {
134         return ver;
135     }
136     return NULL;
137 }
138
139
140 int
141 gcry_control( enum gcry_ctl_cmds cmd, ... )
142 {
143     static int init_finished = 0;
144     va_list arg_ptr ;
145
146     va_start( arg_ptr, cmd ) ;
147     switch( cmd ) {
148 #if 0
149       case GCRYCTL_NO_MEM_IS_FATAL:
150         break;
151       case GCRYCTL_SET_FATAL_FNC:
152         break;
153 #endif
154
155       case GCRYCTL_ENABLE_M_GUARD:
156         _gcry_private_enable_m_guard();
157         break;
158
159       case GCRYCTL_ENABLE_QUICK_RANDOM:
160         _gcry_quick_random_gen (1);
161         break;
162
163       case GCRYCTL_DUMP_RANDOM_STATS:
164         _gcry_random_dump_stats();
165         break;
166
167       case GCRYCTL_DUMP_MEMORY_STATS:
168         /*m_print_stats("[fixme: prefix]");*/
169         break;
170
171       case GCRYCTL_DUMP_SECMEM_STATS:
172         _gcry_secmem_dump_stats();
173         break;
174
175       case GCRYCTL_DROP_PRIVS:
176         global_init ();
177         _gcry_secmem_init( 0 );
178         break;
179
180       case GCRYCTL_DISABLE_SECMEM:
181         global_init ();
182         no_secure_memory = 1;
183         break;    
184
185       case GCRYCTL_INIT_SECMEM:
186         global_init ();
187         _gcry_secmem_init( va_arg( arg_ptr, unsigned int ) );
188         break;
189
190       case GCRYCTL_TERM_SECMEM:
191         global_init ();
192         _gcry_secmem_term();
193         break;
194
195       case GCRYCTL_DISABLE_SECMEM_WARN:
196         _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
197                                  | GCRY_SECMEM_FLAG_NO_WARNING));
198         break;
199
200       case GCRYCTL_SUSPEND_SECMEM_WARN:
201         _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
202                                  | GCRY_SECMEM_FLAG_SUSPEND_WARNING));
203         break;
204
205       case GCRYCTL_RESUME_SECMEM_WARN:
206         _gcry_secmem_set_flags ((_gcry_secmem_get_flags ()
207                                  & ~GCRY_SECMEM_FLAG_SUSPEND_WARNING));
208         break;
209
210       case GCRYCTL_USE_SECURE_RNDPOOL:
211         global_init ();
212         _gcry_secure_random_alloc(); /* put random number into secure memory */
213         break;
214
215       case GCRYCTL_SET_VERBOSITY:
216         _gcry_set_log_verbosity( va_arg( arg_ptr, int ) );
217         break;
218
219       case GCRYCTL_SET_DEBUG_FLAGS:
220         debug_flags |= va_arg( arg_ptr, unsigned int );
221         break;
222
223       case GCRYCTL_CLEAR_DEBUG_FLAGS:
224         debug_flags &= ~va_arg( arg_ptr, unsigned int );
225         break;
226
227       case GCRYCTL_DISABLE_INTERNAL_LOCKING:
228         global_init ();
229         /* We waste some bytes by doing it this way.  OTOH this
230            function is not anymore required becuase it is done
231            automagically. */
232         ath_deinit ();
233         break;
234
235       case GCRYCTL_ANY_INITIALIZATION_P:
236         va_end(arg_ptr);
237         return any_init_done? 1 : 0;
238
239       case GCRYCTL_INITIALIZATION_FINISHED_P:
240         va_end(arg_ptr);
241         return init_finished? 1 : 0;
242
243       case GCRYCTL_INITIALIZATION_FINISHED:
244         /* This is a hook which should be used by an application after
245            all initialization has been done and right before any
246            threads are started.  It is not really needed but the only
247            way to be really sure that all initialization for
248            thread-safety has been done. */
249         if (!init_finished) {
250             global_init ();
251             _gcry_random_initialize ();
252             init_finished = 1;
253         }
254         break;
255
256       default:
257         va_end(arg_ptr);
258         return GCRYERR_INV_OP;
259     }
260     va_end(arg_ptr);
261     return 0;
262 }
263
264 int
265 gcry_errno()
266 {
267     return last_ec;
268 }
269
270 const char*
271 gcry_strerror( int ec )
272 {
273     const char *s;
274     static char buf[20];
275
276     if( ec == -1 )
277         ec = gcry_errno();
278   #define X(n,a) case GCRYERR_##n : s = a; break;
279     switch( ec ) {
280       X(SUCCESS,        N_("no error"))
281       X(GENERAL,        N_("general error"))
282
283       X(INV_PK_ALGO,    N_("invalid public key algorithm"))
284       X(INV_MD_ALGO,    N_("invalid hash algorithm"))
285       X(BAD_PUBLIC_KEY ,N_("bad public key"))
286       X(BAD_SECRET_KEY ,N_("bad secret key"))
287       X(BAD_SIGNATURE , N_("bad signature"))
288
289       X(INV_CIPHER_ALGO,N_("invalid cipher algorithm"))
290       X(BAD_MPI,        N_("bad big integer"))
291       X(WRONG_PK_ALGO,  N_("unusable public key algorithm"))
292       X(WEAK_KEY,       N_("weak encryption key"))
293       X(INV_KEYLEN,     N_("invalid key length"))
294       X(INV_ARG,        N_("invalid argument"))
295       X(SELFTEST,       N_("selftest failed"))
296
297       X(INV_OP,         N_("invalid operation code or ctl command"))
298       X(NO_MEM,         N_("out of core"))
299       X(INTERNAL,       N_("internal error"))
300       X(EOF,            N_("EOF"))
301       X(INV_OBJ,        N_("an object is not valid"))
302       X(TOO_SHORT,      N_("provided buffer too short"))
303       X(TOO_LARGE,      N_("object is too large"))
304       X(NO_OBJ,         N_("no object"))
305       X(NOT_IMPL,       N_("not implemented"))
306       X(CONFLICT,       N_("conflict"))
307       X(INV_CIPHER_MODE,N_("invalid cipher mode"))
308         X(INV_FLAG,     N_("invalid flag"))
309
310         X(SEXP_INV_LEN_SPEC   ,N_("invalid length specification")) 
311         X(SEXP_STRING_TOO_LONG,N_("string too long")) 
312         X(SEXP_UNMATCHED_PAREN,N_("unmatched parenthesis")) 
313         X(SEXP_NOT_CANONICAL  ,N_("not a canonical S-expression")) 
314         X(SEXP_BAD_CHARACTER  ,N_("bad character")) 
315         X(SEXP_BAD_QUOTATION  ,N_("invalid hex/octal value or bad quotation")) 
316         X(SEXP_ZERO_PREFIX    ,N_("a length may not begin with zero")) 
317         X(SEXP_NESTED_DH      ,N_("nested display hints")) 
318         X(SEXP_UNMATCHED_DH   ,N_("unmatched display hint close")) 
319         X(SEXP_UNEXPECTED_PUNC,N_("unexpected reserved punctuation")) 
320         X(SEXP_BAD_HEX_CHAR,   N_("invalid hex character"))
321         X(SEXP_ODD_HEX_NUMBERS,N_("odd number of hex characters"))
322         X(SEXP_BAD_OCT_CHAR,   N_("invalid octal character"))
323
324       default:
325         sprintf( buf, "ec=%d", ec );
326         s = buf;
327     }
328   #undef X
329     return s;
330 }
331
332
333 int
334 _gcry_set_lasterr( int ec )
335 {
336     if( ec )
337         last_ec = ec == -1 ? GCRYERR_EOF : ec;
338     return ec;
339 }
340
341
342
343 /****************
344  * NOTE: All 5 functions should be set.  */
345 void
346 gcry_set_allocation_handler( void *(*new_alloc_func)(size_t n),
347                              void *(*new_alloc_secure_func)(size_t n),
348                              int (*new_is_secure_func)(const void*),
349                              void *(*new_realloc_func)(void *p, size_t n),
350                              void (*new_free_func)(void*) )
351 {
352     global_init ();
353
354     alloc_func        = new_alloc_func;
355     alloc_secure_func = new_alloc_secure_func;
356     is_secure_func    = new_is_secure_func;
357     realloc_func      = new_realloc_func;
358     free_func         = new_free_func;
359 }
360
361
362
363 /****************
364  * Set an optional handler which is called in case the xmalloc functions
365  * ran out of memory.  This handler may do one of these things:
366  *   o free some memory and return true, so that the xmalloc function
367  *     tries again.
368  *   o Do whatever it like and return false, so that the xmalloc functions
369  *     use the default fatal error handler.
370  *   o Terminate the program and don't return.
371  *
372  * The handler function is called with 3 arguments:  The opaque value set with
373  * this function, the requested memory size, and a flag with these bits
374  * currently defined:
375  *      bit 0 set = secure memory has been requested.
376  */
377 void
378 gcry_set_outofcore_handler( int (*f)( void*, size_t, unsigned int ),
379                                                         void *value )
380 {
381     global_init ();
382
383     outofcore_handler = f;
384     outofcore_handler_value = value;
385 }
386
387
388
389 void *
390 gcry_malloc( size_t n )
391 {
392     if( alloc_func )
393         return alloc_func( n ) ;
394     return _gcry_private_malloc( n );
395 }
396
397 void *
398 gcry_malloc_secure( size_t n )
399 {
400   if (no_secure_memory)
401     return gcry_malloc (n);
402   if (alloc_secure_func)
403     return alloc_secure_func (n) ;
404   return _gcry_private_malloc_secure (n);
405 }
406
407 int
408 gcry_is_secure( const void *a )
409 {
410   if (no_secure_memory)
411     return 0;
412   if (is_secure_func)
413     return is_secure_func (a) ;
414   return _gcry_private_is_secure (a);
415 }
416
417 void
418 _gcry_check_heap( const void *a )
419 {
420     /* FIXME: implement this*/
421   #if 0
422     if( some_handler )
423         some_handler(a)
424     else
425         _gcry_private_check_heap(a)
426   #endif
427 }
428
429 void *
430 gcry_realloc( void *a, size_t n )
431 {
432     /* FIXME: Make sure that the realloced memory is cleared out */
433
434     if( realloc_func )
435         return realloc_func( a, n ) ;
436     return _gcry_private_realloc( a, n );
437 }
438
439 void
440 gcry_free( void *p )
441 {
442     if( !p )
443         return;
444
445     if( free_func )
446         free_func( p );
447     else
448         _gcry_private_free( p );
449 }
450
451 void *
452 gcry_calloc (size_t n, size_t m)
453 {
454   size_t bytes;
455   void *p;
456
457   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
458   if (m && bytes / m != n) 
459     {
460       errno = ENOMEM;
461       return NULL;
462     }
463
464   p = gcry_malloc (bytes);
465   if (p)
466     memset (p, 0, bytes);
467   return p;
468 }
469
470 void *
471 gcry_calloc_secure (size_t n, size_t m)
472 {
473   size_t bytes;
474   void *p;
475
476   bytes = n * m; /* size_t is unsigned so the behavior on overflow is defined. */
477   if (m && bytes / m != n) 
478     {
479       errno = ENOMEM;
480       return NULL;
481     }
482   
483   p = gcry_malloc_secure (bytes);
484   if (p)
485     memset (p, 0, bytes);
486   return p;
487 }
488
489
490 char *
491 gcry_strdup( const char *string )
492 {
493     void *p = gcry_malloc( strlen(string)+1 );
494     strcpy( p, string );
495     return p;
496 }
497
498
499 void *
500 gcry_xmalloc( size_t n )
501 {
502     void *p;
503
504     while ( !(p = gcry_malloc( n )) ) {
505         if( !outofcore_handler
506             || !outofcore_handler( outofcore_handler_value, n, 0 ) ) {
507             _gcry_fatal_error(GCRYERR_NO_MEM, NULL );
508         }
509     }
510     return p;
511 }
512
513 void *
514 gcry_xrealloc( void *a, size_t n )
515 {
516     void *p;
517
518     while ( !(p = gcry_realloc( a, n )) ) {
519         if( !outofcore_handler
520             || !outofcore_handler( outofcore_handler_value, n, 2 ) ) {
521             _gcry_fatal_error(GCRYERR_NO_MEM, NULL );
522         }
523     }
524     return p;
525 }
526
527 void *
528 gcry_xmalloc_secure( size_t n )
529 {
530     void *p;
531
532     while ( !(p = gcry_malloc_secure( n )) ) {
533         if( !outofcore_handler
534             || !outofcore_handler( outofcore_handler_value, n, 1 ) ) {
535             _gcry_fatal_error(GCRYERR_NO_MEM,
536                              _("out of core in secure memory"));
537         }
538     }
539     return p;
540 }
541
542 void *
543 gcry_xcalloc( size_t n, size_t m )
544 {
545     void *p = gcry_xmalloc( n*m );
546     memset( p, 0, n*m );
547     return p;
548 }
549
550 void *
551 gcry_xcalloc_secure( size_t n, size_t m )
552 {
553     void *p = gcry_xmalloc_secure( n* m );
554     memset( p, 0, n*m );
555     return p;
556 }
557
558 char *
559 gcry_xstrdup( const char *string )
560 {
561     void *p = gcry_xmalloc( strlen(string)+1 );
562     strcpy( p, string );
563     return p;
564 }
565
566
567 int
568 _gcry_get_debug_flag( unsigned int mask )
569 {
570     return debug_flags & mask;
571 }
572
573
574 \f
575 /* It is often useful to get some feedback of long running operations.
576    This function may be used to register a handler for this. 
577    The callback function CB is used as:
578
579    void cb (void *opaque, const char *what, int printchar,
580            int current, int total);
581
582    Where WHAT is a string identifying the the type of the progress
583    output, PRINTCHAR the character usually printed, CURRENT the amount
584    of progress currently done and TOTAL the expected amount of
585    progress.  A value of 0 for TOTAL indicates that there is no
586    estimation available.
587
588    Defined values for WHAT:
589
590    "need_entropy"  X    0  number-of-bytes-required
591             When running low on entropy
592    "primegen"      '\n'  0 0
593            Prime generated
594                    '!'
595            Need to refresh the prime pool
596                    '<','>'
597            Number of bits adjusted
598                    '^'
599            Looking for a generator
600                    '.'
601            Fermat tests on 10 candidates failed
602                   ':'
603            Restart with a new random value
604                   '+'
605            Rabin Miller test passed          
606    "pk_elg"        '+','-','.','\n'   0  0
607             Only used in debugging mode.
608    "pk_dsa"       
609             Only used in debugging mode.
610 */
611 void
612 gcry_set_progress_handler (void (*cb)(void *,const char*,int, int, int),
613                            void *cb_data)
614 {
615 #if USE_DSA
616   _gcry_register_pk_dsa_progress (cb, cb_data);
617 #endif
618 #if USE_ELGAMAL
619   _gcry_register_pk_elg_progress (cb, cb_data);
620 #endif
621   _gcry_register_primegen_progress (cb, cb_data);
622   _gcry_register_random_progress (cb, cb_data);
623 }