Commit 31995007813 for php.net
commit 31995007813d1640ae90c1a7aa24e616c7a04e75
Merge: e6e4d059a66 f81a9a2f7de
Author: ndossche <7771979+ndossche@users.noreply.github.com>
Date: Sat Apr 4 12:45:24 2026 +0200
Merge branch 'PHP-8.4' into PHP-8.5
* PHP-8.4:
Add missing error check on SSL_set_ex_data()
Fix UB and error propagation when X509_gmtime_adj() fails
Fix memory leaks when BN_bin2bn() fails
Add missing error check on BN_CTX_new()
diff --cc ext/openssl/openssl_backend_v1.c
index 6b1ab9ed056,00000000000..13aab24c3ff
mode 100644,000000..100644
--- a/ext/openssl/openssl_backend_v1.c
+++ b/ext/openssl/openssl_backend_v1.c
@@@ -1,770 -1,0 +1,780 @@@
+/*
+ +----------------------------------------------------------------------+
+ | 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: Jakub Zelenka <bukka@php.net> |
+ +----------------------------------------------------------------------+
+ */
+
+#include "php_openssl_backend.h"
+
+#if PHP_OPENSSL_API_VERSION < 0x30000
+
+#include <openssl/bn.h>
+#include <openssl/rsa.h>
+#include <openssl/dsa.h>
+#include <openssl/dh.h>
+
+#if defined(LIBRESSL_VERSION_NUMBER) && !defined(OPENSSL_NO_ENGINE)
+#include <openssl/engine.h>
+#endif
+
+void php_openssl_backend_init(void)
+{
+#ifdef LIBRESSL_VERSION_NUMBER
+ OPENSSL_config(NULL);
+ SSL_library_init();
+ OpenSSL_add_all_ciphers();
+ OpenSSL_add_all_digests();
+ OpenSSL_add_all_algorithms();
+ SSL_load_error_strings();
+#else
+ OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL);
+#endif
+
+ php_openssl_backend_init_common();
+}
+
+void php_openssl_backend_shutdown(void)
+{
+#ifdef LIBRESSL_VERSION_NUMBER
+ EVP_cleanup();
+
+ /* prevent accessing locking callback from unloaded extension */
+ CRYPTO_set_locking_callback(NULL);
+
+ /* Free engine list initialized by OPENSSL_config */
+ ENGINE_cleanup();
+
+ /* free allocated error strings */
+ ERR_free_strings();
+ CONF_modules_free();
+#endif
+}
+
+void php_openssl_backend_init_libctx(struct php_openssl_libctx *ctx)
+{
+ // Do nothing as there is no libctx
+}
+
+void php_openssl_backend_destroy_libctx(struct php_openssl_libctx *ctx)
+{
+ // Do nothing as there is no libctx
+}
+
+EVP_PKEY_CTX *php_openssl_pkey_new_from_name(const char *name, int id)
+{
+ return EVP_PKEY_CTX_new_id(id, NULL);
+}
+
+EVP_PKEY_CTX *php_openssl_pkey_new_from_pkey(EVP_PKEY *pkey)
+{
+ return EVP_PKEY_CTX_new(pkey, NULL);
+}
+
+static bool php_openssl_pkey_init_rsa_data(RSA *rsa, zval *data)
+{
+ BIGNUM *n, *e, *d, *p, *q, *dmp1, *dmq1, *iqmp;
+
+ OPENSSL_PKEY_SET_BN(data, n);
+ OPENSSL_PKEY_SET_BN(data, e);
+ OPENSSL_PKEY_SET_BN(data, d);
+ if (!n || !d || !RSA_set0_key(rsa, n, e, d)) {
+ return 0;
+ }
+
+ OPENSSL_PKEY_SET_BN(data, p);
+ OPENSSL_PKEY_SET_BN(data, q);
+ if ((p || q) && !RSA_set0_factors(rsa, p, q)) {
+ return 0;
+ }
+
+ OPENSSL_PKEY_SET_BN(data, dmp1);
+ OPENSSL_PKEY_SET_BN(data, dmq1);
+ OPENSSL_PKEY_SET_BN(data, iqmp);
+ if ((dmp1 || dmq1 || iqmp) && !RSA_set0_crt_params(rsa, dmp1, dmq1, iqmp)) {
+ return 0;
+ }
+
+ return 1;
+}
+
+EVP_PKEY *php_openssl_pkey_init_rsa(zval *data)
+{
+ EVP_PKEY *pkey = EVP_PKEY_new();
+ if (!pkey) {
+ php_openssl_store_errors();
+ return NULL;
+ }
+
+ RSA *rsa = RSA_new();
+ if (!rsa) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ return NULL;
+ }
+
+ if (!php_openssl_pkey_init_rsa_data(rsa, data) || !EVP_PKEY_assign_RSA(pkey, rsa)) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ RSA_free(rsa);
+ return NULL;
+ }
+
+ return pkey;
+}
+
+static bool php_openssl_pkey_init_dsa_data(DSA *dsa, zval *data, bool *is_private)
+{
+ BIGNUM *p, *q, *g, *priv_key, *pub_key;
+ const BIGNUM *priv_key_const, *pub_key_const;
+
+ OPENSSL_PKEY_SET_BN(data, p);
+ OPENSSL_PKEY_SET_BN(data, q);
+ OPENSSL_PKEY_SET_BN(data, g);
- if (!p || !q || !g || !DSA_set0_pqg(dsa, p, q, g)) {
++ if (!p || !q || !g) {
++ BN_free(p);
++ BN_free(q);
++ BN_free(g);
++ return 0;
++ }
++
++ if (!DSA_set0_pqg(dsa, p, q, g)) {
+ return 0;
+ }
+
+ OPENSSL_PKEY_SET_BN(data, pub_key);
+ OPENSSL_PKEY_SET_BN(data, priv_key);
+ *is_private = priv_key != NULL;
+ if (pub_key) {
+ return DSA_set0_key(dsa, pub_key, priv_key);
+ }
+
+ /* generate key */
+ if (!DSA_generate_key(dsa)) {
+ php_openssl_store_errors();
+ return 0;
+ }
+
+ /* if BN_mod_exp return -1, then DSA_generate_key succeed for failed key
+ * so we need to double check that public key is created */
+ DSA_get0_key(dsa, &pub_key_const, &priv_key_const);
+ if (!pub_key_const || BN_is_zero(pub_key_const)) {
+ return 0;
+ }
+ /* all good */
+ *is_private = true;
+ return 1;
+}
+
+EVP_PKEY *php_openssl_pkey_init_dsa(zval *data, bool *is_private)
+{
+ EVP_PKEY *pkey = EVP_PKEY_new();
+ if (!pkey) {
+ php_openssl_store_errors();
+ return NULL;
+ }
+
+ DSA *dsa = DSA_new();
+ if (!dsa) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ return NULL;
+ }
+
+ if (!php_openssl_pkey_init_dsa_data(dsa, data, is_private)
+ || !EVP_PKEY_assign_DSA(pkey, dsa)) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ DSA_free(dsa);
+ return NULL;
+ }
+
+ return pkey;
+}
+
+static bool php_openssl_pkey_init_dh_data(DH *dh, zval *data, bool *is_private)
+{
+ BIGNUM *p, *q, *g, *priv_key, *pub_key;
+
+ OPENSSL_PKEY_SET_BN(data, p);
+ OPENSSL_PKEY_SET_BN(data, q);
+ OPENSSL_PKEY_SET_BN(data, g);
+ if (!p || !q) {
+ BN_free(p);
+ return 0;
+ }
+
+ if (!DH_set0_pqg(dh, p, q, g)) {
+ return 0;
+ }
+
+ OPENSSL_PKEY_SET_BN(data, priv_key);
+ OPENSSL_PKEY_SET_BN(data, pub_key);
+ *is_private = priv_key != NULL;
+ if (pub_key) {
+ return DH_set0_key(dh, pub_key, priv_key);
+ }
+ if (priv_key) {
+ pub_key = php_openssl_dh_pub_from_priv(priv_key, g, p);
+ if (pub_key == NULL) {
+ BN_free(p);
+ BN_free(q);
+ BN_free(g);
+ BN_free(priv_key);
+ return 0;
+ }
+ return DH_set0_key(dh, pub_key, priv_key);
+ }
+
+ /* generate key */
+ if (!DH_generate_key(dh)) {
+ php_openssl_store_errors();
+ return 0;
+ }
+ /* all good */
+ *is_private = true;
+ return 1;
+}
+
+EVP_PKEY *php_openssl_pkey_init_dh(zval *data, bool *is_private)
+{
+ EVP_PKEY *pkey = EVP_PKEY_new();
+ if (!pkey) {
+ php_openssl_store_errors();
+ return NULL;
+ }
+
+ DH *dh = DH_new();
+ if (!dh) {
+ EVP_PKEY_free(pkey);
+ return NULL;
+ }
+
+ if (!php_openssl_pkey_init_dh_data(dh, data, is_private) || !EVP_PKEY_assign_DH(pkey, dh)) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ DH_free(dh);
+ return NULL;
+ }
+
+ return pkey;
+}
+
+#ifdef HAVE_EVP_PKEY_EC
+static bool php_openssl_pkey_init_ec_data(EC_KEY *eckey, zval *data, bool *is_private) {
+ BIGNUM *p = NULL, *a = NULL, *b = NULL, *order = NULL, *g_x = NULL, *g_y = NULL , *cofactor = NULL;
+ BIGNUM *x = NULL, *y = NULL, *d = NULL;
+ EC_POINT *point_g = NULL;
+ EC_POINT *point_q = NULL;
+ EC_GROUP *group = NULL;
+ BN_CTX *bctx = BN_CTX_new();
++ if (!bctx) {
++ goto clean_exit;
++ }
+
+ *is_private = false;
+
+ zval *curve_name_zv = zend_hash_str_find(Z_ARRVAL_P(data), "curve_name", sizeof("curve_name") - 1);
+ if (curve_name_zv && Z_TYPE_P(curve_name_zv) == IS_STRING && Z_STRLEN_P(curve_name_zv) > 0) {
+ int nid = OBJ_sn2nid(Z_STRVAL_P(curve_name_zv));
+ if (nid == NID_undef) {
+ php_error_docref(NULL, E_WARNING, "Unknown elliptic curve (short) name %s", Z_STRVAL_P(curve_name_zv));
+ goto clean_exit;
+ }
+
+ if (!(group = EC_GROUP_new_by_curve_name(nid))) {
+ goto clean_exit;
+ }
+ EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE);
+ } else {
+ OPENSSL_PKEY_SET_BN(data, p);
+ OPENSSL_PKEY_SET_BN(data, a);
+ OPENSSL_PKEY_SET_BN(data, b);
+ OPENSSL_PKEY_SET_BN(data, order);
+
+ if (!(p && a && b && order)) {
+ if (!p && !a && !b && !order) {
+ php_error_docref(NULL, E_WARNING, "Missing params: curve_name");
+ } else {
+ php_error_docref(
+ NULL, E_WARNING, "Missing params: curve_name or p, a, b, order");
+ }
+ goto clean_exit;
+ }
+
+ if (!(group = EC_GROUP_new_curve_GFp(p, a, b, bctx))) {
+ goto clean_exit;
+ }
+
+ if (!(point_g = EC_POINT_new(group))) {
+ goto clean_exit;
+ }
+
+ zval *generator_zv = zend_hash_str_find(Z_ARRVAL_P(data), "generator", sizeof("generator") - 1);
+ if (generator_zv && Z_TYPE_P(generator_zv) == IS_STRING && Z_STRLEN_P(generator_zv) > 0) {
+ if (!(EC_POINT_oct2point(group, point_g, (unsigned char *)Z_STRVAL_P(generator_zv), Z_STRLEN_P(generator_zv), bctx))) {
+ goto clean_exit;
+ }
+ } else {
+ OPENSSL_PKEY_SET_BN(data, g_x);
+ OPENSSL_PKEY_SET_BN(data, g_y);
+
+ if (!g_x || !g_y) {
+ php_error_docref(
+ NULL, E_WARNING, "Missing params: generator or g_x and g_y");
+ goto clean_exit;
+ }
+
+ if (!EC_POINT_set_affine_coordinates_GFp(group, point_g, g_x, g_y, bctx)) {
+ goto clean_exit;
+ }
+ }
+
+ zval *seed_zv = zend_hash_str_find(Z_ARRVAL_P(data), "seed", sizeof("seed") - 1);
+ if (seed_zv && Z_TYPE_P(seed_zv) == IS_STRING && Z_STRLEN_P(seed_zv) > 0) {
+ if (!EC_GROUP_set_seed(group, (unsigned char *)Z_STRVAL_P(seed_zv), Z_STRLEN_P(seed_zv))) {
+ goto clean_exit;
+ }
+ }
+
+ /*
+ * OpenSSL uses 0 cofactor as a marker for "unknown cofactor".
+ * So accept cofactor == NULL or cofactor >= 0.
+ * Internally, the lib will check the cofactor value.
+ */
+ OPENSSL_PKEY_SET_BN(data, cofactor);
+ if (!EC_GROUP_set_generator(group, point_g, order, cofactor)) {
+ goto clean_exit;
+ }
+ EC_GROUP_set_asn1_flag(group, OPENSSL_EC_EXPLICIT_CURVE);
+ }
+
+ EC_GROUP_set_point_conversion_form(group, POINT_CONVERSION_UNCOMPRESSED);
+
+ if (!EC_KEY_set_group(eckey, group)) {
+ goto clean_exit;
+ }
+
+ OPENSSL_PKEY_SET_BN(data, d);
+ OPENSSL_PKEY_SET_BN(data, x);
+ OPENSSL_PKEY_SET_BN(data, y);
+
+ if (d) {
+ *is_private = true;
+ if (!EC_KEY_set_private_key(eckey, d)) {
+ goto clean_exit;
+ }
+
+ point_q = EC_POINT_new(group);
+ if (!point_q || !EC_POINT_mul(group, point_q, d, NULL, NULL, bctx)) {
+ goto clean_exit;
+ }
+ } else if (x && y) {
+ /* OpenSSL does not allow setting EC_PUB_X/EC_PUB_Y, so convert to encoded format. */
+ point_q = EC_POINT_new(group);
+ if (!point_q || !EC_POINT_set_affine_coordinates_GFp(group, point_q, x, y, bctx)) {
+ goto clean_exit;
+ }
+ }
+
+ if (point_q != NULL) {
+ if (!EC_KEY_set_public_key(eckey, point_q)) {
+ goto clean_exit;
+ }
+ }
+
+ if (!EC_KEY_check_key(eckey)) {
+ *is_private = true;
+ EC_KEY_generate_key(eckey);
+ }
+
+clean_exit:
+ php_openssl_store_errors();
+ BN_CTX_free(bctx);
+ EC_GROUP_free(group);
+ EC_POINT_free(point_g);
+ EC_POINT_free(point_q);
+ BN_free(p);
+ BN_free(a);
+ BN_free(b);
+ BN_free(order);
+ BN_free(g_x);
+ BN_free(g_y);
+ BN_free(cofactor);
+ BN_free(d);
+ BN_free(x);
+ BN_free(y);
+ return EC_KEY_check_key(eckey);
+}
+
+EVP_PKEY *php_openssl_pkey_init_ec(zval *data, bool *is_private) {
+ EVP_PKEY *pkey = EVP_PKEY_new();
+ if (!pkey) {
+ php_openssl_store_errors();
+ return NULL;
+ }
+
+ EC_KEY *ec = EC_KEY_new();
+ if (!ec) {
+ EVP_PKEY_free(pkey);
+ return NULL;
+ }
+
+ if (!php_openssl_pkey_init_ec_data(ec, data, is_private) || !EVP_PKEY_assign_EC_KEY(pkey, ec)) {
+ php_openssl_store_errors();
+ EVP_PKEY_free(pkey);
+ EC_KEY_free(ec);
+ return NULL;
+ }
+
+ return pkey;
+}
+
+#endif
+
+zend_long php_openssl_pkey_get_details(zval *return_value, EVP_PKEY *pkey)
+{
+ zend_long ktype;
+ switch (EVP_PKEY_base_id(pkey)) {
+ case EVP_PKEY_RSA:
+ case EVP_PKEY_RSA2:
+ {
+ RSA *rsa = EVP_PKEY_get0_RSA(pkey);
+ ktype = OPENSSL_KEYTYPE_RSA;
+
+ if (rsa != NULL) {
+ zval z_rsa;
+ const BIGNUM *n, *e, *d, *p, *q, *dmp1, *dmq1, *iqmp;
+
+ RSA_get0_key(rsa, &n, &e, &d);
+ RSA_get0_factors(rsa, &p, &q);
+ RSA_get0_crt_params(rsa, &dmp1, &dmq1, &iqmp);
+
+ array_init(&z_rsa);
+ OPENSSL_PKEY_GET_BN(z_rsa, n);
+ OPENSSL_PKEY_GET_BN(z_rsa, e);
+ OPENSSL_PKEY_GET_BN(z_rsa, d);
+ OPENSSL_PKEY_GET_BN(z_rsa, p);
+ OPENSSL_PKEY_GET_BN(z_rsa, q);
+ OPENSSL_PKEY_GET_BN(z_rsa, dmp1);
+ OPENSSL_PKEY_GET_BN(z_rsa, dmq1);
+ OPENSSL_PKEY_GET_BN(z_rsa, iqmp);
+ add_assoc_zval(return_value, "rsa", &z_rsa);
+ }
+ }
+ break;
+ case EVP_PKEY_DSA:
+ case EVP_PKEY_DSA2:
+ case EVP_PKEY_DSA3:
+ case EVP_PKEY_DSA4:
+ {
+ DSA *dsa = EVP_PKEY_get0_DSA(pkey);
+ ktype = OPENSSL_KEYTYPE_DSA;
+
+ if (dsa != NULL) {
+ zval z_dsa;
+ const BIGNUM *p, *q, *g, *priv_key, *pub_key;
+
+ DSA_get0_pqg(dsa, &p, &q, &g);
+ DSA_get0_key(dsa, &pub_key, &priv_key);
+
+ array_init(&z_dsa);
+ OPENSSL_PKEY_GET_BN(z_dsa, p);
+ OPENSSL_PKEY_GET_BN(z_dsa, q);
+ OPENSSL_PKEY_GET_BN(z_dsa, g);
+ OPENSSL_PKEY_GET_BN(z_dsa, priv_key);
+ OPENSSL_PKEY_GET_BN(z_dsa, pub_key);
+ add_assoc_zval(return_value, "dsa", &z_dsa);
+ }
+ }
+ break;
+ case EVP_PKEY_DH:
+ {
+ DH *dh = EVP_PKEY_get0_DH(pkey);
+ ktype = OPENSSL_KEYTYPE_DH;
+
+ if (dh != NULL) {
+ zval z_dh;
+ const BIGNUM *p, *q, *g, *priv_key, *pub_key;
+
+ DH_get0_pqg(dh, &p, &q, &g);
+ DH_get0_key(dh, &pub_key, &priv_key);
+
+ array_init(&z_dh);
+ OPENSSL_PKEY_GET_BN(z_dh, p);
+ OPENSSL_PKEY_GET_BN(z_dh, g);
+ OPENSSL_PKEY_GET_BN(z_dh, priv_key);
+ OPENSSL_PKEY_GET_BN(z_dh, pub_key);
+ add_assoc_zval(return_value, "dh", &z_dh);
+ }
+ }
+ break;
+#ifdef HAVE_EVP_PKEY_EC
+ case EVP_PKEY_EC:
+ ktype = OPENSSL_KEYTYPE_EC;
+ if (EVP_PKEY_get0_EC_KEY(pkey) != NULL) {
+ zval ec;
+ const EC_GROUP *ec_group;
+ const EC_POINT *pub;
+ int nid;
+ char *crv_sn;
+ ASN1_OBJECT *obj;
+ // openssl recommends a buffer length of 80
+ char oir_buf[80];
+ const EC_KEY *ec_key = EVP_PKEY_get0_EC_KEY(pkey);
+ BIGNUM *x = BN_new();
+ BIGNUM *y = BN_new();
+ const BIGNUM *d;
+
+ ec_group = EC_KEY_get0_group(ec_key);
+
+ array_init(&ec);
+
+ /** Curve nid (numerical identifier) used for ASN1 mapping */
+ nid = EC_GROUP_get_curve_name(ec_group);
+ if (nid != NID_undef) {
+ crv_sn = (char*) OBJ_nid2sn(nid);
+ if (crv_sn != NULL) {
+ add_assoc_string(&ec, "curve_name", crv_sn);
+ }
+
+ obj = OBJ_nid2obj(nid);
+ if (obj != NULL) {
+ int oir_len = OBJ_obj2txt(oir_buf, sizeof(oir_buf), obj, 1);
+ add_assoc_stringl(&ec, "curve_oid", (char*) oir_buf, oir_len);
+ ASN1_OBJECT_free(obj);
+ }
+ }
+
+ pub = EC_KEY_get0_public_key(ec_key);
+
+ if (EC_POINT_get_affine_coordinates_GFp(ec_group, pub, x, y, NULL)) {
+ php_openssl_add_bn_to_array(&ec, x, "x");
+ php_openssl_add_bn_to_array(&ec, y, "y");
+ } else {
+ php_openssl_store_errors();
+ }
+
+ if ((d = EC_KEY_get0_private_key(EVP_PKEY_get0_EC_KEY(pkey))) != NULL) {
+ php_openssl_add_bn_to_array(&ec, d, "d");
+ }
+
+ add_assoc_zval(return_value, "ec", &ec);
+
+ BN_free(x);
+ BN_free(y);
+ }
+ break;
+#endif
+ default:
+ ktype = -1;
+ break;
+ }
+
+ return ktype;
+}
+
+zend_string *php_openssl_dh_compute_key(EVP_PKEY *pkey, char *pub_str, size_t pub_len)
+{
+ DH *dh = EVP_PKEY_get0_DH(pkey);
+ if (dh == NULL) {
+ return NULL;
+ }
+
+ BIGNUM *pub = BN_bin2bn((unsigned char*)pub_str, (int)pub_len, NULL);
+ zend_string *data = zend_string_alloc(DH_size(dh), 0);
+ int len = DH_compute_key((unsigned char*)ZSTR_VAL(data), pub, dh);
+ BN_free(pub);
+
+ if (len < 0) {
+ php_openssl_store_errors();
+ zend_string_release_ex(data, 0);
+ return NULL;
+ }
+
+ ZSTR_LEN(data) = len;
+ ZSTR_VAL(data)[len] = 0;
+ return data;
+}
+
+const EVP_MD *php_openssl_get_evp_md_by_name(const char *name)
+{
+ return EVP_get_digestbyname(name);
+}
+
+const EVP_MD *php_openssl_get_evp_md_from_algo(zend_long algo)
+{
+ EVP_MD *mdtype;
+
+ switch (algo) {
+ case OPENSSL_ALGO_SHA1:
+ mdtype = (EVP_MD *) EVP_sha1();
+ break;
+ case OPENSSL_ALGO_MD5:
+ mdtype = (EVP_MD *) EVP_md5();
+ break;
+#ifndef OPENSSL_NO_MD4
+ case OPENSSL_ALGO_MD4:
+ mdtype = (EVP_MD *) EVP_md4();
+ break;
+#endif
+#ifndef OPENSSL_NO_MD2
+ case OPENSSL_ALGO_MD2:
+ mdtype = (EVP_MD *) EVP_md2();
+ break;
+#endif
+ case OPENSSL_ALGO_SHA224:
+ mdtype = (EVP_MD *) EVP_sha224();
+ break;
+ case OPENSSL_ALGO_SHA256:
+ mdtype = (EVP_MD *) EVP_sha256();
+ break;
+ case OPENSSL_ALGO_SHA384:
+ mdtype = (EVP_MD *) EVP_sha384();
+ break;
+ case OPENSSL_ALGO_SHA512:
+ mdtype = (EVP_MD *) EVP_sha512();
+ break;
+#ifndef OPENSSL_NO_RMD160
+ case OPENSSL_ALGO_RMD160:
+ mdtype = (EVP_MD *) EVP_ripemd160();
+ break;
+#endif
+ default:
+ return NULL;
+ break;
+ }
+ return mdtype;
+}
+
+void php_openssl_release_evp_md(const EVP_MD *md)
+{
+ // Do nothing as MD is static
+}
+
+const EVP_CIPHER *php_openssl_get_evp_cipher_by_name(const char *name)
+{
+ return EVP_get_cipherbyname(name);
+}
+
+const EVP_CIPHER *php_openssl_get_evp_cipher_from_algo(zend_long algo)
+{
+ switch (algo) {
+#ifndef OPENSSL_NO_RC2
+ case PHP_OPENSSL_CIPHER_RC2_40:
+ return EVP_rc2_40_cbc();
+ break;
+ case PHP_OPENSSL_CIPHER_RC2_64:
+ return EVP_rc2_64_cbc();
+ break;
+ case PHP_OPENSSL_CIPHER_RC2_128:
+ return EVP_rc2_cbc();
+ break;
+#endif
+
+#ifndef OPENSSL_NO_DES
+ case PHP_OPENSSL_CIPHER_DES:
+ return EVP_des_cbc();
+ break;
+ case PHP_OPENSSL_CIPHER_3DES:
+ return EVP_des_ede3_cbc();
+ break;
+#endif
+
+#ifndef OPENSSL_NO_AES
+ case PHP_OPENSSL_CIPHER_AES_128_CBC:
+ return EVP_aes_128_cbc();
+ break;
+ case PHP_OPENSSL_CIPHER_AES_192_CBC:
+ return EVP_aes_192_cbc();
+ break;
+ case PHP_OPENSSL_CIPHER_AES_256_CBC:
+ return EVP_aes_256_cbc();
+ break;
+#endif
+
+
+ default:
+ return NULL;
+ break;
+ }
+}
+
+void php_openssl_release_evp_cipher(const EVP_CIPHER *cipher)
+{
+ // Do nothing as the cipher is static
+}
+
+void php_openssl_get_cipher_methods(zval *return_value, bool aliases)
+{
+ array_init(return_value);
+ OBJ_NAME_do_all_sorted(OBJ_NAME_TYPE_CIPHER_METH,
+ aliases ? php_openssl_add_method_or_alias : php_openssl_add_method,
+ return_value);
+}
+
+CONF *php_openssl_nconf_new(void)
+{
+ return NCONF_new(NULL);
+}
+
+X509 *php_openssl_pem_read_asn1_bio_x509(BIO *in)
+{
+ return PEM_ASN1_read_bio((d2i_of_void *)d2i_X509, PEM_STRING_X509, in, NULL, NULL, NULL);
+}
+
+X509 *php_openssl_pem_read_bio_x509(BIO *in)
+{
+ return PEM_read_bio_X509(in, NULL, NULL, NULL);
+}
+
+X509_REQ *php_openssl_pem_read_bio_x509_req(BIO *in)
+{
+ return PEM_read_bio_X509_REQ(in, NULL, NULL, NULL);
+}
+
+STACK_OF(X509_INFO) *php_openssl_pem_read_bio_x509_info(BIO *in)
+{
+ return PEM_X509_INFO_read_bio(in, NULL, NULL, NULL);
+}
+
+EVP_PKEY *php_openssl_pem_read_bio_public_key(BIO *in)
+{
+ return PEM_read_bio_PUBKEY(in, NULL, NULL, NULL);
+}
+
+EVP_PKEY *php_openssl_pem_read_bio_private_key(BIO *in, pem_password_cb *cb, void *u)
+{
+ return PEM_read_bio_PrivateKey(in, NULL, cb, u);
+}
+
+PKCS7 *php_openssl_pem_read_bio_pkcs7(BIO *in)
+{
+ return PEM_read_bio_PKCS7(in, NULL, NULL, NULL);
+}
+
+CMS_ContentInfo *php_openssl_pem_read_bio_cms(BIO *in)
+{
+ return PEM_read_bio_CMS(in, NULL, NULL, NULL);
+}
+
+CMS_ContentInfo *php_openssl_d2i_bio_cms(BIO *in)
+{
+ return d2i_CMS_bio(in, NULL);
+}
+
+CMS_ContentInfo *php_openssl_smime_read_cms(BIO *bio, BIO **bcont)
+{
+ return SMIME_read_CMS(bio, bcont);
+}
+
+#endif