X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=crypto%2Fstore%2Fstr_lib.c;h=f1dbcbd0e0c729972db4da7cfa487b748a3d0d8b;hb=319d5c7a586a5695589494e16cb3dd5f82d753ca;hp=a8bd53132568ea76eb5c2d3a9bdc7e617754789a;hpb=b52d512dfa04ec44cb58ec1efa6a230a4693b0b0;p=oweals%2Fopenssl.git

diff --git a/crypto/store/str_lib.c b/crypto/store/str_lib.c
index a8bd531325..f1dbcbd0e0 100644
--- a/crypto/store/str_lib.c
+++ b/crypto/store/str_lib.c
@@ -59,7 +59,11 @@
 #include <string.h>
 #include <openssl/bn.h>
 #include <openssl/err.h>
+#ifndef OPENSSL_NO_ENGINE
 #include <openssl/engine.h>
+#endif
+#include <openssl/sha.h>
+#include <openssl/x509.h>
 #include "str_locl.h"
 
 const char * const STORE_object_type_string[STORE_OBJECT_TYPE_NUM+1] =
@@ -69,7 +73,8 @@ const char * const STORE_object_type_string[STORE_OBJECT_TYPE_NUM+1] =
 	"X.509 CRL",
 	"Private Key",
 	"Public Key",
-	"Number"
+	"Number",
+	"Arbitrary Data"
 	};
 
 const int STORE_param_sizes[STORE_PARAM_TYPE_NUM+1] =
@@ -101,19 +106,20 @@ STORE *STORE_new_method(const STORE_METHOD *method)
 	{
 	STORE *ret;
 
-	ret=(STORE *)OPENSSL_malloc(sizeof(STORE));
-	if (ret == NULL)
+	if (method == NULL)
 		{
-		STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_MALLOC_FAILURE);
+		STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_PASSED_NULL_PARAMETER);
 		return NULL;
 		}
-	if (method == NULL)
+
+	ret=(STORE *)OPENSSL_malloc(sizeof(STORE));
+	if (ret == NULL)
 		{
-		STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_PASSED_NULL_PARAMETER);
+		STOREerr(STORE_F_STORE_NEW_METHOD,ERR_R_MALLOC_FAILURE);
 		return NULL;
 		}
-	else
-		ret->meth=method;
+
+	ret->meth=method;
 
 	CRYPTO_new_ex_data(CRYPTO_EX_INDEX_STORE, ret, &ret->ex_data);
 	if (ret->meth->init && !ret->meth->init(ret))
@@ -182,6 +188,19 @@ void STORE_free(STORE *store)
 	OPENSSL_free(store);
 	}
 
+int STORE_ctrl(STORE *store, int cmd, long i, void *p, void (*f)(void))
+	{
+	if (store == NULL)
+		{
+		STOREerr(STORE_F_STORE_CTRL,ERR_R_PASSED_NULL_PARAMETER);
+		return 0;
+		}
+	if (store->meth->ctrl)
+		return store->meth->ctrl(store, cmd, i, p, f);
+	STOREerr(STORE_F_STORE_CTRL,STORE_R_NO_CONTROL_FUNCTION);
+	return 0;
+	}
+
 
 int STORE_get_ex_new_index(long argl, void *argp, CRYPTO_EX_new *new_func,
 	     CRYPTO_EX_dup *dup_func, CRYPTO_EX_free *free_func)
