generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Remove store.

Browse Source 
Rebased and merged by me, with Ben's approval.

Reviewed-by: Richard Levitte <levitte@openssl.org>
Reviewed-by: Ben Laurie <ben@openssl.org>
This commit is contained in:
Rich Salz
2016-02-10 07:52:49 -05:00
committed by Rich Salz
parent deca5df2fb
commit 7984f082d5
20 changed files with 12 additions and 3746 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Configure
View File

@@ -212,7 +212,7 @@ $config{sdirs} = [
"bn", "ec", "rsa", "dsa", "dh", "dso", "engine", "bn", "ec", "rsa", "dsa", "dh", "dso", "engine",
"buffer", "bio", "stack", "lhash", "rand", "err", "buffer", "bio", "stack", "lhash", "rand", "err",
"evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui", "evp", "asn1", "pem", "x509", "x509v3", "conf", "txt_db", "pkcs7", "pkcs12", "comp", "ocsp", "ui",
"cms", "ts", "jpake", "srp", "store", "cmac", "ct", "async", "kdf" "cms", "ts", "jpake", "srp", "cmac", "ct", "async", "kdf"
]; ];
# Known TLS and DTLS protocols # Known TLS and DTLS protocols
@@ -294,7 +294,6 @@ my @disablables = (
"ssl-trace", "ssl-trace",
"static-engine", "static-engine",
"stdio", "stdio",
"store",
"threads", "threads",
"tls", "tls",
"unit-test", "unit-test",
@@ -319,7 +318,6 @@ my %disabled = ( # "what" => "comment" [or special keyword "experimental
"sctp" => "default", "sctp" => "default",
"shared" => "default", "shared" => "default",
"ssl-trace" => "default", "ssl-trace" => "default",
"store" => "experimental",
"unit-test" => "default", "unit-test" => "default",
"zlib" => "default", "zlib" => "default",
"zlib-dynamic" => "default", "zlib-dynamic" => "default",

2
Makefile.in
View File

@@ -411,7 +411,7 @@ rehash.time: certs build_apps build_tools
touch rehash.time; \ touch rehash.time; \
else :; fi else :; fi
test: tests test: files tests
tests: rehash tests: rehash

4
crypto/engine/Makefile.in
View File

@@ -17,13 +17,13 @@ GENERAL=Makefile
LIB=$(TOP)/libcrypto.a LIB=$(TOP)/libcrypto.a
LIBSRC= eng_err.c eng_lib.c eng_list.c eng_init.c eng_ctrl.c \ LIBSRC= eng_err.c eng_lib.c eng_list.c eng_init.c eng_ctrl.c \
eng_table.c eng_pkey.c eng_fat.c eng_all.c \ eng_table.c eng_pkey.c eng_fat.c eng_all.c \
tb_rsa.c tb_dsa.c tb_dh.c tb_rand.c tb_store.c \ tb_rsa.c tb_dsa.c tb_dh.c tb_rand.c \
tb_cipher.c tb_digest.c tb_pkmeth.c tb_asnmth.c tb_eckey.c \ tb_cipher.c tb_digest.c tb_pkmeth.c tb_asnmth.c tb_eckey.c \
eng_openssl.c eng_cnf.c eng_dyn.c eng_cryptodev.c \ eng_openssl.c eng_cnf.c eng_dyn.c eng_cryptodev.c \
eng_rdrand.c eng_rdrand.c
LIBOBJ= eng_err.o eng_lib.o eng_list.o eng_init.o eng_ctrl.o \ LIBOBJ= eng_err.o eng_lib.o eng_list.o eng_init.o eng_ctrl.o \
eng_table.o eng_pkey.o eng_fat.o eng_all.o \ eng_table.o eng_pkey.o eng_fat.o eng_all.o \
tb_rsa.o tb_dsa.o tb_dh.o tb_rand.o tb_store.o \ tb_rsa.o tb_dsa.o tb_dh.o tb_rand.o \
tb_cipher.o tb_digest.o tb_pkmeth.o tb_asnmth.o tb_eckey.o \ tb_cipher.o tb_digest.o tb_pkmeth.o tb_asnmth.o tb_eckey.o \
eng_openssl.o eng_cnf.o eng_dyn.o eng_cryptodev.o \ eng_openssl.o eng_cnf.o eng_dyn.o eng_cryptodev.o \
eng_rdrand.o eng_rdrand.o

1
crypto/engine/eng_int.h
View File

@@ -179,7 +179,6 @@ struct engine_st {
const DH_METHOD *dh_meth; const DH_METHOD *dh_meth;
const EC_KEY_METHOD *ec_meth; const EC_KEY_METHOD *ec_meth;
const RAND_METHOD *rand_meth; const RAND_METHOD *rand_meth;
const STORE_METHOD *store_meth;
/* Cipher handling is via this callback */ /* Cipher handling is via this callback */
ENGINE_CIPHERS_PTR ciphers; ENGINE_CIPHERS_PTR ciphers;
/* Digest handling is via this callback */ /* Digest handling is via this callback */

1
crypto/engine/eng_lib.c
View File

@@ -89,7 +89,6 @@ void engine_set_all_null(ENGINE *e)
e->dsa_meth = NULL; e->dsa_meth = NULL;
e->dh_meth = NULL; e->dh_meth = NULL;
e->rand_meth = NULL; e->rand_meth = NULL;
e->store_meth = NULL;
e->ciphers = NULL; e->ciphers = NULL;
e->digests = NULL; e->digests = NULL;
e->destroy = NULL; e->destroy = NULL;

1
crypto/engine/eng_list.c
View File

@@ -304,7 +304,6 @@ static void engine_cpy(ENGINE *dest, const ENGINE *src)
dest->ec_meth = src->ec_meth; dest->ec_meth = src->ec_meth;
#endif #endif
dest->rand_meth = src->rand_meth; dest->rand_meth = src->rand_meth;
dest->store_meth = src->store_meth;
dest->ciphers = src->ciphers; dest->ciphers = src->ciphers;
dest->digests = src->digests; dest->digests = src->digests;
dest->pkey_meths = src->pkey_meths; dest->pkey_meths = src->pkey_meths;

105
crypto/engine/tb_store.c
View File

@@ -1,105 +0,0 @@
/* ====================================================================
* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* licensing@OpenSSL.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
#include "eng_int.h"
/*
* If this symbol is defined then ENGINE_get_default_STORE(), the function
* that is used by STORE to hook in implementation code and cache defaults
* (etc), will display brief debugging summaries to stderr with the 'nid'.
*/
/* #define ENGINE_STORE_DEBUG */
static ENGINE_TABLE *store_table = NULL;
static const int dummy_nid = 1;
void ENGINE_unregister_STORE(ENGINE *e)
{
engine_table_unregister(&store_table, e);
}
static void engine_unregister_all_STORE(void)
{
engine_table_cleanup(&store_table);
}
int ENGINE_register_STORE(ENGINE *e)
{
if (e->store_meth)
return engine_table_register(&store_table,
engine_unregister_all_STORE, e,
&dummy_nid, 1, 0);
return 1;
}
void ENGINE_register_all_STORE()
{
ENGINE *e;
for (e = ENGINE_get_first(); e; e = ENGINE_get_next(e))
ENGINE_register_STORE(e);
}
/* Obtains an STORE implementation from an ENGINE functional reference */
const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e)
{
return e->store_meth;
}
/* Sets an STORE implementation in an ENGINE structure */
int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth)
{
e->store_meth = store_meth;
return 1;
}

46
crypto/store/Makefile.in
View File

@@ -1,46 +0,0 @@
#
# OpenSSL/crypto/store/Makefile
#
DIR= store
TOP= ../..
CC= cc
INCLUDES= -I.. -I$(TOP) -I../../include
CFLAG=-g
MAKEFILE= Makefile
AR= ar r
CFLAGS= $(INCLUDES) $(CFLAG)
GENERAL=Makefile
LIB=$(TOP)/libcrypto.a
LIBSRC= str_err.c str_lib.c str_meth.c str_mem.c
LIBOBJ= str_err.o str_lib.o str_meth.o str_mem.o
SRC= $(LIBSRC)
HEADER= str_locl.h
ALL= $(GENERAL) $(SRC) $(HEADER)
top:
(cd ../..; $(MAKE) DIRS=crypto SDIRS=$(DIR) sub_all)
all: lib
lib: $(LIBOBJ)
$(AR) $(LIB) $(LIBOBJ)
$(RANLIB) $(LIB) || echo Never mind.
@touch lib
files:
$(PERL) $(TOP)/util/files.pl Makefile >> $(TOP)/MINFO
depend:
$(TOP)/util/domd $(CFLAG) $(INCLUDES) $(DEPFLAG) -- $(PROGS) $(LIBSRC)
clean:
rm -f *.o */*.o *.obj lib tags core .pure .nfs* *.old *.bak fluff
# DO NOT DELETE THIS LINE -- make depend depends on it.

101
crypto/store/README
View File

@@ -1,101 +0,0 @@
NOTE:
This is a planned replacement for X509_STORE.
It is incomplete, has compile errors, and is
not built as part of the standard configuration.
The STORE type
==============
A STORE, as defined in this code section, is really a rather simple
thing which stores objects and per-object associations to a number
of attributes. What attributes are supported entirely depends on
the particular implementation of a STORE. It has some support for
generation of certain objects (for example, keys and CRLs).
Supported object types
----------------------
For now, the objects that are supported are the following:
X.509 certificate
X.509 CRL
private key
public key
number
arbitrary (application) data
The intention is that a STORE should be able to store everything
needed by an application that wants a cert/key store, as well as
the data a CA might need to store (this includes the serial number
counter, which explains the support for numbers).
Supported attribute types
-------------------------
For now, the following attributes are supported:
Friendly Name - the value is a normal C string
Key ID - the value is a 160 bit SHA1 hash
Issuer Key ID - the value is a 160 bit SHA1 hash
Subject Key ID - the value is a 160 bit SHA1 hash
Issuer/Serial Hash - the value is a 160 bit SHA1 hash
Issuer - the value is a X509_NAME
Serial - the value is a BIGNUM
Subject - the value is a X509_NAME
Certificate Hash - the value is a 160 bit SHA1 hash
Email - the value is a normal C string
Filename - the value is a normal C string
It is expected that these attributes should be enough to support
the need from most, if not all, current applications. Applications
that need to do certificate verification would typically use Subject
Key ID, Issuer/Serial Hash or Subject to look up issuer certificates.
S/MIME applications would typically use Email to look up recipient
and signer certificates.
There's added support for combined sets of attributes to search for,
with the special OR attribute.
Supported basic functionality
-----------------------------
The functions that are supported through the STORE type are these:
generate_object - for example to generate keys and CRLs
get_object - to look up one object
NOTE: this function is really rather
redundant and probably of lesser usage
than the list functions
store_object - store an object and the attributes
associated with it
modify_object - modify the attributes associated with
a specific object
revoke_object - revoke an object
NOTE: this only marks an object as
invalid, it doesn't remove the object
from the database
delete_object - remove an object from the database
list_object - list objects associated with a given
set of attributes
NOTE: this is really four functions:
list_start, list_next, list_end and
list_endp
update_store - update the internal data of the store
lock_store - lock the store
unlock_store - unlock the store
The list functions need some extra explanation: list_start is
used to set up a lookup. That's where the attributes to use in
the search are set up. It returns a search context. list_next
returns the next object searched for. list_end closes the search.
list_endp is used to check if we have reached the end.
A few words on the store functions as well: update_store is
typically used by a CA application to update the internal
structure of a database. This may for example involve automatic
removal of expired certificates. lock_store and unlock_store
are used for locking a store to allow exclusive writes.

2
crypto/store/build.info
View File

@@ -1,2 +0,0 @@
LIBS=../../libcrypto
SOURCE[../../libcrypto]=str_err.c str_lib.c str_meth.c str_mem.c

257
crypto/store/str_err.c
View File

@@ -1,257 +0,0 @@
/* ====================================================================
* Copyright (c) 1999-2015 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@OpenSSL.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
/*
* NOTE: this file was auto generated by the mkerr.pl script: any changes
* made to it will be overwritten when the script next updates this file,
* only reason strings will be preserved.
*/
#include <stdio.h>
#include <openssl/err.h>
#include <openssl/store.h>
/* BEGIN ERROR CODES */
#ifndef OPENSSL_NO_ERR
# define ERR_FUNC(func) ERR_PACK(ERR_LIB_STORE,func,0)
# define ERR_REASON(reason) ERR_PACK(ERR_LIB_STORE,0,reason)
static ERR_STRING_DATA STORE_str_functs[] = {
{ERR_FUNC(STORE_F_MEM_DELETE), "mem_delete"},
{ERR_FUNC(STORE_F_MEM_GENERATE), "mem_generate"},
{ERR_FUNC(STORE_F_MEM_LIST_END), "mem_list_end"},
{ERR_FUNC(STORE_F_MEM_LIST_NEXT), "mem_list_next"},
{ERR_FUNC(STORE_F_MEM_LIST_START), "mem_list_start"},
{ERR_FUNC(STORE_F_MEM_MODIFY), "mem_modify"},
{ERR_FUNC(STORE_F_MEM_STORE), "mem_store"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_GET0_CSTR),
"STORE_ATTR_INFO_get0_cstr"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_GET0_DN), "STORE_ATTR_INFO_get0_dn"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_GET0_NUMBER),
"STORE_ATTR_INFO_get0_number"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_GET0_SHA1STR),
"STORE_ATTR_INFO_get0_sha1str"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_MODIFY_CSTR),
"STORE_ATTR_INFO_modify_cstr"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_MODIFY_DN),
"STORE_ATTR_INFO_modify_dn"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_MODIFY_NUMBER),
"STORE_ATTR_INFO_modify_number"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_MODIFY_SHA1STR),
"STORE_ATTR_INFO_modify_sha1str"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_SET_CSTR), "STORE_ATTR_INFO_set_cstr"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_SET_DN), "STORE_ATTR_INFO_set_dn"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_SET_NUMBER),
"STORE_ATTR_INFO_set_number"},
{ERR_FUNC(STORE_F_STORE_ATTR_INFO_SET_SHA1STR),
"STORE_ATTR_INFO_set_sha1str"},
{ERR_FUNC(STORE_F_STORE_CERTIFICATE), "STORE_store_certificate"},
{ERR_FUNC(STORE_F_STORE_CTRL), "STORE_ctrl"},
{ERR_FUNC(STORE_F_STORE_DELETE_ARBITRARY), "STORE_delete_arbitrary"},
{ERR_FUNC(STORE_F_STORE_DELETE_CERTIFICATE), "STORE_delete_certificate"},
{ERR_FUNC(STORE_F_STORE_DELETE_CRL), "STORE_delete_crl"},
{ERR_FUNC(STORE_F_STORE_DELETE_NUMBER), "STORE_delete_number"},
{ERR_FUNC(STORE_F_STORE_DELETE_PRIVATE_KEY), "STORE_delete_private_key"},
{ERR_FUNC(STORE_F_STORE_DELETE_PUBLIC_KEY), "STORE_delete_public_key"},
{ERR_FUNC(STORE_F_STORE_GENERATE_CRL), "STORE_generate_crl"},
{ERR_FUNC(STORE_F_STORE_GENERATE_KEY), "STORE_generate_key"},
{ERR_FUNC(STORE_F_STORE_GET_ARBITRARY), "STORE_get_arbitrary"},
{ERR_FUNC(STORE_F_STORE_GET_CERTIFICATE), "STORE_get_certificate"},
{ERR_FUNC(STORE_F_STORE_GET_CRL), "STORE_get_crl"},
{ERR_FUNC(STORE_F_STORE_GET_NUMBER), "STORE_get_number"},
{ERR_FUNC(STORE_F_STORE_GET_PRIVATE_KEY), "STORE_get_private_key"},
{ERR_FUNC(STORE_F_STORE_GET_PUBLIC_KEY), "STORE_get_public_key"},
{ERR_FUNC(STORE_F_STORE_LIST_CERTIFICATE_END),
"STORE_list_certificate_end"},
{ERR_FUNC(STORE_F_STORE_LIST_CERTIFICATE_ENDP),
"STORE_list_certificate_endp"},
{ERR_FUNC(STORE_F_STORE_LIST_CERTIFICATE_NEXT),
"STORE_list_certificate_next"},
{ERR_FUNC(STORE_F_STORE_LIST_CERTIFICATE_START),
"STORE_list_certificate_start"},
{ERR_FUNC(STORE_F_STORE_LIST_CRL_END), "STORE_list_crl_end"},
{ERR_FUNC(STORE_F_STORE_LIST_CRL_ENDP), "STORE_list_crl_endp"},
{ERR_FUNC(STORE_F_STORE_LIST_CRL_NEXT), "STORE_list_crl_next"},
{ERR_FUNC(STORE_F_STORE_LIST_CRL_START), "STORE_list_crl_start"},
{ERR_FUNC(STORE_F_STORE_LIST_PRIVATE_KEY_END),
"STORE_list_private_key_end"},
{ERR_FUNC(STORE_F_STORE_LIST_PRIVATE_KEY_ENDP),
"STORE_list_private_key_endp"},
{ERR_FUNC(STORE_F_STORE_LIST_PRIVATE_KEY_NEXT),
"STORE_list_private_key_next"},
{ERR_FUNC(STORE_F_STORE_LIST_PRIVATE_KEY_START),
"STORE_list_private_key_start"},
{ERR_FUNC(STORE_F_STORE_LIST_PUBLIC_KEY_END),
"STORE_list_public_key_end"},
{ERR_FUNC(STORE_F_STORE_LIST_PUBLIC_KEY_ENDP),
"STORE_list_public_key_endp"},
{ERR_FUNC(STORE_F_STORE_LIST_PUBLIC_KEY_NEXT),
"STORE_list_public_key_next"},
{ERR_FUNC(STORE_F_STORE_LIST_PUBLIC_KEY_START),
"STORE_list_public_key_start"},
{ERR_FUNC(STORE_F_STORE_MODIFY_ARBITRARY), "STORE_modify_arbitrary"},
{ERR_FUNC(STORE_F_STORE_MODIFY_CERTIFICATE), "STORE_modify_certificate"},
{ERR_FUNC(STORE_F_STORE_MODIFY_CRL), "STORE_modify_crl"},
{ERR_FUNC(STORE_F_STORE_MODIFY_NUMBER), "STORE_modify_number"},
{ERR_FUNC(STORE_F_STORE_MODIFY_PRIVATE_KEY), "STORE_modify_private_key"},
{ERR_FUNC(STORE_F_STORE_MODIFY_PUBLIC_KEY), "STORE_modify_public_key"},
{ERR_FUNC(STORE_F_STORE_NEW_ENGINE), "STORE_new_engine"},
{ERR_FUNC(STORE_F_STORE_NEW_METHOD), "STORE_new_method"},
{ERR_FUNC(STORE_F_STORE_PARSE_ATTRS_END), "STORE_parse_attrs_end"},
{ERR_FUNC(STORE_F_STORE_PARSE_ATTRS_ENDP), "STORE_parse_attrs_endp"},
{ERR_FUNC(STORE_F_STORE_PARSE_ATTRS_NEXT), "STORE_parse_attrs_next"},
{ERR_FUNC(STORE_F_STORE_PARSE_ATTRS_START), "STORE_parse_attrs_start"},
{ERR_FUNC(STORE_F_STORE_REVOKE_CERTIFICATE), "STORE_revoke_certificate"},
{ERR_FUNC(STORE_F_STORE_REVOKE_PRIVATE_KEY), "STORE_revoke_private_key"},
{ERR_FUNC(STORE_F_STORE_REVOKE_PUBLIC_KEY), "STORE_revoke_public_key"},
{ERR_FUNC(STORE_F_STORE_STORE_ARBITRARY), "STORE_store_arbitrary"},
{ERR_FUNC(STORE_F_STORE_STORE_CERTIFICATE), "STORE_store_certificate"},
{ERR_FUNC(STORE_F_STORE_STORE_CRL), "STORE_store_crl"},
{ERR_FUNC(STORE_F_STORE_STORE_NUMBER), "STORE_store_number"},
{ERR_FUNC(STORE_F_STORE_STORE_PRIVATE_KEY), "STORE_store_private_key"},
{ERR_FUNC(STORE_F_STORE_STORE_PUBLIC_KEY), "STORE_store_public_key"},
{0, NULL}
};
static ERR_STRING_DATA STORE_str_reasons[] = {
{ERR_REASON(STORE_R_ALREADY_HAS_A_VALUE), "already has a value"},
{ERR_REASON(STORE_R_FAILED_DELETING_ARBITRARY),
"failed deleting arbitrary"},
{ERR_REASON(STORE_R_FAILED_DELETING_CERTIFICATE),
"failed deleting certificate"},
{ERR_REASON(STORE_R_FAILED_DELETING_KEY), "failed deleting key"},
{ERR_REASON(STORE_R_FAILED_DELETING_NUMBER), "failed deleting number"},
{ERR_REASON(STORE_R_FAILED_GENERATING_CRL), "failed generating crl"},
{ERR_REASON(STORE_R_FAILED_GENERATING_KEY), "failed generating key"},
{ERR_REASON(STORE_R_FAILED_GETTING_ARBITRARY),
"failed getting arbitrary"},
{ERR_REASON(STORE_R_FAILED_GETTING_CERTIFICATE),
"failed getting certificate"},
{ERR_REASON(STORE_R_FAILED_GETTING_KEY), "failed getting key"},
{ERR_REASON(STORE_R_FAILED_GETTING_NUMBER), "failed getting number"},
{ERR_REASON(STORE_R_FAILED_LISTING_CERTIFICATES),
"failed listing certificates"},
{ERR_REASON(STORE_R_FAILED_LISTING_KEYS), "failed listing keys"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_ARBITRARY),
"failed modifying arbitrary"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_CERTIFICATE),
"failed modifying certificate"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_CRL), "failed modifying crl"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_NUMBER), "failed modifying number"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_PRIVATE_KEY),
"failed modifying private key"},
{ERR_REASON(STORE_R_FAILED_MODIFYING_PUBLIC_KEY),
"failed modifying public key"},
{ERR_REASON(STORE_R_FAILED_REVOKING_CERTIFICATE),
"failed revoking certificate"},
{ERR_REASON(STORE_R_FAILED_REVOKING_KEY), "failed revoking key"},
{ERR_REASON(STORE_R_FAILED_STORING_ARBITRARY),
"failed storing arbitrary"},
{ERR_REASON(STORE_R_FAILED_STORING_CERTIFICATE),
"failed storing certificate"},
{ERR_REASON(STORE_R_FAILED_STORING_KEY), "failed storing key"},
{ERR_REASON(STORE_R_FAILED_STORING_NUMBER), "failed storing number"},
{ERR_REASON(STORE_R_NOT_IMPLEMENTED), "not implemented"},
{ERR_REASON(STORE_R_NO_CONTROL_FUNCTION), "no control function"},
{ERR_REASON(STORE_R_NO_DELETE_ARBITRARY_FUNCTION),
"no delete arbitrary function"},
{ERR_REASON(STORE_R_NO_DELETE_NUMBER_FUNCTION),
"no delete number function"},
{ERR_REASON(STORE_R_NO_DELETE_OBJECT_FUNCTION),
"no delete object function"},
{ERR_REASON(STORE_R_NO_GENERATE_CRL_FUNCTION),
"no generate crl function"},
{ERR_REASON(STORE_R_NO_GENERATE_OBJECT_FUNCTION),
"no generate object function"},
{ERR_REASON(STORE_R_NO_GET_OBJECT_ARBITRARY_FUNCTION),
"no get object arbitrary function"},
{ERR_REASON(STORE_R_NO_GET_OBJECT_FUNCTION), "no get object function"},
{ERR_REASON(STORE_R_NO_GET_OBJECT_NUMBER_FUNCTION),
"no get object number function"},
{ERR_REASON(STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION),
"no list object endp function"},
{ERR_REASON(STORE_R_NO_LIST_OBJECT_END_FUNCTION),
"no list object end function"},
{ERR_REASON(STORE_R_NO_LIST_OBJECT_NEXT_FUNCTION),
"no list object next function"},
{ERR_REASON(STORE_R_NO_LIST_OBJECT_START_FUNCTION),
"no list object start function"},
{ERR_REASON(STORE_R_NO_MODIFY_OBJECT_FUNCTION),
"no modify object function"},
{ERR_REASON(STORE_R_NO_REVOKE_OBJECT_FUNCTION),
"no revoke object function"},
{ERR_REASON(STORE_R_NO_STORE), "no store"},
{ERR_REASON(STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION),
"no store object arbitrary function"},
{ERR_REASON(STORE_R_NO_STORE_OBJECT_FUNCTION),
"no store object function"},
{ERR_REASON(STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION),
"no store object number function"},
{ERR_REASON(STORE_R_NO_VALUE), "no value"},
{0, NULL}
};
#endif
void ERR_load_STORE_strings(void)
{
#ifndef OPENSSL_NO_ERR
if (ERR_func_error_string(STORE_str_functs[0].error) == NULL) {
ERR_load_strings(0, STORE_str_functs);
ERR_load_strings(0, STORE_str_reasons);
}
#endif
}

