Allow transition to Error states from thye Init state.
[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 #include <string.h>
26 #ifdef ENABLE_HMAC_BINARY_CHECK
27 # include <dlfcn.h> 
28 #endif
29 #ifdef HAVE_SYSLOG
30 # include <syslog.h>
31 #endif /*HAVE_SYSLOG*/
32
33 #include "g10lib.h"
34 #include "ath.h"
35 #include "cipher-proto.h"
36 #include "hmac256.h"
37
38 /* The states of the finite state machine used in fips mode.  */
39 enum module_states 
40   {
41     /* POWEROFF cannot be represented.  */
42     STATE_POWERON  = 0,
43     STATE_INIT,
44     STATE_SELFTEST,
45     STATE_OPERATIONAL,
46     STATE_ERROR,
47     STATE_FATALERROR,
48     STATE_SHUTDOWN
49   };
50
51
52 /* Flag telling whether we are in fips mode.  It uses inverse logic so
53    that fips mode is the default unless changed by the intialization
54    code. To check whether fips mode is enabled, use the function
55    fips_mode()! */
56 static int no_fips_mode_required;
57
58 /* This is the lock we use to protect the FSM.  */
59 static ath_mutex_t fsm_lock = ATH_MUTEX_INITIALIZER;
60
61 /* The current state of the FSM.  The whole state machinery is only
62    used while in fips mode. Change this only while holding fsm_lock. */
63 static enum module_states current_state;
64
65
66
67
68 \f
69 static void fips_new_state (enum module_states new_state);
70
71
72 \f
73 /* Convert lowercase hex digits; assumes valid hex digits. */
74 #define loxtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): (*(p)-'a'+10))
75 #define loxtoi_2(p)   ((loxtoi_1(p) * 16) + loxtoi_1((p)+1))
76
77 /* Returns true if P points to a lowercase hex digit. */
78 #define loxdigit_p(p) !!strchr ("01234567890abcdef", *(p))
79
80
81 \f
82 /* Check whether the OS is in FIPS mode and record that in a module
83    local variable.  If FORCE is passed as true, fips mode will be
84    enabled anyway. Note: This function is not thread-safe and should
85    be called before any threads are created.  This function may only
86    be called once.  */
87 void
88 _gcry_initialize_fips_mode (int force)
89 {
90   static int done;
91   gpg_error_t err;
92       
93   /* Make sure we are not accidently called twice.  */
94   if (done)
95     {
96       if ( fips_mode () )
97         {
98           fips_new_state (STATE_FATALERROR);
99           fips_noreturn ();
100         }
101       /* If not in fips mode an assert is sufficient.  */
102       gcry_assert (!done);
103     }
104   done = 1;
105
106   /* If the calling applicatione explicitly requested fipsmode, do so.  */
107   if (force)
108     {
109       gcry_assert (!no_fips_mode_required);
110       goto leave;
111     }
112
113   /* For testing the system it is useful to override the system
114      provided detection of the FIPS mode and force FIPS mode using a
115      file.  The filename is hardwired so that there won't be any
116      confusion on whether /etc/gcrypt/ or /usr/local/etc/gcrypt/ is
117      actually used.  The file itself may be empty.  A comment may be
118      included in the file, but comment lines need to be prefixed with
119      a hash mark; only such comment lines and empty lines are
120      allowed.  */
121   if ( !access ("/etc/gcrypt/fips140.force", F_OK) )
122     {
123       gcry_assert (!no_fips_mode_required);
124       goto leave;
125     }
126
127   /* Checking based on /proc file properties.  */
128   {
129     FILE *fp;
130     int saved_errno;
131     static const char const procfname[] = "/proc/sys/crypto/fips_enabled";
132
133     fp = fopen (procfname, "r");
134     if (fp)
135       {
136         char line[256];
137         
138         if (fgets (line, sizeof line, fp) && atoi (line))
139           {
140             /* System is in fips mode.  */
141             fclose (fp);
142             gcry_assert (!no_fips_mode_required);
143             goto leave;
144           }
145         fclose (fp);
146       }
147     else if ((saved_errno = errno) != ENOENT
148              && !access ("/proc/version", F_OK) )
149       {
150         /* Problem reading the fips file despite that we have the proc
151            file system.  We better stop right away. */
152         log_info ("FATAL: error reading `%s' in libgcrypt: %s\n",
153                   procfname, strerror (saved_errno));
154 #ifdef HAVE_SYSLOG
155         syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
156                 "reading `%s' failed: %s - abort",
157                 procfname, strerror (saved_errno));
158 #endif /*HAVE_SYSLOG*/
159         abort ();
160       }
161   }
162   
163   /* Fips not not requested, set flag.  */
164   no_fips_mode_required = 1;
165
166  leave:
167   if (!no_fips_mode_required)
168     {
169       /* Yes, we are in FIPS mode.  */
170
171       /* Intitialize the lock to protect the FSM.  */
172       err = ath_mutex_init (&fsm_lock);
173       if (err)
174         {
175           /* If that fails we can't do anything but abort the
176              process. We need to use log_info so that the FSM won't
177              get involved.  */
178           log_info ("FATAL: failed to create the FSM lock in libgcrypt: %s\n",
179                      strerror (err));
180 #ifdef HAVE_SYSLOG
181           syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
182                   "creating FSM lock failed: %s - abort",
183                   strerror (err));
184 #endif /*HAVE_SYSLOG*/
185           abort ();
186         }
187       
188       /* Now get us into the INIT state.  */
189       fips_new_state (STATE_INIT);
190       
191     }
192   return;
193 }
194
195 static void
196 lock_fsm (void)
197 {
198   gpg_error_t err;
199
200   err = ath_mutex_lock (&fsm_lock);
201   if (err)
202     {
203       log_info ("FATAL: failed to acquire the FSM lock in libgrypt: %s\n", 
204                 strerror (err));
205 #ifdef HAVE_SYSLOG
206       syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
207               "acquiring FSM lock failed: %s - abort",
208               strerror (err));
209 #endif /*HAVE_SYSLOG*/
210       abort ();
211     }
212 }
213
214 static void
215 unlock_fsm (void)
216 {
217   gpg_error_t err;
218
219   err = ath_mutex_unlock (&fsm_lock);
220   if (err)
221     {
222       log_info ("FATAL: failed to release the FSM lock in libgrypt: %s\n",
223                 strerror (err));
224 #ifdef HAVE_SYSLOG
225       syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
226               "releasing FSM lock failed: %s - abort",
227               strerror (err));
228 #endif /*HAVE_SYSLOG*/
229       abort ();
230     }
231 }
232
233
234 /* This function returns true if fips mode is enabled.  This is
235    independent of the fips required finite state machine and only used
236    to enable fips specific code.  Please use the fips_mode macro
237    instead of calling this function directly. */
238 int
239 _gcry_fips_mode (void)
240 {
241   /* No locking is required becuase we have the requirement that this
242      variable is only intialized once with no other threads
243      exiisting.  */
244   return !no_fips_mode_required;
245 }
246
247
248 static const char *
249 state2str (enum module_states state)
250 {
251   const char *s;
252
253   switch (state)
254     {
255     case STATE_POWERON:     s = "Power-On"; break;
256     case STATE_INIT:        s = "Init"; break;
257     case STATE_SELFTEST:    s = "Self-Test"; break;
258     case STATE_OPERATIONAL: s = "Operational"; break;
259     case STATE_ERROR:       s = "Error"; break;
260     case STATE_FATALERROR:  s = "Fatal-Error"; break;
261     case STATE_SHUTDOWN:    s = "Shutdown"; break;
262     default:                s = "?"; break;
263     }
264   return s;
265 }
266
267
268 /* Return true if the library is in the operational state.  */
269 int 
270 _gcry_fips_is_operational (void)
271 {
272   int result;
273
274   if (!fips_mode ())
275     result = 1;
276   else
277     {
278       lock_fsm ();
279       if (current_state == STATE_INIT)
280         {
281           /* If we are still in the INIT state, we need to run the
282              selftests so that the FSM can eventually get into
283              operational state.  Given that we would need a 2-phase
284              initialization of libgcrypt, but that has traditionally
285              not been enforced, we use this on demand self-test
286              checking.  Note that Proper applications would do the
287              application specific libgcrypt initialization between a
288              gcry_check_version() and gcry_control
289              (GCRYCTL_INITIALIZATION_FINISHED) where the latter will
290              run the selftests.  The drawback of these on-demand
291              self-tests are a small chance that self-tests are
292              performed by severeal threads; that is no problem because
293              our FSM make sure that we won't oversee any error. */
294           unlock_fsm ();
295           _gcry_fips_run_selftests (0);
296           lock_fsm ();
297         }
298
299       result = (current_state == STATE_OPERATIONAL);
300       unlock_fsm ();
301     }
302   return result;
303 }
304
305
306 /* This is test on wether the library is in the operational state.  In
307    contrast to _gcry_fips_is_operational this function won't do a
308    state transition on the fly.  */
309 int
310 _gcry_fips_test_operational (void)
311 {
312   int result;
313
314   if (!fips_mode ())
315     result = 1;
316   else
317     {
318       lock_fsm ();
319       result = (current_state == STATE_OPERATIONAL);
320       unlock_fsm ();
321     }
322   return result;
323 }
324
325
326 /* This is a test on whether the library is in the error or
327    operational state. */
328 int
329 _gcry_fips_test_error_or_operational (void)
330 {
331   int result;
332
333   if (!fips_mode ())
334     result = 1;
335   else
336     {
337       lock_fsm ();
338       result = (current_state == STATE_OPERATIONAL
339                 || current_state == STATE_ERROR);
340       unlock_fsm ();
341     }
342   return result;
343 }
344
345
346 static void
347 reporter (const char *domain, int algo, const char *what, const char *errtxt)
348 {
349   if (!errtxt && !_gcry_log_verbosity (2))
350     return;
351
352   log_info ("libgcrypt selftest: %s %s%s (%d): %s%s%s%s\n",
353             !strcmp (domain, "hmac")? "digest":domain,
354             !strcmp (domain, "hmac")? "HMAC-":"",
355             !strcmp (domain, "cipher")? _gcry_cipher_algo_name (algo) :
356             !strcmp (domain, "digest")? _gcry_md_algo_name (algo) :
357             !strcmp (domain, "hmac")?   _gcry_md_algo_name (algo) :
358             !strcmp (domain, "pubkey")? _gcry_pk_algo_name (algo) : "",
359             algo, errtxt? errtxt:"Okay", 
360             what?" (":"", what? what:"", what?")":""); 
361 }
362
363 /* Run self-tests for all required cipher algorithms.  Return 0 on
364    success. */
365 static int
366 run_cipher_selftests (int extended)
367 {
368   static int algos[] = 
369     {
370       GCRY_CIPHER_3DES,
371       GCRY_CIPHER_AES128,
372       GCRY_CIPHER_AES192,
373       GCRY_CIPHER_AES256,
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_cipher_selftest (algos[idx], extended, reporter);
383       reporter ("cipher", 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 hash algorithms.  Return 0 on
393    success. */
394 static int
395 run_digest_selftests (int extended)
396 {
397   static int algos[] = 
398     {
399       GCRY_MD_SHA1,
400       GCRY_MD_SHA224,
401       GCRY_MD_SHA256,
402       GCRY_MD_SHA384,
403       GCRY_MD_SHA512,
404       0
405     };
406   int idx;
407   gpg_error_t err;
408   int anyerr = 0;
409
410   for (idx=0; algos[idx]; idx++)
411     {
412       err = _gcry_md_selftest (algos[idx], extended, reporter);
413       reporter ("digest", algos[idx], NULL,
414                 err? gpg_strerror (err):NULL);
415       if (err)
416         anyerr = 1;
417     }
418   return anyerr;
419 }
420
421
422 /* Run self-tests for all HMAC algorithms.  Return 0 on success. */
423 static int
424 run_hmac_selftests (int extended)
425 {
426   static int algos[] = 
427     {
428       GCRY_MD_SHA1,
429       GCRY_MD_SHA224,
430       GCRY_MD_SHA256,
431       GCRY_MD_SHA384,
432       GCRY_MD_SHA512,
433       0
434     };
435   int idx;
436   gpg_error_t err;
437   int anyerr = 0;
438
439   for (idx=0; algos[idx]; idx++)
440     {
441       err = _gcry_hmac_selftest (algos[idx], extended, reporter);
442       reporter ("hmac", algos[idx], NULL,
443                 err? gpg_strerror (err):NULL);
444       if (err)
445         anyerr = 1;
446     }
447   return anyerr;
448 }
449
450
451 /* Run self-tests for all required public key algorithms.  Return 0 on
452    success. */
453 static int
454 run_pubkey_selftests (int extended)
455 {
456   static int algos[] = 
457     {
458       GCRY_PK_RSA,
459       GCRY_PK_DSA,
460       /* GCRY_PK_ECDSA is not enabled in fips mode.  */
461       0
462     };
463   int idx;
464   gpg_error_t err;
465   int anyerr = 0;
466
467   for (idx=0; algos[idx]; idx++)
468     {
469       err = _gcry_pk_selftest (algos[idx], extended, reporter);
470       reporter ("pubkey", algos[idx], NULL,
471                 err? gpg_strerror (err):NULL);
472       if (err)
473         anyerr = 1;
474     }
475   return anyerr;
476 }
477
478
479 /* Run self-tests for the random number generator.  Returns 0 on
480    success. */
481 static int
482 run_random_selftests (void)
483 {
484   gpg_error_t err;
485
486   err = _gcry_random_selftest (reporter);
487   reporter ("random", 0, NULL, err? gpg_strerror (err):NULL);
488   
489   return !!err;
490 }
491
492 /* Run an integrity check on the binary.  Returns 0 on success.  */
493 static int
494 check_binary_integrity (void)
495 {
496 #ifdef ENABLE_HMAC_BINARY_CHECK
497   gpg_error_t err;
498   Dl_info info;
499   unsigned char digest[32];
500   int dlen;
501   char *fname = NULL;
502   const char key[] = "What am I, a doctor or a moonshuttle conductor?";
503   
504   if (!dladdr ("gcry_check_version", &info))
505     err = gpg_error_from_syserror ();
506   else
507     {
508       dlen = _gcry_hmac256_file (digest, sizeof digest, info.dli_fname,
509                                  key, strlen (key));
510       if (dlen < 0)
511         err = gpg_error_from_syserror ();
512       else if (dlen != 32)
513         err = gpg_error (GPG_ERR_INTERNAL);
514       else
515         {
516           fname = gcry_malloc (strlen (info.dli_fname) + 1 + 5 + 1 );
517           if (!fname)
518             err = gpg_error_from_syserror ();
519           else
520             {
521               FILE *fp;
522               char *p;
523
524               /* Prefix the basename with a dot.  */
525               strcpy (fname, info.dli_fname);
526               p = strrchr (fname, '/');
527               if (p)
528                 p++;
529               else
530                 p = fname;
531               memmove (p+1, p, strlen (p)+1);
532               *p = '.';
533               strcat (fname, ".hmac");
534
535               /* Open the file.  */
536               fp = fopen (fname, "r");
537               if (!fp)
538                 err = gpg_error_from_syserror ();
539               else
540                 {
541                   /* A buffer of 64 bytes plus one for a LF and one to
542                      detect garbage.  */
543                   unsigned char buffer[64+1+1]; 
544                   const unsigned char *s;
545                   int n;
546
547                   /* The HMAC files consists of lowercase hex digits
548                      only with an optional trailing linefeed.  Fail if
549                      there is any garbage.  */
550                   err = gpg_error (GPG_ERR_SELFTEST_FAILED);
551                   n = fread (buffer, 1, sizeof buffer, fp);
552                   if (n == 64 || (n == 65 && buffer[64] == '\n'))
553                     {
554                       buffer[64] = 0;
555                       for (n=0, s= buffer;
556                            n < 32 && loxdigit_p (s) && loxdigit_p (s+1);
557                            n++, s += 2)
558                         buffer[n] = loxtoi_2 (s);
559                       if ( n == 32 && !memcmp (digest, buffer, 32) )
560                         err = 0;
561                     }
562                   fclose (fp);
563                 }
564             }
565         }
566     }
567   reporter ("binary", 0, fname, err? gpg_strerror (err):NULL);
568 #ifdef HAVE_SYSLOG
569   if (err)
570     syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
571             "integrity check using `%s' failed: %s",
572             fname? fname:"[?]", gpg_strerror (err));
573 #endif /*HAVE_SYSLOG*/
574   gcry_free (fname);
575   return !!err;
576 #else
577   return 0;
578 #endif
579 }
580
581
582 /* Run the self-tests.  If EXTENDED is true, extended versions of the
583    selftest are run, that is more tests than required by FIPS.  */
584 gpg_err_code_t
585 _gcry_fips_run_selftests (int extended)
586 {
587   enum module_states result = STATE_ERROR;
588   gcry_err_code_t ec = GPG_ERR_SELFTEST_FAILED;
589   
590   if (fips_mode ())
591     fips_new_state (STATE_SELFTEST);
592
593   if (run_cipher_selftests (extended))
594     goto leave;
595
596   if (run_digest_selftests (extended))
597     goto leave;
598
599   if (run_hmac_selftests (extended))
600     goto leave;
601
602   /* Run random tests before the pubkey tests because the latter
603      require random.  */
604   if (run_random_selftests ())
605     goto leave;
606
607   if (run_pubkey_selftests (extended))
608     goto leave;
609
610   /* Now check the integrity of the binary.  We do this this after
611      having checked the HMAC code.  */
612   if (check_binary_integrity ())
613     goto leave;
614
615   /* All selftests passed.  */
616   result = STATE_OPERATIONAL;
617   ec = 0;
618
619  leave:
620   if (fips_mode ())
621     fips_new_state (result);
622
623   return ec;
624 }
625
626
627 /* This function is used to tell the FSM about errors in the library.
628    The FSM will be put into an error state.  This function should not
629    be called directly but by one of the macros
630
631      fips_signal_error (description)
632      fips_signal_fatal_error (description)
633
634    where DESCRIPTION is a string describing the error. */
635 void
636 _gcry_fips_signal_error (const char *srcfile, int srcline, const char *srcfunc,
637                          int is_fatal, const char *description)
638 {
639   if (!fips_mode ())
640     return;  /* Not required.  */
641
642   /* Set new state before printing an error.  */
643   fips_new_state (is_fatal? STATE_FATALERROR : STATE_ERROR);
644
645   /* Print error.  */
646   log_info ("%serror in libgcrypt, file %s, line %d%s%s: %s\n",
647             is_fatal? "fatal ":"",
648             srcfile, srcline, 
649             srcfunc? ", function ":"", srcfunc? srcfunc:"",
650             description? description : "no description available");
651 #ifdef HAVE_SYSLOG
652   syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
653           "%serror in file %s, line %d%s%s: %s",
654           is_fatal? "fatal ":"",
655           srcfile, srcline, 
656           srcfunc? ", function ":"", srcfunc? srcfunc:"",
657           description? description : "no description available");
658 #endif /*HAVE_SYSLOG*/
659 }
660
661
662 /* Perform a state transition to NEW_STATE.  If this is an invalid
663    transition, the module will go into a fatal error state. */
664 static void
665 fips_new_state (enum module_states new_state)
666 {
667   int ok = 0;
668   enum module_states last_state;
669
670   lock_fsm ();
671
672   last_state = current_state;
673   switch (current_state)
674     {
675     case STATE_POWERON:
676       if (new_state == STATE_INIT
677           || new_state == STATE_ERROR
678           || new_state == STATE_FATALERROR)
679         ok = 1;
680       break;
681
682     case STATE_INIT:
683       if (new_state == STATE_SELFTEST
684           || new_state == STATE_ERROR
685           || new_state == STATE_FATALERROR)
686         ok = 1;
687       break;
688       
689     case STATE_SELFTEST:
690       if (new_state == STATE_OPERATIONAL
691           || new_state == STATE_ERROR
692           || new_state == STATE_FATALERROR)
693         ok = 1;
694       break;
695       
696     case STATE_OPERATIONAL:
697       if (new_state == STATE_SHUTDOWN 
698           || new_state == STATE_SELFTEST
699           || new_state == STATE_ERROR
700           || new_state == STATE_FATALERROR)
701         ok = 1;
702       break;
703       
704     case STATE_ERROR:
705       if (new_state == STATE_SHUTDOWN
706           || new_state == STATE_FATALERROR
707           || new_state == STATE_SELFTEST)
708         ok = 1;
709       break;
710       
711     case STATE_FATALERROR:
712       if (new_state == STATE_SHUTDOWN )
713         ok = 1;
714       break;
715       
716     case STATE_SHUTDOWN:
717       /* We won't see any transition *from* Shutdown because the only
718          allowed new state is Power-Off and that one can't be
719          represented.  */
720       break;
721       
722     }
723
724   if (ok)
725     {
726       current_state = new_state;
727     }
728
729   unlock_fsm ();
730
731   if (!ok || _gcry_log_verbosity (2))
732     log_info ("libgcrypt state transition %s => %s %s\n",
733               state2str (last_state), state2str (new_state),
734               ok? "granted":"denied");
735   
736   if (!ok)
737     {
738       /* Invalid state transition.  Halting library. */
739 #ifdef HAVE_SYSLOG
740       syslog (LOG_USER|LOG_ERR, 
741               "Libgcrypt error: invalid state transition %s => %s",
742               state2str (last_state), state2str (new_state));
743 #endif /*HAVE_SYSLOG*/
744       fips_noreturn ();
745     }
746   else if (new_state == STATE_ERROR || new_state == STATE_FATALERROR)
747     {
748 #ifdef HAVE_SYSLOG
749       syslog (LOG_USER|LOG_WARNING, 
750               "Libgcrypt notice: state transition %s => %s",
751               state2str (last_state), state2str (new_state));
752 #endif /*HAVE_SYSLOG*/
753     }
754 }
755
756
757
758
759 /* This function should be called to ensure that the execution shall
760    not continue. */
761 void
762 _gcry_fips_noreturn (void)
763 {
764 #ifdef HAVE_SYSLOG
765   syslog (LOG_USER|LOG_ERR, "Libgcrypt terminated the application");
766 #endif /*HAVE_SYSLOG*/
767   fflush (NULL);
768   abort ();
769   /*NOTREACHED*/
770 }