crypto/rand/randfile.c

   1 /*
   2  * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include "e_os.h"
  11
  12 #include <errno.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16
  17 #include <openssl/crypto.h>
  18 #include <openssl/rand.h>
  19 #include <openssl/buffer.h>
  20
  21 #ifdef OPENSSL_SYS_VMS
  22 # include <unixio.h>
  23 #endif
  24 #ifndef NO_SYS_TYPES_H
  25 # include <sys/types.h>
  26 #endif
  27 #ifndef OPENSSL_NO_POSIX_IO
  28 # include <sys/stat.h>
  29 # include <fcntl.h>
  30 /*
  31  * Following should not be needed, and we could have been stricter
  32  * and demand S_IS*. But some systems just don't comply... Formally
  33  * below macros are "anatomically incorrect", because normally they
  34  * would look like ((m) & MASK == TYPE), but since MASK availability
  35  * is as questionable, we settle for this poor-man fallback...
  36  */
  37 # if !defined(S_ISBLK)
  38 #  if defined(_S_IFBLK)
  39 #   define S_ISBLK(m) ((m) & _S_IFBLK)
  40 #  elif defined(S_IFBLK)
  41 #   define S_ISBLK(m) ((m) & S_IFBLK)
  42 #  elif defined(_WIN32)
  43 #   define S_ISBLK(m) 0 /* no concept of block devices on Windows */
  44 #  endif
  45 # endif
  46 # if !defined(S_ISCHR)
  47 #  if defined(_S_IFCHR)
  48 #   define S_ISCHR(m) ((m) & _S_IFCHR)
  49 #  elif defined(S_IFCHR)
  50 #   define S_ISCHR(m) ((m) & S_IFCHR)
  51 #  endif
  52 # endif
  53 #endif
  54
  55 #ifdef _WIN32
  56 # define stat    _stat
  57 # define chmod   _chmod
  58 # define open    _open
  59 # define fdopen  _fdopen
  60 #endif
  61
  62 #undef BUFSIZE
  63 #define BUFSIZE 1024
  64 #define RAND_DATA 1024
  65
  66 #ifdef OPENSSL_SYS_VMS
  67 /*
  68  * This declaration is a nasty hack to get around vms' extension to fopen for
  69  * passing in sharing options being disabled by our /STANDARD=ANSI89
  70  */
  71 static FILE *(*const vms_fopen)(const char *, const char *, ...) =
  72     (FILE *(*)(const char *, const char *, ...))fopen;
  73 # define VMS_OPEN_ATTRS "shr=get,put,upd,del","ctx=bin,stm","rfm=stm","rat=none","mrs=0"
  74 #endif
  75
  76 #define RFILE ".rnd"
  77
  78 /*
  79  * Note that these functions are intended for seed files only. Entropy
  80  * devices and EGD sockets are handled in rand_unix.c
  81  */
  82
  83 int RAND_load_file(const char *file, long bytes)
  84 {
  85     /*-
  86      * If bytes >= 0, read up to 'bytes' bytes.
  87      * if bytes == -1, read complete file.
  88      */
  89
  90     unsigned char buf[BUFSIZE];
  91 #ifndef OPENSSL_NO_POSIX_IO
  92     struct stat sb;
  93 #endif
  94     int i, ret = 0, n;
  95     FILE *in;
  96
  97     if (file == NULL)
  98         return (0);
  99
 100 #ifndef OPENSSL_NO_POSIX_IO
 101     /*
 102      * struct stat can have padding and unused fields that may not be
 103      * initialized in the call to stat(). We need to clear the entire
 104      * structure before calling RAND_add() to avoid complaints from
 105      * applications such as Valgrind.
 106      */
 107     memset(&sb, 0, sizeof(sb));
 108     if (stat(file, &sb) < 0)
 109         return (0);
 110     RAND_add(&sb, sizeof(sb), 0.0);
 111 #endif
 112     if (bytes == 0)
 113         return (ret);
 114
 115 #ifdef OPENSSL_SYS_VMS
 116     in = vms_fopen(file, "rb", VMS_OPEN_ATTRS);
 117 #else
 118     in = fopen(file, "rb");
 119 #endif
 120     if (in == NULL)
 121         goto err;
 122 #if defined(S_ISBLK) && defined(S_ISCHR) && !defined(OPENSSL_NO_POSIX_IO)
 123     if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) {
 124         /*
 125          * this file is a device. we don't want read an infinite number of
 126          * bytes from a random device, nor do we want to use buffered I/O
 127          * because we will waste system entropy.
 128          */
 129         bytes = (bytes == -1) ? 2048 : bytes; /* ok, is 2048 enough? */
 130         setbuf(in, NULL); /* don't do buffered reads */
 131     }
 132 #endif
 133     for (;;) {
 134         if (bytes > 0)
 135             n = (bytes < BUFSIZE) ? (int)bytes : BUFSIZE;
 136         else
 137             n = BUFSIZE;
 138         i = fread(buf, 1, n, in);
 139         if (i <= 0)
 140             break;
 141
 142         RAND_add(buf, i, (double)i);
 143         ret += i;
 144         if (bytes > 0) {
 145             bytes -= n;
 146             if (bytes <= 0)
 147                 break;
 148         }
 149     }
 150     fclose(in);
 151     OPENSSL_cleanse(buf, BUFSIZE);
 152  err:
 153     return (ret);
 154 }
 155
 156 int RAND_write_file(const char *file)
 157 {
 158     unsigned char buf[BUFSIZE];
 159     int i, ret = 0, rand_err = 0;
 160     FILE *out = NULL;
 161     int n;
 162 #ifndef OPENSSL_NO_POSIX_IO
 163     struct stat sb;
 164
 165     i = stat(file, &sb);
 166     if (i != -1) {
 167 # if defined(S_ISBLK) && defined(S_ISCHR)
 168         if (S_ISBLK(sb.st_mode) || S_ISCHR(sb.st_mode)) {
 169             /*
 170              * this file is a device. we don't write back to it. we
 171              * "succeed" on the assumption this is some sort of random
 172              * device. Otherwise attempting to write to and chmod the device
 173              * causes problems.
 174              */
 175             return (1);
 176         }
 177 # endif
 178     }
 179 #endif
 180
 181 #if defined(O_CREAT) && !defined(OPENSSL_NO_POSIX_IO) && !defined(OPENSSL_SYS_VMS)
 182     {
 183 # ifndef O_BINARY
 184 #  define O_BINARY 0
 185 # endif
 186         /*
 187          * chmod(..., 0600) is too late to protect the file, permissions
 188          * should be restrictive from the start
 189          */
 190         int fd = open(file, O_WRONLY | O_CREAT | O_BINARY, 0600);
 191         if (fd != -1)
 192             out = fdopen(fd, "wb");
 193     }
 194 #endif
 195
 196 #ifdef OPENSSL_SYS_VMS
 197     /*
 198      * VMS NOTE: Prior versions of this routine created a _new_ version of
 199      * the rand file for each call into this routine, then deleted all
 200      * existing versions named ;-1, and finally renamed the current version
 201      * as ';1'. Under concurrent usage, this resulted in an RMS race
 202      * condition in rename() which could orphan files (see vms message help
 203      * for RMS$_REENT). With the fopen() calls below, openssl/VMS now shares
 204      * the top-level version of the rand file. Note that there may still be
 205      * conditions where the top-level rand file is locked. If so, this code
 206      * will then create a new version of the rand file. Without the delete
 207      * and rename code, this can result in ascending file versions that stop
 208      * at version 32767, and this routine will then return an error. The
 209      * remedy for this is to recode the calling application to avoid
 210      * concurrent use of the rand file, or synchronize usage at the
 211      * application level. Also consider whether or not you NEED a persistent
 212      * rand file in a concurrent use situation.
 213      */
 214
 215     out = vms_fopen(file, "rb+", VMS_OPEN_ATTRS);
 216     if (out == NULL)
 217         out = vms_fopen(file, "wb", VMS_OPEN_ATTRS);
 218 #else
 219     if (out == NULL)
 220         out = fopen(file, "wb");
 221 #endif
 222     if (out == NULL)
 223         goto err;
 224
 225 #if !defined(NO_CHMOD) && !defined(OPENSSL_NO_POSIX_IO)
 226     chmod(file, 0600);
 227 #endif
 228     n = RAND_DATA;
 229     for (;;) {
 230         i = (n > BUFSIZE) ? BUFSIZE : n;
 231         n -= BUFSIZE;
 232         if (RAND_bytes(buf, i) <= 0)
 233             rand_err = 1;
 234         i = fwrite(buf, 1, i, out);
 235         if (i <= 0) {
 236             ret = 0;
 237             break;
 238         }
 239         ret += i;
 240         if (n <= 0)
 241             break;
 242     }
 243
 244     fclose(out);
 245     OPENSSL_cleanse(buf, BUFSIZE);
 246  err:
 247     return (rand_err ? -1 : ret);
 248 }
 249
 250 const char *RAND_file_name(char *buf, size_t size)
 251 {
 252     char *s = NULL;
 253 #ifdef __OpenBSD__
 254     struct stat sb;
 255 #endif
 256
 257     if (OPENSSL_issetugid() == 0)
 258         s = getenv("RANDFILE");
 259     if (s != NULL && *s && strlen(s) + 1 < size) {
 260         if (OPENSSL_strlcpy(buf, s, size) >= size)
 261             return NULL;
 262     } else {
 263         if (OPENSSL_issetugid() == 0)
 264             s = getenv("HOME");
 265 #ifdef DEFAULT_HOME
 266         if (s == NULL) {
 267             s = DEFAULT_HOME;
 268         }
 269 #endif
 270         if (s && *s && strlen(s) + strlen(RFILE) + 2 < size) {
 271             OPENSSL_strlcpy(buf, s, size);
 272 #ifndef OPENSSL_SYS_VMS
 273             OPENSSL_strlcat(buf, "/", size);
 274 #endif
 275             OPENSSL_strlcat(buf, RFILE, size);
 276         } else
 277             buf[0] = '\0';      /* no file name */
 278     }
 279
 280 #ifdef __OpenBSD__
 281     /*
 282      * given that all random loads just fail if the file can't be seen on a
 283      * stat, we stat the file we're returning, if it fails, use /dev/arandom
 284      * instead. this allows the user to use their own source for good random
 285      * data, but defaults to something hopefully decent if that isn't
 286      * available.
 287      */
 288
 289     if (!buf[0])
 290         if (OPENSSL_strlcpy(buf, "/dev/arandom", size) >= size) {
 291             return (NULL);
 292         }
 293     if (stat(buf, &sb) == -1)
 294         if (OPENSSL_strlcpy(buf, "/dev/arandom", size) >= size) {
 295             return (NULL);
 296         }
 297 #endif
 298     return (buf);
 299 }