1759
crypto/store/str_lib.c
View File

File diff suppressed because it is too large Load Diff

124
crypto/store/str_locl.h
View File

@@ -1,124 +0,0 @@
/*
* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
* 2003.
*/
/* ====================================================================
* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
#ifndef HEADER_STORE_LOCL_H
# define HEADER_STORE_LOCL_H
# include <openssl/crypto.h>
# include <openssl/store.h>
#ifdef __cplusplus
extern "C" {
#endif
struct store_method_st {
char *name;
/*
* All the functions return a positive integer or non-NULL for success
* and 0, a negative integer or NULL for failure
*/
/* Initialise the STORE with private data */
STORE_INITIALISE_FUNC_PTR init;
/* Initialise the STORE with private data */
STORE_CLEANUP_FUNC_PTR clean;
/* Generate an object of a given type */
STORE_GENERATE_OBJECT_FUNC_PTR generate_object;
/*
* Get an object of a given type. This function isn't really very useful
* since the listing functions (below) can be used for the same purpose
* and are much more general.
*/
STORE_GET_OBJECT_FUNC_PTR get_object;
/* Store an object of a given type. */
STORE_STORE_OBJECT_FUNC_PTR store_object;
/* Modify the attributes bound to an object of a given type. */
STORE_MODIFY_OBJECT_FUNC_PTR modify_object;
/* Revoke an object of a given type. */
STORE_HANDLE_OBJECT_FUNC_PTR revoke_object;
/* Delete an object of a given type. */
STORE_HANDLE_OBJECT_FUNC_PTR delete_object;
/*
* List a bunch of objects of a given type and with the associated
* attributes.
*/
STORE_START_OBJECT_FUNC_PTR list_object_start;
STORE_NEXT_OBJECT_FUNC_PTR list_object_next;
STORE_END_OBJECT_FUNC_PTR list_object_end;
STORE_END_OBJECT_FUNC_PTR list_object_endp;
/* Store-level function to make any necessary update operations. */
STORE_GENERIC_FUNC_PTR update_store;
/* Store-level function to get exclusive access to the store. */
STORE_GENERIC_FUNC_PTR lock_store;
/* Store-level function to release exclusive access to the store. */
STORE_GENERIC_FUNC_PTR unlock_store;
/* Generic control function */
STORE_CTRL_FUNC_PTR ctrl;
};
struct store_st {
const STORE_METHOD *meth;
/* functional reference if 'meth' is ENGINE-provided */
ENGINE *engine;
CRYPTO_EX_DATA ex_data;
int references;
};
#ifdef __cplusplus
}
#endif
#endif

