Finished the X9.31 RNG implementations.
[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   char buffer[8];
426
427   /* FIXME: For now we just try to get a few bytes.  */
428   gcry_randomize (buffer, sizeof buffer, GCRY_STRONG_RANDOM);
429
430   return 0;
431 }
432
433
434 /* Run the self-tests.  */
435 void
436 _gcry_fips_run_selftests (void)
437 {
438   enum module_states result = STATE_ERROR;
439   
440   fips_new_state (STATE_SELFTEST);
441
442 /*   { */
443 /*     Dl_info info; */
444
445 /*     if (dladdr ("gcry_check_version", &info)) */
446 /*       log_info ("DL_info:  fname=`%s'\n", */
447 /*                 info.dli_fname); */
448 /*   } */
449
450
451   if (run_cipher_selftests ())
452     goto leave;
453
454   if (run_digest_selftests ())
455     goto leave;
456
457   if (run_hmac_selftests ())
458     goto leave;
459
460   if (run_pubkey_selftests ())
461     goto leave;
462
463   if (run_random_selftests ())
464     goto leave;
465
466   /* All selftests passed.  */
467   result = STATE_OPERATIONAL;
468
469  leave:
470   fips_new_state (result);
471 }
472
473
474 /* This function is used to tell the FSM about errors in the library.
475    The FSM will be put into an error state.  This function should not
476    be called directly but by one of the macros
477
478      fips_signal_error (description)
479      fips_signal_fatal_error (description)
480
481    where DESCRIPTION is a string describing the error. */
482 void
483 _gcry_fips_signal_error (const char *srcfile, int srcline, const char *srcfunc,
484                          int is_fatal, const char *description)
485 {
486   if (!fips_mode ())
487     return;  /* Not required.  */
488
489   /* Set new state before printing an error.  */
490   fips_new_state (is_fatal? STATE_FATALERROR : STATE_ERROR);
491
492   /* Print error.  */
493   log_info ("%serror in libgcrypt, file %s, line %d%s%s: %s\n",
494             is_fatal? "fatal ":"",
495             srcfile, srcline, 
496             srcfunc? ", function ":"", srcfunc? srcfunc:"",
497             description? description : "no description available");
498 }
499
500
501 /* Perform a state transition to NEW_STATE.  If this is an invalid
502    transition, the module will go into a fatal error state. */
503 static void
504 fips_new_state (enum module_states new_state)
505 {
506   int ok = 0;
507   enum module_states last_state;
508
509   lock_fsm ();
510
511   last_state = current_state;
512   switch (current_state)
513     {
514     case STATE_POWERON:
515       if (new_state == STATE_INIT
516           || new_state == STATE_ERROR
517           || new_state == STATE_FATALERROR)
518         ok = 1;
519       break;
520
521     case STATE_INIT:
522       if (new_state == STATE_SELFTEST )
523         ok = 1;
524       break;
525       
526     case STATE_SELFTEST:
527       if (new_state == STATE_OPERATIONAL
528           || new_state == STATE_ERROR
529           || new_state == STATE_FATALERROR)
530         ok = 1;
531       break;
532       
533     case STATE_OPERATIONAL:
534       if (new_state == STATE_SHUTDOWN 
535           || new_state == STATE_SELFTEST
536           || new_state == STATE_ERROR
537           || new_state == STATE_FATALERROR)
538         ok = 1;
539       break;
540       
541     case STATE_ERROR:
542       if (new_state == STATE_SHUTDOWN
543           || new_state == STATE_FATALERROR
544           || new_state == STATE_INIT)
545         ok = 1;
546       break;
547       
548     case STATE_FATALERROR:
549       if (new_state == STATE_SHUTDOWN )
550         ok = 1;
551       break;
552       
553     case STATE_SHUTDOWN:
554       /* We won't see any transition *from* Shutdown because the only
555          allowed new state is Power-Off and that one can't be
556          represented.  */
557       break;
558       
559     }
560
561   if (ok)
562     {
563       current_state = new_state;
564     }
565
566   unlock_fsm ();
567
568   log_info ("libgcrypt state transition %s => %s %s\n",
569             state2str (last_state), state2str (new_state),
570             ok? "granted":"denied");
571   
572   if (!ok)
573     {
574       /* Invalid state transition.  Halting library. */
575       fips_noreturn ();
576     }
577 }
578
579
580
581
582 /* This function should be called to ensure that the execution shall
583    not continue. */
584 void
585 _gcry_fips_noreturn (void)
586 {
587   fflush (NULL);
588   abort ();
589   /*NOTREACHED*/
590 }