#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] =
"X.509 CRL",
"Private Key",
"Public Key",
- "Number"
+ "Number",
+ "Arbitrary Data"
};
const int STORE_param_sizes[STORE_PARAM_TYPE_NUM+1] =
const int STORE_attr_sizes[STORE_ATTR_TYPE_NUM+1] =
{
0,
- -1, /* FRIENDLYNAME: C string */
+ -1, /* FRIENDLYNAME: C string */
SHA_DIGEST_LENGTH, /* KEYID: SHA1 digest, 160 bits */
SHA_DIGEST_LENGTH, /* ISSUERKEYID: SHA1 digest, 160 bits */
- SHA_DIGEST_LENGTH, /* SUBJECTKEYID: SHA1 digest, 160 bits */
+ SHA_DIGEST_LENGTH, /* SUBJECTKEYID: SHA1 digest, 160 bits */
SHA_DIGEST_LENGTH, /* ISSUERSERIALHASH: SHA1 digest, 160 bits */
sizeof(X509_NAME *), /* ISSUER: X509_NAME * */
sizeof(BIGNUM *), /* SERIAL: BIGNUM * */
{
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))
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)
#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; \
/* API functions */
-X509 *STORE_get_certificate(STORE *s, OPENSSL_ITEM attributes[])
+X509 *STORE_get_certificate(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
X509 *x;
check_store(s,STORE_F_STORE_GET_CERTIFICATE,
get_object,STORE_R_NO_GET_OBJECT_FUNCTION);
- object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes);
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+ attributes, parameters);
if (!object || !object->data.x509.certificate)
{
STOREerr(STORE_F_STORE_GET_CERTIFICATE,
return x;
}
-int store_certificate(STORE *s, X509 *data, 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;
}
#endif
object->data.x509.certificate = data;
- i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, object, attributes);
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+ object, attributes, parameters);
STORE_OBJECT_free(object);
if (!i)
{
- STOREerr(STORE_F_STORE_CERTIFICATE,
+ STOREerr(STORE_F_STORE_STORE_CERTIFICATE,
STORE_R_FAILED_STORING_CERTIFICATE);
return 0;
}
return 1;
}
-int STORE_revoke_certificate(STORE *s, OPENSSL_ITEM attributes[])
+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[])
{
check_store(s,STORE_F_STORE_REVOKE_CERTIFICATE,
revoke_object,STORE_R_NO_REVOKE_OBJECT_FUNCTION);
- if (!s->meth->revoke_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes))
+ if (!s->meth->revoke_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+ attributes, parameters))
{
STOREerr(STORE_F_STORE_REVOKE_CERTIFICATE,
STORE_R_FAILED_REVOKING_CERTIFICATE);
return 1;
}
-int STORE_delete_certificate(STORE *s, OPENSSL_ITEM attributes[])
+int STORE_delete_certificate(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
check_store(s,STORE_F_STORE_DELETE_CERTIFICATE,
delete_object,STORE_R_NO_DELETE_OBJECT_FUNCTION);
- if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes))
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_X509_CERTIFICATE,
+ attributes, parameters))
{
STOREerr(STORE_F_STORE_DELETE_CERTIFICATE,
STORE_R_FAILED_DELETING_CERTIFICATE);
return 1;
}
-void *STORE_list_certificate_start(STORE *s, OPENSSL_ITEM attributes[])
+void *STORE_list_certificate_start(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
void *handle;
check_store(s,STORE_F_STORE_LIST_CERTIFICATE_START,
list_object_start,STORE_R_NO_LIST_OBJECT_START_FUNCTION);
- handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes);
+ handle = s->meth->list_object_start(s,
+ STORE_OBJECT_TYPE_X509_CERTIFICATE, attributes, parameters);
if (!handle)
{
STOREerr(STORE_F_STORE_LIST_CERTIFICATE_START,
return 1;
}
-EVP_PKEY *STORE_generate_key(STORE *s,
- int evp_type, size_t bits, OPENSSL_ITEM attributes[])
+EVP_PKEY *STORE_generate_key(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
EVP_PKEY *pkey;
- OPENSSL_ITEM params[3];
-
- params[0].code = STORE_PARAM_EVP_TYPE;
- params[0].value = &evp_type;
- params[0].value_size = sizeof(evp_type);
- params[1].code = STORE_PARAM_BITS;
- params[1].value = &bits;
- params[1].value_size = sizeof(bits);
- params[2].code = 0;
check_store(s,STORE_F_STORE_GENERATE_KEY,
generate_object,STORE_R_NO_GENERATE_OBJECT_FUNCTION);
object = s->meth->generate_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
- params, attributes);
+ attributes, parameters);
if (!object || !object->data.key)
{
STOREerr(STORE_F_STORE_GENERATE_KEY,
return pkey;
}
-EVP_PKEY *STORE_get_private_key(STORE *s, OPENSSL_ITEM attributes[])
+EVP_PKEY *STORE_get_private_key(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
EVP_PKEY *pkey;
check_store(s,STORE_F_STORE_GET_PRIVATE_KEY,
get_object,STORE_R_NO_GET_OBJECT_FUNCTION);
- object = s->meth->get_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, attributes);
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+ attributes, parameters);
if (!object || !object->data.key || !object->data.key)
{
STOREerr(STORE_F_STORE_GET_PRIVATE_KEY,
return pkey;
}
-int store_private_key(STORE *s, EVP_PKEY *data, 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;
}
#endif
object->data.key = data;
- i = s->meth->store_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, object, attributes);
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, object,
+ attributes, parameters);
STORE_OBJECT_free(object);
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_revoke_private_key(STORE *s, OPENSSL_ITEM attributes[])
+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[])
{
int i;
check_store(s,STORE_F_STORE_REVOKE_PRIVATE_KEY,
revoke_object,STORE_R_NO_REVOKE_OBJECT_FUNCTION);
- i = s->meth->revoke_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, attributes);
+ i = s->meth->revoke_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+ attributes, parameters);
if (!i)
{
return i;
}
-int STORE_delete_private_key(STORE *s, OPENSSL_ITEM attributes[])
+int STORE_delete_private_key(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
check_store(s,STORE_F_STORE_DELETE_PRIVATE_KEY,
delete_object,STORE_R_NO_DELETE_OBJECT_FUNCTION);
- if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY, attributes))
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+ attributes, parameters))
{
STOREerr(STORE_F_STORE_DELETE_PRIVATE_KEY,
STORE_R_FAILED_DELETING_KEY);
return 1;
}
-void *STORE_list_private_key_start(STORE *s, OPENSSL_ITEM attributes[])
+void *STORE_list_private_key_start(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
void *handle;
check_store(s,STORE_F_STORE_LIST_PRIVATE_KEY_START,
list_object_start,STORE_R_NO_LIST_OBJECT_START_FUNCTION);
- handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_PRIVATE_KEY, attributes);
+ handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_PRIVATE_KEY,
+ attributes, parameters);
if (!handle)
{
STOREerr(STORE_F_STORE_LIST_PRIVATE_KEY_START,
return 1;
}
-EVP_PKEY *STORE_get_public_key(STORE *s, OPENSSL_ITEM attributes[])
+EVP_PKEY *STORE_get_public_key(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
EVP_PKEY *pkey;
check_store(s,STORE_F_STORE_GET_PUBLIC_KEY,
get_object,STORE_R_NO_GET_OBJECT_FUNCTION);
- object = s->meth->get_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes);
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+ attributes, parameters);
if (!object || !object->data.key || !object->data.key)
{
STOREerr(STORE_F_STORE_GET_PUBLIC_KEY,
return pkey;
}
-int store_public_key(STORE *s, EVP_PKEY *data, 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;
}
#endif
object->data.key = data;
- i = s->meth->store_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, object, attributes);
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, object,
+ attributes, parameters);
STORE_OBJECT_free(object);
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_revoke_public_key(STORE *s, OPENSSL_ITEM attributes[])
+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[])
{
int i;
check_store(s,STORE_F_STORE_REVOKE_PUBLIC_KEY,
revoke_object,STORE_R_NO_REVOKE_OBJECT_FUNCTION);
- i = s->meth->revoke_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes);
+ i = s->meth->revoke_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+ attributes, parameters);
if (!i)
{
return i;
}
-int STORE_delete_public_key(STORE *s, OPENSSL_ITEM attributes[])
+int STORE_delete_public_key(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
check_store(s,STORE_F_STORE_DELETE_PUBLIC_KEY,
delete_object,STORE_R_NO_DELETE_OBJECT_FUNCTION);
- if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes))
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+ attributes, parameters))
{
STOREerr(STORE_F_STORE_DELETE_PUBLIC_KEY,
STORE_R_FAILED_DELETING_KEY);
return 1;
}
-void *STORE_list_public_key_start(STORE *s, OPENSSL_ITEM attributes[])
+void *STORE_list_public_key_start(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
void *handle;
check_store(s,STORE_F_STORE_LIST_PUBLIC_KEY_START,
list_object_start,STORE_R_NO_LIST_OBJECT_START_FUNCTION);
- handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_PUBLIC_KEY, attributes);
+ handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_PUBLIC_KEY,
+ attributes, parameters);
if (!handle)
{
STOREerr(STORE_F_STORE_LIST_PUBLIC_KEY_START,
return 1;
}
-X509_CRL *STORE_generate_crl(STORE *s, OPENSSL_ITEM attributes[])
+X509_CRL *STORE_generate_crl(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
X509_CRL *crl;
check_store(s,STORE_F_STORE_GENERATE_CRL,
generate_object,STORE_R_NO_GENERATE_CRL_FUNCTION);
- object = s->meth->generate_object(s, STORE_OBJECT_TYPE_X509_CRL, 0, attributes);
+ object = s->meth->generate_object(s, STORE_OBJECT_TYPE_X509_CRL,
+ attributes, parameters);
if (!object || !object->data.crl)
{
STOREerr(STORE_F_STORE_GENERATE_CRL,
return crl;
}
-X509_CRL *STORE_get_crl(STORE *s, OPENSSL_ITEM attributes[])
+X509_CRL *STORE_get_crl(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
STORE_OBJECT *object;
X509_CRL *crl;
check_store(s,STORE_F_STORE_GET_CRL,
get_object,STORE_R_NO_GET_OBJECT_FUNCTION);
- object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CRL, attributes);
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_X509_CRL,
+ attributes, parameters);
if (!object || !object->data.crl)
{
STOREerr(STORE_F_STORE_GET_CRL,
return crl;
}
-int store_crl(STORE *s, X509_CRL *data, 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;
}
#endif
object->data.crl = data;
- i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CRL, object, attributes);
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_X509_CRL, object,
+ attributes, parameters);
STORE_OBJECT_free(object);
if (!i)
{
- STOREerr(STORE_F_STORE_CRL,
+ STOREerr(STORE_F_STORE_STORE_CRL,
STORE_R_FAILED_STORING_KEY);
return 0;
}
return i;
}
-int STORE_delete_crl(STORE *s, OPENSSL_ITEM attributes[])
+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[])
{
check_store(s,STORE_F_STORE_DELETE_CRL,
delete_object,STORE_R_NO_DELETE_OBJECT_FUNCTION);
- if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_X509_CRL, attributes))
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_X509_CRL,
+ attributes, parameters))
{
STOREerr(STORE_F_STORE_DELETE_CRL,
STORE_R_FAILED_DELETING_KEY);
return 1;
}
-void *STORE_list_crl_start(STORE *s, OPENSSL_ITEM attributes[])
+void *STORE_list_crl_start(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
void *handle;
check_store(s,STORE_F_STORE_LIST_CRL_START,
list_object_start,STORE_R_NO_LIST_OBJECT_START_FUNCTION);
- handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_X509_CRL, attributes);
+ handle = s->meth->list_object_start(s, STORE_OBJECT_TYPE_X509_CRL,
+ attributes, parameters);
if (!handle)
{
STOREerr(STORE_F_STORE_LIST_CRL_START,
return 1;
}
-int store_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[])
+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;
}
object->data.number = data;
- i = s->meth->store_object(s, STORE_OBJECT_TYPE_NUMBER, object, attributes);
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_NUMBER, object,
+ attributes, parameters);
STORE_OBJECT_free(object);
if (!i)
{
- STOREerr(STORE_F_STORE_NUMBER,
+ STOREerr(STORE_F_STORE_STORE_NUMBER,
STORE_R_FAILED_STORING_NUMBER);
return 0;
}
return 1;
}
-BIGNUM *STORE_get_number(STORE *s, OPENSSL_ITEM attributes[])
+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[])
{
STORE_OBJECT *object;
BIGNUM *n;
check_store(s,STORE_F_STORE_GET_NUMBER,
get_object,STORE_R_NO_GET_OBJECT_NUMBER_FUNCTION);
- object = s->meth->get_object(s, STORE_OBJECT_TYPE_NUMBER, attributes);
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_NUMBER, attributes,
+ parameters);
if (!object || !object->data.number)
{
STOREerr(STORE_F_STORE_GET_NUMBER,
return n;
}
-int STORE_delete_number(STORE *s, BIGNUM *data, OPENSSL_ITEM attributes[])
+int STORE_delete_number(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
{
check_store(s,STORE_F_STORE_DELETE_NUMBER,
delete_object,STORE_R_NO_DELETE_NUMBER_FUNCTION);
- if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_NUMBER, attributes))
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_NUMBER, attributes,
+ parameters))
{
STOREerr(STORE_F_STORE_DELETE_NUMBER,
STORE_R_FAILED_DELETING_NUMBER);
return 1;
}
+int STORE_store_arbitrary(STORE *s, BUF_MEM *data, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
+ {
+ STORE_OBJECT *object;
+ int i;
+
+ 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_STORE_ARBITRARY,
+ ERR_R_MALLOC_FAILURE);
+ return 0;
+ }
+
+ object->data.arbitrary = data;
+
+ i = s->meth->store_object(s, STORE_OBJECT_TYPE_ARBITRARY, object,
+ attributes, parameters);
+
+ STORE_OBJECT_free(object);
+
+ if (!i)
+ {
+ 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[])
+ {
+ STORE_OBJECT *object;
+ BUF_MEM *b;
+
+ check_store(s,STORE_F_STORE_GET_ARBITRARY,
+ get_object,STORE_R_NO_GET_OBJECT_ARBITRARY_FUNCTION);
+
+ object = s->meth->get_object(s, STORE_OBJECT_TYPE_ARBITRARY,
+ attributes, parameters);
+ if (!object || !object->data.arbitrary)
+ {
+ STOREerr(STORE_F_STORE_GET_ARBITRARY,
+ STORE_R_FAILED_GETTING_ARBITRARY);
+ return 0;
+ }
+ b = object->data.arbitrary;
+ object->data.arbitrary = NULL;
+ STORE_OBJECT_free(object);
+ return b;
+ }
+
+int STORE_delete_arbitrary(STORE *s, OPENSSL_ITEM attributes[],
+ OPENSSL_ITEM parameters[])
+ {
+ check_store(s,STORE_F_STORE_DELETE_ARBITRARY,
+ delete_object,STORE_R_NO_DELETE_ARBITRARY_FUNCTION);
+
+ if (!s->meth->delete_object(s, STORE_OBJECT_TYPE_ARBITRARY, attributes,
+ parameters))
+ {
+ STOREerr(STORE_F_STORE_DELETE_ARBITRARY,
+ STORE_R_FAILED_DELETING_ARBITRARY);
+ return 0;
+ }
+ return 1;
+ }
+
STORE_OBJECT *STORE_OBJECT_new(void)
{
STORE_OBJECT *object = OPENSSL_malloc(sizeof(STORE_OBJECT));
case STORE_OBJECT_TYPE_NUMBER:
BN_free(data->data.number);
break;
+ case STORE_OBJECT_TYPE_ARBITRARY:
+ BUF_MEM_free(data->data.arbitrary);
+ break;
}
OPENSSL_free(data);
}
-IMPLEMENT_STACK_OF(STORE_OBJECT*);
+IMPLEMENT_STACK_OF(STORE_OBJECT*)
struct STORE_attr_info_st
(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;
}
{
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;
}
{
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;
}
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)
{
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;
}
-int STORE_ATTR_INFO_compare(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
+static int attr_info_compare_compute_range(
+ const unsigned char *abits, const unsigned char *bbits,
+ unsigned int *alowp, unsigned int *ahighp,
+ unsigned int *blowp, unsigned int *bhighp)
{
- unsigned char *abits, *bbits;
- int i;
+ unsigned int alow = (unsigned int)-1, ahigh = 0;
+ unsigned int blow = (unsigned int)-1, bhigh = 0;
+ int i, res = 0;
- if (a == b) return 0;
- if (!a) return -1;
- if (!b) return 1;
- abits = a->set;
- bbits = b->set;
for (i = 0; i < (STORE_ATTR_TYPE_NUM + 8) / 8; i++, abits++, bbits++)
{
- if (*abits < *bbits) return -1;
- if (*abits > *bbits) return 1;
+ if (res == 0)
+ {
+ if (*abits < *bbits) res = -1;
+ if (*abits > *bbits) res = 1;
+ }
+ if (*abits)
+ {
+ if (alow == (unsigned int)-1)
+ {
+ alow = i * 8;
+ if (!(*abits & 0x01)) alow++;
+ if (!(*abits & 0x02)) alow++;
+ if (!(*abits & 0x04)) alow++;
+ if (!(*abits & 0x08)) alow++;
+ if (!(*abits & 0x10)) alow++;
+ if (!(*abits & 0x20)) alow++;
+ if (!(*abits & 0x40)) alow++;
+ }
+ ahigh = i * 8 + 7;
+ if (!(*abits & 0x80)) ahigh++;
+ if (!(*abits & 0x40)) ahigh++;
+ if (!(*abits & 0x20)) ahigh++;
+ if (!(*abits & 0x10)) ahigh++;
+ if (!(*abits & 0x08)) ahigh++;
+ if (!(*abits & 0x04)) ahigh++;
+ if (!(*abits & 0x02)) ahigh++;
+ }
+ if (*bbits)
+ {
+ if (blow == (unsigned int)-1)
+ {
+ blow = i * 8;
+ if (!(*bbits & 0x01)) blow++;
+ if (!(*bbits & 0x02)) blow++;
+ if (!(*bbits & 0x04)) blow++;
+ if (!(*bbits & 0x08)) blow++;
+ if (!(*bbits & 0x10)) blow++;
+ if (!(*bbits & 0x20)) blow++;
+ if (!(*bbits & 0x40)) blow++;
+ }
+ bhigh = i * 8 + 7;
+ if (!(*bbits & 0x80)) bhigh++;
+ if (!(*bbits & 0x40)) bhigh++;
+ if (!(*bbits & 0x20)) bhigh++;
+ if (!(*bbits & 0x10)) bhigh++;
+ if (!(*bbits & 0x08)) bhigh++;
+ if (!(*bbits & 0x04)) bhigh++;
+ if (!(*bbits & 0x02)) bhigh++;
+ }
}
+ if (ahigh + alow < bhigh + blow) res = -1;
+ if (ahigh + alow > bhigh + blow) res = 1;
+ if (alowp) *alowp = alow;
+ if (ahighp) *ahighp = ahigh;
+ if (blowp) *blowp = blow;
+ if (bhighp) *bhighp = bhigh;
+ return res;
+ }
+
+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);
+ }
+
+int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
+ {
+ unsigned int alow, ahigh, blow, bhigh;
+
+ if (a == b) return 1;
+ if (!a) return 0;
+ if (!b) return 0;
+ attr_info_compare_compute_range(a->set, b->set,
+ &alow, &ahigh, &blow, &bhigh);
+ if (alow >= blow && ahigh <= bhigh)
+ return 1;
return 0;
}
+
int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
{
unsigned char *abits, *bbits;
bbits = b->set;
for (i = 0; i < (STORE_ATTR_TYPE_NUM + 8) / 8; i++, abits++, bbits++)
{
- if (*abits && *bbits != *abits)
+ if (*abits && (*bbits & *abits) != *abits)
return 0;
}
return 1;
}
+
int STORE_ATTR_INFO_in_ex(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b)
{
STORE_ATTR_TYPES i;
projects / oweals / openssl.git / blobdiff