379
crypto/store/str_mem.c
View File

@@ -1,379 +0,0 @@
/*
* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
* 2003.
*/
/* ====================================================================
* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
#include <string.h>
#include <openssl/err.h>
#include "str_locl.h"
/*
* The memory store is currently highly experimental. It's meant to become a
* base store used by other stores for internal caching (for full caching
* support, aging needs to be added).
*
* The database use is meant to support as much attribute association as
* possible, while providing for as small search ranges as possible. This is
* currently provided for by sorting the entries by numbers that are composed
* of bits set at the positions indicated by attribute type codes. This
* provides for ranges determined by the highest attribute type code value.
* A better idea might be to sort by values computed from the range of
* attributes associated with the object (basically, the difference between
* the highest and lowest attribute type code) and it's distance from a base
* (basically, the lowest associated attribute type code).
*/
typedef struct mem_object_data_st {
STORE_OBJECT *object;
STORE_ATTR_INFO *attr_info;
int references;
} MEM_OBJECT_DATA;
DEFINE_STACK_OF(MEM_OBJECT_DATA)
struct mem_data_st {
/*
* sorted with
* STORE_ATTR_INFO_compare().
*/
STACK_OF(MEM_OBJECT_DATA) *data;
/*
* Currently unused, but can
* be used to add attributes
* from parts of the data.
*/
unsigned int compute_components:1;
};
DEFINE_STACK_OF(STORE_ATTR_INFO)
struct mem_ctx_st {
/* The type we're searching for */
int type;
/*
* Sets of
* attributes to search for. Each
* element is a STORE_ATTR_INFO.
*/
STACK_OF(STORE_ATTR_INFO) *search_attributes;
/*
* which of the search attributes we
* found a match for, -1 when we still
* haven't found any
*/
int search_index;
/* -1 as long as we're searching for the first */
int index;
};
static int mem_init(STORE *s);
static void mem_clean(STORE *s);
static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
static int mem_store(STORE *s, STORE_OBJECT_TYPES type, STORE_OBJECT *data,
OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_attributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[]);
static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
static STORE_OBJECT *mem_list_next(STORE *s, void *handle);
static int mem_list_end(STORE *s, void *handle);
static int mem_list_endp(STORE *s, void *handle);
static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void));
static STORE_METHOD store_memory = {
"OpenSSL memory store interface",
mem_init,
mem_clean,
mem_generate,
mem_get,
mem_store,
mem_modify,
NULL, /* revoke */
mem_delete,
mem_list_start,
mem_list_next,
mem_list_end,
mem_list_endp,
NULL, /* update */
mem_lock,
mem_unlock,
mem_ctrl
};
const STORE_METHOD *STORE_Memory(void)
{
return &store_memory;
}
static int mem_init(STORE *s)
{
return 1;
}
static void mem_clean(STORE *s)
{
return;
}
static STORE_OBJECT *mem_generate(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
STOREerr(STORE_F_MEM_GENERATE, STORE_R_NOT_IMPLEMENTED);
return 0;
}
static STORE_OBJECT *mem_get(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
void *context = mem_list_start(s, type, attributes, parameters);
if (context) {
STORE_OBJECT *object = mem_list_next(s, context);
if (mem_list_end(s, context))
return object;
}
return NULL;
}
static int mem_store(STORE *s, STORE_OBJECT_TYPES type,
STORE_OBJECT *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
STOREerr(STORE_F_MEM_STORE, STORE_R_NOT_IMPLEMENTED);
return 0;
}
static int mem_modify(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_attributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[])
{
STOREerr(STORE_F_MEM_MODIFY, STORE_R_NOT_IMPLEMENTED);
return 0;
}
static int mem_delete(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[], OPENSSL_ITEM parameters[])
{
STOREerr(STORE_F_MEM_DELETE, STORE_R_NOT_IMPLEMENTED);
return 0;
}
/*
* The list functions may be the hardest to understand. Basically,
* mem_list_start compiles a stack of attribute info elements, and puts that
* stack into the context to be returned. mem_list_next will then find the
* first matching element in the store, and then walk all the way to the end
* of the store (since any combination of attribute bits above the starting
* point may match the searched for bit pattern...).
*/
static void *mem_list_start(STORE *s, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
struct mem_ctx_st *context = OPENSSL_zalloc(sizeof(*context));
void *attribute_context = NULL;
STORE_ATTR_INFO *attrs = NULL;
if (context == NULL) {
STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
return 0;
}
attribute_context = STORE_parse_attrs_start(attributes);
if (!attribute_context) {
STOREerr(STORE_F_MEM_LIST_START, ERR_R_STORE_LIB);
goto err;
}
while ((attrs = STORE_parse_attrs_next(attribute_context))) {
if (context->search_attributes == NULL) {
context->search_attributes =
sk_STORE_ATTR_INFO_new(STORE_ATTR_INFO_compare);
if (context->search_attributes == NULL) {
STOREerr(STORE_F_MEM_LIST_START, ERR_R_MALLOC_FAILURE);
goto err;
}
}
sk_STORE_ATTR_INFO_push(context->search_attributes, attrs);
}
if (!STORE_parse_attrs_endp(attribute_context))
goto err;
STORE_parse_attrs_end(attribute_context);
context->search_index = -1;
context->index = -1;
return context;
err:
if (attribute_context)
STORE_parse_attrs_end(attribute_context);
mem_list_end(s, context);
return NULL;
}
static STORE_OBJECT *mem_list_next(STORE *s, void *handle)
{
int i;
struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
struct mem_object_data_st key = { 0, 0, 1 };
struct mem_data_st *store = (struct mem_data_st *)STORE_get_ex_data(s, 1);
int srch;
int cres = 0;
if (!context) {
STOREerr(STORE_F_MEM_LIST_NEXT, ERR_R_PASSED_NULL_PARAMETER);
return NULL;
}
if (!store) {
STOREerr(STORE_F_MEM_LIST_NEXT, STORE_R_NO_STORE);
return NULL;
}
if (context->search_index == -1) {
for (i = 0;
i < sk_STORE_ATTR_INFO_num(context->search_attributes); i++) {
key.attr_info
= sk_STORE_ATTR_INFO_value(context->search_attributes, i);
srch = sk_MEM_OBJECT_DATA_find_ex(store->data, &key);
if (srch >= 0) {
context->search_index = srch;
break;
}
}
}
if (context->search_index < 0)
return NULL;
key.attr_info =
sk_STORE_ATTR_INFO_value(context->search_attributes,
context->search_index);
for (srch = context->search_index;
srch < sk_MEM_OBJECT_DATA_num(store->data)
&& STORE_ATTR_INFO_in_range(key.attr_info,
sk_MEM_OBJECT_DATA_value(store->data,
srch)->attr_info)
&& !(cres =
STORE_ATTR_INFO_in_ex(key.attr_info,
sk_MEM_OBJECT_DATA_value(store->data,
srch)->attr_info));
srch++) ;
context->search_index = srch;
if (cres)
return (sk_MEM_OBJECT_DATA_value(store->data, srch))->object;
return NULL;
}
static int mem_list_end(STORE *s, void *handle)
{
struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
if (!context) {
STOREerr(STORE_F_MEM_LIST_END, ERR_R_PASSED_NULL_PARAMETER);
return 0;
}
if (context)
sk_STORE_ATTR_INFO_free(context->search_attributes);
OPENSSL_free(context);
return 1;
}
static int mem_list_endp(STORE *s, void *handle)
{
struct mem_ctx_st *context = (struct mem_ctx_st *)handle;
if (!context
|| context->search_index
== sk_STORE_ATTR_INFO_num(context->search_attributes))
return 1;
return 0;
}
static int mem_lock(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
return 1;
}
static int mem_unlock(STORE *s, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[])
{
return 1;
}
static int mem_ctrl(STORE *s, int cmd, long l, void *p, void (*f) (void))
{
return 1;
}

