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