#include "php_ini.h"
#include "php_openssl.h"
#include "zend_exceptions.h"
+#include "Zend/zend_interfaces.h"
/* PHP Includes */
#include "ext/standard/file.h"
ENCODING_PEM,
};
+/* OpenSSLCertificate class */
+
+zend_class_entry *php_openssl_certificate_ce;
+
+static zend_object_handlers php_openssl_certificate_object_handlers;
+
+static zend_object *php_openssl_certificate_create_object(zend_class_entry *class_type) {
+ php_openssl_certificate_object *intern = zend_object_alloc(sizeof(php_openssl_certificate_object), class_type);
+
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+ intern->std.handlers = &php_openssl_certificate_object_handlers;
+
+ return &intern->std;
+}
+
+static zend_function *php_openssl_certificate_get_constructor(zend_object *object) {
+ zend_throw_error(NULL, "Cannot directly construct OpenSSLCertificate, use openssl_x509_read() instead");
+ return NULL;
+}
+
+static void php_openssl_certificate_free_obj(zend_object *object)
+{
+ php_openssl_certificate_object *x509_object = php_openssl_certificate_from_obj(object);
+
+ X509_free(x509_object->x509);
+ zend_object_std_dtor(&x509_object->std);
+}
+
+/* OpenSSLCertificateSigningRequest class */
+
+typedef struct _php_openssl_x509_request_object {
+ X509_REQ *csr;
+ zend_object std;
+} php_openssl_request_object;
+
+zend_class_entry *php_openssl_request_ce;
+
+static inline php_openssl_request_object *php_openssl_request_from_obj(zend_object *obj) {
+ return (php_openssl_request_object *)((char *)(obj) - XtOffsetOf(php_openssl_request_object, std));
+}
+
+#define Z_OPENSSL_REQUEST_P(zv) php_openssl_request_from_obj(Z_OBJ_P(zv))
+
+static zend_object_handlers php_openssl_request_object_handlers;
+
+static zend_object *php_openssl_request_create_object(zend_class_entry *class_type) {
+ php_openssl_request_object *intern = zend_object_alloc(sizeof(php_openssl_request_object), class_type);
+
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+ intern->std.handlers = &php_openssl_request_object_handlers;
+
+ return &intern->std;
+}
+
+static zend_function *php_openssl_request_get_constructor(zend_object *object) {
+ zend_throw_error(NULL, "Cannot directly construct OpenSSLCertificateSigningRequest, use openssl_csr_new() instead");
+ return NULL;
+}
+
+static void php_openssl_request_free_obj(zend_object *object)
+{
+ php_openssl_request_object *x509_request = php_openssl_request_from_obj(object);
+
+ X509_REQ_free(x509_request->csr);
+ zend_object_std_dtor(&x509_request->std);
+}
+
+/* OpenSSLAsymmetricKey class */
+
+typedef struct _php_openssl_pkey_object {
+ EVP_PKEY *pkey;
+ zend_object std;
+} php_openssl_pkey_object;
+
+zend_class_entry *php_openssl_pkey_ce;
+
+static inline php_openssl_pkey_object *php_openssl_pkey_from_obj(zend_object *obj) {
+ return (php_openssl_pkey_object *)((char *)(obj) - XtOffsetOf(php_openssl_pkey_object, std));
+}
+
+#define Z_OPENSSL_PKEY_P(zv) php_openssl_pkey_from_obj(Z_OBJ_P(zv))
+
+static zend_object_handlers php_openssl_pkey_object_handlers;
+
+static zend_object *php_openssl_pkey_create_object(zend_class_entry *class_type) {
+ php_openssl_pkey_object *intern = zend_object_alloc(sizeof(php_openssl_pkey_object), class_type);
+
+ zend_object_std_init(&intern->std, class_type);
+ object_properties_init(&intern->std, class_type);
+ intern->std.handlers = &php_openssl_pkey_object_handlers;
+
+ return &intern->std;
+}
+
+static zend_function *php_openssl_pkey_get_constructor(zend_object *object) {
+ zend_throw_error(NULL, "Cannot directly construct OpenSSLAsymmetricKey, use openssl_pkey_new() instead");
+ return NULL;
+}
+
+static void php_openssl_pkey_free_obj(zend_object *object)
+{
+ php_openssl_pkey_object *key_object = php_openssl_pkey_from_obj(object);
+
+ EVP_PKEY *pkey = key_object->pkey;
+ assert(pkey != NULL);
+ EVP_PKEY_free(pkey);
+
+ zend_object_std_dtor(&key_object->std);
+}
+
/* {{{ openssl_module_entry */
zend_module_entry openssl_module_entry = {
STANDARD_MODULE_HEADER,
/* {{{ OpenSSL compatibility functions and macros */
#if PHP_OPENSSL_API_VERSION < 0x10100
+
#define EVP_PKEY_get0_RSA(_pkey) _pkey->pkey.rsa
#define EVP_PKEY_get0_DH(_pkey) _pkey->pkey.dh
#define EVP_PKEY_get0_DSA(_pkey) _pkey->pkey.dsa
return M_ASN1_STRING_data(asn1);
}
+static int EVP_PKEY_up_ref(EVP_PKEY *pkey)
+{
+ return CRYPTO_add(&pkey->references, 1, CRYPTO_LOCK_EVP_PKEY);
+}
+
#if PHP_OPENSSL_API_VERSION < 0x10002
static int X509_get_signature_nid(const X509 *x)
}
/* }}} */
-static int le_key;
-static int le_x509;
-static int le_csr;
static int ssl_stream_data_index;
-int php_openssl_get_x509_list_id(void) /* {{{ */
-{
- return le_x509;
-}
-/* }}} */
-
-/* {{{ resource destructors */
-static void php_openssl_pkey_free(zend_resource *rsrc)
-{
- EVP_PKEY *pkey = (EVP_PKEY *)rsrc->ptr;
-
- assert(pkey != NULL);
-
- EVP_PKEY_free(pkey);
-}
-
-static void php_openssl_x509_free(zend_resource *rsrc)
-{
- X509 *x509 = (X509 *)rsrc->ptr;
- X509_free(x509);
-}
-
-static void php_openssl_csr_free(zend_resource *rsrc)
-{
- X509_REQ * csr = (X509_REQ*)rsrc->ptr;
- X509_REQ_free(csr);
-}
/* }}} */
/* {{{ openssl open_basedir check */
};
/* }}} */
-static X509 * php_openssl_x509_from_zval(zval * val, int makeresource, zend_resource **resourceval);
-static EVP_PKEY * php_openssl_evp_from_zval(
- zval * val, int public_key, char *passphrase, size_t passphrase_len,
- int makeresource, zend_resource **resourceval);
+static X509 *php_openssl_x509_from_param(zend_object *cert_obj, zend_string *cert_str);
+static X509 *php_openssl_x509_from_zval(zval *val, bool *free_cert);
+static X509_REQ *php_openssl_csr_from_param(zend_object *csr_obj, zend_string *csr_str);
+static EVP_PKEY *php_openssl_pkey_from_zval(zval *val, int public_key, char *passphrase, size_t passphrase_len, bool *free_pkey);
+
static int php_openssl_is_private_key(EVP_PKEY* pkey);
static X509_STORE * php_openssl_setup_verify(zval * calist);
static STACK_OF(X509) * php_openssl_load_all_certs_from_file(char *certfile);
-static X509_REQ * php_openssl_csr_from_zval(zval * val, int makeresource, zend_resource ** resourceval);
static EVP_PKEY * php_openssl_generate_private_key(struct php_x509_request * req);
static void php_openssl_add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int shortname) /* {{{ */
{
char * config_filename;
- le_key = zend_register_list_destructors_ex(php_openssl_pkey_free, NULL, "OpenSSL key", module_number);
- le_x509 = zend_register_list_destructors_ex(php_openssl_x509_free, NULL, "OpenSSL X.509", module_number);
- le_csr = zend_register_list_destructors_ex(php_openssl_csr_free, NULL, "OpenSSL X.509 CSR", module_number);
+ zend_class_entry ce;
+ INIT_CLASS_ENTRY(ce, "OpenSSLCertificate", class_OpenSSLCertificate_methods);
+ php_openssl_certificate_ce = zend_register_internal_class(&ce);
+ php_openssl_certificate_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+ php_openssl_certificate_ce->create_object = php_openssl_certificate_create_object;
+ php_openssl_certificate_ce->serialize = zend_class_serialize_deny;
+ php_openssl_certificate_ce->unserialize = zend_class_unserialize_deny;
+
+ memcpy(&php_openssl_certificate_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+ php_openssl_certificate_object_handlers.offset = XtOffsetOf(php_openssl_certificate_object, std);
+ php_openssl_certificate_object_handlers.free_obj = php_openssl_certificate_free_obj;
+ php_openssl_certificate_object_handlers.get_constructor = php_openssl_certificate_get_constructor;
+ php_openssl_certificate_object_handlers.clone_obj = NULL;
+
+ zend_class_entry csr_ce;
+ INIT_CLASS_ENTRY(csr_ce, "OpenSSLCertificateSigningRequest", class_OpenSSLCertificateSigningRequest_methods);
+ php_openssl_request_ce = zend_register_internal_class(&csr_ce);
+ php_openssl_request_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+ php_openssl_request_ce->create_object = php_openssl_request_create_object;
+ php_openssl_request_ce->serialize = zend_class_serialize_deny;
+ php_openssl_request_ce->unserialize = zend_class_unserialize_deny;
+
+ memcpy(&php_openssl_request_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+ php_openssl_request_object_handlers.offset = XtOffsetOf(php_openssl_request_object, std);
+ php_openssl_request_object_handlers.free_obj = php_openssl_request_free_obj;
+ php_openssl_request_object_handlers.get_constructor = php_openssl_request_get_constructor;
+ php_openssl_request_object_handlers.clone_obj = NULL;
+
+ zend_class_entry key_ce;
+ INIT_CLASS_ENTRY(key_ce, "OpenSSLAsymmetricKey", class_OpenSSLAsymmetricKey_methods);
+ php_openssl_pkey_ce = zend_register_internal_class(&key_ce);
+ php_openssl_pkey_ce->ce_flags |= ZEND_ACC_FINAL | ZEND_ACC_NO_DYNAMIC_PROPERTIES;
+ php_openssl_pkey_ce->create_object = php_openssl_pkey_create_object;
+ php_openssl_pkey_ce->serialize = zend_class_serialize_deny;
+ php_openssl_pkey_ce->unserialize = zend_class_unserialize_deny;
+
+ memcpy(&php_openssl_pkey_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+ php_openssl_pkey_object_handlers.offset = XtOffsetOf(php_openssl_pkey_object, std);
+ php_openssl_pkey_object_handlers.free_obj = php_openssl_pkey_free_obj;
+ php_openssl_pkey_object_handlers.get_constructor = php_openssl_pkey_get_constructor;
+ php_openssl_pkey_object_handlers.clone_obj = NULL;
#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined (LIBRESSL_VERSION_NUMBER)
OPENSSL_config(NULL);
}
/* }}} */
-
-/* {{{ php_openssl_x509_from_zval
- Given a zval, coerce it into an X509 object.
- The zval can be:
- . X509 resource created using openssl_read_x509()
- . if it starts with file:// then it will be interpreted as the path to that cert
- . it will be interpreted as the cert data
- If you supply makeresource, the result will be registered as an x509 resource and
- it's value returned in makeresource.
-*/
-static X509 * php_openssl_x509_from_zval(zval * val, int makeresource, zend_resource **resourceval)
-{
+static X509 *php_openssl_x509_from_str(zend_string *cert_str) {
X509 *cert = NULL;
BIO *in;
- if (resourceval) {
- *resourceval = NULL;
- }
- if (Z_TYPE_P(val) == IS_RESOURCE) {
- /* is it an x509 resource ? */
- void * what;
- zend_resource *res = Z_RES_P(val);
-
- what = zend_fetch_resource(res, "OpenSSL X.509", le_x509);
- if (!what) {
- return NULL;
- }
- if (resourceval) {
- *resourceval = res;
- if (makeresource) {
- Z_ADDREF_P(val);
- }
- }
- return (X509*)what;
- }
-
- if (!(Z_TYPE_P(val) == IS_STRING || Z_TYPE_P(val) == IS_OBJECT)) {
- return NULL;
- }
-
- /* force it to be a string and check if it refers to a file */
- if (!try_convert_to_string(val)) {
- return NULL;
- }
-
- if (Z_STRLEN_P(val) > 7 && memcmp(Z_STRVAL_P(val), "file://", sizeof("file://") - 1) == 0) {
-
- if (php_openssl_open_base_dir_chk(Z_STRVAL_P(val) + (sizeof("file://") - 1))) {
+ if (ZSTR_LEN(cert_str) > 7 && memcmp(ZSTR_VAL(cert_str), "file://", sizeof("file://") - 1) == 0) {
+ if (php_openssl_open_base_dir_chk(ZSTR_VAL(cert_str) + (sizeof("file://") - 1))) {
return NULL;
}
- in = BIO_new_file(Z_STRVAL_P(val) + (sizeof("file://") - 1), PHP_OPENSSL_BIO_MODE_R(PKCS7_BINARY));
+ in = BIO_new_file(ZSTR_VAL(cert_str) + (sizeof("file://") - 1), PHP_OPENSSL_BIO_MODE_R(PKCS7_BINARY));
if (in == NULL) {
php_openssl_store_errors();
return NULL;
}
cert = PEM_read_bio_X509(in, NULL, NULL, NULL);
-
} else {
-
- in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
+ in = BIO_new_mem_buf(ZSTR_VAL(cert_str), (int) ZSTR_LEN(cert_str));
if (in == NULL) {
php_openssl_store_errors();
return NULL;
return NULL;
}
- if (makeresource && resourceval) {
- *resourceval = zend_register_resource(cert, le_x509);
- }
return cert;
}
+/* {{{ php_openssl_x509_from_param
+ Given a parameter, extract it into an X509 object.
+ The parameter can be:
+ . X509 object created using openssl_read_x509()
+ . a path to that cert if it starts with file://
+ . the cert data otherwise
+*/
+static X509 *php_openssl_x509_from_param(zend_object *cert_obj, zend_string *cert_str) {
+ if (cert_obj) {
+ return php_openssl_certificate_from_obj(cert_obj)->x509;
+ }
+
+ ZEND_ASSERT(cert_str);
+
+ return php_openssl_x509_from_str(cert_str);
+}
+/* }}} */
+
+static X509 *php_openssl_x509_from_zval(zval *val, bool *free_cert)
+{
+ if (Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val) == php_openssl_certificate_ce) {
+ *free_cert = 0;
+
+ return php_openssl_certificate_from_obj(Z_OBJ_P(val))->x509;
+ }
+
+ *free_cert = 1;
+
+ if (!try_convert_to_string(val)) {
+ return NULL;
+ }
+
+ return php_openssl_x509_from_str(Z_STR_P(val));
+}
/* }}} */
/* {{{ Exports a CERT to file or a var */
PHP_FUNCTION(openssl_x509_export_to_file)
{
- X509 * cert;
- zval * zcert;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+
zend_bool notext = 1;
BIO * bio_out;
char * filename;
size_t filename_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zp|b", &zcert, &filename, &filename_len, ¬ext) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(2, 3)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_PATH(filename, filename_len)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(notext)
+ ZEND_PARSE_PARAMETERS_END();
+
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 1");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
return;
}
php_openssl_store_errors();
php_error_docref(NULL, E_WARNING, "Error opening file %s", filename);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+
+ if (cert_str) {
X509_free(cert);
}
PHP_FUNCTION(openssl_spki_new)
{
size_t challenge_len;
- char * challenge = NULL, * spkstr = NULL;
+ char * challenge = NULL, *spkstr = NULL;
zend_string * s = NULL;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
const char *spkac = "SPKAC=";
zend_long algo = OPENSSL_ALGO_MD5;
- zval * zpkey = NULL;
- EVP_PKEY * pkey = NULL;
+ zval *zpkey = NULL;
+ EVP_PKEY *pkey = NULL;
NETSCAPE_SPKI *spki=NULL;
const EVP_MD *mdtype;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "rs|l", &zpkey, &challenge, &challenge_len, &algo) == FAILURE) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "Os|l", &zpkey, php_openssl_pkey_ce, &challenge, &challenge_len, &algo) == FAILURE) {
RETURN_THROWS();
}
RETVAL_FALSE;
PHP_OPENSSL_CHECK_SIZE_T_TO_INT(challenge_len, challenge);
- pkey = php_openssl_evp_from_zval(zpkey, 0, challenge, challenge_len, 1, &keyresource);
+ pkey = php_openssl_pkey_from_zval(zpkey, 0, challenge, challenge_len, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Unable to use supplied private key");
if (spki != NULL) {
NETSCAPE_SPKI_free(spki);
}
- if (keyresource == NULL && pkey != NULL) {
- EVP_PKEY_free(pkey);
- }
if (s && ZSTR_LEN(s) <= 0) {
RETVAL_FALSE;
}
-
- if (keyresource == NULL && s != NULL) {
- zend_string_release_ex(s, 0);
- }
}
/* }}} */
/* {{{ Exports a CERT to file or a var */
PHP_FUNCTION(openssl_x509_export)
{
- X509 * cert;
- zval * zcert, *zout;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zout;
zend_bool notext = 1;
BIO * bio_out;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz|b", &zcert, &zout, ¬ext) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(2, 3)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zout)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(notext)
+ ZEND_PARSE_PARAMETERS_END();
+
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 1");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
return;
}
BIO_free(bio_out);
cleanup:
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
}
PHP_FUNCTION(openssl_x509_fingerprint)
{
X509 *cert;
- zval *zcert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
zend_bool raw_output = 0;
char *method = "sha1";
size_t method_len;
zend_string *fingerprint;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|sb", &zcert, &method, &method_len, &raw_output) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(1, 3)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_STRING(method, method_len)
+ Z_PARAM_BOOL(raw_output)
+ ZEND_PARSE_PARAMETERS_END();
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 1");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
RETURN_FALSE;
}
RETVAL_FALSE;
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
}
/* {{{ Checks if a private key corresponds to a CERT */
PHP_FUNCTION(openssl_x509_check_private_key)
{
- zval * zcert, *zkey;
- X509 * cert = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zkey;
EVP_PKEY * key = NULL;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
- RETVAL_FALSE;
+ ZEND_PARSE_PARAMETERS_START(2, 2)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zkey)
+ ZEND_PARSE_PARAMETERS_END();
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zcert, &zkey) == FAILURE) {
- RETURN_THROWS();
- }
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
RETURN_FALSE;
}
- key = php_openssl_evp_from_zval(zkey, 0, "", 0, 1, &keyresource);
+
+ RETVAL_FALSE;
+
+ key = php_openssl_pkey_from_zval(zkey, 0, "", 0, &free_pkey);
if (key) {
RETVAL_BOOL(X509_check_private_key(cert, key));
}
- if (keyresource == NULL && key) {
+ if (free_pkey && key) {
EVP_PKEY_free(key);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+
+ if (cert_str) {
X509_free(cert);
}
}
/* {{{ Verifies the signature of certificate cert using public key key */
PHP_FUNCTION(openssl_x509_verify)
{
- zval * zcert, *zkey;
- X509 * cert = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zkey;
EVP_PKEY * key = NULL;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
int err = -1;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &zcert, &zkey) == FAILURE) {
- RETURN_THROWS();
- }
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ ZEND_PARSE_PARAMETERS_START(2, 2)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zkey)
+ ZEND_PARSE_PARAMETERS_END();
+
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
RETURN_LONG(err);
}
- key = php_openssl_evp_from_zval(zkey, 1, NULL, 0, 0, &keyresource);
+
+ key = php_openssl_pkey_from_zval(zkey, 1, NULL, 0, &free_pkey);
if (key == NULL) {
X509_free(cert);
RETURN_LONG(err);
php_openssl_store_errors();
}
- if (keyresource == NULL && key) {
+ if (free_pkey && key) {
EVP_PKEY_free(key);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
/* {{{ Returns an array of the fields/values of the CERT */
PHP_FUNCTION(openssl_x509_parse)
{
- zval * zcert;
- X509 * cert = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
int i, sig_nid;
zend_bool useshortnames = 1;
char * tmpstr;
char *hex_serial;
char buf[256];
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &zcert, &useshortnames) == FAILURE) {
- RETURN_THROWS();
- }
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ ZEND_PARSE_PARAMETERS_START(1, 2)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(useshortnames)
+ ZEND_PARSE_PARAMETERS_END();
+
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
RETURN_FALSE;
}
} else {
zend_array_destroy(Z_ARR_P(return_value));
BIO_free(bio_out);
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
RETURN_FALSE;
BIO_free(bio_out);
}
add_assoc_zval(return_value, "extensions", &subitem);
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
}
/* {{{ Checks the CERT to see if it can be used for the purpose in purpose. cainfo holds information about trusted CAs */
PHP_FUNCTION(openssl_x509_checkpurpose)
{
- zval * zcert, * zcainfo = NULL;
- X509_STORE * cainfo = NULL;
- X509 * cert = NULL;
- STACK_OF(X509) * untrustedchain = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zcainfo = NULL;
+ X509_STORE *cainfo = NULL;
+ STACK_OF(X509) *untrustedchain = NULL;
zend_long purpose;
char * untrusted = NULL;
size_t untrusted_len = 0;
int ret;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zl|a!s", &zcert, &purpose, &zcainfo, &untrusted, &untrusted_len) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(2, 4)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_LONG(purpose)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ARRAY_OR_NULL(zcainfo)
+ Z_PARAM_STRING_OR_NULL(untrusted, untrusted_len)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_LONG(-1);
if (cainfo == NULL) {
goto clean_exit;
}
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
goto clean_exit;
}
} else {
RETVAL_BOOL(ret);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
clean_exit:
/* {{{ Reads X.509 certificates */
PHP_FUNCTION(openssl_x509_read)
{
- zval *cert;
- X509 *x509;
- zend_resource *res;
+ X509 *cert;
+ php_openssl_certificate_object *x509_cert_obj;
+ zend_object *cert_obj;
+ zend_string *cert_str;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &cert) == FAILURE) {
- RETURN_THROWS();
- }
- x509 = php_openssl_x509_from_zval(cert, 1, &res);
- ZVAL_RES(return_value, res);
+ ZEND_PARSE_PARAMETERS_START(1, 1)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ ZEND_PARSE_PARAMETERS_END();
- if (x509 == NULL) {
- php_error_docref(NULL, E_WARNING, "Supplied parameter cannot be coerced into an X509 certificate!");
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
+ if (cert == NULL) {
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
RETURN_FALSE;
}
+
+ object_init_ex(return_value, php_openssl_certificate_ce);
+ x509_cert_obj = Z_OPENSSL_CERTIFICATE_P(return_value);
+ x509_cert_obj->x509 = cert_obj ? X509_dup(cert) : cert;
}
/* }}} */
PHP_FUNCTION(openssl_x509_free)
{
zval *x509;
- X509 *cert;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &x509) == FAILURE) {
- RETURN_THROWS();
- }
- if ((cert = (X509 *)zend_fetch_resource(Z_RES_P(x509), "OpenSSL X.509", le_x509)) == NULL) {
- RETURN_THROWS();
- }
- zend_list_close(Z_RES_P(x509));
+ ZEND_PARSE_PARAMETERS_START(1, 1)
+ Z_PARAM_OBJECT_OF_CLASS(x509, php_openssl_certificate_ce)
+ ZEND_PARSE_PARAMETERS_END();
}
/* }}} */
zval * zcertval;
STACK_OF(X509) * sk = NULL;
X509 * cert;
- zend_resource *certresource;
+ bool free_cert;
sk = sk_X509_new_null();
/* get certs */
if (Z_TYPE_P(zcerts) == IS_ARRAY) {
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zcerts), zcertval) {
- cert = php_openssl_x509_from_zval(zcertval, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zcertval, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
cert = X509_dup(cert);
if (cert == NULL) {
} ZEND_HASH_FOREACH_END();
} else {
/* a single certificate */
- cert = php_openssl_x509_from_zval(zcerts, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zcerts, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
cert = X509_dup(cert);
if (cert == NULL) {
php_openssl_store_errors();
/* {{{ Creates and exports a PKCS to file */
PHP_FUNCTION(openssl_pkcs12_export_to_file)
{
- X509 * cert = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
BIO * bio_out = NULL;
PKCS12 * p12 = NULL;
char * filename;
size_t filename_len;
char * pass;
size_t pass_len;
- zval *zcert = NULL, *zpkey = NULL, *args = NULL;
+ zval *zpkey = NULL, *args = NULL;
EVP_PKEY *priv_key = NULL;
- zend_resource *keyresource;
+ bool free_pkey;
zval * item;
STACK_OF(X509) *ca = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zpzs|a", &zcert, &filename, &filename_len, &zpkey, &pass, &pass_len, &args) == FAILURE)
- RETURN_THROWS();
+ ZEND_PARSE_PARAMETERS_START(4, 5)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_PATH(filename, filename_len)
+ Z_PARAM_ZVAL(zpkey)
+ Z_PARAM_STRING(pass, pass_len)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ARRAY(args)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 1");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
return;
}
- priv_key = php_openssl_evp_from_zval(zpkey, 0, "", 0, 1, &keyresource);
+
+ priv_key = php_openssl_pkey_from_zval(zpkey, 0, "", 0, &free_pkey);
if (priv_key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Cannot get private key from parameter 3");
cleanup:
- if (keyresource == NULL && priv_key) {
+ if (free_pkey && priv_key) {
EVP_PKEY_free(priv_key);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
}
/* {{{ Creates and exports a PKCS12 to a var */
PHP_FUNCTION(openssl_pkcs12_export)
{
- X509 * cert = NULL;
+ X509 *cert;
+ zend_object *cert_obj;
+ zend_string *cert_str;
BIO * bio_out;
PKCS12 * p12 = NULL;
- zval * zcert = NULL, *zout = NULL, *zpkey, *args = NULL;
+ zval *zout = NULL, *zpkey, *args = NULL;
EVP_PKEY *priv_key = NULL;
- zend_resource *keyresource;
+ bool free_pkey;
char * pass;
size_t pass_len;
char * friendly_name = NULL;
zval * item;
STACK_OF(X509) *ca = NULL;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zzzs|a", &zcert, &zout, &zpkey, &pass, &pass_len, &args) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(4, 5)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zout)
+ Z_PARAM_ZVAL(zpkey)
+ Z_PARAM_STRING(pass, pass_len)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ARRAY(args)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(zcert, 0, NULL);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 1");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
return;
}
- priv_key = php_openssl_evp_from_zval(zpkey, 0, "", 0, 1, &keyresource);
+
+ priv_key = php_openssl_pkey_from_zval(zpkey, 0, "", 0, &free_pkey);
if (priv_key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Cannot get private key from parameter 3");
cleanup:
- if (keyresource == NULL && priv_key) {
+ if (free_pkey && priv_key) {
EVP_PKEY_free(priv_key);
}
- if (Z_TYPE_P(zcert) != IS_RESOURCE) {
+ if (cert_str) {
X509_free(cert);
}
}
}
/* }}} */
-/* {{{ php_openssl_csr_from_zval */
-static X509_REQ * php_openssl_csr_from_zval(zval * val, int makeresource, zend_resource **resourceval)
+
+static X509_REQ *php_openssl_csr_from_str(zend_string *csr_str)
{
X509_REQ * csr = NULL;
char * filename = NULL;
BIO * in;
- if (resourceval) {
- *resourceval = NULL;
- }
- if (Z_TYPE_P(val) == IS_RESOURCE) {
- void * what;
- zend_resource *res = Z_RES_P(val);
-
- what = zend_fetch_resource(res, "OpenSSL X.509 CSR", le_csr);
- if (what) {
- if (resourceval) {
- *resourceval = res;
- if (makeresource) {
- Z_ADDREF_P(val);
- }
- }
- return (X509_REQ*)what;
- }
- return NULL;
- } else if (Z_TYPE_P(val) != IS_STRING) {
- return NULL;
+ if (ZSTR_LEN(csr_str) > 7 && memcmp(ZSTR_VAL(csr_str), "file://", sizeof("file://") - 1) == 0) {
+ filename = ZSTR_VAL(csr_str) + (sizeof("file://") - 1);
}
- if (Z_STRLEN_P(val) > 7 && memcmp(Z_STRVAL_P(val), "file://", sizeof("file://") - 1) == 0) {
- filename = Z_STRVAL_P(val) + (sizeof("file://") - 1);
- }
if (filename) {
if (php_openssl_open_base_dir_chk(filename)) {
return NULL;
}
in = BIO_new_file(filename, PHP_OPENSSL_BIO_MODE_R(PKCS7_BINARY));
} else {
- in = BIO_new_mem_buf(Z_STRVAL_P(val), (int)Z_STRLEN_P(val));
+ in = BIO_new_mem_buf(ZSTR_VAL(csr_str), (int) ZSTR_LEN(csr_str));
}
if (in == NULL) {
return csr;
}
-/* }}} */
+
+static X509_REQ *php_openssl_csr_from_param(zend_object *csr_obj, zend_string *csr_str)
+{
+ if (csr_obj) {
+ return php_openssl_request_from_obj(csr_obj)->csr;
+ }
+
+ ZEND_ASSERT(csr_str);
+
+ return php_openssl_csr_from_str(csr_str);
+}
/* {{{ Exports a CSR to file */
PHP_FUNCTION(openssl_csr_export_to_file)
{
- X509_REQ * csr;
- zval * zcsr = NULL;
+ X509_REQ *csr;
+ zend_object *csr_obj;
+ zend_string *csr_str;
zend_bool notext = 1;
char * filename = NULL;
size_t filename_len;
BIO * bio_out;
- zend_resource *csr_resource;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "rp|b", &zcsr, &filename, &filename_len, ¬ext) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(2, 3)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(csr_str, csr_obj, php_openssl_request_ce)
+ Z_PARAM_PATH(filename, filename_len)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(notext)
+ ZEND_PARSE_PARAMETERS_END();
+
RETVAL_FALSE;
- csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource);
+ csr = php_openssl_csr_from_param(csr_obj, csr_str);
if (csr == NULL) {
- if (!EG(exception)) {
- php_error_docref(NULL, E_WARNING, "Cannot get CSR from parameter 1");
- }
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate Signing Request cannot be retrieved");
return;
}
php_error_docref(NULL, E_WARNING, "Error opening file %s", filename);
}
- if (csr_resource == NULL && csr != NULL) {
+ if (csr_str) {
X509_REQ_free(csr);
}
}
/* {{{ Exports a CSR to file or a var */
PHP_FUNCTION(openssl_csr_export)
{
- X509_REQ * csr;
- zval * zcsr = NULL, *zout=NULL;
+ X509_REQ *csr;
+ zend_object *csr_obj;
+ zend_string *csr_str;
+ zval *zout;
zend_bool notext = 1;
BIO * bio_out;
- zend_resource *csr_resource;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "rz|b", &zcsr, &zout, ¬ext) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(2, 3)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(csr_str, csr_obj, php_openssl_request_ce)
+ Z_PARAM_ZVAL(zout)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(notext)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource);
+ csr = php_openssl_csr_from_param(csr_obj, csr_str);
if (csr == NULL) {
- if (!EG(exception)) {
- php_error_docref(NULL, E_WARNING, "Cannot get CSR from parameter 1");
- }
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate Signing Request cannot be retrieved");
return;
}
php_openssl_store_errors();
}
- if (csr_resource == NULL && csr) {
+ if (csr_str) {
X509_REQ_free(csr);
}
BIO_free(bio_out);
/* {{{ Signs a cert with another CERT */
PHP_FUNCTION(openssl_csr_sign)
{
- zval * zcert = NULL, *zcsr, *zpkey, *args = NULL;
+ X509_REQ *csr;
+ zend_object *csr_obj;
+ zend_string *csr_str;
+
+ php_openssl_certificate_object *cert_object;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zpkey, *args = NULL;
zend_long num_days;
zend_long serial = Z_L(0);
- X509 * cert = NULL, *new_cert = NULL;
- X509_REQ * csr;
+ X509 *cert = NULL, *new_cert = NULL;
EVP_PKEY * key = NULL, *priv_key = NULL;
- zend_resource *csr_resource, *certresource = NULL, *keyresource = NULL;
+ bool free_pkey = 0;
int i;
struct php_x509_request req;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz!zl|a!l", &zcsr, &zcert, &zpkey, &num_days, &args, &serial) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(4, 6)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(csr_str, csr_obj, php_openssl_request_ce)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS_OR_NULL(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zpkey)
+ Z_PARAM_LONG(num_days)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ARRAY_OR_NULL(args)
+ Z_PARAM_LONG(serial)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- PHP_SSL_REQ_INIT(&req);
- csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource);
+ csr = php_openssl_csr_from_param(csr_obj, csr_str);
if (csr == NULL) {
- if (!EG(exception)) {
- php_error_docref(NULL, E_WARNING, "Cannot get CSR from parameter 1");
- }
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate Signing Request cannot be retrieved");
return;
}
- if (zcert) {
- cert = php_openssl_x509_from_zval(zcert, 0, &certresource);
+
+ PHP_SSL_REQ_INIT(&req);
+
+ if (cert_str || cert_obj) {
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Cannot get cert from parameter 2");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
goto cleanup;
}
}
- priv_key = php_openssl_evp_from_zval(zpkey, 0, "", 0, 1, &keyresource);
+
+ priv_key = php_openssl_pkey_from_zval(zpkey, 0, "", 0, &free_pkey);
if (priv_key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Cannot get private key from parameter 3");
goto cleanup;
}
- /* Succeeded; lets return the cert */
- ZVAL_RES(return_value, zend_register_resource(new_cert, le_x509));
- new_cert = NULL;
+ object_init_ex(return_value, php_openssl_certificate_ce);
+ cert_object = Z_OPENSSL_CERTIFICATE_P(return_value);
+ cert_object->x509 = new_cert;
cleanup:
if (cert == new_cert) {
cert = NULL;
}
+
PHP_SSL_REQ_DISPOSE(&req);
- if (keyresource == NULL && priv_key) {
+ if (free_pkey && priv_key) {
EVP_PKEY_free(priv_key);
}
if (key) {
EVP_PKEY_free(key);
}
- if (csr_resource == NULL && csr) {
+ if (csr_str) {
X509_REQ_free(csr);
}
- if (zcert && certresource == NULL && cert) {
+ if (cert_str && cert) {
X509_free(cert);
}
- if (new_cert) {
- X509_free(new_cert);
- }
}
/* }}} */
PHP_FUNCTION(openssl_csr_new)
{
struct php_x509_request req;
- zval * args = NULL, * dn, *attribs = NULL;
- zval * out_pkey;
- X509_REQ * csr = NULL;
+ php_openssl_request_object *x509_request_obj;
+ zval *args = NULL, *dn, *attribs = NULL;
+ zval *out_pkey;
+ X509_REQ *csr = NULL;
int we_made_the_key = 1;
- zend_resource *key_resource;
+ bool free_pkey;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "az|a!a!", &dn, &out_pkey, &args, &attribs) == FAILURE) {
RETURN_THROWS();
/* Generate or use a private key */
if (Z_TYPE_P(out_pkey_val) != IS_NULL) {
- req.priv_key = php_openssl_evp_from_zval(out_pkey_val, 0, NULL, 0, 0, &key_resource);
+ req.priv_key = php_openssl_pkey_from_zval(out_pkey_val, 0, NULL, 0, &free_pkey);
if (req.priv_key != NULL) {
we_made_the_key = 0;
}
RETVAL_TRUE;
if (X509_REQ_sign(csr, req.priv_key, req.digest)) {
- ZVAL_RES(return_value, zend_register_resource(csr, le_csr));
+ object_init_ex(return_value, php_openssl_request_ce);
+ x509_request_obj = Z_OPENSSL_REQUEST_P(return_value);
+ x509_request_obj->csr = csr;
csr = NULL;
} else {
php_openssl_store_errors();
}
if (we_made_the_key) {
- /* and a resource for the private key */
- ZEND_TRY_ASSIGN_REF_RES(out_pkey, zend_register_resource(req.priv_key, le_key));
+ /* and an object for the private key */
+ zval zkey_object;
+ php_openssl_pkey_object *key_object;
+ object_init_ex(&zkey_object, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(&zkey_object);
+ key_object->pkey = req.priv_key;
+
+ ZEND_TRY_ASSIGN_REF_TMP(out_pkey, &zkey_object);
req.priv_key = NULL; /* make sure the cleanup code doesn't zap it! */
- } else if (key_resource != NULL) {
+ } else if (!free_pkey) {
req.priv_key = NULL; /* make sure the cleanup code doesn't zap it! */
}
}
/* {{{ Returns the subject of a CERT or FALSE on error */
PHP_FUNCTION(openssl_csr_get_subject)
{
- zval * zcsr;
+ X509_REQ *csr;
+ zend_object *csr_obj;
+ zend_string *csr_str;
zend_bool use_shortnames = 1;
- zend_resource *csr_resource;
- X509_NAME * subject;
- X509_REQ * csr;
+ X509_NAME *subject;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &zcsr, &use_shortnames) == FAILURE) {
- RETURN_THROWS();
- }
-
- csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource);
+ ZEND_PARSE_PARAMETERS_START(1, 2)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(csr_str, csr_obj, php_openssl_request_ce)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(use_shortnames)
+ ZEND_PARSE_PARAMETERS_END();
+ csr = php_openssl_csr_from_param(csr_obj, csr_str);
if (csr == NULL) {
RETURN_FALSE;
}
array_init(return_value);
php_openssl_add_assoc_name_entry(return_value, NULL, subject, use_shortnames);
- if (!csr_resource) {
+ if (csr_str) {
X509_REQ_free(csr);
}
}
/* {{{ Returns the subject of a CERT or FALSE on error */
PHP_FUNCTION(openssl_csr_get_public_key)
{
- zval * zcsr;
+ X509_REQ *orig_csr, *csr;
+ zend_object *csr_obj;
+ zend_string *csr_str;
zend_bool use_shortnames = 1;
- zend_resource *csr_resource;
- X509_REQ *orig_csr, *csr;
+ php_openssl_pkey_object *key_object;
EVP_PKEY *tpubkey;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|b", &zcsr, &use_shortnames) == FAILURE) {
- RETURN_THROWS();
- }
-
- orig_csr = php_openssl_csr_from_zval(zcsr, 0, &csr_resource);
+ ZEND_PARSE_PARAMETERS_START(1, 2)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(csr_str, csr_obj, php_openssl_request_ce)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_BOOL(use_shortnames)
+ ZEND_PARSE_PARAMETERS_END();
+ orig_csr = php_openssl_csr_from_param(csr_obj, csr_str);
if (orig_csr == NULL) {
RETURN_FALSE;
}
X509_REQ_free(csr);
}
- if (!csr_resource) {
+ if (csr_str) {
/* We also need to free the original CSR if it was freshly created */
X509_REQ_free(orig_csr);
}
RETURN_FALSE;
}
- RETURN_RES(zend_register_resource(tpubkey, le_key));
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = tpubkey;
}
/* }}} */
}
/* }}} */
-/* {{{ php_openssl_evp_from_zval
- Given a zval, coerce it into a EVP_PKEY object.
- It can be:
- 1. private key resource from openssl_get_privatekey()
- 2. X509 resource -> public key will be extracted from it
- 3. if it starts with file:// interpreted as path to key file
- 4. interpreted as the data from the cert/key file and interpreted in same way as openssl_get_privatekey()
- 5. an array(0 => [items 2..4], 1 => passphrase)
- 6. if val is a string (possibly starting with file:///) and it is not an X509 certificate, then interpret as public key
- NOTE: If you are requesting a private key but have not specified a passphrase, you should use an
- empty string rather than NULL for the passphrase - NULL causes a passphrase prompt to be emitted in
- the Apache error log!
-*/
-static EVP_PKEY * php_openssl_evp_from_zval(
- zval * val, int public_key, char *passphrase, size_t passphrase_len,
- int makeresource, zend_resource **resourceval)
+static EVP_PKEY *php_openssl_pkey_from_zval(zval *val, int public_key, char *passphrase, size_t passphrase_len, bool *free_pkey)
{
- EVP_PKEY * key = NULL;
- X509 * cert = NULL;
- int free_cert = 0;
- zend_resource *cert_res = NULL;
+ EVP_PKEY *key = NULL;
+ X509 *cert = NULL;
+ bool free_cert = 0;
char * filename = NULL;
zval tmp;
} \
return NULL;
- if (resourceval) {
- *resourceval = NULL;
+ if (free_pkey) {
+ *free_pkey = 1;
}
+
if (Z_TYPE_P(val) == IS_ARRAY) {
zval * zphrase;
}
}
- if (Z_TYPE_P(val) == IS_RESOURCE) {
- void * what;
- zend_resource * res = Z_RES_P(val);
+ if (Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val) == php_openssl_pkey_ce) {
+ int is_priv;
+
+ key = php_openssl_pkey_from_obj(Z_OBJ_P(val))->pkey;
+ is_priv = php_openssl_is_private_key(key);
- what = zend_fetch_resource2(res, "OpenSSL X.509/key", le_x509, le_key);
- if (!what) {
+ /* check whether it is actually a private key if requested */
+ if (!public_key && !is_priv) {
+ php_error_docref(NULL, E_WARNING, "Supplied key param is a public key");
TMP_CLEAN;
}
- if (res->type == le_x509) {
- /* extract key from cert, depending on public_key param */
- cert = (X509*)what;
- free_cert = 0;
- } else if (res->type == le_key) {
- int is_priv;
- is_priv = php_openssl_is_private_key((EVP_PKEY*)what);
-
- /* check whether it is actually a private key if requested */
- if (!public_key && !is_priv) {
- php_error_docref(NULL, E_WARNING, "Supplied key param is a public key");
- TMP_CLEAN;
+ if (public_key && is_priv) {
+ php_error_docref(NULL, E_WARNING, "Don't know how to get public key from this private key");
+ TMP_CLEAN;
+ } else {
+ if (Z_TYPE(tmp) == IS_STRING) {
+ zval_ptr_dtor_str(&tmp);
}
-
- if (public_key && is_priv) {
- php_error_docref(NULL, E_WARNING, "Don't know how to get public key from this private key");
- TMP_CLEAN;
- } else {
- if (Z_TYPE(tmp) == IS_STRING) {
- zval_ptr_dtor_str(&tmp);
- }
- /* got the key - return it */
- if (resourceval) {
- *resourceval = res;
- Z_ADDREF_P(val);
- }
- return (EVP_PKEY*)what;
+ /* got the key - return it */
+ if (free_pkey) {
+ *free_pkey = 0;
}
- } else {
- /* other types could be used here - eg: file pointers and read in the data from them */
- TMP_CLEAN;
+ return key;
}
+ } else if (Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val) == php_openssl_certificate_ce) {
+ cert = php_openssl_certificate_from_obj(Z_OBJ_P(val))->x509;
} else {
/* force it to be a string and check if it refers to a file */
/* passing non string values leaks, object uses toString, it returns NULL
}
/* it's an X509 file/cert of some kind, and we need to extract the data from that */
if (public_key) {
- cert = php_openssl_x509_from_zval(val, 0, &cert_res);
- free_cert = (cert_res == NULL);
- /* actual extraction done later */
- if (!cert) {
+ cert = php_openssl_x509_from_str(Z_STR_P(val));
+
+ if (cert) {
+ free_cert = 1;
+ } else {
/* not a X509 certificate, try to retrieve public key */
BIO* in;
if (filename) {
}
}
- if (free_cert && cert) {
+ if (free_cert) {
X509_free(cert);
}
- if (key && makeresource && resourceval) {
- *resourceval = zend_register_resource(key, le_key);
- }
+
if (Z_TYPE(tmp) == IS_STRING) {
zval_ptr_dtor_str(&tmp);
}
+
return key;
}
-/* }}} */
/* {{{ php_openssl_generate_private_key */
static EVP_PKEY * php_openssl_generate_private_key(struct php_x509_request * req)
struct php_x509_request req;
zval * args = NULL;
zval *data;
+ php_openssl_pkey_object *key_object;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|a!", &args) == FAILURE) {
RETURN_THROWS();
RSA *rsa = RSA_new();
if (rsa) {
if (php_openssl_pkey_init_and_assign_rsa(pkey, rsa, data)) {
- RETURN_RES(zend_register_resource(pkey, le_key));
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
+ return;
}
RSA_free(rsa);
} else {
if (dsa) {
if (php_openssl_pkey_init_dsa(dsa, data)) {
if (EVP_PKEY_assign_DSA(pkey, dsa)) {
- RETURN_RES(zend_register_resource(pkey, le_key));
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
+ return;
} else {
php_openssl_store_errors();
}
if (dh) {
if (php_openssl_pkey_init_dh(dh, data)) {
if (EVP_PKEY_assign_DH(pkey, dh)) {
- ZVAL_COPY_VALUE(return_value, zend_list_insert(pkey, le_key));
+ php_openssl_pkey_object *key_object;
+
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
return;
} else {
php_openssl_store_errors();
}
if (EC_KEY_check_key(eckey) && EVP_PKEY_assign_EC_KEY(pkey, eckey)) {
EC_GROUP_free(group);
- RETURN_RES(zend_register_resource(pkey, le_key));
+
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
+ return;
} else {
php_openssl_store_errors();
}
if (PHP_SSL_REQ_PARSE(&req, args) == SUCCESS) {
if (php_openssl_generate_private_key(&req)) {
/* pass back a key resource */
- RETVAL_RES(zend_register_resource(req.priv_key, le_key));
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = req.priv_key;
/* make sure the cleanup code doesn't zap it! */
req.priv_key = NULL;
}
size_t passphrase_len = 0;
char * filename = NULL;
size_t filename_len = 0;
- zend_resource *key_resource = NULL;
+ bool free_pkey = 0;
int pem_write = 0;
EVP_PKEY * key;
BIO * bio_out = NULL;
RETVAL_FALSE;
PHP_OPENSSL_CHECK_SIZE_T_TO_INT(passphrase_len, passphrase);
- key = php_openssl_evp_from_zval(zpkey, 0, passphrase, passphrase_len, 0, &key_resource);
+ key = php_openssl_pkey_from_zval(zpkey, 0, passphrase, passphrase_len, &free_pkey);
if (key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Cannot get key from parameter 1");
clean_exit:
PHP_SSL_REQ_DISPOSE(&req);
- if (key_resource == NULL && key) {
+ if (free_pkey && key) {
EVP_PKEY_free(key);
}
if (bio_out) {
zval * zpkey, * args = NULL, *out;
char * passphrase = NULL; size_t passphrase_len = 0;
int pem_write = 0;
- zend_resource *key_resource = NULL;
+ bool free_pkey = 0;
EVP_PKEY * key;
BIO * bio_out = NULL;
const EVP_CIPHER * cipher;
RETVAL_FALSE;
PHP_OPENSSL_CHECK_SIZE_T_TO_INT(passphrase_len, passphrase);
- key = php_openssl_evp_from_zval(zpkey, 0, passphrase, passphrase_len, 0, &key_resource);
+ key = php_openssl_pkey_from_zval(zpkey, 0, passphrase, passphrase_len, &free_pkey);
if (key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Cannot get key from parameter 1");
}
PHP_SSL_REQ_DISPOSE(&req);
- if (key_resource == NULL && key) {
+ if (free_pkey && key) {
EVP_PKEY_free(key);
}
if (bio_out) {
{
zval *cert;
EVP_PKEY *pkey;
- zend_resource *res;
+ php_openssl_pkey_object *key_object;
+ bool free_pkey;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &cert) == FAILURE) {
RETURN_THROWS();
}
- pkey = php_openssl_evp_from_zval(cert, 1, NULL, 0, 1, &res);
+ pkey = php_openssl_pkey_from_zval(cert, 1, NULL, 0, &free_pkey);
if (pkey == NULL) {
RETURN_FALSE;
}
- ZVAL_RES(return_value, res);
+
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
+ if (!free_pkey) {
+ EVP_PKEY_up_ref(pkey);
+ }
}
/* }}} */
PHP_FUNCTION(openssl_pkey_free)
{
zval *key;
- EVP_PKEY *pkey;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &key) == FAILURE) {
- RETURN_THROWS();
- }
- if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &key, php_openssl_pkey_ce) == FAILURE) {
RETURN_THROWS();
}
- zend_list_close(Z_RES_P(key));
}
/* }}} */
EVP_PKEY *pkey;
char * passphrase = "";
size_t passphrase_len = sizeof("")-1;
- zend_resource *res;
+ php_openssl_pkey_object *key_object;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "z|s", &cert, &passphrase, &passphrase_len) == FAILURE) {
RETURN_THROWS();
}
PHP_OPENSSL_CHECK_SIZE_T_TO_INT(passphrase_len, passphrase);
- pkey = php_openssl_evp_from_zval(cert, 0, passphrase, passphrase_len, 1, &res);
+ pkey = php_openssl_pkey_from_zval(cert, 0, passphrase, passphrase_len, NULL);
if (pkey == NULL) {
RETURN_FALSE;
}
- ZVAL_RES(return_value, res);
+
+ object_init_ex(return_value, php_openssl_pkey_ce);
+ key_object = Z_OPENSSL_PKEY_P(return_value);
+ key_object->pkey = pkey;
}
/* }}} */
char *pbio;
zend_long ktype;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "r", &key) == FAILURE) {
- RETURN_THROWS();
- }
- if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "O", &key, php_openssl_pkey_ce) == FAILURE) {
RETURN_THROWS();
}
+
+ pkey = Z_OPENSSL_PKEY_P(key)->pkey;
+
out = BIO_new(BIO_s_mem());
if (!PEM_write_bio_PUBKEY(out, pkey)) {
BIO_free(out);
zend_string *data;
int len;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "sr", &pub_str, &pub_len, &key) == FAILURE) {
- RETURN_THROWS();
- }
- if ((pkey = (EVP_PKEY *)zend_fetch_resource(Z_RES_P(key), "OpenSSL key", le_key)) == NULL) {
+ if (zend_parse_parameters(ZEND_NUM_ARGS(), "sO", &pub_str, &pub_len, &key, php_openssl_pkey_ce) == FAILURE) {
RETURN_THROWS();
}
+
+ pkey = Z_OPENSSL_PKEY_P(key)->pkey;
+
if (EVP_PKEY_base_id(pkey) != EVP_PKEY_DH) {
RETURN_FALSE;
}
php_error_docref(NULL, E_WARNING, "keylen < 0, assuming NULL");
}
key_size = key_len;
- if ((pkey = php_openssl_evp_from_zval(priv_key, 0, "", 0, 0, NULL)) == NULL
- || (peer_key = php_openssl_evp_from_zval(peer_pub_key, 1, NULL, 0, 0, NULL)) == NULL) {
+ if ((pkey = php_openssl_pkey_from_zval(priv_key, 0, "", 0, NULL)) == NULL
+ || (peer_key = php_openssl_pkey_from_zval(peer_pub_key, 1, NULL, 0, NULL)) == NULL) {
RETURN_FALSE;
}
EVP_PKEY_CTX *ctx = EVP_PKEY_CTX_new(pkey, NULL);
RETURN_THROWS();
}
-
if (php_openssl_open_base_dir_chk(infilename) || php_openssl_open_base_dir_chk(outfilename)) {
return;
}
/* get certs */
if (Z_TYPE_P(zrecipcerts) == IS_ARRAY) {
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zrecipcerts), zcertval) {
- zend_resource *certresource;
+ bool free_cert;
- cert = php_openssl_x509_from_zval(zcertval, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zcertval, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
/* we shouldn't free this particular cert, as it is a resource.
make a copy and push that on the stack instead */
cert = X509_dup(cert);
} ZEND_HASH_FOREACH_END();
} else {
/* a single certificate */
- zend_resource *certresource;
+ bool free_cert;
- cert = php_openssl_x509_from_zval(zrecipcerts, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zrecipcerts, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
/* we shouldn't free this particular cert, as it is a resource.
make a copy and push that on the stack instead */
cert = X509_dup(cert);
PHP_FUNCTION(openssl_pkcs7_sign)
{
- zval * zcert, * zprivkey, * zheaders;
+ X509 *cert = NULL;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zprivkey, * zheaders;
zval * hval;
- X509 * cert = NULL;
EVP_PKEY * privkey = NULL;
zend_long flags = PKCS7_DETACHED;
PKCS7 * p7 = NULL;
BIO * infile = NULL, * outfile = NULL;
STACK_OF(X509) *others = NULL;
- zend_resource *certresource = NULL, *keyresource = NULL;
+ bool free_pkey = 0;
zend_string * strindex;
char * infilename;
size_t infilename_len;
char * extracertsfilename = NULL;
size_t extracertsfilename_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ppzza!|lp!",
- &infilename, &infilename_len, &outfilename, &outfilename_len,
- &zcert, &zprivkey, &zheaders, &flags, &extracertsfilename,
- &extracertsfilename_len) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(5, 7)
+ Z_PARAM_PATH(infilename, infilename_len)
+ Z_PARAM_PATH(outfilename, outfilename_len)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zprivkey)
+ Z_PARAM_ARRAY_OR_NULL(zheaders)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_LONG(flags)
+ Z_PARAM_PATH_OR_NULL(extracertsfilename, extracertsfilename_len)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
}
}
- privkey = php_openssl_evp_from_zval(zprivkey, 0, "", 0, 0, &keyresource);
+ privkey = php_openssl_pkey_from_zval(zprivkey, 0, "", 0, &free_pkey);
if (privkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Error getting private key");
goto clean_exit;
}
- cert = php_openssl_x509_from_zval(zcert, 0, &certresource);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Error getting cert");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
goto clean_exit;
}
if (others) {
sk_X509_pop_free(others, X509_free);
}
- if (privkey && keyresource == NULL) {
+ if (privkey && free_pkey) {
EVP_PKEY_free(privkey);
}
- if (cert && certresource == NULL) {
+ if (cert && cert_str) {
X509_free(cert);
}
}
PHP_FUNCTION(openssl_pkcs7_decrypt)
{
- zval * recipcert, * recipkey = NULL;
- X509 * cert = NULL;
+ X509 *cert;
+ zval *recipcert, *recipkey = NULL;
+ bool free_recipcert;
EVP_PKEY * key = NULL;
- zend_resource *certresval, *keyresval;
- BIO * in = NULL, * out = NULL, * datain = NULL;
+ bool free_pkey;
+ BIO * in = NULL, *out = NULL, *datain = NULL;
PKCS7 * p7 = NULL;
char * infilename;
size_t infilename_len;
char * outfilename;
size_t outfilename_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ppz|z", &infilename, &infilename_len,
- &outfilename, &outfilename_len, &recipcert, &recipkey) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(3, 4)
+ Z_PARAM_PATH(infilename, infilename_len)
+ Z_PARAM_PATH(outfilename, outfilename_len)
+ Z_PARAM_ZVAL(recipcert)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ZVAL_OR_NULL(recipkey)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(recipcert, 0, &certresval);
+ cert = php_openssl_x509_from_zval(recipcert, &free_recipcert);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Unable to coerce parameter 3 to x509 cert");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
goto clean_exit;
}
- key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, 0, &keyresval);
+ key = php_openssl_pkey_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &free_pkey);
if (key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Unable to get private key");
BIO_free(datain);
BIO_free(in);
BIO_free(out);
- if (cert && certresval == NULL) {
+ if (cert && free_recipcert) {
X509_free(cert);
}
- if (key && keyresval == NULL) {
+ if (key && free_pkey) {
EVP_PKEY_free(key);
}
}
/* get certs */
if (Z_TYPE_P(zrecipcerts) == IS_ARRAY) {
ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(zrecipcerts), zcertval) {
- zend_resource *certresource;
+ bool free_cert;
- cert = php_openssl_x509_from_zval(zcertval, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zcertval, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
/* we shouldn't free this particular cert, as it is a resource.
make a copy and push that on the stack instead */
cert = X509_dup(cert);
} ZEND_HASH_FOREACH_END();
} else {
/* a single certificate */
- zend_resource *certresource;
+ bool free_cert;
- cert = php_openssl_x509_from_zval(zrecipcerts, 0, &certresource);
+ cert = php_openssl_x509_from_zval(zrecipcerts, &free_cert);
if (cert == NULL) {
goto clean_exit;
}
- if (certresource != NULL) {
+ if (!free_cert) {
/* we shouldn't free this particular cert, as it is a resource.
make a copy and push that on the stack instead */
cert = X509_dup(cert);
PHP_FUNCTION(openssl_cms_sign)
{
- zval * zcert, * zprivkey, * zheaders;
+ X509 *cert = NULL;
+ zend_object *cert_obj;
+ zend_string *cert_str;
+ zval *zprivkey, *zheaders;
zval * hval;
- X509 * cert = NULL;
EVP_PKEY * privkey = NULL;
zend_long flags = 0;
zend_long encoding = ENCODING_SMIME;
CMS_ContentInfo * cms = NULL;
BIO * infile = NULL, * outfile = NULL;
STACK_OF(X509) *others = NULL;
- zend_resource *certresource = NULL, *keyresource = NULL;
+ bool free_pkey = 0;
zend_string * strindex;
char * infilename;
size_t infilename_len;
size_t extracertsfilename_len;
int need_final = 0;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ppzza!|llp!",
- &infilename, &infilename_len, &outfilename, &outfilename_len,
- &zcert, &zprivkey, &zheaders, &flags, &encoding, &extracertsfilename,
- &extracertsfilename_len) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(5, 8)
+ Z_PARAM_PATH(infilename, infilename_len)
+ Z_PARAM_PATH(outfilename, outfilename_len)
+ Z_PARAM_STR_OR_OBJ_OF_CLASS(cert_str, cert_obj, php_openssl_certificate_ce)
+ Z_PARAM_ZVAL(zprivkey)
+ Z_PARAM_ARRAY_OR_NULL(zheaders)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_LONG(flags)
+ Z_PARAM_LONG(encoding)
+ Z_PARAM_PATH(extracertsfilename, extracertsfilename_len)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
}
}
- privkey = php_openssl_evp_from_zval(zprivkey, 0, "", 0, 0, &keyresource);
+ privkey = php_openssl_pkey_from_zval(zprivkey, 0, "", 0, &free_pkey);
if (privkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Error getting private key");
goto clean_exit;
}
- cert = php_openssl_x509_from_zval(zcert, 0, &certresource);
+ cert = php_openssl_x509_from_param(cert_obj, cert_str);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Error getting cert");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
goto clean_exit;
}
sk_X509_pop_free(others, X509_free);
}
EVP_PKEY_free(privkey);
- if (cert && certresource == NULL) {
+ if (cert && cert_str) {
X509_free(cert);
}
}
PHP_FUNCTION(openssl_cms_decrypt)
{
- zval * recipcert, * recipkey = NULL;
- X509 * cert = NULL;
+ X509 *cert;
+ zval *recipcert, *recipkey = NULL;
+ bool free_recipcert;
EVP_PKEY * key = NULL;
- zend_resource *certresval, *keyresval;
+ bool free_pkey;
zend_long encoding = ENCODING_SMIME;
BIO * in = NULL, * out = NULL, * datain = NULL;
CMS_ContentInfo * cms = NULL;
char * outfilename;
size_t outfilename_len;
- if (zend_parse_parameters(ZEND_NUM_ARGS(), "ppz|zl", &infilename, &infilename_len,
- &outfilename, &outfilename_len, &recipcert,
- &recipkey, &encoding) == FAILURE) {
- RETURN_THROWS();
- }
+ ZEND_PARSE_PARAMETERS_START(3, 5)
+ Z_PARAM_PATH(infilename, infilename_len)
+ Z_PARAM_PATH(outfilename, outfilename_len)
+ Z_PARAM_ZVAL(recipcert)
+ Z_PARAM_OPTIONAL
+ Z_PARAM_ZVAL(recipkey)
+ Z_PARAM_LONG(encoding)
+ ZEND_PARSE_PARAMETERS_END();
RETVAL_FALSE;
- cert = php_openssl_x509_from_zval(recipcert, 0, &certresval);
+ cert = php_openssl_x509_from_zval(recipcert, &free_recipcert);
if (cert == NULL) {
- php_error_docref(NULL, E_WARNING, "Unable to coerce parameter 3 to x509 cert");
+ php_error_docref(NULL, E_WARNING, "X.509 Certificate cannot be retrieved");
goto clean_exit;
}
- key = php_openssl_evp_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, 0, &keyresval);
+ key = php_openssl_pkey_from_zval(recipkey ? recipkey : recipcert, 0, "", 0, &free_pkey);
if (key == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Unable to get private key");
BIO_free(datain);
BIO_free(in);
BIO_free(out);
- if (cert && certresval == NULL) {
+ if (cert && free_recipcert) {
X509_free(cert);
}
- if (key && keyresval == NULL) {
+ if (key && free_pkey) {
EVP_PKEY_free(key);
}
}
int cryptedlen;
zend_string *cryptedbuf = NULL;
int successful = 0;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
char * data;
size_t data_len;
zend_long padding = RSA_PKCS1_PADDING;
}
RETVAL_FALSE;
- pkey = php_openssl_evp_from_zval(key, 0, "", 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 0, "", 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
if (cryptedbuf) {
zend_string_release_ex(cryptedbuf, 0);
}
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
}
unsigned char *crypttemp;
int successful = 0;
zend_long padding = RSA_PKCS1_PADDING;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
char * data;
size_t data_len;
}
RETVAL_FALSE;
- pkey = php_openssl_evp_from_zval(key, 0, "", 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 0, "", 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "key parameter is not a valid private key");
php_openssl_store_errors();
}
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
if (cryptedbuf) {
int cryptedlen;
zend_string *cryptedbuf;
int successful = 0;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
zend_long padding = RSA_PKCS1_PADDING;
char * data;
size_t data_len;
}
RETVAL_FALSE;
- pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 1, NULL, 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "key parameter is not a valid public key");
} else {
php_openssl_store_errors();
}
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
if (cryptedbuf) {
zend_string *cryptedbuf = NULL;
unsigned char *crypttemp;
int successful = 0;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
zend_long padding = RSA_PKCS1_PADDING;
char * data;
size_t data_len;
}
RETVAL_FALSE;
- pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 1, NULL, 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "key parameter is not a valid public key");
if (cryptedbuf) {
zend_string_release_ex(cryptedbuf, 0);
}
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
}
EVP_PKEY *pkey;
unsigned int siglen;
zend_string *sigbuf;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
char * data;
size_t data_len;
EVP_MD_CTX *md_ctx;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "szz|z", &data, &data_len, &signature, &key, &method) == FAILURE) {
RETURN_THROWS();
}
- pkey = php_openssl_evp_from_zval(key, 0, "", 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 0, "", 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Supplied key param cannot be coerced into a private key");
RETVAL_FALSE;
}
EVP_MD_CTX_destroy(md_ctx);
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
}
int err = 0;
EVP_MD_CTX *md_ctx;
const EVP_MD *mdtype;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
char * data;
size_t data_len;
char * signature;
RETURN_FALSE;
}
- pkey = php_openssl_evp_from_zval(key, 1, NULL, 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(key, 1, NULL, 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Supplied key param cannot be coerced into a public key");
}
EVP_MD_CTX_destroy(md_ctx);
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
RETURN_LONG(err);
zval *pubkeys, *pubkey, *sealdata, *ekeys, *iv = NULL;
HashTable *pubkeysht;
EVP_PKEY **pkeys;
- zend_resource ** key_resources; /* so we know what to cleanup */
+ bool *free_pkeys; /* so we know what to cleanup */
int i, len1, len2, *eksl, nkeys, iv_len;
unsigned char iv_buf[EVP_MAX_IV_LENGTH + 1], *buf = NULL, **eks;
char * data;
eksl = safe_emalloc(nkeys, sizeof(*eksl), 0);
eks = safe_emalloc(nkeys, sizeof(*eks), 0);
memset(eks, 0, sizeof(*eks) * nkeys);
- key_resources = safe_emalloc(nkeys, sizeof(zend_resource*), 0);
- memset(key_resources, 0, sizeof(zend_resource*) * nkeys);
+ free_pkeys = safe_emalloc(nkeys, sizeof(int *), 0);
+ memset(free_pkeys, 0, sizeof(int *) * nkeys);
memset(pkeys, 0, sizeof(*pkeys) * nkeys);
/* get the public keys we are using to seal this data */
i = 0;
ZEND_HASH_FOREACH_VAL(pubkeysht, pubkey) {
- pkeys[i] = php_openssl_evp_from_zval(pubkey, 1, NULL, 0, 0, &key_resources[i]);
+ pkeys[i] = php_openssl_pkey_from_zval(pubkey, 1, NULL, 0, &free_pkeys[i]);
if (pkeys[i] == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Not a public key (%dth member of pubkeys)", i+1);
clean_exit:
for (i=0; i<nkeys; i++) {
- if (key_resources[i] == NULL && pkeys[i] != NULL) {
+ if (free_pkeys[i] && pkeys[i] != NULL) {
EVP_PKEY_free(pkeys[i]);
}
if (eks[i]) {
efree(eks);
efree(eksl);
efree(pkeys);
- efree(key_resources);
+ efree(free_pkeys);
}
/* }}} */
EVP_PKEY *pkey;
int len1, len2, cipher_iv_len;
unsigned char *buf, *iv_buf;
- zend_resource *keyresource = NULL;
+ bool free_pkey = 0;
EVP_CIPHER_CTX *ctx;
char * data;
size_t data_len;
RETURN_THROWS();
}
- pkey = php_openssl_evp_from_zval(privkey, 0, "", 0, 0, &keyresource);
+ pkey = php_openssl_pkey_from_zval(privkey, 0, "", 0, &free_pkey);
if (pkey == NULL) {
if (!EG(exception)) {
php_error_docref(NULL, E_WARNING, "Unable to coerce parameter 4 into a private key");
}
efree(buf);
- if (keyresource == NULL) {
+ if (free_pkey) {
EVP_PKEY_free(pkey);
}
EVP_CIPHER_CTX_free(ctx);
/** @generate-function-entries */
-function openssl_x509_export_to_file($x509, string $outfilename, bool $notext = true): bool {}
+final class OpenSSLCertificate
+{
+}
-function openssl_x509_export($x509 , &$out, bool $notext = true): bool {}
+final class OpenSSLCertificateSigningRequest
+{
+}
-function openssl_x509_fingerprint($x509, string $method = 'sha1', bool $raw_output = false): string|false {}
+final class OpenSSLAsymmetricKey
+{
+}
-function openssl_x509_check_private_key($cert, $key): bool {}
+function openssl_x509_export_to_file(OpenSSLCertificate|string $x509, string $outfilename, bool $notext = true): bool {}
-function openssl_x509_verify($cert, $key): int {}
+function openssl_x509_export(OpenSSLCertificate|string $x509, &$out, bool $notext = true): bool {}
-function openssl_x509_parse($x509, bool $shortname = true): array|false {}
+function openssl_x509_fingerprint(OpenSSLCertificate|string $x509, string $method = "sha1", bool $raw_output = false): string|false {}
-function openssl_x509_checkpurpose($x509cert, int $purpose, ?array $cainfo = [], string $untrustedfile = UNKNOWN): bool|int {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key */
+function openssl_x509_check_private_key(OpenSSLCertificate|string $x509, $key): bool {}
-/** @return resource|false */
-function openssl_x509_read($cert) {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key */
+function openssl_x509_verify(OpenSSLCertificate|string $x509, $key): int {}
-function openssl_x509_free($x509): ?bool {}
+function openssl_x509_parse(OpenSSLCertificate|string $x509, bool $shortname = true): array|false {}
-/**
- * @param resource|string $x509cert
- * @param resource|string|array $priv_key
- */
-function openssl_pkcs12_export_to_file($x509cert, string $filename, $priv_key, string $pass, array $args = UNKNOWN): bool {}
+function openssl_x509_checkpurpose(OpenSSLCertificate|string $x509, int $purpose, ?array $cainfo = [], ?string $untrustedfile = null): bool|int {}
-/**
- * @param resource|string $x509
- * @param resource|string|array $priv_key
- */
-function openssl_pkcs12_export($x509 , &$out, $priv_key, string $pass, array $args = UNKNOWN): bool {}
+function openssl_x509_read(OpenSSLCertificate|string $x509): OpenSSLCertificate|false {}
+
+/** @deprecated */
+function openssl_x509_free(OpenSSLCertificate $x509): void {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $priv_key */
+function openssl_pkcs12_export_to_file(OpenSSLCertificate|string $x509cert, string $filename, $priv_key, string $pass, array $args = []): bool {}
+
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $priv_key */
+function openssl_pkcs12_export(OpenSSLCertificate|string $x509, &$out, $priv_key, string $pass, array $args = []): bool {}
+
+/** @param array $certs */
function openssl_pkcs12_read(string $pkcs12, &$certs, string $pass): bool {}
-/** @param resource $csr */
-function openssl_csr_export_to_file($csr, string $outfilename, bool $notext = true): bool {}
+function openssl_csr_export_to_file(OpenSSLCertificateSigningRequest|string $csr, string $outfilename, bool $notext = true): bool {}
-/** @param resource $csr */
-function openssl_csr_export($csr, &$out, bool $notext = true): bool {}
+/** @param OpenSSLAsymmetricKey $out */
+function openssl_csr_export(OpenSSLCertificateSigningRequest|string $csr, &$out, bool $notext = true): bool {}
-/**
- * @param resource|string $csr
- * @param resource|string $cacert
- * @param resource|string|array $priv_key
- * @return resource|false
- */
-function openssl_csr_sign($csr, $cacert = null, $priv_key, int $days, ?array $config_args = null, int $serial = 0) {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $priv_key */
+function openssl_csr_sign(OpenSSLCertificateSigningRequest|string $csr, OpenSSLCertificate|string|null $cacert, $priv_key, int $days, ?array $config_args = null, int $serial = 0): OpenSSLCertificate|false {}
-/** @return resource|false */
-function openssl_csr_new(array $dn, &$privkey, ?array $configargs = null, ?array $extraattribs = null) {}
+/** @param OpenSSLAsymmetricKey $privkey */
+function openssl_csr_new(array $dn, &$privkey, ?array $configargs = null, ?array $extraattribs = null): OpenSSLCertificateSigningRequest|false {}
-/** @param resource|string $csr */
-function openssl_csr_get_subject($csr, bool $use_shortnames = true): array|false {}
+function openssl_csr_get_subject(OpenSSLCertificateSigningRequest|string $csr, bool $use_shortnames = true): array|false {}
-/**
- * @param resource|string $csr
- * @return resource|false
- */
-function openssl_csr_get_public_key($csr, bool $use_shortnames = true) {}
+function openssl_csr_get_public_key(OpenSSLCertificateSigningRequest|string $csr, bool $use_shortnames = true): OpenSSLAsymmetricKey|false {}
-/** @return resource|false */
-function openssl_pkey_new(?array $configargs = null) {}
+function openssl_pkey_new(?array $configargs = null): OpenSSLAsymmetricKey|false {}
-/** @param resource|string|array $key */
+/**
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ * @param string $out
+ */
function openssl_pkey_export_to_file($key, string $outfilename, ?string $passphrase = null, ?array $configargs = null): bool {}
-/** @param resource|string|array $key */
-function openssl_pkey_export($key, &$out, ?string $passphrase = null, ?array $configargs = null): bool {}
-
/**
- * @param resource|string|array $cert
- * @return resource|false
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ * @param string $out
*/
-function openssl_pkey_get_public($cert) {}
+function openssl_pkey_export($key, &$out, ?string $passphrase = null, ?array $configargs = null): bool {}
+
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $cert */
+function openssl_pkey_get_public($cert): OpenSSLAsymmetricKey|false {}
/**
- * @param resource|string|array $cert
- * @return resource|false
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $cert
* @alias openssl_pkey_get_public
*/
-function openssl_get_publickey($cert) {}
+function openssl_get_publickey($cert): OpenSSLAsymmetricKey|false {}
-/** @param resource $key */
-function openssl_pkey_free($key): void {}
+/** @deprecated */
+function openssl_pkey_free(OpenSSLAsymmetricKey $key): void {}
/**
- * @param resource $key
* @alias openssl_pkey_free
+ * @deprecated
*/
-function openssl_free_key($key): void {}
+function openssl_free_key(OpenSSLAsymmetricKey $key): void {}
-/**
- * @param resource|string|array $key
- * @return resource|false
- */
-function openssl_pkey_get_private($key, string $passphrase = UNKNOWN) {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key */
+function openssl_pkey_get_private($key, string $passphrase = UNKNOWN): OpenSSLAsymmetricKey|false {}
/**
- * @param resource|string|array $key
- * @return resource|false
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
* @alias openssl_pkey_get_private
*/
-function openssl_get_privatekey($key, string $passphrase = UNKNOWN) {}
+function openssl_get_privatekey($key, string $passphrase = UNKNOWN): OpenSSLAsymmetricKey|false {}
-/** @param resource $key */
-function openssl_pkey_get_details($key): array|false {}
+function openssl_pkey_get_details(OpenSSLAsymmetricKey $key): array|false {}
function openssl_pbkdf2(string $password, string $salt, int $key_length, int $iterations, string $digest_algorithm = 'sha1'): string|false {}
function openssl_pkcs7_verify(string $filename, int $flags, string $signerscerts = UNKNOWN, array $cainfo = UNKNOWN, string $extracerts = UNKNOWN, string $content = UNKNOWN, string $pk7 = UNKNOWN): bool|int {}
-/** @param resource|string|array $recipcerts */
+/** @param OpenSSLCertificate|array|string $recipcerts */
function openssl_pkcs7_encrypt(string $infile, string $outfile, $recipcerts, ?array $headers, int $flags = 0, int $cipher = OPENSSL_CIPHER_RC2_40): bool {}
-/**
- * @param resource|string $signcert
- * @param resource|string|array $signkey
- */
-function openssl_pkcs7_sign(string $infile, string $outfile, $signcert, $signkey, ?array $headers, int $flags = PKCS7_DETACHED, ?string $extracertsfilename = null): bool {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $signkey */
+function openssl_pkcs7_sign(string $infile, string $outfile, OpenSSLCertificate|string $signcert, $signkey, ?array $headers, int $flags = PKCS7_DETACHED, ?string $extracertsfilename = null): bool {}
-/**
- * @param resource|string $recipcert
- * @param resource|string|array $recipkey
- */
-function openssl_pkcs7_decrypt(string $infilename, string $outfilename, $recipcert, $recipkey = UNKNOWN): bool {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string|null $recipkey */
+function openssl_pkcs7_decrypt(string $infilename, string $outfilename, OpenSSLCertificate|string $recipcert, $recipkey = null): bool {}
function openssl_pkcs7_read(string $infilename, &$certs): bool {}
function openssl_cms_verify(string $filename, int $flags = 0, ?string $signerscerts = null, ?array $cainfo = null, ?string $extracerts = null, ?string $content = null, ?string $pk7 = null, ?string $sigfile = null, $encoding = OPENSSL_ENCODING_SMIME): bool {}
-/** @param resource|string|array $recipcerts */
+/** @param OpenSSLCertificate|array|string $recipcerts */
function openssl_cms_encrypt(string $infile, string $outfile, $recipcerts, ?array $headers, int $flags = 0, int $encoding = OPENSSL_ENCODING_SMIME, int $cipher = OPENSSL_CIPHER_RC2_40): bool {}
-/**
- * @param resource|string $signcert
- * @param resource|string|array $signkey
- */
-function openssl_cms_sign(string $infile, string $outfile, $signcert, $signkey, ?array $headers, int $flags = 0, int $encoding = OPENSSL_ENCODING_SMIME, ?string $extracertsfilename = null): bool {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $signkey */
+function openssl_cms_sign(string $infile, string $outfile, OpenSSLCertificate|string $signcert, $signkey, ?array $headers, int $flags = 0, int $encoding = OPENSSL_ENCODING_SMIME, ?string $extracertsfilename = null): bool {}
-/**
- * @param resource|string $recipcert
- * @param resource|string|array $recipkey
- */
-function openssl_cms_decrypt(string $infilename, string $outfilename, $recipcert, $recipkey, int $encoding = OPENSSL_ENCODING_SMIME): bool {}
+/** @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $recipkey */
+function openssl_cms_decrypt(string $infilename, string $outfilename, OpenSSLCertificate|string $recipcert, $recipkey, int $encoding = OPENSSL_ENCODING_SMIME): bool {}
+/** @param array $certs */
function openssl_cms_read(string $infilename, &$certs): bool {}
-
-/** @param resource|string|array $key */
+/**
+ * @param string $crypted
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ */
function openssl_private_encrypt(string $data, &$crypted, $key, int $padding = OPENSSL_PKCS1_PADDING): bool {}
-/** @param resource|string|array $key */
+/**
+ * @param string $crypted
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ */
function openssl_private_decrypt(string $data, &$crypted, $key, int $padding = OPENSSL_PKCS1_PADDING): bool {}
-/** @param resource|string|array $key */
+/**
+ * @param string $crypted
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ */
function openssl_public_encrypt(string $data, &$crypted, $key, int $padding = OPENSSL_PKCS1_PADDING): bool {}
-/** @param resource|string|array $key */
+/**
+ * @param string $crypted
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
+ */
function openssl_public_decrypt(string $data, &$crypted, $key, int $padding = OPENSSL_PKCS1_PADDING): bool {}
function openssl_error_string(): string|false {}
/**
- * @param resource|string|array $key
+ * @param string $signature
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
* @param int|string $method
*/
function openssl_sign(string $data, &$signature, $key, $method = OPENSSL_ALGO_SHA1): bool {}
/**
- * @param resource|string|array $key
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $key
* @param int|string $method
*/
function openssl_verify(string $data, string $signature, $key, $method = OPENSSL_ALGO_SHA1): int|false {}
+/**
+ * @param string $sealdata
+ * @param array $ekeys
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $pubkeys
+ * @param string $iv
+ */
function openssl_seal(string $data, &$sealdata, &$ekeys, array $pubkeys, string $method = UNKNOWN, &$iv = UNKNOWN): int|false {}
-/** @param resource|string|array $privkey */
+/**
+ * @param string $opendata
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $privkey
+ */
function openssl_open(string $data, &$opendata, string $ekey, $privkey, string $method = UNKNOWN, string $iv = UNKNOWN): bool {}
-function openssl_get_md_methods($aliases = false): array {}
+function openssl_get_md_methods(bool $aliases = false): array {}
-function openssl_get_cipher_methods($aliases = false): array {}
+function openssl_get_cipher_methods(bool $aliases = false): array {}
#ifdef HAVE_EVP_PKEY_EC
function openssl_get_curve_names(): array|false {}
function openssl_digest(string $data, string $method, bool $raw_output = false): string|false {}
+/** @param string $tag */
function openssl_encrypt(string $data, string $method, string $password, int $options = 0, string $iv = '', &$tag = UNKNOWN, string $aad = '', int $tag_length = 16): string|false {}
function openssl_decrypt(string $data, string $method, string $password, int $options = 0, string $iv = '', string $tag = UNKNOWN, string $aad = ''): string|false {}
function openssl_cipher_iv_length(string $method): int|false {}
-/** @param resource $dh_key */
-function openssl_dh_compute_key(string $pub_key, $dh_key): string|false {}
+function openssl_dh_compute_key(string $pub_key, OpenSSLAsymmetricKey $dh_key): string|false {}
/**
- * @param resource|string|array $peer_pub_key
- * @param resource|string|array $priv_key
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $peer_pub_key
+ * @param OpenSSLAsymmetricKey|OpenSSLCertificate|array|string $priv_key
*/
function openssl_pkey_derive($peer_pub_key, $priv_key, int $keylen = 0): string|false {}
+/** @param bool $result_is_strong */
function openssl_random_pseudo_bytes(int $length, &$result_is_strong = UNKNOWN): string {}
-/** @param resource $privkey */
-function openssl_spki_new($privkey, string $challenge, int $algo = OPENSSL_ALGO_MD5): string|false {}
+function openssl_spki_new(OpenSSLAsymmetricKey $privkey, string $challenge, int $algo = OPENSSL_ALGO_MD5): string|false {}
function openssl_spki_verify(string $spki): bool {}
/* This is a generated file, edit the .stub.php file instead.
- * Stub hash: 0d04e9173f45a10b9f6614b79029d96a528bec49 */
+ * Stub hash: 5189cc18305417d2566fe594f69806f72899c355 */
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_export_to_file, 0, 2, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, x509)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO(0, outfilename, IS_STRING, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, notext, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_export, 0, 2, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, x509)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(1, out)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, notext, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_x509_fingerprint, 0, 1, MAY_BE_STRING|MAY_BE_FALSE)
- ZEND_ARG_INFO(0, x509)
- ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, method, IS_STRING, 0, "\'sha1\'")
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, method, IS_STRING, 0, "\"sha1\"")
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, raw_output, _IS_BOOL, 0, "false")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_check_private_key, 0, 2, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, cert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(0, key)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_verify, 0, 2, IS_LONG, 0)
- ZEND_ARG_INFO(0, cert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(0, key)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_x509_parse, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
- ZEND_ARG_INFO(0, x509)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, shortname, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_x509_checkpurpose, 0, 2, MAY_BE_BOOL|MAY_BE_LONG)
- ZEND_ARG_INFO(0, x509cert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO(0, purpose, IS_LONG, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, cainfo, IS_ARRAY, 1, "[]")
- ZEND_ARG_TYPE_INFO(0, untrustedfile, IS_STRING, 0)
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, untrustedfile, IS_STRING, 1, "null")
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_x509_read, 0, 0, 1)
- ZEND_ARG_INFO(0, cert)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_x509_read, 0, 1, OpenSSLCertificate, MAY_BE_FALSE)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_free, 0, 1, _IS_BOOL, 1)
- ZEND_ARG_INFO(0, x509)
+ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_x509_free, 0, 1, IS_VOID, 0)
+ ZEND_ARG_OBJ_INFO(0, x509, OpenSSLCertificate, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs12_export_to_file, 0, 4, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, x509cert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509cert, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO(0, filename, IS_STRING, 0)
ZEND_ARG_INFO(0, priv_key)
ZEND_ARG_TYPE_INFO(0, pass, IS_STRING, 0)
- ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, args, IS_ARRAY, 0, "[]")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs12_export, 0, 4, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, x509)
+ ZEND_ARG_OBJ_TYPE_MASK(0, x509, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(1, out)
ZEND_ARG_INFO(0, priv_key)
ZEND_ARG_TYPE_INFO(0, pass, IS_STRING, 0)
- ZEND_ARG_TYPE_INFO(0, args, IS_ARRAY, 0)
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, args, IS_ARRAY, 0, "[]")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs12_read, 0, 3, _IS_BOOL, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_csr_export_to_file, 0, 2, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, csr)
+ ZEND_ARG_OBJ_TYPE_MASK(0, csr, OpenSSLCertificateSigningRequest, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO(0, outfilename, IS_STRING, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, notext, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_csr_export, 0, 2, _IS_BOOL, 0)
- ZEND_ARG_INFO(0, csr)
+ ZEND_ARG_OBJ_TYPE_MASK(0, csr, OpenSSLCertificateSigningRequest, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(1, out)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, notext, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_csr_sign, 0, 0, 4)
- ZEND_ARG_INFO(0, csr)
- ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, cacert, "null")
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_csr_sign, 0, 4, OpenSSLCertificate, MAY_BE_FALSE)
+ ZEND_ARG_OBJ_TYPE_MASK(0, csr, OpenSSLCertificateSigningRequest, MAY_BE_STRING, NULL)
+ ZEND_ARG_OBJ_TYPE_MASK(0, cacert, OpenSSLCertificate, MAY_BE_STRING|MAY_BE_NULL, NULL)
ZEND_ARG_INFO(0, priv_key)
ZEND_ARG_TYPE_INFO(0, days, IS_LONG, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, config_args, IS_ARRAY, 1, "null")
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, serial, IS_LONG, 0, "0")
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_csr_new, 0, 0, 2)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_csr_new, 0, 2, OpenSSLCertificateSigningRequest, MAY_BE_FALSE)
ZEND_ARG_TYPE_INFO(0, dn, IS_ARRAY, 0)
ZEND_ARG_INFO(1, privkey)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, configargs, IS_ARRAY, 1, "null")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_csr_get_subject, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
- ZEND_ARG_INFO(0, csr)
+ ZEND_ARG_OBJ_TYPE_MASK(0, csr, OpenSSLCertificateSigningRequest, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_shortnames, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_csr_get_public_key, 0, 0, 1)
- ZEND_ARG_INFO(0, csr)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_csr_get_public_key, 0, 1, OpenSSLAsymmetricKey, MAY_BE_FALSE)
+ ZEND_ARG_OBJ_TYPE_MASK(0, csr, OpenSSLCertificateSigningRequest, MAY_BE_STRING, NULL)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, use_shortnames, _IS_BOOL, 0, "true")
ZEND_END_ARG_INFO()
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_pkey_new, 0, 0, 0)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_pkey_new, 0, 0, OpenSSLAsymmetricKey, MAY_BE_FALSE)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, configargs, IS_ARRAY, 1, "null")
ZEND_END_ARG_INFO()
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, configargs, IS_ARRAY, 1, "null")
ZEND_END_ARG_INFO()
-#define arginfo_openssl_pkey_get_public arginfo_openssl_x509_read
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_pkey_get_public, 0, 1, OpenSSLAsymmetricKey, MAY_BE_FALSE)
+ ZEND_ARG_INFO(0, cert)
+ZEND_END_ARG_INFO()
-#define arginfo_openssl_get_publickey arginfo_openssl_x509_read
+#define arginfo_openssl_get_publickey arginfo_openssl_pkey_get_public
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkey_free, 0, 1, IS_VOID, 0)
- ZEND_ARG_INFO(0, key)
+ ZEND_ARG_OBJ_INFO(0, key, OpenSSLAsymmetricKey, 0)
ZEND_END_ARG_INFO()
#define arginfo_openssl_free_key arginfo_openssl_pkey_free
-ZEND_BEGIN_ARG_INFO_EX(arginfo_openssl_pkey_get_private, 0, 0, 1)
+ZEND_BEGIN_ARG_WITH_RETURN_OBJ_TYPE_MASK_EX(arginfo_openssl_pkey_get_private, 0, 1, OpenSSLAsymmetricKey, MAY_BE_FALSE)
ZEND_ARG_INFO(0, key)
ZEND_ARG_TYPE_INFO(0, passphrase, IS_STRING, 0)
ZEND_END_ARG_INFO()
#define arginfo_openssl_get_privatekey arginfo_openssl_pkey_get_private
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_pkey_get_details, 0, 1, MAY_BE_ARRAY|MAY_BE_FALSE)
- ZEND_ARG_INFO(0, key)
+ ZEND_ARG_OBJ_INFO(0, key, OpenSSLAsymmetricKey, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_pbkdf2, 0, 4, MAY_BE_STRING|MAY_BE_FALSE)
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs7_sign, 0, 5, _IS_BOOL, 0)
ZEND_ARG_TYPE_INFO(0, infile, IS_STRING, 0)
ZEND_ARG_TYPE_INFO(0, outfile, IS_STRING, 0)
- ZEND_ARG_INFO(0, signcert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, signcert, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(0, signkey)
ZEND_ARG_TYPE_INFO(0, headers, IS_ARRAY, 1)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "PKCS7_DETACHED")
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs7_decrypt, 0, 3, _IS_BOOL, 0)
ZEND_ARG_TYPE_INFO(0, infilename, IS_STRING, 0)
ZEND_ARG_TYPE_INFO(0, outfilename, IS_STRING, 0)
- ZEND_ARG_INFO(0, recipcert)
- ZEND_ARG_INFO(0, recipkey)
+ ZEND_ARG_OBJ_TYPE_MASK(0, recipcert, OpenSSLCertificate, MAY_BE_STRING, NULL)
+ ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, recipkey, "null")
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_pkcs7_read, 0, 2, _IS_BOOL, 0)
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_cms_sign, 0, 5, _IS_BOOL, 0)
ZEND_ARG_TYPE_INFO(0, infile, IS_STRING, 0)
ZEND_ARG_TYPE_INFO(0, outfile, IS_STRING, 0)
- ZEND_ARG_INFO(0, signcert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, signcert, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(0, signkey)
ZEND_ARG_TYPE_INFO(0, headers, IS_ARRAY, 1)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0")
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_cms_decrypt, 0, 4, _IS_BOOL, 0)
ZEND_ARG_TYPE_INFO(0, infilename, IS_STRING, 0)
ZEND_ARG_TYPE_INFO(0, outfilename, IS_STRING, 0)
- ZEND_ARG_INFO(0, recipcert)
+ ZEND_ARG_OBJ_TYPE_MASK(0, recipcert, OpenSSLCertificate, MAY_BE_STRING, NULL)
ZEND_ARG_INFO(0, recipkey)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, encoding, IS_LONG, 0, "OPENSSL_ENCODING_SMIME")
ZEND_END_ARG_INFO()
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_openssl_get_md_methods, 0, 0, IS_ARRAY, 0)
- ZEND_ARG_INFO_WITH_DEFAULT_VALUE(0, aliases, "false")
+ ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, aliases, _IS_BOOL, 0, "false")
ZEND_END_ARG_INFO()
#define arginfo_openssl_get_cipher_methods arginfo_openssl_get_md_methods
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_dh_compute_key, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
ZEND_ARG_TYPE_INFO(0, pub_key, IS_STRING, 0)
- ZEND_ARG_INFO(0, dh_key)
+ ZEND_ARG_OBJ_INFO(0, dh_key, OpenSSLAsymmetricKey, 0)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_pkey_derive, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
ZEND_END_ARG_INFO()
ZEND_BEGIN_ARG_WITH_RETURN_TYPE_MASK_EX(arginfo_openssl_spki_new, 0, 2, MAY_BE_STRING|MAY_BE_FALSE)
- ZEND_ARG_INFO(0, privkey)
+ ZEND_ARG_OBJ_INFO(0, privkey, OpenSSLAsymmetricKey, 0)
ZEND_ARG_TYPE_INFO(0, challenge, IS_STRING, 0)
ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, algo, IS_LONG, 0, "OPENSSL_ALGO_MD5")
ZEND_END_ARG_INFO()
ZEND_FE(openssl_x509_parse, arginfo_openssl_x509_parse)
ZEND_FE(openssl_x509_checkpurpose, arginfo_openssl_x509_checkpurpose)
ZEND_FE(openssl_x509_read, arginfo_openssl_x509_read)
- ZEND_FE(openssl_x509_free, arginfo_openssl_x509_free)
+ ZEND_DEP_FE(openssl_x509_free, arginfo_openssl_x509_free)
ZEND_FE(openssl_pkcs12_export_to_file, arginfo_openssl_pkcs12_export_to_file)
ZEND_FE(openssl_pkcs12_export, arginfo_openssl_pkcs12_export)
ZEND_FE(openssl_pkcs12_read, arginfo_openssl_pkcs12_read)
ZEND_FE(openssl_pkey_export, arginfo_openssl_pkey_export)
ZEND_FE(openssl_pkey_get_public, arginfo_openssl_pkey_get_public)
ZEND_FALIAS(openssl_get_publickey, openssl_pkey_get_public, arginfo_openssl_get_publickey)
- ZEND_FE(openssl_pkey_free, arginfo_openssl_pkey_free)
- ZEND_FALIAS(openssl_free_key, openssl_pkey_free, arginfo_openssl_free_key)
+ ZEND_DEP_FE(openssl_pkey_free, arginfo_openssl_pkey_free)
+ ZEND_DEP_FALIAS(openssl_free_key, openssl_pkey_free, arginfo_openssl_free_key)
ZEND_FE(openssl_pkey_get_private, arginfo_openssl_pkey_get_private)
ZEND_FALIAS(openssl_get_privatekey, openssl_pkey_get_private, arginfo_openssl_get_privatekey)
ZEND_FE(openssl_pkey_get_details, arginfo_openssl_pkey_get_details)
ZEND_FE(openssl_get_cert_locations, arginfo_openssl_get_cert_locations)
ZEND_FE_END
};
+
+
+static const zend_function_entry class_OpenSSLCertificate_methods[] = {
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_OpenSSLCertificateSigningRequest_methods[] = {
+ ZEND_FE_END
+};
+
+
+static const zend_function_entry class_OpenSSLAsymmetricKey_methods[] = {
+ ZEND_FE_END
+};
projects / php / commitdiff