276
crypto/store/str_meth.c
View File

@@ -1,276 +0,0 @@
/*
* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
* 2003.
*/
/* ====================================================================
* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
#include <string.h>
#include <openssl/buffer.h>
#include "str_locl.h"
STORE_METHOD *STORE_create_method(char *name)
{
STORE_METHOD *store_method = OPENSSL_zalloc(sizeof(*store_method));
if (store_method != NULL)
store_method->name = OPENSSL_strdup(name);
return store_method;
}
/*
* BIG FSCKING WARNING!!!! If you use this on a statically allocated method
* (that is, it hasn't been allocated using STORE_create_method(), you
* deserve anything Murphy can throw at you and more! You have been warned.
*/
void STORE_destroy_method(STORE_METHOD *store_method)
{
if (!store_method)
return;
OPENSSL_free(store_method->name);
store_method->name = NULL;
OPENSSL_free(store_method);
}
int STORE_method_set_initialise_function(STORE_METHOD *sm,
STORE_INITIALISE_FUNC_PTR init_f)
{
sm->init = init_f;
return 1;
}
int STORE_method_set_cleanup_function(STORE_METHOD *sm,
STORE_CLEANUP_FUNC_PTR clean_f)
{
sm->clean = clean_f;
return 1;
}
int STORE_method_set_generate_function(STORE_METHOD *sm,
STORE_GENERATE_OBJECT_FUNC_PTR
generate_f)
{
sm->generate_object = generate_f;
return 1;
}
int STORE_method_set_get_function(STORE_METHOD *sm,
STORE_GET_OBJECT_FUNC_PTR get_f)
{
sm->get_object = get_f;
return 1;
}
int STORE_method_set_store_function(STORE_METHOD *sm,
STORE_STORE_OBJECT_FUNC_PTR store_f)
{
sm->store_object = store_f;
return 1;
}
int STORE_method_set_modify_function(STORE_METHOD *sm,
STORE_MODIFY_OBJECT_FUNC_PTR modify_f)
{
sm->modify_object = modify_f;
return 1;
}
int STORE_method_set_revoke_function(STORE_METHOD *sm,
STORE_HANDLE_OBJECT_FUNC_PTR revoke_f)
{
sm->revoke_object = revoke_f;
return 1;
}
int STORE_method_set_delete_function(STORE_METHOD *sm,
STORE_HANDLE_OBJECT_FUNC_PTR delete_f)
{
sm->delete_object = delete_f;
return 1;
}
int STORE_method_set_list_start_function(STORE_METHOD *sm,
STORE_START_OBJECT_FUNC_PTR
list_start_f)
{
sm->list_object_start = list_start_f;
return 1;
}
int STORE_method_set_list_next_function(STORE_METHOD *sm,
STORE_NEXT_OBJECT_FUNC_PTR
list_next_f)
{
sm->list_object_next = list_next_f;
return 1;
}
int STORE_method_set_list_end_function(STORE_METHOD *sm,
STORE_END_OBJECT_FUNC_PTR list_end_f)
{
sm->list_object_end = list_end_f;
return 1;
}
int STORE_method_set_update_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR update_f)
{
sm->update_store = update_f;
return 1;
}
int STORE_method_set_lock_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR lock_f)
{
sm->lock_store = lock_f;
return 1;
}
int STORE_method_set_unlock_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR unlock_f)
{
sm->unlock_store = unlock_f;
return 1;
}
int STORE_method_set_ctrl_function(STORE_METHOD *sm,
STORE_CTRL_FUNC_PTR ctrl_f)
{
sm->ctrl = ctrl_f;
return 1;
}
STORE_INITIALISE_FUNC_PTR STORE_method_get_initialise_function(STORE_METHOD
*sm)
{
return sm->init;
}
STORE_CLEANUP_FUNC_PTR STORE_method_get_cleanup_function(STORE_METHOD *sm)
{
return sm->clean;
}
STORE_GENERATE_OBJECT_FUNC_PTR STORE_method_get_generate_function(STORE_METHOD
*sm)
{
return sm->generate_object;
}
STORE_GET_OBJECT_FUNC_PTR STORE_method_get_get_function(STORE_METHOD *sm)
{
return sm->get_object;
}
STORE_STORE_OBJECT_FUNC_PTR STORE_method_get_store_function(STORE_METHOD *sm)
{
return sm->store_object;
}
STORE_MODIFY_OBJECT_FUNC_PTR STORE_method_get_modify_function(STORE_METHOD
*sm)
{
return sm->modify_object;
}
STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_revoke_function(STORE_METHOD
*sm)
{
return sm->revoke_object;
}
STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_delete_function(STORE_METHOD
*sm)
{
return sm->delete_object;
}
STORE_START_OBJECT_FUNC_PTR STORE_method_get_list_start_function(STORE_METHOD
*sm)
{
return sm->list_object_start;
}
STORE_NEXT_OBJECT_FUNC_PTR STORE_method_get_list_next_function(STORE_METHOD
*sm)
{
return sm->list_object_next;
}
STORE_END_OBJECT_FUNC_PTR STORE_method_get_list_end_function(STORE_METHOD *sm)
{
return sm->list_object_end;
}
STORE_GENERIC_FUNC_PTR STORE_method_get_update_store_function(STORE_METHOD
*sm)
{
return sm->update_store;
}
STORE_GENERIC_FUNC_PTR STORE_method_get_lock_store_function(STORE_METHOD *sm)
{
return sm->lock_store;
}
STORE_GENERIC_FUNC_PTR STORE_method_get_unlock_store_function(STORE_METHOD
*sm)
{
return sm->unlock_store;
}
STORE_CTRL_FUNC_PTR STORE_method_get_ctrl_function(STORE_METHOD *sm)
{
return sm->ctrl;
}

