Implemented transient-key flag as requested by the GNUNet folks.
[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 static void
293 reporter (const char *domain, int algo, const char *what, const char *errtxt)
294 {
295   if (!errtxt && !_gcry_log_verbosity (2))
296     return;
297
298   log_info ("libgcrypt selftest: %s %s%s (%d): %s%s%s%s\n",
299             !strcmp (domain, "hmac")? "digest":domain,
300             !strcmp (domain, "hmac")? "HMAC-":"",
301             !strcmp (domain, "cipher")? _gcry_cipher_algo_name (algo) :
302             !strcmp (domain, "digest")? _gcry_md_algo_name (algo) :
303             !strcmp (domain, "hmac")?   _gcry_md_algo_name (algo) :
304             !strcmp (domain, "pubkey")? _gcry_pk_algo_name (algo) : "",
305             algo, errtxt? errtxt:"Okay", 
306             what?" (":"", what? what:"", what?")":""); 
307 }
308
309 /* Run self-tests for all required cipher algorithms.  Return 0 on
310    success. */
311 static int
312 run_cipher_selftests (void)
313 {
314   static int algos[] = 
315     {
316       GCRY_CIPHER_3DES,
317       GCRY_CIPHER_AES128,
318       GCRY_CIPHER_AES192,
319       GCRY_CIPHER_AES256,
320       0
321     };
322   int idx;
323   gpg_error_t err;
324   int anyerr = 0;
325
326   for (idx=0; algos[idx]; idx++)
327     {
328       err = _gcry_cipher_selftest (algos[idx], reporter);
329       reporter ("cipher", algos[idx], NULL,
330                 err? gpg_strerror (err):NULL);
331       if (err)
332         anyerr = 1;
333     }
334   return anyerr;
335 }
336
337
338 /* Run self-tests for all required hash algorithms.  Return 0 on
339    success. */
340 static int
341 run_digest_selftests (void)
342 {
343   static int algos[] = 
344     {
345       GCRY_MD_SHA1,
346       GCRY_MD_SHA224,
347       GCRY_MD_SHA256,
348       GCRY_MD_SHA384,
349       GCRY_MD_SHA512,
350       0
351     };
352   int idx;
353   gpg_error_t err;
354   int anyerr = 0;
355
356   for (idx=0; algos[idx]; idx++)
357     {
358       err = _gcry_md_selftest (algos[idx], reporter);
359       reporter ("digest", algos[idx], NULL,
360                 err? gpg_strerror (err):NULL);
361       if (err)
362         anyerr = 1;
363     }
364   return anyerr;
365 }
366
367
368 /* Run self-tests for all HMAC algorithms.  Return 0 on success. */
369 static int
370 run_hmac_selftests (void)
371 {
372   static int algos[] = 
373     {
374       GCRY_MD_SHA1,
375       GCRY_MD_SHA224,
376       GCRY_MD_SHA256,
377       GCRY_MD_SHA384,
378       GCRY_MD_SHA512,
379       0
380     };
381   int idx;
382   gpg_error_t err;
383   int anyerr = 0;
384
385   for (idx=0; algos[idx]; idx++)
386     {
387       err = _gcry_hmac_selftest (algos[idx], reporter);
388       reporter ("hmac", algos[idx], NULL,
389                 err? gpg_strerror (err):NULL);
390       if (err)
391         anyerr = 1;
392     }
393   return anyerr;
394 }
395
396
397 /* Run self-tests for all required public key algorithms.  Return 0 on
398    success. */
399 static int
400 run_pubkey_selftests (void)
401 {
402   static int algos[] = 
403     {
404       GCRY_PK_RSA,
405       GCRY_PK_DSA,
406       /* GCRY_PK_ECDSA is not enabled in fips mode.  */
407       0
408     };
409   int idx;
410   gpg_error_t err;
411   int anyerr = 0;
412
413   for (idx=0; algos[idx]; idx++)
414     {
415       err = _gcry_pk_selftest (algos[idx], reporter);
416       reporter ("pubkey", algos[idx], NULL,
417                 err? gpg_strerror (err):NULL);
418       if (err)
419         anyerr = 1;
420     }
421   return anyerr;
422 }
423
424
425 /* Run self-tests for the random number generator.  Returns 0 on
426    success. */
427 static int
428 run_random_selftests (void)
429 {
430   gpg_error_t err;
431
432   err = _gcry_random_selftest (reporter);
433   reporter ("random", 0, NULL, err? gpg_strerror (err):NULL);
434   
435   return !!err;
436 }
437
438 /* Run an integrity check on the binary.  Returns 0 on success.  */
439 static int
440 check_binary_integrity (void)
441 {
442 #ifdef ENABLE_HMAC_BINARY_CHECK
443   gpg_error_t err;
444   Dl_info info;
445   unsigned char digest[32];
446   int dlen;
447   char *fname = NULL;
448   const char key[] = "What am I, a doctor or a moonshuttle conductor?";
449   
450   if (!dladdr ("gcry_check_version", &info))
451     err = gpg_error_from_syserror ();
452   else
453     {
454       dlen = _gcry_hmac256_file (digest, sizeof digest, info.dli_fname,
455                                  key, strlen (key));
456       if (dlen < 0)
457         err = gpg_error_from_syserror ();
458       else if (dlen != 32)
459         err = gpg_error (GPG_ERR_INTERNAL);
460       else
461         {
462           FILE *fp;
463   
464           fname = gcry_malloc (strlen (info.dli_fname) + 5 + 1 );
465           if (!fname)
466             err = gpg_error_from_syserror ();
467           else
468             {
469               strcpy (stpcpy (fname, info.dli_fname), ".hmac");
470               fp = fopen (fname, "rb");
471               if (!fp)
472                 err = gpg_error_from_syserror ();
473               else
474                 {
475                   char buffer[33];
476                   int n;
477
478                   /* We expect a file of exactly 32 bytes.  Consider
479                      the self-test failed if this is not the case or
480                      if it does not match the just computed HMAC.  */
481                   if ((n=fread (buffer, 1, 33, fp)) != 32
482                       || memcmp (digest, buffer, 32) )
483                     err = gpg_error (GPG_ERR_SELFTEST_FAILED);
484                   else
485                     err = 0;
486
487                   fclose (fp);
488                 }
489             }
490         }
491     }
492   reporter ("binary", 0, fname, err? gpg_strerror (err):NULL);
493   gcry_free (fname);
494   return !!err;
495 #else
496   return 0;
497 #endif
498 }
499
500
501 /* Run the self-tests.  */
502 void
503 _gcry_fips_run_selftests (void)
504 {
505   enum module_states result = STATE_ERROR;
506   
507   fips_new_state (STATE_SELFTEST);
508
509   if (run_cipher_selftests ())
510     goto leave;
511
512   if (run_digest_selftests ())
513     goto leave;
514
515   if (run_hmac_selftests ())
516     goto leave;
517
518   if (run_pubkey_selftests ())
519     goto leave;
520
521   if (run_random_selftests ())
522     goto leave;
523
524   /* Now check the integrity of the binary.  We do this this after
525      having checked the HMAC code.  */
526   if (check_binary_integrity ())
527     goto leave;
528
529   /* All selftests passed.  */
530   result = STATE_OPERATIONAL;
531
532  leave:
533   fips_new_state (result);
534 }
535
536
537 /* This function is used to tell the FSM about errors in the library.
538    The FSM will be put into an error state.  This function should not
539    be called directly but by one of the macros
540
541      fips_signal_error (description)
542      fips_signal_fatal_error (description)
543
544    where DESCRIPTION is a string describing the error. */
545 void
546 _gcry_fips_signal_error (const char *srcfile, int srcline, const char *srcfunc,
547                          int is_fatal, const char *description)
548 {
549   if (!fips_mode ())
550     return;  /* Not required.  */
551
552   /* Set new state before printing an error.  */
553   fips_new_state (is_fatal? STATE_FATALERROR : STATE_ERROR);
554
555   /* Print error.  */
556   log_info ("%serror in libgcrypt, file %s, line %d%s%s: %s\n",
557             is_fatal? "fatal ":"",
558             srcfile, srcline, 
559             srcfunc? ", function ":"", srcfunc? srcfunc:"",
560             description? description : "no description available");
561 }
562
563
564 /* Perform a state transition to NEW_STATE.  If this is an invalid
565    transition, the module will go into a fatal error state. */
566 static void
567 fips_new_state (enum module_states new_state)
568 {
569   int ok = 0;
570   enum module_states last_state;
571
572   lock_fsm ();
573
574   last_state = current_state;
575   switch (current_state)
576     {
577     case STATE_POWERON:
578       if (new_state == STATE_INIT
579           || new_state == STATE_ERROR
580           || new_state == STATE_FATALERROR)
581         ok = 1;
582       break;
583
584     case STATE_INIT:
585       if (new_state == STATE_SELFTEST )
586         ok = 1;
587       break;
588       
589     case STATE_SELFTEST:
590       if (new_state == STATE_OPERATIONAL
591           || new_state == STATE_ERROR
592           || new_state == STATE_FATALERROR)
593         ok = 1;
594       break;
595       
596     case STATE_OPERATIONAL:
597       if (new_state == STATE_SHUTDOWN 
598           || new_state == STATE_SELFTEST
599           || new_state == STATE_ERROR
600           || new_state == STATE_FATALERROR)
601         ok = 1;
602       break;
603       
604     case STATE_ERROR:
605       if (new_state == STATE_SHUTDOWN
606           || new_state == STATE_FATALERROR
607           || new_state == STATE_INIT)
608         ok = 1;
609       break;
610       
611     case STATE_FATALERROR:
612       if (new_state == STATE_SHUTDOWN )
613         ok = 1;
614       break;
615       
616     case STATE_SHUTDOWN:
617       /* We won't see any transition *from* Shutdown because the only
618          allowed new state is Power-Off and that one can't be
619          represented.  */
620       break;
621       
622     }
623
624   if (ok)
625     {
626       current_state = new_state;
627     }
628
629   unlock_fsm ();
630
631   if (!ok || _gcry_log_verbosity (2))
632     log_info ("libgcrypt state transition %s => %s %s\n",
633               state2str (last_state), state2str (new_state),
634               ok? "granted":"denied");
635   
636   if (!ok)
637     {
638       /* Invalid state transition.  Halting library. */
639       fips_noreturn ();
640     }
641 }
642
643
644
645
646 /* This function should be called to ensure that the execution shall
647    not continue. */
648 void
649 _gcry_fips_noreturn (void)
650 {
651   fflush (NULL);
652   abort ();
653   /*NOTREACHED*/
654 }