1 /* crypto/rand/randfile.c */

     2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)

     3  * All rights reserved.

     4  *

     5  * This package is an SSL implementation written

     6  * by Eric Young (eay@cryptsoft.com).

     7  * The implementation was written so as to conform with Netscapes SSL.

     8  * 

     9  * This library is free for commercial and non-commercial use as long as

    10  * the following conditions are aheared to.  The following conditions

    11  * apply to all code found in this distribution, be it the RC4, RSA,

    12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation

    13  * included with this distribution is covered by the same copyright terms

    14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).

    15  * 

    16  * Copyright remains Eric Young's, and as such any Copyright notices in

    17  * the code are not to be removed.

    18  * If this package is used in a product, Eric Young should be given attribution

    19  * as the author of the parts of the library used.

    20  * This can be in the form of a textual message at program startup or

    21  * in documentation (online or textual) provided with the package.

    22  * 

    23  * Redistribution and use in source and binary forms, with or without

    24  * modification, are permitted provided that the following conditions

    25  * are met:

    26  * 1. Redistributions of source code must retain the copyright

    27  *    notice, this list of conditions and the following disclaimer.

    28  * 2. Redistributions in binary form must reproduce the above copyright

    29  *    notice, this list of conditions and the following disclaimer in the

    30  *    documentation and/or other materials provided with the distribution.

    31  * 3. All advertising materials mentioning features or use of this software

    32  *    must display the following acknowledgement:

    33  *    "This product includes cryptographic software written by

    34  *     Eric Young (eay@cryptsoft.com)"

    35  *    The word 'cryptographic' can be left out if the rouines from the library

    36  *    being used are not cryptographic related :-).

    37  * 4. If you include any Windows specific code (or a derivative thereof) from 

    38  *    the apps directory (application code) you must include an acknowledgement:

    39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"

    40  * 

    41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND

    42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

    44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE

    45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

    47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

    48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

    49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

    50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

    51  * SUCH DAMAGE.

    52  * 

    53  * The licence and distribution terms for any publically available version or

    54  * derivative of this code cannot be changed.  i.e. this code cannot simply be

    55  * copied and put under another distribution licence

    56  * [including the GNU Public Licence.]

    57  */

    58 /*

    59  © Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.

    60  */

    61 /* We need to define this to get macros like S_IFBLK and S_IFCHR */

    62 #define _XOPEN_SOURCE 500

    63 

    64 

    65 

    66 #include <errno.h>

    67 #include <stdio.h>

    68 #include <stdlib.h>

    69 #include <string.h>

    70 

    71 

    72 #include "e_os.h"

    73 #include <openssl/crypto.h>

    74 #include <openssl/rand.h>

    75 #include <openssl/buffer.h>

    76 

    77 # include <sys/types.h>

    78 

    79 #ifdef OPENSSL_SYS_VMS

    80 #include <unixio.h>

    81 #endif

    82 #ifndef NO_SYS_TYPES_H

    83 # include <sys/types.h>

    84 #endif

    85 #ifdef MAC_OS_pre_X

    86 # include <stat.h>

    87 #else

    88 # include <sys/stat.h>

    89 #endif

    90 

    91 #undef BUFSIZE

    92 #ifndef SYMBIAN

    93 #define BUFSIZE	1024

    94 #define RAND_DATA 1024

    95 #else

    96 #define BUFSIZE	512

    97 #define RAND_DATA 512

    98 #endif

    99 

   100 

   101 /* #define RFILE ".rnd" - defined in ../../e_os.h */

   102 

   103 /* Note that these functions are intended for seed files only.

   104  * Entropy devices and EGD sockets are handled in rand_unix.c */

   105 

   106 EXPORT_C int RAND_load_file(const char *file, long bytes)

   107 	{

   108 	/* If bytes >= 0, read up to 'bytes' bytes.

   109 	 * if bytes == -1, read complete file. */

   110 

   111 	MS_STATIC unsigned char buf[BUFSIZE];

   112 	struct stat sb;

   113 	int i,ret=0,n;

   114 	FILE *in;

   115 

   116 	if (file == NULL) return(0);

   117 

   118 	if (stat(file,&sb) < 0) return(0);

   119 	RAND_add(&sb,sizeof(sb),0.0);

   120 	if (bytes == 0) return(ret);

   121 

   122 	in=fopen(file,"rb");

   123 	if (in == NULL) goto err;

   124 #if defined(S_IFBLK) && defined(S_IFCHR)

   125 	if (sb.st_mode & (S_IFBLK | S_IFCHR)) {

   126 	  /* this file is a device. we don't want read an infinite number

   127 	   * of bytes from a random device, nor do we want to use buffered

   128 	   * I/O because we will waste system entropy. 

   129 	   */

   130 	  bytes = (bytes == -1) ? 2048 : bytes; /* ok, is 2048 enough? */

   131 	  setvbuf(in, NULL, _IONBF, 0); /* don't do buffered reads */

   132 	}

   133 #endif

   134 	for (;;)

   135 		{

   136 		if (bytes > 0)

   137 			n = (bytes < BUFSIZE)?(int)bytes:BUFSIZE;

   138 		else

   139 			n = BUFSIZE;

   140 		i=fread(buf,1,n,in);

   141 		if (i <= 0) break;

   142 		/* even if n != i, use the full array */

   143 		RAND_add(buf,n,(double)i);

   144 		ret+=i;

   145 		if (bytes > 0)

   146 			{

   147 			bytes-=n;

   148 			if (bytes <= 0) break;

   149 			}

   150 		}

   151 	fclose(in);

   152 	OPENSSL_cleanse(buf,BUFSIZE);

   153 err:

   154 	return(ret);

   155 	}

   156 

   157 EXPORT_C int RAND_write_file(const char *file)

   158 	{

   159 	unsigned char buf[BUFSIZE];

   160 	int i,ret=0,rand_err=0;

   161 	FILE *out = NULL;

   162 	int n;

   163 	struct stat sb;

   164 	

   165 	i=stat(file,&sb);

   166 	if (i != -1) { 

   167 #if defined(S_IFBLK) && defined(S_IFCHR)

   168 	  if (sb.st_mode & (S_IFBLK | S_IFCHR)) {

   169 	    /* this file is a device. we don't write back to it. 

   170 	     * we "succeed" on the assumption this is some sort 

   171 	     * of random device. Otherwise attempting to write to 

   172 	     * and chmod the device causes problems.

   173 	     */

   174 	    return(1); 

   175 	  }

   176 #endif

   177 	}

   178 

   179 #if defined(O_CREAT) && !defined(OPENSSL_SYS_WIN32)

   180 	{

   181 	/* For some reason Win32 can't write to files created this way */

   182 	

   183 	/* chmod(..., 0600) is too late to protect the file,

   184 	 * permissions should be restrictive from the start */

   185 	int fd = open(file, O_CREAT, 0600);

   186 	if (fd != -1)

   187 		out = fdopen(fd, "wb");

   188 	}

   189 #endif

   190 	if (out == NULL)

   191 		out = fopen(file,"wb");

   192 	if (out == NULL) goto err;

   193 

   194 #ifndef NO_CHMOD

   195 	chmod(file,0600);

   196 #endif

   197 	n=RAND_DATA;

   198 	for (;;)

   199 		{

   200 		i=(n > BUFSIZE)?BUFSIZE:n;

   201 		n-=BUFSIZE;

   202 		if (RAND_bytes(buf,i) <= 0)

   203 			rand_err=1;

   204 		i=fwrite(buf,1,i,out);

   205 		if (i <= 0)

   206 			{

   207 			ret=0;

   208 			break;

   209 			}

   210 		ret+=i;

   211 		if (n <= 0) break;

   212                 }

   213 #ifdef OPENSSL_SYS_VMS

   214 	/* Try to delete older versions of the file, until there aren't

   215 	   any */

   216 	{

   217 	char *tmpf;

   218 

   219 	tmpf = OPENSSL_malloc(strlen(file) + 4);  /* to add ";-1" and a nul */

   220 	if (tmpf)

   221 		{

   222 		strcpy(tmpf, file);

   223 		strcat(tmpf, ";-1");

   224 		while(delete(tmpf) == 0)

   225 			;

   226 		rename(file,";1"); /* Make sure it's version 1, or we

   227 				      will reach the limit (32767) at

   228 				      some point... */

   229 		}

   230 	}

   231 #endif /* OPENSSL_SYS_VMS */

   232 

   233 	fclose(out);

   234 	OPENSSL_cleanse(buf,BUFSIZE);

   235 err:

   236 	return (rand_err ? -1 : ret);

   237 	}

   238 

   239 EXPORT_C const char *RAND_file_name(char *buf, size_t size)

   240 	{

   241 	char *s=NULL;

   242 	int ok = 0;

   243 #ifdef __OpenBSD__

   244 	struct stat sb;

   245 #endif

   246 

   247 	if (OPENSSL_issetugid() == 0)

   248 		s=getenv("RANDFILE");

   249 	if (s != NULL && *s && strlen(s) + 1 < size)

   250 		{

   251 		if (BUF_strlcpy(buf,s,size) >= size)

   252 			return NULL;

   253 		}

   254 	else

   255 		{

   256 		if (OPENSSL_issetugid() == 0)

   257 			s=getenv("HOME");

   258 #ifdef DEFAULT_HOME

   259 		if (s == NULL)

   260 			{

   261 			s = DEFAULT_HOME;

   262 			}

   263 #endif

   264 		if (s && *s && strlen(s)+strlen(RFILE)+2 < size)

   265 			{

   266 			BUF_strlcpy(buf,s,size);

   267 #ifndef OPENSSL_SYS_VMS

   268 			BUF_strlcat(buf,"/",size);

   269 #endif

   270 			BUF_strlcat(buf,RFILE,size);

   271 			ok = 1;

   272 			}

   273 		else

   274 		  	buf[0] = '\0'; /* no file name */

   275 		}

   276 

   277 #ifdef __OpenBSD__

   278 	/* given that all random loads just fail if the file can't be 

   279 	 * seen on a stat, we stat the file we're returning, if it

   280 	 * fails, use /dev/arandom instead. this allows the user to 

   281 	 * use their own source for good random data, but defaults

   282 	 * to something hopefully decent if that isn't available. 

   283 	 */

   284 

   285 	if (!ok)

   286 		if (BUF_strlcpy(buf,"/dev/arandom",size) >= size) {

   287 			return(NULL);

   288 		}	

   289 	if (stat(buf,&sb) == -1)

   290 		if (BUF_strlcpy(buf,"/dev/arandom",size) >= size) {

   291 			return(NULL);

   292 		}	

   293 

   294 #endif

   295 	return(buf);

   296 	}