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