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