7
doc/crypto/engine.pod
View File

@@ -75,9 +75,6 @@ engine - ENGINE cryptographic module support
int ENGINE_register_RAND(ENGINE *e); int ENGINE_register_RAND(ENGINE *e);
void ENGINE_unregister_RAND(ENGINE *e); void ENGINE_unregister_RAND(ENGINE *e);
void ENGINE_register_all_RAND(void); void ENGINE_register_all_RAND(void);
int ENGINE_register_STORE(ENGINE *e);
void ENGINE_unregister_STORE(ENGINE *e);
void ENGINE_register_all_STORE(void);
int ENGINE_register_ciphers(ENGINE *e); int ENGINE_register_ciphers(ENGINE *e);
void ENGINE_unregister_ciphers(ENGINE *e); void ENGINE_unregister_ciphers(ENGINE *e);
void ENGINE_register_all_ciphers(void); void ENGINE_register_all_ciphers(void);
@@ -106,7 +103,6 @@ engine - ENGINE cryptographic module support
int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *dh_meth); int ENGINE_set_ECDSA(ENGINE *e, const ECDSA_METHOD *dh_meth);
int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *rand_meth);
int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
@@ -126,7 +122,6 @@ engine - ENGINE cryptographic module support
const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e); const ECDSA_METHOD *ENGINE_get_ECDSA(const ENGINE *e);
const DH_METHOD *ENGINE_get_DH(const ENGINE *e); const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);
@@ -160,7 +155,7 @@ implementation includes the following abstractions;
RSA_METHOD - for providing alternative RSA implementations RSA_METHOD - for providing alternative RSA implementations
DSA_METHOD, DH_METHOD, RAND_METHOD, ECDH_METHOD, ECDSA_METHOD, DSA_METHOD, DH_METHOD, RAND_METHOD, ECDH_METHOD, ECDSA_METHOD,
STORE_METHOD - similarly for other OpenSSL APIs - similarly for other OpenSSL APIs
EVP_CIPHER - potentially multiple cipher algorithms (indexed by 'nid') EVP_CIPHER - potentially multiple cipher algorithms (indexed by 'nid')
EVP_DIGEST - potentially multiple hash algorithms (indexed by 'nid') EVP_DIGEST - potentially multiple hash algorithms (indexed by 'nid')
key-loading - loading public and/or private EVP_PKEY keys key-loading - loading public and/or private EVP_PKEY keys

7
include/openssl/engine.h
View File

@@ -108,7 +108,6 @@ extern "C" {
# define ENGINE_METHOD_RAND (unsigned int)0x0008 # define ENGINE_METHOD_RAND (unsigned int)0x0008
# define ENGINE_METHOD_CIPHERS (unsigned int)0x0040 # define ENGINE_METHOD_CIPHERS (unsigned int)0x0040
# define ENGINE_METHOD_DIGESTS (unsigned int)0x0080 # define ENGINE_METHOD_DIGESTS (unsigned int)0x0080
# define ENGINE_METHOD_STORE (unsigned int)0x0100
# define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200 # define ENGINE_METHOD_PKEY_METHS (unsigned int)0x0200
# define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400 # define ENGINE_METHOD_PKEY_ASN1_METHS (unsigned int)0x0400
# define ENGINE_METHOD_EC (unsigned int)0x0800 # define ENGINE_METHOD_EC (unsigned int)0x0800
@@ -441,10 +440,6 @@ int ENGINE_register_RAND(ENGINE *e);
void ENGINE_unregister_RAND(ENGINE *e); void ENGINE_unregister_RAND(ENGINE *e);
void ENGINE_register_all_RAND(void); void ENGINE_register_all_RAND(void);
int ENGINE_register_STORE(ENGINE *e);
void ENGINE_unregister_STORE(ENGINE *e);
void ENGINE_register_all_STORE(void);
int ENGINE_register_ciphers(ENGINE *e); int ENGINE_register_ciphers(ENGINE *e);
void ENGINE_unregister_ciphers(ENGINE *e); void ENGINE_unregister_ciphers(ENGINE *e);
void ENGINE_register_all_ciphers(void); void ENGINE_register_all_ciphers(void);
@@ -542,7 +537,6 @@ int ENGINE_set_DSA(ENGINE *e, const DSA_METHOD *dsa_meth);
int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth); int ENGINE_set_EC(ENGINE *e, const EC_KEY_METHOD *ecdsa_meth);
int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth); int ENGINE_set_DH(ENGINE *e, const DH_METHOD *dh_meth);
int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth); int ENGINE_set_RAND(ENGINE *e, const RAND_METHOD *rand_meth);
int ENGINE_set_STORE(ENGINE *e, const STORE_METHOD *store_meth);
int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f); int ENGINE_set_destroy_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR destroy_f);
int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f); int ENGINE_set_init_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR init_f);
int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f); int ENGINE_set_finish_function(ENGINE *e, ENGINE_GEN_INT_FUNC_PTR finish_f);
@@ -586,7 +580,6 @@ const DSA_METHOD *ENGINE_get_DSA(const ENGINE *e);
const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e); const EC_KEY_METHOD *ENGINE_get_EC(const ENGINE *e);
const DH_METHOD *ENGINE_get_DH(const ENGINE *e); const DH_METHOD *ENGINE_get_DH(const ENGINE *e);
const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e); const RAND_METHOD *ENGINE_get_RAND(const ENGINE *e);
const STORE_METHOD *ENGINE_get_STORE(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_destroy_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_init_function(const ENGINE *e);
ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e); ENGINE_GEN_INT_FUNC_PTR ENGINE_get_finish_function(const ENGINE *e);

3
include/openssl/ossl_typ.h
View File

@@ -173,9 +173,6 @@ typedef struct pkcs8_priv_key_info_st PKCS8_PRIV_KEY_INFO;
typedef struct v3_ext_ctx X509V3_CTX; typedef struct v3_ext_ctx X509V3_CTX;
typedef struct conf_st CONF; typedef struct conf_st CONF;
typedef struct store_st STORE;
typedef struct store_method_st STORE_METHOD;
typedef struct ui_st UI; typedef struct ui_st UI;
typedef struct ui_method_st UI_METHOD; typedef struct ui_method_st UI_METHOD;

665
include/openssl/store.h
View File

