mirror of
https://github.com/php/php-src.git
synced 2024-09-22 10:27:25 +00:00
2b5de6f839
Closes GH-5758
292 lines
7.2 KiB
C
292 lines
7.2 KiB
C
/*
|
|
+----------------------------------------------------------------------+
|
|
| Copyright (c) The PHP Group |
|
|
+----------------------------------------------------------------------+
|
|
| This source file is subject to version 3.01 of the PHP license, |
|
|
| that is bundled with this package in the file LICENSE, and is |
|
|
| available through the world-wide-web at the following url: |
|
|
| http://www.php.net/license/3_01.txt |
|
|
| If you did not receive a copy of the PHP license and are unable to |
|
|
| obtain it through the world-wide-web, please send a note to |
|
|
| license@php.net so we can mail you a copy immediately. |
|
|
+----------------------------------------------------------------------+
|
|
| Authors: Sammy Kaye Powers <me@sammyk.me> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <math.h>
|
|
|
|
#include "php.h"
|
|
#include "zend_exceptions.h"
|
|
#include "php_random.h"
|
|
|
|
#ifdef PHP_WIN32
|
|
# include "win32/winutil.h"
|
|
#endif
|
|
#ifdef __linux__
|
|
# include <sys/syscall.h>
|
|
#endif
|
|
#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)
|
|
# include <sys/param.h>
|
|
# if __FreeBSD__ && __FreeBSD_version > 1200000
|
|
# include <sys/random.h>
|
|
# endif
|
|
#endif
|
|
|
|
#if __has_feature(memory_sanitizer)
|
|
# include <sanitizer/msan_interface.h>
|
|
#endif
|
|
|
|
#ifdef ZTS
|
|
int random_globals_id;
|
|
#else
|
|
php_random_globals random_globals;
|
|
#endif
|
|
|
|
static void random_globals_ctor(php_random_globals *random_globals_p)
|
|
{
|
|
random_globals_p->fd = -1;
|
|
}
|
|
|
|
static void random_globals_dtor(php_random_globals *random_globals_p)
|
|
{
|
|
if (random_globals_p->fd > 0) {
|
|
close(random_globals_p->fd);
|
|
random_globals_p->fd = -1;
|
|
}
|
|
}
|
|
|
|
/* {{{ */
|
|
PHP_MINIT_FUNCTION(random)
|
|
{
|
|
#ifdef ZTS
|
|
ts_allocate_id(&random_globals_id, sizeof(php_random_globals), (ts_allocate_ctor)random_globals_ctor, (ts_allocate_dtor)random_globals_dtor);
|
|
#else
|
|
random_globals_ctor(&random_globals);
|
|
#endif
|
|
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ */
|
|
PHP_MSHUTDOWN_FUNCTION(random)
|
|
{
|
|
#ifndef ZTS
|
|
random_globals_dtor(&random_globals);
|
|
#endif
|
|
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ php_random_bytes */
|
|
PHPAPI int php_random_bytes(void *bytes, size_t size, zend_bool should_throw)
|
|
{
|
|
#ifdef PHP_WIN32
|
|
/* Defer to CryptGenRandom on Windows */
|
|
if (php_win32_get_random_bytes(bytes, size) == FAILURE) {
|
|
if (should_throw) {
|
|
zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
|
|
}
|
|
return FAILURE;
|
|
}
|
|
#elif HAVE_DECL_ARC4RANDOM_BUF && ((defined(__OpenBSD__) && OpenBSD >= 201405) || (defined(__NetBSD__) && __NetBSD_Version__ >= 700000001))
|
|
arc4random_buf(bytes, size);
|
|
#else
|
|
size_t read_bytes = 0;
|
|
ssize_t n;
|
|
#if (defined(__linux__) && defined(SYS_getrandom)) || (defined(__FreeBSD__) && __FreeBSD_version >= 1200000)
|
|
/* Linux getrandom(2) syscall or FreeBSD getrandom(2) function*/
|
|
/* Keep reading until we get enough entropy */
|
|
while (read_bytes < size) {
|
|
/* Below, (bytes + read_bytes) is pointer arithmetic.
|
|
|
|
bytes read_bytes size
|
|
| | |
|
|
[#######=============] (we're going to write over the = region)
|
|
\\\\\\\\\\\\\
|
|
amount_to_read
|
|
|
|
*/
|
|
size_t amount_to_read = size - read_bytes;
|
|
#if defined(__linux__)
|
|
n = syscall(SYS_getrandom, bytes + read_bytes, amount_to_read, 0);
|
|
#else
|
|
n = getrandom(bytes + read_bytes, amount_to_read, 0);
|
|
#endif
|
|
|
|
if (n == -1) {
|
|
if (errno == ENOSYS) {
|
|
/* This can happen if PHP was compiled against a newer kernel where getrandom()
|
|
* is available, but then runs on an older kernel without getrandom(). If this
|
|
* happens we simply fall back to reading from /dev/urandom. */
|
|
ZEND_ASSERT(read_bytes == 0);
|
|
break;
|
|
} else if (errno == EINTR || errno == EAGAIN) {
|
|
/* Try again */
|
|
continue;
|
|
} else {
|
|
/* If the syscall fails, fall back to reading from /dev/urandom */
|
|
break;
|
|
}
|
|
}
|
|
|
|
#if __has_feature(memory_sanitizer)
|
|
/* MSan does not instrument manual syscall invocations. */
|
|
__msan_unpoison(bytes + read_bytes, n);
|
|
#endif
|
|
read_bytes += (size_t) n;
|
|
}
|
|
#endif
|
|
if (read_bytes < size) {
|
|
int fd = RANDOM_G(fd);
|
|
struct stat st;
|
|
|
|
if (fd < 0) {
|
|
#if HAVE_DEV_URANDOM
|
|
fd = open("/dev/urandom", O_RDONLY);
|
|
#endif
|
|
if (fd < 0) {
|
|
if (should_throw) {
|
|
zend_throw_exception(zend_ce_exception, "Cannot open source device", 0);
|
|
}
|
|
return FAILURE;
|
|
}
|
|
/* Does the file exist and is it a character device? */
|
|
if (fstat(fd, &st) != 0 ||
|
|
# ifdef S_ISNAM
|
|
!(S_ISNAM(st.st_mode) || S_ISCHR(st.st_mode))
|
|
# else
|
|
!S_ISCHR(st.st_mode)
|
|
# endif
|
|
) {
|
|
close(fd);
|
|
if (should_throw) {
|
|
zend_throw_exception(zend_ce_exception, "Error reading from source device", 0);
|
|
}
|
|
return FAILURE;
|
|
}
|
|
RANDOM_G(fd) = fd;
|
|
}
|
|
|
|
for (read_bytes = 0; read_bytes < size; read_bytes += (size_t) n) {
|
|
n = read(fd, bytes + read_bytes, size - read_bytes);
|
|
if (n <= 0) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (read_bytes < size) {
|
|
if (should_throw) {
|
|
zend_throw_exception(zend_ce_exception, "Could not gather sufficient random data", 0);
|
|
}
|
|
return FAILURE;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Return an arbitrary length of pseudo-random bytes as binary string */
|
|
PHP_FUNCTION(random_bytes)
|
|
{
|
|
zend_long size;
|
|
zend_string *bytes;
|
|
|
|
ZEND_PARSE_PARAMETERS_START(1, 1)
|
|
Z_PARAM_LONG(size)
|
|
ZEND_PARSE_PARAMETERS_END();
|
|
|
|
if (size < 1) {
|
|
zend_argument_value_error(1, "must be greater than 0");
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
bytes = zend_string_alloc(size, 0);
|
|
|
|
if (php_random_bytes_throw(ZSTR_VAL(bytes), size) == FAILURE) {
|
|
zend_string_release_ex(bytes, 0);
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
ZSTR_VAL(bytes)[size] = '\0';
|
|
|
|
RETURN_STR(bytes);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ */
|
|
PHPAPI int php_random_int(zend_long min, zend_long max, zend_long *result, zend_bool should_throw)
|
|
{
|
|
zend_ulong umax;
|
|
zend_ulong trial;
|
|
|
|
if (min == max) {
|
|
*result = min;
|
|
return SUCCESS;
|
|
}
|
|
|
|
umax = (zend_ulong) max - (zend_ulong) min;
|
|
|
|
if (php_random_bytes(&trial, sizeof(trial), should_throw) == FAILURE) {
|
|
return FAILURE;
|
|
}
|
|
|
|
/* Special case where no modulus is required */
|
|
if (umax == ZEND_ULONG_MAX) {
|
|
*result = (zend_long)trial;
|
|
return SUCCESS;
|
|
}
|
|
|
|
/* Increment the max so the range is inclusive of max */
|
|
umax++;
|
|
|
|
/* Powers of two are not biased */
|
|
if ((umax & (umax - 1)) != 0) {
|
|
/* Ceiling under which ZEND_LONG_MAX % max == 0 */
|
|
zend_ulong limit = ZEND_ULONG_MAX - (ZEND_ULONG_MAX % umax) - 1;
|
|
|
|
/* Discard numbers over the limit to avoid modulo bias */
|
|
while (trial > limit) {
|
|
if (php_random_bytes(&trial, sizeof(trial), should_throw) == FAILURE) {
|
|
return FAILURE;
|
|
}
|
|
}
|
|
}
|
|
|
|
*result = (zend_long)((trial % umax) + min);
|
|
return SUCCESS;
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Return an arbitrary pseudo-random integer */
|
|
PHP_FUNCTION(random_int)
|
|
{
|
|
zend_long min;
|
|
zend_long max;
|
|
zend_long result;
|
|
|
|
ZEND_PARSE_PARAMETERS_START(2, 2)
|
|
Z_PARAM_LONG(min)
|
|
Z_PARAM_LONG(max)
|
|
ZEND_PARSE_PARAMETERS_END();
|
|
|
|
if (min > max) {
|
|
zend_argument_value_error(1, "must be less than or equal to argument #2 ($max)");
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
if (php_random_int_throw(min, max, &result) == FAILURE) {
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
RETURN_LONG(result);
|
|
}
|
|
/* }}} */
|