Move zend utility function and rename

Author: arnaud-lb

Zend/zend.c

@@ -94,8 +94,8 @@ ZEND_API char *(*zend_getenv)(const char *name, size_t name_len);
 ZEND_API zend_string *(*zend_resolve_path)(zend_string *filename);
 ZEND_API zend_result (*zend_post_startup_cb)(void) = NULL;
 ZEND_API void (*zend_post_shutdown_cb)(void) = NULL;
-ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_os_csprng_random_bytes)(void *bytes, size_t size, char *errstr, size_t errstr_size) = NULL;
-ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_general_random_bytes)(zend_utility_general_random_state *state, void *bytes, size_t size) = NULL;
+ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_random_bytes)(void *bytes, size_t size, char *errstr, size_t errstr_size) = NULL;
+ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_random_bytes_insecure)(zend_utility_random_bytes_insecure_state *state, void *bytes, size_t size) = NULL;
 
 /* This callback must be signal handler safe! */
 void (*zend_on_timeout)(int seconds);
@@ -915,9 +915,9 @@ void zend_startup(zend_utility_functions *utility_functions) /* {{{ */
 #endif
 
 	/* Set up early utility functions. zend_mm depends on
-	 * zend_general_random_bytes */
-	zend_os_csprng_random_bytes = utility_functions->os_csprng_random_bytes_function;
-	zend_general_random_bytes = utility_functions->general_random_bytes_function;
+	 * zend_random_bytes_insecure */
+	zend_random_bytes = utility_functions->random_bytes_function;
+	zend_random_bytes_insecure = utility_functions->random_bytes_insecure_function;
 
 	start_memory_manager();
 

Zend/zend.h

@@ -237,7 +237,7 @@ struct _zend_class_entry {
 typedef union {
 	zend_max_align_t align;
 	uint64_t opaque[5];
-} zend_utility_general_random_state;
+} zend_utility_random_bytes_insecure_state;
 
 typedef struct _zend_utility_functions {
 	void (*error_function)(int type, zend_string *error_filename, const uint32_t error_lineno, zend_string *message);
@@ -253,8 +253,8 @@ typedef struct _zend_utility_functions {
 	void (*printf_to_smart_str_function)(smart_str *buf, const char *format, va_list ap);
 	char *(*getenv_function)(const char *name, size_t name_len);
 	zend_string *(*resolve_path_function)(zend_string *filename);
-	zend_result (*os_csprng_random_bytes_function)(void *bytes, size_t size, char *errstr, size_t errstr_size);
-	zend_result (*general_random_bytes_function)(zend_utility_general_random_state *state, void *bytes, size_t size);
+	zend_result (*random_bytes_function)(void *bytes, size_t size, char *errstr, size_t errstr_size);
+	zend_result (*random_bytes_insecure_function)(zend_utility_random_bytes_insecure_state *state, void *bytes, size_t size);
 } zend_utility_functions;
 
 typedef struct _zend_utility_values {
@@ -348,10 +348,13 @@ extern void (*zend_printf_to_smart_str)(smart_str *buf, const char *format, va_l
 extern ZEND_API char *(*zend_getenv)(const char *name, size_t name_len);
 extern ZEND_API zend_string *(*zend_resolve_path)(zend_string *filename);
 /* Generate 'size' random bytes into 'bytes' with the OS CSPRNG. */
-extern ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_os_csprng_random_bytes)(void *bytes, size_t size, char *errstr, size_t errstr_size);
-/* Generate 'size' random bytes into 'bytes' with a general purpose PRNG.
- * 'state' must be zeroed before the first call and can be reused. */
-extern ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_general_random_bytes)(zend_utility_general_random_state *state, void *bytes, size_t size);
+extern ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_random_bytes)(
+		void *bytes, size_t size, char *errstr, size_t errstr_size);
+/* Generate 'size' random bytes into 'bytes' with a general purpose PRNG (not
+ * crypto safe). 'state' must be zeroed before the first call and can be reused.
+ */
+extern ZEND_ATTRIBUTE_NONNULL ZEND_API zend_result (*zend_random_bytes_insecure)(
+		zend_utility_random_bytes_insecure_state *state, void *bytes, size_t size);
 
 /* These two callbacks are especially for opcache */
 extern ZEND_API zend_result (*zend_post_startup_cb)(void);

