/* random-daemon.c - Access to the external random daemon * Copyright (C) 2006 Free Software Foundation, Inc. * * This file is part of Libgcrypt. * * Libgcrypt is free software; you can redistribute it and/or modify * it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * Libgcrypt is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA */ /* The functions here are used by random.c to divert calls to an external random number daemon. The actual daemon we use is gcryptrnd. Such a daemon is useful to keep a persistent pool in memory over invocations of a single application and to allow prioritizing access to the actual entropy sources. The drawback is that we need to use IPC (i.e. unix domain socket) to convey sensitive data. */ #error This dameon needs to be fixed due to the ath changes #include #include #include #include #include #include #include #include #include #include "g10lib.h" #include "random.h" #include "ath.h" /* This is default socket name we use in case the provided socket name is NULL. */ #define RANDOM_DAEMON_SOCKET "/var/run/libgcrypt/S.gcryptrnd" /* The lock serializing access to the daemon. */ static ath_mutex_t daemon_lock = ATH_MUTEX_INITIALIZER; /* The socket connected to the daemon. */ static int daemon_socket = -1; /* Creates a socket connected to the daemon. On success, store the socket fd in *SOCK. Returns error code. */ static gcry_error_t connect_to_socket (const char *socketname, int *sock) { struct sockaddr_un *srvr_addr; socklen_t addrlen; gcry_error_t err; int fd; int rc; srvr_addr = NULL; /* Create a socket. */ fd = socket (AF_UNIX, SOCK_STREAM, 0); if (fd == -1) { log_error ("can't create socket: %s\n", strerror (errno)); err = gcry_error_from_errno (errno); goto out; } /* Set up address. */ srvr_addr = gcry_malloc (sizeof *srvr_addr); if (! srvr_addr) { log_error ("malloc failed: %s\n", strerror (errno)); err = gcry_error_from_errno (errno); goto out; } memset (srvr_addr, 0, sizeof *srvr_addr); srvr_addr->sun_family = AF_UNIX; if (strlen (socketname) + 1 >= sizeof (srvr_addr->sun_path)) { log_error ("socket name `%s' too long\n", socketname); err = gcry_error (GPG_ERR_ENAMETOOLONG); goto out; } strcpy (srvr_addr->sun_path, socketname); addrlen = (offsetof (struct sockaddr_un, sun_path) + strlen (srvr_addr->sun_path) + 1); /* Connect socket. */ rc = connect (fd, (struct sockaddr *) srvr_addr, addrlen); if (rc == -1) { log_error ("error connecting socket `%s': %s\n", srvr_addr->sun_path, strerror (errno)); err = gcry_error_from_errno (errno); goto out; } err = 0; out: gcry_free (srvr_addr); if (err) { close (fd); fd = -1; } *sock = fd; return err; } /* Initialize basics of this module. This should be viewed as a constructor to prepare locking. */ void _gcry_daemon_initialize_basics (void) { static int initialized; int err; if (!initialized) { initialized = 1; err = ath_mutex_init (&daemon_lock); if (err) log_fatal ("failed to create the daemon lock: %s\n", strerror (err) ); } } /* Send LENGTH bytes of BUFFER to file descriptor FD. Returns 0 on success or another value on write error. */ static int writen (int fd, const void *buffer, size_t length) { ssize_t n; while (length) { do n = ath_write (fd, buffer, length); while (n < 0 && errno == EINTR); if (n < 0) { log_error ("write error: %s\n", strerror (errno)); return -1; /* write error */ } length -= n; buffer = (const char*)buffer + n; } return 0; /* Okay */ } static int readn (int fd, void *buf, size_t buflen, size_t *ret_nread) { size_t nleft = buflen; int nread; char *p; p = buf; while (nleft > 0) { nread = ath_read (fd, buf, nleft); if (nread < 0) { if (nread == EINTR) nread = 0; else return -1; } else if (!nread) break; /* EOF */ nleft -= nread; buf = (char*)buf + nread; } if (ret_nread) *ret_nread = buflen - nleft; return 0; } /* This functions requests REQ_NBYTES from the daemon. If NONCE is true, the data should be suited for a nonce. If NONCE is FALSE, data of random level LEVEL will be generated. The retrieved random data will be stored in BUFFER. Returns error code. */ static gcry_error_t call_daemon (const char *socketname, void *buffer, size_t req_nbytes, int nonce, enum gcry_random_level level) { static int initialized; unsigned char buf[255]; gcry_error_t err = 0; size_t nbytes; size_t nread; int rc; if (!req_nbytes) return 0; ath_mutex_lock (&daemon_lock); /* Open the socket if that has not been done. */ if (!initialized) { initialized = 1; err = connect_to_socket (socketname ? socketname : RANDOM_DAEMON_SOCKET, &daemon_socket); if (err) { daemon_socket = -1; log_info ("not using random daemon\n"); ath_mutex_unlock (&daemon_lock); return err; } } /* Check that we have a valid socket descriptor. */ if ( daemon_socket == -1 ) { ath_mutex_unlock (&daemon_lock); return gcry_error (GPG_ERR_INTERNAL); } /* Do the real work. */ do { /* Process in chunks. */ nbytes = req_nbytes > sizeof (buf) ? sizeof (buf) : req_nbytes; req_nbytes -= nbytes; /* Construct request. */ buf[0] = 3; if (nonce) buf[1] = 10; else if (level == GCRY_VERY_STRONG_RANDOM) buf[1] = 12; else if (level == GCRY_STRONG_RANDOM) buf[1] = 11; buf[2] = nbytes; /* Send request. */ rc = writen (daemon_socket, buf, 3); if (rc == -1) { err = gcry_error_from_errno (errno); break; } /* Retrieve response. */ rc = readn (daemon_socket, buf, 2, &nread); if (rc == -1) { err = gcry_error_from_errno (errno); log_error ("read error: %s\n", _gcry_strerror (err)); break; } if (nread && buf[0]) { log_error ("random daemon returned error code %d\n", buf[0]); err = gcry_error (GPG_ERR_INTERNAL); /* ? */ break; } if (nread != 2) { log_error ("response too small\n"); err = gcry_error (GPG_ERR_PROTOCOL_VIOLATION); /* ? */ break; } /* if (1)*/ /* Do this in verbose mode? */ /* log_info ("received response with %d bytes of data\n", buf[1]);*/ if (buf[1] < nbytes) { log_error ("error: server returned less bytes than requested\n"); err = gcry_error (GPG_ERR_PROTOCOL_VIOLATION); /* ? */ break; } else if (buf[1] > nbytes) { log_error ("warning: server returned more bytes than requested\n"); err = gcry_error (GPG_ERR_PROTOCOL_VIOLATION); /* ? */ break; } assert (nbytes <= sizeof (buf)); rc = readn (daemon_socket, buf, nbytes, &nread); if (rc == -1) { err = gcry_error_from_errno (errno); log_error ("read error: %s\n", _gcry_strerror (err)); break; } if (nread != nbytes) { log_error ("too little random data read\n"); err = gcry_error (GPG_ERR_INTERNAL); break; } /* Successfuly read another chunk of data. */ memcpy (buffer, buf, nbytes); buffer = ((char *) buffer) + nbytes; } while (req_nbytes); ath_mutex_unlock (&daemon_lock); return err; } /* Internal function to fill BUFFER with LENGTH bytes of random. We support GCRY_STRONG_RANDOM and GCRY_VERY_STRONG_RANDOM here. Return 0 on success. */ int _gcry_daemon_randomize (const char *socketname, void *buffer, size_t length, enum gcry_random_level level) { gcry_error_t err; err = call_daemon (socketname, buffer, length, 0, level); return err ? -1 : 0; } /* END */