mirror of
https://github.com/php/php-src.git
synced 2026-03-24 00:02:20 +01:00
81744d6cf7
* random: Improve the output quality of RANDOM_SEED()
Previously 4 consecutive calls to `RANDOM_SEED()` each for 4 different CLI
requests resulted in:
$ sapi/cli/php test.php
2c13e9fde9caa
2c13e9fd1d6b0
2c13e9fd4de34
2c13e9fd1610e
$ sapi/cli/php test.php
2c1436764fe07
2c14367621770
2c143676c0bf6
2c143676e02f5
$ sapi/cli/php test.php
2c144995a0626
2c14499590fe2
2c144995c65db
2c14499536833
$ sapi/cli/php test.php
2c145cb30860b
2c145cb3ec027
2c145cb33b4ca
2c145cb38ff63
Now they result in:
$ sapi/cli/php test.php
6796973ace1b5f3d
1913daf5c158cb4b
255dbf24237bc8c9
7c3ba22e60f35196
$ sapi/cli/php test.php
afb7cc9ba9819cd2
3e01a71b91ad020c
6b718364d3ef108
bdcd17beeb4b31d2
$ sapi/cli/php test.php
53d36eb9b83f8788
4381c85e816187aa
2e9b32ee9898e71e
31d15c946842bddb
$ sapi/cli/php test.php
2037a3cba88114b4
ba0b0d93a9bb43aa
e13d82d2421269e2
191de474f3292240
* tree-wide: Replace GENERATE_SEED() by php_random_generate_fallback_seed()
* random: Fix NTS build
* random: Fix Windows build
406 lines
13 KiB
C
406 lines
13 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: |
|
|
| https://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: Rasmus Lerdorf <rasmus@php.net> |
|
|
| Zeev Suraski <zeev@php.net> |
|
|
| Pedro Melo <melo@ip.pt> |
|
|
| Sterling Hughes <sterling@php.net> |
|
|
| Go Kudo <zeriyoshi@php.net> |
|
|
| |
|
|
| Based on code from: Richard J. Wagner <rjwagner@writeme.com> |
|
|
| Makoto Matsumoto <matumoto@math.keio.ac.jp> |
|
|
| Takuji Nishimura |
|
|
| Shawn Cokus <Cokus@math.washington.edu> |
|
|
+----------------------------------------------------------------------+
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include "php.h"
|
|
#include "php_random.h"
|
|
#include "php_random_csprng.h"
|
|
|
|
#include "Zend/zend_exceptions.h"
|
|
|
|
/*
|
|
The following mt19937 algorithms are based on a C++ class MTRand by
|
|
Richard J. Wagner. For more information see the web page at
|
|
http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/VERSIONS/C-LANG/MersenneTwister.h
|
|
|
|
Mersenne Twister random number generator -- a C++ class MTRand
|
|
Based on code by Makoto Matsumoto, Takuji Nishimura, and Shawn Cokus
|
|
Richard J. Wagner v1.0 15 May 2003 rjwagner@writeme.com
|
|
|
|
The Mersenne Twister is an algorithm for generating random numbers. It
|
|
was designed with consideration of the flaws in various other generators.
|
|
The period, 2^19937-1, and the order of equidistribution, 623 dimensions,
|
|
are far greater. The generator is also fast; it avoids multiplication and
|
|
division, and it benefits from caches and pipelines. For more information
|
|
see the inventors' web page at http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
|
|
|
|
Reference
|
|
M. Matsumoto and T. Nishimura, "Mersenne Twister: A 623-Dimensionally
|
|
Equidistributed Uniform Pseudo-Random Number Generator", ACM Transactions on
|
|
Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
|
|
|
|
Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
|
|
Copyright (C) 2000 - 2003, Richard J. Wagner
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
3. The names of its contributors may not be used to endorse or promote
|
|
products derived from this software without specific prior written
|
|
permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#define N 624 /* length of state vector */
|
|
ZEND_STATIC_ASSERT(
|
|
N == sizeof(((php_random_status_state_mt19937*)0)->state) / sizeof(((php_random_status_state_mt19937*)0)->state[0]),
|
|
"Assumed length of Mt19937 state vector does not match actual size."
|
|
);
|
|
#define M (397) /* a period parameter */
|
|
#define hiBit(u) ((u) & 0x80000000U) /* mask all but highest bit of u */
|
|
#define loBit(u) ((u) & 0x00000001U) /* mask all but lowest bit of u */
|
|
#define loBits(u) ((u) & 0x7FFFFFFFU) /* mask the highest bit of u */
|
|
#define mixBits(u, v) (hiBit(u) | loBits(v)) /* move hi bit of u to hi bit of v */
|
|
|
|
#define twist(m,u,v) (m ^ (mixBits(u,v) >> 1) ^ ((uint32_t)(-(int32_t)(loBit(v))) & 0x9908b0dfU))
|
|
#define twist_php(m,u,v) (m ^ (mixBits(u,v) >> 1) ^ ((uint32_t)(-(int32_t)(loBit(u))) & 0x9908b0dfU))
|
|
|
|
static inline void mt19937_reload(php_random_status_state_mt19937 *state)
|
|
{
|
|
uint32_t *p = state->state;
|
|
|
|
if (state->mode == MT_RAND_MT19937) {
|
|
for (uint32_t i = N - M; i--; ++p) {
|
|
*p = twist(p[M], p[0], p[1]);
|
|
}
|
|
for (uint32_t i = M; --i; ++p) {
|
|
*p = twist(p[M-N], p[0], p[1]);
|
|
}
|
|
*p = twist(p[M-N], p[0], state->state[0]);
|
|
} else {
|
|
for (uint32_t i = N - M; i--; ++p) {
|
|
*p = twist_php(p[M], p[0], p[1]);
|
|
}
|
|
for (uint32_t i = M; --i; ++p) {
|
|
*p = twist_php(p[M-N], p[0], p[1]);
|
|
}
|
|
*p = twist_php(p[M-N], p[0], state->state[0]);
|
|
}
|
|
|
|
state->count = 0;
|
|
}
|
|
|
|
PHPAPI inline void php_random_mt19937_seed32(php_random_status_state_mt19937 *state, uint32_t seed)
|
|
{
|
|
uint32_t i, prev_state;
|
|
|
|
/* Initialize generator state with seed
|
|
See Knuth TAOCP Vol 2, 3rd Ed, p.106 for multiplier.
|
|
In previous versions, most significant bits (MSBs) of the seed affect
|
|
only MSBs of the state array. Modified 9 Jan 2002 by Makoto Matsumoto. */
|
|
state->state[0] = seed;
|
|
for (i = 1; i < N; i++) {
|
|
prev_state = state->state[i - 1];
|
|
state->state[i] = (1812433253U * (prev_state ^ (prev_state >> 30)) + i) & 0xffffffffU;
|
|
}
|
|
state->count = i;
|
|
|
|
mt19937_reload(state);
|
|
}
|
|
|
|
static php_random_result generate(void *state)
|
|
{
|
|
php_random_status_state_mt19937 *s = state;
|
|
uint32_t s1;
|
|
|
|
if (s->count >= N) {
|
|
mt19937_reload(s);
|
|
}
|
|
|
|
s1 = s->state[s->count++];
|
|
s1 ^= (s1 >> 11);
|
|
s1 ^= (s1 << 7) & 0x9d2c5680U;
|
|
s1 ^= (s1 << 15) & 0xefc60000U;
|
|
|
|
return (php_random_result){
|
|
.size = sizeof(uint32_t),
|
|
.result = (uint64_t) (s1 ^ (s1 >> 18)),
|
|
};
|
|
}
|
|
|
|
static zend_long range(void *state, zend_long min, zend_long max)
|
|
{
|
|
return php_random_range((php_random_algo_with_state){
|
|
.algo = &php_random_algo_mt19937,
|
|
.state = state,
|
|
}, min, max);
|
|
}
|
|
|
|
static bool serialize(void *state, HashTable *data)
|
|
{
|
|
php_random_status_state_mt19937 *s = state;
|
|
zval t;
|
|
|
|
for (uint32_t i = 0; i < N; i++) {
|
|
ZVAL_STR(&t, php_random_bin2hex_le(&s->state[i], sizeof(uint32_t)));
|
|
zend_hash_next_index_insert(data, &t);
|
|
}
|
|
ZVAL_LONG(&t, s->count);
|
|
zend_hash_next_index_insert(data, &t);
|
|
ZVAL_LONG(&t, s->mode);
|
|
zend_hash_next_index_insert(data, &t);
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool unserialize(void *state, HashTable *data)
|
|
{
|
|
php_random_status_state_mt19937 *s = state;
|
|
zval *t;
|
|
|
|
/* Verify the expected number of elements, this implicitly ensures that no additional elements are present. */
|
|
if (zend_hash_num_elements(data) != (N + 2)) {
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < N; i++) {
|
|
t = zend_hash_index_find(data, i);
|
|
if (!t || Z_TYPE_P(t) != IS_STRING || Z_STRLEN_P(t) != (2 * sizeof(uint32_t))) {
|
|
return false;
|
|
}
|
|
if (!php_random_hex2bin_le(Z_STR_P(t), &s->state[i])) {
|
|
return false;
|
|
}
|
|
}
|
|
t = zend_hash_index_find(data, N);
|
|
if (!t || Z_TYPE_P(t) != IS_LONG) {
|
|
return false;
|
|
}
|
|
s->count = Z_LVAL_P(t);
|
|
if (s->count > N) {
|
|
return false;
|
|
}
|
|
|
|
t = zend_hash_index_find(data, N + 1);
|
|
if (!t || Z_TYPE_P(t) != IS_LONG) {
|
|
return false;
|
|
}
|
|
s->mode = Z_LVAL_P(t);
|
|
if (s->mode != MT_RAND_MT19937 && s->mode != MT_RAND_PHP) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
const php_random_algo php_random_algo_mt19937 = {
|
|
sizeof(php_random_status_state_mt19937),
|
|
generate,
|
|
range,
|
|
serialize,
|
|
unserialize
|
|
};
|
|
|
|
/* {{{ php_random_mt19937_seed_default */
|
|
PHPAPI void php_random_mt19937_seed_default(php_random_status_state_mt19937 *state)
|
|
{
|
|
uint32_t seed = 0;
|
|
|
|
if (php_random_bytes_silent(&seed, sizeof(seed)) == FAILURE) {
|
|
seed = (uint32_t)php_random_generate_fallback_seed();
|
|
}
|
|
|
|
php_random_mt19937_seed32(state, seed);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Random\Engine\Mt19937::__construct() */
|
|
PHP_METHOD(Random_Engine_Mt19937, __construct)
|
|
{
|
|
php_random_algo_with_state engine = Z_RANDOM_ENGINE_P(ZEND_THIS)->engine;
|
|
php_random_status_state_mt19937 *state = engine.state;
|
|
zend_long seed, mode = MT_RAND_MT19937;
|
|
bool seed_is_null = true;
|
|
|
|
ZEND_PARSE_PARAMETERS_START(0, 2)
|
|
Z_PARAM_OPTIONAL;
|
|
Z_PARAM_LONG_OR_NULL(seed, seed_is_null);
|
|
Z_PARAM_LONG(mode);
|
|
ZEND_PARSE_PARAMETERS_END();
|
|
|
|
switch (mode) {
|
|
case MT_RAND_MT19937:
|
|
state->mode = MT_RAND_MT19937;
|
|
break;
|
|
case MT_RAND_PHP:
|
|
zend_error(E_DEPRECATED, "The MT_RAND_PHP variant of Mt19937 is deprecated");
|
|
state->mode = MT_RAND_PHP;
|
|
break;
|
|
default:
|
|
zend_argument_value_error(2, "must be either MT_RAND_MT19937 or MT_RAND_PHP");
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
if (seed_is_null) {
|
|
/* MT19937 has a very large state, uses CSPRNG for seeding only */
|
|
if (php_random_bytes_throw(&seed, sizeof(seed)) == FAILURE) {
|
|
zend_throw_exception(random_ce_Random_RandomException, "Failed to generate a random seed", 0);
|
|
RETURN_THROWS();
|
|
}
|
|
}
|
|
|
|
php_random_mt19937_seed32(state, seed);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Random\Engine\Mt19937::generate() */
|
|
PHP_METHOD(Random_Engine_Mt19937, generate)
|
|
{
|
|
php_random_algo_with_state engine = Z_RANDOM_ENGINE_P(ZEND_THIS)->engine;
|
|
zend_string *bytes;
|
|
|
|
ZEND_PARSE_PARAMETERS_NONE();
|
|
|
|
php_random_result generated = engine.algo->generate(engine.state);
|
|
if (EG(exception)) {
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
bytes = zend_string_alloc(generated.size, false);
|
|
|
|
/* Endianness safe copy */
|
|
for (size_t i = 0; i < generated.size; i++) {
|
|
ZSTR_VAL(bytes)[i] = (generated.result >> (i * 8)) & 0xff;
|
|
}
|
|
ZSTR_VAL(bytes)[generated.size] = '\0';
|
|
|
|
RETURN_STR(bytes);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Random\Engine\Mt19937::__serialize() */
|
|
PHP_METHOD(Random_Engine_Mt19937, __serialize)
|
|
{
|
|
php_random_engine *engine = Z_RANDOM_ENGINE_P(ZEND_THIS);
|
|
zval t;
|
|
|
|
ZEND_PARSE_PARAMETERS_NONE();
|
|
|
|
array_init(return_value);
|
|
|
|
/* members */
|
|
ZVAL_ARR(&t, zend_std_get_properties(&engine->std));
|
|
Z_TRY_ADDREF(t);
|
|
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &t);
|
|
|
|
/* state */
|
|
array_init(&t);
|
|
if (!engine->engine.algo->serialize(engine->engine.state, Z_ARRVAL(t))) {
|
|
zend_throw_exception(NULL, "Engine serialize failed", 0);
|
|
RETURN_THROWS();
|
|
}
|
|
zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &t);
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Random\Engine\Mt19937::__unserialize() */
|
|
PHP_METHOD(Random_Engine_Mt19937, __unserialize)
|
|
{
|
|
php_random_engine *engine = Z_RANDOM_ENGINE_P(ZEND_THIS);
|
|
HashTable *d;
|
|
zval *t;
|
|
|
|
ZEND_PARSE_PARAMETERS_START(1, 1)
|
|
Z_PARAM_ARRAY_HT(d);
|
|
ZEND_PARSE_PARAMETERS_END();
|
|
|
|
/* Verify the expected number of elements, this implicitly ensures that no additional elements are present. */
|
|
if (zend_hash_num_elements(d) != 2) {
|
|
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name));
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
/* members */
|
|
t = zend_hash_index_find(d, 0);
|
|
if (!t || Z_TYPE_P(t) != IS_ARRAY) {
|
|
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name));
|
|
RETURN_THROWS();
|
|
}
|
|
object_properties_load(&engine->std, Z_ARRVAL_P(t));
|
|
if (EG(exception)) {
|
|
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name));
|
|
RETURN_THROWS();
|
|
}
|
|
|
|
/* state */
|
|
t = zend_hash_index_find(d, 1);
|
|
if (!t || Z_TYPE_P(t) != IS_ARRAY) {
|
|
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name));
|
|
RETURN_THROWS();
|
|
}
|
|
if (!engine->engine.algo->unserialize(engine->engine.state, Z_ARRVAL_P(t))) {
|
|
zend_throw_exception_ex(NULL, 0, "Invalid serialization data for %s object", ZSTR_VAL(engine->std.ce->name));
|
|
RETURN_THROWS();
|
|
}
|
|
}
|
|
/* }}} */
|
|
|
|
/* {{{ Random\Engine\Mt19937::__debugInfo() */
|
|
PHP_METHOD(Random_Engine_Mt19937, __debugInfo)
|
|
{
|
|
php_random_engine *engine = Z_RANDOM_ENGINE_P(ZEND_THIS);
|
|
zval t;
|
|
|
|
ZEND_PARSE_PARAMETERS_NONE();
|
|
|
|
if (!engine->std.properties) {
|
|
rebuild_object_properties(&engine->std);
|
|
}
|
|
ZVAL_ARR(return_value, zend_array_dup(engine->std.properties));
|
|
|
|
if (engine->engine.algo->serialize) {
|
|
array_init(&t);
|
|
if (!engine->engine.algo->serialize(engine->engine.state, Z_ARRVAL(t))) {
|
|
zend_throw_exception(NULL, "Engine serialize failed", 0);
|
|
RETURN_THROWS();
|
|
}
|
|
zend_hash_str_add(Z_ARR_P(return_value), "__states", strlen("__states"), &t);
|
|
}
|
|
}
|
|
/* }}} */
|