A lot of cleanups as well as minor API changes.
[libgcrypt.git] / src / gcryptrnd.c
1 /* gcryptrnd.c - Libgcrypt Random Number Daemon
2  * Copyright (C) 2006 Free Software Foundation, Inc.
3  *
4  * Gcryptend is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published
6  * by the Free Software Foundation; either version 2 of the License,
7  * or (at your option) any later version.
8  *
9  * Gcryptrnd is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  */
19
20 /* We require vsyslog pth
21    We need to test for:  setrlimit
22
23    We should also prioritize requests.  This is best done by putting
24    the requests into queues and have a main thread processing these
25    queues.
26
27  */
28
29 #include <config.h>
30 #include <stdio.h>
31 #include <stddef.h>
32 #include <stdlib.h>
33 #include <assert.h>
34 #include <time.h>
35 #include <sys/times.h>
36 #include <sys/types.h>
37 #include <sys/stat.h>
38 #include <stdarg.h>
39 #include <syslog.h>
40 #include <sys/socket.h>
41 #include <sys/un.h>
42 #include <unistd.h>
43 #include <errno.h>
44 #include <pth.h>
45 #include <gcrypt.h>
46
47 #define PGM "gcryptrnd"
48 #define MYVERSION_LINE PGM " (Libgcrypt) " VERSION
49 #define BUGREPORT_LINE "\nReport bugs to <bug-libgcrypt@gnupg.org>.\n"
50
51 /* Pth wrapper function definitions. */
52 GCRY_THREAD_OPTION_PTH_IMPL;
53
54
55 /* Flag set to true if we have been daemonized. */
56 static int running_detached;
57 /* Flag indicating that a shutdown has been requested.  */
58 static int shutdown_pending;
59 /* Counter for active connections.  */
60 static int active_connections;
61
62
63
64 /* Local prototypes.  */
65 static void serve (int listen_fd);
66
67
68
69 \f
70
71 /* To avoid that a compiler optimizes certain memset calls away, these
72    macros may be used instead. */
73 #define wipememory2(_ptr,_set,_len) do { \
74               volatile char *_vptr=(volatile char *)(_ptr); \
75               size_t _vlen=(_len); \
76               while(_vlen) { *_vptr=(_set); _vptr++; _vlen--; } \
77                   } while(0)
78 #define wipememory(_ptr,_len) wipememory2(_ptr,0,_len)
79
80
81
82
83 /* Error printing utility.  PRIORITY should be one of syslog's
84    priority levels.  This fucntions prints to the stderro or syslog
85    depending on whether we are already daemonized. */
86 static void
87 logit (int priority, const char *format, ...)
88 {
89   va_list arg_ptr;
90
91   va_start (arg_ptr, format) ;
92   if (running_detached)
93     {
94       vsyslog (priority, format, arg_ptr);
95     }
96   else
97     {
98       fputs (PGM ": ", stderr);
99       vfprintf (stderr, format, arg_ptr);
100       putc ('\n', stderr);
101     }
102   va_end (arg_ptr);
103 }
104
105 /* Callback used by libgcrypt for logging. */
106 static void
107 my_gcry_logger (void *dummy, int level, const char *format, va_list arg_ptr)
108 {
109   (void)dummy;
110
111   /* Map the log levels. */
112   switch (level)
113     {
114     case GCRY_LOG_CONT: level = LOG_INFO /* FIXME */; break;
115     case GCRY_LOG_INFO: level = LOG_INFO; break;
116     case GCRY_LOG_WARN: level = LOG_WARNING; break;
117     case GCRY_LOG_ERROR:level = LOG_ERR; break;
118     case GCRY_LOG_FATAL:level = LOG_CRIT; break;
119     case GCRY_LOG_BUG:  level = LOG_CRIT; break;
120     case GCRY_LOG_DEBUG:level = LOG_DEBUG; break;
121     default:            level = LOG_ERR; break;  
122     }
123   if (running_detached)
124     {
125       vsyslog (level, format, arg_ptr);
126     }
127   else
128     {
129       fputs (PGM ": ", stderr);
130       vfprintf (stderr, format, arg_ptr);
131       if (!*format || format[strlen (format)-1] != '\n')
132         putc ('\n', stderr);
133     }
134 }
135
136
137 /* The cleanup handler - used to wipe out the secure memory. */
138 static void
139 cleanup (void)
140 {
141   gcry_control (GCRYCTL_TERM_SECMEM );
142 }
143
144
145 /* Make us a daemon and open the syslog. */
146 static void
147 daemonize (void)
148 {
149   int i;
150   pid_t pid;
151
152   fflush (NULL);
153
154   pid = fork ();
155   if (pid == (pid_t)-1) 
156     {
157       logit (LOG_CRIT, "fork failed: %s", strerror (errno));
158       exit (1);
159     }
160   if (pid)
161     exit (0); 
162
163   if (setsid() == -1)
164     {
165       logit (LOG_CRIT, "setsid() failed: %s", strerror(errno));
166       exit (1);
167     }
168   
169   signal (SIGHUP, SIG_IGN);
170
171   pid = fork ();
172   if (pid == (pid_t)-1) 
173     {
174       logit (LOG_CRIT, PGM ": second fork failed: %s", strerror (errno));
175       exit (1);
176     }
177   if (pid)
178     exit (0); /* First child exits. */
179
180   running_detached = 1;
181
182   if (chdir("/"))
183     {
184       logit (LOG_CRIT, "chdir(\"/\") failed: %s", strerror (errno));
185       exit (1);
186     }
187   umask (0);
188
189   for (i=0; i <= 2; i++)
190     close (i);
191
192   openlog (PGM, LOG_PID, LOG_DAEMON);
193 }
194
195
196 static void
197 disable_core_dumps (void)
198 {
199 #ifdef HAVE_SETRLIMIT
200   struct rlimit limit;
201
202   if (getrlimit (RLIMIT_CORE, &limit))
203     limit.rlim_max = 0;
204   limit.rlim_cur = 0;
205   if( !setrlimit (RLIMIT_CORE, &limit) )
206     return 0;
207   if (errno != EINVAL && errno != ENOSYS)
208     logit (LOG_ERR, "can't disable core dumps: %s\n", strerror (errno));
209 #endif /* HAVE_SETRLIMIT */
210 }
211
212
213
214 static void
215 print_version (int with_help)
216 {
217   fputs (MYVERSION_LINE "\n"
218          "Copyright (C) 2006 Free Software Foundation, Inc.\n"
219          "This program comes with ABSOLUTELY NO WARRANTY.\n"
220          "This is free software, and you are welcome to redistribute it\n"
221          "under certain conditions. See the file COPYING for details.\n",
222          stdout);
223         
224   if (with_help)
225     fputs ("\n"
226            "Usage: " PGM " [OPTIONS] [SOCKETNAME]\n"
227            "Start Libgcrypt's random number daemon listening"
228            " on socket SOCKETNAME\n"
229            "SOCKETNAME defaults to XXX\n"
230            "\n"
231            "  --no-detach   do not deatach from the console\n"        
232            "  --version     print version of the program and exit\n"
233            "  --help        display this help and exit\n"
234            BUGREPORT_LINE, stdout );
235   
236   exit (0);
237 }
238
239 static int
240 print_usage (void)
241 {
242   fputs ("usage: " PGM " [OPTIONS] [SOCKETNAME]\n", stderr);
243   fputs ("       (use --help to display options)\n", stderr);
244   exit (1);
245 }
246
247
248 int 
249 main (int argc, char **argv)
250 {
251   int no_detach = 0;
252   gpg_error_t err;
253   struct sockaddr_un *srvr_addr;
254   socklen_t addrlen;
255   int fd;
256   int rc;
257   const char *socketname = "/var/run/libgcrypt/S.gcryptrnd";
258
259  
260   if (argc)
261     {
262       argc--; argv++;
263     }
264   while (argc && **argv == '-' && (*argv)[1] == '-')
265     {
266       if (!(*argv)[2])
267         {
268           argc--; argv++;
269           break;
270         }
271       else if (!strcmp (*argv, "--version"))
272         print_version (0);
273       else if (!strcmp (*argv, "--help"))
274         print_version (1);
275       else if (!strcmp (*argv, "--no-detach"))
276         {
277           no_detach = 1;
278           argc--; argv++;
279         }
280       else
281         print_usage ();
282     }          
283  
284   if (argc == 1)
285     socketname = argv[0];
286   else if (argc > 1)
287     print_usage ();
288
289   if (!no_detach)
290     daemonize ();
291
292   signal (SIGPIPE, SIG_IGN);
293
294   logit (LOG_NOTICE, "started version " VERSION );
295
296   /* Libgcrypt requires us to register the threading model before we
297      do anything else with it. Note that this also calls pth_init.  We
298      do the initialization while already running as a daemon to avoid
299      overhead with double initialization of Libgcrypt. */
300   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
301   if (err)
302     {
303       logit (LOG_CRIT, "can't register GNU Pth with Libgcrypt: %s",
304              gpg_strerror (err));
305       exit (1);
306     }
307
308   /* Check that the libgcrypt version is sufficient.  */
309   if (!gcry_check_version (VERSION) )
310     {
311       logit (LOG_CRIT, "libgcrypt is too old (need %s, have %s)",
312              VERSION, gcry_check_version (NULL) );
313       exit (1);
314     }
315
316   /* Register the logging callback and tell Libcgrypt to put the
317      random pool into secure memory. */
318   gcry_set_log_handler (my_gcry_logger, NULL);
319   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
320
321   /* Obviously we don't want to allow any core dumps. */
322   disable_core_dumps ();
323
324   /* Initialize the secure memory stuff which will also drop any extra
325      privileges we have. */
326   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
327
328   /* Register a cleanup handler. */
329   atexit (cleanup);
330
331   /* Create and listen on the socket. */
332   fd = socket (AF_UNIX, SOCK_STREAM, 0);
333   if (fd == -1)
334     {
335       logit (LOG_CRIT, "can't create socket: %s", strerror (errno));
336       exit (1);
337     }
338   srvr_addr = gcry_xmalloc (sizeof *srvr_addr); 
339   memset (srvr_addr, 0, sizeof *srvr_addr);
340   srvr_addr->sun_family = AF_UNIX;
341   if (strlen (socketname) + 1 >= sizeof (srvr_addr->sun_path))
342     {
343       logit (LOG_CRIT, "socket name `%s' too long", socketname);
344       exit (1);
345     }
346   strcpy (srvr_addr->sun_path, socketname);
347   addrlen = (offsetof (struct sockaddr_un, sun_path)
348              + strlen (srvr_addr->sun_path) + 1);
349   rc = bind (fd, (struct sockaddr*) srvr_addr, addrlen);
350   if (rc == -1 && errno == EADDRINUSE)
351     {
352       remove (socketname);
353       rc = bind (fd, (struct sockaddr*) srvr_addr, addrlen);
354     }
355   if (rc == -1)
356     {
357       logit (LOG_CRIT, "error binding socket to `%s': %s",
358              srvr_addr->sun_path, strerror (errno));
359       close (fd);
360       exit (1);
361     }
362
363   if (listen (fd, 5 ) == -1)
364     {
365       logit (LOG_CRIT, "listen() failed: %s", strerror (errno));
366       close (fd);
367       exit (1);
368     }
369   
370   logit (LOG_INFO, "listening on socket `%s', fd=%d",
371          srvr_addr->sun_path, fd);
372
373   serve (fd);
374   close (fd);
375
376   logit (LOG_NOTICE, "stopped version " VERSION );
377   return 0;
378 }
379
380
381 /* Send LENGTH bytes of BUFFER to file descriptor FD.  Returns 0 on
382    success or another value on write error. */
383 static int
384 writen (int fd, const void *buffer, size_t length)
385 {
386   while (length)
387     {
388       ssize_t n = pth_write (fd, buffer, length);
389       if (n < 0)
390          {
391            logit (LOG_ERR, "connection %d: write error: %s",
392                   fd, strerror (errno));
393            return -1; /* write error */
394          }
395       length -= n;
396       buffer = (const char*)buffer + n;
397     }
398   return 0;  /* Okay */
399 }
400
401
402 /* Send an error response back.  Returns 0 on success. */
403 static int
404 send_error (int fd, int errcode)
405 {
406   unsigned char buf[2];
407
408   buf[0] = errcode;
409   buf[1] = 0;
410   return writen (fd, buf, 2 );
411 }
412
413 /* Send a pong response back.  Returns 0 on success or another value
414    on write error.  */
415 static int
416 send_pong (int fd)
417 {
418   return writen (fd, "\x00\x04pong", 6);
419 }
420
421 /* Send a nonce of size LENGTH back. Return 0 on success. */
422 static int
423 send_nonce (int fd, int length)
424 {
425   unsigned char buf[2+255];
426   int rc;
427
428   assert (length >= 0 && length <= 255);
429   buf[0] = 0;
430   buf[1] = length;
431   gcry_create_nonce (buf+2, length);
432   rc = writen (fd, buf, 2+length );
433   wipememory (buf+2, length);
434   return rc;
435 }
436
437 /* Send a random of size LENGTH with quality LEVEL back. Return 0 on
438    success. */
439 static int
440 send_random (int fd, int length, int level)
441 {
442   unsigned char buf[2+255];
443   int rc;
444
445   assert (length >= 0 && length <= 255);
446   assert (level == GCRY_STRONG_RANDOM || level == GCRY_VERY_STRONG_RANDOM);
447   buf[0] = 0;
448   buf[1] = length;
449   /* Note that we don't bother putting the random stuff into secure
450      memory because this daemon is anyway intended to be run under
451      root and it is questionable whether the kernel buffers etc. are
452      equally well protected. */
453   gcry_randomize (buf+2, length, level);
454   rc = writen (fd, buf, 2+length );
455   wipememory (buf+2, length);
456   return rc;
457 }
458
459 /* Main processing loop for a connection.
460
461    A request is made up of:
462
463     1 byte  Total length of request; must be 3
464     1 byte  Command
465             0   = Ping
466             10  = GetNonce
467             11  = GetStrongRandom
468             12  = GetVeryStrongRandom
469             (all other values are reserved)
470     1 byte  Number of requested bytes.
471             This is ignored for command Ping.
472
473    A response is made up of:
474
475     1 byte  Error Code
476             0    = Everything is fine
477             1    = Bad Command
478             0xff = Other error.
479             (For a bad request the connection will simply be closed)
480     1 byte  Length of data
481     n byte  data
482
483    The requests are read as long as the connection is open.
484
485
486  */
487 static void
488 connection_loop (int fd)
489 {
490   unsigned char request[3];
491   unsigned char *p;
492   int nleft, n;
493   int rc;
494
495   for (;;)
496     {
497       for (nleft=3, p=request; nleft > 0; )
498         {
499           n = pth_read (fd, p, nleft);
500           if (!n && p == request)
501             return; /* Client terminated connection. */
502           if (n <= 0)
503             {
504               logit (LOG_ERR, "connection %d: read error: %s",
505                      fd, n? strerror (errno) : "Unexpected EOF");
506               return;
507             }
508           p += n;
509           nleft -= n;
510         }
511       if (request[0] != 3)
512         {
513           logit (LOG_ERR, "connection %d: invalid length (%d) of request",
514                  fd, request[0]);
515           return;
516         }
517
518       switch (request[1])
519         {
520         case 0: /* Ping */
521           rc = send_pong (fd);
522           break;
523         case 10: /* GetNonce */
524           rc = send_nonce (fd, request[2]);
525           break;
526         case 11: /* GetStrongRandom */
527           rc = send_random (fd, request[2], GCRY_STRONG_RANDOM);
528           break;
529         case 12: /* GetVeryStrongRandom */
530           rc = send_random (fd, request[2], GCRY_VERY_STRONG_RANDOM);
531           break;
532
533         default: /* Invalid command */
534           rc = send_error (fd, 1);
535           break;
536         }
537       if (rc)
538         break; /* A write error occured while sending the response. */
539     }
540 }
541
542
543
544 /* Entry point for a connection's thread. */
545 static void *
546 connection_thread (void *arg)
547 {
548   int fd = (int)arg;
549
550   active_connections++;
551   logit (LOG_INFO, "connection handler for fd %d started", fd);
552
553   connection_loop (fd);
554
555   close (fd);
556   logit (LOG_INFO, "connection handler for fd %d terminated", fd);
557   active_connections--;
558   
559   return NULL;
560 }
561
562
563 /* This signal handler is called from the main loop between acepting
564    connections.  It is called on the regular stack, thus no special
565    caution needs to be taken.  It returns true to indicate that the
566    process should terminate. */
567 static int
568 handle_signal (int signo)
569 {
570   switch (signo)
571     {
572     case SIGHUP:
573       logit (LOG_NOTICE, "SIGHUP received - re-reading configuration");
574       break;
575       
576     case SIGUSR1:
577       logit (LOG_NOTICE, "SIGUSR1 received - no action defined");
578       break;
579       
580     case SIGUSR2:
581       logit (LOG_NOTICE, "SIGUSR2 received - no action defined");
582       break;
583
584     case SIGTERM:
585       if (!shutdown_pending)
586         logit (LOG_NOTICE, "SIGTERM received - shutting down ...");
587       else
588         logit (LOG_NOTICE, "SIGTERM received - still %d active connections",
589                active_connections);
590       shutdown_pending++;
591       if (shutdown_pending > 2)
592         {
593           logit (LOG_NOTICE, "shutdown forced");
594           return 1;
595         }
596       break;
597         
598     case SIGINT:
599       logit (LOG_NOTICE, "SIGINT received - immediate shutdown");
600       return 1;
601
602     default:
603       logit (LOG_NOTICE, "signal %d received - no action defined\n", signo);
604     }
605   return 0;
606 }
607
608
609
610 /* Main server loop.  This is called with the FD of the listening
611    socket. */
612 static void
613 serve (int listen_fd)
614 {
615   pth_attr_t tattr;
616   pth_event_t ev;
617   sigset_t sigs;
618   int signo;
619   struct sockaddr_un paddr;
620   socklen_t plen = sizeof (paddr);
621   int fd;
622
623   tattr = pth_attr_new();
624   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
625   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 256*1024);
626   pth_attr_set (tattr, PTH_ATTR_NAME, "connection");
627
628   sigemptyset (&sigs);
629   sigaddset (&sigs, SIGHUP);
630   sigaddset (&sigs, SIGUSR1);
631   sigaddset (&sigs, SIGUSR2);
632   sigaddset (&sigs, SIGINT);
633   sigaddset (&sigs, SIGTERM);
634   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
635
636   for (;;)
637     {
638       if (shutdown_pending)
639         {
640           if (!active_connections)
641             break; /* Ready. */
642
643           /* Do not accept anymore connections but wait for existing
644              connections to terminate.  */
645           signo = 0;
646           pth_wait (ev);
647           if (pth_event_occurred (ev) && signo)
648             if (handle_signal (signo))
649               break; /* Stop the loop. */
650           continue;
651         }
652
653       gcry_fast_random_poll ();
654       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
655       if (fd == -1)
656         {
657           if (pth_event_occurred (ev))
658             {
659               if (handle_signal (signo))
660                 break; /* Stop the loop. */
661               continue;
662             }
663           logit (LOG_WARNING, "accept failed: %s - waiting 1s\n",
664                  strerror (errno));
665           gcry_fast_random_poll ();
666           pth_sleep (1);
667           continue;
668         }
669
670       if (!pth_spawn (tattr, connection_thread, (void*)fd))
671         {
672           logit (LOG_ERR, "error spawning connection handler: %s\n",
673                  strerror (errno) );
674           close (fd);
675         }
676     }
677   
678   pth_event_free (ev, PTH_FREE_ALL);
679 }
680