#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] =
{
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; \
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;
}
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[])
{
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;
}
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[])
{
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;
}
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[])
{
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;
}
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[])
{
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;
}
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[])
{
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;
}
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[])
{
(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;