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