Rewrite RAND_egd
authorRich Salz <rsalz@openssl.org>
Sat, 8 Jul 2017 18:45:15 +0000 (14:45 -0400)
committerRich Salz <rsalz@openssl.org>
Wed, 12 Jul 2017 15:09:39 +0000 (11:09 -0400)
Use stdio and its buffering.
Limit to 255 bytes (could remove that if neceessary).

Reviewed-by: Paul Dale <paul.dale@oracle.com>
(Merged from https://github.com/openssl/openssl/pull/3888)

crypto/rand/rand_egd.c
doc/man3/RAND_egd.pod

index 1b091e8..657a3bc 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2016 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2000-2017 The OpenSSL Project Authors. All Rights Reserved.
  *
  * Licensed under the OpenSSL license (the "License").  You may not use
  * this file except in compliance with the License.  You can obtain a copy
@@ -16,41 +16,8 @@ NON_EMPTY_TRANSLATION_UNIT
 # include <openssl/e_os2.h>
 # include <openssl/rand.h>
 
-/*-
- * Query the EGD <URL: http://www.lothar.com/tech/crypto/>.
- *
- * This module supplies three routines:
- *
- * RAND_query_egd_bytes(path, buf, bytes)
- *   will actually query "bytes" bytes of entropy form the egd-socket located
- *   at path and will write them to buf (if supplied) or will directly feed
- *   it to RAND_seed() if buf==NULL.
- *   The number of bytes is not limited by the maximum chunk size of EGD,
- *   which is 255 bytes. If more than 255 bytes are wanted, several chunks
- *   of entropy bytes are requested. The connection is left open until the
- *   query is competed.
- *   RAND_query_egd_bytes() returns with
- *     -1  if an error occurred during connection or communication.
- *     num the number of bytes read from the EGD socket. This number is either
- *         the number of bytes requested or smaller, if the EGD pool is
- *         drained and the daemon signals that the pool is empty.
- *   This routine does not touch any RAND_status(). This is necessary, since
- *   PRNG functions may call it during initialization.
- *
- * RAND_egd_bytes(path, bytes) will query "bytes" bytes and have them
- *   used to seed the PRNG.
- *   RAND_egd_bytes() is a wrapper for RAND_query_egd_bytes() with buf=NULL.
- *   Unlike RAND_query_egd_bytes(), RAND_status() is used to test the
- *   seed status so that the return value can reflect the seed state:
- *     -1  if an error occurred during connection or communication _or_
- *         if the PRNG has still not received the required seeding.
- *     num the number of bytes read from the EGD socket. This number is either
- *         the number of bytes requested or smaller, if the EGD pool is
- *         drained and the daemon signals that the pool is empty.
- *
- * RAND_egd(path) will query 255 bytes and use the bytes retrieved to seed
- *   the PRNG.
- *   RAND_egd() is a wrapper for RAND_egd_bytes() with numbytes=255.
+/*
+ * Query an EGD
  */
 
 # if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_MSDOS) || defined(OPENSSL_SYS_VXWORKS) || defined(OPENSSL_SYS_VOS) || defined(OPENSSL_SYS_UEFI)
@@ -61,14 +28,16 @@ int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes)
 
 int RAND_egd(const char *path)
 {
-    return -1;
+    return (-1);
 }
 
 int RAND_egd_bytes(const char *path, int bytes)
 {
-    return -1;
+    return (-1);
 }
+
 # else
+
 #  include <openssl/opensslconf.h>
 #  include OPENSSL_UNISTD
 #  include <stddef.h>
