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