@@ -1,665 +0,0 @@
/*
* Written by Richard Levitte (richard@levitte.org) for the OpenSSL project
* 2003.
*/
/* ====================================================================
* Copyright (c) 2003 The OpenSSL Project. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. All advertising materials mentioning features or use of this
* software must display the following acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
*
* 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
* endorse or promote products derived from this software without
* prior written permission. For written permission, please contact
* openssl-core@openssl.org.
*
* 5. Products derived from this software may not be called "OpenSSL"
* nor may "OpenSSL" appear in their names without prior written
* permission of the OpenSSL Project.
*
* 6. Redistributions of any form whatsoever must retain the following
* acknowledgment:
* "This product includes software developed by the OpenSSL Project
* for use in the OpenSSL Toolkit (http://www.openssl.org/)"
*
* THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
* EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OpenSSL PROJECT OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
* OF THE POSSIBILITY OF SUCH DAMAGE.
* ====================================================================
*
* This product includes cryptographic software written by Eric Young
* (eay@cryptsoft.com). This product includes software written by Tim
* Hudson (tjh@cryptsoft.com).
*
*/
#ifndef HEADER_STORE_H
# define HEADER_STORE_H
# include <openssl/opensslconf.h>
# ifdef OPENSSL_NO_STORE
# error STORE is disabled.
# endif
# include <openssl/ossl_typ.h>
# if OPENSSL_API_COMPAT < 0x10100000L
# include <openssl/evp.h>
# include <openssl/bn.h>
# include <openssl/x509.h>
# endif
#ifdef __cplusplus
extern "C" {
#endif
/* Already defined in ossl_typ.h */
/* typedef struct store_st STORE; */
/* typedef struct store_method_st STORE_METHOD; */
/*
* All the following functions return 0, a negative number or NULL on error.
* When everything is fine, they return a positive value or a non-NULL
* pointer, all depending on their purpose.
*/
/* Creators and destructor. */
STORE *STORE_new_method(const STORE_METHOD *method);
STORE *STORE_new_engine(ENGINE *engine);
void STORE_free(STORE *ui);
/*
* Give a user interface parametrised control commands. This can be used to
* send down an integer, a data pointer or a function pointer, as well as be
* used to get information from a STORE.
*/
int STORE_ctrl(STORE *store, int cmd, long i, void *p, void (*f) (void));
/*
* A control to set the directory with keys and certificates. Used by the
* built-in directory level method.
*/
# define STORE_CTRL_SET_DIRECTORY 0x0001
/*
* A control to set a file to load. Used by the built-in file level method.
*/
# define STORE_CTRL_SET_FILE 0x0002
/*
* A control to set a configuration file to load. Can be used by any method
* that wishes to load a configuration file.
*/
# define STORE_CTRL_SET_CONF_FILE 0x0003
/*
* A control to set a the section of the loaded configuration file. Can be
* used by any method that wishes to load a configuration file.
*/
# define STORE_CTRL_SET_CONF_SECTION 0x0004
/* Some methods may use extra data */
# define STORE_set_app_data(s,arg) STORE_set_ex_data(s,0,arg)
# define STORE_get_app_data(s) STORE_get_ex_data(s,0)
#define STORE_get_ex_new_index(l, p, newf, dupf, freef) \
CRYPTO_get_ex_new_index(CRYPTO_EX_INDEX_STORE, l, p, newf, dupf, freef)
int STORE_set_ex_data(STORE *r, int idx, void *arg);
void *STORE_get_ex_data(STORE *r, int idx);
/* Use specific methods instead of the built-in one */
const STORE_METHOD *STORE_get_method(STORE *store);
const STORE_METHOD *STORE_set_method(STORE *store, const STORE_METHOD *meth);
/* The standard OpenSSL methods. */
/*
* This is the in-memory method. It does everything except revoking and
* updating, and is of course volatile. It's used by other methods that have
* an in-memory cache.
*/
const STORE_METHOD *STORE_Memory(void);
# if 0 /* Not yet implemented */
/*
* This is the directory store. It does everything except revoking and
* updating, and uses STORE_Memory() to cache things in memory.
*/
const STORE_METHOD *STORE_Directory(void);
/*
* This is the file store. It does everything except revoking and updating,
* and uses STORE_Memory() to cache things in memory. Certificates are added
* to it with the store operation, and it will only get cached certificates.
*/
const STORE_METHOD *STORE_File(void);
# endif
/*
* Store functions take a type code for the type of data they should store or
* fetch
*/
typedef enum STORE_object_types {
STORE_OBJECT_TYPE_X509_CERTIFICATE = 0x01, /* X509 * */
STORE_OBJECT_TYPE_X509_CRL = 0x02, /* X509_CRL * */
STORE_OBJECT_TYPE_PRIVATE_KEY = 0x03, /* EVP_PKEY * */
STORE_OBJECT_TYPE_PUBLIC_KEY = 0x04, /* EVP_PKEY * */
STORE_OBJECT_TYPE_NUMBER = 0x05, /* BIGNUM * */
STORE_OBJECT_TYPE_ARBITRARY = 0x06, /* BUF_MEM * */
STORE_OBJECT_TYPE_NUM = 0x06 /* The amount of known object types */
} STORE_OBJECT_TYPES;
/* List of text strings corresponding to the object types. */
extern const char *const STORE_object_type_string[STORE_OBJECT_TYPE_NUM + 1];
/*
* Some store functions take a parameter list. Those parameters come with
* one of the following codes. The comments following the codes below
* indicate what type the value should be a pointer to.
*/
typedef enum STORE_params {
STORE_PARAM_EVP_TYPE = 0x01, /* int */
STORE_PARAM_BITS = 0x02, /* size_t */
STORE_PARAM_KEY_PARAMETERS = 0x03, /* ??? */
STORE_PARAM_KEY_NO_PARAMETERS = 0x04, /* N/A */
STORE_PARAM_AUTH_PASSPHRASE = 0x05, /* char * */
STORE_PARAM_TYPE_NUM = 0x05 /* The amount of known parameter types */
} STORE_PARAM_TYPES;
/*
* Parameter value sizes. -1 means unknown, anything else is the required
* size.
*/
extern const int STORE_param_sizes[STORE_PARAM_TYPE_NUM + 1];
/*
* Store functions take attribute lists. Those attributes come with codes.
* The comments following the codes below indicate what type the value should
* be a pointer to.
*/
typedef enum STORE_attribs {
STORE_ATTR_END = 0x00,
STORE_ATTR_FRIENDLYNAME = 0x01, /* C string */
STORE_ATTR_KEYID = 0x02, /* 160 bit string (SHA1) */
STORE_ATTR_ISSUERKEYID = 0x03, /* 160 bit string (SHA1) */
STORE_ATTR_SUBJECTKEYID = 0x04, /* 160 bit string (SHA1) */
STORE_ATTR_ISSUERSERIALHASH = 0x05, /* 160 bit string (SHA1) */
STORE_ATTR_ISSUER = 0x06, /* X509_NAME * */
STORE_ATTR_SERIAL = 0x07, /* BIGNUM * */
STORE_ATTR_SUBJECT = 0x08, /* X509_NAME * */
STORE_ATTR_CERTHASH = 0x09, /* 160 bit string (SHA1) */
STORE_ATTR_EMAIL = 0x0a, /* C string */
STORE_ATTR_FILENAME = 0x0b, /* C string */
STORE_ATTR_TYPE_NUM = 0x0b, /* The amount of known attribute types */
STORE_ATTR_OR = 0xff /* This is a special separator, which
* expresses the OR operation. */
} STORE_ATTR_TYPES;
/*
* Attribute value sizes. -1 means unknown, anything else is the required
* size.
*/
extern const int STORE_attr_sizes[STORE_ATTR_TYPE_NUM + 1];
typedef enum STORE_certificate_status {
STORE_X509_VALID = 0x00,
STORE_X509_EXPIRED = 0x01,
STORE_X509_SUSPENDED = 0x02,
STORE_X509_REVOKED = 0x03
} STORE_CERTIFICATE_STATUS;
/*
* Engine store functions will return a structure that contains all the
* necessary information, including revokation status for certificates. This
* is really not needed for application authors, as the ENGINE framework
* functions will extract the OpenSSL-specific information when at all
* possible. However, for engine authors, it's crucial to know this
* structure.
*/
typedef struct STORE_OBJECT_st {
STORE_OBJECT_TYPES type;
union {
struct {
STORE_CERTIFICATE_STATUS status;
X509 *certificate;
} x509;
X509_CRL *crl;
EVP_PKEY *key;
BIGNUM *number;
BUF_MEM *arbitrary;
} data;
} STORE_OBJECT;
DEFINE_STACK_OF(STORE_OBJECT)
STORE_OBJECT *STORE_OBJECT_new(void);
void STORE_OBJECT_free(STORE_OBJECT *data);
/* A generic structure to pass assorted data in a expandable way */
typedef struct openssl_item_st {
int code;
void *value; /* Not used for flag attributes */
size_t value_size; /* Max size of value for output, length for
* input */
size_t *value_length; /* Returned length of value for output */
} OPENSSL_ITEM;
/*
* The following functions handle the storage. They return 0, a negative
* number or NULL on error, anything else on success.
*/
X509 *STORE_get_certificate(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_store_certificate(STORE *e, X509 *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_certificate(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_attributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
int STORE_revoke_certificate(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_certificate(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
void *STORE_list_certificate_start(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
X509 *STORE_list_certificate_next(STORE *e, void *handle);
int STORE_list_certificate_end(STORE *e, void *handle);
int STORE_list_certificate_endp(STORE *e, void *handle);
EVP_PKEY *STORE_generate_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
EVP_PKEY *STORE_get_private_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_store_private_key(STORE *e, EVP_PKEY *data,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_private_key(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_sttributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
int STORE_revoke_private_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_private_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
void *STORE_list_private_key_start(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
EVP_PKEY *STORE_list_private_key_next(STORE *e, void *handle);
int STORE_list_private_key_end(STORE *e, void *handle);
int STORE_list_private_key_endp(STORE *e, void *handle);
EVP_PKEY *STORE_get_public_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_store_public_key(STORE *e, EVP_PKEY *data,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_public_key(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_sttributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
int STORE_revoke_public_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_public_key(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
void *STORE_list_public_key_start(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
EVP_PKEY *STORE_list_public_key_next(STORE *e, void *handle);
int STORE_list_public_key_end(STORE *e, void *handle);
int STORE_list_public_key_endp(STORE *e, void *handle);
X509_CRL *STORE_generate_crl(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
X509_CRL *STORE_get_crl(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_store_crl(STORE *e, X509_CRL *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_crl(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_sttributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_crl(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
void *STORE_list_crl_start(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
X509_CRL *STORE_list_crl_next(STORE *e, void *handle);
int STORE_list_crl_end(STORE *e, void *handle);
int STORE_list_crl_endp(STORE *e, void *handle);
int STORE_store_number(STORE *e, BIGNUM *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_number(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_sttributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
BIGNUM *STORE_get_number(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_number(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_store_arbitrary(STORE *e, BUF_MEM *data, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_modify_arbitrary(STORE *e, OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_sttributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
BUF_MEM *STORE_get_arbitrary(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
int STORE_delete_arbitrary(STORE *e, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
/* Create and manipulate methods */
STORE_METHOD *STORE_create_method(char *name);
void STORE_destroy_method(STORE_METHOD *store_method);
/* These callback types are use for store handlers */
typedef int (*STORE_INITIALISE_FUNC_PTR) (STORE *);
typedef void (*STORE_CLEANUP_FUNC_PTR) (STORE *);
typedef STORE_OBJECT *(*STORE_GENERATE_OBJECT_FUNC_PTR)(STORE *,
STORE_OBJECT_TYPES
type,
OPENSSL_ITEM
attributes[],
OPENSSL_ITEM
parameters[]);
typedef STORE_OBJECT *(*STORE_GET_OBJECT_FUNC_PTR)(STORE *,
STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
typedef void *(*STORE_START_OBJECT_FUNC_PTR)(STORE *, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
typedef STORE_OBJECT *(*STORE_NEXT_OBJECT_FUNC_PTR)(STORE *, void *handle);
typedef int (*STORE_END_OBJECT_FUNC_PTR) (STORE *, void *handle);
typedef int (*STORE_HANDLE_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
typedef int (*STORE_STORE_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type,
STORE_OBJECT *data,
OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
typedef int (*STORE_MODIFY_OBJECT_FUNC_PTR) (STORE *, STORE_OBJECT_TYPES type,
OPENSSL_ITEM search_attributes[],
OPENSSL_ITEM add_attributes[],
OPENSSL_ITEM modify_attributes[],
OPENSSL_ITEM delete_attributes[],
OPENSSL_ITEM parameters[]);
typedef int (*STORE_GENERIC_FUNC_PTR) (STORE *, OPENSSL_ITEM attributes[],
OPENSSL_ITEM parameters[]);
typedef int (*STORE_CTRL_FUNC_PTR) (STORE *, int cmd, long l, void *p,
void (*f) (void));
int STORE_method_set_initialise_function(STORE_METHOD *sm,
STORE_INITIALISE_FUNC_PTR init_f);
int STORE_method_set_cleanup_function(STORE_METHOD *sm,
STORE_CLEANUP_FUNC_PTR clean_f);
int STORE_method_set_generate_function(STORE_METHOD *sm,
STORE_GENERATE_OBJECT_FUNC_PTR
generate_f);
int STORE_method_set_get_function(STORE_METHOD *sm,
STORE_GET_OBJECT_FUNC_PTR get_f);
int STORE_method_set_store_function(STORE_METHOD *sm,
STORE_STORE_OBJECT_FUNC_PTR store_f);
int STORE_method_set_modify_function(STORE_METHOD *sm,
STORE_MODIFY_OBJECT_FUNC_PTR store_f);
int STORE_method_set_revoke_function(STORE_METHOD *sm,
STORE_HANDLE_OBJECT_FUNC_PTR revoke_f);
int STORE_method_set_delete_function(STORE_METHOD *sm,
STORE_HANDLE_OBJECT_FUNC_PTR delete_f);
int STORE_method_set_list_start_function(STORE_METHOD *sm,
STORE_START_OBJECT_FUNC_PTR
list_start_f);
int STORE_method_set_list_next_function(STORE_METHOD *sm,
STORE_NEXT_OBJECT_FUNC_PTR
list_next_f);
int STORE_method_set_list_end_function(STORE_METHOD *sm,
STORE_END_OBJECT_FUNC_PTR list_end_f);
int STORE_method_set_update_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR);
int STORE_method_set_lock_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR);
int STORE_method_set_unlock_store_function(STORE_METHOD *sm,
STORE_GENERIC_FUNC_PTR);
int STORE_method_set_ctrl_function(STORE_METHOD *sm,
STORE_CTRL_FUNC_PTR ctrl_f);
STORE_INITIALISE_FUNC_PTR STORE_method_get_initialise_function(STORE_METHOD
*sm);
STORE_CLEANUP_FUNC_PTR STORE_method_get_cleanup_function(STORE_METHOD *sm);
STORE_GENERATE_OBJECT_FUNC_PTR STORE_method_get_generate_function(STORE_METHOD
*sm);
STORE_GET_OBJECT_FUNC_PTR STORE_method_get_get_function(STORE_METHOD *sm);
STORE_STORE_OBJECT_FUNC_PTR STORE_method_get_store_function(STORE_METHOD *sm);
STORE_MODIFY_OBJECT_FUNC_PTR STORE_method_get_modify_function(STORE_METHOD
*sm);
STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_revoke_function(STORE_METHOD
*sm);
STORE_HANDLE_OBJECT_FUNC_PTR STORE_method_get_delete_function(STORE_METHOD
*sm);
STORE_START_OBJECT_FUNC_PTR STORE_method_get_list_start_function(STORE_METHOD
*sm);
STORE_NEXT_OBJECT_FUNC_PTR STORE_method_get_list_next_function(STORE_METHOD
*sm);
STORE_END_OBJECT_FUNC_PTR STORE_method_get_list_end_function(STORE_METHOD
*sm);
STORE_GENERIC_FUNC_PTR STORE_method_get_update_store_function(STORE_METHOD
*sm);
STORE_GENERIC_FUNC_PTR STORE_method_get_lock_store_function(STORE_METHOD *sm);
STORE_GENERIC_FUNC_PTR STORE_method_get_unlock_store_function(STORE_METHOD
*sm);
STORE_CTRL_FUNC_PTR STORE_method_get_ctrl_function(STORE_METHOD *sm);
/* Method helper structures and functions. */
/*
* This structure is the result of parsing through the information in a list
* of OPENSSL_ITEMs. It stores all the necessary information in a structured
* way.
*/
typedef struct STORE_attr_info_st STORE_ATTR_INFO;
/*
* Parse a list of OPENSSL_ITEMs and return a pointer to a STORE_ATTR_INFO.
* Note that we do this in the list form, since the list of OPENSSL_ITEMs can
* come in blocks separated with STORE_ATTR_OR. Note that the value returned
* by STORE_parse_attrs_next() must be freed with STORE_ATTR_INFO_free().
*/
void *STORE_parse_attrs_start(OPENSSL_ITEM *attributes);
STORE_ATTR_INFO *STORE_parse_attrs_next(void *handle);
int STORE_parse_attrs_end(void *handle);
int STORE_parse_attrs_endp(void *handle);
/* Creator and destructor */
STORE_ATTR_INFO *STORE_ATTR_INFO_new(void);
int STORE_ATTR_INFO_free(STORE_ATTR_INFO *attrs);
/* Manipulators */
char *STORE_ATTR_INFO_get0_cstr(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code);
unsigned char *STORE_ATTR_INFO_get0_sha1str(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code);
X509_NAME *STORE_ATTR_INFO_get0_dn(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code);
BIGNUM *STORE_ATTR_INFO_get0_number(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code);
int STORE_ATTR_INFO_set_cstr(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
char *cstr, size_t cstr_size);
int STORE_ATTR_INFO_set_sha1str(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
unsigned char *sha1str, size_t sha1str_size);
int STORE_ATTR_INFO_set_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
X509_NAME *dn);
int STORE_ATTR_INFO_set_number(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
BIGNUM *number);
int STORE_ATTR_INFO_modify_cstr(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
char *cstr, size_t cstr_size);
int STORE_ATTR_INFO_modify_sha1str(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code,
unsigned char *sha1str,
size_t sha1str_size);
int STORE_ATTR_INFO_modify_dn(STORE_ATTR_INFO *attrs, STORE_ATTR_TYPES code,
X509_NAME *dn);
int STORE_ATTR_INFO_modify_number(STORE_ATTR_INFO *attrs,
STORE_ATTR_TYPES code, BIGNUM *number);
/*
* Compare on basis of a bit pattern formed by the STORE_ATTR_TYPES values in
* each contained attribute.
*/
int STORE_ATTR_INFO_compare(const STORE_ATTR_INFO *const *a,
const STORE_ATTR_INFO *const *b);
/*
* Check if the set of attributes in a is within the range of attributes set
* in b.
*/
int STORE_ATTR_INFO_in_range(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b);
/* Check if the set of attributes in a are also set in b. */
int STORE_ATTR_INFO_in(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b);
/* Same as STORE_ATTR_INFO_in(), but also checks the attribute values. */
int STORE_ATTR_INFO_in_ex(STORE_ATTR_INFO *a, STORE_ATTR_INFO *b);
/* BEGIN ERROR CODES */
/*
* The following lines are auto generated by the script mkerr.pl. Any changes
* made after this point may be overwritten when the script is next run.
*/
void ERR_load_STORE_strings(void);
/* Error codes for the STORE functions. */
/* Function codes. */
# define STORE_F_MEM_DELETE 134
# define STORE_F_MEM_GENERATE 135
# define STORE_F_MEM_LIST_END 168
# define STORE_F_MEM_LIST_NEXT 136
# define STORE_F_MEM_LIST_START 137
# define STORE_F_MEM_MODIFY 169
# define STORE_F_MEM_STORE 138
# define STORE_F_STORE_ATTR_INFO_GET0_CSTR 139
# define STORE_F_STORE_ATTR_INFO_GET0_DN 140
# define STORE_F_STORE_ATTR_INFO_GET0_NUMBER 141
# define STORE_F_STORE_ATTR_INFO_GET0_SHA1STR 142
# define STORE_F_STORE_ATTR_INFO_MODIFY_CSTR 143
# define STORE_F_STORE_ATTR_INFO_MODIFY_DN 144
# define STORE_F_STORE_ATTR_INFO_MODIFY_NUMBER 145
# define STORE_F_STORE_ATTR_INFO_MODIFY_SHA1STR 146
# define STORE_F_STORE_ATTR_INFO_SET_CSTR 147
# define STORE_F_STORE_ATTR_INFO_SET_DN 148
# define STORE_F_STORE_ATTR_INFO_SET_NUMBER 149
# define STORE_F_STORE_ATTR_INFO_SET_SHA1STR 150
# define STORE_F_STORE_CERTIFICATE 170
# define STORE_F_STORE_CTRL 161
# define STORE_F_STORE_DELETE_ARBITRARY 158
# define STORE_F_STORE_DELETE_CERTIFICATE 102
# define STORE_F_STORE_DELETE_CRL 103
# define STORE_F_STORE_DELETE_NUMBER 104
# define STORE_F_STORE_DELETE_PRIVATE_KEY 105
# define STORE_F_STORE_DELETE_PUBLIC_KEY 106
# define STORE_F_STORE_GENERATE_CRL 107
# define STORE_F_STORE_GENERATE_KEY 108
# define STORE_F_STORE_GET_ARBITRARY 159
# define STORE_F_STORE_GET_CERTIFICATE 109
# define STORE_F_STORE_GET_CRL 110
# define STORE_F_STORE_GET_NUMBER 111
# define STORE_F_STORE_GET_PRIVATE_KEY 112
# define STORE_F_STORE_GET_PUBLIC_KEY 113
# define STORE_F_STORE_LIST_CERTIFICATE_END 114
# define STORE_F_STORE_LIST_CERTIFICATE_ENDP 153
# define STORE_F_STORE_LIST_CERTIFICATE_NEXT 115
# define STORE_F_STORE_LIST_CERTIFICATE_START 116
# define STORE_F_STORE_LIST_CRL_END 117
# define STORE_F_STORE_LIST_CRL_ENDP 154
# define STORE_F_STORE_LIST_CRL_NEXT 118
# define STORE_F_STORE_LIST_CRL_START 119
# define STORE_F_STORE_LIST_PRIVATE_KEY_END 120
# define STORE_F_STORE_LIST_PRIVATE_KEY_ENDP 155
# define STORE_F_STORE_LIST_PRIVATE_KEY_NEXT 121
# define STORE_F_STORE_LIST_PRIVATE_KEY_START 122
# define STORE_F_STORE_LIST_PUBLIC_KEY_END 123
# define STORE_F_STORE_LIST_PUBLIC_KEY_ENDP 156
# define STORE_F_STORE_LIST_PUBLIC_KEY_NEXT 124
# define STORE_F_STORE_LIST_PUBLIC_KEY_START 125
# define STORE_F_STORE_MODIFY_ARBITRARY 162
# define STORE_F_STORE_MODIFY_CERTIFICATE 163
# define STORE_F_STORE_MODIFY_CRL 164
# define STORE_F_STORE_MODIFY_NUMBER 165
# define STORE_F_STORE_MODIFY_PRIVATE_KEY 166
# define STORE_F_STORE_MODIFY_PUBLIC_KEY 167
# define STORE_F_STORE_NEW_ENGINE 133
# define STORE_F_STORE_NEW_METHOD 132
# define STORE_F_STORE_PARSE_ATTRS_END 151
# define STORE_F_STORE_PARSE_ATTRS_ENDP 172
# define STORE_F_STORE_PARSE_ATTRS_NEXT 152
# define STORE_F_STORE_PARSE_ATTRS_START 171
# define STORE_F_STORE_REVOKE_CERTIFICATE 129
# define STORE_F_STORE_REVOKE_PRIVATE_KEY 130
# define STORE_F_STORE_REVOKE_PUBLIC_KEY 131
# define STORE_F_STORE_STORE_ARBITRARY 157
# define STORE_F_STORE_STORE_CERTIFICATE 100
# define STORE_F_STORE_STORE_CRL 101
# define STORE_F_STORE_STORE_NUMBER 126
# define STORE_F_STORE_STORE_PRIVATE_KEY 127
# define STORE_F_STORE_STORE_PUBLIC_KEY 128
/* Reason codes. */
# define STORE_R_ALREADY_HAS_A_VALUE 127
# define STORE_R_FAILED_DELETING_ARBITRARY 132
# define STORE_R_FAILED_DELETING_CERTIFICATE 100
# define STORE_R_FAILED_DELETING_KEY 101
# define STORE_R_FAILED_DELETING_NUMBER 102
# define STORE_R_FAILED_GENERATING_CRL 103
# define STORE_R_FAILED_GENERATING_KEY 104
# define STORE_R_FAILED_GETTING_ARBITRARY 133
# define STORE_R_FAILED_GETTING_CERTIFICATE 105
# define STORE_R_FAILED_GETTING_KEY 106
# define STORE_R_FAILED_GETTING_NUMBER 107
# define STORE_R_FAILED_LISTING_CERTIFICATES 108
# define STORE_R_FAILED_LISTING_KEYS 109
# define STORE_R_FAILED_MODIFYING_ARBITRARY 138
# define STORE_R_FAILED_MODIFYING_CERTIFICATE 139
# define STORE_R_FAILED_MODIFYING_CRL 140
# define STORE_R_FAILED_MODIFYING_NUMBER 141
# define STORE_R_FAILED_MODIFYING_PRIVATE_KEY 142
# define STORE_R_FAILED_MODIFYING_PUBLIC_KEY 143
# define STORE_R_FAILED_REVOKING_CERTIFICATE 110
# define STORE_R_FAILED_REVOKING_KEY 111
# define STORE_R_FAILED_STORING_ARBITRARY 134
# define STORE_R_FAILED_STORING_CERTIFICATE 112
# define STORE_R_FAILED_STORING_KEY 113
# define STORE_R_FAILED_STORING_NUMBER 114
# define STORE_R_NOT_IMPLEMENTED 128
# define STORE_R_NO_CONTROL_FUNCTION 144
# define STORE_R_NO_DELETE_ARBITRARY_FUNCTION 135
# define STORE_R_NO_DELETE_NUMBER_FUNCTION 115
# define STORE_R_NO_DELETE_OBJECT_FUNCTION 116
# define STORE_R_NO_GENERATE_CRL_FUNCTION 117
# define STORE_R_NO_GENERATE_OBJECT_FUNCTION 118
# define STORE_R_NO_GET_OBJECT_ARBITRARY_FUNCTION 136
# define STORE_R_NO_GET_OBJECT_FUNCTION 119
# define STORE_R_NO_GET_OBJECT_NUMBER_FUNCTION 120
# define STORE_R_NO_LIST_OBJECT_ENDP_FUNCTION 131
# define STORE_R_NO_LIST_OBJECT_END_FUNCTION 121
# define STORE_R_NO_LIST_OBJECT_NEXT_FUNCTION 122
# define STORE_R_NO_LIST_OBJECT_START_FUNCTION 123
# define STORE_R_NO_MODIFY_OBJECT_FUNCTION 145
# define STORE_R_NO_REVOKE_OBJECT_FUNCTION 124
# define STORE_R_NO_STORE 129
# define STORE_R_NO_STORE_OBJECT_ARBITRARY_FUNCTION 137
# define STORE_R_NO_STORE_OBJECT_FUNCTION 125
# define STORE_R_NO_STORE_OBJECT_NUMBER_FUNCTION 126
# define STORE_R_NO_VALUE 130
#ifdef __cplusplus
}
#endif
#endif

10
util/libeay.num
View File

@@ -2872,7 +2872,7 @@ BIO_new_dgram 3330 1_1_0 EXIST::FUNCTION:
BN_get0_nist_prime_384 3331 1_1_0 EXIST::FUNCTION: BN_get0_nist_prime_384 3331 1_1_0 EXIST::FUNCTION:
ERR_set_mark 3332 1_1_0 EXIST::FUNCTION: ERR_set_mark 3332 1_1_0 EXIST::FUNCTION:
X509_STORE_CTX_set0_crls 3333 1_1_0 EXIST::FUNCTION: X509_STORE_CTX_set0_crls 3333 1_1_0 EXIST::FUNCTION:
ENGINE_set_STORE 3334 1_1_0 EXIST::FUNCTION:ENGINE ENGINE_set_STORE 3334 1_1_0 NOEXIST::FUNCTION:
ENGINE_register_ECDSA 3335 1_1_0 NOEXIST::FUNCTION: ENGINE_register_ECDSA 3335 1_1_0 NOEXIST::FUNCTION:
STORE_meth_set_list_start_fn 3336 1_1_0 NOEXIST::FUNCTION: STORE_meth_set_list_start_fn 3336 1_1_0 NOEXIST::FUNCTION:
STORE_method_set_list_start_function 3336 1_1_0 NOEXIST::FUNCTION: STORE_method_set_list_start_function 3336 1_1_0 NOEXIST::FUNCTION:
@@ -2928,7 +2928,7 @@ STORE_ATTR_INFO_set_dn 3380 1_1_0 NOEXIST::FUNCTION:
X509_policy_tree_get0_policies 3381 1_1_0 EXIST::FUNCTION: X509_policy_tree_get0_policies 3381 1_1_0 EXIST::FUNCTION:
EC_GROUP_new_curve_GF2m 3382 1_1_0 EXIST::FUNCTION:EC,EC2M EC_GROUP_new_curve_GF2m 3382 1_1_0 EXIST::FUNCTION:EC,EC2M
STORE_destroy_method 3383 1_1_0 NOEXIST::FUNCTION: STORE_destroy_method 3383 1_1_0 NOEXIST::FUNCTION:
ENGINE_unregister_STORE 3384 1_1_0 EXIST::FUNCTION:ENGINE ENGINE_unregister_STORE 3384 1_1_0 NOEXIST::FUNCTION:
EVP_PKEY_get1_EC_KEY 3385 1_1_0 EXIST::FUNCTION:EC EVP_PKEY_get1_EC_KEY 3385 1_1_0 EXIST::FUNCTION:EC
STORE_ATTR_INFO_get0_number 3386 1_1_0 NOEXIST::FUNCTION: STORE_ATTR_INFO_get0_number 3386 1_1_0 NOEXIST::FUNCTION:
ENGINE_get_default_ECDH 3387 1_1_0 NOEXIST::FUNCTION: ENGINE_get_default_ECDH 3387 1_1_0 NOEXIST::FUNCTION:
@@ -3125,7 +3125,7 @@ d2i_ECPrivateKey 3563 1_1_0 EXIST::FUNCTION:EC
ASN1_item_ndef_i2d 3564 1_1_0 EXIST::FUNCTION: ASN1_item_ndef_i2d 3564 1_1_0 EXIST::FUNCTION:
STORE_delete_private_key 3565 1_1_0 NOEXIST::FUNCTION: STORE_delete_private_key 3565 1_1_0 NOEXIST::FUNCTION:
ERR_pop_to_mark 3566 1_1_0 EXIST::FUNCTION: ERR_pop_to_mark 3566 1_1_0 EXIST::FUNCTION:
ENGINE_register_all_STORE 3567 1_1_0 EXIST::FUNCTION:ENGINE ENGINE_register_all_STORE 3567 1_1_0 NOEXIST::FUNCTION:
X509_policy_level_get0_node 3568 1_1_0 EXIST::FUNCTION: X509_policy_level_get0_node 3568 1_1_0 EXIST::FUNCTION:
i2d_PKCS7_NDEF 3569 1_1_0 EXIST::FUNCTION: i2d_PKCS7_NDEF 3569 1_1_0 EXIST::FUNCTION:
EC_GROUP_get_degree 3570 1_1_0 EXIST::FUNCTION:EC EC_GROUP_get_degree 3570 1_1_0 EXIST::FUNCTION:EC
@@ -3236,7 +3236,7 @@ SHA256_Transform 3664 1_1_0 EXIST::FUNCTION:
EC_KEY_set_enc_flags 3665 1_1_0 EXIST::FUNCTION:EC EC_KEY_set_enc_flags 3665 1_1_0 EXIST::FUNCTION:EC
ECDSA_verify 3666 1_1_0 EXIST::FUNCTION:EC ECDSA_verify 3666 1_1_0 EXIST::FUNCTION:EC
EC_POINT_point2hex 3667 1_1_0 EXIST::FUNCTION:EC EC_POINT_point2hex 3667 1_1_0 EXIST::FUNCTION:EC
ENGINE_get_STORE 3668 1_1_0 EXIST::FUNCTION:ENGINE ENGINE_get_STORE 3668 1_1_0 NOEXIST::FUNCTION:
SHA512 3669 1_1_0 EXIST:!VMSVAX:FUNCTION: SHA512 3669 1_1_0 EXIST:!VMSVAX:FUNCTION:
STORE_get_certificate 3670 1_1_0 NOEXIST::FUNCTION: STORE_get_certificate 3670 1_1_0 NOEXIST::FUNCTION:
ECDSA_do_sign_ex 3671 1_1_0 EXIST::FUNCTION:EC ECDSA_do_sign_ex 3671 1_1_0 EXIST::FUNCTION:EC
@@ -3254,7 +3254,7 @@ STORE_get_ex_data 3681 1_1_0 NOEXIST::FUNCTION:
EC_KEY_set_public_key 3682 1_1_0 EXIST::FUNCTION:EC EC_KEY_set_public_key 3682 1_1_0 EXIST::FUNCTION:EC
PEM_read_ECPKParameters 3683 1_1_0 EXIST::FUNCTION:EC PEM_read_ECPKParameters 3683 1_1_0 EXIST::FUNCTION:EC
X509_CERT_PAIR_new 3684 1_1_0 NOEXIST::FUNCTION: X509_CERT_PAIR_new 3684 1_1_0 NOEXIST::FUNCTION:
ENGINE_register_STORE 3685 1_1_0 EXIST::FUNCTION:ENGINE ENGINE_register_STORE 3685 1_1_0 NOEXIST::FUNCTION:
RSA_generate_key_ex 3686 1_1_0 EXIST::FUNCTION:RSA RSA_generate_key_ex 3686 1_1_0 EXIST::FUNCTION:RSA
DSA_generate_parameters_ex 3687 1_1_0 EXIST::FUNCTION:DSA DSA_generate_parameters_ex 3687 1_1_0 EXIST::FUNCTION:DSA
ECParameters_print_fp 3688 1_1_0 EXIST::FUNCTION:EC,STDIO ECParameters_print_fp 3688 1_1_0 EXIST::FUNCTION:EC,STDIO