@@ -91,157 +60,97 @@ struct sockaddr_un {
 
 int RAND_query_egd_bytes(const char *path, unsigned char *buf, int bytes)
 {
-    int ret = 0;
+    FILE *fp = NULL;
     struct sockaddr_un addr;
-    int len, num, numbytes;
-    int fd = -1;
-    int success;
-    unsigned char egdbuf[2], tempbuf[255], *retrievebuf;
+    int mybuffer, ret = -1, i, numbytes, fd;
+    unsigned char tempbuf[255];
 
+    if (bytes > (int)sizeof(tempbuf))
+        return -1;
+
+    /* Make socket. */
     memset(&addr, 0, sizeof(addr));
     addr.sun_family = AF_UNIX;
     if (strlen(path) >= sizeof(addr.sun_path))
-        return -1;
+        return (-1);
     strcpy(addr.sun_path, path);
-    len = offsetof(struct sockaddr_un, sun_path) + strlen(path);
+    i = offsetof(struct sockaddr_un, sun_path) + strlen(path);
     fd = socket(AF_UNIX, SOCK_STREAM, 0);
-    if (fd == -1)
-        return -1;
-    success = 0;
-    while (!success) {
-        if (connect(fd, (struct sockaddr *)&addr, len) == 0)
-            success = 1;
-        else {
-            switch (errno) {
-#  ifdef EINTR
-            case EINTR:
-#  endif
-#  ifdef EAGAIN
-            case EAGAIN:
-#  endif
-#  ifdef EINPROGRESS
-            case EINPROGRESS:
-#  endif
-#  ifdef EALREADY
-            case EALREADY:
-#  endif
-                /* No error, try again */
-                break;
+    if (fd == -1 || (fp = fdopen(fd, "r+")) == NULL)
+        return (-1);
+
+    /* Try to connect */
+    for ( ; ; ) {
+        if (connect(fd, (struct sockaddr *)&addr, i) == 0)
+            break;
 #  ifdef EISCONN
-            case EISCONN:
-                success = 1;
-                break;
+        if (errno == EISCONN)
+            break;
 #  endif
-            default:
-                ret = -1;
-                goto err;       /* failure */
-            }
-        }
-    }
-
-    while (bytes > 0) {
-        egdbuf[0] = 1;
-        egdbuf[1] = bytes < 255 ? bytes : 255;
-        numbytes = 0;
-        while (numbytes != 2) {
-            num = write(fd, egdbuf + numbytes, 2 - numbytes);
-            if (num >= 0)
-                numbytes += num;
-            else {
-                switch (errno) {
+        switch (errno) {
 #  ifdef EINTR
-                case EINTR:
+        case EINTR:
 #  endif
 #  ifdef EAGAIN
-                case EAGAIN:
+        case EAGAIN:
 #  endif
-                    /* No error, try again */
-                    break;
-                default:
-                    ret = -1;
-                    goto err;   /* failure */
-                }
-            }
-        }
-        numbytes = 0;
-        while (numbytes != 1) {
-            num = read(fd, egdbuf, 1);
-            if (num == 0)
-                goto err;       /* descriptor closed */
-            else if (num > 0)
-                numbytes += num;
-            else {
-                switch (errno) {
-#  ifdef EINTR
-                case EINTR:
+#  ifdef EINPROGRESS
+        case EINPROGRESS:
 #  endif
-#  ifdef EAGAIN
-                case EAGAIN:
+#  ifdef EALREADY
+        case EALREADY:
 #  endif
-                    /* No error, try again */
-                    break;
-                default:
-                    ret = -1;
-                    goto err;   /* failure */
-                }
-            }
-        }
-        if (egdbuf[0] == 0)
+            /* No error, try again */
+            break;
+        default:
+            ret = -1;
             goto err;
-        if (buf)
-            retrievebuf = buf + ret;
-        else
-            retrievebuf = tempbuf;
-        numbytes = 0;
-        while (numbytes != egdbuf[0]) {
-            num = read(fd, retrievebuf + numbytes, egdbuf[0] - numbytes);
-            if (num == 0)
-                goto err;       /* descriptor closed */
-            else if (num > 0)
-                numbytes += num;
-            else {
-                switch (errno) {
-#  ifdef EINTR
-                case EINTR:
-#  endif
-#  ifdef EAGAIN
-                case EAGAIN:
-#  endif
-                    /* No error, try again */
-                    break;
-                default:
-                    ret = -1;
-                    goto err;   /* failure */
-                }
-            }
         }
-        ret += egdbuf[0];
-        bytes -= egdbuf[0];
-        if (!buf)
-            RAND_seed(tempbuf, egdbuf[0]);
     }
+
+    /* Make request, see how many bytes we can get back. */
+    tempbuf[0] = 1;
+    tempbuf[1] = bytes;
+    if (fwrite(tempbuf, sizeof(char), 2, fp) != 2 || fflush(fp) == EOF)
+        goto err;
+    if (fread(tempbuf, sizeof(char), 1, fp) != 1 || tempbuf[0] == 0)
+        goto err;
+    numbytes = tempbuf[0];
+
+    /* Which buffer are we using? */
+    mybuffer = buf == NULL;
+    if (mybuffer)
+        buf = tempbuf;
+
+    /* Read bytes. */
+    i = fread(buf, sizeof(char), numbytes, fp);
+    if (i < numbytes)
+        goto err;
+    ret = numbytes;
+    if (mybuffer)
+        RAND_seed(tempbuf, i);
+
  err:
-    if (fd != -1)
-        close(fd);
+    if (fp != NULL)
+        fclose(fp);
     return ret;
 }
 
 int RAND_egd_bytes(const char *path, int bytes)
 {
-    int num, ret = -1;
+    int num;
 
     num = RAND_query_egd_bytes(path, NULL, bytes);
     if (num < 0)
-        goto err;
-    if (RAND_status() == 1)
-        ret = num;
- err:
-    return ret;
+        return -1;
+    if (RAND_status() != 1)
+        return -1;
+    return num;
 }
 
 int RAND_egd(const char *path)
 {
-    return RAND_egd_bytes(path, 255);
+    return (RAND_egd_bytes(path, 255));
 }
 
 # endif
index e2c7b3f..e68eb8f 100644 (file)
@@ -26,7 +26,7 @@ specified socket B<path>, and passes the data it receives into RAND_add().
 RAND_egd() is equivalent to RAND_egd_bytes() with B<num> set to 255.
 
 RAND_query_egd_bytes() requests B<num> bytes of randomness from an EGD at
-the specified socket B<path>.
+the specified socket B<path>, where B<num> must be less than 256.
 If B<buf> is B<NULL>, it is equivalent to RAND_egd_bytes().
 If B<buf> is not B<NULL>, then the data is copied to the buffer and
 RAND_add() is not called.