Zend/zend_alloc.c

@@ -338,7 +338,7 @@ struct _zend_mm_heap {
 	HashTable *tracked_allocs;
 #endif
 	pid_t pid;
-	zend_utility_general_random_state rand_state;
+	zend_utility_random_bytes_insecure_state rand_state;
 };
 
 struct _zend_mm_chunk {
@@ -2045,7 +2045,7 @@ static void zend_mm_free_huge(zend_mm_heap *heap, void *ptr ZEND_FILE_LINE_DC ZE
 
 static zend_result zend_mm_refresh_key(zend_mm_heap *heap)
 {
-	return zend_general_random_bytes(&heap->rand_state, &heap->shadow_key, sizeof(heap->shadow_key));
+	return zend_random_bytes_insecure(&heap->rand_state, &heap->shadow_key, sizeof(heap->shadow_key));
 }
 
 static zend_result zend_mm_init_key(zend_mm_heap *heap)

Zend/zend_portability.h

@@ -800,8 +800,12 @@ typedef union {
 	short s;
 	int i;
 	long l;
+#if SIZEOF_LONG_LONG
+	long long ll;
+#endif
 	float f;
 	double d;
+	long double ld;
 	void *p;
 	void (*fun)();
 } zend_max_align_t;

ext/random/config.m4

@@ -27,6 +27,7 @@ PHP_NEW_EXTENSION(random,
       engine_secure.c \
       engine_user.c \
       gammasection.c \
-      randomizer.c,
+      randomizer.c \
+      zend_utils.c,
       no,, -DZEND_ENABLE_STATIC_TSRMLS_CACHE=1)
 PHP_INSTALL_HEADERS([ext/random], [php_random.h php_random_csprng.h php_random_uint128.h])

ext/random/config.w32

@@ -1,4 +1,4 @@
 EXTENSION("random", "random.c", false /* never shared */, "/DZEND_ENABLE_STATIC_TSRMLS_CACHE=1");
 PHP_RANDOM="yes";
-ADD_SOURCES(configure_module_dirname, "csprng.c engine_combinedlcg.c engine_mt19937.c engine_pcgoneseq128xslrr64.c engine_xoshiro256starstar.c engine_secure.c engine_user.c gammasection.c randomizer.c", "random");
+ADD_SOURCES(configure_module_dirname, "csprng.c engine_combinedlcg.c engine_mt19937.c engine_pcgoneseq128xslrr64.c engine_xoshiro256starstar.c engine_secure.c engine_user.c gammasection.c randomizer.c zend_utils.c", "random");
 PHP_INSTALL_HEADERS("ext/random", "php_random.h php_random_csprng.h php_random_uint128.h");

ext/random/php_random.h

@@ -38,11 +38,9 @@
 PHPAPI double php_combined_lcg(void);
 
 typedef struct _php_random_fallback_seed_state php_random_fallback_seed_state;
-typedef struct _php_random_state_for_zend php_random_state_for_zend;
 
 PHPAPI uint64_t php_random_generate_fallback_seed(void);
 PHPAPI uint64_t php_random_generate_fallback_seed_ex(php_random_fallback_seed_state *state);
-PHPAPI zend_result php_general_random_bytes_for_zend(zend_utility_general_random_state *state, void *bytes, size_t size);
 
 static inline zend_long GENERATE_SEED(void)
 {
@@ -118,13 +116,6 @@ typedef struct _php_random_fallback_seed_state {
 	unsigned char seed[20];
 } php_random_fallback_seed_state;
 
-typedef struct _php_random_state_for_zend {
-	bool initialized;
-	php_random_status_state_xoshiro256starstar xoshiro256starstar_state;
-} php_random_state_for_zend;
-
-ZEND_STATIC_ASSERT(sizeof(zend_utility_general_random_state) >= sizeof(php_random_state_for_zend), "");
-
 extern PHPAPI const php_random_algo php_random_algo_combinedlcg;
 extern PHPAPI const php_random_algo php_random_algo_mt19937;
 extern PHPAPI const php_random_algo php_random_algo_pcgoneseq128xslrr64;

ext/random/php_random_csprng.h

@@ -21,7 +21,6 @@
 # include "php.h"
 
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_random_bytes(void *bytes, size_t size, bool should_throw);
-
 ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_random_bytes_ex(void *bytes, size_t size, char *errstr, size_t errstr_size);
 
 PHPAPI zend_result php_random_int(zend_long min, zend_long max, zend_long *result, bool should_throw);

ext/random/php_random_zend_utils.h

@@ -0,0 +1,35 @@
+/*
+   +----------------------------------------------------------------------+
+   | 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          |
+   | [email protected] so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+   | Authors: Arnaud Le Blanc <[email protected]>                       |
+   |          Tim Düsterhus <[email protected]>                            |
+   +----------------------------------------------------------------------+
+*/
+
+#ifndef PHP_RANDOM_ZEND_UTILS_H
+# define PHP_RANDOM_ZEND_UTILS_H
+
+# include "php.h"
+# include "php_random.h"
+# include "zend.h"
+
+typedef struct _php_random_bytes_insecure_state_for_zend {
+	bool initialized;
+	php_random_status_state_xoshiro256starstar xoshiro256starstar_state;
+} php_random_bytes_insecure_state_for_zend;
+
+ZEND_STATIC_ASSERT(sizeof(zend_utility_random_bytes_insecure_state) >= sizeof(php_random_bytes_insecure_state_for_zend), "");
+
+ZEND_ATTRIBUTE_NONNULL PHPAPI zend_result php_random_bytes_insecure_for_zend(
+		zend_utility_random_bytes_insecure_state *state, void *bytes, size_t size);
+
+#endif /* PHP_RANDOM_ZEND_UTILS_H */

ext/random/random.c

@@ -699,55 +699,6 @@ uint64_t php_random_generate_fallback_seed(void)
 	return php_random_generate_fallback_seed_ex(&RANDOM_G(fallback_seed_state));
 }
 
-static void php_general_random_bytes_for_zend_initialize(php_random_state_for_zend *state)
-{
-	uint64_t t[4];
-	php_random_fallback_seed_state fallback_state = {
-		.initialized = false,
-	};
-
-	do {
-		/* Skip the CSPRNG if it has already failed */
-		if (!fallback_state.initialized) {
-			char errstr[128];
-			if (php_random_bytes_ex(&t, sizeof(t), errstr, sizeof(errstr)) == FAILURE) {
-#if ZEND_DEBUG
-				fprintf(stderr, "php_random_bytes_ex: Failed to generate a random seed: %s\n", errstr);
-#endif
-				goto fallback;
-			}
-		} else {
-fallback:
-			t[0] = php_random_generate_fallback_seed_ex(&fallback_state);
-			t[1] = php_random_generate_fallback_seed_ex(&fallback_state);
-			t[2] = php_random_generate_fallback_seed_ex(&fallback_state);
-			t[3] = php_random_generate_fallback_seed_ex(&fallback_state);
-		}
-	} while (UNEXPECTED(t[0] == 0 && t[1] == 0 && t[2] == 0 && t[3] == 0));
-
-	php_random_xoshiro256starstar_seed256(&state->xoshiro256starstar_state, t[0], t[1], t[2], t[3]);
-}
-
-PHPAPI zend_result php_general_random_bytes_for_zend(zend_utility_general_random_state *opaque_state, void *bytes, size_t size)
-{
-	php_random_state_for_zend *state = (php_random_state_for_zend*) opaque_state;
-
-	if (!state->initialized) {
-		php_general_random_bytes_for_zend_initialize(state);
-		state->initialized = true;
-	}
-
-	while (size > 0) {
-		php_random_result result = php_random_algo_xoshiro256starstar.generate(&state->xoshiro256starstar_state);
-		ZEND_ASSERT(result.size == 8 && sizeof(result.result) == 8);
-		size_t chunk_size = MIN(size, 8);
-		bytes = zend_mempcpy(bytes, &result.result, chunk_size);
-		size -= chunk_size;
-	}
-
-	return SUCCESS;
-}
-
 /* {{{ PHP_GINIT_FUNCTION */
 static PHP_GINIT_FUNCTION(random)
 {