FIPS140 mode is detected on run-time.
[gnutls:gnutls.git] / lib / gnutls_global.c
1 /*
2  * Copyright (C) 2001-2013 Free Software Foundation, Inc.
3  *
4  * Author: Nikos Mavrogiannopoulos
5  *
6  * This file is part of GnuTLS.
7  *
8  * The GnuTLS is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public License
10  * as published by the Free Software Foundation; either version 2.1 of
11  * the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful, but
14  * WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public License
19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
20  *
21  */
22
23 #include <gnutls_int.h>
24 #include <gnutls_errors.h>
25 #include <libtasn1.h>
26 #include <gnutls_dh.h>
27 #include <random.h>
28 #include <gnutls/pkcs11.h>
29
30 #include <gnutls_extensions.h>  /* for _gnutls_ext_init */
31 #include <locks.h>
32 #include <system.h>
33 #include <accelerated/cryptodev.h>
34 #include <accelerated/accelerated.h>
35 #include <fips.h>
36
37 #include "sockets.h"
38 #include "gettext.h"
39
40 /* Minimum library versions we accept. */
41 #define GNUTLS_MIN_LIBTASN1_VERSION "0.3.4"
42
43 /* created by asn1c */
44 extern const ASN1_ARRAY_TYPE gnutls_asn1_tab[];
45 extern const ASN1_ARRAY_TYPE pkix_asn1_tab[];
46 void *_gnutls_file_mutex;
47 void *_gnutls_pkcs11_mutex;
48
49 ASN1_TYPE _gnutls_pkix1_asn;
50 ASN1_TYPE _gnutls_gnutls_asn;
51
52 gnutls_log_func _gnutls_log_func = NULL;
53 gnutls_audit_log_func _gnutls_audit_log_func = NULL;
54 int _gnutls_log_level = 0;      /* default log level */
55
56 static void default_log_func(int level, const char* str)
57 {
58         fprintf(stderr, "gnutls[%d]: %s", level, str);
59 }
60
61 /**
62  * gnutls_global_set_log_function:
63  * @log_func: it's a log function
64  *
65  * This is the function where you set the logging function gnutls is
66  * going to use.  This function only accepts a character array.
67  * Normally you may not use this function since it is only used for
68  * debugging purposes.
69  *
70  * @gnutls_log_func is of the form,
71  * void (*gnutls_log_func)( int level, const char*);
72  **/
73 void gnutls_global_set_log_function(gnutls_log_func log_func)
74 {
75         _gnutls_log_func = log_func;
76 }
77
78 /**
79  * gnutls_global_set_audit_log_function:
80  * @log_func: it is the audit log function
81  *
82  * This is the function to set the audit logging function. This
83  * is a function to report important issues, such as possible
84  * attacks in the protocol. This is different from gnutls_global_set_log_function()
85  * because it will report also session-specific events. The session
86  * parameter will be null if there is no corresponding TLS session.
87  *
88  * @gnutls_audit_log_func is of the form,
89  * void (*gnutls_audit_log_func)( gnutls_session_t, const char*);
90  *
91  * Since: 3.0
92  **/
93 void gnutls_global_set_audit_log_function(gnutls_audit_log_func log_func)
94 {
95         _gnutls_audit_log_func = log_func;
96 }
97
98 /**
99  * gnutls_global_set_time_function:
100  * @time_func: it's the system time function, a gnutls_time_func() callback.
101  *
102  * This is the function where you can override the default system time
103  * function.  The application provided function should behave the same
104  * as the standard function.
105  *
106  * Since: 2.12.0
107  **/
108 void gnutls_global_set_time_function(gnutls_time_func time_func)
109 {
110         gnutls_time = time_func;
111 }
112
113 /**
114  * gnutls_global_set_log_level:
115  * @level: it's an integer from 0 to 99.
116  *
117  * This is the function that allows you to set the log level.  The
118  * level is an integer between 0 and 9.  Higher values mean more
119  * verbosity. The default value is 0.  Larger values should only be
120  * used with care, since they may reveal sensitive information.
121  *
122  * Use a log level over 10 to enable all debugging options.
123  **/
124 void gnutls_global_set_log_level(int level)
125 {
126         _gnutls_log_level = level;
127 }
128
129 /**
130  * gnutls_global_set_mem_functions:
131  * @alloc_func: it's the default memory allocation function. Like malloc().
132  * @secure_alloc_func: This is the memory allocation function that will be used for sensitive data.
133  * @is_secure_func: a function that returns 0 if the memory given is not secure. May be NULL.
134  * @realloc_func: A realloc function
135  * @free_func: The function that frees allocated data. Must accept a NULL pointer.
136  *
137  * This is the function where you set the memory allocation functions
138  * gnutls is going to use. By default the libc's allocation functions
139  * (malloc(), free()), are used by gnutls, to allocate both sensitive
140  * and not sensitive data.  This function is provided to set the
141  * memory allocation functions to something other than the defaults
142  *
143  * This function must be called before gnutls_global_init() is called.
144  * This function is not thread safe.
145  **/
146 void
147 gnutls_global_set_mem_functions(gnutls_alloc_function alloc_func,
148                                 gnutls_alloc_function secure_alloc_func,
149                                 gnutls_is_secure_function is_secure_func,
150                                 gnutls_realloc_function realloc_func,
151                                 gnutls_free_function free_func)
152 {
153         gnutls_secure_malloc = secure_alloc_func;
154         gnutls_malloc = alloc_func;
155         gnutls_realloc = realloc_func;
156         gnutls_free = free_func;
157
158         /* if using the libc's default malloc
159          * use libc's calloc as well.
160          */
161         if (gnutls_malloc == malloc) {
162                 gnutls_calloc = calloc;
163         } else {                /* use the included ones */
164                 gnutls_calloc = _gnutls_calloc;
165         }
166         gnutls_strdup = _gnutls_strdup;
167
168 }
169
170 GNUTLS_STATIC_MUTEX(global_init_mutex);
171 static int _gnutls_init = 0;
172 static unsigned int loaded_modules = 0;
173
174 #define GNUTLS_GLOBAL_INIT_ALL (~((unsigned int)0))
175 #define GNUTLS_GLOBAL_INIT_MINIMAL (1)
176 #define GNUTLS_GLOBAL_INIT_PKCS11 (1<<1)
177 #define GNUTLS_GLOBAL_INIT_CRYPTO (1<<2)
178
179 #define GLOBAL_INIT_ALL (GNUTLS_GLOBAL_INIT_MINIMAL|GNUTLS_GLOBAL_INIT_PKCS11|GNUTLS_GLOBAL_INIT_CRYPTO)
180
181 /*-
182  * gnutls_global_init2:
183  *
184  * @flags: it's a %GNUTLS_GLOBAL_* flag
185  *
186  * This function performs any required precalculations, detects
187  * the supported CPU capabilities and initializes the underlying
188  * cryptographic backend. In order to free any resources 
189  * taken by this call you should gnutls_global_deinit() 
190  * when gnutls usage is no longer needed.
191  *
192  * This function increments a global counter, so that
193  * gnutls_global_deinit() only releases resources when it has been
194  * called as many times as gnutls_global_init().  This is useful when
195  * GnuTLS is used by more than one library in an application.  This
196  * function can be called many times, but will only do something the
197  * first time.
198  *
199  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
200  *   otherwise a negative error code is returned.
201  -*/
202 static int gnutls_global_init2(unsigned int flags)
203 {
204         int ret = 0, res;
205         int level;
206         const char* e;
207         
208         GNUTLS_STATIC_MUTEX_LOCK(global_init_mutex);
209
210         _gnutls_init++;
211
212         /* rationalize flags */
213         if (flags == GNUTLS_GLOBAL_INIT_ALL)
214                 flags = GLOBAL_INIT_ALL;
215
216         flags &= ~loaded_modules;
217         
218         if (flags == 0) { /* The requested were already loaded */
219                 ret = 0;
220                 goto out;
221         }
222         
223         if (!(flags & GNUTLS_GLOBAL_INIT_MINIMAL) &&
224                 !(loaded_modules & GNUTLS_GLOBAL_INIT_MINIMAL)) {
225                 /* Must always initialize the minimal before everything else */
226                 _gnutls_init--;
227                 ret = gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
228                 goto out;
229         }
230
231         loaded_modules |= flags;
232
233         if (flags & GNUTLS_GLOBAL_INIT_MINIMAL) {
234                 _gnutls_switch_lib_state(LIB_STATE_INIT);
235
236                 e = getenv("GNUTLS_DEBUG_LEVEL");
237                 if (e != NULL) {
238                         level = atoi(e);
239                         gnutls_global_set_log_level(level);
240                         if (_gnutls_log_func == NULL)
241                                 gnutls_global_set_log_function(default_log_func);
242                         _gnutls_debug_log("Enabled GnuTLS logging...\n");
243                 }
244
245                 if (gl_sockets_startup(SOCKETS_1_1)) {
246                         ret = gnutls_assert_val(GNUTLS_E_SOCKETS_INIT_ERROR);
247                         goto out;
248                 }
249
250                 bindtextdomain(PACKAGE, LOCALEDIR);
251
252                 res = gnutls_crypto_init();
253                 if (res != 0) {
254                         gnutls_assert();
255                         ret = GNUTLS_E_CRYPTO_INIT_FAILED;
256                         goto out;
257                 }
258
259                 /* initialize ASN.1 parser
260                  * This should not deal with files in the final
261                  * version.
262                  */
263                 if (asn1_check_version(GNUTLS_MIN_LIBTASN1_VERSION) == NULL) {
264                         gnutls_assert();
265                         _gnutls_debug_log
266                             ("Checking for libtasn1 failed: %s < %s\n",
267                              asn1_check_version(NULL),
268                              GNUTLS_MIN_LIBTASN1_VERSION);
269                         ret = GNUTLS_E_INCOMPATIBLE_LIBTASN1_LIBRARY;
270                         goto out;
271                 }
272
273                 res = asn1_array2tree(pkix_asn1_tab, &_gnutls_pkix1_asn, NULL);
274                 if (res != ASN1_SUCCESS) {
275                         ret = _gnutls_asn2err(res);
276                         goto out;
277                 }
278
279                 res = asn1_array2tree(gnutls_asn1_tab, &_gnutls_gnutls_asn, NULL);
280                 if (res != ASN1_SUCCESS) {
281                         ret = _gnutls_asn2err(res);
282                         goto out;
283                 }
284
285                 /* Initialize the random generator */
286                 ret = _gnutls_rnd_init();
287                 if (ret < 0) {
288                         gnutls_assert();
289                         goto out;
290                 }
291
292                 /* Initialize the default TLS extensions */
293                 ret = _gnutls_ext_init();
294                 if (ret < 0) {
295                         gnutls_assert();
296                         goto out;
297                 }
298
299                 ret = gnutls_mutex_init(&_gnutls_file_mutex);
300                 if (ret < 0) {
301                         gnutls_assert();
302                         goto out;
303                 }
304
305                 ret = gnutls_mutex_init(&_gnutls_pkcs11_mutex);
306                 if (ret < 0) {
307                         gnutls_assert();
308                         goto out;
309                 }
310
311                 ret = gnutls_system_global_init();
312                 if (ret < 0) {
313                         gnutls_assert();
314                         goto out;
315                 }
316                 
317         }
318
319         if (flags & GNUTLS_GLOBAL_INIT_CRYPTO) {
320                 _gnutls_register_accel_crypto();
321
322                 _gnutls_cryptodev_init();
323         }
324
325 #ifdef ENABLE_PKCS11
326         if (flags & GNUTLS_GLOBAL_INIT_PKCS11) {
327                 gnutls_pkcs11_init(GNUTLS_PKCS11_FLAG_AUTO, NULL);
328         }
329 #endif
330
331 #ifdef ENABLE_FIPS140
332         /* Perform FIPS140 checks last, so that all modules
333          * have been loaded */
334         if (flags & GNUTLS_GLOBAL_INIT_MINIMAL) {
335                 res = _gnutls_fips_mode_enabled();
336                 /* res == 1 -> fips140-2 mode enabled
337                  * res == 2 -> only self checks performed - but no failure
338                  * res == not in fips140 mode
339                  */
340                 if (res != 0) {
341                         _gnutls_priority_update_fips();
342
343                         ret = _gnutls_fips_perform_self_checks();
344                         if (res != 2) {
345                                 if (ret < 0) {
346                                         gnutls_assert();
347                                         goto out;
348                                 }
349                         }
350                 }
351         }
352 #endif
353         _gnutls_switch_lib_state(LIB_STATE_OPERATIONAL);
354         ret = 0;
355
356       out:
357         GNUTLS_STATIC_MUTEX_UNLOCK(global_init_mutex);
358         return ret;
359 }
360
361 /**
362  * gnutls_global_init:
363  *
364  * This function performs any required precalculations, detects
365  * the supported CPU capabilities and initializes the underlying
366  * cryptographic backend. In order to free any resources 
367  * taken by this call you should gnutls_global_deinit() 
368  * when gnutls usage is no longer needed.
369  *
370  * This function increments a global counter, so that
371  * gnutls_global_deinit() only releases resources when it has been
372  * called as many times as gnutls_global_init().  This is useful when
373  * GnuTLS is used by more than one library in an application.  This
374  * function can be called many times, but will only do something the
375  * first time.
376  *
377  * Note!  This function is not thread safe.  If two threads call this
378  * function simultaneously, they can cause a race between checking
379  * the global counter and incrementing it, causing both threads to
380  * execute the library initialization code.  That could lead to a
381  * memory leak or even a crash.  To handle this, your application should 
382  * invoke this function after aquiring a thread mutex.  
383  *
384  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned,
385  *   otherwise a negative error code is returned.
386  **/
387 int gnutls_global_init(void)
388 {
389         return gnutls_global_init2(GNUTLS_GLOBAL_INIT_ALL);
390 }
391
392 /**
393  * gnutls_global_deinit:
394  *
395  * This function deinitializes the global data, that were initialized
396  * using gnutls_global_init().
397  *
398  **/
399 void gnutls_global_deinit(void)
400 {
401         GNUTLS_STATIC_MUTEX_LOCK(global_init_mutex);
402         if (_gnutls_init == 1) {
403                 _gnutls_init = 0;
404                 gl_sockets_cleanup();
405                 gnutls_crypto_deinit();
406                 _gnutls_rnd_deinit();
407                 _gnutls_ext_deinit();
408                 asn1_delete_structure(&_gnutls_gnutls_asn);
409                 asn1_delete_structure(&_gnutls_pkix1_asn);
410                 _gnutls_crypto_deregister();
411                 gnutls_system_global_deinit();
412                 
413                 if (loaded_modules & GNUTLS_GLOBAL_INIT_CRYPTO) {
414                         _gnutls_cryptodev_deinit();
415                 }
416 #ifdef ENABLE_PKCS11
417                 if (loaded_modules & GNUTLS_GLOBAL_INIT_PKCS11) {
418                         gnutls_pkcs11_deinit();
419                 }
420 #endif
421
422                 gnutls_mutex_deinit(&_gnutls_file_mutex);
423                 gnutls_mutex_deinit(&_gnutls_pkcs11_mutex);
424                 loaded_modules = 0;
425         } else {
426                 if (_gnutls_init > 0)
427                         _gnutls_init--;
428         }
429         GNUTLS_STATIC_MUTEX_UNLOCK(global_init_mutex);
430 }
431
432 /**
433  * gnutls_check_version:
434  * @req_version: version string to compare with, or %NULL.
435  *
436  * Check GnuTLS Library version.
437  *
438  * See %GNUTLS_VERSION for a suitable @req_version string.
439  *
440  * Returns: Check that the version of the library is at
441  *   minimum the one given as a string in @req_version and return the
442  *   actual version string of the library; return %NULL if the
443  *   condition is not met.  If %NULL is passed to this function no
444  *   check is done and only the version string is returned.
445   **/
446 const char *gnutls_check_version(const char *req_version)
447 {
448         if (!req_version || strverscmp(req_version, VERSION) <= 0)
449                 return VERSION;
450
451         return NULL;
452 }
453
454 #if defined(__GNUC__) || defined(ENABLE_FIPS140)
455 __attribute__((constructor))
456 #endif
457 static void lib_init(void)
458 {
459         if (gnutls_global_init() < 0) {
460                 fprintf(stderr, "Error in GnuTLS initialization");
461                 _gnutls_switch_lib_state(LIB_STATE_ERROR);
462         }
463 }
464
465 #if defined(__GNUC__) || defined(ENABLE_FIPS140)
466 __attribute__((destructor))
467 #endif
468 static void lib_deinit(void)
469 {
470         gnutls_global_deinit();
471 }