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