Preparing
[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 intialization
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 = ATH_MUTEX_INITIALIZER;
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              && !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 = ath_mutex_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                      strerror (err));
191 #ifdef HAVE_SYSLOG
192           syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
193                   "creating FSM lock failed: %s - abort",
194                   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 = ath_mutex_lock (&fsm_lock);
225   if (err)
226     {
227       log_info ("FATAL: failed to acquire the FSM lock in libgrypt: %s\n", 
228                 strerror (err));
229 #ifdef HAVE_SYSLOG
230       syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
231               "acquiring FSM lock failed: %s - abort",
232               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 = ath_mutex_unlock (&fsm_lock);
244   if (err)
245     {
246       log_info ("FATAL: failed to release the FSM lock in libgrypt: %s\n",
247                 strerror (err));
248 #ifdef HAVE_SYSLOG
249       syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
250               "releasing FSM lock failed: %s - abort",
251               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   return enforced_fips_mode;
277 }
278
279
280 /* If we do not want to enforce the fips mode, we can set a flag so
281    that the application may check whether it is still in fips mode.
282    TEXT will be printed as part of a syslog message.  This function
283    may only be be called if in fips mode. */
284 void
285 _gcry_inactivate_fips_mode (const char *text)
286 {
287   gcry_assert (_gcry_fips_mode ());
288
289   if (_gcry_enforced_fips_mode () )
290     {
291       /* Get us into the error state. */
292       fips_signal_error (text);
293       return;
294     }
295
296   lock_fsm ();
297   if (!inactive_fips_mode)
298     {
299       inactive_fips_mode = 1;
300       unlock_fsm ();
301 #ifdef HAVE_SYSLOG
302       syslog (LOG_USER|LOG_WARNING, "Libgcrypt warning: "
303               "%s - FIPS mode inactivated", text);
304 #endif /*HAVE_SYSLOG*/
305     }
306   else
307     unlock_fsm ();
308 }
309
310
311 /* Return the FIPS mode inactive flag.  If it is true the FIPS mode is
312    not anymore active.  */
313 int
314 _gcry_is_fips_mode_inactive (void)
315 {
316   int flag;
317
318   if (!_gcry_fips_mode ())
319     return 0;
320   lock_fsm ();
321   flag = inactive_fips_mode;
322   unlock_fsm ();
323   return flag;
324 }
325
326
327
328 static const char *
329 state2str (enum module_states state)
330 {
331   const char *s;
332
333   switch (state)
334     {
335     case STATE_POWERON:     s = "Power-On"; break;
336     case STATE_INIT:        s = "Init"; break;
337     case STATE_SELFTEST:    s = "Self-Test"; break;
338     case STATE_OPERATIONAL: s = "Operational"; break;
339     case STATE_ERROR:       s = "Error"; break;
340     case STATE_FATALERROR:  s = "Fatal-Error"; break;
341     case STATE_SHUTDOWN:    s = "Shutdown"; break;
342     default:                s = "?"; break;
343     }
344   return s;
345 }
346
347
348 /* Return true if the library is in the operational state.  */
349 int 
350 _gcry_fips_is_operational (void)
351 {
352   int result;
353
354   if (!fips_mode ())
355     result = 1;
356   else
357     {
358       lock_fsm ();
359       if (current_state == STATE_INIT)
360         {
361           /* If we are still in the INIT state, we need to run the
362              selftests so that the FSM can eventually get into
363              operational state.  Given that we would need a 2-phase
364              initialization of libgcrypt, but that has traditionally
365              not been enforced, we use this on demand self-test
366              checking.  Note that Proper applications would do the
367              application specific libgcrypt initialization between a
368              gcry_check_version() and gcry_control
369              (GCRYCTL_INITIALIZATION_FINISHED) where the latter will
370              run the selftests.  The drawback of these on-demand
371              self-tests are a small chance that self-tests are
372              performed by severeal threads; that is no problem because
373              our FSM make sure that we won't oversee any error. */
374           unlock_fsm ();
375           _gcry_fips_run_selftests (0);
376           lock_fsm ();
377         }
378
379       result = (current_state == STATE_OPERATIONAL);
380       unlock_fsm ();
381     }
382   return result;
383 }
384
385
386 /* This is test on wether the library is in the operational state.  In
387    contrast to _gcry_fips_is_operational this function won't do a
388    state transition on the fly.  */
389 int
390 _gcry_fips_test_operational (void)
391 {
392   int result;
393
394   if (!fips_mode ())
395     result = 1;
396   else
397     {
398       lock_fsm ();
399       result = (current_state == STATE_OPERATIONAL);
400       unlock_fsm ();
401     }
402   return result;
403 }
404
405
406 /* This is a test on whether the library is in the error or
407    operational state. */
408 int
409 _gcry_fips_test_error_or_operational (void)
410 {
411   int result;
412
413   if (!fips_mode ())
414     result = 1;
415   else
416     {
417       lock_fsm ();
418       result = (current_state == STATE_OPERATIONAL
419                 || current_state == STATE_ERROR);
420       unlock_fsm ();
421     }
422   return result;
423 }
424
425
426 static void
427 reporter (const char *domain, int algo, const char *what, const char *errtxt)
428 {
429   if (!errtxt && !_gcry_log_verbosity (2))
430     return;
431
432   log_info ("libgcrypt selftest: %s %s%s (%d): %s%s%s%s\n",
433             !strcmp (domain, "hmac")? "digest":domain,
434             !strcmp (domain, "hmac")? "HMAC-":"",
435             !strcmp (domain, "cipher")? _gcry_cipher_algo_name (algo) :
436             !strcmp (domain, "digest")? _gcry_md_algo_name (algo) :
437             !strcmp (domain, "hmac")?   _gcry_md_algo_name (algo) :
438             !strcmp (domain, "pubkey")? _gcry_pk_algo_name (algo) : "",
439             algo, errtxt? errtxt:"Okay", 
440             what?" (":"", what? what:"", what?")":""); 
441 }
442
443 /* Run self-tests for all required cipher algorithms.  Return 0 on
444    success. */
445 static int
446 run_cipher_selftests (int extended)
447 {
448   static int algos[] = 
449     {
450       GCRY_CIPHER_3DES,
451       GCRY_CIPHER_AES128,
452       GCRY_CIPHER_AES192,
453       GCRY_CIPHER_AES256,
454       0
455     };
456   int idx;
457   gpg_error_t err;
458   int anyerr = 0;
459
460   for (idx=0; algos[idx]; idx++)
461     {
462       err = _gcry_cipher_selftest (algos[idx], extended, reporter);
463       reporter ("cipher", algos[idx], NULL,
464                 err? gpg_strerror (err):NULL);
465       if (err)
466         anyerr = 1;
467     }
468   return anyerr;
469 }
470
471
472 /* Run self-tests for all required hash algorithms.  Return 0 on
473    success. */
474 static int
475 run_digest_selftests (int extended)
476 {
477   static int algos[] = 
478     {
479       GCRY_MD_SHA1,
480       GCRY_MD_SHA224,
481       GCRY_MD_SHA256,
482       GCRY_MD_SHA384,
483       GCRY_MD_SHA512,
484       0
485     };
486   int idx;
487   gpg_error_t err;
488   int anyerr = 0;
489
490   for (idx=0; algos[idx]; idx++)
491     {
492       err = _gcry_md_selftest (algos[idx], extended, reporter);
493       reporter ("digest", algos[idx], NULL,
494                 err? gpg_strerror (err):NULL);
495       if (err)
496         anyerr = 1;
497     }
498   return anyerr;
499 }
500
501
502 /* Run self-tests for all HMAC algorithms.  Return 0 on success. */
503 static int
504 run_hmac_selftests (int extended)
505 {
506   static int algos[] = 
507     {
508       GCRY_MD_SHA1,
509       GCRY_MD_SHA224,
510       GCRY_MD_SHA256,
511       GCRY_MD_SHA384,
512       GCRY_MD_SHA512,
513       0
514     };
515   int idx;
516   gpg_error_t err;
517   int anyerr = 0;
518
519   for (idx=0; algos[idx]; idx++)
520     {
521       err = _gcry_hmac_selftest (algos[idx], extended, reporter);
522       reporter ("hmac", algos[idx], NULL,
523                 err? gpg_strerror (err):NULL);
524       if (err)
525         anyerr = 1;
526     }
527   return anyerr;
528 }
529
530
531 /* Run self-tests for all required public key algorithms.  Return 0 on
532    success. */
533 static int
534 run_pubkey_selftests (int extended)
535 {
536   static int algos[] = 
537     {
538       GCRY_PK_RSA,
539       GCRY_PK_DSA,
540       /* GCRY_PK_ECDSA is not enabled in fips mode.  */
541       0
542     };
543   int idx;
544   gpg_error_t err;
545   int anyerr = 0;
546
547   for (idx=0; algos[idx]; idx++)
548     {
549       err = _gcry_pk_selftest (algos[idx], extended, reporter);
550       reporter ("pubkey", algos[idx], NULL,
551                 err? gpg_strerror (err):NULL);
552       if (err)
553         anyerr = 1;
554     }
555   return anyerr;
556 }
557
558
559 /* Run self-tests for the random number generator.  Returns 0 on
560    success. */
561 static int
562 run_random_selftests (void)
563 {
564   gpg_error_t err;
565
566   err = _gcry_random_selftest (reporter);
567   reporter ("random", 0, NULL, err? gpg_strerror (err):NULL);
568   
569   return !!err;
570 }
571
572 /* Run an integrity check on the binary.  Returns 0 on success.  */
573 static int
574 check_binary_integrity (void)
575 {
576 #ifdef ENABLE_HMAC_BINARY_CHECK
577   gpg_error_t err;
578   Dl_info info;
579   unsigned char digest[32];
580   int dlen;
581   char *fname = NULL;
582   const char key[] = "What am I, a doctor or a moonshuttle conductor?";
583   
584   if (!dladdr ("gcry_check_version", &info))
585     err = gpg_error_from_syserror ();
586   else
587     {
588       dlen = _gcry_hmac256_file (digest, sizeof digest, info.dli_fname,
589                                  key, strlen (key));
590       if (dlen < 0)
591         err = gpg_error_from_syserror ();
592       else if (dlen != 32)
593         err = gpg_error (GPG_ERR_INTERNAL);
594       else
595         {
596           fname = gcry_malloc (strlen (info.dli_fname) + 1 + 5 + 1 );
597           if (!fname)
598             err = gpg_error_from_syserror ();
599           else
600             {
601               FILE *fp;
602               char *p;
603
604               /* Prefix the basename with a dot.  */
605               strcpy (fname, info.dli_fname);
606               p = strrchr (fname, '/');
607               if (p)
608                 p++;
609               else
610                 p = fname;
611               memmove (p+1, p, strlen (p)+1);
612               *p = '.';
613               strcat (fname, ".hmac");
614
615               /* Open the file.  */
616               fp = fopen (fname, "r");
617               if (!fp)
618                 err = gpg_error_from_syserror ();
619               else
620                 {
621                   /* A buffer of 64 bytes plus one for a LF and one to
622                      detect garbage.  */
623                   unsigned char buffer[64+1+1]; 
624                   const unsigned char *s;
625                   int n;
626
627                   /* The HMAC files consists of lowercase hex digits
628                      only with an optional trailing linefeed.  Fail if
629                      there is any garbage.  */
630                   err = gpg_error (GPG_ERR_SELFTEST_FAILED);
631                   n = fread (buffer, 1, sizeof buffer, fp);
632                   if (n == 64 || (n == 65 && buffer[64] == '\n'))
633                     {
634                       buffer[64] = 0;
635                       for (n=0, s= buffer;
636                            n < 32 && loxdigit_p (s) && loxdigit_p (s+1);
637                            n++, s += 2)
638                         buffer[n] = loxtoi_2 (s);
639                       if ( n == 32 && !memcmp (digest, buffer, 32) )
640                         err = 0;
641                     }
642                   fclose (fp);
643                 }
644             }
645         }
646     }
647   reporter ("binary", 0, fname, err? gpg_strerror (err):NULL);
648 #ifdef HAVE_SYSLOG
649   if (err)
650     syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
651             "integrity check using `%s' failed: %s",
652             fname? fname:"[?]", gpg_strerror (err));
653 #endif /*HAVE_SYSLOG*/
654   gcry_free (fname);
655   return !!err;
656 #else
657   return 0;
658 #endif
659 }
660
661
662 /* Run the self-tests.  If EXTENDED is true, extended versions of the
663    selftest are run, that is more tests than required by FIPS.  */
664 gpg_err_code_t
665 _gcry_fips_run_selftests (int extended)
666 {
667   enum module_states result = STATE_ERROR;
668   gcry_err_code_t ec = GPG_ERR_SELFTEST_FAILED;
669   
670   if (fips_mode ())
671     fips_new_state (STATE_SELFTEST);
672
673   if (run_cipher_selftests (extended))
674     goto leave;
675
676   if (run_digest_selftests (extended))
677     goto leave;
678
679   if (run_hmac_selftests (extended))
680     goto leave;
681
682   /* Run random tests before the pubkey tests because the latter
683      require random.  */
684   if (run_random_selftests ())
685     goto leave;
686
687   if (run_pubkey_selftests (extended))
688     goto leave;
689
690   /* Now check the integrity of the binary.  We do this this after
691      having checked the HMAC code.  */
692   if (check_binary_integrity ())
693     goto leave;
694
695   /* All selftests passed.  */
696   result = STATE_OPERATIONAL;
697   ec = 0;
698
699  leave:
700   if (fips_mode ())
701     fips_new_state (result);
702
703   return ec;
704 }
705
706
707 /* This function is used to tell the FSM about errors in the library.
708    The FSM will be put into an error state.  This function should not
709    be called directly but by one of the macros
710
711      fips_signal_error (description)
712      fips_signal_fatal_error (description)
713
714    where DESCRIPTION is a string describing the error. */
715 void
716 _gcry_fips_signal_error (const char *srcfile, int srcline, const char *srcfunc,
717                          int is_fatal, const char *description)
718 {
719   if (!fips_mode ())
720     return;  /* Not required.  */
721
722   /* Set new state before printing an error.  */
723   fips_new_state (is_fatal? STATE_FATALERROR : STATE_ERROR);
724
725   /* Print error.  */
726   log_info ("%serror in libgcrypt, file %s, line %d%s%s: %s\n",
727             is_fatal? "fatal ":"",
728             srcfile, srcline, 
729             srcfunc? ", function ":"", srcfunc? srcfunc:"",
730             description? description : "no description available");
731 #ifdef HAVE_SYSLOG
732   syslog (LOG_USER|LOG_ERR, "Libgcrypt error: "
733           "%serror in file %s, line %d%s%s: %s",
734           is_fatal? "fatal ":"",
735           srcfile, srcline, 
736           srcfunc? ", function ":"", srcfunc? srcfunc:"",
737           description? description : "no description available");
738 #endif /*HAVE_SYSLOG*/
739 }
740
741
742 /* Perform a state transition to NEW_STATE.  If this is an invalid
743    transition, the module will go into a fatal error state. */
744 static void
745 fips_new_state (enum module_states new_state)
746 {
747   int ok = 0;
748   enum module_states last_state;
749
750   lock_fsm ();
751
752   last_state = current_state;
753   switch (current_state)
754     {
755     case STATE_POWERON:
756       if (new_state == STATE_INIT
757           || new_state == STATE_ERROR
758           || new_state == STATE_FATALERROR)
759         ok = 1;
760       break;
761
762     case STATE_INIT:
763       if (new_state == STATE_SELFTEST
764           || new_state == STATE_ERROR
765           || new_state == STATE_FATALERROR)
766         ok = 1;
767       break;
768       
769     case STATE_SELFTEST:
770       if (new_state == STATE_OPERATIONAL
771           || new_state == STATE_ERROR
772           || new_state == STATE_FATALERROR)
773         ok = 1;
774       break;
775       
776     case STATE_OPERATIONAL:
777       if (new_state == STATE_SHUTDOWN 
778           || new_state == STATE_SELFTEST
779           || new_state == STATE_ERROR
780           || new_state == STATE_FATALERROR)
781         ok = 1;
782       break;
783       
784     case STATE_ERROR:
785       if (new_state == STATE_SHUTDOWN
786           || new_state == STATE_ERROR
787           || new_state == STATE_FATALERROR
788           || new_state == STATE_SELFTEST)
789         ok = 1;
790       break;
791       
792     case STATE_FATALERROR:
793       if (new_state == STATE_SHUTDOWN )
794         ok = 1;
795       break;
796       
797     case STATE_SHUTDOWN:
798       /* We won't see any transition *from* Shutdown because the only
799          allowed new state is Power-Off and that one can't be
800          represented.  */
801       break;
802       
803     }
804
805   if (ok)
806     {
807       current_state = new_state;
808     }
809
810   unlock_fsm ();
811
812   if (!ok || _gcry_log_verbosity (2))
813     log_info ("libgcrypt state transition %s => %s %s\n",
814               state2str (last_state), state2str (new_state),
815               ok? "granted":"denied");
816   
817   if (!ok)
818     {
819       /* Invalid state transition.  Halting library. */
820 #ifdef HAVE_SYSLOG
821       syslog (LOG_USER|LOG_ERR, 
822               "Libgcrypt error: invalid state transition %s => %s",
823               state2str (last_state), state2str (new_state));
824 #endif /*HAVE_SYSLOG*/
825       fips_noreturn ();
826     }
827   else if (new_state == STATE_ERROR || new_state == STATE_FATALERROR)
828     {
829 #ifdef HAVE_SYSLOG
830       syslog (LOG_USER|LOG_WARNING, 
831               "Libgcrypt notice: state transition %s => %s",
832               state2str (last_state), state2str (new_state));
833 #endif /*HAVE_SYSLOG*/
834     }
835 }
836
837
838
839
840 /* This function should be called to ensure that the execution shall
841    not continue. */
842 void
843 _gcry_fips_noreturn (void)
844 {
845 #ifdef HAVE_SYSLOG
846   syslog (LOG_USER|LOG_ERR, "Libgcrypt terminated the application");
847 #endif /*HAVE_SYSLOG*/
848   fflush (NULL);
849   abort ();
850   /*NOTREACHED*/
851 }