Replace assert calls by a new gcry_assert at most places.
[libgcrypt.git] / src / fips.c
1 /* fips.c - FIPS mode management
2  * Copyright (C) 2008  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, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include <config.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <errno.h>
24 #include <unistd.h>
25
26 /* #include <dlfcn.h>  /\* FIXME:  GNU only *\/ */
27
28 #include "g10lib.h"
29 #include "ath.h"
30 #include "cipher-proto.h"
31
32 /* The states of the finite state machine used in fips mode.  */
33 enum module_states 
34   {
35     /* POWEROFF cannot be represented.  */
36     STATE_POWERON  = 0,
37     STATE_INIT,
38     STATE_SELFTEST,
39     STATE_OPERATIONAL,
40     STATE_ERROR,
41     STATE_FATALERROR,
42     STATE_SHUTDOWN
43   };
44
45
46 /* Flag telling whether we are in fips mode.  It uses inverse logic so
47    that fips mode is the default unless changed by the intialization
48    code. To check whether fips mode is enabled, use the function
49    fips_mode()! */
50 static int no_fips_mode_required;
51
52 /* This is the lock we use to protect the FSM.  */
53 static ath_mutex_t fsm_lock = ATH_MUTEX_INITIALIZER;
54
55 /* The current state of the FSM.  The whole state machinery is only
56    used while in fips mode. Change this only while holding fsm_lock. */
57 static enum module_states current_state;
58
59
60
61 \f
62 static void fips_new_state (enum module_states new_state);
63
64
65
66 \f
67 /* Check whether the OS is in FIPS mode and record that in a module
68    local variable.  If FORCE is passed as true, fips mode will be
69    enabled anyway. Note: This function is not thread-safe and should
70    be called before any threads are created.  This function may only
71    be called once.  */
72 void
73 _gcry_initialize_fips_mode (int force)
74 {
75   static int done;
76   gpg_error_t err;
77       
78   /* Make sure we are not accidently called twice.  */
79   if (done)
80     {
81       if ( fips_mode () )
82         {
83           fips_new_state (STATE_FATALERROR);
84           fips_noreturn ();
85         }
86       /* If not in fips mode an assert is sufficient.  */
87       gcry_assert (!done);
88     }
89   done = 1;
90
91   /* If the calling applicatione explicitly requested fipsmode, do so.  */
92   if (force)
93     {
94       gcry_assert (!no_fips_mode_required);
95       goto leave;
96     }
97
98   /* For testing the system it is useful to override the system
99      provided detection of the FIPS mode and force FIPS mode using a
100      file.  The filename is hardwired so that there won't be any
101      confusion on whether /etc/gcrypt/ or /usr/local/etc/gcrypt/ is
102      actually used.  The file itself may be empty.  A comment may be
103      included in the file, but comment lines need to be prefixed with
104      a hash mark; only such comment lines and empty lines are
105      allowed.  */
106   if ( !access ("/etc/gcrypt/fips140.force", F_OK) )
107     {
108       gcry_assert (!no_fips_mode_required);
109       goto leave;
110     }
111
112   /* Checking based on /proc file properties.  */
113   {
114     FILE *fp;
115     int saved_errno;
116
117     fp = fopen ("/proc/fips140", "r");
118     if (fp)
119       {
120         char line[256];
121         
122         if (fgets (line, sizeof line, fp) && atoi (line) == 1)
123           {
124             /* System is in fips mode.  */
125             fclose (fp);
126             gcry_assert (!no_fips_mode_required);
127             goto leave;
128           }
129         fclose (fp);
130       }
131     else if ((saved_errno = errno) != ENOENT
132              && !access ("/proc/version", F_OK) )
133       {
134         /* Problem reading the fips file despite that we have the proc
135            file system.  We better stop right away. */
136         log_info ("FATAL: error reading `%s' in libgcrypt: %s\n",
137                   "/proc/fips140", strerror (saved_errno));
138         abort ();
139       }
140   }
141   
142   /* Fips not not requested, set flag.  */
143   no_fips_mode_required = 1;
144
145  leave:
146   if (!no_fips_mode_required)
147     {
148       /* Yes, we are in FIPS mode.  */
149
150       /* Intitialize the lock to protect the FSM.  */
151       err = ath_mutex_init (&fsm_lock);
152       if (err)
153         {
154           /* If that fails we can't do anything but abort the
155              process. We need to use log_info so that the FSM won't
156              get involved.  */
157           log_info ("FATAL: failed to create the FSM lock in libgcrypt: %s\n",
158                      strerror (err));
159           abort ();
160         }
161       
162       /* Now get us into the INIT state.  */
163       fips_new_state (STATE_INIT);
164       
165     }
166   return;
167 }
168
169 static void
170 lock_fsm (void)
171 {
172   gpg_error_t err;
173
174   err = ath_mutex_lock (&fsm_lock);
175   if (err)
176     {
177       log_info ("FATAL: failed to acquire the FSM lock in libgrypt: %s\n", 
178                 strerror (err));
179       abort ();
180     }
181 }
182
183 static void
184 unlock_fsm (void)
185 {
186   gpg_error_t err;
187
188   err = ath_mutex_unlock (&fsm_lock);
189   if (err)
190     {
191       log_info ("FATAL: failed to release the FSM lock in libgrypt: %s\n",
192                 strerror (err));
193       abort ();
194     }
195 }
196
197
198 /* This function returns true if fips mode is enabled.  This is
199    independent of the fips required finite state machine and only used
200    to enable run fips specific code.  Please use the fips_mode macro
201    instead of calling this fucntion directly. */
202 int
203 _gcry_fips_mode (void)
204 {
205   /* No locking is required becuase we have the requirement that this
206      variable is only intialized once with no other threads
207      exiisting.  */
208   return !no_fips_mode_required;
209 }
210
211
212 static const char *
213 state2str (enum module_states state)
214 {
215   const char *s;
216
217   switch (state)
218     {
219     case STATE_POWERON:     s = "Power-On"; break;
220     case STATE_INIT:        s = "Init"; break;
221     case STATE_SELFTEST:    s = "Self-Test"; break;
222     case STATE_OPERATIONAL: s = "Operational"; break;
223     case STATE_ERROR:       s = "Error"; break;
224     case STATE_FATALERROR:  s = "Fatal-Error"; break;
225     case STATE_SHUTDOWN:    s = "Shutdown"; break;
226     default:                s = "?"; break;
227     }
228   return s;
229 }
230
231
232 /* Return true if the library is in the operational state.  */
233 int 
234 _gcry_fips_is_operational (void)
235 {
236   int result;
237
238   if (!fips_mode ())
239     result = 1;
240   else
241     {
242       lock_fsm ();
243       if (current_state == STATE_INIT)
244         {
245           /* If we are still in the INIT state, we need to run the
246              selftests so that the FSM can eventually get into
247              operational state.  Given that we would need a 2-phase
248              initialization of libgcrypt, but that has traditionally
249              not been enforced, we use this on demand self-test
250              checking.  Note that Proper applications would do the
251              application specific libgcrypt initialization between a
252              gcry_check_version() and gcry_control
253              (GCRYCTL_INITIALIZATION_FINISHED) where the latter will
254              run the selftests.  The drawback of these on-demand
255              self-tests are a small chance that self-tests are
256              performed by severeal threads; that is no problem because
257              our FSM make sure that we won't oversee any error. */
258           unlock_fsm ();
259           _gcry_fips_run_selftests ();
260           lock_fsm ();
261         }
262
263       result = (current_state == STATE_OPERATIONAL);
264       unlock_fsm ();
265     }
266   return result;
267 }
268
269
270 /* This is test on wether the library is in the operational state.  In
271    contrast to _gcry_fips_is_operational this function won't do a
272    state transition on the fly.  */
273 int
274 _gcry_fips_test_operational (void)
275 {
276   int result;
277
278   if (!fips_mode ())
279     result = 1;
280   else
281     {
282       lock_fsm ();
283       result = (current_state == STATE_OPERATIONAL);
284       unlock_fsm ();
285     }
286   return result;
287 }
288
289
290 static void
291 reporter (const char *domain, int algo, const char *what, const char *errtxt)
292 {
293   log_info ("libgcrypt selftest: %s %s%s (%d): %s%s%s%s\n",
294             !strcmp (domain, "hmac")? "digest":domain,
295             !strcmp (domain, "hmac")? "HMAC-":"",
296             !strcmp (domain, "cipher")? _gcry_cipher_algo_name (algo) :
297             !strcmp (domain, "digest")? _gcry_md_algo_name (algo) :
298             !strcmp (domain, "hmac")?   _gcry_md_algo_name (algo) :
299             !strcmp (domain, "pubkey")? _gcry_pk_algo_name (algo) : "",
300             algo, errtxt? errtxt:"Okay", 
301             what?" (":"", what? what:"", what?")":""); 
302 }
303
304 /* Run self-tests for all required cipher algorithms.  Return 0 on
305    success. */
306 static int
307 run_cipher_selftests (void)
308 {
309   static int algos[] = 
310     {
311       GCRY_CIPHER_3DES,
312       GCRY_CIPHER_AES128,
313       GCRY_CIPHER_AES192,
314       GCRY_CIPHER_AES256,
315       0
316     };
317   int idx;
318   gpg_error_t err;
319   int anyerr = 0;
320
321   for (idx=0; algos[idx]; idx++)
322     {
323       err = _gcry_cipher_selftest (algos[idx], reporter);
324       reporter ("cipher", algos[idx], NULL,
325                 err? gpg_strerror (err):NULL);
326       if (err)
327         anyerr = 1;
328     }
329   return anyerr;
330 }
331
332
333 /* Run self-tests for all required hash algorithms.  Return 0 on
334    success. */
335 static int
336 run_digest_selftests (void)
337 {
338   static int algos[] = 
339     {
340       GCRY_MD_SHA1,
341       GCRY_MD_SHA224,
342       GCRY_MD_SHA256,
343       GCRY_MD_SHA384,
344       GCRY_MD_SHA512,
345       0
346     };
347   int idx;
348   gpg_error_t err;
349   int anyerr = 0;
350
351   for (idx=0; algos[idx]; idx++)
352     {
353       err = _gcry_md_selftest (algos[idx], reporter);
354       reporter ("digest", algos[idx], NULL,
355                 err? gpg_strerror (err):NULL);
356       if (err)
357         anyerr = 1;
358     }
359   return anyerr;
360 }
361
362
363 /* Run self-tests for all HMAC algorithms.  Return 0 on success. */
364 static int
365 run_hmac_selftests (void)
366 {
367   static int algos[] = 
368     {
369       GCRY_MD_SHA1,
370       GCRY_MD_SHA224,
371       GCRY_MD_SHA256,
372       GCRY_MD_SHA384,
373       GCRY_MD_SHA512,
374       0
375     };
376   int idx;
377   gpg_error_t err;
378   int anyerr = 0;
379
380   for (idx=0; algos[idx]; idx++)
381     {
382       err = _gcry_hmac_selftest (algos[idx], reporter);
383       reporter ("hmac", algos[idx], NULL,
384                 err? gpg_strerror (err):NULL);
385       if (err)
386         anyerr = 1;
387     }
388   return anyerr;
389 }
390
391
392 /* Run self-tests for all required public key algorithms.  Return 0 on
393    success. */
394 static int
395 run_pubkey_selftests (void)
396 {
397   static int algos[] = 
398     {
399       GCRY_PK_RSA,
400       GCRY_PK_DSA,
401       /* GCRY_PK_ECDSA is not enabled in fips mode.  */
402       0
403     };
404   int idx;
405   gpg_error_t err;
406   int anyerr = 0;
407
408   for (idx=0; algos[idx]; idx++)
409     {
410       err = _gcry_pk_selftest (algos[idx], reporter);
411       reporter ("pubkey", algos[idx], NULL,
412                 err? gpg_strerror (err):NULL);
413       if (err)
414         anyerr = 1;
415     }
416   return anyerr;
417 }
418
419
420 /* Run self-tests for the random number generator.  Return 0 on
421    success. */
422 static int
423 run_random_selftests (void)
424 {
425
426   return 0;
427 }
428
429
430 /* Run the self-tests.  */
431 void
432 _gcry_fips_run_selftests (void)
433 {
434   enum module_states result = STATE_ERROR;
435   
436   fips_new_state (STATE_SELFTEST);
437
438 /*   { */
439 /*     Dl_info info; */
440
441 /*     if (dladdr ("gcry_check_version", &info)) */
442 /*       log_info ("DL_info:  fname=`%s'\n", */
443 /*                 info.dli_fname); */
444 /*   } */
445
446
447   if (run_cipher_selftests ())
448     goto leave;
449
450   if (run_digest_selftests ())
451     goto leave;
452
453   if (run_hmac_selftests ())
454     goto leave;
455
456   if (run_pubkey_selftests ())
457     goto leave;
458
459   if (run_random_selftests ())
460     goto leave;
461
462   /* All selftests passed.  */
463   result = STATE_OPERATIONAL;
464
465  leave:
466   fips_new_state (result);
467 }
468
469
470 /* This function is used to tell the FSM about errors in the library.
471    The FSM will be put into an error state.  This function should not
472    be called directly but by one of the macros
473
474      fips_signal_error (description)
475      fips_signal_fatal_error (description)
476
477    where DESCRIPTION is a string describing the error. */
478 void
479 _gcry_fips_signal_error (const char *srcfile, int srcline, const char *srcfunc,
480                          int is_fatal, const char *description)
481 {
482   if (!fips_mode ())
483     return;  /* Not required.  */
484
485   /* Set new state before printing an error.  */
486   fips_new_state (is_fatal? STATE_FATALERROR : STATE_ERROR);
487
488   /* Print error.  */
489   log_info ("%serror in libgcrypt, file %s, line %d%s%s: %s\n",
490             is_fatal? "fatal ":"",
491             srcfile, srcline, 
492             srcfunc? ", function ":"", srcfunc? srcfunc:"",
493             description? description : "no description available");
494 }
495
496
497 /* Perform a state transition to NEW_STATE.  If this is an invalid
498    transition, the module will go into a fatal error state. */
499 static void
500 fips_new_state (enum module_states new_state)
501 {
502   int ok = 0;
503   enum module_states last_state;
504
505   lock_fsm ();
506
507   last_state = current_state;
508   switch (current_state)
509     {
510     case STATE_POWERON:
511       if (new_state == STATE_INIT
512           || new_state == STATE_ERROR
513           || new_state == STATE_FATALERROR)
514         ok = 1;
515       break;
516
517     case STATE_INIT:
518       if (new_state == STATE_SELFTEST )
519         ok = 1;
520       break;
521       
522     case STATE_SELFTEST:
523       if (new_state == STATE_OPERATIONAL
524           || new_state == STATE_ERROR
525           || new_state == STATE_FATALERROR)
526         ok = 1;
527       break;
528       
529     case STATE_OPERATIONAL:
530       if (new_state == STATE_SHUTDOWN 
531           || new_state == STATE_SELFTEST
532           || new_state == STATE_ERROR
533           || new_state == STATE_FATALERROR)
534         ok = 1;
535       break;
536       
537     case STATE_ERROR:
538       if (new_state == STATE_SHUTDOWN
539           || new_state == STATE_INIT)
540         ok = 1;
541       break;
542       
543     case STATE_FATALERROR:
544       if (new_state == STATE_SHUTDOWN )
545         ok = 1;
546       break;
547       
548     case STATE_SHUTDOWN:
549       /* We won't see any transition *from* Shutdown because the only
550          allowed new state is Power-Off and that one can't be
551          represented.  */
552       break;
553       
554     }
555
556   if (ok)
557     {
558       current_state = new_state;
559     }
560
561   unlock_fsm ();
562
563   log_info ("libgcrypt state transition %s => %s %s\n",
564             state2str (last_state), state2str (new_state),
565             ok? "granted":"denied");
566   
567   if (!ok)
568     {
569       /* Invalid state transition.  Halting library. */
570       fips_noreturn ();
571     }
572 }
573
574
575
576
577 /* This function should be called to ensure that the execution shall
578    not continue. */
579 void
580 _gcry_fips_noreturn (void)
581 {
582   fflush (NULL);
583   abort ();
584   /*NOTREACHED*/
585 }