@@ -217,7 +236,7 @@ const STORE_METHOD *STORE_set_method(STORE *store, const STORE_METHOD *meth)
 #define check_store(s,fncode,fnname,fnerrcode) \
 	do \
 		{ \
-		if ((s) == NULL || (s)->meth) \
+		if ((s) == NULL || (s)->meth == NULL) \
 			{ \
 			STOREerr((fncode), ERR_R_PASSED_NULL_PARAMETER); \
 			return 0; \
@@ -261,15 +280,16 @@ X509 *STORE_get_certificate(STORE *s, OPENSSL_ITEM attributes[],
 int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
 	check_store(s,STORE_F_STORE_CERTIFICATE,
 		store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_CERTIFICATE,
+		STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -287,13 +307,31 @@ int STORE_store_certificate(STORE *s, X509 *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_CERTIFICATE,
+		STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
 			STORE_R_FAILED_STORING_CERTIFICATE);
 		return 0;
 		}
 	return 1;
 	}
 
+int STORE_modify_certificate(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_CERTIFICATE,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_CERTIFICATE,
+			STORE_R_FAILED_MODIFYING_CERTIFICATE);
+		return 0;
+		}
+	return 1;
+	}
+
 int STORE_revoke_certificate(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -452,22 +490,23 @@ EVP_PKEY *STORE_get_private_key(STORE *s, OPENSSL_ITEM attributes[],
 int STORE_store_private_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
-	check_store(s,STORE_F_STORE_PRIVATE_KEY,
+	check_store(s,STORE_F_STORE_STORE_PRIVATE_KEY,
 		store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_PRIVATE_KEY,
+		STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
 	object->data.key = EVP_PKEY_new();
 	if (!object->data.key)
 		{
-		STOREerr(STORE_F_STORE_PRIVATE_KEY,
+		STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -485,13 +524,31 @@ int STORE_store_private_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_PRIVATE_KEY,
+		STOREerr(STORE_F_STORE_STORE_PRIVATE_KEY,
 			STORE_R_FAILED_STORING_KEY);
 		return 0;
 		}
 	return i;
 	}
 
+int STORE_modify_private_key(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_PRIVATE_KEY,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_PRIVATE_KEY,
+			STORE_R_FAILED_MODIFYING_PRIVATE_KEY);
+		return 0;
+		}
+	return 1;
+	}
+
 int STORE_revoke_private_key(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -628,22 +685,23 @@ EVP_PKEY *STORE_get_public_key(STORE *s, OPENSSL_ITEM attributes[],
 int STORE_store_public_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
-	check_store(s,STORE_F_STORE_PUBLIC_KEY,
+	check_store(s,STORE_F_STORE_STORE_PUBLIC_KEY,
 		store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_PUBLIC_KEY,
+		STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
 	object->data.key = EVP_PKEY_new();
 	if (!object->data.key)
 		{
-		STOREerr(STORE_F_STORE_PUBLIC_KEY,
+		STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -661,13 +719,31 @@ int STORE_store_public_key(STORE *s, EVP_PKEY *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_PUBLIC_KEY,
+		STOREerr(STORE_F_STORE_STORE_PUBLIC_KEY,
 			STORE_R_FAILED_STORING_KEY);
 		return 0;
 		}
 	return i;
 	}
 
+int STORE_modify_public_key(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_PUBLIC_KEY,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_PUBLIC_KEY,
+			STORE_R_FAILED_MODIFYING_PUBLIC_KEY);
+		return 0;
+		}
+	return 1;
+	}
+
 int STORE_revoke_public_key(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -830,15 +906,16 @@ X509_CRL *STORE_get_crl(STORE *s, OPENSSL_ITEM attributes[],
 int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
-	check_store(s,STORE_F_STORE_CRL,
+	check_store(s,STORE_F_STORE_STORE_CRL,
 		store_object,STORE_R_NO_STORE_OBJECT_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_CRL,
+		STOREerr(STORE_F_STORE_STORE_CRL,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -856,13 +933,31 @@ int STORE_store_crl(STORE *s, X509_CRL *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_CRL,
+		STOREerr(STORE_F_STORE_STORE_CRL,
 			STORE_R_FAILED_STORING_KEY);
 		return 0;
 		}
 	return i;
 	}
 
+int STORE_modify_crl(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_CRL,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_X509_CRL,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_CRL,
+			STORE_R_FAILED_MODIFYING_CRL);
+		return 0;
+		}
+	return 1;
+	}
+
 int STORE_delete_crl(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -953,15 +1048,16 @@ int STORE_list_crl_endp(STORE *s, void *handle)
 int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
-	check_store(s,STORE_F_STORE_NUMBER,
+	check_store(s,STORE_F_STORE_STORE_NUMBER,
 		store_object,STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_NUMBER,
+		STOREerr(STORE_F_STORE_STORE_NUMBER,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -975,13 +1071,31 @@ int STORE_store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_NUMBER,
+		STOREerr(STORE_F_STORE_STORE_NUMBER,
 			STORE_R_FAILED_STORING_NUMBER);
 		return 0;
 		}
 	return 1;
 	}
 
+int STORE_modify_number(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_NUMBER,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_NUMBER,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_NUMBER,
+			STORE_R_FAILED_MODIFYING_NUMBER);
+		return 0;
+		}
+	return 1;
+	}
+
 BIGNUM *STORE_get_number(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -1024,15 +1138,16 @@ int STORE_delete_number(STORE *s, OPENSSL_ITEM attributes[],
 int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
-	STORE_OBJECT *object = STORE_OBJECT_new();
+	STORE_OBJECT *object;
 	int i;
 
-	check_store(s,STORE_F_STORE_ARBITRARY,
+	check_store(s,STORE_F_STORE_STORE_ARBITRARY,
 		store_object,STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION);
 
+	object = STORE_OBJECT_new();
 	if (!object)
 		{
-		STOREerr(STORE_F_STORE_ARBITRARY,
+		STOREerr(STORE_F_STORE_STORE_ARBITRARY,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -1046,13 +1161,31 @@ int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
 
 	if (!i)
 		{
-		STOREerr(STORE_F_STORE_ARBITRARY,
+		STOREerr(STORE_F_STORE_STORE_ARBITRARY,
 			STORE_R_FAILED_STORING_ARBITRARY);
 		return 0;
 		}
 	return 1;
 	}
 
+int STORE_modify_arbitrary(STORE *s, OPENSSL_ITEM search_attributes[],
+	OPENSSL_ITEM add_attributes[], OPENSSL_ITEM modify_attributes[],
+	OPENSSL_ITEM delete_attributes[], OPENSSL_ITEM parameters[])
+	{
+	check_store(s,STORE_F_STORE_MODIFY_ARBITRARY,
+		modify_object,STORE_R_NO_MODIFY_OBJECT_FUNCTION);
+
+	if (!s->meth->modify_object(s, STORE_OBJECT_TYPE_ARBITRARY,
+		    search_attributes, add_attributes, modify_attributes,
+		    delete_attributes, parameters))
+		{
+		STOREerr(STORE_F_STORE_MODIFY_ARBITRARY,
+			STORE_R_FAILED_MODIFYING_ARBITRARY);
+		return 0;
+		}
+	return 1;
+	}
+
 BUF_MEM *STORE_get_arbitrary(STORE *s, OPENSSL_ITEM attributes[],
 	OPENSSL_ITEM parameters[])
 	{
@@ -1283,7 +1416,7 @@ int STORE_ATTR_INFO_set_sha1str(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
 			    (unsigned char *)BUF_memdup(sha1str,
 				    sha1str_size)))
 			return 1;
-		STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+		STOREerr(STORE_F_STORE_ATTR_INFO_SET_SHA1STR,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -1303,7 +1436,7 @@ int STORE_ATTR_INFO_set_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
 		{
 		if ((attrs->values[code].dn = X509_NAME_dup(dn)))
 			return 1;
-		STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+		STOREerr(STORE_F_STORE_ATTR_INFO_SET_DN,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -1323,7 +1456,7 @@ int STORE_ATTR_INFO_set_number(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
 		{
 		if ((attrs->values[code].number = BN_dup(number)))
 			return 1;
-		STOREerr(STORE_F_STORE_ATTR_INFO_SET_CSTR,
+		STOREerr(STORE_F_STORE_ATTR_INFO_SET_NUMBER,
 			ERR_R_MALLOC_FAILURE);
 		return 0;
 		}
@@ -1412,11 +1545,11 @@ void *STORE_parse_attrs_start(OPENSSL_ITEM *attributes)
 		if (context)
 			context->attributes = attributes;
 		else
-			STOREerr(STORE_F_STORE_PARSE_ATTRS_END,
+			STOREerr(STORE_F_STORE_PARSE_ATTRS_START,
 				ERR_R_MALLOC_FAILURE);
 		return context;
 		}
-	STOREerr(STORE_F_STORE_PARSE_ATTRS_END, ERR_R_PASSED_NULL_PARAMETER);
+	STOREerr(STORE_F_STORE_PARSE_ATTRS_START, ERR_R_PASSED_NULL_PARAMETER);
 	return 0;
 	}
 STORE_ATTR_INFO *STORE_parse_attrs_next(void *handle)
@@ -1532,12 +1665,12 @@ int STORE_parse_attrs_endp(void *handle)
 		{
 		return context->attributes->code == STORE_ATTR_END;
 		}
-	STOREerr(STORE_F_STORE_PARSE_ATTRS_END, ERR_R_PASSED_NULL_PARAMETER);
+	STOREerr(STORE_F_STORE_PARSE_ATTRS_ENDP, ERR_R_PASSED_NULL_PARAMETER);
 	return 0;
 	}
 
 static int attr_info_compare_compute_range(
-	unsigned char *abits, unsigned char *bbits,
+	const unsigned char *abits, const unsigned char *bbits,
 	unsigned int *alowp, unsigned int *ahighp,
 	unsigned int *blowp, unsigned int *bhighp)
 	{
@@ -1606,13 +1739,15 @@ static int attr_info_compare_compute_range(
 	return res;
 	}
 
-int STORE_ATTR_INFO_compare(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
+int STORE_ATTR_INFO_compare(const STORE_ATTR_INFO * const *a,
+			    const STORE_ATTR_INFO * const *b)
 	{
 	if (a == b) return 0;
 	if (!a) return -1;
 	if (!b) return 1;
-	return attr_info_compare_compute_range(a->set, b->set, 0, 0, 0, 0);
+	return attr_info_compare_compute_range((*a)->set, (*b)->set, 0, 0, 0, 0);
 	}
+
 int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
 	{
 	unsigned int alow, ahigh, blow, bhigh;
@@ -1626,6 +1761,7 @@ int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
 		return 1;
 	return 0;
 	}
+
 int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
 	{
 	unsigned char *abits, *bbits;
@@ -1643,6 +1779,7 @@ int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
 		}
 	return 1;
 	}
+
 int STORE_ATTR_INFO_in_ex(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
 	{
 	STORE_ATTR_TYPES i;